Heat Wave Mirage Pattern using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(-5, 5, 100)

y = np.linspace(-5, 5, 100)

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

heat_source_x, heat_source_y = 0, 0 

sigma = 1.5  

Z = np.exp(-((X - heat_source_x)**2 + (Y - heat_source_y)**2) / (2 * sigma**2))

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

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

ax.plot_surface(X,Y,Z,cmap="hot",edgecolor="none")

ax.set_xlabel("X Axis")

ax.set_ylabel("Y Axis")

ax.set_zlabel("Heat Intensity")

ax.set_title("Heat Wave Mirage pattern")

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

plt.show()

#source code --> clcoding.com 

Code Explanation:

Import Required Libraries

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

NumPy (np): Used for creating numerical arrays and mesh grids.

 Matplotlib (plt): Used for creating the 3D surface plot.

 mpl_toolkits.mplot3d: Enables 3D plotting in Matplotlib.

 

Create a Grid for Heat Simulation

x = np.linspace(-5, 5, 100)  # X-axis range (-5 to 5) with 100 points

y = np.linspace(-5, 5, 100)  # Y-axis range (-5 to 5) with 100 points

X, Y = np.meshgrid(x, y)     # Create a 2D mesh grid from x and y values

np.linspace(-5, 5, 100): Creates 100 evenly spaced points from -5 to 5 in both x and y directions.

 np.meshgrid(x, y): Creates a grid of (X, Y) points where each (x, y) pair forms a coordinate in a 2D plane.

 

Define Heat Source and Heat Diffusion Formula

heat_source_x, heat_source_y = 0, 0  # Heat source at (0,0)

sigma = 1.5  # Controls the spread of heat

Z = np.exp(-((X - heat_source_x)**2 + (Y - heat_source_y)**2) / (2 * sigma**2))

(heat_source_x, heat_source_y): Defines the center of the heat source.

sigma: Controls how fast heat dissipates (higher value = wider spread).

This equation models how heat intensity decreases as we move away from the heat source.

High intensity at (0,0) and gradual fading outward.

 

Create a 3D Plot

fig = plt.figure(figsize=(10, 7))  # Create figure with size 10x7

ax = fig.add_subplot(111, projection="3d")  # Add 3D subplot

fig = plt.figure(figsize=(10, 7)): Initializes a Matplotlib figure.

 ax = fig.add_subplot(111, projection="3d"): Creates a 3D plot area (ax).

 

Plot Heat Distribution as a 3D Surface

ax.plot_surface(X, Y, Z, cmap="hot", edgecolor="none")

plot_surface(X, Y, Z): Creates a 3D surface plot.

cmap="hot": Uses the "hot" color map, where:

Red & yellow = High heat

Black & dark orange = Low heat

edgecolor="none": Removes edges to make the plot smooth.

 

Customize Labels and Titles

ax.set_xlabel("X Axis")

ax.set_ylabel("Y Axis")

ax.set_zlabel("Heat Intensity")

ax.set_title("Heatwave Mirage - 3D Heat Diffusion Simulation")

Adds labels for X, Y, and Z axes.

Sets the plot title.

 Remove Grid Ticks for a Clean Look

ax.set_xticks([])

ax.set_yticks([])

ax.set_zticks([])

Hides grid ticks for a smoother visualization.

 

Display the Final Heatwave Mirage

plt.show()

Displays the 3D plot.

Read More

Stellar Spectrum Mesh Grid Pattern using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

theta = np.linspace(0, 2 * np.pi, 100)

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

theta, z = np.meshgrid(theta, z)

r = z**2 + 1

x = r * np.sin(theta)

y = r * np.cos(theta)

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

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

colors = np.sin(z) * np.cos(theta)

surf = ax.plot_surface(x,y,z,facecolors=plt.cm.viridis((colors - colors.min()) /

(colors.max() - colors.min())), rstride=1, cstride=1, antialiased=True)

ax.set_xlabel('X Axis')

ax.set_ylabel('Y Axis')

ax.set_zlabel('Z Axis')

ax.set_title('Stellar Spectrum Mesh: 3D Waveform using Matplotlib')

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

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 (np): Used for numerical operations, creating arrays, and mathematical functions.

 matplotlib.pyplot (plt): Used for plotting 2D and 3D visualizations.

 mpl_toolkits.mplot3d: Provides tools for 3D plotting using Matplotlib.

 Axes3D: Enables 3D plotting capabilities.

 

2. Create Data for the Mesh Grid

a) Generate Angles (Theta) and Z Values

theta = np.linspace(0, 2 * np.pi, 100)

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

np.linspace(start, stop, num):

 Generates 100 evenly spaced values.

 theta ranges from 0 to 2π, representing a full circular rotation in radians.

 z ranges from -2 to 2, representing the vertical axis.

 

b) Create a Mesh Grid

theta, z = np.meshgrid(theta, z)

np.meshgrid():

 Creates a 2D grid of coordinates from theta and z.

 Every combination of theta and z is represented in a matrix form.

 Used for surface plotting.

 

3. Calculate Radius and Coordinates

a) Calculate Radius (r)

r = z**2 + 1

r=z 2+1

 The radius expands as z moves away from zero.

This results in a wavy, expanding, circular mesh.

 

b) Compute X and Y Coordinates

x = r * np.sin(theta)

y = r * np.cos(theta)

X and Y Coordinates:

x = r × sin(θ) and y = r × cos(θ) are parametric equations for a circular shape.

The radius r scales the size of the circle, and theta controls the angular position.

The expanding radius forms a spiral effect.

 

4. Plot the 3D Surface

a) Initialize the Figure and Axis

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

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

fig = plt.figure(figsize=(12, 8)):

Creates a figure of size 12x8 inches.

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

Creates a 3D axis using projection='3d'.

111 indicates 1 row, 1 column, and first subplot.

 

5. Apply Colors Using a Spectrum

a)Generate Color Values

colors = np.sin(z) * np.cos(theta)

This applies a color effect using a mathematical combination of sine and cosine.

 np.sin(z) creates a wave pattern along the Z-axis.

 np.cos(theta) creates variations based on angular position.

 Multiplying them results in a dynamic, swirling color effect.

 b) Plot the Surface with Colors

surf = ax.plot_surface(

    x, y, z,

    facecolors=plt.cm.viridis((colors - colors.min()) / (colors.max() - colors.min())),

    rstride=1,

    cstride=1,

    antialiased=True

)

ax.plot_surface():

 Plots a 3D surface using the computed X, Y, and Z coordinates.

 facecolors applies a gradient from the Viridis colormap (plt.cm.viridis).

 This ensures color values are scaled between 0 and 1.

 rstride=1 and cstride=1 determine the resolution of the mesh by setting row and column strides.

 antialiased=True smoothens the surface edges.

 

6. Customize the Plot

a) Add Axis Labels and Title

ax.set_xlabel('X Axis')

ax.set_ylabel('Y Axis')

ax.set_zlabel('Z Axis')

ax.set_title('Stellar Spectrum Mesh: 3D Waveform using Matplotlib')

Labels the axes for clarity.

 The title provides a meaningful description of the plot.

 b) Add a Colorbar

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

plt.colorbar():

 Adds a colorbar to represent the color mapping on the surface.

 shrink=0.5: Adjusts the colorbar size to 50% of its original size.

 aspect=5: Adjusts the aspect ratio of the colorbar for better readability.

 

7. Display the Plot

plt.show()

This function renders and displays the plot.

 

Read More

Python Coding Challange - Question With Answer(01050425)

 

 Step-by-step Explanation:

1. playerScores = dict()

   • Creates an empty dictionary named playerScores.

2. Adding player scores:

   playerScores["MS Dhoni"] = 125
   playerScores["Akshar"] = 133

   • Adds 2 entries to the dictionary:

     
     {
      "MS Dhoni": 125,
      "Akshar": 133

   • }

3. Deleting one entry:

   del playerScores["MS Dhoni"]

   • Removes the key "MS Dhoni" from the dictionary.

   • Now it becomes:

     
     {
       "Akshar": 133

   • }

4. Printing values:

   for key, value in playerScores.items():
       print(value)

   • Loops through each key-value pair in the dictionary.

   • Since only "Akshar" is left, it prints:

   Output:

   133

---

Let me know if you'd like a version that prints both the name and score like:

print(f"{key}: {value}")

Check Now 400 Days Python Coding Challenges with Explanation
https://pythonclcoding.gumroad.com/l/sputu

Read More

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

 

Line-by-Line Explanation

class Descriptor:

This defines a custom descriptor class. In Python, a descriptor is any object that implements at least one of the following methods:

__get__()

__set__()

__delete__()

Descriptors are typically used for custom attribute access logic.

def __get__(self, obj, objtype=None):

This defines the getter behavior for the descriptor.

self: the descriptor instance

obj: the instance of the class where the descriptor is accessed (e.g., MyClass() object)

objtype: the class type (usually not used unless needed)

return 42

Whenever the attribute is accessed, this method returns the constant 42.

 class MyClass:

A normal class where you're going to use the descriptor.

attr = Descriptor()

Here:

attr becomes a descriptor-managed attribute.

It's now an instance of Descriptor, so any access to MyClass().attr will trigger the __get__() method from Descriptor.

print(MyClass().attr)

Let’s unpack this:

MyClass() creates an instance of MyClass.

.attr is accessed on that instance.

Since attr is a descriptor, Python automatically calls:

Descriptor.__get__(self=attr, obj=MyClass(), objtype=MyClass)

And we know __get__() always returns 42.

Output:

42

Read More

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

 

import re

This imports Python's re module, which handles regular expressions.

Regular expressions (regex) let you search, match, and extract patterns from strings.

m = re.search(r"<.*>", "<a><b>")

This is the key line. Let's break it down:

re.search(pattern, string)

Searches the string for the first match of the given regex pattern.

If it finds a match, it returns a Match object (stored in m).

If no match is found, it returns None.

r"<.*>"

This is the regex pattern used to search.

The r before the string means it's a raw string, so backslashes like \n or \t are treated as literal characters (not escapes).

Let’s decode the pattern:

Pattern Meaning

< Match the literal < character

.* Match any characters (.) zero or more times (*) — greedy

> Match the literal > character

So the pattern <.*> matches:

A substring that starts with <

Ends with >

And contains anything in between, matching as much as possible (greedy).

Input string: "<a><b>"

Regex matches:

Start at the first < (which is <a>)

Then .* grabs everything, including the ><b>, until the last > in the string

So it matches:

<a><b>

print(m.group())

m is the Match object from re.search.

.group() gives you the actual string that matched the pattern.

In this case, the matched part is:

<a><b>

Final Output:

<a><b>

Read More

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

 

Code Explanation:

1. Import lru_cache

from functools import lru_cache

lru_cache stands for Least Recently Used cache.

It's a decorator that caches the results of function calls so repeated inputs don't recompute.

2. Define Fibonacci Function with Memoization

@lru_cache()

def fib(n):

    return n if n < 2 else fib(n - 1) + fib(n - 2)

This is a recursive function for computing Fibonacci numbers.

Base case: If n is 0 or 1, return n directly.

Recursive case: Add the previous two Fibonacci numbers:

F(n)=F(n−1)+F(n−2)

@lru_cache() stores the result of each call so fib(5) doesn’t recalculate fib(4) and fib(3) again — this drastically improves performance!

3. Compute fib(10)

print(fib(10))

The 10th Fibonacci number (using 0-based indexing) is:

F(0)=0F(1)=1F(2)=1F(3)=2F(4)=3F(5)=5F(6)=8F(7)=13F(8)=21F(9)=34F(10)=55

Output:

55

Read More

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

 

Code Explanation:

1. Importing Libraries

import statsmodels.api as sm  

import numpy as np  

numpy is used for numerical operations and creating arrays.

statsmodels.api is a Python package used for statistical modeling — especially regression.

2. Defining Data

x = np.array([1, 2, 3, 4, 5])  

y = np.array([3, 6, 9, 12, 15])  

x is the independent variable.

y is the dependent variable.

From a quick look: y = 3 * x — it’s a perfect linear relationship.

 3. Adding Intercept to X

X = sm.add_constant(x)

This adds a column of ones to x so the model can estimate an intercept term (bias).

Now X becomes a 2D array:

[[1. 1.]

 [1. 2.]

 [1. 3.]

 [1. 4.]

 [1. 5.]]

First column = constant (intercept)

Second column = original x values

4. Fitting the OLS Model

model = sm.OLS(y, X).fit()

This runs Ordinary Least Squares (OLS) regression using:

y as the dependent variable

X (with constant) as the independent variable(s)

.fit() estimates the parameters (intercept and slope)

5. Accessing the Slope

print(model.params[1])

model.params returns the regression coefficients:

[intercept, slope]

model.params[1] extracts the slope of the line.

Since the data is perfectly linear (y = 3x), the slope should be exactly 3.0.

Final Output

>>> 3.0

This confirms the slope is 3, matching the relationship between x and y.

Read More

Python Quiz on Numpy Array Slicing

 

Read More

Python Coding Challange - Question With Answer(01040425)

 

What’s happening here?

• fruits is a list of 5 string items.

  ['Python', 'Py', 'Anaconda', 'CPython', 'Dragon']
  index: 0     1        2          3         4

• fruits[1:3] is list slicing. It means:

  • Start at index 1 ('Py')

  • Go up to but not including index 3 ('CPython')

So it includes:

• 'Py' (index 1)

• 'Anaconda' (index 2)

It stops before index 3.

---

✅ Output:

['Py', 'Anaconda']

Check Now 400 Days Python Coding Challenges with Explanation
https://pythonclcoding.gumroad.com/l/sputu

Read More

Python Coding Challange - Question With Answer(01030425)

 

tep 1: First if Condition

if not (code >= 100 and code <= 200):
   print("1")

• code = 501, so we check:
  code >= 100 → True 
  code <= 200 → False 
  (code >= 100 and code <= 200) → (True and False) → False
not (False) → True

• Since the condition is True, it executes:
  Output: 1 ✅

---

Step 2: Second if Condition

if not (code >= 400 or code == 501):
   print("2")

• code = 501, so we check:

  code >= 400 → True 
  code == 501 → True 
  (code >= 400 or code == 501) → (True or True) → True
not (True) → False

• Since the condition is False, it does not execute print("2").

---

Final Output

1

"2" is not printed because its condition evaluates to False.

Check Now 300 Days Python Coding Challenges with Explanation 

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

Read More

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

 

Step-by-Step Breakdown:

1. Importing NumPy

import numpy as np

NumPy is imported as np to use its numerical functions.

2. Defining the Data Points

x = np.array([1, 2, 3, 4, 5])  

y = np.array([2, 4, 6, 8, 10])  

x and y are NumPy arrays representing a set of data points.

The relationship between x and y follows a linear pattern:

y=2x

This means y is exactly twice the value of x.

3. Performing Linear Regression with np.polyfit

slope, intercept = np.polyfit(x, y, 1)

np.polyfit(x, y, 1) fits a polynomial of degree 1 (a straight line) to the data.

The function finds the best-fit slope (m) and intercept (c) for the equation:

y=mx+c

In this case, since the data follows y = 2x, the computed values will be:

slope = 2.0

intercept = 0.0

4. Printing the Slope

print(slope)

This prints 2.0 since the best-fit line is y = 2x + 0.

Final Output:

2

Read More

Velvet Nebula Pattern using Python

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

theta=np.linspace(0,4*np.pi,400)

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

r=z**2+1

x=r*np.sin(theta)

y=r*np.cos(theta)

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

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

colors=np.linspace(0,1,len(x))

ax.scatter(x,y,z,c=colors,cmap='plasma',s=10)

ax.set_xlabel('X Axis')

ax.set_ylabel('Y Axis')

ax.set_zlabel('Z Axis')

ax.set_title('Velvet Nebula Bloom')

plt.show()

#source code --> clcoding.com

 Code Explanation:

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

 

import numpy as np:

Imports the NumPy library using the alias np.

NumPy is used for efficient numerical calculations and generating arrays of data points.

 

import matplotlib.pyplot as plt:

Imports Matplotlib’s pyplot module using the alias plt.

It provides functions to plot graphs, charts, and visualizations.

 

from mpl_toolkits.mplot3d import Axes3D:

Imports Axes3D from the mpl_toolkits.mplot3d module.

It allows creating 3D plots using Matplotlib.

 

2. Generate Data for the Spiral

a) Theta - Angle Generation

theta = np.linspace(0, 4 * np.pi, 400)

np.linspace(start, stop, num):

Generates 400 evenly spaced values from 0 to 4π (approx 12.566).

theta represents the angle in radians for a circular or spiral motion.

This variable will be used to define the x and y coordinates using sine and cosine functions.

 

b) Z - Vertical Axis (Height)

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

Generates 400 points from -2 to 2, representing the Z-axis (height).

This makes the spiral extend vertically from -2 to 2 units.

 

c) R - Spiral Radius

r = z**2 + 1

This creates a varying radius using the formula:

𝑟=𝑧2+1

 

Explanation:

At the center (z = 0), the radius is 1.

As z increases or decreases, the radius expands because  increases.

This makes the spiral bloom outward, resembling a nebula.

 

d) Calculate X and Y Coordinates

x = r * np.sin(theta)

y = r * np.cos(theta)

x = r × sin(θ) and y = r × cos(θ):

 

These parametric equations define the position of points in a circular (spiral) pattern.

sin() and cos() determine the coordinates on the XY-plane.

r controls how far the points are from the origin, forming a widening spiral.

 

3. Create the Plot

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

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

plt.figure(figsize=(12, 8)):

Creates a figure with a size of 12x8 inches for better visualization.

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

Adds a 3D subplot to the figure.

111 means 1 row, 1 column, and this is the first subplot.

projection='3d' enables 3D plotting.

 

4. Apply a Color Gradient

colors = np.linspace(0, 1, len(x))

np.linspace(0, 1, len(x)):

Generates an array of values from 0 to 1 to map colors.

len(x) ensures there is one color for each point.

These values will be used to create a smooth gradient using a colormap.

 

Plot the Spiral Using Scatter Plot

ax.scatter(x, y, z, c=colors, cmap='plasma', s=10)

ax.scatter():

 

Creates a 3D scatter plot.

Each point is represented as a small dot in 3D space.

Parameters:

x, y, z: Coordinates for each point.

c=colors: The color values for each point (gradient).

cmap='plasma': Uses the Plasma colormap, giving a vibrant velvet glow.

s=10: Sets the size of the points to 10 pixels.

 

5. Add Axis Labels and Title

ax.set_xlabel('X Axis')

ax.set_ylabel('Y Axis')

ax.set_zlabel('Z Axis')

ax.set_title('Velvet Nebula Bloom: 3D Spiral Pattern using Matplotlib')

ax.set_xlabel(): Labels the X-axis.

ax.set_ylabel(): Labels the Y-axis.

ax.set_zlabel(): Labels the Z-axis.

ax.set_title(): Sets the plot title, describing the visualization as Velvet Nebula Bloom.

 

6. Display the Plot

plt.show()

plt.show():

Renders the plot and displays it in a window.

You can rotate, zoom, and explore the plot using the interactive Matplotlib interface.

Read More

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

 

Code Explanation:

1. Importing Required Libraries

from scipy.linalg import eig

import numpy as np

scipy.linalg.eig: This function is used to compute the eigenvalues and eigenvectors of a square matrix.

numpy (np): A fundamental package for numerical computations in Python.

2. Defining the Matrix A

A = np.array([[0, -1], [1, 0]])

This matrix represents a 90-degree rotation in 2D space.

3. Computing Eigenvalues

eigenvalues, _ = eig(A)

eig(A): Computes the eigenvalues and eigenvectors of matrix A.

eigenvalues: The roots of the characteristic equation 

det(A−λI)=0.

_: We use _ as a placeholder since we are not interested in the eigenvectors.

4. Printing the Eigenvalues

print(eigenvalues)

The output will be:

Final Output:

[1j ,-1j]

Read More

Python Quiz on Numpy Array Indexing

 

Read More

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

 

Step-by-Step Breakdown

1. Import Required Libraries

import statsmodels.api as sm  

import numpy as np  

statsmodels.api is a Python library for statistical modeling, including Ordinary Least Squares (OLS) regression.

numpy is used for handling arrays.

2. Define Input Data

x = np.array([1, 2, 3, 4, 5])  

y = np.array([3, 6, 9, 12, 15])  

x represents the independent variable (predictor).

y represents the dependent variable (response).

The relationship follows a perfect linear pattern:

y=3x

This means the data is already perfectly aligned with a straight line.

3. Add Constant Term for Intercept

X = sm.add_constant(x)

sm.add_constant(x) adds a column of ones to x, which allows the regression model to estimate the intercept in the equation:

y=mx+c

After this step, X looks like:

[[1, 1],

 [1, 2],

 [1, 3],

 [1, 4],

 [1, 5]]

where:

The first column (all 1s) represents the intercept.

The second column is the original x values.

4. Fit the OLS Model

model = sm.OLS(y, X).fit()

sm.OLS(y, X).fit() performs Ordinary Least Squares (OLS) regression, which finds the best-fitting line by minimizing the sum of squared residuals.

5. Print the Slope (Coefficient)

print(model.params[1])

.params gives the estimated coefficients [intercept, slope].

model.params[1] extracts the slope (coefficient of x).

Final Output

3

Read More

Python Coding Challange - Question With Answer(01020425)

 

Step-by-Step Breakdown:

1. Variable Assignment:

   word = 'clcoding'

   The string 'clcoding' is assigned to the variable word.

2. Negative Indexing:

   • In Python, negative indexing allows you to access elements from the end of the string.

   • Here’s the index mapping for 'clcoding':

     
     c  l  c  o  d  i  n  g-

   • 8 - 7 - 6 - 5 - 4 - 3 - 2 - 1

3. Slicing word[-4:-2]:

   • word[-4:-2] means extracting characters from index -4 to -2 (excluding -2).

   • Looking at the negative indexes:

     • word[-4] → 'd'

     • word[-3] → 'i'

     • word[-2] → 'n' (not included in the slice)

   • The output includes characters at -4 and -3, which are "di".

Final Output:

di

This means the code prints:

di

Check Now 400 Days Python Coding Challenges with Explanation
https://pythonclcoding.gumroad.com/l/sputu

Read More