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

 

Code Explanation:

Function Definition

def append_to_list(val, list=[]):

What Happens:

A function named append_to_list is defined.

It takes two parameters:

val: the value to be added to a list.

list: an optional parameter, with a default value of an empty list [].

Append Value to List

    list.append(val)

What Happens:

The method append(val) adds the value val to the end of the list.

If no custom list was passed, it uses the shared default list, which keeps getting modified across function calls.

Return the Modified List

    return list

 What Happens:

The updated list is returned as the output of the function.

First Function Call

print(append_to_list(1))

What Happens:

No list is passed, so it uses the default list: [].

1 is appended → list becomes [1].

The default list is now modified and becomes [1].

Output:

[1]

Second Function Call

print(append_to_list(2, []))

What Happens:

A new empty list [] is passed.

2 is appended to this new list → list becomes [2].

The default list ([1]) is not affected here.

Output:

[2]

Third Function Call

print(append_to_list(3))

What Happens:

No list is passed again, so it uses the modified default list from the first call, which is now [1].

3 is appended → list becomes [1, 3].

Output:

[1, 3]

Final Output Summary

[1]

[2]

[1, 3]

Read More

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

 

Code Explanation:

1. Function Definition: append_to_list(val, lst=[])

def append_to_list(val, lst=[]):

    lst.append(val)

    return lst

This function is defined with two parameters:

val: The value that will be appended to the list.

lst: The list to which the value will be added. It has a default value of an empty list [].

Important Concept: The parameter lst=[] uses a mutable default argument (a list). In Python, default mutable arguments (like lists, dictionaries) are not re-initialized every time the function is called. Instead, they are modified in-place across function calls.

2. First Function Call: append_to_list(1)

print(append_to_list(1))

Here, append_to_list(1) is called with val=1 and the default lst=[].

Since the list lst is empty initially, 1 is appended to it, changing lst to [1].

The function returns [1], and that is printed.

Output after first call:

[1]

3. Second Function Call: append_to_list(2)

print(append_to_list(2))

In the second call, append_to_list(2) is executed with val=2.

Now, because of the mutable default argument, the same list lst (from the previous call) is used again. This means the list now already contains [1] from the previous call.

The value 2 is appended to this list, updating it to [1, 2].

The function returns [1, 2], and that is printed.

Output after second call:

[1, 2]

4. Why Does This Happen?

Mutable Default Argument: The default value lst=[] is only initialized once when the function is defined. If the function is called multiple times and doesn't explicitly pass the lst argument, it keeps modifying the same list object. This is why in the second function call, the value 2 is appended to the same list that had 1 from the first call.

Mutable objects like lists, dictionaries are shared across function calls when used as default arguments.

5. Final Output

When the code is executed:

print(append_to_list(1))  # Output: [1]

print(append_to_list(2))  # Output: [1, 2]

The outputs printed are:

Final Output:

[1]

[1, 2]

Read More

The AI Workshop: The Complete Beginner's Guide to AI: Your A-Z Guide to Mastering Artificial Intelligence for Life, Work, and Business—No Coding Required

 

The AI Workshop: A Complete Beginner’s Guide to Artificial Intelligence (No Coding Needed)

Artificial Intelligence (AI) is no longer science fiction or the domain of software engineers. It’s real, it's here, and it's reshaping how we live, work, and do business. But for many beginners, the complexity and technical jargon can be overwhelming—especially for those with no programming background.

That’s where “The AI Workshop: The Complete Beginner's Guide to AI” comes in. This book serves as an A-to-Z, hands-on guide to understanding and applying AI, even if you've never written a single line of code. Whether you're a small business owner, a professional, or just curious about AI, this guide gives you practical tools to get started immediately.

Why AI Matters in Today’s World

AI is behind the smart assistants on your phone, the recommendations on Netflix, the spam filter in your email, and even the predictive text you're reading right now. It automates tasks, finds patterns in data, improves decision-making, and can significantly enhance productivity and creativity.

Yet, despite its wide applications, there's a misconception that AI is only for tech experts. In reality, you don't need to be a coder to understand or even use AI. That’s what this book emphasizes.

What This Book Offers (and Why It Stands Out)

The AI Workshop demystifies AI by breaking it down into digestible concepts. It’s designed around a practical framework, combining clear explanations, visual examples, and interactive exercises. Here’s what makes it special:

No Coding Required

You won’t need Python, Jupyter notebooks, or any machine learning libraries. The book uses real-world, low-code/no-code platforms like:

Google AutoML

Microsoft Power Automate

ChatGPT and GPT-based tools

AI writing and design tools (Jasper, Canva AI)

AI-powered analytics platforms (Tableau, Power BI with AI integrations)

Step-by-Step Workshops

Every chapter is formatted like a workshop, guiding you through actual use cases:

• Build a chatbot with AI tools
• Automate social media posts using AI schedulers
• Use AI to summarize reports or emails
• Generate customer insights from survey data
• Create content using generative AI tools

Business Applications

Understand how AI can:

• Automate customer support
• Improve marketing campaigns
• Predict customer churn
• Enhance HR and recruitment
• Streamline project management

Life Applications

Use AI to:

• Plan your travel itineraries
• Organize your daily tasks
• Personalize your fitness routines
• Manage finances through AI-enabled apps

Topics Covered in the Book

Here’s a glimpse of the book’s core sections:

1. What Is AI?

A beginner-friendly breakdown of AI, machine learning, deep learning, and how they all fit together.

2. Types of AI

Narrow AI vs General AI

Supervised vs Unsupervised Learning (explained visually)

Natural Language Processing (NLP)

Computer Vision basics

3. AI Tools You Can Use Today

Hands-on tutorials on:

ChatGPT and conversational AI

AI design generators (like DALL·E and Canva AI)

Data prediction without code (e.g., Google AutoML Tables)

4. How to Think Like an AI Designer

Problem framing

Understanding bias in AI

Ethical considerations

Human-AI collaboration (not competition)

5. AI for Business

AI for sales forecasting

Personalized customer experiences

AI-driven data dashboards

Automating repetitive back-office tasks

6. AI for Career Growth

Using AI to build your resume

Leveraging AI to learn faster

Preparing for an AI-powered job market

What You'll Gain

By the end of this book, readers will:

Understand key AI concepts and vocabulary

Know how to choose the right AI tool for a task

Be able to apply AI immediately to real-life or business challenges

Have the confidence to explore more advanced tools, even without coding

Who Is This Book For?

Entrepreneurs who want to automate and grow smarter

Professionals looking to increase productivity or pivot careers

Students and educators wanting to bring AI into classrooms or projects

Non-technical managers who oversee AI teams or projects

Curious learners who want to explore the future responsibly

Hard Copy : The AI Workshop: The Complete Beginner's Guide to AI: Your A-Z Guide to Mastering Artificial Intelligence for Life, Work, and Business—No Coding Required

Kindle : The AI Workshop: The Complete Beginner's Guide to AI: Your A-Z Guide to Mastering Artificial Intelligence for Life, Work, and Business—No Coding Required

Final Thoughts: AI Is a Tool, Not a Threat

The AI Workshop proves that you don’t have to be a tech genius to ride the AI wave. Instead, AI is a tool—one that can enhance your daily life, boost your work output, and unlock entirely new opportunities. Whether you’re running a business, climbing the career ladder, or just trying to work smarter, this guide helps you do exactly that—without needing to learn how to code.

It’s not about becoming an AI expert. It’s about becoming AI-literate, and using that knowledge to thrive in the world that’s already being shaped by it.

Read More

3D Rose Surface Plot using Python

 

import numpy as np

import matplotlib.pyplot as plt

k=8

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

phi=np.linspace(0,np.pi,300)

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

r = np.sin(k * theta) * np.sin(phi)

x = r * np.sin(phi) * np.cos(theta)

y = r * np.sin(phi) * np.sin(theta)

z = r * np.cos(phi)

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

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

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

ax.set_title('3D Rose Surface Plot')

ax.axis('off')

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Import Libraries

import numpy as np

import matplotlib.pyplot as plt

numpy: For numerical calculations and creating coordinate grids.

 matplotlib.pyplot: For plotting the 3D surface.

 2. Set the Parameter

k = 5  # Number of petals (can be any float or integer)

The variable k controls the number of "petals" in the rose pattern.

 A higher or fractional k gives more complex shapes.

 3. Create Meshgrid for Angles

theta = np.linspace(0, 2 * np.pi, 300)  # Azimuthal angle

phi = np.linspace(0, np.pi, 300)        # Polar angle

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

theta: Goes from 0 to

2π, wrapping around the z-axis (like longitude).

phi: Goes from 0 to

π, spanning from top to bottom of the sphere (like latitude).

np.meshgrid creates a grid of angle values used for surface plotting.

 4. Define the Rose Function

r = np.sin(k * theta) * np.sin(phi)

This defines the radius r at each angle based on the polar rose formula:

 r(θ,ϕ)=sin(kθ)⋅sin(ϕ)

sin(kθ) makes the petal pattern.

 sin(φ) ensures the pattern wraps over the sphere rather than staying flat.

 5. Convert to 3D Cartesian Coordinates

 x = r * np.sin(phi) * np.cos(theta)

y = r * np.sin(phi) * np.sin(theta)

z = r * np.cos(phi)

This converts spherical coordinates

(r,θ,ϕ) to Cartesian coordinates (x,y,z):

 x=r⋅sin(ϕ)⋅cos(θ)

y=r⋅sin(ϕ)⋅sin(θ)

z=r⋅cos(ϕ)

 This gives a 3D shape based on the rose function wrapped over a sphere.

 6. Plot the Surface

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

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

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

Creates a 3D plot (projection='3d').

 plot_surface() draws the rose surface using x, y, z.

 cmap='inferno' adds color based on height/intensity.

 edgecolor='none' smooths the surface by hiding grid lines.

 7. Final Touches

ax.set_title(f"3D Rose Surface Plot (k = {k})")

ax.axis('off')

plt.show()

Adds a title showing the value of k.

 Turns off axis for a clean visual.

 

Read More

Petal Swirl Matrix using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

def petal_shape(k, theta):

    return np.sin(k * theta)

k_values = np.linspace(2, 7, 20)  

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

theta_grid, k_grid = np.meshgrid(theta, k_values)

r = petal_shape(k_grid, theta_grid)

x = r * np.cos(theta_grid)

y = r * np.sin(theta_grid)

z = k_grid  

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

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

ax.set_facecolor('black')

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

ax.set_title("Petal Swirl Matrix", color='white', fontsize=18)

ax.axis('off')

fig.colorbar(surface, shrink=0.5, aspect=10)

ax.view_init(elev=45, azim=135)

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 (as np): For numerical calculations and handling arrays.

matplotlib.pyplot (as plt): For creating visual plots (2D and 3D).

Axes3D: This is necessary for 3D plotting with matplotlib.

2. Defining the Petal Shape Function

def petal_shape(k, theta):

    return np.sin(k * theta)

petal_shape(k, theta): This function generates a petal shape for the pattern, based on the frequency parameter k and angle theta. It returns the radial distance r as a function of k and theta (sinusoidal oscillation).

3. Defining Parameters and Generating Grids

k_values = np.linspace(2, 7, 20)  

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

theta_grid, k_grid = np.meshgrid(theta, k_values)

k_values: Creates an array of 20 values ranging from 2 to 7 for the frequency parameter k.

theta: Creates an array of 400 equally spaced values for the angle theta from 0 to 

2π.

meshgrid: Creates a 2D grid of coordinates for theta and k that will be used to evaluate the petal_shape function over all combinations.

4. Generating the Radial Distance (r)

r = petal_shape(k_grid, theta_grid)

r: Uses the petal_shape function to calculate the radial distance for each (k, theta) pair. This produces the petal-like oscillations for different values of k.

5. Converting to Cartesian Coordinates

x = r * np.cos(theta_grid)

y = r * np.sin(theta_grid)

z = k_grid  

x and y: Convert the polar coordinates (r, theta) to Cartesian coordinates.

x=rcos(θ)

y=rsin(θ)

z: Set the z coordinate to the k values, so each petal is positioned at a different height based on k.

6. Creating the 3D Plot

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

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

fig: Creates a new figure with a size of 6x6 inches.

ax: Adds a 3D subplot to the figure for plotting the surface.

7. Setting Plot Aesthetics

ax.set_facecolor('black')

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

ax.set_facecolor('black'): Sets the background color of the plot to black.

plot_surface: Plots the surface with:

cmap='spring': A spring-like color map for surface coloring.

edgecolor='none': Removes the edges of the surface grid.

alpha=0.95: Sets the surface to be slightly transparent.

8. Adding Title and Customizing Axes

ax.set_title("Petal Swirl Matrix", color='white', fontsize=18)

ax.axis('off')

ax.set_title: Adds the title "Petal Swirl Matrix" in white color and with a font size of 18.

ax.axis('off'): Hides the axes for a cleaner look.

9. Adding a Colorbar

fig.colorbar(surface, shrink=0.5, aspect=10)

Adds a color bar to the plot to show the color mapping used for the surface, with shrink=0.5 to reduce its size and aspect=10 to adjust its aspect ratio.

10. Adjusting the View Angle

ax.view_init(elev=45, azim=135)

view_init: Sets the initial view of the plot, with:

elev=45: Elevation angle of 45° (view from above).

azim=135: Azimuthal angle of 135° (rotates the view around the z-axis).

11. Displaying the Plot

plt.show()

plt.show(): Renders and displays the final 3D plot.

Read More

Coral Torus Bloom Pattern using Python

 

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

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

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

u,v=np.meshgrid(u,v)

R=1

r=0.3

bloom=0.1*np.sin(5*u)*np.cos(7*v)

x=(R+r*np.cos(v)+bloom)*np.cos(u)

y=(R+r*np.cos(v)+bloom)*np.sin(u)

z=r*np.sin(v)+bloom

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

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

ax.set_facecolor('black')

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

ax.set_xlim([-1.5,1.5])

ax.set_ylim([-1.5,1.5])

ax.set_zlim([-1.5,1.5])

ax.axis('off')

fig.colorbar(surface,shrink=0.5,aspect=10)

plt.title('Coral Torus Bloom',color='white',fontsize=18)

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 (as np): Used for numerical operations and array manipulations.

matplotlib.pyplot (as plt): Used for plotting 2D/3D graphics.

Axes3D: Enables 3D plotting in matplotlib.

2. Creating Meshgrid Parameters

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

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

u, v = np.meshgrid(u, v)

u and v: Arrays of 100 values evenly spaced from 0 to 

2π, representing angles.

meshgrid: Creates 2D coordinate grids from u and v for parameterizing a surface.

3. Defining Torus Parameters and Surface Perturbation

R = 1     

r = 0.3   

bloom = 0.1 * np.sin(5 * u) * np.cos(7 * v)

R: Major radius (distance from center of tube to center of torus).

r: Minor radius (radius of the tube).

bloom: A sinusoidal perturbation to add organic "bloom" effects to the torus surface, like coral growth.

4. Parametric Equations of the Deformed Torus

x = (R + r * np.cos(v) + bloom) * np.cos(u)

y = (R + r * np.cos(v) + bloom) * np.sin(u)

z = r * np.sin(v) + bloom

These are the parametric equations of a torus modified by the bloom effect:

x=(R+rcos(v)+bloom)cos(u)

y=(R+rcos(v)+bloom)sin(u)

z=rsin(v)+bloom

5. Creating the 3D Plot

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

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

fig: Creates a new figure window of size 6x6 inches.

ax: Adds a 3D subplot to the figure.

6. Plot Settings and Aesthetics

ax.set_facecolor('black')

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

ax.set_facecolor: Sets the background of the 3D plot to black.

plot_surface: Plots the deformed torus surface with:

cmap='plasma': Color map for surface coloring.

edgecolor='none': No mesh lines.

alpha=0.95: Slight transparency.

7. Setting Plot Limits and Hiding Axes

ax.set_xlim([-1.5, 1.5])

ax.set_ylim([-1.5, 1.5])

ax.set_zlim([-1.5, 1.5])

ax.axis('off')

These limit the 3D view range for x, y, z axes and hide the axis grid and ticks for a cleaner look.

8. Adding Colorbar and Title

fig.colorbar(surface, shrink=0.5, aspect=10)

plt.title("Coral Torus Bloom", color='white', fontsize=18)

Adds a color bar to indicate surface value mappings.

Sets the title of the plot with white text.

9. Displaying the Plot

plt.show()

Renders the final 3D visualization.

Read More

3D Simulated Fireball using Python

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

n = 5000

r = np.random.rand(n) ** 0.5  

theta = np.random.uniform(0, 2 * np.pi, n)

phi = np.random.uniform(0, np.pi, n)

x = r * np.sin(phi) * np.cos(theta)

y = r * np.sin(phi) * np.sin(theta)

z = r * np.cos(phi)

intensity = 1 - rs

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

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

sc = ax.scatter(x, y, z, c=intensity, cmap='hot', s=2, alpha=0.8)

ax.set_title("3D Simulated Fireball")

ax.set_xlabel("X")

ax.set_ylabel("Y")

ax.set_zlabel("Z")

ax.set_box_aspect([1, 1, 1])

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 math operations and random number generation.

matplotlib.pyplot: For plotting.

Axes3D: Enables 3D plotting using matplotlib.

2. Define Parameters and Generate Random Points in Spherical Coordinates

n = 5000  # Number of particles in the fireball

r = np.random.rand(n) ** 0.5  

Generates 5000 random radii from the origin.

** 0.5 makes particles denser toward the center, like a real fireball.

3. Generate Random Angular Coordinates

theta = np.random.uniform(0, 2 * np.pi, n)

phi = np.random.uniform(0, np.pi, n)

theta: Random azimuthal angle around the Z-axis (0 to 2π).

phi: Polar angle from the vertical axis (0 to π).

4. Convert Spherical to Cartesian Coordinates

x = r * np.sin(phi) * np.cos(theta)

y = r * np.sin(phi) * np.sin(theta)

z = r * np.cos(phi)

Converts spherical (r, theta, phi) to 3D Cartesian coordinates (x, y, z) to plot in 3D space.

5. Define Fireball Intensity (Brighter at Core)

intensity = 1 - r

Points closer to the center (r ≈ 0) are brighter (intensity ≈ 1).

Points near the edge fade out (intensity ≈ 0).

6. Set Up 3D Plotting Area

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

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

Sets up a 3D subplot with a square figure size.

7. Plot the Fireball with Color Mapping

sc = ax.scatter(x, y, z, c=intensity, cmap='hot', s=2, alpha=0.8)

scatter: Plots all points in 3D.

c=intensity: Colors depend on how close the point is to the center.

cmap='hot': Uses a red-orange-yellow gradient like real fire.

s=2: Small point size for a glowing cluster.

alpha=0.8: Slight transparency for blending.

8. Add Labels and Aesthetics

ax.set_title("3D Simulated Fireball")

ax.set_xlabel("X")

ax.set_ylabel("Y")

ax.set_zlabel("Z")

ax.set_box_aspect([1, 1, 1])

Title and axis labels.

set_box_aspect([1, 1, 1]): Ensures equal scaling in all directions (spherical symmetry).

9. Show the Plot

plt.tight_layout()

plt.show()

tight_layout(): Adjusts spacing.

show(): Displays the final plot.

 

Read More

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

 Code Explanation:

 Line 1 – Create an empty list

funcs = []

Initializes an empty list named funcs.

This list will be used to store functions (lambdas).

 Lines 2–3 – Append lambdas inside a loop

for i in range(3):

    funcs.append(lambda: i)

range(3) gives i = 0, 1, 2

Each time, a lambda function is created and added to the list.

BUT: The lambda captures i by reference, not value.

This means all the lambdas share the same i, which changes during each loop iteration.

After the loop ends, i = 2, and all lambdas "remember" that final value.

 Line 4 – Call all stored functions

results = [f() for f in funcs]

This calls each lambda in funcs.

Since all lambdas reference the same variable i, and i == 2 after the loop:

Each f() returns 2

 Line 5 – Print the result

print(results)

Output:

[2, 2, 2]

Read More

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

 

Code Explanation:

1. try Block

try:

    1 / 0  # This raises a ZeroDivisionError

The code in the try block attempts to divide 1 by 0, which causes a ZeroDivisionError to be raised.

At this point, the program jumps to the except block to handle the exception.

2. except Block

except ZeroDivisionError:

    return 1  # This will be executed when the exception is raised

Since a ZeroDivisionError was raised, this block is executed.

return 1 is executed, and the function tries to return 1 immediately.

3. finally Block

finally:

    return 2  # This will always be executed, even if there's a return in the try/except

The finally block is always executed, whether or not an exception was raised or handled.

In this case, even though return 1 was about to return from the except block, the finally block overrides it because a return statement in the finally block always takes precedence.

What Happens in the End?

The function initially tries to return 1 from the except block.

However, the finally block executes next and forces the function to return 2, overriding the 1 that was previously returned.

Output:

2

Read More

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

 

Code Explanation:

Function Definition

def f(x, acc=[]):

    acc.append(x)

    if x > 0:

        return f(x - 1, acc)

    return sum(acc)

Parameters:

x: An integer passed to the function.

acc: A mutable default argument (list), which accumulates values during recursion.

Initial Call: f(3)

When f(3) is called:

x = 3, and the default list acc = [] is used since no other list is provided.

3 is appended to acc, so acc = [3].

The condition x > 0 is true, so the function calls f(2, [3]).

Second Call: f(2, [3])

x = 2, and the list acc = [3] is passed.

2 is appended to acc, so acc = [3, 2].

The condition x > 0 is still true, so the function calls f(1, [3, 2]).

Third Call: f(1, [3, 2])

x = 1, and the list acc = [3, 2] is passed.

1 is appended to acc, so acc = [3, 2, 1].

The condition x > 0 is still true, so the function calls f(0, [3, 2, 1]).

Fourth Call: f(0, [3, 2, 1])

x = 0, and the list acc = [3, 2, 1] is passed.

0 is appended to acc, so acc = [3, 2, 1, 0].

The condition x > 0 is false, so it returns the sum of the list acc, which is sum([3, 2, 1, 0]) = 6.

Final Return Value

The function returns 6, and the final output is printed as:

6

Read More

3D Parametric Shell Surface using Python

 

import numpy as np

import matplotlib.pyplot as plt

a = 1

b = 0.2

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

v = np.linspace(0, 4 * np.pi, 100)

u, v = np.meshgrid(u, v)

X = a * (1 - v / (2 * np.pi)) * np.cos(v) * np.cos(u)

Y = a * (1 - v / (2 * np.pi)) * np.cos(v) * np.sin(u)

Z = a * (1 - v / (2 * np.pi)) * np.sin(v) + b * u

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

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

ax.plot_surface(X, Y, Z, cmap='magma', edgecolor='k', alpha=0.9)

ax.set_title("3D Parametric Shell Surface")

ax.set_xlabel("X axis")

ax.set_ylabel("Y axis")

ax.set_zlabel("Z axis")

ax.set_box_aspect([1, 1, 1])

plt.tight_layout()

plt.show()

#source code --> clcoding.com 

Code Explanation:

1. Import Libraries

import numpy as np

import matplotlib.pyplot as plt

numpy: Used for numerical computations and creating arrays.

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

 2. Define Constants for Shape Control

a = 1

b = 0.2

a: Controls the overall scale of the shell surface.

 b: Adds a vertical twist/extension as the surface rotates.

 3. Create Parameter Grids (u and v)

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

v = np.linspace(0, 4 * np.pi, 100)

u, v = np.meshgrid(u, v)

u: Angle around the circular cross-section (like the shell's rim).

 v: Controls the spiral motion (shell’s growth).

 np.meshgrid: Creates a grid for evaluating parametric equations over 2D domains.

 4. Define Parametric Equations

X = a * (1 - v / (2 * np.pi)) * np.cos(v) * np.cos(u)

Y = a * (1 - v / (2 * np.pi)) * np.cos(v) * np.sin(u)

Z = a * (1 - v / (2 * np.pi)) * np.sin(v) + b * u

These equations generate a spiraling and shrinking shell surface:

 X and Y: Determine the radial coordinates; they shrink over v.

 Z: Adds a vertical twist via b * u, and height via sin(v).

 The structure gets smaller as v increases, mimicking how a shell tightens inward.

 5. Set Up 3D Plotting

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

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

Initializes a 3D plot.

 figsize=(10, 8): Sets the size of the figure.

 6. Plot the Shell Surface

ax.plot_surface(X, Y, Z, cmap='magma', edgecolor='k', alpha=0.9)

plot_surface: Draws the parametric surface in 3D.

 cmap='magma': Uses a vibrant color map.

 edgecolor='k': Adds black edges for clarity.

 alpha=0.9: Slight transparency for smoother visuals.

  7. Customize Plot Appearance

ax.set_title("3D Parametric Shell Surface")

ax.set_xlabel("X axis")

ax.set_ylabel("Y axis")

ax.set_zlabel("Z axis")

ax.set_box_aspect([1, 1, 1])

Adds axis labels and title.

 8. Display the Plot

plt.tight_layout()

plt.show()

tight_layout(): Avoids label overlaps.

 show(): Renders the 3D plot.

Read More

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

 

Code Explanation:

 Step 1: make_multipliers() creates lambdas in a loop

[lambda x: x * i for i in range(3)]

At each iteration, a lambda is added to the list.

But all lambdas capture the same variable i, which keeps changing in the loop.

After the loop ends, i = 2, so all lambdas refer to i = 2.

Step 2: Store in funcs

Now funcs is a list of 3 lambdas, each of which does:

lambda x: x * i  # where i is 2 for all of them

Step 3: Call each lambda with x = 2

results = [f(2) for f in funcs]

Each f is essentially:

lambda x: x * 2

So all return 2 * 2 = 4.

Output

[4, 4, 4]

Read More

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

 

Code Explanation:

Step 1: Define adder(n)

adder is a higher-order function that returns a lambda.

The lambda takes an input x and returns x + n.

Step 2: Create add5

add5 = adder(5)

This creates a function:

lambda x: x + 5

Step 3: Create add10

add10 = adder(10)

This creates a function:

lambda x: x + 10

Step 4: Call the functions

add5(3) → 3 + 5 = 8  

add10(3) → 3 + 10 = 13

Output

8 13

Read More

Python for Everyone: Coding, Data Science & ML Essentials syllabus

 

Week 1: Introduction to Coding and Python

Topic: Introduction to coding and Python
Details:

• Overview of programming concepts and Python's significance

• Installing Python and setting up the development environment

• Introduction to IDEs like PyCharm, VS Code, or Jupyter Notebooks

---

Week 2: Variables and Data Types

Topic: Understanding variables and data types
Details:

• Variables: Naming conventions and assignment

• Data types: strings, integers, floats, and booleans

• Simple calculations and printing output

---

Week 3: User Interaction

Topic: Using the input() function for user interaction
Details:

• Reading user input

• Converting input types

• Using input in simple programs

---

Week 4: Decision Making with If-Else Statements

Topic: Basic if-else statements for decision-making
Details:

• Syntax and structure of if, elif, and else

• Nested if-else statements

• Practical examples and exercises

---

Week 5: Introduction to Loops

Topic: Introduction to loops for repetitive tasks
Details:

• While loops: syntax and use cases

• For loops: syntax and use cases

• Loop control statements: break, continue, and pass

• Simple loop exercises

---

Week 6: Functions and Code Organization

Topic: Introduction to functions
Details:

• Definition and syntax of functions

• Parameters and return values

• The importance of functions in organizing code

---

Week 7: Built-in and User-Defined Functions

Topic: Exploring built-in functions and creating user-defined functions
Details:

• Common built-in functions in Python

• Creating and using user-defined functions

• Scope and lifetime of variables

---

Week 8: Working with Lists

Topic: Understanding and using lists
Details:

• Creating and modifying lists

• List indexing and slicing

• Common list operations (append, remove, pop, etc.)

• List comprehensions

---

Week 9: String Manipulation

Topic: Introduction to string manipulation
Details:

• String slicing and indexing

• String concatenation and formatting

• Common string methods (split, join, replace, etc.)

---

Week 10: Recap and Practice

Topic: Recap and practice exercises
Details:

• Review of previous topics

• Practice exercises and mini-projects

• Q&A session for clarification of doubts

---

Week 11: Introduction to Dictionaries

Topic: Working with dictionaries for key-value data storage
Details:

• Creating and accessing dictionaries

• Dictionary methods and operations (keys, values, items, etc.)

• Practical examples and exercises

---

Week 12: Working with Files

Topic: Reading and writing data to files
Details:

• File handling modes (read, write, append)

• Reading from and writing to files

• Practical file handling exercises

---

Week 13: Exceptions and Error Handling

Topic: Introduction to exceptions and error handling
Details:

• Understanding exceptions

• Try, except, else, and finally blocks

• Raising exceptions

• Practical error handling exercises

---

Week 14: Introduction to Object-Oriented Programming

Topic: Basic introduction to OOP
Details:

• Understanding classes and objects

• Creating classes and objects

• Attributes and methods

• Practical examples of OOP concepts

---

Week 15: Final Recap and Practice

Topic: Recap and practice exercises
Details:

• Comprehensive review of all topics

• Advanced practice exercises and projects

• Final Q&A and course completion

---

📊 Data Science & Machine Learning Extension

Week 16: Introduction to Data Science & Jupyter Notebooks

Topic: Getting started with Data Science
Details:

• What is Data Science?

• Setting up Jupyter Notebooks

• Introduction to NumPy and Pandas

• Loading and inspecting data

---

Week 17: Data Manipulation with Pandas

Topic: Data wrangling and cleaning
Details:

• DataFrames and Series

• Reading/writing CSV, Excel

• Handling missing data

• Filtering, sorting, grouping data

---

Week 18: Data Visualization

Topic: Exploring data visually
Details:

• Plotting with Matplotlib

• Advanced visuals using Seaborn

• Histograms, scatter plots, box plots

• Customizing graphs for insights

---

Week 19: Introduction to Machine Learning

Topic: Machine Learning fundamentals
Details:

• What is ML? Types of ML (Supervised, Unsupervised)

• Scikit-learn basics

• Splitting data into training/testing sets

• Evaluation metrics (accuracy, precision, recall)

---

Week 20: Building Your First ML Model

Topic: Creating a classification model
Details:

• Logistic Regression or Decision Trees

• Model training and prediction

• Evaluating model performance

• Model improvement basics

---

Week 21: Capstone Project & Course Wrap-up

Topic: Apply what you’ve learned
Details:

• Real-world data project (e.g., Titanic, Iris, or custom dataset)

• Full pipeline: load → clean → visualize → model → evaluate

• Presentation and peer review

• Final certification and next steps

Read More

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

 

Code Explanation:

1. Function make_funcs()

return [lambda: i for i in range(3)]

This creates a list of 3 lambda functions: lambda: i

All these lambdas refer to the same variable i, not its value at that time.

In the list comprehension, i goes from 0 → 1 → 2, but each lambda still just says "return i".

Important: Lambdas capture i by reference, not by value.

That means they all share the final value of i.

2. After make_funcs() is called:

funcs = make_funcs()

funcs is now a list of 3 lambda functions.

All of them will return the current value of i when they're called.

By the end of the loop, i == 2.

3. Calling the lambdas:

results = [f() for f in funcs]

Each lambda is called:

f1() → returns 2

f2() → returns 2

f3() → returns 2

Final Output:

[2, 2, 2]

Read More

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

 Code Explanation:

1. Define the generator function:

def gen():

    val = yield 1

    yield val * 2

This generator yields two values:

First, it yields 1.

Then, it waits for a value to be sent in, assigns it to val, and yields val * 2.

2. Create the generator object:

g = gen()

Now g is a generator object.

3. Start the generator:

print(next(g))

This starts the generator and runs it until the first yield, which is yield 1.

It outputs 1, and pauses at val = yield 1, waiting for a value to be sent into it.

Output so far:

1

4. Send a value into the generator:

print(g.send(10))

This resumes the generator and sends 10 into the paused yield expression.

So val = 10.

The next line yield val * 2 becomes yield 20.

Output:

20

Read More

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

 

Code Explanation:

 1. Importing the decimal Module

from decimal import Decimal, getcontext

Decimal is used for high-precision decimal arithmetic, avoiding float inaccuracies.

getcontext() accesses the current decimal arithmetic settings, such as precision.

 2. Setting Precision

getcontext().prec = 4

Sets the precision of decimal operations to 4 significant digits (not decimal places).

This affects how many total digits (before + after decimal) the results can retain.

Important: this doesn't round the final printed value like round() — it controls internal calculation precision.

3. Division with Precision

x = Decimal(1) / Decimal(7)

Performs the division 1 ÷ 7 with Decimal precision of 4 digits.

Result: Decimal('0.1429') (rounded to 4 significant digits)

4. Multiplying and Converting

print(int(x * 1000))

x ≈ 0.1429

Multiply by 1000: 0.1429 * 1000 = 142.9

Convert to int: truncates decimal → 142

 Final Output

142

Read More

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

 

Code Explanation:

1. Function Definition

def f(n):

This defines a function f that takes one argument n.

It is intended to compute the factorial of n recursively.

2. Base Case for Recursion

    if n == 0: return 1

If n is 0, the function returns 1.

This is the base case of the recursion.

0! = 1 by mathematical definition.

3. Recursive Case

    return n * f(n - 1)

If n > 0, the function returns n * f(n - 1).

This is the recursive step: it multiplies n by the factorial of n-1.

For example, f(3) returns 3 * f(2), which returns 3 * 2 * f(1) → and so on until f(0).

4. Function Call and Result Conversion

print(len(str(f(20))))

This calls the function with n = 20, so f(20) computes 20! (20 factorial).

20! = 2432902008176640000

Then str(...) converts the result to a string: "2432902008176640000"

len(...) gets the number of characters (digits) in the string.

Final Output

The number of digits in 20! is 19.

>>> print(len(str(f(20))))

19

Read More

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

 

Code Explanation:

Importing defaultdict:

defaultdict(int) creates a dictionary where the default value for any key that doesn't exist is 0 (since int() gives 0).

The String "banana":

The string "banana" consists of the following characters: b, a, n, a, n, a.

Looping through "banana":

The loop iterates through each character in the string "banana" and increments its corresponding count in the freq dictionary.

Here’s how the dictionary evolves during the loop:

For the first character b, the default value is 0, so freq['b'] becomes 1.

For the second character a, the default value is 0, so freq['a'] becomes 1.

For the third character n, the default value is 0, so freq['n'] becomes 1.

For the fourth character a, freq['a'] is already 1, so it's incremented to 2.

For the fifth character n, freq['n'] is already 1, so it's incremented to 2.

For the sixth character a, freq['a'] is already 2, so it's incremented to 3.

Printing freq['a'] and freq['n']:

After the loop, the frequency count of the characters is:

'a' appears 3 times

'n' appears 2 times

So, freq['a'] = 3 and freq['n'] = 2.

Output:

3 2

Read More

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

 

Code Explanation:

Importing reduce:

The reduce() function is part of the functools module. It is used to apply a binary function (a function that takes two arguments) cumulatively to the items of an iterable, from left to right, reducing the iterable to a single value.

The Iterable (numbers):

The iterable in this case is the list numbers = [1, 2, 3, 4].

The Function (lambda x, y: x + y):

A lambda function is defined, which takes two arguments (x and y) and returns the sum (x + y). This is the function that reduce() will apply cumulatively to the elements in the list.

How reduce() Works:

First iteration:

x = 1, y = 2 (first two elements in the list)

The lambda function is applied: 1 + 2 = 3

Second iteration:

x = 3 (result from the previous iteration), y = 3 (next element in the list)

The lambda function is applied: 3 + 3 = 6

Third iteration:

x = 6 (result from the previous iteration), y = 4 (next element in the list)

The lambda function is applied: 6 + 4 = 10

Final Result:

After all the iterations, the final result is 10, which is the sum of all the numbers in the list.

Output:

10

Read More

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

 

Code Explanation:

 Function Definition with a Mutable Default Argument

def f(key, val, d={}):

    d[key] = val

    return d

A function f is defined with three parameters: key, val, and d (defaulting to an empty dictionary {}).

Important: In Python, default values are evaluated only once, at the time the function is defined, not each time it's called.

So d={} creates one shared dictionary used across calls that don't provide a new one.

First Call: f('a', 1)

f('a', 1)

key='a', val=1, d uses the default value {}.

Adds 'a': 1 to d, so now:

d = {'a': 1}

Second Call: f('b', 2)

f('b', 2)

key='b', val=2, again uses the same default dictionary d.

Adds 'b': 2, so now:

d = {'a': 1, 'b': 2}

Third Call and Final Output

print(f('c', 3)['a'])

key='c', val=3, again uses the same shared dictionary.

Adds 'c': 3, so now:

d = {'a': 1, 'b': 2, 'c': 3}

Then f('c', 3)['a'] retrieves the value of key 'a' → 1

 Final Output

1

Read More