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

 

Code Explanation:

1️⃣ Defining Class Tracker

class Tracker:

A class named Tracker is created.

Objects of this class will inherit its variables and methods.

🔹 2️⃣ Defining a Class Variable

total = 0

total is a class variable.

It belongs to the class itself, not to individual objects.

Internally:

Tracker.total = 0

All instances will use the same variable.

🔹 3️⃣ Defining Method add

def add(self):

add is an instance method.

self refers to the object calling the method (t1 or t2).

🔹 4️⃣ Updating the Class Variable

Tracker.total += 2

This increases the class variable total by 2.

Important:

We are modifying the class variable directly:

Tracker.total

So every object sees the updated value.

🔹 5️⃣ Returning the Updated Value

return Tracker.total

After incrementing, the method returns the new value of total.

🔹 6️⃣ Creating First Object

t1 = Tracker()

Creates an instance named t1.

At this moment:

Tracker.total = 0

🔹 7️⃣ Creating Second Object

t2 = Tracker()

Creates another instance t2.

Both objects share the same variable:

Tracker.total

🔹 8️⃣ Calling the Methods

print(t1.add(), t2.add(), t1.add())

Python executes each call left to right.

Step 1️⃣

t1.add()

Execution:

Tracker.total = 0 + 2

Now:

Tracker.total = 2

Return value:

2

Step 2️⃣

t2.add()

Execution:

Tracker.total = 2 + 2

Now:

Tracker.total = 4

Return value:

4

Step 3️⃣

t1.add()

Execution:

Tracker.total = 4 + 2

Now:

Tracker.total = 6

Return value:

6

✅ Final Output

2 4 6

BOOK: 900 Days Python Coding Challenges with Explanation

Read More

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

 

Code Explanation:

🔹 1️⃣ Defining Descriptor Class D

class D:

A new class D is created.

This class will act as a descriptor because it defines the method __get__.

🔹 2️⃣ Defining the __get__ Method

def __get__(self, obj, objtype):

    return 50

This method is automatically called when the attribute is accessed.

Parameters:

self → the descriptor object

obj → the instance accessing the attribute (a)

objtype → the class of the instance (A)

In this code:

return 50

So whenever the attribute is accessed, 50 will be returned.

🔹 3️⃣ Defining Class A

class A:

A new class A is created.

🔹 4️⃣ Assigning Descriptor to Class Attribute

x = D()

Here an instance of class D is assigned to the class variable x.

So internally:

A.x → descriptor object

This means x is now controlled by the descriptor D.

🔹 5️⃣ Creating an Object of Class A

a = A()

An instance a of class A is created.

At this moment:

a.__dict__ = {}

No instance attributes exist yet.

🔹 6️⃣ Accessing a.x

print(a.x)

Python performs attribute lookup.

Steps:

Step 1

Check instance dictionary

a.__dict__

No x found.

Step 2

Check class attributes

A.x

Found → descriptor object D.

Step 3

Since it is a descriptor, Python calls:

D.__get__(descriptor, a, A)

Inside the method:

return 50

✅ Final Output

50

500 Days Python Coding Challenges with Explanation

Read More

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

 

Code Explanation:

🔹 1️⃣ Defining Descriptor Class D

class D:

A class named D is created.

This class will act as a descriptor.

🔹 2️⃣ Defining the __get__ Method

def __get__(self, obj, objtype):

    return 100

This method runs when the attribute is accessed.

Parameters:

self → descriptor object

obj → instance accessing the attribute (a)

objtype → class of the instance (A)

Behavior:

return 100

So whenever the attribute is accessed, the value 100 is returned.

🔹 3️⃣ Defining the __set__ Method

def __set__(self, obj, value):

    obj.__dict__['x'] = value

This method runs when the attribute is assigned.

Example:

a.x = 5

Execution:

obj.__dict__['x'] = value

So internally Python stores:

a.__dict__['x'] = 5

🔹 4️⃣ Defining Class A

class A:

A class named A is created.

🔹 5️⃣ Assigning Descriptor to Class Attribute

x = D()

Here:

An instance of D is assigned to x.

Internally:

A.x → descriptor object

So x is now controlled by the descriptor D.

🔹 6️⃣ Creating an Object

a = A()

An instance a of class A is created.

Initially:

a.__dict__ = {}

🔹 7️⃣ Assigning Value to a.x

a.x = 5

Python sees that x is a descriptor with __set__.

So it calls:

D.__set__(descriptor, a, 5)

Inside the method:

a.__dict__['x'] = 5

Now:

a.__dict__ = {'x': 5}

🔹 8️⃣ Accessing a.x

print(a.x)

Now Python performs attribute lookup.

Lookup order:

1️⃣ Data descriptor

Since x is a data descriptor, Python calls:

D.__get__(descriptor, a, A)

Inside __get__:

return 100

🔹 9️⃣ Instance Dictionary Ignored

Even though:

a.__dict__['x'] = 5

Python ignores it because:

⚠ Data descriptors take priority over instance attributes.

✅ Final Output

100

400 Days Python Coding Challenges with Explanation

Read More

🔻 Day 30: Funnel Chart in Python

 

🔻 Day 30: Funnel Chart in Python

🔹 What is a Funnel Chart?

A Funnel Chart visualizes a process where data moves through stages, typically showing decrease at each step.

It’s called a funnel because the shape narrows as values drop.

---

🔹 When Should You Use It?

Use a funnel chart when:

• Showing conversion stages

• Tracking sales pipeline

• Visualizing process drop-offs

• Analyzing user journey steps

---

🔹 Example Scenario

Website Conversion Funnel:

1. Website Visitors

2. Product Views

3. Add to Cart

4. Purchases

Each stage usually has fewer users than the previous one.

---

🔹 Key Idea Behind It

👉 Top stage = largest value
👉 Each next stage = reduced value
👉 Highlights where drop-offs happen

---

🔹 Python Code (Funnel Chart using Plotly)

import plotly.graph_objects as go

stages = ["Visitors", "Product Views", "Add to Cart", "Purchases"]
values = [1000, 700, 400, 200]

fig = go.Figure(go.Funnel(
    y=stages,
    x=values
)) 

fig.update_layout(title="Website Conversion Funnel")

fig.show()

📌 Install Plotly if needed:

pip install plotly

---

🔹 Output Explanation

• Top section = maximum users

• Funnel narrows at each stage

• Visually shows conversion drop

• Interactive hover details

---

🔹 Funnel Chart vs Bar Chart

Aspect	Funnel Chart	Bar Chart
Process stages	Excellent	Good
Drop-off clarity	Very High	Medium
Storytelling	Strong	Neutral
Business analytics	Ideal	Useful

---

🔹 Key Takeaways

• Perfect for sales & marketing analysis

• Quickly identifies bottlenecks

• Best for sequential processes

• Very popular in business dashboards

Read More

🌞 Day 29: Sunburst Chart in Python

 

🌞 Day 29: Sunburst Chart in Python

🔹 What is a Sunburst Chart?

A Sunburst Chart is a circular hierarchical visualization where:

• Inner rings represent parent categories

• Outer rings represent child categories

• Each segment’s size shows its proportion

Think of it as a radial treemap.

---

🔹 When Should You Use It?

Use a sunburst chart when:

• Your data is hierarchical

• You want to show part-to-whole at multiple levels

• Structure is more important than exact values

Avoid it for precise numeric comparison.

---

🔹 Example Scenario

• Company → Department → Team performance

• Website → Section → Page views

• Product → Category → Sub-category sales

---

🔹 Key Idea Behind It

👉 Center = top-level category
👉 Rings expand outward for deeper levels
👉 Angle/area represents contribution

---

🔹 Python Code (Sunburst Chart)

import plotly.express as px 
import pandas as pd 

data = pd.DataFrame({ 
 "category": ["Electronics", "Electronics", "Clothing", "Clothing"], 
"subcategory": ["Mobiles", "Laptops", "Men", "Women"],
 "value": [40, 30, 20, 10] }
)

fig = px.sunburst( 
data, path=['category', 'subcategory'], 
values='value', 
title='Sales Distribution by Category' 
) 
fig.show()

📌 Install Plotly if needed:

pip install plotly

---

🔹 Output Explanation

• Inner circle shows main categories

• Outer ring breaks them into subcategories

• Larger segments indicate higher contribution

• Interactive (hover & zoom)

---

🔹 Sunburst vs Treemap

Aspect	Sunburst	Treemap
Shape	Circular	Rectangular
Hierarchy clarity	High	Medium
Space efficiency	Medium	High
Visual appeal	High	Medium

---

🔹 Key Takeaways

• Best for hierarchical storytelling

• Interactive charts work best

• Avoid too many levels

• Great for dashboards & reports

Read More

 🚀 Day 3/150 – Subtract Two Numbers in Python

Let’s explore several methods.

---

1️⃣ Basic Subtraction (Direct Method)

The simplest way to subtract two numbers is by using the - operator.

a = 10 b = 5 result = a - b print(result)

2️⃣ Taking User Input

In real programs, numbers often come from user input rather than being predefined.

a = int(input("Enter first number: ")) b = int(input("Enter second number: ")) print("Difference:", a - b)

Here we use input() to take values from the user and int() to convert them into integers.

3️⃣ Using a Function

Functions help make code reusable and organized.

def subtract(x, y): return x - y print(subtract(10, 5))

The function subtract() takes two parameters and returns their difference.

4️⃣ Using a Lambda Function (One-Line Function)

A lambda function is a small anonymous function written in a single line.

subtract = lambda x, y: x - y print(subtract(10, 5))

Lambda functions are useful when you need a short, temporary function.

5️⃣ Using the operator Module

Python also provides built-in modules that perform mathematical operations. 

import operator print(operator.sub(10, 5))

The operator.sub() function performs the same subtraction operation.

6️⃣ Using List and reduce()

Another approach is to store numbers in a list and apply a reduction operation.

from functools import reduce numbers = [10, 5] result = reduce(lambda x, y: x - y, numbers) print(result)


































reduce() applies the function cumulatively to the items in the list.

🎯 Conclusion

There are many ways to subtract numbers in Python. The most common method is using the - operator, but functions, lambda expressions, and built-in modules provide more flexibility in larger programs.

In this series, we explore multiple approaches so you can understand Python more deeply and write better code.

📌 Next in the series: Multiply Two Numbers in Python

Read More

 

📊 Day 40: Likert Scale Chart in Python

---

🔹 What is a Likert Scale Chart?

A Likert Scale Chart is used to show survey responses like:

• Strongly Agree

• Agree

• Neutral

• Disagree

• Strongly Disagree

It helps visualize opinions or satisfaction levels.

---

🔹 When Should You Use It?

Use a Likert chart when:

• Analyzing survey results

• Measuring customer satisfaction

• Collecting employee feedback

• Getting product reviews

---

🔹 Example Scenario

Survey Question:
"Are you satisfied with our service?"

Responses:

• Strongly Disagree → 5

• Disagree → 10

• Neutral → 15

• Agree → 40

• Strongly Agree → 30

---

🔹 Python Code (Horizontal Likert Chart – Plotly)

import plotly.graph_objects as go

categories = ["Strongly Disagree", "Disagree", "Neutral", "Agree", "Strongly Agree"] 
values = [5, 10, 15, 40, 30] 

fig = go.Figure() 
fig.add_trace(go.Bar(
    y=["Customer Satisfaction"] * len(categories),
    x=values,
    orientation='h',
    text=categories,
    hoverinfo='text+x',
  marker=dict(color=["#BC6C25", "#DDA15E", "#E9C46A", "#90BE6D", "#2A9D8F"])
))

fig.update_layout(
 title="Customer Satisfaction Survey",
    barmode='stack',
    paper_bgcolor="#FAF9F6",
    plot_bgcolor="#FAF9F6", 
    xaxis_title="Number of Responses", 
    showlegend=False, 
    width=800,
    height=300
)

fig.show()

📌 Install if needed:

pip install plotly

---

🔹 Output Explanation (Beginner Friendly)

• Each color represents a response type.

• The length of each section shows how many people selected that option.

• Green shades usually mean positive responses.

• Brown/orange shades represent negative responses.

👉 You can quickly see if most people are satisfied or not.
👉 In this example, most responses are positive (Agree + Strongly Agree).

---

🔹 Why Likert Charts Are Useful

✅ Easy to understand
✅ Great for survey reports
✅ Perfect for dashboards
✅ Visually shows overall sentiment

Read More

Python Coding Challenge - Question with Answer (ID -190326)

 

Explanation:

1. List Initialization

lst = [1, 2, 3, 4]

A list named lst is created.

It contains 4 elements: 1, 2, 3, 4.

🔹 2. For Loop Setup

for i in range(len(lst)):

len(lst) gives the length of the list → 4.

range(4) generates numbers: 0, 1, 2, 3.

The loop runs 4 times with i as the index:

First iteration → i = 0

Second → i = 1

Third → i = 2

Fourth → i = 3

🔹 3. Updating List Elements

lst[i] += i

This means:

👉 lst[i] = lst[i] + i

Let’s see each iteration:

Iteration i Original lst[i] Calculation New Value

1 0 1 1 + 0 1

2 1 2 2 + 1 3

3 2 3 3 + 2 5

4 3 4 4 + 3 7

🔹 4. Final List After Loop

After all updates:

lst = [1, 3, 5, 7]

🔹 5. Printing the Result

print(lst)

Outputs:

[1, 3, 5, 7]

✅ Final Output

[1, 3, 5, 7]

Book: Python for Cybersecurity

Read More

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

 

Code Explanation:

1️⃣ Importing the Module

import threading

Explanation

Imports Python’s threading module.

Used to create and manage threads.

2️⃣ Defining the Function

def task():

Explanation

A function named task is defined.

This function will be executed inside a thread.

3️⃣ Function Body

print("X")

Explanation

When the thread runs, it prints:

X

4️⃣ Creating the Thread

t = threading.Thread(target=task)

Explanation

A thread object t is created.

target=task → thread will execute the task() function.

Thread is created but not started yet.

5️⃣ Starting the Thread

t.start()

Explanation

Starts the thread.

The thread executes task() and prints:

X

6️⃣ Waiting for Thread Completion

t.join()

Explanation

join() makes the main program wait until thread finishes.

Ensures that "X" is printed before moving forward.

7️⃣ Starting the Thread Again (ERROR)

t.start()

Explanation

This tries to start the same thread again.

❌ In Python, a thread can be started only once.

Once a thread finishes execution, it cannot be restarted.

❌ Runtime Error

RuntimeError: threads can only be started once

900 Days Python Coding Challenges with Explanation

Read More

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

 

Code Explanation:

1️⃣ Importing the Module

import threading

Explanation

Imports the threading module.

Enables creation and management of multiple threads.

2️⃣ Creating an Empty List

threads = []

Explanation

A list named threads is created.

It will store all thread objects so we can later wait for them using join().

3️⃣ Starting the Loop

for i in range(3):

Explanation

Loop runs 3 times.

Values of i:

0, 1, 2

4️⃣ Creating the Thread (Important)

t = threading.Thread(target=lambda: print(i))

Explanation

A new thread is created.

target=lambda: print(i) means:

Each thread will execute a lambda function that prints i.

⚠️ Critical Concept: Late Binding

The lambda does NOT capture the value of i at that moment.

Instead, it captures the reference to variable i.

By the time threads execute, loop has finished → i = 2.

👉 So all threads will use the same final value of i.

5️⃣ Storing the Thread

threads.append(t)

Explanation

Thread is added to the list.

This helps later to join all threads.

6️⃣ Starting the Thread

t.start()

Explanation

Starts execution of the thread.

The lambda function will run concurrently.

7️⃣ Joining All Threads

for t in threads:

    t.join()

Explanation

Ensures the main program waits for all threads to finish.

Prevents premature program exit.

📤 Final Output

2

2

2

900 Days Python Coding Challenges with Explanation

Read More

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

 

 Code Explanation:

1. Importing the Module

import threading

🔍 Explanation:

Imports Python’s built-in threading module

This module allows you to run multiple functions concurrently

📌 2. Defining the Task Function

def task():

    print("A")

🔍 Explanation:

A function named task is created

It simply prints "A"

This function will run inside a separate thread

📌 3. Creating a Thread

t = threading.Thread(target=task)

🔍 Explanation:

Creates a new thread object t

target=task means:

👉 “Run the task function inside this thread”

📌 4. Starting the Thread

t.start()

🔍 Explanation:

Starts the thread execution

The task() function begins running in parallel

Now:

Main program continues

Thread runs independently

📌 5. Main Thread Execution

print("B")

🔍 Explanation:

This runs in the main thread

Prints "B"

Possible outputs:

A

B

900 Days Python Coding Challenges with Explanation

Read More

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

 

Code Explanation:

1️⃣ Importing the Module

import threading

Explanation

Imports Python’s threading module.

This module allows execution of multiple threads simultaneously.

2️⃣ Defining the Function

def task(n):

Explanation

A function named task is defined.

It takes one argument n.

Each thread will call this function with a different value.

3️⃣ Printing the Value

print(n)

Explanation

This prints the value passed to the function.

Each thread will print its own number.

4️⃣ Loop Creation

for i in range(3):

Explanation

Loop runs 3 times.

Values of i will be:

0, 1, 2

5️⃣ Creating and Starting Threads

threading.Thread(target=task, args=(i)).start()

Explanation (VERY IMPORTANT ⚠️)

✔ Thread Creation

threading.Thread(...) creates a new thread.

target=task → thread will run task() function.

❌ Mistake in Arguments

args=(i) is NOT a tuple.

Python treats (i) as just an integer, not a tuple.

👉 Correct tuple should be:

args=(i,)

⚠️ What Happens Due to Mistake?

Thread expects arguments as an iterable (tuple/list).

But (i) is an int, not iterable.

So Python raises an error.

❌ Runtime Error

TypeError: 'int' object is not iterable

Final Output:

Error

400 Days Python Coding Challenges with Explanation

Read More

Python Coding Challenge - Question with Answer (ID -180326)

 

Code Explanation:

🔹 1. Creating a Tuple

t = (1, 2, 3, 4)

A tuple named t is created.

It contains 4 elements: 1, 2, 3, 4.

Tuples are immutable → you cannot change their values directly.

🔹 2. Starting a Loop

for i in t:

This is a for loop that iterates over each element of the tuple.

On each iteration, i takes one value from t.

Iteration steps:

1st → i = 1

2nd → i = 2

3rd → i = 3

4th → i = 4

🔹 3. Modifying the Loop Variable

i += 10

This adds 10 to the current value of i.

But important point:

It does NOT change the tuple

It only changes the temporary variable i

So values become:

1 → 11

2 → 12

3 → 13

4 → 14

But these values are not stored anywhere.

🔹 4. Printing the Tuple

print(t)

This prints the original tuple.

Since tuples are immutable and unchanged, output remains the same.

✅ Final Output

(1, 2, 3, 4)

Python for Civil Engineering: Concepts, Computation & Real-world Applications

Read More

Python Coding Challenge - Question with Answer (ID -170326)

 

Explanation:

🔸 1. List Creation

clcoding = [1, 2, 3]

A list named clcoding is created.

It contains three elements: 1, 2, and 3.

Lists in Python are mutable, meaning they can be changed.

👉 After this line:

clcoding = [1, 2, 3]

🔸 2. Using append() Method

clcoding.append(4)

The append() method adds an element to the end of the list.

Here, 4 is added.

👉 After execution:

clcoding = [1, 2, 3, 4]

🔸 3. Important Concept: Return Value of append()

The append() method does NOT return the updated list.

It modifies the list in place.

It returns None.

🔸 4. Print Statement

print(clcoding.append(4))

First, clcoding.append(4) is executed → list becomes [1, 2, 3, 4]

Then print() prints the return value of append(), which is:

None

🔸 5. Final Output

None

Python for Cybersecurity

Read More

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

 

Code Explanation:

1️⃣ Importing the Threading Module

import threading

Explanation

This line imports Python’s threading module.

The module allows a program to run multiple threads (tasks) concurrently.

Threads help perform operations simultaneously within the same process.

2️⃣ Creating a Global Variable

x = 5

Explanation

A variable x is created with the value 5.

This variable is defined outside any function, so it is a global variable.

Global variables can be accessed by all parts of the program.

3️⃣ Defining the Function

def change():

Explanation

A function named change is defined.

This function will later be executed inside a separate thread.

4️⃣ Declaring a Global Variable Inside the Function

global x

Explanation

This tells Python that the variable x inside the function refers to the global variable.

Without global, Python would treat x as a local variable.

5️⃣ Changing the Value of the Variable

x = 10

Explanation

The function changes the value of global variable x from 5 to 10.

6️⃣ Creating a Thread

t = threading.Thread(target=change)

Explanation

A Thread object is created and stored in variable t.

target=change means the thread will run the change() function.

At this stage, the thread is created but not started.

7️⃣ Starting the Thread

t.start()

Explanation

This starts the thread.

The thread begins executing the change() function.

Inside the thread, the value of x becomes 10.

8️⃣ Waiting for the Thread to Finish

t.join()

Explanation

join() tells the main thread to wait until the thread t completes its work.

This ensures that the value of x is updated before printing.

9️⃣ Printing the Value

print(x)

Explanation

The program prints the value of x.

Since the thread changed x to 10, the printed value is:

10

📤 Final Output

10

900 Days Python Coding Challenges with Explanation

Read More

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

 

Code Explanation:

1️⃣ Importing Module

import threading

Explanation

This line imports the threading module.

The threading module allows Python to run multiple threads (tasks) concurrently.

Threads help execute parts of a program simultaneously.

2️⃣ Defining the Function

def task():

Explanation

A function named task is created.

This function will be executed inside a separate thread.

3️⃣ Loop Inside the Function

for i in range(2):

Explanation

A loop runs 2 times.

range(2) generates numbers:

0, 1

4️⃣ Printing Values

print(i)

Explanation

Each iteration prints the value of i.

So the function prints:

0

1

5️⃣ Creating a Thread

t = threading.Thread(target=task)

Explanation

A Thread object is created.

target=task means the thread will execute the task() function.

At this point, the thread is created but not started yet.

6️⃣ Starting the Thread

t.start()

Explanation

This starts the thread.

The thread begins executing the task() function.

The function prints:

0

1

7️⃣ Waiting for Thread to Finish

t.join()

Explanation

join() tells the main program to wait until the thread finishes.

Without join(), the program might print "Done" before the thread finishes.

8️⃣ Printing Final Statement

print("Done")

Explanation

After the thread finishes, the main program prints:

Done

📤 Final Output

0

1

Done

400 Days Python Coding Challenges with Explanation

Read More