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

Python Coding Challange - Question With Answer(01090425)

 

This is a recursive function. It calculates the sum of all numbers from 1 to num.

---

 How does recursion work here?

Let's see how sum(5) gets evaluated:

1. sum(5) → 5 + sum(4)

2. sum(4) → 4 + sum(3)

3. sum(3) → 3 + sum(2)

4. sum(2) → 2 + sum(1)

5. sum(1) → returns 1 (base case)

Now plug values back in:

• sum(2) = 2 + 1 = 3

• sum(3) = 3 + 3 = 6

• sum(4) = 4 + 6 = 10

• sum(5) = 5 + 10 = 15

---

✅ Output:

15

---

In Simple Words:

This function adds:

5 + 4 + 3 + 2 + 1 = 15


Application of Python in Chemical Engineering
https://pythonclcoding.gumroad.com/l/dlrub

Read More

Python Coding Challange - Question With Answer(01080425)

 

Explanation

try block:

• Python runs the code inside the try block first.

• print("Hello") executes normally, so it prints:

  Hello

• Then, raise Exception is used to manually raise an exception. This immediately stops the normal flow and jumps to the except block.

except block:

• Since an exception occurred, the code inside the except block runs.

• It prints:

  
  Python

✅ Final Output:

Hello
Python

This shows how Python handles exceptions:

1. It tries the code.

2. If something goes wrong (an exception is raised), it jumps to except and handles it.

100 Python Programs for Beginner with explanation 

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

Read More