Causal AI

 Causal AI: Understanding Cause-and-Effect in Machine Learning

Traditional machine learning models are excellent at identifying correlations but often fail to distinguish between causation and correlation. This limitation affects decision-making in critical areas such as healthcare, finance, and policy development. Causal AI, an emerging field in artificial intelligence, aims to bridge this gap by integrating causality into machine learning models, allowing them to reason about cause-and-effect relationships rather than just statistical patterns.

In this blog, we will explore the fundamentals of causal AI, its importance, techniques, applications, and future directions.

Why Causal AI Matters

The ability to understand and model causality is crucial for AI systems to make reliable and robust decisions. Some key reasons why causal AI is important include:

Better Decision-Making: Unlike correlation-based AI, causal AI helps predict the effects of interventions rather than just observing associations.

Generalizability: Causal models are more adaptable to new environments and can make accurate predictions even when the data distribution changes.

Fairness and Bias Mitigation: Causal AI helps identify and correct biases in machine learning models by understanding the root causes of disparities.

Improved Interpretability: By modeling cause-and-effect relationships, AI decisions become more transparent and explainable.

Key Concepts in Causal AI

Causal AI relies on foundational concepts from causality research, which include:

Causal Graphs

Causal relationships are often represented using Directed Acyclic Graphs (DAGs). These graphs visually depict dependencies between variables and help distinguish between direct and indirect effects.

Interventions

An intervention involves changing a variable in a causal model to observe its effect on the outcome. This process is crucial for making policy decisions and recommendations.

Counterfactual Reasoning

Counterfactual analysis asks "what if" questions—what would have happened if a specific event had been different? This approach is widely used in fairness assessments and impact analysis.

Confounders and Bias

Confounders are variables that affect both the cause and the effect, potentially leading to spurious correlations. Identifying and adjusting for confounders is critical for causal inference.

Techniques in Causal AI

There are several approaches to implementing causal AI, including:

Causal Discovery

Causal discovery algorithms analyze observational data to infer causal structures. These methods include:

Constraint-based methods: Identify causal relationships based on statistical dependencies.

Score-based methods: Use optimization techniques to find the best-fitting causal graph.

Functional causal models: Assume specific mathematical functions for causal mechanisms.

Causal Inference

Causal inference techniques estimate the effect of an intervention using methods such as:

Propensity Score Matching: Matching similar individuals from different groups to estimate causal effects.

Instrumental Variables: Using external variables that influence the cause but not the outcome directly to estimate causal relationships.

Difference-in-Differences: Comparing changes over time between treatment and control groups to measure the causal effect.

Causal Reinforcement Learning

Causal reinforcement learning integrates causal reasoning into reinforcement learning models, enabling AI systems to make better sequential decisions based on cause-and-effect relationships.

Applications of Causal AI

Causal AI is transforming various industries by enabling more informed and reliable decision-making. Some key applications include:

Healthcare

Identifying the true causes of diseases rather than just risk factors.

Evaluating the effectiveness of treatments and medical interventions.

Reducing biases in AI-driven diagnostics and recommendations.

Finance

Improving credit risk assessment by distinguishing between correlation and causation.

Detecting fraudulent transactions by analyzing causal patterns.

Enhancing investment strategies by understanding causal drivers of market movements.

Marketing and Business Strategy

Understanding the causal impact of advertising campaigns on sales.

Optimizing pricing strategies by analyzing consumer behavior causally.

Identifying factors that truly influence customer retention.

Social Sciences and Policy-Making

Evaluating the impact of policy interventions on economic and social outcomes.

Measuring the effectiveness of education programs.

Reducing bias in hiring and workplace decisions.

Challenges in Causal AI

Despite its potential, causal AI faces several challenges:

Data Limitations: Many datasets lack explicit causal structures, making causal discovery difficult.

Computational Complexity: Inferring causal relationships requires significant computational resources.

Ethical and Interpretability Concerns: Understanding causality in complex systems requires careful interpretation to avoid incorrect conclusions.

Integration with Traditional Machine Learning: Many existing AI models are designed for correlation-based learning, requiring new frameworks to incorporate causality.

Future Directions in Causal AI

Causal AI is rapidly evolving, with ongoing research in:

Hybrid Models: Combining causal inference with deep learning to improve explainability and robustness.

Automated Causal Discovery: Developing algorithms that can learn causal structures from large datasets with minimal human intervention.

Causal AI for Autonomous Systems: Improving decision-making in robotics, self-driving cars, and AI assistants through causal reasoning.

Regulatory and Ethical Standards: Establishing guidelines to ensure responsible use of causal AI in sensitive applications.

Kindle : Causal AI

Hard Copy : Causal AI

Conclusion

Causal AI represents the next frontier in artificial intelligence, enabling machines to move beyond correlation-based reasoning and understand true cause-and-effect relationships. By integrating causal inference techniques, AI systems can become more reliable, fair, and interpretable, ultimately leading to better decision-making across industries.

As causal AI continues to develop, its adoption will play a crucial role in building more trustworthy and effective AI applications. Organizations that embrace causal AI today will gain a competitive advantage by making more informed, evidence-based decisions.

Read More

DMT Grid Pattern using Python

import matplotlib.pyplot as plt

import numpy as np

from mpl_toolkits.mplot3d import Axes3D

fig=plt.figure(figsize=(6,6))

ax=fig.add_subplot(111,projection='3d')

x=np.linspace(-6*np.pi,6*np.pi,300)

y=np.linspace(-6*np.pi,6*np.pi,300)

x,y=np.meshgrid(x,y)

z=np.sin(x)*np.cos(y)+np.sin(y/2)*np.cos(x/2)

surf=ax.plot_surface(x,y,z,cmap='plasma',edgecolor='none',alpha=0.95)

ax.set_title('DMT Grid Pattern',fontsize=18,color='violet')

ax.set_xlabel('X Axis',color='white')

ax.set_ylabel('Y Axis',color='white')

ax.set_zlabel('Z Axis',color='white')

ax.grid(False)

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

fig.colorbar(surf,shrink=0.5,aspect=5)

ax.xaxis.pane.fill=False

ax.yaxis.pane.fill=False

ax.zaxis.pane.fill=False

plt.tight_layout()

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Import Required Libraries

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

numpy: For efficient math operations and array handling.

matplotlib.pyplot: Used for plotting graphs and figures.

Axes3D: Enables 3D plotting capabilities in Matplotlib.

 2. Create a 3D Figure

fig = plt.figure(figsize=(10, 7))

ax = fig.add_subplot(111, projection='3d')

fig = plt.figure(...): Creates a blank figure with size 10x7 inches.

 add_subplot(111, projection='3d'): Adds one subplot (1 row, 1 column, 1 plot) with 3D capabilities.

 3. Generate the X and Y Coordinate Grid

x = np.linspace(-6 * np.pi, 6 * np.pi, 300)

y = np.linspace(-6 * np.pi, 6 * np.pi, 300)

x, y = np.meshgrid(x, y)

np.linspace(...): Creates evenly spaced values from -6π to 6π.

meshgrid: Turns 1D arrays into 2D grid coordinates for surface plotting.

 4. Define the Z-Values (Height of the Surface)

z = np.sin(x) * np.cos(y) + np.sin(y/2) * np.cos(x/2)

This creates a complex wave interference pattern by combining sine and cosine waves.

It gives the surface a psychedelic, rippling effect—like a neural or energy grid.

 5. Plot the 3D Surface

surf = ax.plot_surface(x, y, z, cmap='plasma', edgecolor='none', alpha=0.95)

plot_surface: Draws the 3D surface based on x, y, and z.

cmap='plasma': Sets the color theme to a glowing, trippy gradient.

edgecolor='none': Removes mesh lines for a smooth appearance.

alpha=0.95: Sets surface transparency (slightly see-through).

 6. Set Titles and Axis Labels

ax.set_title('DMTGrid', fontsize=18, color='violet')

ax.set_xlabel('X Axis', color='white')

ax.set_ylabel('Y Axis', color='white')

ax.set_zlabel('Consciousness', color='white')

Gives the plot a title and axis labels.

Label text color is white for contrast against the dark background.

"Consciousness" instead of "Z Axis" adds a fun, mystical touch.

 7. Style the Plot for Psychedelic Effect

ax.grid(False)

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

Turns off gridlines for a cleaner visual.

Sets the background color to black — enhances the plasma colors.

 8. Add a Color Bar (Legend for the Z Values)

fig.colorbar(surf, shrink=0.5, aspect=5)

Adds a side bar that shows the value range of the surface colors.

shrink and aspect adjust its size and shape.

 9. Hide Pane Backgrounds

ax.xaxis.pane.fill = False

ax.yaxis.pane.fill = False

ax.zaxis.pane.fill = False

Removes the gray panes behind the axes to keep the focus on the colorful surface.

 10. Final Layout & Show Plot

plt.tight_layout()

plt.show()

tight_layout(): Automatically adjusts spacing so labels and titles don't overlap.

 show(): Displays the final 3D plot.

 

Read More

Plasma Whirl 3D Pattern using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

theta = np.linspace(0, 15 * np.pi, 1000)  

z = np.linspace(-3, 3, 1000)              

r = np.abs(np.sin(5 * z)) + 0.5

x = r * np.cos(theta)

y = r * np.sin(theta)

fig = plt.figure(figsize=(6, 6))

ax = fig.add_subplot(111, projection='3d')

ax.plot(x, y, z, color='magenta', linewidth=2)

ax.scatter(x, y, z, c=np.abs(z), cmap='plasma', s=2)

ax.set_title('Plasma Whirl 3D Pattern', fontsize=18, color='yellow')

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

ax.grid(False)

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Importing Required Libraries

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

numpy → For mathematical operations and creating data points.

 matplotlib.pyplot → For plotting the graph.

 Axes3D → To enable 3D plotting.

 2. Creating Data for the Spiral Structure

a) Angle Values for Rotation

theta = np.linspace(0, 15 * np.pi, 1000)

Creates values from 0 to 15π (about 7.5 full rotations).

 Controls the circular rotation of the plot.

 b) Z-Axis Values for Height

z = np.linspace(-3, 3, 1000)

Creates points from -3 to 3.

 Controls the vertical spread of the spiral.

 c) Radius for Distance from Center

r = np.abs(np.sin(5 * z)) + 0.5

Radius is dynamic, based on a sine wave of z.

 5 * z → Controls the frequency of waves.

 np.abs() → Ensures radius is always positive.

 +0.5 → Minimum radius to avoid collapse to center.

 This makes the radius oscillate — creating a whirl or spiral wave effect.

 3. Converting to Cartesian Coordinates

x = r * np.cos(theta)

y = r * np.sin(theta)

Converts polar coordinates (r, θ) to Cartesian (x, y) for 3D plotting.

 4. Creating the Plotting Environment

fig = plt.figure(figsize=(10, 7))

ax = fig.add_subplot(111, projection='3d')

Sets the plot size.

 Adds a 3D plot axis.

 5. Plotting the Spiral Line (Main Structure)

ax.plot(x, y, z, color='magenta', linewidth=2)

Draws the spiral line.

 Color → magenta.

 Line thickness → 2.

 6. Adding Scatter Dots (Plasma Energy Effect)

ax.scatter(x, y, z, c=np.abs(z), cmap='plasma', s=2)

Adds glowing dots along the spiral.

 c=np.abs(z) → Color of dots depends on z height.

 cmap='plasma' → Plasma color gradient (yellow-pink-purple).

 s=2 → Size of the dots.

 This gives it the "energy plasma" vibe.

 7. Styling the Plot

ax.set_title('Plasma Whirl 3D Pattern', fontsize=18, color='yellow')

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

ax.grid(False)

Title in yellow color.

 Black background for clean and futuristic look.

 No grid lines for simplicity.

 8. Removing Axis Ticks

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

Hides x, y, z axis ticks for a pure design look.

 9. Display the Final 3D Plot

plt.show()

Shows the final plot.

Read More

Python Coding Challange - Question With Answer(01110425)

 

Understanding the code:

1. range(0, 6, 4)

• This means: Start from 0, go up to (but not including) 6, and increment by 4.

• So, it generates the numbers: 0 and 4.

2. Loop values:

The loop runs with:

i = 0 

i = 4

3. Inside the loop:

• When i == 2: the continue statement would skip the rest of the loop and go to the next iteration.

• But in this case, i is never 2, so continue is never executed.

4. print(i):

• Since i is never 2, both 0 and 4 will be printed.

✅ Final Output:

0
4


PYTHON INTERVIEW QUESTIONS AND ANSWERS
https://pythonclcoding.gumroad.com/l/ylxbs

Read More

Python Coding challenge - Day 434| What is the output of the following Python Code?

Code Explanation:

class A:

This defines a class named A. In Python, classes are blueprints for creating objects.

    def __init__(self): self.x = 1

This defines the constructor method for class A. It is automatically called when an object of class A is created.

self.x = 1 sets an instance variable x to 1 for any object of class A.

So, when you do A(), it creates an object with x = 1.

class B(A):

This defines another class B, which inherits from class A. That means B gets all the methods and properties of A unless they are overridden.

    def __init__(self): super().__init__(); self.x = 2

This is the constructor for class B.

super().__init__() calls the constructor of the parent class (A) — so it sets self.x = 1.

Immediately after that, self.x = 2 overrides the earlier value.

So, any object of class B will have x = 2, because self.x = 2 comes after the parent’s initialization.

print(A().x, B().x)

Now this prints the value of x for instances of both classes:

A().x creates an object of class A, which sets x = 1, and then prints that value.

B().x creates an object of class B, which first sets x = 1 (via super().__init__()), then changes it to 2, and prints that.

Final Output:

1 2

Read More

Ocean Ripples Pattern using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

fig=plt.figure(figsize=(6,7))

ax=fig.add_subplot(111,projection='3d')

x=np.linspace(-10,10,200)

y=np.linspace(-10,10,200)

x,y=np.meshgrid(x,y)

r=np.sqrt(x**2+y**2)

z=np.sin(r)/r

z[r==0]=1

surf=ax.plot_surface(x,y,z,cmap='ocean',edgecolor='none')

ax.set_title('OceanRipple Pattern using Python',fontsize=16)

ax.set_xlabel('X Axis')

ax.set_xlabel('Y Axis')

ax.set_zlabel('Wave Height')

fig.colorbar(surf,shrink=0.5,aspect=5)

plt.tight_layout()

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Importing Libraries

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

numpy is used for numerical operations, especially arrays and math functions.

matplotlib.pyplot is used for plotting graphs.

mpl_toolkits.mplot3d.Axes3D enables 3D plotting within matplotlib.

 

2. Creating the 3D Figure and Axes

fig = plt.figure(figsize=(10, 7))

ax = fig.add_subplot(111, projection='3d')

fig = plt.figure(figsize=(10, 7)): Initializes a new figure with size 10x7 inches.

add_subplot(111, projection='3d'): Adds a 3D subplot (1 row, 1 column, 1 plot) to the figure.

 

3. Generating a Grid for X and Y Coordinates

x = np.linspace(-10, 10, 200)

y = np.linspace(-10, 10, 200)

x, y = np.meshgrid(x, y)

np.linspace(-10, 10, 200): Creates 200 evenly spaced values between -10 and 10.

np.meshgrid(x, y): Converts the 1D arrays into 2D coordinate grids for X and Y, used for surface plotting.

 

4. Defining the Ocean Ripple Pattern (Z Values)

r = np.sqrt(x**2 + y**2)

z = np.sin(r) / r

z[r == 0] = 1

r = np.sqrt(x**2 + y**2): Computes the radial distance from the origin (like a circular ripple).

z = np.sin(r) / r: Defines a ripple pattern based on the sinc function, which gives a wave-like structure.

z[r == 0] = 1: Handles the case where r = 0 to avoid division by zero (since sin(0)/0 is undefined but limit = 1).

 

5. Plotting the Surface

surf = ax.plot_surface(x, y, z, cmap='ocean', edgecolor='none')

plot_surface: Plots a 3D surface based on X, Y, Z values.

cmap='ocean': Applies a blue-ish colormap to simulate water.

edgecolor='none': Removes gridlines for a smooth surface look.

 

6. Adding Title and Axis Labels

ax.set_title('OceanRipples pattern using python', fontsize=16)

ax.set_xlabel('X Axis')

ax.set_ylabel('Y Axis')

ax.set_zlabel('Wave Height')

Sets the main title and axis labels to describe the 3D plot.

 

7. Adding a Color Bar

fig.colorbar(surf, shrink=0.5, aspect=5)

Adds a color scale to the side of the plot to show what values each color represents.

shrink and aspect control its size and proportions.

 

8. Final Touch & Display

plt.tight_layout()

plt.show()

tight_layout(): Adjusts layout to avoid overlap.

show(): Displays the final plot.

 

Read More

Python Quiz on Numpy Data Types

 

Read More

Python Coding challenge - Day 431| What is the output of the following Python Code?

Code Explanation:

class Slotted:

This defines a new class called Slotted.

At this point, it’s a regular Python class — no special behavior like __slots__ has been added.

    def __init__(self):

This defines the constructor method (__init__) for the class.

It’s automatically called when you create a new object from this class.

The self parameter refers to the instance being created.

        self.a = 10

Inside the constructor, a new instance attribute a is created and set to 10.

This means every object of this class will have an attribute a when it's initialized.

s = Slotted()

You create an instance of the class Slotted and store it in the variable s.

This automatically calls the __init__ method, so s.a is now 10.

s.b = 20

Here, you're dynamically adding a new attribute b to the instance s, and setting it to 20.

Because Slotted is a normal class (no __slots__), Python allows this dynamic addition.

print(s.a, s.b)

This prints the values of attributes a and b from the instance s.

Since s.a = 10 and s.b = 20, it prints:

10 20

Read More

Quantum Vortex 3D Pattern using Python

 

import matplotlib.pyplot as plt

import numpy as np

from mpl_toolkits.mplot3d import Axes3D

theta=np.linspace(0,20*np.pi,1000)

z=np.linspace(-2,2,1000)

r=z**2+1

x=r*np.sin(theta)

y=r*np.cos(theta)

fig=plt.figure(figsize=(6,8))

ax=fig.add_subplot(111,projection='3d')

ax.plot(x,y,z,color='cyan',linewidth=2)

ax.set_title('Quantum Vortex Pattern',fontsize=18,color='purple')

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

ax.grid(False)

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Import Required Libraries

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

Purpose:

numpy → For mathematical calculations like arrays, linspace, trigonometric functions.

 matplotlib.pyplot → For plotting the graph.

 mpl_toolkits.mplot3d → To enable 3D plotting using Matplotlib.

 2. Define the Vortex Parameters

theta = np.linspace(0, 20 * np.pi, 1000) 

z = np.linspace(-2, 2, 1000)            

r = z**2 + 1

Explanation:

theta → Controls the angle of the spiral (0 to 20π means multiple spiral loops).

 z → Controls the vertical height of the plot (-2 to 2 units).

 r → Radius of the spiral at each z height.

(As z increases or decreases, radius changes — gives a vortex or tornado effect).

 3. Generate X, Y, Z Coordinates

x = r * np.sin(theta)

y = r * np.cos(theta)

Purpose:

Parametric equations of a spiral in 3D:

 x depends on sin(theta)

 y depends on cos(theta)

 z is already defined.

 This gives the 3D twisted spiral shape.

 4. Create 3D Plot Figure

fig = plt.figure(figsize=(10, 7))

ax = fig.add_subplot(111, projection='3d')

Explanation:

Create a new figure of size 10x7.

 Add a 3D subplot to draw 3D patterns.

 5. Plot the Quantum Vortex

ax.plot(x, y, z, color='cyan', linewidth=2)

Purpose:

Draw the 3D vortex spiral using the x, y, z points.

 Color: Cyan

 Line width: 2

 6. Styling the Plot

ax.set_title('Quantum Vortex 3D Pattern', fontsize=18, color='purple')

ax.set_facecolor('black')

fig.patch.set_facecolor('black')

ax.grid(False)

Purpose:

Add a custom title to the plot.

 Set background color of the plot & figure to black for a "space" or "quantum" look.

 Disable grid lines for a clean visual.

 7. Remove Axis Ticks

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

Purpose:

Remove the axis ticks (numbers) for an aesthetic and clean design.

 8. Show the Final Plot

plt.show()

Purpose:

Display the final 3D vortex pattern on the screen.

Read More

3D Origami Pattern using Python

 

import matplotlib.pyplot as plt

import numpy as np

x=np.linspace(0,10,100)

y=np.linspace(0,10,100)

X,Y=np.meshgrid(x,y)

Z=np.sin(X)*np.cos(Y)

fig=plt.figure(figsize=(8,6))

ax=fig.add_subplot(111,projection='3d')

ax.plot_surface(X,Y,Z,cmap='plasma',edgecolor='k',linewidth=0.3)

ax.set_title("3D Folded Origami Pattern ")

plt.show()

#source code --> clcoding.com

Code Explanation:

1. Importing Libraries

import numpy as np

import matplotlib.pyplot as plt

numpy (as np): Used for numerical operations and array handling.

 matplotlib.pyplot (as plt): Used for plotting and displaying graphs.

 2. Creating the Grid

x = np.linspace(0, 10, 100)

y = np.linspace(0, 10, 100)

X, Y = np.meshgrid(x, y)

np.linspace(0, 10, 100): Creates 100 values linearly spaced from 0 to 10 for both x and y axes.

 np.meshgrid(x, y): Converts the 1D x and y arrays into 2D coordinate grids (X, Y).

 This is needed to plot a surface where each (x, y) pair will have a height Z.

 3. Defining the Height (Z-values)

Z = np.sin(X) * np.cos(Y)

This creates a wave-like height map:

 sin(X) gives you waves along the x-direction.

 cos(Y) gives waves in the y-direction.

 Multiplying them results in a folded checkerboard-like wave pattern — similar to a Miura fold in origami, where some parts are folded up and others down.

 It visually mimics the alternating mountain-valley folds.

 4. Creating the Plot

fig = plt.figure(figsize=(10, 6))

ax = fig.add_subplot(111, projection='3d')

Creates a figure (fig) with a specific size (10 by 6 inches).

 Adds a 3D subplot (ax) to the figure using projection='3d'.

 5. Plotting the 3D Surface

ax.plot_surface(X, Y, Z, cmap='plasma', edgecolor='k', linewidth=0.3)

plot_surface: Draws a 3D surface plot.

 X, Y, Z: Coordinates of the surface.

 cmap='plasma': Applies a colorful colormap for aesthetics (from yellow to purple).

 edgecolor='k': Edges of the grid are black, which enhances the “folded paper” look.

 linewidth=0.3: Makes the grid edges thin for sharp creases, like origami folds.

 6. Final Touches

ax.set_title("3D Folded Origami Pattern (Miura-inspired)")

plt.show()

Adds a title to the plot.

 plt.show() renders and displays the 3D plot window.

Read More

Python Coding Challange - Question With Answer(01100425)

 

Line-by-line explanation:

---

prod = getProd(4,5,2)

• This line is trying to call a function named getProd with arguments 4, 5, and 2.

• However, at this point in the code, getProd is not yet defined, so Python will throw an error.

• Error: NameError: name 'getProd' is not defined

---

print(prod)

• This line will not run because the previous line causes an error.

• If the function was properly defined before being called, this line would print the result of 4 * 5 * 2 = 40.

---

def getProd(a, b, c):

• This defines a function named getProd that takes 3 arguments: a, b, and c.

---

return a * b * c

• This returns the product of the three numbers passed to the function.

---

Summary:

• The code tries to use the function before it's defined.

• Python reads code from top to bottom, so it doesn't know what getProd is when it's first called.

• To fix it, you should define the function before calling it.

Application of Python Libraries for Civil Engineering

https://pythonclcoding.gumroad.com/l/feegvl

Read More

Python Coding challenge - Day 433| What is the output of the following Python Code?

Code Explanation:

def gen():

This defines a generator function named gen.

Unlike a regular function that returns values once and exits, this function will use yield, making it a generator.

When called, it returns a generator object that can produce a sequence of values over time.

    i = 0

Inside the function, you initialize a variable i to 0.

This will be the starting value of your counter.

    while True:

This creates an infinite loop.

It means the code inside this block will keep repeating forever (unless you break it manually or stop calling next()).

The generator is designed to produce values endlessly.

        yield i

This is the core of a generator.

yield means: “pause here and return the value of i to the caller.”

After yielding, the generator’s state is saved — including the current value of i, and where it was in the code.

        i += 1

After yielding i, we increment i by 1.

So next time the generator resumes, it will yield the next number.

This makes the generator produce 0, 1, 2, 3, ... one at a time.

g = gen()

Now you call the generator function, which returns a generator object.

The function body doesn't run yet — it just prepares the generator to be used.

Variable g now holds that generator object.

print(next(g), next(g), next(g))

You are calling next(g) three times.

Each call resumes the generator, runs until the next yield, and returns the value:

next(g) → i = 0, yields 0, then i becomes 1

next(g) → resumes at i = 1, yields 1, then i becomes 2

next(g) → resumes at i = 2, yields 2, then i becomes 3

These three values are printed on one line, separated by spaces.

Final Output:

0 1 2

 

Read More

Python Coding challenge - Day 432| What is the output of the following Python Code?

 

import asyncio

This imports Python's asynchronous I/O library.

The asyncio module provides tools for writing concurrent code using async/await syntax.

You’ll use it to run asynchronous functions (coroutines).

async def a(): return 1

This defines an asynchronous function (coroutine) named a.

The async def syntax marks this as a coroutine.

When called, it returns a coroutine object, not the value 1 immediately.

Inside, it just returns 1.

async def b(): return await a()

This defines another coroutine b.

Inside it, await a() is used, meaning:

It calls the coroutine a() and waits for it to finish.

It pauses execution until a() completes and returns 1.

Then b() returns that result.

async def c(): return await b()

This is a third coroutine c.

It does the same thing: awaits b(), which awaits a(), which returns 1.

So this creates a simple chain of async calls: c() → b() → a() → 1.

print(asyncio.run(c()))

asyncio.run() is used to run the coroutine c() from synchronous code (like a script).

It:

Starts an event loop.

Runs c() until it completes.

Returns the final result.

So here, it executes c() → b() → a() → returns 1.

That 1 is printed.

Final Output:

1

Read More