🔻 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

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

 

Explanation:

1️⃣ Assigning None to x

x = None

This line creates a variable x.

It assigns the value None to x.

None in Python represents no value / null.

The type of None is NoneType.

👉 After this line:

x → None

2️⃣ Assigning 0 to y

y = 0

This line creates a variable y.

It assigns the integer value 0 to y.

0 is a number (integer).

👉 After this line:

y → 0

3️⃣ Printing the Comparison

print(x is y, x == y)

This line prints the result of two comparisons.

x is y

x == y

4️⃣ x is y (Identity Comparison)

The is operator checks whether two variables refer to the same object in memory.

Here:

x → None

y → 0

They are different objects, so:

x is y → False

5️⃣ x == y (Value Comparison)

The == operator checks whether the values are equal.

Here:

None != 0

So:

x == y → False

6️⃣ Final Output

The print statement becomes:

False False

Book: 100 Python Challenges to Think Like a Developer

Read More

Not Just Data: How To Deliver Continuous Enterprise Data

 

Introduction

In today’s digital world, organizations generate and collect enormous amounts of data from various sources such as applications, sensors, customer interactions, and business operations. However, simply collecting data is not enough. The real challenge lies in delivering accurate, timely, and usable data to the right people when they need it.

The book “Not Just Data: How To Deliver Continuous Enterprise Data” explores how organizations can build systems that provide reliable and continuously updated enterprise data. Written in the form of a management-style story, the book explains the challenges faced by enterprise data teams and offers practical insights into building modern data pipelines that support analytics, artificial intelligence, and data-driven decision-making.

---

The Concept of Continuous Enterprise Data

One of the central ideas in the book is the concept of continuous enterprise data. This refers to high-quality, up-to-date data that is available across the organization whenever it is needed. Instead of relying on static reports or delayed data processing, continuous data delivery ensures that business users always have access to current information.

A continuous enterprise data pipeline typically focuses on three key goals:

• Delivering up-to-date information from multiple data sources

• Ensuring that the data is reliable and high quality

• Providing data to the right users at the right time

This approach enables organizations to make faster and more informed decisions.

---

Why Continuous Data Delivery Matters

Modern enterprises rely heavily on data for analytics, automation, and artificial intelligence. Without a reliable data infrastructure, these systems cannot function effectively.

Continuous data delivery helps organizations:

• Support real-time analytics and decision making

• Improve business intelligence and reporting

• Enable AI and machine learning systems to operate effectively

• Provide consistent and trusted data across teams

Organizations increasingly adopt approaches such as DataOps to streamline the flow of data and ensure that data pipelines operate efficiently and reliably.

---

A Story-Based Learning Approach

One of the unique aspects of the book is that it is written as a management novel rather than a traditional technical manual. The story follows a team responsible for building and evolving an enterprise data system inside a large organization.

Through the challenges and experiences of the characters, readers learn about:

• Data pipeline design

• Organizational collaboration between data teams

• The importance of data quality and governance

• Strategies for improving enterprise data systems

This narrative style makes complex data engineering concepts easier to understand for both technical and non-technical readers.

---

Enterprise Data Ecosystems

The book also highlights the importance of building a complete enterprise data ecosystem. Data should not exist in isolated systems or departmental silos. Instead, organizations must create integrated platforms where data from multiple sources can be accessed and analyzed efficiently.

Key elements of a strong enterprise data ecosystem include:

• Scalable data architectures

• Integration of multiple data sources

• Standardized data formats and governance policies

• Collaboration between data engineers, analysts, and business stakeholders

Such systems allow organizations to turn raw data into meaningful insights that support business goals.

---

Data Architecture and Data Strategy

Building continuous enterprise data systems requires a strong data architecture. Data architecture acts as the blueprint for how data is collected, stored, integrated, and accessed across the organization.

A well-designed architecture helps organizations:

• Eliminate data silos

• Improve data quality and reliability

• Scale data infrastructure as the business grows

• Support advanced analytics and AI applications

Enterprises that invest in modern data architecture can transform fragmented data environments into unified, intelligent systems that drive innovation.

---

Lessons for Data Leaders and Teams

The book offers practical lessons for data professionals, managers, and business leaders who want to improve their organization’s data capabilities.

Some of the key lessons include:

• Data systems must evolve continuously to meet changing business needs.

• Collaboration between technical teams and business stakeholders is essential.

• Data quality and reliability are as important as data volume.

• Organizations must treat data as a strategic asset.

These insights help organizations move beyond traditional data warehouses and build modern, flexible data infrastructures.

---

Hard Copy: Not Just Data: How To Deliver Continuous Enterprise Data

Kindle: Not Just Data: How To Deliver Continuous Enterprise Data

Conclusion

Not Just Data: How To Deliver Continuous Enterprise Data provides a compelling exploration of how organizations can transform their data strategies to support modern business needs. By combining storytelling with practical insights, the book explains how continuous data delivery systems can empower enterprises to make better decisions, support artificial intelligence, and unlock the full value of their data.

In an era where data drives innovation and competitive advantage, organizations that successfully implement continuous enterprise data systems will be better positioned to adapt, grow, and thrive in the digital economy.

Read More