Transforming Data into Business Insights
Why Python for Business Data Visualization?
Python has become the leading tool for business data visualization and analytics for several important reasons:
Comparison with Excel:
While Excel is excellent for quick analyses and familiar to most business users, Python offers advantages for serious data work:
Installing Python and VSCode
Step 1: Installing Python
Visit python.org and download the latest version of Python (3.10 or higher recommended):
After installation, verify by opening your command prompt (Windows) or terminal (Mac) and typing:
python --versionYou should see something like “Python 3.11.5”
Step 2: Installing VSCode
VSCode (Visual Studio Code) is a free, powerful code editor developed by Microsoft:
Why VSCode for data visualization?
Understanding the VSCode Interface
When you first open VSCode, you’ll see several key areas:
Left Sidebar (Activity Bar):
Center Area (Editor):
Bottom Panel:
Getting Started Workflow:
Setting Up Python in VSCode
Installing the Python Extension:
This extension provides:
Selecting Python Interpreter:
After installing the extension:
Ctrl+Shift+P (Windows) or Cmd+Shift+P (Mac) to open Command PalettePackage Management with pip
Pip is Python’s package manager - think of it as an app store for Python libraries. It comes pre-installed with Python.
Understanding Packages:
Installing Packages:
Open the terminal in VSCode (View → Terminal or Ctrl+` ) and install each package:
pip install pandas
pip install matplotlib
pip install seaborn
pip install plotlyWhat’s happening behind the scenes:
Troubleshooting Tips:
Your First Python Program
Create a new file named YourName_Hello.py:
# This is a comment - Python ignores this line
# Comments help explain what your code does
print("Welcome to Data Visualization!")
print("Python is ready to analyze business data")Welcome to Data Visualization!
Python is ready to analyze business dataOutput:
Welcome to Data Visualization!
Python is ready to analyze business dataHow to Run:
What print() does:
The print() function displays text or numbers in the terminal. Think of it as Python talking to you - showing results, messages, or data.
Verifying Package Installation
Create YourName_Verification.py:
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
print(" All packages imported successfully!")
print("Pandas version:", pd.__version__)
print("Your data visualization environment is ready!") All packages imported successfully!
Pandas version: 2.2.3
Your data visualization environment is ready!Output:
All packages imported successfully!
Pandas version: 2.3.2
Your data visualization environment is ready!Understanding imports:
import loads a package so you can use its featuresas pd creates a short nickname (alias) to save typingpd, matplotlib.pyplot is plt, seaborn is snsLab 1: Setting Up Your Data Visualization Environment
Objective: Successfully install and configure your complete Python environment for data visualization work.
Pre-Lab Checklist:
Tasks:
Task 1: Software Installation (30 minutes)
Task 2: Create Project Structure (10 minutes)
On your computer, create a folder structure:
Documents/
└── DataViz_Course/
├── Module1/
├── Module2/
├── Module3/
└── Module4/Open the DataViz_Course folder in VSCode
Navigate to the Module1 folder in VSCode Explorer
Task 3: Install Required Packages (20 minutes)
Task 4: Create Your First Python Program (15 minutes)
Lab01_YourName_Setup.pyTask 5: Verify Installation (10 minutes)
Lab01_YourName_Verification.pyDeliverables:
Success Criteria:
Variables and Data Types - The Foundation of Data
Understanding Variables:
In business, we work with different types of information: company names, revenue figures, percentages, and yes/no decisions. Python uses variables to store this information.
Think of a variable as a labeled box where you store data: - The label is the variable name (you choose this) - The contents are the value (the actual data) - The type determines what kind of data you can store
The Four Essential Data Types:
1. Strings (Text Data) Used for: names, descriptions, categories, addresses
company_name = "TechCorp Industries"
product_category = "Electronics"
customer_feedback = "Excellent service!"Rules for strings: - Always enclosed in quotes (single ’ or double “) - Can contain letters, numbers, spaces, punctuation - Case-sensitive:”Sales” and “sales” are different
2. Integers (Whole Numbers) Used for: counts, quantities, years, IDs
units_sold = 1500
employee_count = 247
fiscal_year = 20243. Floats (Decimal Numbers) Used for: money, percentages, measurements, rates
price = 299.99
profit_margin = 0.23
interest_rate = 5.754. Booleans (True/False) Used for: status flags, conditions, yes/no decisions
is_profitable = True
target_achieved = False
premium_customer = TrueWhy Data Types Matter:
Python treats different types differently:
100 + 50 = 150"Hello" + " World" = "Hello World""Sales: " + 1000 causes an errorMathematical Operations for Business Calculations
Basic Arithmetic:
Python uses standard mathematical operators, just like a calculator:
# Quarterly Revenue Analysis
q1_revenue = 250000
q2_revenue = 280000
# Addition: Calculate total
total_revenue = q1_revenue + q2_revenue # 530000
# Subtraction: Calculate growth
revenue_growth = q2_revenue - q1_revenue # 30000
# Multiplication: Calculate with tax
revenue_with_tax = q2_revenue * 1.07 # 299600
# Division: Calculate average
average_revenue = total_revenue / 2 # 265000
# Exponentiation: Calculate compound growth
future_value = 100000 * (1.05)**3 # $115,762.50Order of Operations:
Python follows standard mathematical rules (PEMDAS):
(2 + 3)2**3* and /+ and -Example: 2 + 3 * 4 equals 14, not 20 To get 20: (2 + 3) * 4
Practical Business Example:
# Calculate total cost with discount and tax
original_price = 1000
discount_rate = 0.15
tax_rate = 0.08
discounted_price = original_price * (1 - discount_rate) # 850
final_price = discounted_price * (1 + tax_rate) # 918Working with Strings in Business Context
String Formatting for Professional Output:
The f-string (formatted string) is your tool for creating professional, readable output:
company = "TechCorp"
revenue = 1500000
growth = 0.15
# Old way (hard to read):
print("Company: " + company + " Revenue: " + str(revenue))
# Modern way (f-string):
print(f"{company} generated ${revenue:,} in revenue")
# Output: TechCorp generated $1,500,000 in revenue
print(f"Growth rate: {growth:.1%}")
# Output: Growth rate: 15.0%Company: TechCorp Revenue: 1500000
TechCorp generated $1,500,000 in revenue
Growth rate: 15.0%Output:
Company: TechCorp Revenue: 1500000
TechCorp generated $1,500,000 in revenue
Growth rate: 15.0%Formatting Options:
:, adds thousand separators: 1500000 → 1,500,000:.2f shows 2 decimal places: 3.14159 → 3.14:.1% shows as percentage: 0.15 → 15.0%Lists - Managing Multiple Data Points
Understanding Lists:
In business, we rarely deal with single data points. We have monthly sales, multiple products, various regions. Lists let us store related data together.
A list is an ordered collection of items, like a spreadsheet column:
monthly_sales = [45000, 52000, 48000, 61000, 58000, 63000]Why Lists are Powerful:
List Indexing:
Python uses “zero-based” indexing - counting starts at 0:
months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
# Accessing items:
first_month = months[0] # "Jan" (position 0)
third_month = months[2] # "Mar" (position 2)
last_month = months[-1] # "Jun" (negative counts from end)Built-in List Functions:
Python provides functions to analyze lists quickly:
sales = [45000, 52000, 48000, 61000, 58000, 63000]
total_sales = sum(sales) # 327000
average_sales = sum(sales) / len(sales) # 54500
highest_sales = max(sales) # 63000
lowest_sales = min(sales) # 45000
number_of_months = len(sales) # 6Conditional Statements - Making Decisions
The Business Logic of Programming:
Businesses make decisions based on conditions: “If sales exceed target, pay bonus.” Python uses if statements for this logic.
Basic Structure:
if condition:
# do something when condition is TrueReal Business Example:
actual_sales = 85000
target = 80000
if actual_sales >= target:
print("Congratulations! Target achieved!")
bonus = 5000
else:
print("Target not met this month")
bonus = 0Congratulations! Target achieved!Output:
Congratulations! Target achieved!Multiple Conditions:
score = 78
if score >= 90:
grade = "A - Excellent"
elif score >= 80:
grade = "B - Good"
elif score >= 70:
grade = "C - Satisfactory"
else:
grade = "D - Needs Improvement"The elif is short for “else if” - Python checks conditions from top to bottom - Executes the first True condition - Skips the rest
Loops - Processing Repetitive Data
Why Loops Matter:
Imagine you have 50 products, and need to calculate profit for each. You could write the same code 50 times, or use a loop to repeat the logic automatically.
For Loops - Processing Each Item:
products = ["Laptop", "Mouse", "Keyboard", "Monitor"]
prices = [1200, 25, 75, 350]
print("Product Price List:")
print("-" * 30)
for i in range(len(products)):
print(f"{products[i]}: ${prices[i]}")Product Price List:
------------------------------
Laptop: $1200
Mouse: $25
Keyboard: $75
Monitor: $350Output:
Product Price List:
------------------------------
Laptop: $1200
Mouse: $25
Keyboard: $75
Monitor: $350Understanding range():
range(4) produces: 0, 1, 2, 3range(len(products)) adjusts to list size automaticallyi is the loop variable that changes each iterationSimpler Loop Pattern:
sales = [45000, 52000, 48000, 61000]
total = 0
for sale in sales:
total = total + sale # or: total += sale
average = total / len(sales)When to Use Loops:
Functions - Reusable Business Logic
The Problem Functions Solve:
Suppose you calculate profit margins often. Instead of rewriting the formula repeatedly, write it once as a function, then reuse it.
Creating a Function:
def calculate_profit_margin(revenue, cost):
profit = revenue - cost
margin = (profit / revenue) * 100
return margin
# Using the function:
margin1 = calculate_profit_margin(150000, 98000) # 34.67%
margin2 = calculate_profit_margin(200000, 145000) # 27.5%
margin3 = calculate_profit_margin(75000, 52000) # 30.67%Function Anatomy:
def keyword starts the function definition: starts the function bodyreturn statement (the function’s output)Benefits of Functions:
Lab 2: Python Programming for Business Analytics
Objective: Apply Python fundamentals to solve real business calculation problems.
Scenario: You are a business analyst at “RetailMax,” a regional retail chain. Your manager has asked you to analyze recent sales data and create automated calculation tools.
Tasks:
Task 1: Semi-Annual Sales Analysis (25 points)
Create a file: Lab02_YourName_SalesAnalysis.py
You have six months of sales data for your store:
Write a program that:
Expected Output Format:
RetailMax - Semi-Annual Sales Report
=====================================
Total Sales: $327,000.00
Average Monthly Sales: $54,500.00
Highest Month: $63,000.00
Lowest Month: $45,000.00
Sales Range: $18,000.00Task 2: Product Performance Report (25 points)
Create a file: Lab02_YourName_ProductReport.py
You need to analyze five products:
Write a program that:
Hint for percentage: (individual_sale / total_sales) * 100
Task 3: Employee Commission Calculator (25 points)
Create a file: Lab02_YourName_Commission.py
Write a function called calculate_commission() that:
Then test your function with these salespeople:
For each person, print: name, sales amount, commission rate, and commission earned.
Task 4: Quarterly Growth Analysis (25 points)
Create a file: Lab02_YourName_GrowthAnalysis.py
You have quarterly revenue data:
Write a program that:
((current_quarter - previous_quarter) / previous_quarter) * 100Deliverables:
Grading Rubric:
Tips for Success:
Dictionaries - Structured Data Storage
Moving Beyond Simple Lists:
Lists are great for single types of data (just sales numbers, just names). But business data is more complex - each product has a name, price, category, and quantity sold. We need a way to keep related information together.
Understanding Dictionaries:
A dictionary stores data in key-value pairs, like a real dictionary stores word-definition pairs:
Think of it as a digital form where keys are the field labels and values are what you fill in:
employee = {
"name": "Sarah Johnson",
"department": "Marketing",
"salary": 72000,
"years_employed": 4,
"is_manager": False
}
# Accessing information:
print(employee["name"]) # Sarah Johnson
print(employee["salary"]) # 72000Sarah Johnson
72000Output:
Sarah Johnson
72000Why Dictionaries Matter:
Working with Multiple Records:
employees = [
{"name": "Sarah", "dept": "Marketing", "salary": 72000},
{"name": "Mike", "dept": "Sales", "salary": 68000},
{"name": "Jennifer", "dept": "IT", "salary": 85000}
]
# Accessing specific data:
first_employee = employees[0]
first_name = employees[0]["name"] # SarahThe Limitation:
While dictionaries and lists work for small datasets, they become cumbersome with real business data. This is where Pandas comes in.
Introduction to Pandas DataFrames
What is Pandas?
Pandas is Python’s data analysis library, and the DataFrame is its core tool. Think of a DataFrame as Excel inside Python:
Why Pandas for Business Analysis?
Creating Your First DataFrame:
import pandas as pd
# Business data: product sales
data = {
"Product": ["Laptop", "Mouse", "Keyboard", "Monitor", "Headset"],
"Price": [1200, 25, 75, 350, 80],
"Units_Sold": [150, 500, 320, 200, 280],
"Category": ["Electronics", "Accessories", "Accessories",
"Electronics", "Accessories"]
}
df = pd.DataFrame(data)
print(df) Product Price Units_Sold Category
0 Laptop 1200 150 Electronics
1 Mouse 25 500 Accessories
2 Keyboard 75 320 Accessories
3 Monitor 350 200 Electronics
4 Headset 80 280 AccessoriesOutput:
Product Price Units_Sold Category
0 Laptop 1200 150 Electronics
1 Mouse 25 500 Accessories
2 Keyboard 75 320 Accessories
3 Monitor 350 200 Electronics
4 Headset 80 280 AccessoriesUnderstanding the Structure:
DataFrame Output:
Product Price Units_Sold Category
0 Laptop 1200 150 Electronics
1 Mouse 25 500 Accessories
2 Keyboard 75 320 Accessories
3 Monitor 350 200 Electronics
4 Headset 80 280 AccessoriesExploring DataFrames - Essential Commands
Getting to Know Your Data:
Before analyzing, you must understand what you’re working with. Pandas provides powerful exploration tools:
1. head() and tail() - Preview Data
df.head() # Shows first 5 rows (default)
df.head(3) # Shows first 3 rows
df.tail() # Shows last 5 rows| Product | Price | Units_Sold | Category | |
|---|---|---|---|---|
| 0 | Laptop | 1200 | 150 | Electronics |
| 1 | Mouse | 25 | 500 | Accessories |
| 2 | Keyboard | 75 | 320 | Accessories |
| 3 | Monitor | 350 | 200 | Electronics |
| 4 | Headset | 80 | 280 | Accessories |
Output:
Product Price Units_Sold Category
0 Laptop 1200 150 Electronics
1 Mouse 25 500 Accessories
2 Keyboard 75 320 Accessories
3 Monitor 350 200 Electronics
4 Headset 80 280 AccessoriesWhy this matters: Large datasets can’t be printed entirely. Head/tail gives you a quick look without overwhelming output.
2. info() - Data Structure Report
df.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Product 5 non-null object
1 Price 5 non-null int64
2 Units_Sold 5 non-null int64
3 Category 5 non-null object
dtypes: int64(2), object(2)
memory usage: 292.0+ bytesOutput:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Product 5 non-null object
1 Price 5 non-null int64
2 Units_Sold 5 non-null int64
3 Category 5 non-null object
dtypes: int64(2), object(2)
memory usage: 292.0+ bytesShows:
Business use: Verify data loaded correctly, check for missing values, confirm data types.
3. describe() - Statistical Summary
df.describe()| Price | Units_Sold | |
|---|---|---|
| count | 5.000000 | 5.000000 |
| mean | 346.000000 | 290.000000 |
| std | 494.107782 | 134.907376 |
| min | 25.000000 | 150.000000 |
| 25% | 75.000000 | 200.000000 |
| 50% | 80.000000 | 280.000000 |
| 75% | 350.000000 | 320.000000 |
| max | 1200.000000 | 500.000000 |
Output:
Price Units_Sold
count 5.000000 5.000000
mean 346.000000 290.000000
std 494.107782 134.907376
min 25.000000 150.000000
25% 75.000000 200.000000
50% 80.000000 280.000000
75% 350.000000 320.000000
max 1200.000000 500.000000For numeric columns, shows:
Business use: Quick overview of sales ranges, average prices, revenue distribution.
4. shape, columns, and dtypes
df.shape # (5, 4) means 5 rows, 4 columns
df.columns # List of column names
df.dtypes # Data type of each columnProduct object
Price int64
Units_Sold int64
Category object
dtype: objectOutput:
Product object
Price int64
Units_Sold int64
Category object
dtype: objectAdding Calculated Columns
Business Calculations in DataFrames:
One of Pandas’ most powerful features is creating new columns from existing ones:
# Calculate total revenue per product
df["Revenue"] = df["Price"] * df["Units_Sold"]What happens:
This is called vectorized operations - Pandas applies the operation to entire columns at once, making it fast and efficient.
Multiple Calculations:
df["Revenue"] = df["Price"] * df["Units_Sold"]
df["Revenue_Per_Unit"] = df["Revenue"] / df["Units_Sold"]
df["Price_Category"] = df["Price"] > 100 # True/False columnReading Data from Files
Real Business Data Sources:
In practice, you’ll rarely type data manually. Business data comes from:
Reading CSV Files:
# Basic CSV reading
sales_data = pd.read_csv("sales_report.csv")
# With options
sales_data = pd.read_csv("sales_report.csv",
encoding="utf-8", # Character encoding
thousands=",", # Handle 1,000 format
parse_dates=["Date"]) # Convert date columnsReading Excel Files:
financial_data = pd.read_excel("Q4_Report.xlsx")
# Specific sheet
financial_data = pd.read_excel("Annual_Report.xlsx",
sheet_name="Q4 Sales")Common Issues and Solutions:
encoding="latin-1" or encoding="ISO-8859-1"parse_dates=["Date_Column"]Accessing Data - Columns, Rows, and Cells
Selecting Columns:
There are two ways to select columns:
# Method 1: Single column (returns Series)
products = df["Product"]
# Method 2: Multiple columns (returns DataFrame)
subset = df[["Product", "Price", "Revenue"]]Important distinction:
[] with one name = Series (one column)[[]] with list of names = DataFrame (multiple columns)Selecting Rows:
Pandas offers two main methods:
iloc - Select by position (integer location):
first_row = df.iloc[0] # First row
first_three = df.iloc[0:3] # Rows 0, 1, 2
last_row = df.iloc[-1] # Last rowloc - Select by label:
row_zero = df.loc[0] # Row with index label 0
rows_range = df.loc[0:2] # Rows 0, 1, 2 (inclusive!)Key difference: iloc uses position (0-based), loc uses index labels.
Selecting Specific Cells:
# Get price of first product
price = df.iloc[0, 1] # Row 0, Column 1
price = df.loc[0, "Price"] # Row 0, "Price" columnFiltering Data - Answering Business Questions
The Power of Conditional Selection:
Filtering lets you answer questions like:
Basic Filtering:
# Products priced over $100
expensive = df[df["Price"] > 100]
# Electronics only
electronics = df[df["Category"] == "Electronics"]
# High-volume sales (more than 250 units)
high_volume = df[df["Units_Sold"] > 250]How it works:
df["Price"] > 100 creates a True/False columndf[True/False column] keeps only True rowsMultiple Conditions:
Use & (AND) and | (OR), with parentheses around each condition:
# Electronics AND expensive
premium = df[(df["Category"] == "Electronics") & (df["Price"] > 100)]
# Either high price OR high volume
important = df[(df["Price"] > 200) | (df["Units_Sold"] > 300)]Sorting and Grouping - Organizing Insights
Sorting for Rankings:
# Sort by revenue (lowest to highest)
df_sorted = df.sort_values("Revenue")
# Sort by revenue (highest to lowest)
df_sorted = df.sort_values("Revenue", ascending=False)
# Sort by multiple columns
df_sorted = df.sort_values(["Category", "Price"],
ascending=[True, False])Grouping for Category Analysis:
Grouping is like pivot tables in Excel - summarize data by categories:
# Total revenue by category
category_revenue = df.groupby("Category")["Revenue"].sum()
# Multiple statistics
summary = df.groupby("Category").agg({
"Revenue": "sum",
"Units_Sold": "sum",
"Price": "mean"
})What groupby does:
Business Application:
Lab 3: Working with Pandas DataFrames
Objective: Master Pandas fundamentals by analyzing real sales data and creating business reports.
Scenario: You work for “GlobalRetail Inc.,” a company with sales teams across four regions. Your manager needs a comprehensive analysis of H1 (first half year) sales performance.
Pre-Lab Setup:
Lab03_YourName_PandasAnalysis.pyimport pandas as pdTask 1: Create Sales DataFrame (15 points)
Create a DataFrame with the following information for five salespeople:
| Salesperson | Region | Q1_Sales | Q2_Sales |
|---|---|---|---|
| Alice Chen | North | 150000 | 165000 |
| Bob Martinez | South | 135000 | 142000 |
| Charlie Kim | East | 162000 | 178000 |
| Diana Lopez | West | 148000 | 155000 |
| Eve Johnson | North | 158000 | 171000 |
Requirements:
Task 2: Add Calculated Columns (20 points)
Add four new columns to your DataFrame:
Hint for Performance_Tier: You’ll need to use conditional logic. Look up pd.cut() or use multiple conditions with np.where().
Print the updated DataFrame with all columns.
Task 3: Data Exploration and Analysis (20 points)
Answer these questions using Pandas methods (print each answer clearly labeled):
idxmax())describe()Task 4: Filtering and Segmentation (20 points)
Create and print the following filtered datasets:
Task 5: Regional Analysis (25 points)
Use groupby() to create a regional summary:
Group by Region and calculate:
Print the regional summary table
Answer: Which region had the highest total sales? Which had the best average growth rate?
Sort the regional summary by Total_Sales (descending)
Bonus Task: CSV Operations (10 points)
Lab03_YourName_SalesData.csvdf_reloadedDeliverables:
Lab03_YourName_PandasAnalysis.pyLab03_YourName_SalesData.csvExpected Output Structure:
Your program should have clearly commented sections:
# ===== TASK 1: CREATE DATAFRAME =====
# (your code here)
# ===== TASK 2: ADD CALCULATED COLUMNS =====
# (your code here)
# ===== TASK 3: DATA EXPLORATION =====
# (your code here)
# etc.Grading Rubric:
Common Mistakes to Avoid:
& or | without parentheses in conditionsiloc and locThe Reality of Business Data
Why Data is Never Perfect:
In textbooks and tutorials, data is clean and ready to analyze. Real business data is messy:
The 80/20 Rule in Data Analysis:
Data professionals spend approximately 80% of their time cleaning data and only 20% on actual analysis. This isn’t inefficiency - it’s necessity. Garbage in, garbage out - analysis of dirty data produces unreliable results.
Types of Data Quality Issues:
Understanding Missing Data
Types of Missing Data:
Not all missing data is the same. Understanding WHY data is missing affects how you handle it:
1. Missing Completely at Random (MCAR)
2. Missing at Random (MAR)
3. Missing Not at Random (MNAR)
Detecting Missing Values in Pandas:
import pandas as pd
import numpy as np
# Create sample data with missing values
data = {
"Date": ["2024-01-15", "2024-01-16", None, "2024-01-18"],
"Product": ["Laptop", "Mouse", "Laptop", "Keyboard"],
"Sales": [1200, 25, 1200, None],
"Region": ["North", "South", "North", "South"]
}
df = pd.DataFrame(data)
# Check for missing values
print(df.isnull()) # True/False for each cell
print(df.isnull().sum()) # Count per column
print(df.info()) # Shows non-null counts Date Product Sales Region
0 False False False False
1 False False False False
2 True False False False
3 False False True False
Date 1
Product 0
Sales 1
Region 0
dtype: int64
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Date 3 non-null object
1 Product 4 non-null object
2 Sales 3 non-null float64
3 Region 4 non-null object
dtypes: float64(1), object(3)
memory usage: 260.0+ bytes
NoneOutput:
Date Product Sales Region
0 False False False False
1 False False False False
2 True False False False
3 False False True False
Date 1
Product 0
Sales 1
Region 0
dtype: int64
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Date 3 non-null object
1 Product 4 non-null object
2 Sales 3 non-null float64
3 Region 4 non-null object
dtypes: float64(1), object(3)
memory usage: 260.0+ bytes
NoneStrategies for Handling Missing Values:
Strategy 1: Deletion (when data is MCAR and abundant)
# Remove rows with ANY missing values
df_clean = df.dropna()
# Remove rows where specific column is missing
df_clean = df.dropna(subset=["Sales"])When to use: Dataset is large, few missing values, missingness is random.
Strategy 2: Fill with Statistical Measure
# Fill missing sales with average
mean_sales = df["Sales"].mean()
df["Sales"].fillna(mean_sales, inplace=True)
# Or median (better for skewed data)
median_sales = df["Sales"].median()
df["Sales"].fillna(median_sales, inplace=True)When to use: Numeric data, missingness is random, want to preserve dataset size.
Strategy 3: Fill with Placeholder
# Fill missing region with "Unknown"
df["Region"].fillna("Unknown", inplace=True)
# Fill missing dates with specific value
df["Date"].fillna("2024-01-17", inplace=True)When to use: Categorical data, want to flag missing as separate category.
Strategy 4: Forward/Backward Fill
# Copy previous value down
df["Region"].fillna(method="ffill", inplace=True)
# Copy next value up
df["Region"].fillna(method="bfill", inplace=True)When to use: Time series data where values change slowly.
Business Decision: The method you choose should be documented and justified. Different business contexts require different approaches.
Handling Duplicate Records
Why Duplicates Occur:
Detecting Duplicates:
# Check for completely duplicate rows
print(df.duplicated()) # True/False for each row
print(df.duplicated().sum()) # Count of duplicates
print(df[df.duplicated()]) # View duplicate rows
# Check for duplicates in specific column
print(df.duplicated(subset=["Product"]))0 False
1 False
2 False
3 False
dtype: bool
0
Empty DataFrame
Columns: [Date, Product, Sales, Region]
Index: []
0 False
1 False
2 True
3 False
dtype: boolOutput:
0 False
1 False
2 False
3 False
dtype: bool
0
Empty DataFrame
Columns: [Date, Product, Sales, Region]
Index: []Removing Duplicates:
# Remove duplicate rows (keeps first occurrence)
df_unique = df.drop_duplicates()
# Remove duplicates based on specific column
df_unique = df.drop_duplicates(subset=["Product"], keep="first")
# Options for 'keep':
# - "first": Keep first occurrence (default)
# - "last": Keep last occurrence
# - False: Remove all duplicates including originalBusiness Consideration: Before removing duplicates, verify they ARE duplicates:
Data Type Conversion
Why Data Types Matter:
Pandas must know data types to perform operations:
Common Type Issues:
Checking and Converting Types:
# Check current data types
print(df.dtypes)
# Convert string to numeric
df["Sales"] = pd.to_numeric(df["Sales"])
# Convert to integer (after filling NaN first)
df["Sales"] = df["Sales"].fillna(0).astype(int)
# Convert to datetime
df["Date"] = pd.to_datetime(df["Date"])
# Convert with error handling
df["Sales"] = pd.to_numeric(df["Sales"], errors="coerce")
# 'coerce' turns non-numeric values to NaN instead of errorDate object
Product object
Sales float64
Region object
dtype: objectOutput:
Date object
Product object
Sales float64
Region object
dtype: objectBenefits of Correct Types:
String Cleaning and Standardization
Common String Issues in Business Data:
Pandas String Methods:
# Remove leading/trailing whitespace
df["Product"] = df["Product"].str.strip()
# Convert to consistent case
df["Region"] = df["Region"].str.lower() # all lowercase
df["Region"] = df["Region"].str.upper() # all uppercase
df["Region"] = df["Region"].str.title() # Title Case
df["Region"] = df["Region"].str.capitalize() # Capitalize first
# Replace text
df["Product"] = df["Product"].str.replace("Laptop", "Laptop Pro")
# Remove/clean characters (example: standardise region codes)
df["Region"] = df["Region"].str.replace(" ", "_") # Replace spaces with underscore
df["Region"] = df["Region"].str.replace(r"[^A-Za-z_]", "", regex=True) # Keep only lettersCreating Standardized Categories:
# Map variations to standard values
region_mapping = {
"north": "North",
"NORTH": "North",
"N": "North",
"Northern": "North"
}
df["Region"] = df["Region"].map(region_mapping)Identifying and Handling Outliers
What Are Outliers?
Outliers are data points significantly different from others: - Sales of $1,000,000 when typical sales are $50,000 - Customer age of 150 years - Order quantity of -50
Why They Matter:
Statistical Method: Interquartile Range (IQR)
The IQR method is a robust way to identify outliers:
# Calculate quartiles
Q1 = df["Sales"].quantile(0.25) # 25th percentile
Q3 = df["Sales"].quantile(0.75) # 75th percentile
IQR = Q3 - Q1 # Interquartile range
# Define outlier boundaries
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
print(f"Normal range: ${lower_bound:,.0f} to ${upper_bound:,.0f}")Normal range: $-269 to $2,082Output:
Normal range: $-269 to $2,081What these numbers mean:
Handling Outliers:
# Identify outliers
outliers = df[(df["Sales"] < lower_bound) | (df["Sales"] > upper_bound)]
print("Outliers found:")
print(outliers)
# Option 1: Remove outliers
df_clean = df[(df["Sales"] >= lower_bound) & (df["Sales"] <= upper_bound)]
# Option 2: Cap outliers (replace with boundary values)
df["Sales_Capped"] = df["Sales"].clip(lower=lower_bound, upper=upper_bound)
# Option 3: Replace with median
median_sales = df["Sales"].median()
df["Sales_Clean"] = df["Sales"].apply(
lambda x: median_sales if (x < lower_bound or x > upper_bound) else x
)Outliers found:
Empty DataFrame
Columns: [Date, Product, Sales, Region]
Index: []Output:
Outliers found:
Empty DataFrame
Columns: [Date, Product, Sales, Region]
Index: []Business Decision: Don’t automatically remove outliers:
Creating a Complete Cleaning Pipeline
The Professional Approach:
Rather than cleaning ad-hoc, create a reusable function that applies all cleaning steps consistently:
def clean_sales_data(df):
"""
Comprehensive data cleaning pipeline for sales data
Steps:
1. Remove duplicate records
2. Handle missing values
3. Standardize text fields
4. Convert data types
5. Remove outliers
Returns: Cleaned DataFrame
"""
print(f"Starting with {len(df)} records")
# Step 1: Remove duplicates
original_length = len(df)
df = df.drop_duplicates()
print(f"Removed {original_length - len(df)} duplicates")
# Step 2: Handle missing values
df["Sales"] = df["Sales"].fillna(df["Sales"].median())
df["Region"] = df["Region"].fillna("Unknown")
df = df.dropna(subset=["Date"]) # Date is critical
# Step 3: Standardize strings
df["Region"] = df["Region"].str.strip().str.title()
df["Product"] = df["Product"].str.strip().str.title()
# Step 4: Convert types
df["Date"] = pd.to_datetime(df["Date"])
df["Sales"] = pd.to_numeric(df["Sales"], errors="coerce")
# Step 5: Remove outliers
Q1 = df["Sales"].quantile(0.25)
Q3 = df["Sales"].quantile(0.75)
IQR = Q3 - Q1
df = df[(df["Sales"] >= Q1 - 1.5*IQR) &
(df["Sales"] <= Q3 + 1.5*IQR)]
print(f"Finished with {len(df)} clean records")
return df
# Usage — re-create the original sample df to pass to the function
raw_df = pd.DataFrame({
"Date": ["2024-01-15", "2024-01-16", None, "2024-01-18"],
"Product": ["Laptop", "Mouse", "Laptop", "Keyboard"],
"Sales": [1200, 25, 1200, None],
"Region": ["North", "South", "North", "South"]
})
cleaned_df = clean_sales_data(raw_df)Starting with 4 records
Removed 0 duplicates
Finished with 3 clean recordsBenefits of This Approach:
Lab 4: Comprehensive Data Cleaning Project
Objective: Apply all data cleaning techniques to prepare a messy business dataset for analysis and visualization.
Scenario: You’ve been given a raw sales dataset exported from an old system. It has numerous quality issues that must be resolved before creating visualizations for the executive team. Your manager needs a clean dataset and a report documenting what was cleaned.
Part A: Create Messy Dataset (5 points)
Create file: Lab04_YourName_DataCleaning.py
Create this intentionally problematic dataset:
import pandas as pd
import numpy as np
data = {
"Transaction_ID": [1001, 1002, 1003, 1004, 1005, 1006, 1002, 1007, 1008, 1009],
"Date": ["2024-01-15", "2024-01-16", None, "2024-01-18", "2024-01-19",
"2024-01-20", "2024-01-16", "2024-01-21", "2024-01-22", "2024-01-23"],
"Product": [" Laptop", "MOUSE ", "laptop", "Keyboard", " Monitor",
"mouse", "MOUSE ", "Tablet", "Headphones", "Laptop"],
"Quantity": ["50", "200", "50", "150", "75", "200", "200", "100", "300", "2"],
"Price": [1200, 25, 1200, 75, 350, 25, 25, 450, 80, 1200],
"Sales": [60000, 5000, 60000, None, 26250, 5000, 5000, 45000, 24000, 2400],
"Region": ["north", "SOUTH", "North", "south", None, "South", "SOUTH",
"East", "West", "North"],
"Sales_Rep": ["Alice", "Bob", "Alice", "Charlie", "Diana", "Bob", "Bob",
"Eve", "Frank", "Alice"]
}
df = pd.DataFrame(data)
print("Original messy data created")
print(df)Original messy data created
Transaction_ID Date Product Quantity Price Sales Region \
0 1001 2024-01-15 Laptop 50 1200 60000.0 north
1 1002 2024-01-16 MOUSE 200 25 5000.0 SOUTH
2 1003 None laptop 50 1200 60000.0 North
3 1004 2024-01-18 Keyboard 150 75 NaN south
4 1005 2024-01-19 Monitor 75 350 26250.0 None
5 1006 2024-01-20 mouse 200 25 5000.0 South
6 1002 2024-01-16 MOUSE 200 25 5000.0 SOUTH
7 1007 2024-01-21 Tablet 100 450 45000.0 East
8 1008 2024-01-22 Headphones 300 80 24000.0 West
9 1009 2024-01-23 Laptop 2 1200 2400.0 North
Sales_Rep
0 Alice
1 Bob
2 Alice
3 Charlie
4 Diana
5 Bob
6 Bob
7 Eve
8 Frank
9 Alice Part B: Data Quality Assessment (15 points)
Before cleaning, assess the problems:
Check for missing values:
Check for duplicates:
Check data types:
Check for anomalies:
Create a summary report:
Print a formatted report showing:
Part C: Step-by-Step Cleaning (50 points)
Clean the data following these steps (print results after each step):
Step 1: Handle Duplicates (10 points)
Step 2: Handle Missing Values (10 points)
Step 3: Standardize Text Fields (10 points)
Step 4: Convert Data Types (10 points)
Step 5: Validate and Correct Business Logic (10 points)
Part D: Outlier Analysis (15 points)
Analyze Sales column for outliers:
Business Decision:
Create two versions:
df_with_outliers: Keep all datadf_no_outliers: Remove outliersPart E: Create Cleaning Function (10 points)
Write a reusable function called clean_sales_dataset() that: 1. Takes a raw DataFrame as input 2. Performs all cleaning steps from Parts C and D 3. Returns a clean DataFrame 4. Prints a summary of changes made
Test it by re-creating the messy dataset and running it through your function.
Part F: Export and Documentation (5 points)
Save the cleaned DataFrame to: Lab04_YourName_CleanData.csv
Create a text file: Lab04_YourName_CleaningReport.txt containing:
Deliverables:
Lab04_YourName_DataCleaning.py - Complete Python file with all partsLab04_YourName_CleanData.csv - Cleaned datasetLab04_YourName_CleaningReport.txt - Documentation of cleaning processGrading Rubric:
Bonus Challenge (+10 points):
Add advanced features to your cleaning function:
Tips for Success:
Common Pitfalls to Avoid:
End of Module 1: Foundations of Python and Data Handling
Key Takeaways:
You’re now ready to move to Module 2: Visualization!
Why Data Visualization Matters in Business
The Power of Visual Communication:
Human brains process visual information 60,000 times faster than text. In business contexts, this matters enormously:
When Visualization Beats Tables:
Consider this sales data: - Q1: $450,000, Q2: $485,000, Q3: $510,000, Q4: $545,000
As a table, you need to mentally calculate: “Growth each quarter… looks consistent… upward trend…”
As a line chart, you immediately see: “Steady upward trajectory, accelerating slightly.”
The Business Impact:
Understanding Matplotlib Architecture
What is Matplotlib?
Matplotlib is Python’s foundational visualization library, created in 2003 to bring MATLAB-style plotting to Python. Think of it as the “engine” that powers most Python visualizations - even libraries like Seaborn are built on top of Matplotlib.
Why Start with Matplotlib?
The Two-Layer Architecture:
Matplotlib has two main components you need to understand:
1. Figure (The Canvas):
Think of this as your blank poster board or PowerPoint slide. It’s the overall container for your visualization.
import matplotlib.pyplot as plt
# Create a figure (canvas)
fig = plt.figure(figsize=(8, 5)) # Width: 10 inches, Height: 6 inches<Figure size 768x480 with 0 Axes>Output:
[Chart]
The figsize parameter controls dimensions: - Standard report: (10, 6) - Wide dashboard: (12, 4) - Square social media: (8, 8) - Presentation slide: (12, 6)
2. Axes (The Plot Area):
This is where your actual chart lives - the area with data, axes, and grid. One figure can contain multiple axes (multiple charts).
# Create figure and axes together
fig, ax = plt.subplots(figsize=(8, 5))
Output:
[Chart]
Understanding the Relationship:
Two Approaches to Matplotlib:
Approach 1: pyplot interface (simpler, good for quick plots)
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.show()
Output:
[Line chart]
Approach 2: Object-oriented interface (professional, more control)
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.show()
Output:
[Line chart]
We’ll use the object-oriented approach because: - More explicit and readable - Better for complex visualizations - Industry best practice - Easier to customize
Your First Matplotlib Visualization
The Basic Workflow:
Every Matplotlib visualization follows these steps:
Creating a Simple Line Plot:
import matplotlib.pyplot as plt
# Step 1: Prepare data (monthly sales)
months = [1, 2, 3, 4, 5, 6]
sales = [45000, 52000, 48000, 61000, 58000, 63000]
# Step 2: Create figure and axes
fig, ax = plt.subplots(figsize=(8, 5))
# Step 3: Create the plot
ax.plot(months, sales)
# Step 4: Display
plt.show()
Output:
[Line chart]
What’s Happening:
months goes on the x-axis (horizontal)sales goes on the y-axis (vertical)plot() connects the points with linesshow() displays the visualizationThe plt.show() Command:
Line Plots - Showing Trends Over Time
When to Use Line Plots:
Line plots are ideal for:
Not good for:
Anatomy of a Line Plot:
import matplotlib.pyplot as plt
# Quarterly revenue data
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
revenue = [450000, 485000, 510000, 545000]
# Create plot
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(quarters, revenue)
# Add labels (critical for business context)
ax.set_xlabel('Quarter')
ax.set_ylabel('Revenue ($)')
ax.set_title('Quarterly Revenue - 2024')
plt.show()
Output:
[Line chart: “Quarterly Revenue - 2024”, x: Quarter, y: Revenue ($)]
Essential Plot Elements:
Improving Readability:
import matplotlib.pyplot as plt
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
revenue = [450000, 485000, 510000, 545000]
fig, ax = plt.subplots(figsize=(8, 5))
# Plot with markers to emphasize data points
ax.plot(quarters, revenue, marker='o', linewidth=2, markersize=8)
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Revenue ($)', fontsize=12)
ax.set_title('Quarterly Revenue Growth - 2024', fontsize=14, fontweight='bold')
# Add grid for easier reading
ax.grid(True, alpha=0.3)
plt.show()
Output:
[Line chart: “Quarterly Revenue Growth - 2024”, x: Quarter, y: Revenue ($)]
Parameter Explanations:
marker='o': Adds circular markers at data pointslinewidth=2: Makes the line thicker (default is 1)markersize=8: Controls size of markersgrid(True, alpha=0.3): Adds grid lines with 30% opacityScatter Plots - Showing Relationships
When to Use Scatter Plots:
Scatter plots reveal relationships between two variables:
Business Examples:
Creating a Scatter Plot:
import matplotlib.pyplot as plt
# Employee data: years of experience vs. salary
experience = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
salary = [45000, 48000, 52000, 55000, 58000, 62000, 65000, 68000, 72000, 75000]
fig, ax = plt.subplots(figsize=(8, 5))
# Use scatter instead of plot
ax.scatter(experience, salary, s=100, alpha=0.6)
ax.set_xlabel('Years of Experience', fontsize=12)
ax.set_ylabel('Annual Salary ($)', fontsize=12)
ax.set_title('Salary vs. Experience Analysis', fontsize=14, fontweight='bold')
ax.grid(True, alpha=0.3)
plt.show()
Output:
[Scatter plot: “Salary vs. Experience Analysis”, x: Years of Experience, y: Annual Salary ($)]
Scatter Plot Parameters:
s=100: Size of markers (s stands for size)alpha=0.6: Transparency (0=invisible, 1=opaque)Reading Scatter Plots:
What to look for:
Choosing Between Line and Scatter Plots
Decision Framework:
Use Line Plots when:
Use Scatter Plots when:
The Same Data, Different Stories:
Imagine plotting store locations by (Latitude, Longitude):
Saving Your Visualizations
Why Save Plots:
In business, you’ll need to:
Saving to File:
import matplotlib.pyplot as plt
# Create your plot
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot([1, 2, 3, 4], [10, 20, 25, 30])
ax.set_title('Sample Chart')
# Save before plt.show()
plt.savefig('monthly_sales.png', dpi=300, bbox_inches='tight')
plt.show()
Output:
[Line chart: “Sample Chart”]
Important Parameters:
dpi=300: Resolution (300 is publication quality, 150 is screen quality)bbox_inches='tight': Removes extra whitespace around the plotFormat Guide:
File Naming Best Practices:
Q4_2024_Sales_Trend.png not plot1.pngRevenue_2024_12_15.pngLab 1: Creating Your First Business Visualizations
Objective: Master the fundamentals of Matplotlib by creating line plots and scatter plots for real business scenarios.
Scenario: You work for “TechGadget Inc.,” an electronics retailer. The marketing director has requested visualizations to present at the upcoming board meeting. You’ll create professional charts analyzing sales performance and customer patterns.
Pre-Lab Setup:
M2L01_YourName_FirstPlots.pyPart A: Monthly Sales Trend Analysis (25 points)
Context: Your company’s sales for the first half of 2024 need to be visualized to show the board how performance has trended.
Data:
Tasks:
Create a basic line plot (10 points):
Add professional formatting (10 points):
Save the visualization (5 points):
Expected Outcome: A professional line chart suitable for presentation that clearly shows sales growth over 6 months.
Part B: Product Price vs. Sales Analysis (30 points)
Context: The product team wants to understand if there’s a relationship between product price and units sold to optimize pricing strategy.
Data:
Ten products with their prices and units sold: - Prices: $25, $45, $120, $85, $199, $350, $75, $450, $150, $299 - Units Sold: 850, 720, 245, 380, 180, 95, 425, 68, 210, 125
Tasks:
Create a scatter plot (12 points):
Format for analysis (12 points):
Interpret and annotate (6 points):
Part C: Comparative Analysis (25 points)
Context: The CEO wants to compare this year’s performance against last year to see if the company is improving.
Data:
Tasks:
Create a comparison line plot (15 points):
Add distinguishing features (10 points):
ax.legend(['2023', '2024'], fontsize=11)Part D: Customer Age vs. Purchase Amount (20 points)
Context: Marketing wants to understand if customer age correlates with purchase amount to target advertising appropriately.
Data:
Tasks:
Create an analytical scatter plot (15 points):
Save and analyze (5 points):
Bonus Challenge (+10 points):
Create one additional visualization of your choice using the provided data or your own business scenario: - Must use either line or scatter plot appropriately - Must be professionally formatted - Must include a business context (explain what it shows and why it matters) - Save as: “M2L01_YourName_Bonus.png”
Deliverables:
M2L01_YourName_FirstPlots.py with all parts clearly commentedM2L01_YourName_MonthlySales.pngM2L01_YourName_YearComparison.pngM2L01_YourName_AgeAnalysis.pngM2L01_YourName_Bonus.png (if bonus attempted)Grading Rubric:
Success Criteria:
Common Mistakes to Avoid:
Tips for Success:
The Importance of Customization in Business Context
Why Default Settings Aren’t Enough:
Matplotlib’s default visualizations are functional but generic. In business contexts, customization is essential because:
1. Branding and Professionalism:
2. Accessibility:
3. Clarity:
4. Storytelling:
The Professional Standard:
Compare these descriptions:
The second version communicates authority and attention to detail.
Working with Colors Effectively
Understanding Color in Matplotlib:
Colors in Matplotlib can be specified multiple ways:
Basic Color Application:
import matplotlib.pyplot as plt
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
sales = [45000, 52000, 48000, 61000, 58000, 63000]
fig, ax = plt.subplots(figsize=(8, 5))
# Specify color
ax.plot(months, sales, color='darkblue', linewidth=2.5, marker='o')
ax.set_title('Monthly Sales Trend')
plt.show()
Output:
[Line chart: “Monthly Sales Trend”]
Common Business Color Choices:
Different colors convey different meanings in business:
Color Psychology in Business Charts:
# Profit/Loss visualization
months = ['Q1', 'Q2', 'Q3', 'Q4']
profit = [120000, -45000, 85000, 150000]
fig, ax = plt.subplots(figsize=(8, 5))
# Color bars based on profit/loss
colors = ['green' if p > 0 else 'red' for p in profit]
ax.bar(months, profit, color=colors)
ax.set_title('Quarterly Profit/Loss Analysis')
ax.set_ylabel('Amount ($)')
plt.show()
Output:
[Bar chart: “Quarterly Profit/Loss Analysis”, y: Amount ($)]
Accessibility: Colorblind-Friendly Palettes:
Approximately 8% of men and 0.5% of women have color vision deficiency. Use colorblind-safe palettes:
Good combinations:
Avoid:
Using Colorblind-Friendly Palettes:
# IBM's colorblind-safe palette
colors = ['#648FFF', '#FFB000', '#DC267F', '#FE6100', '#785EF0']
# Sample data for demonstration
x = [1, 2, 3, 4, 5]
y = [10, 20, 15, 25, 18]
y2 = [8, 17, 12, 22, 14]
fig, ax = plt.subplots()
# Or use built-in safe colormaps
ax.plot(x, y, color='#648FFF') # Blue
ax.plot(x, y2, color='#FFB000') # Orange
plt.show()
Output:
[Line chart]
Comprehensive Labeling Strategies
The Three Essential Labels:
Every business visualization must have:
Missing any of these makes your chart ambiguous and unprofessional.
Creating Effective Titles:
Titles should be:
import matplotlib.pyplot as plt
data = [120, 145, 135, 160]
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(quarters, data)
# Poor title:
# ax.set_title('Sales')
# Better title:
# ax.set_title('Sales Data')
# Best title:
ax.set_title('TechGadget Inc. - Quarterly Sales Performance 2024',
fontsize=14, fontweight='bold', pad=20)
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Sales ($1000s)', fontsize=12)
plt.show()
Output:
[Line chart: “Sales”, x: Quarter, y: Sales ($1000s)]
Title Parameters Explained:
fontsize=14: Larger than body text (12) to emphasizefontweight='bold': Makes title stand outpad=20: Adds space between title and plot (default is 6)Axis Label Best Practices:
Always include units:
Be specific:
Use appropriate precision:
# Complete labeling example
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(months, revenue)
ax.set_title('Monthly Revenue Analysis - Fiscal Year 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Month', fontsize=12, fontweight='medium')
ax.set_ylabel('Revenue ($ Millions)', fontsize=12, fontweight='medium')
# Add subtitle if needed (smaller text below title)
ax.text(0.5, 1.05, 'North American Region',
transform=ax.transAxes, ha='center', fontsize=10, style='italic')
plt.show()
Output:
[Line chart: “Monthly Revenue Analysis - Fiscal Year 2024”, x: Month, y: Revenue ($ Millions)]
Legends - Distinguishing Multiple Data Series
When Legends are Essential:
A legend is required when you have: - Multiple lines on one plot - Multiple categories in a bar chart - Different groups in a scatter plot - Comparison of different metrics
Without a legend, viewers can’t distinguish what each line/color represents.
Creating Basic Legends:
import matplotlib.pyplot as plt
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
sales_2023 = [110, 125, 120, 135, 130, 145]
sales_2024 = [125, 142, 138, 156, 151, 168]
fig, ax = plt.subplots(figsize=(8, 5))
# Plot both years
ax.plot(months, sales_2023, marker='o', linewidth=2, label='2023')
ax.plot(months, sales_2024, marker='s', linewidth=2, label='2024')
# Create legend
ax.legend()
ax.set_title('Year-over-Year Sales Comparison')
ax.set_xlabel('Month')
ax.set_ylabel('Sales ($1000s)')
plt.show()
Output:
[Line chart: “Year-over-Year Sales Comparison”, x: Month, y: Sales ($1000s)]
Key Point: Use the label parameter in your plot commands, then call ax.legend() to display the legend.
Positioning Legends Strategically:
Legend placement matters - it shouldn’t obscure data:
# Position options:
ax.legend(loc='upper left') # Top left
ax.legend(loc='upper right') # Top right (default)
ax.legend(loc='lower left') # Bottom left
ax.legend(loc='lower right') # Bottom right
ax.legend(loc='center left') # Middle left
ax.legend(loc='center') # Dead center
ax.legend(loc='best') # Matplotlib decides (usually good)
# Place outside plot area
ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')Customizing Legend Appearance:
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(months, sales_2023, label='2023', linewidth=2.5)
ax.plot(months, sales_2024, label='2024', linewidth=2.5)
# Customized legend
ax.legend(
loc='upper left',
fontsize=11,
frameon=True, # Box around legend
shadow=True, # Drop shadow
fancybox=True, # Rounded corners
title='Fiscal Year', # Legend title
title_fontsize=12
)
plt.show()
Output:
[Line chart: “Fiscal Year”]
Multiple-Column Legends:
For many items, use columns to save space:
ax.legend(loc='upper center', ncol=3, # 3 columns
bbox_to_anchor=(0.5, -0.15)) # Below plotFont Control and Text Styling
Why Typography Matters:
The right fonts make visualizations:
Global Font Settings:
Set fonts for all text in a plot:
import matplotlib.pyplot as plt
# Set font for all elements
plt.rcParams['font.family'] = 'sans-serif'
plt.rcParams['font.sans-serif'] = ['Arial', 'Helvetica', 'DejaVu Sans']
plt.rcParams['font.size'] = 11
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot([1, 2, 3], [10, 20, 15])
ax.set_title('Professional Typography')
plt.show()
Output:
[Line chart: “Professional Typography”]
Common Business Fonts:
Individual Text Customization:
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(months, sales)
# Title with custom font
ax.set_title('Quarterly Performance Report',
fontsize=16,
fontweight='bold',
fontfamily='serif',
color='#2C3E50')
# X-axis label
ax.set_xlabel('Quarter',
fontsize=12,
fontstyle='italic',
fontweight='medium')
# Y-axis label
ax.set_ylabel('Revenue ($M)',
fontsize=12,
fontweight='bold')
plt.show()
Output:
[Line chart: “Quarterly Performance Report”, x: Quarter, y: Revenue ($M)]
Font Property Options:
fontsize: Number (points) or string (‘small’, ‘medium’, ‘large’, ‘x-large’)fontweight: ‘normal’, ‘bold’, ‘heavy’, ‘light’, or numeric (100-900)fontstyle: ‘normal’, ‘italic’, ‘oblique’fontfamily: ‘serif’, ‘sans-serif’, ‘monospace’, ‘fantasy’, ‘cursive’color: Any valid color specificationText Hierarchy in Business Charts:
Create visual hierarchy through sizing:
Axes Formatting and Number Display
The Challenge of Readability:
Compare these Y-axis displays:
1500000 - Hard to read quickly1,500,000 - Better, but takes space1.5M - Clear and compact$1.5M - Even more informativeFormatting Axis Numbers:
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
revenue = [1500000, 2300000, 1800000, 2750000]
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(quarters, revenue)
# Format Y-axis as millions with dollar sign
def millions_formatter(x, pos):
return f'${x/1e6:.1f}M'
ax.yaxis.set_major_formatter(ticker.FuncFormatter(millions_formatter))
ax.set_title('Quarterly Revenue')
ax.set_ylabel('Revenue')
plt.show()
Output:
[Bar chart: “Quarterly Revenue”, y: Revenue]
Common Number Formatters:
import matplotlib.ticker as ticker
# Add thousand separators
ax.yaxis.set_major_formatter(ticker.StrMethodFormatter('{x:,.0f}'))
# Percentage format
ax.yaxis.set_major_formatter(ticker.PercentFormatter(xmax=1))
# Currency format
ax.yaxis.set_major_formatter(ticker.StrMethodFormatter('${x:,.0f}'))
# Millions with 1 decimal
ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, p: f'{x/1e6:.1f}M'))
# Thousands shorthand
ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, p: f'{x/1000:.0f}K'))Controlling Tick Marks:
import matplotlib.ticker as ticker
fig, ax = plt.subplots()
labels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
# Set specific tick locations
ax.set_xticks([0, 1, 2, 3, 4, 5])
ax.set_xticklabels(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun'])
# Rotate tick labels for readability
ax.set_xticklabels(labels, rotation=45, ha='right')
# Set number of ticks
ax.yaxis.set_major_locator(ticker.MaxNLocator(6)) # Approximately 6 ticks
plt.show()
Bringing It All Together: Complete Customization
A Professional, Fully-Customized Chart:
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
# Data
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
revenue_2023 = [1100000, 1250000, 1200000, 1350000, 1300000, 1450000]
revenue_2024 = [1250000, 1420000, 1380000, 1560000, 1510000, 1680000]
# Create figure with specific size
fig, ax = plt.subplots(figsize=(12, 7))
# Plot data with custom colors and styling
ax.plot(months, revenue_2023,
color='#7FB3D5', # Soft blue
linewidth=3,
marker='o',
markersize=8,
label='FY 2023',
alpha=0.8)
ax.plot(months, revenue_2024,
color='#148F77', # Dark green
linewidth=3,
marker='s',
markersize=8,
label='FY 2024',
alpha=0.8)
# Comprehensive labeling
ax.set_title('TechGadget Inc. - Year-over-Year Revenue Comparison',
fontsize=16,
fontweight='bold',
pad=20,
color='#2C3E50')
ax.set_xlabel('Month',
fontsize=13,
fontweight='medium',
color='#34495E')
ax.set_ylabel('Revenue',
fontsize=13,
fontweight='medium',
color='#34495E')
# Format Y-axis as millions
ax.yaxis.set_major_formatter(
ticker.FuncFormatter(lambda x, p: f'${x/1e6:.1f}M')
)
# Customize legend
ax.legend(loc='upper left',
fontsize=11,
frameon=True,
shadow=True,
fancybox=True,
title='Fiscal Year')
# Add grid for readability
ax.grid(True, alpha=0.3, linestyle='--', linewidth=0.8)
# Adjust layout
plt.tight_layout()
# Save and display
plt.savefig('M2L02_Revenue_Comparison.png', dpi=300, bbox_inches='tight')
plt.show()
Output:
[Line chart: “TechGadget Inc. - Year-over-Year Revenue Comparison”, x: Month, y: Revenue]
Design Principles Applied:
Lab 2: Professional Chart Customization
Objective: Transform basic Matplotlib visualizations into polished, business-ready charts through comprehensive customization.
Scenario: You’re preparing for the annual shareholders’ meeting at “GlobalTech Solutions.” The CFO has reviewed your initial charts but requests significant improvements to make them boardroom-ready. Your task is to apply professional customization to create presentation-quality visualizations.
Pre-Lab Setup:
M2L02_YourName_Customization.pyPart A: Revenue Trend Enhancement (30 points)
Context: The basic revenue chart lacks the polish needed for executive presentation. Transform it into a professional visualization.
Data:
quarters = ['Q1 2024', 'Q2 2024', 'Q3 2024', 'Q4 2024']
revenue = [2400000, 2750000, 2650000, 3100000]
target = [2500000, 2600000, 2700000, 2800000]Tasks:
Create a dual-line comparison (12 points):
Apply professional formatting (12 points):
Create an informative legend (6 points):
Part B: Regional Sales Customization (30 points)
Context: Create a professional bar chart comparing regional performance with clear visual hierarchy and formatting.
Data:
regions = ['North America', 'Europe', 'Asia Pacific', 'Latin America', 'Middle East']
sales = [5800000, 4200000, 6500000, 2100000, 1800000]Tasks:
Create a styled bar chart (10 points):
Format for executive presentation (15 points):
Add data labels on bars (5 points):
Part C: Multi-Series Comparison (25 points)
Context: The product team needs a comparison of three product lines over time with distinct, accessible styling.
Data:
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
product_a = [85000, 92000, 88000, 95000, 102000, 98000]
product_b = [62000, 68000, 71000, 74000, 78000, 81000]
product_c = [45000, 43000, 48000, 52000, 55000, 58000]Tasks:
Create accessible visualization (12 points):
Professional formatting (8 points):
Enhance readability (5 points):
Part D: Advanced Customization Challenge (15 points)
Context: Create a visualization showing profit margins over time with conditional formatting (colors change based on performance).
Data:
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
profit_margins = [0.15, 0.18, 0.12, 0.21] # 15%, 18%, 12%, 21%Tasks:
Create a conditional bar chart (10 points):
Format as percentages (5 points):
Bonus Challenge (+15 points):
Create a “Dashboard-Ready” Chart:
Using any of the previous datasets or your own business scenario:
Deliverables:
M2L02_YourName_Customization.py with all partsM2L02_YourName_RevenueVsTarget.pngM2L02_YourName_RegionalSales.pngM2L02_YourName_ProductComparison.pngM2L02_YourName_ProfitMargins.pngM2L02_YourName_Bonus.png (if attempted)Grading Rubric:
Success Criteria:
Professional Standards Checklist:
For each chart, verify:
Tips for Success:
The Business Case for Multiple Plots
Why Single Plots Aren’t Always Enough:
Business analysis often requires viewing multiple perspectives simultaneously:
Scenario 1: Regional Comparison Instead of four separate charts for four regions, one figure with four subplots lets executives:
Scenario 2: Multi-Metric Dashboard A product manager needs to see:
Four separate images become confusing. One dashboard figure tells the complete story.
Scenario 3: Time Period Comparison Comparing this year vs. last year:
Benefits of Subplots:
When NOT to Use Subplots:
Understanding Subplot Architecture
The Conceptual Model:
Think of subplots as a grid:
2 rows, 2 columns:
┌─────────┬─────────┐
│ (0,0) │ (0,1) │ Row 0
├─────────┼─────────┤
│ (1,0) │ (1,1) │ Row 1
└─────────┴─────────┘
Column 0 Column 1Basic Subplot Creation:
import matplotlib.pyplot as plt
# Create a figure with 2x2 grid of subplots
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
# Access individual subplots
axes[0, 0] # Top-left
axes[0, 1] # Top-right
axes[1, 0] # Bottom-left
axes[1, 1] # Bottom-right
Output:
[Chart: 2×2 subplot grid]
Important Notes:
axes is a 2D array if you have rows and columnsaxes is a 1D array if you have only rows OR columnsaxes.flatten() to convert 2D to 1D for easier iterationCreating Different Layout Configurations:
# One row, three columns (horizontal dashboard)
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
# Three rows, one column (vertical report)
fig, axes = plt.subplots(3, 1, figsize=(10, 12))
# 2x3 grid (six panels)
fig, axes = plt.subplots(2, 3, figsize=(15, 8))
Output:
[Chart: 1×3 subplot grid]
Creating a Simple Multi-Plot Dashboard
Example: Quarterly Business Dashboard
import matplotlib.pyplot as plt
import numpy as np
# Sample data
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
revenue = [2400000, 2750000, 2650000, 3100000]
expenses = [1800000, 2100000, 2000000, 2300000]
profit = [r - e for r, e in zip(revenue, expenses)]
customers = [15000, 17500, 18200, 21000]
# Create 2x2 dashboard
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
# Top-left: Revenue trend
axes[0, 0].plot(quarters, revenue, marker='o', linewidth=2, color='#2E86AB')
axes[0, 0].set_title('Quarterly Revenue', fontsize=13, fontweight='bold')
axes[0, 0].set_ylabel('Revenue ($)')
axes[0, 0].grid(True, alpha=0.3)
# Top-right: Profit margins
axes[0, 1].bar(quarters, profit, color='#06A77D', edgecolor='black', linewidth=1.5)
axes[0, 1].set_title('Quarterly Profit', fontsize=13, fontweight='bold')
axes[0, 1].set_ylabel('Profit ($)')
axes[0, 1].grid(True, alpha=0.3, axis='y')
# Bottom-left: Customer growth
axes[1, 0].plot(quarters, customers, marker='s', linewidth=2, color='#D9A72E')
axes[1, 0].set_title('Customer Growth', fontsize=13, fontweight='bold')
axes[1, 0].set_ylabel('Number of Customers')
axes[1, 0].grid(True, alpha=0.3)
# Bottom-right: Revenue vs. Expenses comparison
axes[1, 1].plot(quarters, revenue, marker='o', label='Revenue', linewidth=2)
axes[1, 1].plot(quarters, expenses, marker='s', label='Expenses', linewidth=2)
axes[1, 1].set_title('Revenue vs. Expenses', fontsize=13, fontweight='bold')
axes[1, 1].set_ylabel('Amount ($)')
axes[1, 1].legend()
axes[1, 1].grid(True, alpha=0.3)
# Overall title for dashboard
fig.suptitle('Quarterly Business Performance Dashboard - 2024',
fontsize=16, fontweight='bold', y=0.995)
plt.tight_layout()
plt.savefig('M2L03_Business_Dashboard.png', dpi=300, bbox_inches='tight')
plt.show()
Output:
[Chart: “Quarterly Revenue”, 2×2 subplot grid, y: Revenue ($)]
Key Techniques Applied:
axes[row, col]fig.suptitle() adds overall titletight_layout() prevents overlapping elementsControlling Subplot Spacing and Layout
The Problem of Overlap:
Default spacing often causes:
Solution 1: tight_layout() - Automatic Adjustment
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
# ... create your plots ...
# Automatically adjust spacing
plt.tight_layout()
Output:
[Chart: 2×2 subplot grid]
What tight_layout() does:
Solution 2: subplots_adjust() - Manual Control
For finer control:
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
# ... create your plots ...
# Manual spacing adjustment
plt.subplots_adjust(
left=0.1, # Left margin
right=0.95, # Right margin
top=0.93, # Top margin
bottom=0.1, # Bottom margin
wspace=0.3, # Width space between subplots
hspace=0.4 # Height space between subplots
)
Output:
[Chart: 2×2 subplot grid]
When to use manual adjustment:
tight_layout() doesn’t work wellSharing Axes Across Subplots
The Comparison Challenge:
When comparing across subplots, inconsistent axis scales mislead viewers:
Without shared axes:
Solution: Share X and/or Y Axes
# Share Y-axis across all subplots (common scale)
fig, axes = plt.subplots(2, 2, figsize=(12, 10), sharey=True)
# Share X-axis across all subplots
fig, axes = plt.subplots(2, 2, figsize=(12, 10), sharex=True)
# Share both
fig, axes = plt.subplots(2, 2, figsize=(12, 10), sharex=True, sharey=True)
Output:
[Chart: 2×2 subplot grid]
Practical Example: Regional Sales Comparison
import matplotlib.pyplot as plt
# Data for four regions
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
north = [45000, 52000, 48000, 61000, 58000, 63000]
south = [38000, 42000, 45000, 48000, 51000, 55000]
east = [52000, 58000, 54000, 67000, 64000, 70000]
west = [41000, 45000, 43000, 54000, 52000, 58000]
# Create 2x2 grid with shared Y-axis for fair comparison
fig, axes = plt.subplots(2, 2, figsize=(14, 10), sharey=True)
# North region
axes[0, 0].plot(months, north, marker='o', color='#2E86AB', linewidth=2)
axes[0, 0].set_title('North Region', fontsize=12, fontweight='bold')
axes[0, 0].grid(True, alpha=0.3)
# South region
axes[0, 1].plot(months, south, marker='o', color='#2E86AB', linewidth=2)
axes[0, 1].set_title('South Region', fontsize=12, fontweight='bold')
axes[0, 1].grid(True, alpha=0.3)
# East region
axes[1, 0].plot(months, east, marker='o', color='#2E86AB', linewidth=2)
axes[1, 0].set_title('East Region', fontsize=12, fontweight='bold')
axes[1, 0].set_xlabel('Month')
axes[1, 0].grid(True, alpha=0.3)
# West region
axes[1, 1].plot(months, west, marker='o', color='#2E86AB', linewidth=2)
axes[1, 1].set_title('West Region', fontsize=12, fontweight='bold')
axes[1, 1].set_xlabel('Month')
axes[1, 1].grid(True, alpha=0.3)
# Common Y-label (only on left plots due to sharey)
axes[0, 0].set_ylabel('Sales ($)', fontsize=11)
axes[1, 0].set_ylabel('Sales ($)', fontsize=11)
fig.suptitle('Regional Sales Performance - H1 2024', fontsize=15, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Chart: “North Region”, 2×2 subplot grid, x: Month, y: Sales ($)]
Benefits of Sharing Axes:
Mixing Different Plot Types
Telling Different Stories in One Figure:
Complex business analyses require different visualization types for different metrics.
Example: Comprehensive Product Analysis
import matplotlib.pyplot as plt
import numpy as np
# Data
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
units_sold = [850, 920, 880, 1050, 1020, 1100]
price = [299, 299, 289, 289, 279, 279]
revenue = [u * p for u, p in zip(units_sold, price)]
satisfaction = [4.2, 4.3, 4.1, 4.5, 4.6, 4.7]
# Create 3-panel vertical layout
fig, axes = plt.subplots(3, 1, figsize=(12, 10))
# Panel 1: Sales Volume (Line Chart)
axes[0].plot(months, units_sold, marker='o', linewidth=2.5,
color='#2E86AB', markersize=8)
axes[0].set_title('Units Sold', fontsize=13, fontweight='bold', loc='left')
axes[0].set_ylabel('Units', fontsize=11)
axes[0].grid(True, alpha=0.3)
# Panel 2: Revenue and Price (Dual Line Chart)
ax2_twin = axes[1].twinx() # Create secondary Y-axis
axes[1].plot(months, revenue, marker='s', linewidth=2.5,
color='#06A77D', label='Revenue', markersize=8)
ax2_twin.plot(months, price, marker='^', linewidth=2.5,
color='#D9A72E', label='Price', markersize=8)
axes[1].set_title('Revenue & Pricing', fontsize=13, fontweight='bold', loc='left')
axes[1].set_ylabel('Revenue ($)', fontsize=11, color='#06A77D')
ax2_twin.set_ylabel('Price ($)', fontsize=11, color='#D9A72E')
axes[1].grid(True, alpha=0.3)
# Combine legends
lines1, labels1 = axes[1].get_legend_handles_labels()
lines2, labels2 = ax2_twin.get_legend_handles_labels()
axes[1].legend(lines1 + lines2, labels1 + labels2, loc='upper left')
# Panel 3: Customer Satisfaction (Bar Chart)
axes[2].bar(months, satisfaction, color='#8E44AD', edgecolor='black', linewidth=1.5)
axes[2].set_title('Customer Satisfaction', fontsize=13, fontweight='bold', loc='left')
axes[2].set_xlabel('Month', fontsize=11)
axes[2].set_ylabel('Rating (out of 5)', fontsize=11)
axes[2].axhline(y=4.0, color='red', linestyle='--', linewidth=2, label='Target: 4.0')
axes[2].legend()
axes[2].grid(True, alpha=0.3, axis='y')
axes[2].set_ylim([0, 5])
# Overall title
fig.suptitle('Product Performance Dashboard - H1 2024',
fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Chart: “Units Sold”, 3×1 subplot grid, x: Month, y: Units]
Design Principles Demonstrated:
Advanced Layouts with GridSpec
Beyond Simple Grids:
Sometimes you need asymmetric layouts where subplots have different sizes.
GridSpec Allows:
Example: Executive Summary Layout
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
fig = plt.figure(figsize=(14, 10))
# Create custom grid: 3 rows, 3 columns
gs = gridspec.GridSpec(3, 3, figure=fig, hspace=0.4, wspace=0.3)
# Large main plot spanning top 2 rows, all columns
ax_main = fig.add_subplot(gs[0:2, :])
# Three smaller plots in bottom row
ax_bottom_left = fig.add_subplot(gs[2, 0])
ax_bottom_center = fig.add_subplot(gs[2, 1])
ax_bottom_right = fig.add_subplot(gs[2, 2])
# Main plot: Primary metric (revenue trend)
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
revenue = [2400000, 2750000, 2650000, 3100000]
ax_main.plot(quarters, revenue, marker='o', linewidth=3, markersize=12, color='#2E86AB')
ax_main.set_title('Annual Revenue Trend', fontsize=15, fontweight='bold')
ax_main.set_ylabel('Revenue ($M)', fontsize=12)
ax_main.grid(True, alpha=0.3)
# Bottom plots: Supporting metrics
# Left: Customer count
customers = [15000, 17500, 18200, 21000]
ax_bottom_left.bar(quarters, customers, color='#06A77D', edgecolor='black')
ax_bottom_left.set_title('Customers', fontsize=11, fontweight='bold')
# Center: Profit margin
margins = [0.25, 0.24, 0.25, 0.26]
ax_bottom_center.bar(quarters, margins, color='#D9A72E', edgecolor='black')
ax_bottom_center.set_title('Profit Margin', fontsize=11, fontweight='bold')
# Right: Market share
share = [0.15, 0.16, 0.17, 0.18]
ax_bottom_right.plot(quarters, share, marker='s', linewidth=2, color='#8E44AD')
ax_bottom_right.set_title('Market Share', fontsize=11, fontweight='bold')
fig.suptitle('Executive Dashboard - 2024 Annual Performance',
fontsize=16, fontweight='bold')
plt.savefig('M2L03_Executive_Dashboard.png', dpi=300, bbox_inches='tight')
plt.show()
Output:
[Chart: “Annual Revenue Trend”, y: Revenue ($M)]
When to Use GridSpec:
Lab 3: Building Multi-Panel Dashboards
Objective: Create professional multi-plot visualizations that present comprehensive business analyses in cohesive, easy-to-understand formats.
Scenario: You’re the Business Intelligence Analyst at “RetailMax Corporation.” The Q4 Board Meeting is next week, and executives need comprehensive dashboards showing performance across multiple dimensions. You’ll create three different multi-panel visualizations for different audiences.
Pre-Lab Setup:
M2L03_YourName_Dashboards.pyPart A: Regional Performance Dashboard (35 points)
Context: The VP of Sales needs to compare performance across four regions simultaneously to identify best practices and struggling areas.
Data:
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
northeast = [145000, 158000, 152000, 171000, 168000, 182000]
southeast = [132000, 138000, 145000, 151000, 158000, 165000]
midwest = [158000, 171000, 165000, 183000, 178000, 195000]
west = [141000, 145000, 148000, 162000, 171000, 178000]Tasks:
Create 2x2 regional comparison (20 points):
Format each subplot (10 points):
Polish and save (5 points):
M2L03_YourName_RegionalDashboard.pngPart B: Product Performance Vertical Dashboard (30 points)
Context: The Product Manager needs a comprehensive view of how the flagship product is performing across multiple metrics.
Data:
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
units_sold = [8500, 9200, 11000, 12500]
avg_price = [349, 339, 329, 319]
customer_satisfaction = [4.1, 4.3, 4.5, 4.6]
return_rate = [0.08, 0.07, 0.06, 0.05] # 8%, 7%, 6%, 5%Tasks:
Create 4-panel vertical stack (15 points):
Professional formatting (10 points):
Add business context (5 points):
Part C: Executive KPI Dashboard (35 points)
Context: The CEO needs a high-level dashboard with the most important KPIs visible at a glance, with one primary metric emphasized.
Data:
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
monthly_revenue = [2100000, 2250000, 2400000, 2350000, 2500000, 2650000,
2600000, 2750000, 2850000, 2800000, 3100000, 3200000]
monthly_profit = [420000, 450000, 480000, 470000, 500000, 530000,
520000, 550000, 570000, 560000, 620000, 640000]
customer_count = [45000, 47000, 49000, 51000, 54000, 57000,
60000, 63000, 66000, 69000, 73000, 78000]
employee_count = [450, 455, 460, 465, 470, 475,
480, 485, 490, 495, 500, 505]Tasks:
Create custom layout using GridSpec (15 points):
Emphasize hierarchy (12 points):
Professional finish (8 points):
M2L03_YourName_ExecutiveDashboard.pngBonus Challenge (+20 points):
Create an Interactive Comparison Dashboard:
Use the following data for 3 products:
quarters = ['Q1 2023', 'Q2 2023', 'Q3 2023', 'Q4 2023',
'Q1 2024', 'Q2 2024', 'Q3 2024', 'Q4 2024']
product_a_sales = [450, 480, 510, 540, 580, 620, 650, 680]
product_b_sales = [380, 390, 410, 430, 460, 490, 520, 550]
product_c_sales = [290, 310, 330, 360, 390, 420, 450, 480]Requirements:
Deliverables:
M2L03_YourName_Dashboards.pyM2L03_YourName_RegionalDashboard.pngM2L03_YourName_ProductDashboard.pngM2L03_YourName_ExecutiveDashboard.pngM2L03_YourName_Bonus.png (if bonus attempted)Grading Rubric:
Success Criteria:
Design Best Practices:
Common Pitfalls to Avoid:
Bar Charts - The Foundation of Categorical Comparison
Why Bar Charts Dominate Business:
Bar charts are the most common visualization in business because they excel at answering the fundamental question: “How do these categories compare?”
Perfect for:
The Human Visual System:
Basic Vertical Bar Chart:
import matplotlib.pyplot as plt
# Sales by product category
categories = ['Electronics', 'Clothing', 'Home Goods', 'Sports', 'Books']
sales = [2850000, 1920000, 1650000, 1280000, 980000]
fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(categories, sales, color='#2E86AB', edgecolor='black', linewidth=1.5)
ax.set_title('Sales by Product Category - Q4 2024', fontsize=14, fontweight='bold')
ax.set_xlabel('Product Category', fontsize=12)
ax.set_ylabel('Sales Revenue ($)', fontsize=12)
# Format Y-axis as millions
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1e6:.1f}M'))
ax.grid(True, alpha=0.3, axis='y')
plt.tight_layout()
plt.show()
Output:
[Bar chart: “Sales by Product Category - Q4 2024”, x: Product Category, y: Sales Revenue ($)]
Key Bar Chart Elements:
Horizontal Bar Charts - When to Switch Orientation
Use Horizontal Bars When:
Creating Horizontal Bars:
import matplotlib.pyplot as plt
# Top 10 salespeople (long names)
salespeople = ['Jennifer Martinez-Rodriguez', 'Michael Chen',
'Sarah O\'Connor', 'David Kim', 'Emily Johnson',
'Robert Thompson', 'Maria Garcia', 'James Wilson',
'Linda Davis', 'William Brown']
sales = [685000, 672000, 658000, 645000, 639000,
628000, 615000, 608000, 595000, 587000]
fig, ax = plt.subplots(figsize=(10, 8))
# Use barh() for horizontal
ax.barh(salespeople, sales, color='#06A77D', edgecolor='black', linewidth=1.5)
ax.set_title('Top 10 Salespeople - Annual Performance 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Annual Sales ($)', fontsize=12)
ax.set_ylabel('Salesperson', fontsize=12)
# Format X-axis as thousands with K suffix
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
ax.grid(True, alpha=0.3, axis='x')
plt.tight_layout()
plt.show()
Output:
[Horizontal bar chart: “Top 10 Salespeople - Annual Performance 2024”, x: Annual Sales ($), y: Salesperson]
Horizontal Bar Advantages:
Grouped Bar Charts - Comparing Multiple Series
The Business Need:
Compare the same categories across different groups:
Creating Grouped Bars:
import matplotlib.pyplot as plt
import numpy as np
# Quarterly revenue: 2023 vs 2024
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
revenue_2023 = [2100000, 2250000, 2350000, 2500000]
revenue_2024 = [2400000, 2650000, 2750000, 3100000]
fig, ax = plt.subplots(figsize=(12, 6))
# Position bars side-by-side
x = np.arange(len(quarters)) # [0, 1, 2, 3]
width = 0.35 # Width of each bar
# Create grouped bars
bars1 = ax.bar(x - width/2, revenue_2023, width, label='2023',
color='#7FB3D5', edgecolor='black', linewidth=1.5)
bars2 = ax.bar(x + width/2, revenue_2024, width, label='2024',
color='#148F77', edgecolor='black', linewidth=1.5)
# Set x-axis labels
ax.set_xticks(x)
ax.set_xticklabels(quarters)
ax.set_title('Year-over-Year Revenue Comparison', fontsize=14, fontweight='bold')
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Revenue', fontsize=12)
# Format Y-axis
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1e6:.1f}M'))
ax.legend(title='Fiscal Year', fontsize=11)
ax.grid(True, alpha=0.3, axis='y')
plt.tight_layout()
plt.show()
Output:
[Bar chart: “Year-over-Year Revenue Comparison”, x: Quarter, y: Revenue]
Grouped Bar Formula:
x = np.arange(len(categories))x - width/2 for first group, x + width/2 for secondx - width, x, x + widthWhen to Use Grouped Bars:
Stacked Bar Charts - Showing Part-to-Whole
The Composition Question:
Stacked bars answer: “What makes up this total?”
Creating Stacked Bars:
import matplotlib.pyplot as plt
import numpy as np
# Quarterly revenue by product line
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
electronics = [1200000, 1350000, 1400000, 1650000]
clothing = [650000, 720000, 750000, 850000]
home_goods = [450000, 580000, 600000, 600000]
fig, ax = plt.subplots(figsize=(12, 6))
# Stack bars on top of each other
ax.bar(quarters, electronics, label='Electronics',
color='#2E86AB', edgecolor='black', linewidth=1.5)
ax.bar(quarters, clothing, bottom=electronics, label='Clothing',
color='#06A77D', edgecolor='black', linewidth=1.5)
ax.bar(quarters, home_goods,
bottom=np.array(electronics) + np.array(clothing),
label='Home Goods', color='#D9A72E', edgecolor='black', linewidth=1.5)
ax.set_title('Quarterly Revenue by Product Line - 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Revenue', fontsize=12)
# Format Y-axis
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1e6:.1f}M'))
ax.legend(loc='upper left', fontsize=11)
ax.grid(True, alpha=0.3, axis='y')
plt.tight_layout()
plt.show()
Output:
[Bar chart: “Quarterly Revenue by Product Line - 2024”, x: Quarter, y: Revenue]
Stacked Bar Logic:
bottom=first_series to stack on topbottom=first_series + second_seriesWhen to Use Stacked Bars:
Warning: Stacked bars make it hard to compare middle sections. Only the bottom section and total are easy to compare.
Line Charts - Temporal Trends and Continuous Data
The Time Series Specialist:
Line charts are the default for showing change over time because:
When Line Charts Excel:
Professional Line Chart:
import matplotlib.pyplot as plt
# Monthly website traffic
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
visitors = [245000, 268000, 252000, 289000, 312000, 335000,
358000, 342000, 375000, 398000, 425000, 448000]
fig, ax = plt.subplots(figsize=(12, 6))
ax.plot(months, visitors, marker='o', linewidth=2.5, markersize=8,
color='#2E86AB')
# Highlight peak month
max_idx = visitors.index(max(visitors))
ax.plot(months[max_idx], visitors[max_idx], marker='*',
markersize=20, color='#E74C3C', zorder=3)
ax.set_title('Website Traffic - 2024 Monthly Performance',
fontsize=14, fontweight='bold')
ax.set_xlabel('Month', fontsize=12)
ax.set_ylabel('Monthly Visitors', fontsize=12)
# Format Y-axis with K suffix
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1000:.0f}K'))
# Annotate peak
ax.annotate(f'Peak: {max(visitors):,} visitors',
xy=(months[max_idx], visitors[max_idx]),
xytext=(10, -30), textcoords='offset points',
fontsize=10, color='#E74C3C',
bbox=dict(boxstyle='round,pad=0.5', facecolor='yellow', alpha=0.7),
arrowprops=dict(arrowstyle='->', color='#E74C3C', lw=2))
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
Output:
[Line chart: “Website Traffic - 2024 Monthly Performance”, x: Month, y: Monthly Visitors]
Advanced Line Chart Features:
Pie Charts - Use Sparingly and Wisely
The Controversial Chart:
Pie charts are controversial in data visualization:
When Pie Charts Work:
When to Avoid Pie Charts:
Creating an Effective Pie Chart:
import matplotlib.pyplot as plt
# Market share (simple, clear story)
companies = ['Our Company', 'Competitor A', 'Competitor B', 'Others']
market_share = [35, 28, 22, 15]
fig, ax = plt.subplots(figsize=(10, 8))
# Create pie chart
colors = ['#2E86AB', '#7FB3D5', '#A3C9E2', '#CCCCCC']
explode = (0.1, 0, 0, 0) # Emphasize our company
wedges, texts, autotexts = ax.pie(market_share,
labels=companies,
autopct='%1.1f%%',
startangle=90,
colors=colors,
explode=explode,
shadow=True)
# Format text
for text in texts:
text.set_fontsize(12)
text.set_fontweight('bold')
for autotext in autotexts:
autotext.set_color('white')
autotext.set_fontsize(11)
autotext.set_fontweight('bold')
ax.set_title('Smartphone Market Share - Q4 2024',
fontsize=14, fontweight='bold', pad=20)
plt.tight_layout()
plt.show()
Output:
[Pie chart: “Smartphone Market Share - Q4 2024”]
Pie Chart Best Practices:
Better Alternatives to Pie Charts:
For most situations, consider:
Choosing the Right Chart Type
Decision Framework:
Question: How do categories compare? → Bar Chart (vertical or horizontal)
Question: How has this changed over time? → Line Chart
Question: What is the composition of this whole? → Stacked Bar Chart or Pie Chart (if 2-3 categories)
Question: How do multiple groups compare across categories? → Grouped Bar Chart
Question: What is the relationship between two variables? → Scatter Plot (covered in Section 1)
Chart Selection Table:
| Data Type | Best Chart | When to Use | Avoid If |
|---|---|---|---|
| Categories vs Values | Vertical Bar | Few categories, short names | >12 categories |
| Categories vs Values | Horizontal Bar | Long names, many categories, rankings | Categories unordered |
| Time Series | Line Chart | Continuous data, trends important | Few time points |
| Comparison Over Time | Grouped Bar | 2-4 groups, emphasis on periods | Many groups |
| Part-to-Whole | Stacked Bar | Composition changes, total matters | >5 components |
| Part-to-Whole | Pie Chart | 2-4 categories, simple message | Precise comparison needed |
Lab 4: Comprehensive Business Charts
Objective: Master bar charts, line charts, and pie charts by creating a complete analytical report for a business scenario.
Scenario: You’re the Data Analyst at “MetroMart Retail,” a regional supermarket chain. The Annual Strategy Meeting is approaching, and leadership needs comprehensive visualizations analyzing 2024 performance across products, time, regions, and categories. You’ll create a professional analytical report with multiple chart types.
Pre-Lab Setup:
M2L04_YourName_BusinessCharts.pyPart A: Product Category Performance (25 points)
Context: The Merchandising VP needs to see which product categories drove the most revenue.
Data:
categories = ['Fresh Produce', 'Dairy & Eggs', 'Meat & Seafood',
'Bakery', 'Frozen Foods', 'Beverages', 'Snacks', 'Health & Beauty']
annual_revenue = [4850000, 3920000, 3650000, 2180000, 2950000,
3120000, 2680000, 1850000]Tasks:
Create professional vertical bar chart (15 points):
Format professionally (10 points):
M2L04_YourName_CategoryRevenue.pngPart B: Monthly Sales Trend Analysis (25 points)
Context: The Finance team needs to see monthly revenue patterns to identify seasonality and trends.
Data:
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
monthly_revenue = [2180000, 2050000, 2320000, 2280000, 2450000, 2390000,
2520000, 2480000, 2350000, 2580000, 2850000, 3150000]Tasks:
Create trend line chart (12 points):
Add analytical features (8 points):
Professional formatting (5 points):
M2L04_YourName_MonthlyTrend.pngPart C: Regional Comparison (25 points)
Context: Operations needs to compare performance across store regions.
Data:
regions = ['Downtown Metro', 'Suburban North', 'Suburban South',
'Suburban East', 'Suburban West', 'Urban Center']
q1_sales = [2850000, 3120000, 2980000, 2750000, 3050000, 2890000]
q2_sales = [3020000, 3280000, 3150000, 2920000, 3180000, 3050000]
q3_sales = [2950000, 3180000, 3080000, 2850000, 3120000, 2980000]
q4_sales = [3350000, 3580000, 3420000, 3180000, 3450000, 3280000]Tasks:
Create horizontal bar chart for total annual sales (15 points):
Add data labels (5 points):
Format and save (5 points):
M2L04_YourName_RegionalSales.pngPart D: Quarterly Performance Grouped Bars (25 points)
Context: Strategic planning needs quarterly performance comparison for top 4 product categories.
Data:
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
produce = [1150000, 1220000, 1180000, 1300000]
dairy = [980000, 1020000, 950000, 970000]
meat = [890000, 920000, 910000, 930000]
frozen = [720000, 750000, 730000, 750000]Tasks:
Create grouped bar chart (15 points):
Professional formatting (10 points):
M2L04_YourName_QuarterlyGrouped.pngPart E: Market Composition Pie Chart (Optional - 20 points)
Context: The executive summary needs a simple visual showing revenue composition by major category groups.
Data:
category_groups = ['Perishables', 'Packaged Goods', 'Non-Food']
revenue_by_group = [14900000, 8750000, 1850000]Tasks:
Create effective pie chart (15 points):
Professional presentation (5 points):
M2L04_YourName_Composition.pngBonus Challenge (+25 points):
Create a Comprehensive Dashboard Combining Multiple Chart Types:
Using all the data provided above, create ONE figure that combines:
Requirements:
M2L04_YourName_Dashboard.pngDeliverables:
M2L04_YourName_BusinessCharts.pyM2L04_YourName_CategoryRevenue.pngM2L04_YourName_MonthlyTrend.pngM2L04_YourName_RegionalSales.pngM2L04_YourName_QuarterlyGrouped.pngM2L04_YourName_Composition.png (if Part E attempted)M2L04_YourName_Dashboard.png (if bonus attempted)Grading Rubric:
Success Criteria:
Chart Selection Checklist:
Before creating each chart, ask: - [ ] Is this categorical comparison? → Bar chart - [ ] Is this showing change over time? → Line chart - [ ] Do I need to compare groups? → Grouped bars - [ ] Am I showing composition? → Stacked bars or pie - [ ] Are there many categories? → Horizontal bars - [ ] Do labels fit? → Rotate or use horizontal layout
Professional Touches:
End of Module 2: Core Visualization with Matplotlib
Key Takeaways:
What is Seaborn and Why Use It?
The Evolution Beyond Matplotlib:
While Matplotlib gives you complete control, it requires significant code for common statistical visualizations. Seaborn was created to solve this problem by providing:
A Revealing Comparison:
Consider creating a visualization showing the relationship between two variables with a regression line:
Matplotlib approach: 30+ lines of code
Seaborn approach: 1 line of code
df = pd.DataFrame({
'advertising_spend': np.random.uniform(1000, 50000, 50),
'revenue': np.random.uniform(10000, 500000, 50)
})
sns.regplot(data=df, x='advertising_spend', y='revenue')
plt.show()
Output:
[Regression scatter plot: x: advertising_spend, y: revenue]
Seaborn handles all statistical calculations and styling automatically.
When to Use Each Library:
Use Matplotlib when:
Use Seaborn when:
Important Understanding: Seaborn is built on top of Matplotlib, not a replacement. You’ll often use both together - Seaborn for the plot structure, Matplotlib for fine-tuning.
Installing and Importing Seaborn
Installation:
Seaborn should already be installed from Module 1, but if needed:
pip install seabornStandard Import Convention:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pdThe alias sns is universally used (named after Samuel Norman Seaborn, a character from “The West Wing” TV show).
Version Check:
import seaborn as sns
print(sns.__version__) # Should be 0.12 or higher0.13.2Output:
[Chart]
Seaborn’s Theme and Style System
The Aesthetic Advantage:
One of Seaborn’s most appreciated features is its built-in aesthetic system. With one line, you can transform your visualizations from basic to professional.
Setting Overall Style:
Seaborn provides five preset themes:
import seaborn as sns
import matplotlib.pyplot as plt
# Available styles:
sns.set_style("darkgrid") # Dark background with grid (default)
sns.set_style("whitegrid") # White background with grid
sns.set_style("dark") # Dark background, no grid
sns.set_style("white") # White background, no grid
sns.set_style("ticks") # White background with tick marksOutput:
[Chart]
Style Characteristics:
Understanding Context:
Seaborn also provides context settings that scale all elements appropriately for different uses:
# Contexts scale font sizes and element sizes
sns.set_context("paper") # Smallest, for journal papers
sns.set_context("notebook") # Default, good for screen viewing
sns.set_context("talk") # Larger, for presentations
sns.set_context("poster") # Largest, for posters/large displaysOutput:
[Chart]
Business Context Usage:
Color Palettes:
Seaborn provides sophisticated color palettes designed by professionals:
# Set color palette
sns.set_palette("deep") # Deep, saturated colors (default)
sns.set_palette("muted") # Softer, muted colors (professional)
sns.set_palette("bright") # Bright, vibrant colors
sns.set_palette("pastel") # Pastel colors (subtle)
sns.set_palette("dark") # Dark colors
sns.set_palette("colorblind") # Colorblind-safe palette (recommended!)Output:
[Chart]
Professional Setup for Business:
import seaborn as sns
import matplotlib.pyplot as plt
# Configure for business presentations
sns.set_theme(style="whitegrid", # Clean, professional
context="talk", # Large enough for presentations
palette="colorblind") # Accessible to allOutput:
[Chart]
This single setup ensures all subsequent Seaborn plots have a professional, accessible appearance.
Understanding Seaborn’s Two Interfaces
A Critical Concept:
Seaborn has two types of functions, and understanding the difference is essential:
1. Figure-level functions (newer, recommended):
relplot(), displot(), catplot()2. Axes-level functions (older, more control):
histplot(), boxplot(), scatterplot()Practical Example:
df = pd.DataFrame({'sales': np.random.normal(50000, 15000, 200)})
# Axes-level: You control the figure
fig, ax = plt.subplots(figsize=(8, 5))
sns.histplot(data=df, x='sales', ax=ax)
ax.set_title('Sales Distribution')
plt.show()
# Figure-level: Seaborn controls the figure
sns.displot(data=df, x='sales', height=6, aspect=1.67)
plt.show()
Output:
[Distribution plot: “Sales Distribution”, x: sales]
Which to Use?
Histograms - Understanding Data Distribution
Why Histograms Matter in Business:
Before making decisions based on averages, you must understand the distribution:
Histograms answer these questions visually by showing:
Creating a Histogram with Seaborn:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
# Sample data: Customer purchase amounts
data = {
'purchase_amount': [45, 52, 48, 61, 58, 63, 55, 72, 68, 51,
88, 45, 59, 67, 73, 49, 56, 78, 82, 65,
92, 54, 61, 75, 69, 57, 64, 71, 85, 58]
}
df = pd.DataFrame(data)
# Create histogram
fig, ax = plt.subplots(figsize=(8, 5))
sns.histplot(data=df, x='purchase_amount', bins=10,
kde=False, color='#2E86AB', ax=ax)
ax.set_title('Distribution of Customer Purchase Amounts',
fontsize=14, fontweight='bold')
ax.set_xlabel('Purchase Amount ($)', fontsize=12)
ax.set_ylabel('Number of Customers', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Distribution plot: “Distribution of Customer Purchase Amounts”, x: Purchase Amount ($), y: Number of Customers]
Understanding Histogram Parameters:
kde=True adds a smooth line over the barsReading the Story:
Looking at a histogram, ask:
Business Interpretation Example:
A histogram of customer purchase amounts showing:
KDE Plots - Smooth Distribution Curves
Beyond Histogram Bars:
Kernel Density Estimation (KDE) creates a smooth curve representing the data distribution. Think of it as a smoothed histogram that’s easier to compare across groups.
Advantages of KDE:
Creating a KDE Plot:
import seaborn as sns
import matplotlib.pyplot as plt
# Revenue data for two product lines
product_a_revenue = [45, 52, 48, 61, 58, 63, 55, 72, 68, 51, 59, 67, 73]
product_b_revenue = [38, 42, 45, 39, 51, 48, 43, 55, 52, 46, 49, 58, 61]
df = pd.DataFrame({
'revenue': product_a_revenue + product_b_revenue,
'product': ['A']*len(product_a_revenue) + ['B']*len(product_b_revenue)
})
fig, ax = plt.subplots(figsize=(8, 5))
# KDE plots for both products
sns.kdeplot(data=df, x='revenue', hue='product',
fill=True, alpha=0.5, linewidth=2, ax=ax)
ax.set_title('Revenue Distribution Comparison: Product A vs B',
fontsize=14, fontweight='bold')
ax.set_xlabel('Revenue ($1000s)', fontsize=12)
ax.set_ylabel('Density', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Distribution plot: “Revenue Distribution Comparison: Product A vs B”, x: Revenue ($1000s), y: Density]
KDE Parameters Explained:
Interpreting KDE Plots:
The Y-axis shows “density” - not counts, but relative concentration:
Business Use Case:
Comparing customer lifetime value distributions across regions:
Box Plots - The Statistical Summary
The Five-Number Summary:
Box plots (also called box-and-whisker plots) compress a distribution into five key statistics:
Why Box Plots Matter:
In business, you often need to compare distributions across categories:
Box plots excel at this by showing multiple distributions side-by-side compactly.
Anatomy of a Box Plot:
Outlier •
-------- Maximum (within 1.5×IQR of Q3)
|
┌───┐
│ │ Q3 (75th percentile)
│---│ Median (50th percentile) ← Line inside box
│ │ Q1 (25th percentile)
└───┘
|
-------- Minimum (within 1.5×IQR of Q1)
Outlier •Creating Box Plots:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
# Salesperson performance across regions
data = {
'region': ['North']*15 + ['South']*15 + ['East']*15 + ['West']*15,
'sales': [
# North: generally higher, consistent
145, 152, 148, 161, 158, 163, 155, 172, 168, 151, 159, 167, 173, 149, 156,
# South: lower, more variable
112, 128, 115, 135, 122, 138, 125, 148, 132, 119, 127, 141, 152, 118, 129,
# East: highest performance
168, 175, 172, 181, 178, 183, 175, 192, 188, 171, 179, 187, 193, 169, 176,
# West: mixed, with outliers
141, 145, 98, 162, 148, 155, 143, 178, 152, 146, 149, 165, 172, 142, 151
]
}
df = pd.DataFrame(data)
fig, ax = plt.subplots(figsize=(8, 5))
sns.boxplot(data=df, x='region', y='sales',
palette='Set2', ax=ax)
ax.set_title('Sales Performance by Region - Q4 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Region', fontsize=12)
ax.set_ylabel('Sales ($1000s)', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Box plot: “Sales Performance by Region - Q4 2024”, x: Region, y: Sales ($1000s)]
Reading Box Plots for Business Insights:
1. Compare Medians (center lines):
2. Compare Box Heights (IQR - interquartile range):
3. Identify Outliers (dots beyond whiskers):
4. Compare Whisker Ranges:
Business Application:
A CFO looking at departmental budget variance box plots:
Lab 1: Statistical Visualization Fundamentals
Objective: Master Seaborn’s foundational capabilities by creating professional statistical visualizations that reveal data distributions and enable comparisons.
Scenario: You’re the Analytics Manager at “HealthyLife Fitness,” a gym chain with 500+ members. The executive team is reviewing Q4 performance and needs statistical visualizations to understand member behavior, revenue patterns, and facility usage. Your task is to create a comprehensive statistical analysis report.
Pre-Lab Setup:
S1234567_YourName_StatPlots.pyimport seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as npsns.set_theme(style="whitegrid", context="talk", palette="colorblind")Part A: Member Age Distribution Analysis (25 points)
Context: The marketing team wants to understand the age demographics of your membership to target advertising effectively.
Data:
# Generate realistic age distribution (you'll learn to load real data later)
np.random.seed(42)
member_ages = np.concatenate([
np.random.normal(28, 5, 150), # Young professionals
np.random.normal(45, 8, 200), # Middle-aged
np.random.normal(65, 6, 100), # Seniors
np.random.uniform(18, 75, 50) # Random others
])
member_ages = member_ages[(member_ages >= 18) & (member_ages <= 80)]
df_ages = pd.DataFrame({'age': member_ages})Tasks:
Create a histogram with KDE overlay (15 points):
sns.histplot() with kde=TrueInterpret the distribution (10 points):
ax.axvline(df_ages['age'].median(), color='red', linestyle='--', linewidth=2, label='Median Age')Save the visualization:
S1234567_YourName_AgeDistribution.pngPart B: Revenue Distribution Comparison (30 points)
Context: The finance director needs to compare monthly revenue distributions across different membership tiers (Basic, Premium, Elite) to assess pricing strategy effectiveness.
Data:
np.random.seed(42)
basic_revenue = np.random.normal(450, 75, 180) # Basic: $450 avg
premium_revenue = np.random.normal(850, 120, 150) # Premium: $850 avg
elite_revenue = np.random.normal(1500, 200, 70) # Elite: $1500 avg
df_revenue = pd.DataFrame({
'monthly_revenue': np.concatenate([basic_revenue, premium_revenue, elite_revenue]),
'tier': ['Basic']*180 + ['Premium']*150 + ['Elite']*70
})Tasks:
Create overlapping KDE plots (15 points):
sns.kdeplot() with:
x='monthly_revenue'hue='tier'fill=Truealpha=0.5linewidth=2.5Add reference lines (10 points):
df_revenue.groupby('tier')['monthly_revenue'].mean()Business interpretation (5 points):
S1234567_YourName_RevenueTiers.pngPart C: Facility Usage Box Plot Comparison (25 points)
Context: Operations needs to compare average weekly gym visits across different times of day and days of week to optimize staffing.
Data:
np.random.seed(42)
# Weekly visits by time of day
morning_visits = np.random.poisson(12, 100) # Morning: avg 12/week
afternoon_visits = np.random.poisson(8, 100) # Afternoon: avg 8/week
evening_visits = np.random.poisson(15, 100) # Evening: avg 15/week (busiest)
night_visits = np.random.poisson(5, 100) # Night: avg 5/week
df_visits = pd.DataFrame({
'weekly_visits': np.concatenate([morning_visits, afternoon_visits,
evening_visits, night_visits]),
'time_period': ['Morning (6-10am)']*100 + ['Afternoon (10am-4pm)']*100 +
['Evening (4-8pm)']*100 + ['Night (8pm-12am)']*100
})Tasks:
Create professional box plot (15 points):
sns.boxplot() with:
x='time_period'y='weekly_visits'Enhance with statistical information (10 points):
Save and document:
S1234567_YourName_UsageByTime.pngPart D: Multi-Facility Comparison (20 points)
Context: The VP of Operations oversees 5 locations and needs to compare member satisfaction scores across facilities to identify underperforming locations.
Data:
np.random.seed(42)
facilities = ['Downtown', 'Suburban North', 'Suburban South', 'University District', 'Business Park']
all_scores = []
all_facilities = []
for facility in facilities:
if facility == 'University District':
scores = np.random.normal(4.8, 0.3, 80) # Highest satisfaction
elif facility == 'Business Park':
scores = np.random.normal(3.9, 0.7, 60) # Lowest, most variable
else:
scores = np.random.normal(4.3, 0.5, 70) # Average
scores = np.clip(scores, 1, 5) # Keep between 1-5
all_scores.extend(scores)
all_facilities.extend([facility] * len(scores))
df_satisfaction = pd.DataFrame({
'facility': all_facilities,
'satisfaction_score': all_scores
})Tasks:
Create comparison box plot (12 points):
orient='h' or swap x/y)Add performance benchmarks (8 points):
ax.axvspan() for shadingSave and analyze:
S1234567_YourName_FacilitySatisfaction.pngBonus Challenge (+20 points):
Create a Comprehensive Statistical Dashboard:
Combine all four analyses into a single 2×2 subplot figure:
Additional Requirements:
S1234567_YourName_Dashboard.pngDeliverables:
S1234567_YourName_StatPlots.pyS1234567_YourName_AgeDistribution.pngS1234567_YourName_RevenueTiers.pngS1234567_YourName_UsageByTime.pngS1234567_YourName_FacilitySatisfaction.pngS1234567_YourName_Dashboard.png (bonus)Grading Rubric:
Success Criteria:
Statistical Interpretation Guide:
When analyzing distributions, always assess: 1. Central Tendency: Where is the typical value? (mean/median) 2. Spread: How variable is the data? (range, IQR) 3. Shape: Symmetric? Skewed? Multiple peaks? 4. Outliers: Any unusual values? Why? 5. Comparisons: How do groups differ?
Common Mistakes to Avoid:
Tips for Success:
Beyond Single Variables - Exploring Relationships
The Business Reality:
Most business questions involve relationships between variables:
Single-variable distributions (histograms, box plots) don’t answer these questions. We need bivariate visualizations that show two variables simultaneously.
Types of Relationships to Explore:
1. Positive Correlation:
2. Negative Correlation:
3. No Correlation:
4. Non-linear Relationship:
Scatter Plots with Regression Lines
The Foundation of Relationship Analysis:
We introduced scatter plots in Module 2, but Seaborn enhances them significantly by adding statistical elements automatically.
Seaborn’s regplot() - Scatter + Regression:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sample data: Marketing spend vs Revenue
np.random.seed(42)
marketing_spend = np.linspace(10000, 100000, 50)
revenue = 50000 + 2.5 * marketing_spend + np.random.normal(0, 30000, 50)
df = pd.DataFrame({
'marketing_spend': marketing_spend,
'revenue': revenue
})
fig, ax = plt.subplots(figsize=(8, 5))
# Create scatter plot with regression line
sns.regplot(data=df, x='marketing_spend', y='revenue',
scatter_kws={'alpha': 0.6, 's': 80},
line_kws={'color': 'red', 'linewidth': 2},
ax=ax)
ax.set_title('Marketing Spend vs Revenue Analysis',
fontsize=14, fontweight='bold')
ax.set_xlabel('Marketing Spend ($)', fontsize=12)
ax.set_ylabel('Revenue ($)', fontsize=12)
# Format axes
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
plt.tight_layout()
plt.show()
Output:
[Regression scatter plot: “Marketing Spend vs Revenue Analysis”, x: Marketing Spend (\(), y: Revenue (\))]
What regplot() Provides Automatically:
Understanding the Confidence Interval:
The shaded area represents uncertainty in our estimate:
Business Application:
Looking at the marketing spend plot:
Joint Plots - Combining Multiple Perspectives
The Multi-View Approach:
Joint plots are one of Seaborn’s most powerful features, combining three visualizations in one figure:
This provides comprehensive understanding:
Creating a Joint Plot:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Employee data: Years of experience vs Salary
np.random.seed(42)
experience = np.random.uniform(0, 20, 100)
salary = 40000 + 3500 * experience + np.random.normal(0, 8000, 100)
df = pd.DataFrame({
'years_experience': experience,
'salary': salary
})
# Create joint plot
g = sns.jointplot(data=df, x='years_experience', y='salary',
kind='reg', # Includes regression line
height=8,
color='#2E86AB')
# Customize
g.fig.suptitle('Employee Compensation Analysis: Experience vs Salary',
fontsize=14, fontweight='bold', y=1.02)
g.set_axis_labels('Years of Experience', 'Annual Salary ($)', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Joint plot: “Employee Compensation Analysis: Experience vs Salary”, x: years_experience, y: salary]
Joint Plot “kind” Options:
Seaborn offers several relationship types:
1. kind=‘scatter’ (default)
2. kind=‘reg’
3. kind=‘kde’
4. kind=‘hex’
Reading a Joint Plot:
Top histogram:
Right histogram:
Center scatter:
Business Insights Example:
From employee compensation joint plot:
Pair Plots - Multivariate Exploration
The “Look at Everything” Tool:
In business, you often have many variables and don’t know which relationships matter. Pair plots solve this by creating a matrix of visualizations showing all possible pairs.
Example Scenario:
You have data on:
Which variables correlate? Pair plots show all relationships at once.
Creating a Pair Plot:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sample customer data
np.random.seed(42)
n = 100
df_customers = pd.DataFrame({
'age': np.random.normal(40, 15, n),
'income': np.random.normal(65000, 25000, n),
'years_customer': np.random.uniform(0, 10, n),
'avg_purchase': np.random.normal(150, 50, n)
})
# Ensure reasonable values
df_customers['age'] = df_customers['age'].clip(18, 80)
df_customers['income'] = df_customers['income'].clip(20000, 200000)
df_customers['avg_purchase'] = df_customers['avg_purchase'].clip(20, 500)
# Create pair plot
g = sns.pairplot(df_customers,
diag_kind='kde', # Distribution on diagonal
plot_kws={'alpha': 0.6},
height=2.5)
g.fig.suptitle('Customer Metrics - Pairwise Relationship Analysis',
fontsize=14, fontweight='bold', y=1.01)
plt.tight_layout()
plt.show()
Output:
[Pair plot: “Customer Metrics - Pairwise Relationship Analysis”]
Understanding the Pair Plot Grid:
Diagonal (top-left to bottom-right):
Off-diagonal:
Reading Strategy:
Business Application - Customer Segmentation:
From the pair plot, you might discover:
Adding Categories with Hue:
# Add customer segment
df_customers['segment'] = pd.cut(df_customers['income'],
bins=[0, 50000, 100000, 300000],
labels=['Budget', 'Standard', 'Premium'])
# Pair plot with segments colored
g = sns.pairplot(df_customers,
hue='segment', # Color by segment
palette='Set2',
diag_kind='kde',
height=2.5)
plt.tight_layout()
plt.show()
Output:
[Pair plot]
Now each scatter plot shows three colors (Budget, Standard, Premium), revealing:
Residual Plots - Assessing Model Quality
Beyond the Line - How Good is the Fit?
A regression line looks nice, but how well does it actually fit the data? Residual plots answer this question.
What are Residuals?
Residuals are the differences between actual values and predicted values:
Why Residuals Matter:
A good linear regression should have residuals that: 1. Randomly scattered: No pattern around zero 2. Constant spread: Same variance throughout 3. Normally distributed: Roughly bell-shaped
If residuals show patterns, the linear model may be inappropriate.
Creating a Residual Plot:
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# Create data with different patterns
np.random.seed(42)
# Good linear fit
x_good = np.linspace(0, 10, 100)
y_good = 2 * x_good + 5 + np.random.normal(0, 2, 100)
# Non-linear pattern (quadratic)
x_bad = np.linspace(0, 10, 100)
y_bad = 2 * x_bad**2 + np.random.normal(0, 5, 100)
fig, axes = plt.subplots(1, 2, figsize=(14, 6))
# Good fit residual plot
sns.residplot(x=x_good, y=y_good,
lowess=True,
scatter_kws={'alpha': 0.5},
line_kws={'color': 'red', 'linewidth': 2},
ax=axes[0])
axes[0].set_title('Good Linear Fit\n(Random Scatter)',
fontsize=12, fontweight='bold')
axes[0].set_xlabel('X Variable')
axes[0].set_ylabel('Residuals')
axes[0].axhline(0, color='black', linestyle='--', linewidth=1)
# Poor fit residual plot
sns.residplot(x=x_bad, y=y_bad,
lowess=True,
scatter_kws={'alpha': 0.5},
line_kws={'color': 'red', 'linewidth': 2},
ax=axes[1])
axes[1].set_title('Poor Linear Fit\n(Curved Pattern)',
fontsize=12, fontweight='bold')
axes[1].set_xlabel('X Variable')
axes[1].set_ylabel('Residuals')
axes[1].axhline(0, color='black', linestyle='--', linewidth=1)
plt.tight_layout()
plt.show()
Output:
[Chart: “Good Linear Fit(Random Scatter)”, 1×2 subplot grid, x: X Variable, y: Residuals]
Interpreting Residual Plots:
Good Pattern (Left):
Bad Pattern (Right):
Other Warning Signs:
Fan shape (heteroscedasticity):
Outliers:
Business Example:
Scenario: Modeling sales based on advertising spend
Residual plot shows curve:
Interpretation: Relationship is non-linear (diminishing returns at high spend)
Action: Use polynomial or log model instead of linear
Practical Workflow for Relationship Analysis
Step-by-Step Business Analysis Process:
When exploring relationships in business data:
Step 1: Pair Plot Overview
Step 2: Deep Dive with Joint Plots
kind='reg')Step 3: Verify with Residual Plot
Step 4: Business Interpretation
Complete Example Workflow:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sample sales data
np.random.seed(42)
df_sales = pd.DataFrame({
'ad_spend': np.random.uniform(5000, 50000, 100),
'sales_calls': np.random.poisson(30, 100),
'revenue': np.random.normal(100000, 30000, 100),
'customer_satisfaction': np.random.uniform(3.5, 5.0, 100)
})
# Add realistic relationships
df_sales['revenue'] = (50000 +
1.2 * df_sales['ad_spend'] +
500 * df_sales['sales_calls'] +
np.random.normal(0, 10000, 100))
# Step 1: Pair plot overview
sns.pairplot(df_sales)
plt.suptitle('Sales Data - Initial Exploration', y=1.01)
plt.show()
# Step 2: Deep dive - Ad Spend vs Revenue
g = sns.jointplot(data=df_sales, x='ad_spend', y='revenue',
kind='reg', height=8)
g.fig.suptitle('Deep Dive: Advertising Impact on Revenue', y=1.02)
plt.show()
# Step 3: Check residuals
fig, ax = plt.subplots(figsize=(8, 5))
sns.residplot(data=df_sales, x='ad_spend', y='revenue',
lowess=True, ax=ax)
ax.set_title('Residual Analysis: Ad Spend Model')
ax.axhline(0, color='black', linestyle='--')
plt.show()
# Step 4: Quantify (calculate correlation)
correlation = df_sales[['ad_spend', 'revenue']].corr().iloc[0, 1]
print(f"Correlation between Ad Spend and Revenue: {correlation:.3f}")
Correlation between Ad Spend and Revenue: 0.834Output:
[Pair plot: “Residual Analysis: Ad Spend Model”, x: ad_spend, y: revenue]
Statistical Significance and Business Decisions
Understanding Correlation Strength:
Correlation coefficients range from -1 to +1:
Business Decision Framework:
Correlation = 0.85 (Strong):
Correlation = 0.35 (Weak):
Remember: Correlation ≠ Causation
Just because two variables correlate doesn’t mean one causes the other:
Always ask: Could a third variable explain both?
Lab 2: Relationship and Correlation Analysis
Objective: Master bivariate analysis techniques to uncover, visualize, and interpret relationships between business variables for predictive insights.
Scenario: You’re the Business Intelligence Analyst at “TechStart Solutions,” a B2B software company with 200+ customers. The executive team is planning 2025 strategy and needs data-driven insights about what drives customer success, revenue growth, and satisfaction. Your mission is to analyze relationships between key business metrics to guide strategic decisions.
Pre-Lab Setup:
M3L02_YourName_Relationships.pyimport seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
sns.set_theme(style="whitegrid", context="talk", palette="colorblind")Part A: Customer Success Metrics Exploration (30 points)
Context: Your Customer Success VP wants to understand which factors correlate with customer satisfaction to prioritize improvement efforts.
Data:
np.random.seed(42)
n_customers = 200
# Generate realistic customer data
df_customers = pd.DataFrame({
'customer_id': range(1, n_customers + 1),
'contract_value': np.random.uniform(5000, 100000, n_customers),
'support_tickets': np.random.poisson(8, n_customers),
'response_time_hours': np.random.exponential(12, n_customers),
'features_used': np.random.randint(3, 25, n_customers),
'satisfaction_score': np.random.uniform(2.5, 5.0, n_customers)
})
# Create realistic relationships
df_customers['satisfaction_score'] = (
3.0 +
0.00001 * df_customers['contract_value'] + # Higher value → slightly higher satisfaction
-0.08 * df_customers['support_tickets'] + # More tickets → lower satisfaction
-0.03 * df_customers['response_time_hours'] + # Slower response → lower satisfaction
0.04 * df_customers['features_used'] + # More features → higher satisfaction
np.random.normal(0, 0.3, n_customers)
)
# Clip to valid range
df_customers['satisfaction_score'] = df_customers['satisfaction_score'].clip(1.0, 5.0)Tasks:
Create comprehensive pair plot (15 points):
Identify key relationships (10 points):
Save and document (5 points):
M3L02_YourName_CustomerPairplot.pngPart B: Deep Dive - Support Response Time Impact (30 points)
Context: The support team is debating whether faster response times truly impact satisfaction. They need statistical evidence to justify hiring more support staff.
Tasks:
Create joint plot analysis (15 points):
kind='reg' to include regression lineAnalyze the relationship (10 points):
Create residual plot (5 points):
M3L02_YourName_ResponseTimeJoint.pngM3L02_YourName_ResponseResiduals.pngPart C: Revenue Drivers Analysis (25 points)
Context: The Sales and Marketing teams are arguing about what drives revenue. Marketing says features used (product engagement) matters most. Sales says it’s all about contract value and relationship (support interactions). Settle the debate with data.
Data preparation:
# Add revenue data with realistic relationships
df_customers['annual_revenue'] = (
df_customers['contract_value'] * 1.2 + # Base revenue from contract
500 * df_customers['features_used'] + # Upsell from feature usage
-1000 * df_customers['support_tickets'] + # Cost of support
np.random.normal(0, 5000, n_customers)
)
df_customers['annual_revenue'] = df_customers['annual_revenue'].clip(0, None)Tasks:
Create three regression plots (18 points):
Comparative analysis (7 points):
M3L02_YourName_RevenueDrivers.pngPart D: Customer Segmentation Insights (15 points)
Context: The Product team wants to understand if customer behavior differs by company size (small, medium, large based on contract value).
Tasks:
# Create size segments
df_customers['company_size'] = pd.cut(df_customers['contract_value'],
bins=[0, 25000, 60000, 150000],
labels=['Small', 'Medium', 'Large'])Create segmented pair plot (10 points):
hue='company_size' to color by segmentM3L02_YourName_Segmentation.pngBonus Challenge (+25 points):
Predictive Model Validation:
Build a comprehensive analysis demonstrating whether you can predict satisfaction from other metrics:
Requirements:
Create a regression plot showing predicted vs actual satisfaction:
Create comprehensive residual analysis:
Business recommendations document:
Save all bonus deliverables with clear names
Deliverables:
M3L02_YourName_Relationships.pyM3L02_YourName_CustomerPairplot.pngM3L02_YourName_ResponseTimeJoint.pngM3L02_YourName_ResponseResiduals.pngM3L02_YourName_RevenueDrivers.pngM3L02_YourName_Segmentation.pngGrading Rubric:
Success Criteria:
Statistical Analysis Checklist:
For each relationship analyzed, document:
Common Pitfalls to Avoid:
Professional Tips:
The Nature of Categorical Data in Business
Understanding Categorical Variables:
In business, many critical variables are categorical (also called qualitative or nominal):
Why Categorical Data Requires Different Visualizations:
Unlike continuous variables (revenue, age, temperature), categorical variables:
Business Questions Answered by Categorical Visualizations:
Count Plots - Visualizing Frequencies
The Most Basic Categorical Question: “How Many?”
Count plots are the categorical equivalent of histograms - they show how many observations fall into each category.
Business Use Cases:
Creating a Count Plot:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sample data: Customer segments
np.random.seed(42)
segments = np.random.choice(['Budget', 'Standard', 'Premium', 'Enterprise'],
size=500,
p=[0.4, 0.35, 0.20, 0.05]) # Weighted probabilities
df = pd.DataFrame({'segment': segments})
fig, ax = plt.subplots(figsize=(8, 5))
sns.countplot(data=df, x='segment',
order=['Budget', 'Standard', 'Premium', 'Enterprise'],
palette='Set2', ax=ax)
ax.set_title('Customer Distribution by Segment',
fontsize=14, fontweight='bold')
ax.set_xlabel('Customer Segment', fontsize=12)
ax.set_ylabel('Number of Customers', fontsize=12)
# Add count labels on bars
for container in ax.containers:
ax.bar_label(container, fontsize=11)
plt.tight_layout()
plt.show()
Output:
[Count plot: “Customer Distribution by Segment”, x: Customer Segment, y: Number of Customers]
Key Parameters Explained:
Adding Percentages:
# Calculate and display percentages
total = len(df)
fig, ax = plt.subplots(figsize=(8, 5))
sns.countplot(data=df, x='segment',
order=['Budget', 'Standard', 'Premium', 'Enterprise'],
palette='Set2', ax=ax)
# Add percentage labels
for container in ax.containers:
labels = [f'{int(v.get_height())}\n({v.get_height()/total*100:.1f}%)'
for v in container]
ax.bar_label(container, labels=labels, fontsize=10)
ax.set_title('Customer Distribution by Segment (with Percentages)',
fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Count plot: “Customer Distribution by Segment (with Percentages)”, x: segment]
Business Interpretation:
From the count plot:
Bar Plots - Showing Aggregated Values
Beyond Counts - Showing Calculated Values:
While count plots show frequencies, bar plots show aggregated metrics for each category:
The Critical Difference:
Creating a Bar Plot:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sales data by region
np.random.seed(42)
regions = ['North', 'South', 'East', 'West'] * 50
sales = np.concatenate([
np.random.normal(85000, 15000, 50), # North
np.random.normal(75000, 12000, 50), # South
np.random.normal(92000, 18000, 50), # East
np.random.normal(80000, 14000, 50) # West
])
df_sales = pd.DataFrame({
'region': regions,
'sales': sales
})
fig, ax = plt.subplots(figsize=(8, 5))
# Bar plot shows MEAN by default
sns.barplot(data=df_sales, x='region', y='sales',
order=['North', 'South', 'East', 'West'],
palette='viridis',
errorbar='sd', # Standard deviation error bars
ax=ax)
ax.set_title('Average Sales by Region (with Std Dev)',
fontsize=14, fontweight='bold')
ax.set_xlabel('Region', fontsize=12)
ax.set_ylabel('Average Sales ($)', fontsize=12)
# Format Y-axis
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
plt.tight_layout()
plt.show()
Output:
[Bar plot: “Average Sales by Region (with Std Dev)”, x: Region, y: Average Sales ($)]
Understanding Error Bars:
The black lines on top of bars represent uncertainty or variability:
Business Interpretation:
Changing the Aggregation Function:
# Instead of mean, show median or sum
sns.barplot(data=df_sales, x='region', y='sales',
estimator='median', # Use median instead of mean
errorbar=None) # Median doesn't have standard CI
# Or total sales per region
sns.barplot(data=df_sales, x='region', y='sales',
estimator='sum')
Output:
[Bar plot: x: region, y: sales]
Violin Plots - Distribution Shapes Within Categories
The Problem with Bar Plots:
Bar plots only show one summary statistic (mean, median). They hide:
Violin plots solve this by showing the entire distribution for each category.
What Violin Plots Show:
A violin plot is essentially a rotated, mirrored KDE plot for each category:
Creating Violin Plots:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Employee satisfaction by department
np.random.seed(42)
departments = ['Sales', 'Marketing', 'Engineering', 'Finance', 'HR'] * 40
satisfaction = []
for dept in departments:
if dept == 'Engineering':
satisfaction.extend(np.random.normal(4.5, 0.4, 1)) # High, consistent
elif dept == 'Sales':
satisfaction.extend(np.random.normal(3.8, 0.8, 1)) # Lower, variable
elif dept == 'HR':
satisfaction.extend(np.random.normal(4.2, 0.3, 1)) # Good, consistent
else:
satisfaction.extend(np.random.normal(4.0, 0.5, 1))
df_satisfaction = pd.DataFrame({
'department': departments,
'satisfaction': np.clip(satisfaction, 1, 5) # Keep in 1-5 range
})
fig, ax = plt.subplots(figsize=(12, 6))
sns.violinplot(data=df_satisfaction, x='department', y='satisfaction',
palette='muted',
inner='box', # Show box plot inside
ax=ax)
ax.set_title('Employee Satisfaction Distribution by Department',
fontsize=14, fontweight='bold')
ax.set_xlabel('Department', fontsize=12)
ax.set_ylabel('Satisfaction Score (1-5)', fontsize=12)
ax.set_ylim(1, 5)
# Add reference line at target satisfaction
ax.axhline(4.0, color='red', linestyle='--', linewidth=2, alpha=0.7, label='Target: 4.0')
ax.legend()
plt.tight_layout()
plt.show()
Output:
[Violin plot: “Employee Satisfaction Distribution by Department”, x: Department, y: Satisfaction Score (1-5)]
Violin Plot Parameters:
inner=‘box’: Shows box plot inside (median, quartiles)
inner=‘quartile’: Shows quartile lines only
inner=‘point’: Shows individual points
inner=None: Just the violin shape
split=True: When you have a hue variable, creates split violins for comparison
Reading Violin Plots:
Engineering Department (example):
Sales Department (example):
Business Application:
HR uses violin plots to:
Box Plots for Categorical Comparisons
The Statistical Workhorse:
We introduced box plots in Section 1, but they shine brightest when comparing distributions across categories.
Enhanced Categorical Box Plots:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Product ratings by category
np.random.seed(42)
categories = ['Electronics', 'Clothing', 'Home', 'Sports', 'Books'] * 60
ratings = []
for cat in categories:
if cat == 'Electronics':
ratings.extend(np.random.normal(4.3, 0.6, 1))
elif cat == 'Books':
ratings.extend(np.random.normal(4.5, 0.4, 1))
elif cat == 'Clothing':
ratings.extend(np.random.normal(3.9, 0.8, 1))
else:
ratings.extend(np.random.normal(4.1, 0.5, 1))
df_ratings = pd.DataFrame({
'category': categories,
'rating': np.clip(ratings, 1, 5)
})
fig, ax = plt.subplots(figsize=(12, 6))
sns.boxplot(data=df_ratings, x='category', y='rating',
palette='Set2',
showmeans=True, # Show mean as well as median
meanprops={'marker': 'D', 'markerfacecolor': 'red', 'markersize': 8},
ax=ax)
ax.set_title('Product Ratings by Category (Q4 2024)',
fontsize=14, fontweight='bold')
ax.set_xlabel('Product Category', fontsize=12)
ax.set_ylabel('Customer Rating (1-5 stars)', fontsize=12)
ax.set_ylim(1, 5)
# Add target line
ax.axhline(4.0, color='green', linestyle='--', linewidth=2, alpha=0.5, label='Target: 4.0')
ax.legend()
plt.tight_layout()
plt.show()
Output:
[Box plot: “Product Ratings by Category (Q4 2024)”, x: Product Category, y: Customer Rating (1-5 stars)]
Box Plot vs Violin Plot - When to Use Each:
Use Box Plots when:
Use Violin Plots when:
Point Plots - Showing Trends Across Categories
Emphasizing Changes and Comparisons:
Point plots are like line charts for categorical data, excellent for showing:
Creating Point Plots:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Customer satisfaction over quarters for different tiers
np.random.seed(42)
quarters = ['Q1', 'Q2', 'Q3', 'Q4'] * 3
tiers = ['Basic'] * 4 + ['Premium'] * 4 + ['Enterprise'] * 4
satisfaction = [
3.8, 3.9, 4.0, 4.1, # Basic: steady improvement
4.2, 4.3, 4.4, 4.6, # Premium: strong improvement
4.5, 4.6, 4.5, 4.7 # Enterprise: already high, slight fluctuation
]
df_quarterly = pd.DataFrame({
'quarter': quarters,
'tier': tiers,
'satisfaction': satisfaction
})
fig, ax = plt.subplots(figsize=(12, 6))
sns.pointplot(data=df_quarterly, x='quarter', y='satisfaction',
hue='tier',
markers=['o', 's', 'D'],
linestyles=['-', '--', '-.'],
palette='Set1',
ax=ax)
ax.set_title('Quarterly Customer Satisfaction Trends by Tier - 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Average Satisfaction Score', fontsize=12)
ax.legend(title='Membership Tier', fontsize=11)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
Output:
[Chart: “Quarterly Customer Satisfaction Trends by Tier - 2024”, x: Quarter, y: Average Satisfaction Score]
Point Plot Features:
Business Insights from Point Plots:
Looking at the satisfaction trends:
Strip and Swarm Plots - Showing Individual Data Points
When You Need to See Every Observation:
Sometimes aggregations hide important details. Strip and swarm plots show every individual data point while organizing by category.
Strip Plots (with jitter):
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Sales rep performance (fewer data points, want to see individuals)
np.random.seed(42)
reps = ['Amy', 'Bob', 'Carlos', 'Diana', 'Erik']
performance = []
rep_names = []
for rep in reps:
n_deals = 8 # Each rep closed 8 deals this quarter
if rep == 'Diana':
deals = np.random.normal(25000, 5000, n_deals) # Top performer
elif rep == 'Erik':
deals = np.random.normal(15000, 3000, n_deals) # Struggling
else:
deals = np.random.normal(20000, 4000, n_deals)
performance.extend(deals)
rep_names.extend([rep] * n_deals)
df_reps = pd.DataFrame({
'sales_rep': rep_names,
'deal_size': performance
})
fig, ax = plt.subplots(figsize=(12, 6))
sns.stripplot(data=df_reps, x='sales_rep', y='deal_size',
jitter=0.3, # Add horizontal jitter to prevent overlap
alpha=0.6, # Transparency
size=8, # Point size
palette='deep',
ax=ax)
ax.set_title('Individual Deal Sizes by Sales Representative - Q4 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Sales Representative', fontsize=12)
ax.set_ylabel('Deal Size ($)', fontsize=12)
# Format Y-axis
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
# Add mean line for each rep
for i, rep in enumerate(reps):
mean_val = df_reps[df_reps['sales_rep'] == rep]['deal_size'].mean()
ax.hlines(mean_val, i-0.4, i+0.4, colors='red', linewidth=3, alpha=0.7)
plt.tight_layout()
plt.show()
Output:
[Strip plot: “Individual Deal Sizes by Sales Representative - Q4 2024”, x: Sales Representative, y: Deal Size ($)]
Strip Plot Parameters:
Swarm Plots (organized arrangement):
Swarm plots are like strip plots but organize points to avoid overlap:
fig, ax = plt.subplots(figsize=(12, 6))
sns.swarmplot(data=df_reps, x='sales_rep', y='deal_size',
palette='deep',
size=7,
ax=ax)
ax.set_title('Deal Sizes by Sales Rep (Swarm Plot)',
fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Strip plot: “Deal Sizes by Sales Rep (Swarm Plot)”, x: sales_rep, y: deal_size]
Swarm Plot Characteristics:
Warning: Swarm plots don’t scale well beyond ~500 points per category.
Business Use Cases:
Use strip/swarm plots when:
Combining Multiple Categorical Plots
Layering Plots for Rich Insights:
Seaborn allows combining plot types for comprehensive visualization:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Generate data
np.random.seed(42)
categories = ['Product A', 'Product B', 'Product C'] * 30
values = np.concatenate([
np.random.normal(75, 15, 30),
np.random.normal(85, 12, 30),
np.random.normal(70, 20, 30)
])
df = pd.DataFrame({'product': categories, 'score': values})
fig, ax = plt.subplots(figsize=(12, 6))
# Layer 1: Violin plot for distributions
sns.violinplot(data=df, x='product', y='score',
inner=None, palette='pastel', alpha=0.5, ax=ax)
# Layer 2: Box plot for statistics
sns.boxplot(data=df, x='product', y='score',
width=0.3, palette='dark', ax=ax)
# Layer 3: Individual points
sns.stripplot(data=df, x='product', y='score',
size=4, color='black', alpha=0.3, jitter=0.2, ax=ax)
ax.set_title('Multi-Layer Visualization: Product Performance Scores',
fontsize=14, fontweight='bold')
ax.set_xlabel('Product Line', fontsize=12)
ax.set_ylabel('Performance Score', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Violin plot: “Multi-Layer Visualization: Product Performance Scores”, x: Product Line, y: Performance Score]
What This Reveals:
This comprehensive view helps:
Lab 3: Categorical Data Analysis
Objective: Master categorical visualization techniques to analyze business performance across departments, products, regions, and customer segments.
Scenario: You’re the Operations Analyst at “GlobalManufacture Inc.,” a mid-size manufacturing company with multiple product lines, 8 regional offices, and 300+ employees. The COO is preparing the annual operations review and needs comprehensive categorical analysis to identify performance patterns, problem areas, and opportunities. Your task is to create professional categorical visualizations that tell clear stories about operational performance.
Pre-Lab Setup:
M3L03_YourName_Categorical.pyimport seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
sns.set_theme(style="whitegrid", context="talk", palette="colorblind")Part A: Product Line Performance Analysis (25 points)
Context: The Product VP needs to understand which product lines are performing well and which need attention.
Data:
np.random.seed(42)
# 5 product lines, 60 sales transactions each
products = ['Industrial Tools', 'Safety Equipment', 'Machinery Parts',
'Automation Systems', 'Maintenance Supplies'] * 60
revenue = []
for product in products:
if product == 'Automation Systems':
revenue.append(np.random.normal(85000, 20000, 1)[0]) # High value, variable
elif product == 'Industrial Tools':
revenue.append(np.random.normal(45000, 8000, 1)[0]) # Medium, consistent
elif product == 'Safety Equipment':
revenue.append(np.random.normal(25000, 5000, 1)[0]) # Low, consistent
elif product == 'Machinery Parts':
revenue.append(np.random.normal(55000, 15000, 1)[0]) # Medium-high, variable
else:
revenue.append(np.random.normal(15000, 3000, 1)[0]) # Low volume
df_products = pd.DataFrame({
'product_line': products,
'deal_revenue': np.maximum(revenue, 5000) # Ensure positive values
})Tasks:
Create comprehensive box plot comparison (12 points):
Create layered visualization (8 points):
Business analysis (5 points):
M3L03_YourName_ProductBoxPlot.pngM3L03_YourName_ProductLayered.pngPart B: Regional Performance Trends (30 points)
Context: The Regional Directors meeting is next week. Each director needs to see how their region performed quarterly throughout 2024 compared to other regions.
Data:
np.random.seed(42)
regions = ['Northeast', 'Southeast', 'Midwest', 'Southwest',
'West', 'Northwest', 'Central', 'Florida']
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
data_list = []
for region in regions:
base_performance = np.random.uniform(70, 90) # Each region has base performance
trend = np.random.uniform(-2, 5) # Each region has a trend
for q, quarter in enumerate(quarters):
# Performance with trend and some randomness
performance = base_performance + (trend * q) + np.random.normal(0, 3)
performance = np.clip(performance, 50, 100) # Keep in reasonable range
data_list.append({
'region': region,
'quarter': quarter,
'performance_score': performance
})
df_regional = pd.DataFrame(data_list)Tasks:
Create point plot showing trends (15 points):
Create categorical comparison by quarter (10 points):
Analysis and recommendations (5 points):
M3L03_YourName_RegionalTrends.png and M3L03_YourName_QuarterlyComparison.pngPart C: Employee Department Analysis (25 points)
Context: HR is conducting an employee engagement survey analysis. They need to understand satisfaction and salary distributions across departments to identify equity issues and engagement problems.
Data:
np.random.seed(42)
departments = ['Engineering', 'Sales', 'Marketing', 'Operations',
'Finance', 'HR', 'Customer Success', 'R&D']
n_per_dept = 40
data_list = []
for dept in departments:
for _ in range(n_per_dept):
# Different departments have different characteristics
if dept == 'Engineering':
salary = np.random.normal(95000, 15000, 1)[0]
satisfaction = np.random.normal(4.2, 0.5, 1)[0]
elif dept == 'Sales':
salary = np.random.normal(75000, 25000, 1)[0] # High variance (commission)
satisfaction = np.random.normal(3.8, 0.9, 1)[0] # Variable satisfaction
elif dept == 'R&D':
salary = np.random.normal(105000, 12000, 1)[0] # Highest salaries
satisfaction = np.random.normal(4.5, 0.3, 1)[0] # Highest satisfaction
elif dept == 'Customer Success':
salary = np.random.normal(65000, 10000, 1)[0]
satisfaction = np.random.normal(3.5, 0.7, 1)[0] # Lowest satisfaction
else:
salary = np.random.normal(80000, 15000, 1)[0]
satisfaction = np.random.normal(4.0, 0.5, 1)[0]
data_list.append({
'department': dept,
'salary': max(salary, 40000),
'satisfaction': np.clip(satisfaction, 1, 5)
})
df_employees = pd.DataFrame(data_list)Tasks:
Create violin plot for salary distribution (12 points):
Create satisfaction vs salary scatter with categories (8 points):
HR recommendations (5 points):
M3L03_YourName_SalaryViolin.png and M3L03_YourName_SalarySatisfaction.pngPart D: Customer Segment Count and Revenue Analysis (20 points)
Context: Marketing wants to understand customer distribution and value across segments for 2025 budget allocation.
Data:
np.random.seed(42)
# Generate customer base with realistic distribution
segments_list = (['Small Business'] * 450 +
['Mid-Market'] * 250 +
['Enterprise'] * 80 +
['Startup'] * 220)
industries = ['Manufacturing', 'Technology', 'Healthcare',
'Retail', 'Finance', 'Education']
data_list = []
for segment in segments_list:
industry = np.random.choice(industries)
if segment == 'Enterprise':
revenue = np.random.lognormal(12, 0.5) # Very high, right-skewed
elif segment == 'Mid-Market':
revenue = np.random.lognormal(10, 0.6)
elif segment == 'Small Business':
revenue = np.random.lognormal(8, 0.7)
else: # Startup
revenue = np.random.lognormal(7, 0.9)
data_list.append({
'segment': segment,
'industry': industry,
'annual_revenue': revenue
})
df_customers = pd.DataFrame(data_list)Tasks:
Create count plot with percentages (10 points):
Create bar plot comparing average revenue (10 points):
M3L03_YourName_CustomerCount.png and M3L03_YourName_SegmentRevenue.pngBonus Challenge (+25 points):
Create a Comprehensive Categorical Dashboard:
Build a 2×3 grid (6 subplots) showing: 1. Product line revenue distributions (violin plot) 2. Regional performance trends (point plot) 3. Department satisfaction scores (box plot) 4. Customer segment counts (count plot with percentages) 5. Salary distribution by department (horizontal box plot) 6. Industry vs Segment heatmap (count of customers in each combination)
Requirements:
M3L03_YourName_CategoricalDashboard.pngDeliverables:
M3L03_YourName_Categorical.pyM3L03_YourName_ProductBoxPlot.pngM3L03_YourName_ProductLayered.pngM3L03_YourName_RegionalTrends.pngM3L03_YourName_QuarterlyComparison.pngM3L03_YourName_SalaryViolin.pngM3L03_YourName_SalarySatisfaction.pngM3L03_YourName_CustomerCount.pngM3L03_YourName_SegmentRevenue.pngM3L03_YourName_CategoricalDashboard.png (bonus)Grading Rubric:
Success Criteria:
Categorical Visualization Decision Framework:
| Question | Best Plot Type |
|---|---|
| How many in each category? | Count plot |
| What’s the average per category? | Bar plot |
| How do distributions differ? | Violin or Box plot |
| What are trends across categories? | Point plot |
| Need to see all data points? | Strip or Swarm plot |
| Complex distribution comparison? | Layered: Violin + Box + Strip |
Common Mistakes to Avoid:
The Challenge of Multivariate Data
Beyond Two Variables:
So far, we’ve explored:
But business data is multivariate - many variables interacting:
The Visualization Problem:
How do you visualize 10+ variables simultaneously?
Solution: Heatmaps
Heatmaps show many values at once using color intensity:
One glance reveals patterns across dozens of relationships.
Understanding Correlation
What is Correlation?
Correlation measures the strength and direction of a linear relationship between two variables.
Correlation Coefficient (r):
Interpretation Scale:
| Coefficient Range | Interpretation | Business Meaning |
|---|---|---|
| 0.9 to 1.0 | Very strong positive | Highly predictive |
| 0.7 to 0.9 | Strong positive | Reliable relationship |
| 0.5 to 0.7 | Moderate positive | Noticeable pattern |
| 0.3 to 0.5 | Weak positive | Slight tendency |
| 0.0 to 0.3 | Very weak | Minimal relationship |
| -0.3 to 0.0 | Very weak negative | Minimal inverse |
| -0.5 to -0.3 | Weak negative | Slight inverse |
| -0.7 to -0.5 | Moderate negative | Noticeable inverse |
| -0.9 to -0.7 | Strong negative | Reliable inverse |
| -1.0 to -0.9 | Very strong negative | Highly inverse |
Business Examples:
Strong Positive (r = 0.85):
Moderate Positive (r = 0.55):
Weak Negative (r = -0.35):
Very Weak (r = 0.12):
Creating Correlation Matrices
Calculating Correlations in Pandas:
import pandas as pd
import numpy as np
# Sample business data
np.random.seed(42)
df = pd.DataFrame({
'revenue': np.random.normal(100000, 20000, 100),
'marketing_spend': np.random.normal(15000, 3000, 100),
'sales_calls': np.random.poisson(25, 100),
'customer_satisfaction': np.random.uniform(3.5, 5.0, 100),
'product_price': np.random.uniform(50, 200, 100)
})
# Add realistic relationships
df['revenue'] = (50000 +
2.5 * df['marketing_spend'] +
500 * df['sales_calls'] +
np.random.normal(0, 5000, 100))
# Calculate correlation matrix
correlation_matrix = df.corr()
print(correlation_matrix) revenue marketing_spend sales_calls \
revenue 1.000000 0.796992 0.282892
marketing_spend 0.796992 1.000000 -0.012601
sales_calls 0.282892 -0.012601 1.000000
customer_satisfaction 0.065851 0.064170 0.062285
product_price 0.026338 -0.035095 0.027910
customer_satisfaction product_price
revenue 0.065851 0.026338
marketing_spend 0.064170 -0.035095
sales_calls 0.062285 0.027910
customer_satisfaction 1.000000 0.052959
product_price 0.052959 1.000000 Output:
revenue ... product_price
revenue 1.000000 ... 0.026338
marketing_spend 0.796992 ... -0.035095
sales_calls 0.282892 ... 0.027910
customer_satisfaction 0.065851 ... 0.052959
product_price 0.026338 ... 1.000000
[5 rows x 5 columns]Understanding the Correlation Matrix:
The output is a square table:
revenue marketing_spend sales_calls satisfaction price
revenue 1.000000 0.856234 0.723451 0.234567 -0.102345
marketing_spend 0.856234 1.000000 0.145678 0.198765 0.034567
sales_calls 0.723451 0.145678 1.000000 0.287654 -0.056789
satisfaction 0.234567 0.198765 0.287654 1.000000 0.123456
price -0.102345 0.034567 -0.056789 0.123456 1.000000Reading the Matrix:
Key Insights:
Creating Basic Correlation Heatmaps
Visualizing the Correlation Matrix:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Generate comprehensive business metrics data
np.random.seed(42)
n = 200
df = pd.DataFrame({
'Revenue': np.random.normal(100000, 20000, n),
'Marketing_Spend': np.random.normal(15000, 3000, n),
'Sales_Team_Size': np.random.randint(5, 25, n),
'Customer_Count': np.random.poisson(150, n),
'Avg_Deal_Size': np.random.normal(5000, 1500, n),
'Customer_Satisfaction': np.random.uniform(3.5, 5.0, n),
'Employee_Satisfaction': np.random.uniform(3.0, 5.0, n),
'Product_Quality_Score': np.random.normal(85, 10, n)
})
# Create realistic relationships
df['Revenue'] = (30000 +
2.5 * df['Marketing_Spend'] +
2000 * df['Sales_Team_Size'] +
300 * df['Customer_Count'] +
np.random.normal(0, 8000, n))
df['Customer_Satisfaction'] = (2.5 +
0.02 * df['Product_Quality_Score'] +
0.00001 * df['Revenue'] +
np.random.normal(0, 0.3, n))
df['Customer_Satisfaction'] = df['Customer_Satisfaction'].clip(1, 5)
# Calculate correlation matrix
corr_matrix = df.corr()
# Create heatmap
fig, ax = plt.subplots(figsize=(12, 10))
sns.heatmap(corr_matrix,
annot=True, # Show correlation values
fmt='.2f', # 2 decimal places
cmap='coolwarm', # Color scheme
center=0, # Center colormap at 0
square=True, # Square cells
linewidths=1, # Lines between cells
cbar_kws={'shrink': 0.8}, # Colorbar size
ax=ax)
ax.set_title('Business Metrics Correlation Heatmap',
fontsize=16, fontweight='bold', pad=20)
plt.tight_layout()
plt.show()
Output:
[Heatmap: “Business Metrics Correlation Heatmap”]
Heatmap Parameters Explained:
annot=True: Shows actual correlation values
fmt=‘.2f’: Format for annotations
cmap=‘coolwarm’: Color scheme
center=0: Where to center the colormap
square=True: Makes cells square
Reading a Correlation Heatmap:
Strong Positive (Dark Red):
Strong Negative (Dark Blue):
Weak Correlations (White/Light):
Surprising Patterns:
Advanced Heatmap Techniques
Masking the Upper Triangle (Avoid Redundancy):
Since correlation matrices are symmetric, showing both triangles is redundant:
import numpy as np
# Generate mask for upper triangle
mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
fig, ax = plt.subplots(figsize=(12, 10))
sns.heatmap(corr_matrix,
mask=mask, # Hide upper triangle
annot=True,
fmt='.2f',
cmap='coolwarm',
center=0,
square=True,
linewidths=1,
cbar_kws={'shrink': 0.8},
ax=ax)
ax.set_title('Correlation Heatmap (Lower Triangle)',
fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Heatmap: “Correlation Heatmap (Lower Triangle)”]
Benefits:
Highlighting Strong Correlations:
# Create custom annotations to highlight strong correlations
annot_array = corr_matrix.values.copy()
annotations = []
for i in range(len(annot_array)):
row_annot = []
for j in range(len(annot_array[i])):
val = annot_array[i, j]
if abs(val) > 0.7 and i != j: # Strong correlation, not diagonal
row_annot.append(f'{val:.2f}*') # Add asterisk
else:
row_annot.append(f'{val:.2f}')
annotations.append(row_annot)
fig, ax = plt.subplots(figsize=(12, 10))
sns.heatmap(corr_matrix,
annot=np.array(annotations),
fmt='', # Don't format, we already did
cmap='coolwarm',
center=0,
square=True,
linewidths=1,
ax=ax)
ax.set_title('Correlation Heatmap (* indicates |r| > 0.7)',
fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
Output:
[Heatmap: “Correlation Heatmap (* indicates |r| > 0.7)”]
Pivot Table Heatmaps - Two-Way Categorical Analysis
Beyond Correlation - Categorical Relationships:
Heatmaps aren’t just for correlations. They excel at showing values across two categorical dimensions:
Creating Pivot Table Heatmaps:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Generate sales data by region and quarter
np.random.seed(42)
regions = ['North', 'South', 'East', 'West']
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
data_list = []
for region in regions:
for quarter in quarters:
# Different regions have different patterns
if region == 'East':
base = 85000
elif region == 'West':
base = 78000
elif region == 'North':
base = 82000
else:
base = 75000
# Seasonal variation by quarter
if quarter == 'Q4':
seasonal = 15000 # Holiday boost
elif quarter == 'Q1':
seasonal = -5000 # Post-holiday slump
else:
seasonal = 0
sales = base + seasonal + np.random.normal(0, 5000)
data_list.append({
'Region': region,
'Quarter': quarter,
'Sales': sales
})
df_sales = pd.DataFrame(data_list)
# Create pivot table
pivot_table = df_sales.pivot_table(values='Sales',
index='Region',
columns='Quarter',
aggfunc='mean')
# Create heatmap
fig, ax = plt.subplots(figsize=(8, 5))
sns.heatmap(pivot_table,
annot=True,
fmt='.0f', # No decimals for currency
cmap='YlGnBu', # Yellow to Green to Blue
linewidths=2,
linecolor='white',
cbar_kws={'label': 'Average Sales ($)'},
ax=ax)
ax.set_title('Average Sales by Region and Quarter - 2024',
fontsize=14, fontweight='bold')
ax.set_xlabel('Quarter', fontsize=12)
ax.set_ylabel('Region', fontsize=12)
plt.tight_layout()
plt.show()
Output:
[Heatmap: “Average Sales by Region and Quarter - 2024”, x: Quarter, y: Region]
Reading Two-Way Heatmaps:
Hotspots (Darker colors):
Cold spots (Lighter colors):
Patterns:
Business Actions:
Clustermaps - Discovering Hidden Groupings
The Pattern Recognition Problem:
Sometimes relationships aren’t obvious from raw order. Clustermaps automatically reorder rows and columns to group similar variables together.
What Clustermaps Reveal:
Creating a Clustermap:
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Generate diverse business metrics
np.random.seed(42)
n = 150
df = pd.DataFrame({
# Financial metrics (should cluster)
'Revenue': np.random.normal(100000, 20000, n),
'Profit': np.random.normal(25000, 8000, n),
'Cash_Flow': np.random.normal(30000, 10000, n),
# Customer metrics (should cluster)
'Customer_Count': np.random.poisson(200, n),
'Customer_Satisfaction': np.random.uniform(3.5, 5.0, n),
'Net_Promoter_Score': np.random.normal(45, 15, n),
# Operational metrics (should cluster)
'Employee_Count': np.random.randint(20, 100, n),
'Productivity_Score': np.random.normal(75, 12, n),
'Efficiency_Rating': np.random.uniform(65, 95, n),
# Marketing metrics (should cluster)
'Marketing_Spend': np.random.normal(15000, 5000, n),
'Lead_Generation': np.random.poisson(50, n),
'Conversion_Rate': np.random.uniform(0.15, 0.35, n)
})
# Create realistic relationships within clusters
df['Profit'] = 0.25 * df['Revenue'] + np.random.normal(0, 3000, n)
df['Cash_Flow'] = 0.30 * df['Revenue'] + np.random.normal(0, 4000, n)
df['Net_Promoter_Score'] = 20 + 6 * df['Customer_Satisfaction'] + np.random.normal(0, 5, n)
df['Productivity_Score'] = 50 + 0.25 * df['Employee_Count'] + np.random.normal(0, 8, n)
df['Conversion_Rate'] = 0.15 + 0.000003 * df['Marketing_Spend'] + np.random.normal(0, 0.03, n)
# Calculate correlation
corr_matrix = df.corr()
# Create clustermap
g = sns.clustermap(corr_matrix,
annot=True,
fmt='.2f',
cmap='coolwarm',
center=0,
figsize=(14, 14),
linewidths=0.5,
cbar_kws={'label': 'Correlation Coefficient'})
g.fig.suptitle('Clustered Correlation Heatmap - Business Metrics',
fontsize=16, fontweight='bold', y=0.98)
plt.tight_layout()
plt.show()
Output:
[Cluster heatmap: “Clustered Correlation Heatmap - Business Metrics”]
Reading a Clustermap:
Dendrograms (Tree structures on sides):
Reordered Matrix:
Business Insights from Clusters:
Cluster 1: Financial Metrics
Cluster 2: Customer Metrics
Cluster 3: Operational Metrics
Multicollinearity and Variable Selection
The Redundancy Problem:
In predictive modeling or analysis, highly correlated independent variables cause problems:
Using Heatmaps to Identify Redundancy:
# Identify highly correlated variable pairs (excluding diagonal)
high_corr_pairs = []
threshold = 0.85
for i in range(len(corr_matrix.columns)):
for j in range(i+1, len(corr_matrix.columns)):
if abs(corr_matrix.iloc[i, j]) >= threshold:
high_corr_pairs.append({
'Variable 1': corr_matrix.columns[i],
'Variable 2': corr_matrix.columns[j],
'Correlation': corr_matrix.iloc[i, j]
})
df_high_corr = pd.DataFrame(high_corr_pairs)
print("\nHighly Correlated Variable Pairs (|r| >= 0.85):")
print(df_high_corr)
Highly Correlated Variable Pairs (|r| >= 0.85):
Empty DataFrame
Columns: []
Index: []Output:
Highly Correlated Variable Pairs (|r| >= 0.85):
Empty DataFrame
Columns: []
Index: []Business Decision Framework:
If Revenue and Cash_Flow correlate at r=0.92: 1. Keep one, drop the other for modeling 2. Which to keep? - The one easier to measure - The one more relevant to the business question - The one with less measurement error
Example:
Color Scheme Selection for Different Contexts
Choosing the Right Colors Matters:
Different data types and questions require different color schemes:
Diverging (Best for Correlations):
# Data centered at 0, both positive and negative values
cmap='coolwarm' # Blue (negative) → White (zero) → Red (positive)
cmap='RdBu_r' # Red → Blue reversed
cmap='PiYG' # Pink → Yellow → GreenSequential (Best for One-directional Values):
# All positive values, low to high
cmap='YlGnBu' # Yellow → Green → Blue
cmap='Blues' # Light blue → Dark blue
cmap='Reds' # Light red → Dark redQualitative (Best for Categories):
# Distinct categories, no order
cmap='Set1'
cmap='Set2'
cmap='tab10'Business Context Examples:
Financial Performance (diverging):
cmap='RdYlGn' # Red-Yellow-GreenSales Performance (sequential):
cmap='YlOrRd' # Yellow-Orange-Red (heat map feel)Customer Satisfaction (sequential):
cmap='RdYlGn' # But not centered at 0, normalized to data rangeLab 4: Correlation and Heatmap Analysis
Objective: Master correlation analysis and heatmap visualization to uncover complex relationships in multivariate business data and communicate insights through color-coded matrices.
Scenario: You’re the Senior Data Analyst at “MarketPro Analytics,” a marketing analytics firm. Your client, a major e-commerce company, has provided comprehensive data on their operations. The CMO is struggling to understand which metrics drive success and where to focus improvement efforts. Your task is to create correlation analyses and heatmaps that reveal the hidden relationships in their complex business data and provide clear, actionable insights for strategic planning.
Pre-Lab Setup:
M3L04_YourName_Heatmaps.pyimport seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
sns.set_theme(style="white", context="talk")Part A: Comprehensive Business Metrics Correlation Analysis (30 points)
Context: The client wants to understand how their various business metrics relate to each other to identify key drivers of success.
Data:
np.random.seed(42)
n = 250 # 250 days of data
# Generate comprehensive e-commerce metrics
df_metrics = pd.DataFrame({
'Daily_Revenue': np.random.normal(50000, 12000, n),
'Website_Traffic': np.random.poisson(15000, n),
'Conversion_Rate': np.random.uniform(0.02, 0.08, n),
'Avg_Order_Value': np.random.normal(85, 20, n),
'Marketing_Spend': np.random.normal(3000, 800, n),
'Email_Open_Rate': np.random.uniform(0.15, 0.35, n),
'Social_Media_Engagement': np.random.poisson(500, n),
'Customer_Service_Tickets': np.random.poisson(45, n),
'Product_Returns': np.random.poisson(25, n),
'Page_Load_Time': np.random.uniform(1.5, 4.5, n),
'Mobile_Traffic_Pct': np.random.uniform(0.45, 0.75, n),
'Customer_Satisfaction': np.random.uniform(3.8, 4.8, n)
})
# Create realistic relationships
df_metrics['Daily_Revenue'] = (
10000 +
1.8 * df_metrics['Website_Traffic'] +
200000 * df_metrics['Conversion_Rate'] +
300 * df_metrics['Avg_Order_Value'] +
2.5 * df_metrics['Marketing_Spend'] +
-2000 * df_metrics['Page_Load_Time'] +
np.random.normal(0, 5000, n)
)
df_metrics['Conversion_Rate'] = (
0.03 +
0.00000015 * df_metrics['Website_Traffic'] +
0.01 * df_metrics['Email_Open_Rate'] +
-0.003 * df_metrics['Page_Load_Time'] +
0.002 * df_metrics['Customer_Satisfaction'] +
np.random.normal(0, 0.005, n)
)
df_metrics['Conversion_Rate'] = df_metrics['Conversion_Rate'].clip(0.01, 0.10)
df_metrics['Customer_Satisfaction'] = (
3.0 +
0.3 * (5 - df_metrics['Page_Load_Time']) +
-0.015 * df_metrics['Customer_Service_Tickets'] +
-0.020 * df_metrics['Product_Returns'] +
np.random.normal(0, 0.2, n)
)
df_metrics['Customer_Satisfaction'] = df_metrics['Customer_Satisfaction'].clip(1, 5)Tasks:
Create comprehensive correlation heatmap (12 points):
Create lower triangle version (8 points):
M3L04_YourName_FullCorrelation.png (full) and M3L04_YourName_LowerTriangle.png (masked)Identify and document key insights (10 points):
Part B: Revenue Driver Deep Dive (25 points)
Context: The CMO specifically wants to know which factors most strongly influence revenue. Create a focused analysis on revenue correlations.
Tasks:
Create revenue-focused correlation visualization (15 points):
Statistical significance and interpretation (10 points):
M3L04_YourName_RevenueDrivers.pngPart C: Marketing Performance Pivot Heatmap (25 points)
Context: The marketing team runs campaigns across different channels (Email, Social, PPC, Display) in different customer segments (New, Returning, VIP). They need to see performance by Channel × Segment.
Data:
np.random.seed(42)
channels = ['Email', 'Social Media', 'PPC', 'Display Ads']
segments = ['New Customers', 'Returning', 'VIP']
marketing_data = []
for channel in channels:
for segment in segments:
# Different channels perform differently with different segments
if channel == 'Email' and segment == 'VIP':
roi = np.random.normal(4.5, 0.5, 30) # Email works great for VIP
elif channel == 'Social Media' and segment == 'New Customers':
roi = np.random.normal(3.8, 0.6, 30) # Social good for acquisition
elif channel == 'PPC' and segment == 'Returning':
roi = np.random.normal(3.5, 0.4, 30)
elif channel == 'Display Ads':
roi = np.random.normal(2.2, 0.5, 30) # Display generally weaker
else:
roi = np.random.normal(3.0, 0.5, 30)
for r in roi:
marketing_data.append({
'Channel': channel,
'Segment': segment,
'ROI': max(r, 0.5) # Ensure positive ROI
})
df_marketing = pd.DataFrame(marketing_data)Tasks:
Create pivot table heatmap (15 points):
Add conditional formatting context (5 points):
Business recommendations (5 points):
M3L04_YourName_MarketingROI.pngPart D: Customer Behavior Clustermap (20 points)
Context: The product team has metrics on customer behavior but doesn’t know which behaviors cluster together or which customer segments behave similarly.
Data:
np.random.seed(42)
# Customer behavior metrics
behaviors = pd.DataFrame({
'Purchase_Frequency': np.random.gamma(2, 2, 200),
'Avg_Session_Duration': np.random.normal(8, 3, 200),
'Pages_Per_Session': np.random.poisson(5, 200),
'Cart_Abandonment_Rate': np.random.uniform(0.3, 0.8, 200),
'Wishlist_Usage': np.random.poisson(3, 200),
'Review_Activity': np.random.poisson(2, 200),
'Social_Shares': np.random.poisson(1, 200),
'Coupon_Usage_Rate': np.random.uniform(0.1, 0.6, 200),
'Customer_Service_Contact': np.random.poisson(1, 200),
'Mobile_App_Usage': np.random.uniform(0.2, 0.9, 200)
})
# Create some natural relationships
behaviors['Purchase_Frequency'] = (
behaviors['Purchase_Frequency'] *
(1 + 0.3 * behaviors['Wishlist_Usage'] / behaviors['Wishlist_Usage'].max())
)
behaviors['Review_Activity'] = (
behaviors['Review_Activity'] +
0.3 * behaviors['Purchase_Frequency']
)
behaviors['Social_Shares'] = (
behaviors['Social_Shares'] +
0.5 * behaviors['Review_Activity']
)
df_behaviors = behaviorsTasks:
Create clustermap (15 points):
Interpret clusters (5 points):
M3L04_YourName_BehaviorClustermap.pngBonus Challenge (+30 points):
Create a Comprehensive Executive Dashboard with Multiple Heatmaps:
Build a figure with 4 subplots (2×2) showing:
Requirements:
M3L04_YourName_ExecutiveDashboard.pngDeliverables:
M3L04_YourName_Heatmaps.pyM3L04_YourName_FullCorrelation.pngM3L04_YourName_LowerTriangle.pngM3L04_YourName_RevenueDrivers.pngM3L04_YourName_MarketingROI.pngM3L04_YourName_BehaviorClustermap.pngM3L04_YourName_ExecutiveDashboard.png (bonus)Grading Rubric:
Success Criteria:
Heatmap Best Practices Checklist:
Common Mistakes to Avoid:
Professional Tips:
End of Module 3: Statistical Visualization with Seaborn
Key Takeaways:
Why Interactive Visualizations Transform Business Communication
The Limitation of Static Charts:
In Modules 2 and 3, we created beautiful static visualizations with Matplotlib and Seaborn. But static charts have inherent limitations:
The Interactive Advantage:
Interactive visualizations solve these problems:
1. Progressive Disclosure:
2. Enhanced Engagement:
3. Richer Information:
Business Impact Examples:
Sales Dashboard (Static):
Sales Dashboard (Interactive):
Result: Executives answer their own questions in real-time during presentations.
Understanding Plotly - The Interactive Visualization Library
What is Plotly?
Plotly is a graphing library that creates interactive, web-based visualizations:
Plotly Versions:
1. Plotly Express (px) - High-Level API:
import plotly.express as px
df = pd.DataFrame({
'sales': np.random.uniform(10000, 100000, 50),
'profit': np.random.uniform(1000, 20000, 50)
})
# Simple, concise, opinionated
fig = px.scatter(df, x='sales', y='profit')
fig.show()Output:
[Interactive scatter plot: x: sales, y: profit] - Best for: Quick exploration, standard charts - Advantages: One-line plots, automatic styling - Used when: Learning, rapid prototyping
2. Plotly Graph Objects (go) - Low-Level API:
import plotly.graph_objects as go
# Detailed control, more verbose
fig = go.Figure(data=[go.Scatter(x=df['sales'], y=df['profit'])])
fig.show()Output:
[Interactive Plotly chart] - Best for: Custom visualizations, fine control - Advantages: Complete flexibility - Used when: Specific requirements, complex layouts
We’ll focus primarily on Plotly Express (easier to learn, covers 90% of business needs).
Installation Check:
import plotly
print(plotly.__version__) # Should be 5.x or higher5.22.0If not installed:
pip install plotlyYour First Interactive Chart - The Plotly Workflow
Understanding the Fundamental Difference:
Matplotlib/Seaborn workflow:
Plotly workflow:
Creating a Simple Interactive Scatter Plot:
import plotly.express as px
import pandas as pd
import numpy as np
# Sample business data: Marketing spend vs Revenue
np.random.seed(42)
df = pd.DataFrame({
'marketing_spend': np.random.uniform(5000, 50000, 100),
'revenue': np.random.uniform(50000, 500000, 100),
'region': np.random.choice(['North', 'South', 'East', 'West'], 100),
'quarter': np.random.choice(['Q1', 'Q2', 'Q3', 'Q4'], 100)
})
# Add realistic relationship
df['revenue'] = 30000 + 6 * df['marketing_spend'] + np.random.normal(0, 30000, 100)
# Create interactive scatter plot
fig = px.scatter(df,
x='marketing_spend',
y='revenue',
title='Marketing Spend vs Revenue Analysis')
# Display in browser
fig.show()Output:
[Interactive scatter plot: “Marketing Spend vs Revenue Analysis”, x: marketing_spend, y: revenue]
What Just Happened:
When you run fig.show():
The Magic of Interactivity:
Try these interactions:
No additional code needed - interactivity is automatic!
Customizing Hover Information
The Default Hover is Good, But We Can Do Better:
Default hover shows:
Professional hover should show:
Enhanced Hover with Custom Text:
import plotly.express as px
import pandas as pd
import numpy as np
# Same data as before
np.random.seed(42)
df = pd.DataFrame({
'marketing_spend': np.random.uniform(5000, 50000, 100),
'revenue': np.random.uniform(50000, 500000, 100),
'region': np.random.choice(['North', 'South', 'East', 'West'], 100),
'quarter': np.random.choice(['Q1', 'Q2', 'Q3', 'Q4'], 100),
'campaign': [f'Campaign {i}' for i in range(100)]
})
df['revenue'] = 30000 + 6 * df['marketing_spend'] + np.random.normal(0, 30000, 100)
# Create hover template
fig = px.scatter(df,
x='marketing_spend',
y='revenue',
color='region', # Color by region
hover_data=['quarter', 'campaign'], # Additional info
title='Marketing ROI Analysis by Region')
# Update labels for readability
fig.update_layout(
xaxis_title='Marketing Spend ($)',
yaxis_title='Revenue Generated ($)',
font=dict(size=12)
)
# Format hover to show currency
fig.update_traces(
hovertemplate='<b>%{fullData.name}</b><br>' +
'Marketing: $%{x:,.0f}<br>' +
'Revenue: $%{y:,.0f}<br>' +
'<extra></extra>'
)
fig.show()Output:
[Interactive scatter plot: “Marketing ROI Analysis by Region”, x: marketing_spend, y: revenue]
Understanding Hover Customization:
hover_data parameter:
['quarter', 'campaign']hovertemplate:
- Custom HTML-like template
- **%{x}**: X-axis value
- **%{y}**: Y-axis value
- **:,.0f**: Format as number with commas, 0 decimals
- **<b>...</b>**: Bold text
- **<br>**: Line break
- **<extra></extra>**: Remove default trace infoCreating Interactive Line Charts
Time Series with Interactive Features:
Line charts are perfect for exploring temporal patterns interactively.
import plotly.express as px
import pandas as pd
import numpy as np
# Generate monthly revenue data for 3 years
np.random.seed(42)
dates = pd.date_range('2022-01-01', '2024-12-31', freq='D')
df_revenue = pd.DataFrame({
'date': dates,
'revenue': np.random.normal(100000, 15000, len(dates)),
'region': np.random.choice(['North', 'South', 'East'], len(dates))
})
# Add trend and seasonality
df_revenue['revenue'] = (
80000 +
(df_revenue.index * 30) + # Growth trend
20000 * np.sin(df_revenue.index / 365 * 2 * np.pi) + # Yearly seasonality
df_revenue['revenue'] * 0.2
)
# Aggregate by month and region
df_monthly = df_revenue.groupby([pd.Grouper(key='date', freq='M'), 'region'])['revenue'].sum().reset_index()
# Create interactive line chart
fig = px.line(df_monthly,
x='date',
y='revenue',
color='region',
title='Monthly Revenue Trends by Region (2022-2024)',
labels={'revenue': 'Monthly Revenue ($)', 'date': 'Month'})
# Enhance layout
fig.update_layout(
hovermode='x unified', # Show all series at once when hovering
xaxis=dict(
rangeslider=dict(visible=True), # Add range slider
type='date'
),
yaxis=dict(
tickformat='$,.0f' # Format Y-axis as currency
),
legend=dict(
title='Region',
yanchor='top',
y=0.99,
xanchor='right',
x=0.99
)
)
fig.show()Output:
[Interactive line chart: “Monthly Revenue Trends by Region (2022-2024)”, x: date, y: date]
Interactive Features Explained:
1. Range Slider (rangeslider):
2. Hover Mode ‘x unified’:
3. Legend Interaction:
Business Use Case:
Executive asks: “Did the South region dip in Q3 2023?”
Interactive Bar Charts with Drill-Down
Bar Charts with Rich Context:
import plotly.express as px
import pandas as pd
import numpy as np
# Product category sales data
np.random.seed(42)
categories = ['Electronics', 'Clothing', 'Home Goods', 'Sports', 'Books', 'Toys']
df_sales = pd.DataFrame({
'category': categories,
'q1_sales': np.random.uniform(200000, 500000, len(categories)),
'q2_sales': np.random.uniform(250000, 550000, len(categories)),
'q3_sales': np.random.uniform(230000, 520000, len(categories)),
'q4_sales': np.random.uniform(300000, 600000, len(categories)),
'units_sold': np.random.randint(5000, 25000, len(categories)),
'avg_rating': np.random.uniform(3.8, 4.8, len(categories))
})
df_sales['total_sales'] = (df_sales['q1_sales'] + df_sales['q2_sales'] +
df_sales['q3_sales'] + df_sales['q4_sales'])
# Sort by total sales
df_sales = df_sales.sort_values('total_sales', ascending=True)
# Create horizontal bar chart
fig = px.bar(df_sales,
y='category',
x='total_sales',
orientation='h',
title='Annual Sales by Product Category - 2024',
labels={'total_sales': 'Total Annual Sales ($)', 'category': ''},
hover_data={
'total_sales': ':$,.0f',
'units_sold': ':,.0f',
'avg_rating': ':.1f'
},
color='total_sales',
color_continuous_scale='Blues')
# Customize layout
fig.update_layout(
showlegend=False,
xaxis=dict(
title='Annual Sales',
tickformat='$,.0f',
showgrid=True,
gridcolor='lightgray'
),
yaxis=dict(
title=''
),
height=500,
coloraxis_colorbar=dict(
title='Sales ($)',
tickformat='$,.0f'
)
)
fig.show()Output:
[Interactive bar chart: “Annual Sales by Product Category - 2024”, x: total_sales, y: category]
Advanced Hover Formatting:
In hover_data:
{column: format_string}Color Scales:
Saving and Sharing Interactive Visualizations
Export Options:
1. HTML (Interactive):
fig.write_html('M4L01_Interactive_Sales.html')Output:
[Chart] - Fully interactive - Opens in any browser - Can be shared via email - Embeds in websites - File size: Usually 500KB - 2MB
2. Static Image (Non-Interactive):
fig.write_image('M4L01_Sales_Chart.png', width=1200, height=800)pip install kaleido3. For Presentations:
# Higher quality for projection
fig.write_image('M4L01_Presentation.png', width=1920, height=1080, scale=2)Embedding in Reports:
Interactive HTML charts can be embedded in:
Plotly Express vs Graph Objects - When to Use Each
Quick Reference:
Use Plotly Express when:
Use Graph Objects when:
Example Comparison:
Plotly Express (Simple):
import plotly.express as px
df = pd.DataFrame({
'sales': np.random.uniform(10000, 100000, 60),
'profit': np.random.uniform(1000, 20000, 60),
'region': np.random.choice(['North', 'South', 'East', 'West'], 60)
})
fig = px.scatter(df, x='sales', y='profit', color='region')
fig.show()Output:
[Interactive scatter plot: x: sales, y: profit]
Graph Objects (More Control):
import plotly.graph_objects as go
fig = go.Figure()
for region in df['region'].unique():
df_region = df[df['region'] == region]
fig.add_trace(go.Scatter(
x=df_region['sales'],
y=df_region['profit'],
mode='markers',
name=region,
marker=dict(size=10, opacity=0.7)
))
fig.update_layout(title='Sales vs Profit by Region')
fig.show()Output:
[Interactive Plotly chart: “Sales vs Profit by Region”]
Both produce similar results, but Express is much more concise for standard cases.
Lab 1: Creating Interactive Business Visualizations
Objective: Master Plotly’s interactive capabilities by creating professional, explorable visualizations that enable stakeholders to discover insights through interaction.
Scenario: You’re the Business Intelligence Developer at “DataDrive Consulting,” hired by “MegaRetail Corp” to modernize their data presentation. The executive team is tired of static PowerPoint charts that can’t answer follow-up questions. Your mission is to create interactive visualizations that executives can explore during meetings, allowing them to answer their own questions in real-time.
Pre-Lab Setup:
M4L01_YourName_Interactive.pyimport plotly.express as px
import plotly.graph_objects as go
import pandas as pd
import numpy as nppip install kaleidoPart A: Interactive Sales Performance Explorer (25 points)
Context: The VP of Sales wants to explore 3 years of daily sales data across 5 regions. They need to zoom into specific periods, compare regions, and identify trends without requesting new charts.
Data:
np.random.seed(42)
# Generate 3 years of daily sales data
dates = pd.date_range('2022-01-01', '2024-12-31', freq='D')
regions = ['Northeast', 'Southeast', 'Midwest', 'Southwest', 'West']
data_list = []
for date in dates:
for region in regions:
# Base sales with regional differences
base = {'Northeast': 25000, 'Southeast': 22000, 'Midwest': 28000,
'Southwest': 20000, 'West': 30000}[region]
# Add trend, seasonality, and randomness
day_of_year = date.timetuple().tm_yday
trend = (date.year - 2022) * 1000 # Growth over years
seasonality = 5000 * np.sin(day_of_year / 365 * 2 * np.pi) # Yearly cycle
random_var = np.random.normal(0, 3000)
sales = base + trend + seasonality + random_var
data_list.append({
'date': date,
'region': region,
'daily_sales': max(sales, 5000) # Ensure positive
})
df_sales = pd.DataFrame(data_list)
# Aggregate to monthly for cleaner visualization
df_monthly = df_sales.groupby([pd.Grouper(key='date', freq='M'), 'region'])['daily_sales'].sum().reset_index()
df_monthly['date'] = df_monthly['date'].dt.to_period('M').dt.to_timestamp()Tasks:
Create interactive line chart with range slider (12 points):
px.line() with date on x-axis, daily_sales on y-axisrangeslider=dict(visible=True))Enhance interactivity and formatting (8 points):
Save and document (5 points):
M4L01_YourName_SalesExplorer.htmlM4L01_YourName_SalesExplorer.pngPart B: Marketing Campaign ROI Interactive Scatter (30 points)
Context: The CMO needs to evaluate 50 marketing campaigns across different channels and customer segments. They want to explore which campaigns had best ROI, identify outliers, and understand patterns through interaction.
Data:
np.random.seed(42)
channels = ['Email', 'Social Media', 'PPC', 'Display', 'Influencer']
segments = ['New Customers', 'Existing Customers', 'VIP', 'Lapsed']
campaigns_list = []
for i in range(50):
channel = np.random.choice(channels)
segment = np.random.choice(segments)
# Different channels have different cost structures
if channel == 'Influencer':
cost = np.random.uniform(15000, 50000)
revenue = cost * np.random.uniform(2.0, 5.0)
elif channel == 'PPC':
cost = np.random.uniform(5000, 25000)
revenue = cost * np.random.uniform(2.5, 4.5)
elif channel == 'Email':
cost = np.random.uniform(2000, 8000)
revenue = cost * np.random.uniform(3.0, 6.0)
elif channel == 'Social Media':
cost = np.random.uniform(3000, 15000)
revenue = cost * np.random.uniform(2.0, 5.0)
else: # Display
cost = np.random.uniform(8000, 30000)
revenue = cost * np.random.uniform(1.5, 3.5)
campaigns_list.append({
'campaign_id': f'CAMP-{i+1:03d}',
'channel': channel,
'segment': segment,
'cost': cost,
'revenue': revenue,
'roi': (revenue - cost) / cost,
'duration_days': np.random.randint(14, 90),
'impressions': int(cost * np.random.uniform(5, 20))
})
df_campaigns = pd.DataFrame(campaigns_list)Tasks:
Create advanced interactive scatter plot (15 points):
size='roi' parameter with appropriate size range (size_max=30)trendline='ols' (ordinary least squares regression)Format hover information professionally (10 points):
Add business intelligence features (5 points):
M4L01_YourName_CampaignROI.html and .pngPart C: Product Category Sales Comparison (25 points)
Context: The Product team wants an interactive bar chart showing quarterly sales by category, allowing them to toggle between quarters and compare performance.
Data:
np.random.seed(42)
categories = ['Electronics', 'Clothing', 'Home & Garden', 'Sports & Outdoors',
'Books & Media', 'Toys & Games', 'Health & Beauty', 'Automotive']
quarters_list = []
for quarter in ['Q1', 'Q2', 'Q3', 'Q4']:
for category in categories:
# Different categories perform differently by quarter
base_sales = np.random.uniform(500000, 2000000)
# Q4 boost for certain categories
if quarter == 'Q4' and category in ['Electronics', 'Toys & Games']:
boost = 1.5
elif quarter == 'Q1' and category in ['Health & Beauty', 'Sports & Outdoors']:
boost = 1.3
else:
boost = 1.0
quarters_list.append({
'quarter': quarter,
'category': category,
'sales': base_sales * boost,
'units_sold': int(base_sales / np.random.uniform(50, 200)),
'profit_margin': np.random.uniform(0.15, 0.35)
})
df_products = pd.DataFrame(quarters_list)Tasks:
Create grouped bar chart with animation (15 points):
px.bar() with animation_frame=‘quarter’Enhance animation controls (5 points):
Analysis and insights (5 points):
M4L01_YourName_ProductQuarterly.html and .pngPart D: Employee Satisfaction Multi-Dimensional Analysis (20 points)
Context: HR wants to explore employee satisfaction across departments, tenure, and locations using an interactive bubble chart.
Data:
np.random.seed(42)
departments = ['Engineering', 'Sales', 'Marketing', 'Operations', 'Finance', 'HR', 'Customer Support']
locations = ['New York', 'San Francisco', 'Chicago', 'Austin', 'Remote']
employees_list = []
for dept in departments:
n_employees = np.random.randint(25, 60)
for _ in range(n_employees):
location = np.random.choice(locations)
tenure = np.random.uniform(0.5, 15)
# Different departments have different satisfaction patterns
if dept == 'Engineering':
base_satisfaction = 4.2
elif dept == 'Sales':
base_satisfaction = 3.7
elif dept == 'Customer Support':
base_satisfaction = 3.5
else:
base_satisfaction = 4.0
# Longer tenure slightly higher satisfaction
tenure_effect = min(tenure * 0.05, 0.5)
satisfaction = base_satisfaction + tenure_effect + np.random.normal(0, 0.4)
satisfaction = np.clip(satisfaction, 1, 5)
salary = np.random.normal(
{'Engineering': 110000, 'Sales': 85000, 'Marketing': 80000,
'Operations': 75000, 'Finance': 95000, 'HR': 78000,
'Customer Support': 65000}[dept],
15000
)
employees_list.append({
'department': dept,
'location': location,
'tenure_years': tenure,
'satisfaction_score': satisfaction,
'salary': max(salary, 45000)
})
df_employees = pd.DataFrame(employees_list)Tasks:
Create multi-dimensional bubble chart (12 points):
px.scatter() with:
Interactive filtering capabilities (5 points):
Insights documentation (3 points):
M4L01_YourName_EmployeeSatisfaction.html and .pngBonus Challenge (+20 points):
Create an Interactive Dashboard with Dropdown Selectors:
Build a single interactive figure that allows users to: 1. Select which metric to display via dropdown (Sales, Profit, ROI) 2. Select time period via dropdown (Monthly, Quarterly, Yearly) 3. Toggle between chart types via buttons (Line, Bar, Area)
Requirements:
updatemenus for dropdown controlsM4L01_YourName_InteractiveDashboard.htmlHint: Research fig.update_layout(updatemenus=[...]) in Plotly documentation.
Deliverables:
M4L01_YourName_Interactive.pyM4L01_YourName_SalesExplorer.htmlM4L01_YourName_CampaignROI.htmlM4L01_YourName_ProductQuarterly.htmlM4L01_YourName_EmployeeSatisfaction.htmlM4L01_YourName_InteractiveDashboard.html (bonus)Grading Rubric:
Success Criteria:
Interactivity Checklist:
For each visualization, verify:
Common Mistakes to Avoid:
Professional Tips:
fig.show() during development to previewMulti-Trace Figures - Combining Different Visualizations
The Power of Layered Information:
Real business analysis often requires showing different data types on the same chart:
Example: Sales with Target Lines and Average:
import plotly.graph_objects as go
import pandas as pd
import numpy as np
# Generate monthly sales data
np.random.seed(42)
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
actual_sales = np.random.normal(100000, 15000, 12)
target_sales = np.full(12, 110000)
forecast = actual_sales * 1.1 # Next year forecast
# Create figure with multiple traces
fig = go.Figure()
# Trace 1: Actual sales (bar chart)
fig.add_trace(go.Bar(
x=months,
y=actual_sales,
name='Actual Sales',
marker_color='lightblue',
hovertemplate='<b>Actual</b><br>%{x|%b %Y}<br>$%{y:,.0f}<extra></extra>'
))
# Trace 2: Target line
fig.add_trace(go.Scatter(
x=months,
y=target_sales,
name='Target',
line=dict(color='red', width=3, dash='dash'),
hovertemplate='<b>Target</b><br>$%{y:,.0f}<extra></extra>'
))
# Trace 3: Forecast line
fig.add_trace(go.Scatter(
x=months,
y=forecast,
name='2025 Forecast',
line=dict(color='green', width=2, dash='dot'),
hovertemplate='<b>Forecast</b><br>%{x|%b %Y}<br>$%{y:,.0f}<extra></extra>'
))
# Trace 4: Average line
avg_sales = np.mean(actual_sales)
fig.add_hline(y=avg_sales,
line_dash='dash',
line_color='gray',
annotation_text=f'Average: ${avg_sales:,.0f}',
annotation_position='right')
# Update layout
fig.update_layout(
title='2024 Sales Performance: Actual vs Target with 2025 Forecast',
xaxis_title='Month',
yaxis_title='Sales ($)',
yaxis_tickformat='$,.0f',
hovermode='x unified',
legend=dict(
orientation='h',
yanchor='bottom',
y=1.02,
xanchor='right',
x=1
),
height=600
)
fig.show()Output:
[Interactive Plotly chart: “2024 Sales Performance: Actual vs Target with 2025 Forecast”]
Understanding Multi-Trace Construction:
Why Use Graph Objects Here:
Key Techniques:
add_trace(): Adds new data seriesadd_hline() / add_vline(): Reference lineshovermode='x unified': Compare all traces at onceBusiness Value:
Faceted Plots - Small Multiples for Comparison
The Small Multiples Principle:
When comparing many groups, sometimes separate plots work better than overlaying: - Each group gets full space - Patterns within groups clearer - Easy to spot outliers per group - Still comparable (same scales)
Creating Faceted Plots with Plotly Express:
import plotly.express as px
import pandas as pd
import numpy as np
# Generate sales data for multiple products and regions
np.random.seed(42)
products = ['Product A', 'Product B', 'Product C', 'Product D']
regions = ['North', 'South', 'East', 'West']
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
data_list = []
for product in products:
for region in regions:
for month in months:
# Different products have different patterns
base = {'Product A': 50000, 'Product B': 35000,
'Product C': 45000, 'Product D': 30000}[product]
# Regional variation
regional_mult = {'North': 1.1, 'South': 0.9,
'East': 1.2, 'West': 1.0}[region]
# Trend and noise
month_num = month.month
sales = base * regional_mult * (1 + 0.1 * np.sin(month_num/6 * np.pi)) + np.random.normal(0, 3000)
data_list.append({
'date': month,
'product': product,
'region': region,
'sales': max(sales, 10000)
})
df_sales = pd.DataFrame(data_list)
# Create faceted line chart
fig = px.line(df_sales,
x='date',
y='sales',
color='region',
facet_col='product',
facet_col_wrap=2, # 2 columns, multiple rows
title='Sales Performance by Product and Region - 2024',
labels={'sales': 'Monthly Sales ($)', 'date': 'Month'},
height=800)
# Update all subplot titles
fig.for_each_annotation(lambda a: a.update(text=a.text.split('=')[1]))
# Format y-axes
fig.update_yaxes(tickformat='$,.0f')
# Improve facet spacing
fig.update_layout(
showlegend=True,
legend=dict(
title='Region',
orientation='v',
yanchor='top',
y=1,
xanchor='left',
x=1.02
)
)
fig.show()Output:
[Interactive line chart: “Sales Performance by Product and Region - 2024”, x: date, y: sales]
Faceting Parameters:
facet_col: Creates columns of subplots
facet_col='product': One column per productfacet_row: Creates rows of subplots
facet_row='region': One row per regionfacet_col_wrap: Wraps columns to multiple rows
facet_col_wrap=2: Maximum 2 columns, then wrap to next rowWhen to Use Facets:
Dropdown Menus and Buttons - User-Controlled Interactivity
Beyond Hover and Zoom:
Sometimes users need to change WHAT data is displayed, not just HOW it’s viewed:
Creating Dropdown Menus:
import plotly.graph_objects as go
import pandas as pd
import numpy as np
# Generate data
np.random.seed(42)
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
revenue = np.random.normal(100000, 15000, 12)
profit = revenue * np.random.uniform(0.15, 0.30, 12)
units = revenue / np.random.uniform(45, 55, 12)
# Create figure with multiple traces (initially all visible)
fig = go.Figure()
# Revenue trace
fig.add_trace(go.Scatter(
x=months,
y=revenue,
name='Revenue',
line=dict(color='blue', width=3),
visible=True
))
# Profit trace
fig.add_trace(go.Scatter(
x=months,
y=profit,
name='Profit',
line=dict(color='green', width=3),
visible=False # Initially hidden
))
# Units trace
fig.add_trace(go.Scatter(
x=months,
y=units,
name='Units Sold',
line=dict(color='orange', width=3),
visible=False # Initially hidden
))
# Create dropdown menu
fig.update_layout(
updatemenus=[
dict(
buttons=list([
dict(
args=[{'visible': [True, False, False]},
{'yaxis': {'title': 'Revenue ($)', 'tickformat': '$,.0f'}}],
label='Revenue',
method='update'
),
dict(
args=[{'visible': [False, True, False]},
{'yaxis': {'title': 'Profit ($)', 'tickformat': '$,.0f'}}],
label='Profit',
method='update'
),
dict(
args=[{'visible': [False, False, True]},
{'yaxis': {'title': 'Units Sold', 'tickformat': ',.0f'}}],
label='Units',
method='update'
),
]),
direction='down',
pad={'r': 10, 't': 10},
showactive=True,
x=0.11,
xanchor='left',
y=1.15,
yanchor='top'
),
],
title='Business Performance Dashboard - Select Metric',
xaxis_title='Month',
yaxis_title='Revenue ($)',
yaxis_tickformat='$,.0f',
height=600
)
fig.show()Output:
[Interactive Plotly chart: “Business Performance Dashboard - Select Metric”]
Understanding Update Menus:
Structure:
updatemenus=[
dict(
buttons=[...], # List of button definitions
direction='down', # Dropdown direction
showactive=True, # Highlight selected button
x=0.11, # Position (0-1 scale)
y=1.15 # Position (0-1 scale)
)
]Button Definition:
dict(
args=[{trace updates}, {layout updates}],
label='Button Text',
method='update' # 'update' changes both traces and layout
)args Structure:
{'visible': [True, False, False]}){'yaxis': {'title': 'New Title'}})Business Application:
Executive dashboard where users select:
Animation - Showing Change Over Time
When Animation Enhances Understanding:
Animation is powerful when:
Creating Animated Scatter Plot:
import plotly.express as px
import pandas as pd
import numpy as np
# Generate data: Company metrics over 5 years
np.random.seed(42)
years = range(2020, 2025)
companies = ['TechCorp', 'InnovateLtd', 'DataSystems', 'CloudNet',
'AIVentures', 'DevOps Inc', 'CyberGuard']
data_list = []
for year in years:
for company in companies:
# Each company grows differently
year_factor = (year - 2020) + 1
revenue = np.random.uniform(10, 100) * year_factor
profit_margin = np.random.uniform(0.05, 0.30)
employees = int(revenue * np.random.uniform(5, 15))
data_list.append({
'year': year,
'company': company,
'revenue': revenue,
'profit_margin': profit_margin,
'employees': employees
})
df_companies = pd.DataFrame(data_list)
# Create animated scatter plot
fig = px.scatter(df_companies,
x='revenue',
y='profit_margin',
animation_frame='year',
animation_group='company',
size='employees',
color='company',
hover_name='company',
size_max=60,
range_x=[0, 500],
range_y=[0, 0.35],
title='Company Growth Animation: Revenue vs Profitability (2020-2024)',
labels={
'revenue': 'Revenue ($M)',
'profit_margin': 'Profit Margin',
'year': 'Year'
})
# Format hover
fig.update_traces(
hovertemplate='<b>%{hovertext}</b><br>' +
'Revenue: $%{x:.1f}M<br>' +
'Profit Margin: %{y:.1%}<br>' +
'<extra></extra>'
)
# Improve animation controls
fig.layout.updatemenus[0].buttons[0].args[1]['frame']['duration'] = 1000
fig.layout.updatemenus[0].buttons[0].args[1]['transition']['duration'] = 500
fig.show()Output:
[Interactive scatter plot: “Company Growth Animation: Revenue vs Profitability (2020-2024)”, x: revenue, y: profit_margin]
Animation Parameters:
animation_frame: Variable that defines time steps
'year' creates 5 frames (2020-2024)animation_group: Variable that tracks objects across frames
Fixed Ranges (Important!):
range_x=[0, 500],
range_y=[0, 0.35]Without fixed ranges, axes rescale each frame (disorienting).
Animation Speed:
fig.layout.updatemenus[0].buttons[0].args[1]['frame']['duration'] = 1000 # 1 second per frame
fig.layout.updatemenus[0].buttons[0].args[1]['transition']['duration'] = 500 # 0.5s transitionWhen to Use Animation:
3D Visualizations - Adding Another Dimension
Three-Dimensional Data:
Some business problems naturally have three continuous dimensions:
Creating 3D Scatter Plot:
import plotly.express as px
import pandas as pd
import numpy as np
# Generate customer data with 3 dimensions
np.random.seed(42)
n_customers = 300
df_customers = pd.DataFrame({
'customer_id': range(1, n_customers + 1),
'age': np.random.normal(40, 15, n_customers),
'annual_income': np.random.normal(65000, 25000, n_customers),
'annual_spending': np.random.normal(25000, 10000, n_customers),
'segment': np.random.choice(['Budget', 'Standard', 'Premium'], n_customers)
})
# Ensure reasonable values
df_customers['age'] = df_customers['age'].clip(18, 80)
df_customers['annual_income'] = df_customers['annual_income'].clip(20000, 200000)
df_customers['annual_spending'] = df_customers['annual_spending'].clip(5000, 80000)
# Create realistic relationships
df_customers['annual_spending'] = (
5000 +
0.2 * df_customers['annual_income'] +
np.random.normal(0, 5000, n_customers)
)
# Segment based on behavior
df_customers['segment'] = pd.cut(
df_customers['annual_spending'] / df_customers['annual_income'],
bins=[0, 0.2, 0.4, 1.0],
labels=['Budget', 'Standard', 'Premium']
)
# Create 3D scatter plot
fig = px.scatter_3d(df_customers,
x='age',
y='annual_income',
z='annual_spending',
color='segment',
size_max=10,
title='Customer Segmentation Analysis (3D)',
labels={
'age': 'Age (years)',
'annual_income': 'Annual Income ($)',
'annual_spending': 'Annual Spending ($)'
},
color_discrete_map={
'Budget': 'lightblue',
'Standard': 'lightgreen',
'Premium': 'gold'
})
# Format hover
fig.update_traces(
hovertemplate='<b>Customer</b><br>' +
'Age: %{x:.0f}<br>' +
'Income: $%{y:,.0f}<br>' +
'Spending: $%{z:,.0f}<br>' +
'<extra></extra>'
)
# Update layout for better 3D viewing
fig.update_layout(
scene=dict(
xaxis_title='Age',
yaxis_title='Income ($)',
zaxis_title='Spending ($)',
camera=dict(
eye=dict(x=1.5, y=1.5, z=1.3) # Viewing angle
)
),
height=700
)
fig.show()Output:
[Interactive 3D scatter plot: “Customer Segmentation Analysis (3D)”, x: age, y: annual_income]
3D Interactivity:
Users can:
When to Use 3D:
Good use cases:
Avoid 3D when:
Alternative: Multiple 2D views often better than 3D
Synchronized Subplots - Coordinated Multiple Views
The Coordinated View Concept:
Show multiple related views that interact together:
Creating Synchronized Subplots:
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np
# Generate product data
np.random.seed(42)
products = ['Product A', 'Product B', 'Product C', 'Product D', 'Product E']
metrics = []
for product in products:
metrics.append({
'product': product,
'revenue': np.random.uniform(500000, 2000000),
'profit': np.random.uniform(50000, 400000),
'units_sold': np.random.randint(5000, 25000),
'customer_satisfaction': np.random.uniform(3.5, 4.8),
'return_rate': np.random.uniform(0.02, 0.12)
})
df_products = pd.DataFrame(metrics)
# Create subplots with shared x-axis
fig = make_subplots(
rows=3, cols=1,
shared_xaxes=True,
vertical_spacing=0.05,
subplot_titles=('Revenue by Product', 'Customer Satisfaction', 'Return Rate')
)
# Add revenue bars
fig.add_trace(
go.Bar(x=df_products['product'], y=df_products['revenue'],
name='Revenue', marker_color='lightblue',
hovertemplate='%{x}<br>Revenue: $%{y:,.0f}<extra></extra>'),
row=1, col=1
)
# Add satisfaction line
fig.add_trace(
go.Scatter(x=df_products['product'], y=df_products['customer_satisfaction'],
mode='lines+markers', name='Satisfaction',
line=dict(color='green', width=3),
hovertemplate='%{x}<br>Satisfaction: %{y:.2f}/5<extra></extra>'),
row=2, col=1
)
# Add return rate bars
fig.add_trace(
go.Bar(x=df_products['product'], y=df_products['return_rate'],
name='Return Rate', marker_color='salmon',
hovertemplate='%{x}<br>Returns: %{y:.1%}<extra></extra>'),
row=3, col=1
)
# Update layout
fig.update_layout(
title_text='Product Performance Dashboard - Synchronized Views',
showlegend=True,
height=900,
hovermode='x unified' # Synchronize hover across all subplots
)
# Update axes
fig.update_yaxes(title_text='Revenue ($)', row=1, col=1, tickformat='$,.0f')
fig.update_yaxes(title_text='Satisfaction (1-5)', row=2, col=1)
fig.update_yaxes(title_text='Return Rate', row=3, col=1, tickformat='.1%')
fig.update_xaxes(title_text='Product', row=3, col=1)
fig.show()Output:
[Interactive Plotly chart]
Key Synchronization Features:
shared_xaxes=True:
hovermode=‘x unified’:
Business Value:
Hover over “Product C”:
Custom Styling and Themes
Beyond Default Aesthetics:
Professional applications require brand consistency:
Creating a Custom Theme:
import plotly.graph_objects as go
import plotly.express as px
# Define company theme
COMPANY_COLORS = {
'primary': '#1F4788', # Corporate blue
'secondary': '#F39C12', # Accent orange
'success': '#27AE60', # Green
'danger': '#E74C3C', # Red
'background': '#F8F9FA', # Light gray
'text': '#2C3E50' # Dark blue-gray
}
COMPANY_TEMPLATE = go.layout.Template(
layout=go.Layout(
font=dict(
family='Arial, sans-serif',
size=12,
color=COMPANY_COLORS['text']
),
title=dict(
font=dict(size=18, color=COMPANY_COLORS['text']),
x=0.5,
xanchor='center'
),
plot_bgcolor=COMPANY_COLORS['background'],
paper_bgcolor='white',
colorway=[COMPANY_COLORS['primary'], COMPANY_COLORS['secondary'],
COMPANY_COLORS['success'], COMPANY_COLORS['danger']],
xaxis=dict(
showgrid=True,
gridcolor='white',
showline=True,
linecolor=COMPANY_COLORS['text'],
linewidth=2
),
yaxis=dict(
showgrid=True,
gridcolor='white',
showline=True,
linecolor=COMPANY_COLORS['text'],
linewidth=2
)
)
)
# Use the custom template
df = pd.DataFrame({
'category': ['Electronics', 'Accessories', 'Software', 'Services'],
'sales': [45000, 28000, 35000, 22000]
})
fig = px.bar(df, x='category', y='sales')
fig.update_layout(template=COMPANY_TEMPLATE)
fig.show()Output:
[Interactive bar chart: x: category, y: Arial, sans-serif]
Applying Theme Globally:
import plotly.io as pio
# Set as default template
pio.templates['company_theme'] = COMPANY_TEMPLATE
pio.templates.default = 'company_theme'
# Now all plots use this theme automatically
df = pd.DataFrame({'x': range(5), 'y': [1, 4, 2, 5, 3]})
fig = px.scatter(df, x='x', y='y')
fig.show() # Automatically uses company themeOutput:
[Interactive scatter plot: x: x, y: y]
Lab 2: Advanced Interactive Visualizations
Objective: Master advanced Plotly techniques including multi-trace figures, animations, user controls, and 3D visualizations to create sophisticated, business-ready interactive dashboards.
Scenario: You’re the Lead Data Visualization Engineer at “GlobalInsights Analytics,” working for a Fortune 500 client launching a new product line. The executive committee needs advanced interactive visualizations for their quarterly board presentation. Standard charts won’t suffice - they need visualizations that tell stories, respond to questions, and impress stakeholders. Your mission is to create cutting-edge interactive visualizations that showcase data sophistication.
Pre-Lab Setup:
M4L02_YourName_Advanced.pyimport plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import pandas as pd
import numpy as npPart A: Multi-Metric Performance Dashboard with Dropdown Controls (30 points)
Context: The CFO needs one dashboard that can switch between viewing Revenue, Profit, Operating Costs, and ROI - all with proper formatting and context for each metric.
Data:
np.random.seed(42)
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
df_financial = pd.DataFrame({
'month': months,
'revenue': np.random.uniform(800000, 1200000, 12) + np.arange(12) * 10000,
'costs': np.random.uniform(500000, 700000, 12) + np.arange(12) * 5000,
'marketing': np.random.uniform(50000, 100000, 12),
'r_and_d': np.random.uniform(80000, 150000, 12)
})
df_financial['profit'] = df_financial['revenue'] - df_financial['costs']
df_financial['operating_costs'] = df_financial['marketing'] + df_financial['r_and_d']
df_financial['roi'] = (df_financial['profit'] / df_financial['operating_costs']) * 100Tasks:
Create multi-trace figure with dropdown selector (20 points):
Add target lines and annotations (5 points):
Professional styling (5 points):
M4L02_YourName_FinancialDashboard.htmlPart B: Animated Market Share Evolution (25 points)
Context: Marketing needs to show how market share evolved quarter-over-quarter for top 8 competitors, with animation revealing the competitive dynamics.
Data:
np.random.seed(42)
quarters = ['Q1 2023', 'Q2 2023', 'Q3 2023', 'Q4 2023',
'Q1 2024', 'Q2 2024', 'Q3 2024', 'Q4 2024']
companies = ['Our Company', 'Competitor A', 'Competitor B', 'Competitor C',
'Competitor D', 'Competitor E', 'Competitor F', 'Others']
market_data = []
for i, quarter in enumerate(quarters):
# Each company's market share evolves
shares = {
'Our Company': 22 + i * 1.5 + np.random.uniform(-1, 1),
'Competitor A': 18 - i * 0.3 + np.random.uniform(-1, 1),
'Competitor B': 15 + i * 0.5 + np.random.uniform(-1, 1),
'Competitor C': 12 - i * 0.2 + np.random.uniform(-1, 1),
'Competitor D': 11 + i * 0.3 + np.random.uniform(-1, 1),
'Competitor E': 9 - i * 0.4 + np.random.uniform(-1, 1),
'Competitor F': 7 + i * 0.1 + np.random.uniform(-1, 1),
}
# Others is remainder
shares['Others'] = 100 - sum(shares.values())
for company, share in shares.items():
market_data.append({
'quarter': quarter,
'company': company,
'market_share': max(share, 1) # Ensure positive
})
df_market = pd.DataFrame(market_data)Tasks:
Create animated bar chart race (15 points):
Optimize animation quality (5 points):
Business insights overlay (5 points):
M4L02_YourName_MarketShareAnimation.htmlPart C: 3D Product Portfolio Analysis (25 points)
Context: The product team needs to visualize their portfolio across three dimensions: Price, Quality Score, and Market Demand, with segments identified.
Data:
np.random.seed(42)
n_products = 50
df_portfolio = pd.DataFrame({
'product_id': [f'SKU-{i:03d}' for i in range(1, n_products + 1)],
'price': np.random.uniform(20, 500, n_products),
'quality_score': np.random.uniform(60, 100, n_products),
'market_demand': np.random.uniform(1000, 50000, n_products),
'profit_margin': np.random.uniform(0.10, 0.40, n_products),
'category': np.random.choice(['Electronics', 'Accessories', 'Software'], n_products)
})
# Create natural relationships
df_portfolio['market_demand'] = df_portfolio['market_demand'] * (
1 + (100 - df_portfolio['price']) / 100
) # Lower price = higher demand
df_portfolio['profit_margin'] = df_portfolio['profit_margin'] * (
1 + (df_portfolio['quality_score'] - 60) / 100
) # Higher quality = higher margin
# Strategic segments
df_portfolio['strategic_segment'] = 'Standard'
df_portfolio.loc[(df_portfolio['quality_score'] > 85) &
(df_portfolio['profit_margin'] > 0.25), 'strategic_segment'] = 'Premium Stars'
df_portfolio.loc[(df_portfolio['market_demand'] > 30000) &
(df_portfolio['profit_margin'] > 0.20), 'strategic_segment'] = 'Volume Winners'
df_portfolio.loc[(df_portfolio['quality_score'] < 70) |
(df_portfolio['profit_margin'] < 0.15), 'strategic_segment'] = 'Review Needed'Tasks:
Create interactive 3D scatter plot (15 points):
Enhance 3D visualization (5 points):
Strategic insights (5 points):
M4L02_YourName_Portfolio3D.html and M4L02_YourName_Portfolio2D.htmlPart D: Synchronized Multi-View Sales Dashboard (20 points)
Context: Regional managers need a dashboard showing sales performance, with synchronized views of different metrics that highlight together.
Data:
np.random.seed(42)
regions = ['North', 'South', 'East', 'West', 'Central']
df_regional = pd.DataFrame({
'region': regions,
'q1_sales': [450000, 380000, 520000, 410000, 390000],
'q2_sales': [470000, 390000, 550000, 430000, 405000],
'q3_sales': [490000, 405000, 570000, 445000, 420000],
'q4_sales': [580000, 480000, 650000, 520000, 495000],
'customer_count': [2500, 2100, 2900, 2300, 2200],
'avg_deal_size': [800, 750, 900, 850, 775],
'satisfaction': [4.3, 4.1, 4.5, 4.2, 4.0]
})
df_regional['total_sales'] = (df_regional['q1_sales'] + df_regional['q2_sales'] +
df_regional['q3_sales'] + df_regional['q4_sales'])
df_regional['growth_rate'] = (df_regional['q4_sales'] - df_regional['q1_sales']) / df_regional['q1_sales']Tasks:
Create synchronized 4-panel dashboard (15 points):
make_subplots() with 2 rows, 2 columnsImplement interactivity (3 points):
hovermode='x unified' where appropriateLayout optimization (2 points):
M4L02_YourName_SynchronizedDashboard.htmlBonus Challenge (+25 points):
Create an Executive Decision Support Tool:
Build an advanced interactive dashboard combining multiple techniques:
Requirements:
M4L02_YourName_ExecutiveTool.htmlDeliverables:
M4L02_YourName_Advanced.pyM4L02_YourName_FinancialDashboard.htmlM4L02_YourName_MarketShareAnimation.htmlM4L02_YourName_Portfolio3D.htmlM4L02_YourName_Portfolio2D.htmlM4L02_YourName_SynchronizedDashboard.htmlM4L02_YourName_ExecutiveTool.html (bonus)Grading Rubric:
Success Criteria:
Advanced Techniques Checklist:
Common Mistakes to Avoid:
The Anatomy of an Effective Business Dashboard
What Makes a Dashboard Effective:
A dashboard is not just multiple charts on one page. An effective business dashboard has:
1. Clear Hierarchy:
2. Context and Comparison:
3. Actionability:
4. Appropriate Density:
Dashboard Design Principles:
The 5-Second Rule:
The “So What?” Test:
Building a Multi-Panel Dashboard Layout
Strategic Layout Patterns:
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np
# Generate comprehensive business data
np.random.seed(42)
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
df_business = pd.DataFrame({
'month': months,
'revenue': np.random.uniform(800000, 1200000, 12) + np.arange(12) * 20000,
'costs': np.random.uniform(500000, 700000, 12) + np.arange(12) * 10000,
'new_customers': np.random.randint(150, 300, 12),
'churn_rate': np.random.uniform(0.02, 0.08, 12)
})
df_business['profit'] = df_business['revenue'] - df_business['costs']
df_business['profit_margin'] = df_business['profit'] / df_business['revenue']
# Regional breakdown
regions = ['North', 'South', 'East', 'West']
regional_sales = [3200000, 2800000, 3500000, 2900000]
# Product categories
categories = ['Product A', 'Product B', 'Product C', 'Product D']
category_revenue = [4200000, 3500000, 2800000, 2100000]
# Create dashboard layout: 2x2 grid
fig = make_subplots(
rows=2, cols=2,
subplot_titles=('Monthly Revenue Trend',
'Regional Sales Distribution',
'Profit Margin Evolution',
'Product Revenue Breakdown'),
specs=[[{'type': 'scatter'}, {'type': 'bar'}],
[{'type': 'scatter'}, {'type': 'pie'}]],
vertical_spacing=0.12,
horizontal_spacing=0.1
)
# Chart 1: Revenue trend line (top-left)
fig.add_trace(
go.Scatter(
x=df_business['month'],
y=df_business['revenue'],
mode='lines+markers',
name='Revenue',
line=dict(color='#2E86AB', width=3),
marker=dict(size=8),
hovertemplate='<b>Revenue</b><br>%{x|%b %Y}<br>$%{y:,.0f}<extra></extra>'
),
row=1, col=1
)
# Add target line
fig.add_hline(y=1000000, line_dash='dash', line_color='red',
annotation_text='Target: $1M',
annotation_position='right',
row=1, col=1)
# Chart 2: Regional sales bars (top-right)
fig.add_trace(
go.Bar(
x=regions,
y=regional_sales,
name='Regional Sales',
marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A'],
text=[f'${v/1e6:.1f}M' for v in regional_sales],
textposition='outside',
hovertemplate='<b>%{x}</b><br>$%{y:,.0f}<extra></extra>'
),
row=1, col=2
)
# Chart 3: Profit margin line (bottom-left)
fig.add_trace(
go.Scatter(
x=df_business['month'],
y=df_business['profit_margin'],
mode='lines+markers',
name='Profit Margin',
line=dict(color='#06A77D', width=3),
fill='tozeroy',
fillcolor='rgba(6, 167, 125, 0.2)',
hovertemplate='<b>Profit Margin</b><br>%{x|%b %Y}<br>%{y:.1%}<extra></extra>'
),
row=2, col=1
)
# Chart 4: Product revenue pie (bottom-right)
fig.add_trace(
go.Pie(
labels=categories,
values=category_revenue,
name='Products',
hovertemplate='<b>%{label}</b><br>$%{value:,.0f}<br>%{percent}<extra></extra>',
marker=dict(colors=['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A'])
),
row=2, col=2
)
# Update layout
fig.update_layout(
title_text='<b>Business Performance Dashboard - 2024 Overview</b>',
title_font_size=20,
title_x=0.5,
showlegend=False,
height=800,
plot_bgcolor='#F8F9FA',
paper_bgcolor='white'
)
# Format axes
fig.update_xaxes(showgrid=True, gridcolor='white', row=1, col=1)
fig.update_yaxes(title_text='Revenue ($)', tickformat='$,.0f', row=1, col=1)
fig.update_yaxes(title_text='Sales ($)', tickformat='$,.0f', row=1, col=2)
fig.update_yaxes(title_text='Margin', tickformat='.0%', row=2, col=1)
fig.show()Output:
[Interactive Plotly chart]
Layout Strategy Explained:
Top Row (Strategic Overview):
Bottom Row (Supporting Details):
Visual Flow: Top → Bottom, Left → Right (Western reading pattern)
Creating KPI Cards and Metric Displays
KPI Cards: The Dashboard Headlines
Key Performance Indicators should be immediately visible, large, and comparative.
import plotly.graph_objects as go
from plotly.subplots import make_subplots
# Calculate KPIs
current_month_revenue = 1180000
previous_month_revenue = 1100000
revenue_change = ((current_month_revenue - previous_month_revenue) /
previous_month_revenue)
current_customers = 4850
previous_customers = 4720
customer_change = ((current_customers - previous_customers) /
previous_customers)
current_margin = 0.28
previous_margin = 0.26
margin_change = current_margin - previous_margin
# Create figure with annotation-based KPI cards
fig = go.Figure()
# Add invisible trace to set up the canvas
fig.add_trace(go.Scatter(
x=[0, 1],
y=[0, 1],
mode='markers',
marker=dict(size=0.1, color='white'),
showlegend=False,
hoverinfo='none'
))
# KPI Card 1: Revenue
fig.add_annotation(
x=0.15, y=0.85,
xref='paper', yref='paper',
text=f'<b>Monthly Revenue</b><br>' +
f'<span style="font-size:32px; color:#2E86AB">${current_month_revenue:,.0f}</span><br>' +
f'<span style="color:{"green" if revenue_change > 0 else "red"}">{"↑" if revenue_change > 0 else "↓"} {revenue_change:.1%} vs last month</span>',
showarrow=False,
bgcolor='#F8F9FA',
bordercolor='#2E86AB',
borderwidth=2,
borderpad=20,
font=dict(size=12),
align='center'
)
# KPI Card 2: Customers
fig.add_annotation(
x=0.50, y=0.85,
xref='paper', yref='paper',
text=f'<b>Active Customers</b><br>' +
f'<span style="font-size:32px; color:#06A77D">{current_customers:,}</span><br>' +
f'<span style="color:{"green" if customer_change > 0 else "red"}">{"↑" if customer_change > 0 else "↓"} {customer_change:.1%} vs last month</span>',
showarrow=False,
bgcolor='#F8F9FA',
bordercolor='#06A77D',
borderwidth=2,
borderpad=20,
font=dict(size=12),
align='center'
)
# KPI Card 3: Profit Margin
fig.add_annotation(
x=0.85, y=0.85,
xref='paper', yref='paper',
text=f'<b>Profit Margin</b><br>' +
f'<span style="font-size:32px; color:#FFA07A">{current_margin:.1%}</span><br>' +
f'<span style="color:{"green" if margin_change > 0 else "red"}">{"↑" if margin_change > 0 else "↓"} {abs(margin_change):.1%} vs last month</span>',
showarrow=False,
bgcolor='#F8F9FA',
bordercolor='#FFA07A',
borderwidth=2,
borderpad=20,
font=dict(size=12),
align='center'
)
# Update layout
fig.update_layout(
title='<b>Key Performance Indicators - December 2024</b>',
title_x=0.5,
title_font_size=20,
xaxis=dict(visible=False),
yaxis=dict(visible=False),
plot_bgcolor='white',
paper_bgcolor='white',
height=300,
margin=dict(l=20, r=20, t=80, b=20)
)
fig.show()Output:
[Interactive Plotly chart: “Key Performance Indicators - December 2024”]
KPI Card Best Practices:
1. Structure:
2. Color Coding:
3. Positioning:
Building a Complete Executive Dashboard
Integrated Dashboard with All Elements:
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
import numpy as np
# Generate data
np.random.seed(42)
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
df = pd.DataFrame({
'month': months,
'revenue': np.cumsum(np.random.uniform(80000, 120000, 12)),
'customers': np.cumsum(np.random.randint(50, 150, 12)),
'satisfaction': np.random.uniform(4.0, 4.8, 12)
})
# Create complex dashboard
fig = make_subplots(
rows=4, cols=3,
row_heights=[0.15, 0.35, 0.35, 0.15],
column_widths=[0.33, 0.33, 0.34],
specs=[
[{'type': 'indicator'}, {'type': 'indicator'}, {'type': 'indicator'}],
[{'type': 'scatter', 'colspan': 2}, None, {'type': 'bar'}],
[{'type': 'scatter', 'colspan': 2}, None, {'type': 'pie'}],
[{'type': 'table', 'colspan': 3}, None, None]
],
subplot_titles=['', '', '',
'Revenue Growth Trend', '', 'Top Products',
'Customer Acquisition', '', 'Channel Mix',
''],
vertical_spacing=0.08,
horizontal_spacing=0.05
)
# Row 1: KPI Indicators
fig.add_trace(go.Indicator(
mode='number+delta',
value=df['revenue'].iloc[-1],
delta={'reference': df['revenue'].iloc[-2], 'relative': True, 'valueformat': '.1%'},
title={'text': 'Monthly Revenue'},
number={'prefix': '$', 'valueformat': ',.0f'},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=1)
fig.add_trace(go.Indicator(
mode='number+delta',
value=df['customers'].iloc[-1],
delta={'reference': df['customers'].iloc[-2], 'relative': True, 'valueformat': '.1%'},
title={'text': 'Total Customers'},
number={'valueformat': ','},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=2)
fig.add_trace(go.Indicator(
mode='gauge+number+delta',
value=df['satisfaction'].iloc[-1],
delta={'reference': 4.0},
gauge={'axis': {'range': [1, 5]},
'bar': {'color': '#06A77D'},
'threshold': {'line': {'color': 'red', 'width': 4},
'thickness': 0.75, 'value': 4.0}},
title={'text': 'Satisfaction'},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=3)
# Row 2: Revenue trend and Top Products
fig.add_trace(go.Scatter(
x=df['month'], y=df['revenue'],
mode='lines+markers',
line=dict(color='#2E86AB', width=3),
fill='tozeroy',
fillcolor='rgba(46, 134, 171, 0.2)',
name='Revenue'
), row=2, col=1)
products = ['Product A', 'Product B', 'Product C', 'Product D']
product_sales = [450000, 380000, 320000, 280000]
fig.add_trace(go.Bar(
x=product_sales, y=products,
orientation='h',
marker_color='#FF6B6B',
name='Sales'
), row=2, col=3)
# Row 3: Customer acquisition and Channel mix
fig.add_trace(go.Scatter(
x=df['month'], y=df['customers'],
mode='lines+markers',
line=dict(color='#06A77D', width=3),
name='Customers'
), row=3, col=1)
channels = ['Direct', 'Partner', 'Online', 'Reseller']
channel_revenue = [35, 28, 22, 15]
fig.add_trace(go.Pie(
labels=channels, values=channel_revenue,
marker_colors=['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A'],
name='Channels'
), row=3, col=3)
# Row 4: Summary table
fig.add_trace(go.Table(
header=dict(values=['<b>Metric</b>', '<b>Current</b>', '<b>Target</b>', '<b>Status</b>'],
fill_color='#2E86AB',
font=dict(color='white', size=12),
align='left'),
cells=dict(values=[
['Revenue', 'Customers', 'Profit Margin', 'Satisfaction'],
['$1.18M', '4,850', '28%', '4.5/5'],
['$1.10M', '4,500', '25%', '4.0/5'],
[' Exceeds', ' Exceeds', ' Exceeds', ' Exceeds']
],
fill_color=[['#F8F9FA', 'white']*4],
font=dict(size=11),
align='left')
), row=4, col=1)
# Update layout
fig.update_layout(
title_text='<b>Executive Dashboard - December 2024</b><br>' +
'<sub>Key metrics and performance indicators</sub>',
title_x=0.5,
title_font_size=22,
showlegend=False,
height=1200,
plot_bgcolor='#F8F9FA',
paper_bgcolor='white'
)
# Format axes
fig.update_xaxes(showgrid=True, gridcolor='white')
fig.update_yaxes(showgrid=True, gridcolor='white')
fig.show()Output:
[Interactive Plotly chart]
Dashboard Features:
1. Top Row - KPIs:
2. Middle Rows - Details:
3. Bottom Row - Summary:
Creating Narrative-Driven Reports
Beyond Dashboards: Analytical Reports
Reports tell a story with data, guiding readers through analysis:
import plotly.graph_objects as go
from plotly.subplots import make_subplots
# Create narrative report structure
fig = make_subplots(
rows=5, cols=1,
row_heights=[0.1, 0.25, 0.25, 0.25, 0.15],
specs=[
[{'type': 'table'}],
[{'type': 'scatter'}],
[{'type': 'bar'}],
[{'type': 'scatter'}],
[{'type': 'table'}]
],
subplot_titles=['',
'1. Revenue Shows Strong Growth Throughout 2024',
'2. Regional Performance Varies Significantly',
'3. Customer Satisfaction Remains High Despite Growth',
''],
vertical_spacing=0.08
)
# Executive Summary (top)
fig.add_trace(go.Table(
header=dict(values=['<b>Executive Summary: 2024 Performance Review</b>'],
fill_color='#2E86AB',
font=dict(color='white', size=14),
height=40),
cells=dict(values=[
['Our analysis reveals strong growth in 2024 with revenue increasing 45% YoY. ' +
'Regional performance shows East region leading growth at 52%, while South lags at 28%. ' +
'Customer satisfaction remained consistently above 4.5/5 despite rapid scaling. ' +
'Recommendations: Invest in South region training, maintain quality focus during growth.']
],
fill_color='#F8F9FA',
font=dict(size=12),
height=30,
align='left')
), row=1, col=1)
# Chart 1: Revenue trend with annotations
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
revenue = np.cumsum(np.random.uniform(80000, 120000, 12))
fig.add_trace(go.Scatter(
x=months, y=revenue,
mode='lines+markers',
line=dict(color='#2E86AB', width=3),
name='Revenue'
), row=2, col=1)
# Add annotation for key insight
fig.add_annotation(
x=months[8], y=revenue[8],
text='Q3 surge due to<br>new product launch',
showarrow=True,
arrowhead=2,
ax=-50, ay=-50,
row=2, col=1
)
# Chart 2: Regional comparison
regions = ['North', 'South', 'East', 'West']
growth = [42, 28, 52, 38]
fig.add_trace(go.Bar(
x=regions, y=growth,
marker_color=['#06A77D' if g > 40 else '#FFA07A' for g in growth],
text=[f'{g}%' for g in growth],
textposition='outside'
), row=3, col=1)
# Chart 3: Satisfaction trend
satisfaction = np.random.uniform(4.3, 4.7, 12)
fig.add_trace(go.Scatter(
x=months, y=satisfaction,
mode='lines+markers',
line=dict(color='#06A77D', width=3)
), row=4, col=1)
# Add target line (use add_shape for compatibility with mixed subplot types)
fig.add_shape(type='line', x0=0, x1=1, xref='x4 domain',
y0=4.0, y1=4.0, yref='y4',
line=dict(dash='dash', color='red'))
fig.add_annotation(x=0.5, xref='x4 domain', y=4.0, yref='y4',
text='Minimum Target', showarrow=False, yshift=12)
# Recommendations (bottom)
fig.add_trace(go.Table(
header=dict(values=['<b>Strategic Recommendations</b>'],
fill_color='#06A77D',
font=dict(color='white', size=14)),
cells=dict(values=[
['1. South Region: Deploy best practices from East region, provide additional training<br>' +
'2. Scaling: Maintain quality controls as customer base grows, hire support staff<br>' +
'3. Products: Capitalize on Q3 success, plan Q2 2025 launch<br>' +
'4. Investment: Allocate additional budget to high-growth regions']
],
fill_color='#F8F9FA',
font=dict(size=11),
align='left')
), row=5, col=1)
fig.update_layout(
title='<b>2024 Annual Performance Analysis</b><br>' +
'<sub>Prepared for Executive Leadership Team | January 2025</sub>',
title_x=0.5,
title_font_size=20,
showlegend=False,
height=1400,
plot_bgcolor='white',
paper_bgcolor='white'
)
fig.show()Output:
[Interactive Plotly chart: “2024 Annual Performance Analysis
”]
Narrative Report Structure:
1. Executive Summary:
2. Body (Charts with Context):
3. Recommendations:
Exporting and Sharing Professional Reports
Export Options for Business Distribution:
1. Interactive HTML (Best for Digital Distribution):
fig.write_html(
'Executive_Dashboard_Dec2024.html',
config={
'displayModeBar': True, # Show toolbar
'displaylogo': False, # Remove Plotly logo
'modeBarButtonsToRemove': ['lasso2d', 'select2d'] # Remove unnecessary buttons
}
)Output:
[Chart]
2. Static Image (For PowerPoint/Documents):
fig.write_image(
'Dashboard_Report.png',
width=1920,
height=1080,
scale=2 # High resolution
)3. PDF Report (For Print):
fig.write_image(
'Annual_Report_2024.pdf',
width=1200,
height=1600
)Embedding in Business Tools:
SharePoint/Confluence:
Email Distribution:
PowerPoint Presentation:
Responsive Design for Different Devices
Making Dashboards Mobile-Friendly:
import plotly.graph_objects as go
fig = go.Figure()
# Add your charts...
# Configure for responsive viewing
fig.update_layout(
autosize=True, # Adapt to container size
margin=dict(l=40, r=40, t=80, b=40), # Reasonable margins
font=dict(size=12), # Readable font size
# Mobile-specific optimizations
xaxis=dict(
tickangle=-45 # Angle labels if needed
),
# Adjust legend for mobile
legend=dict(
orientation='v',
yanchor='top',
y=0.99,
xanchor='left',
x=0.01
)
)
# For HTML export with responsive container
fig.write_html(
'responsive_dashboard.html',
config={'responsive': True}
)Output:
[Interactive Plotly chart]
Design Considerations:
Desktop (>1200px width):
Tablet (768-1200px):
Mobile (<768px):
Lab 3: Building Professional Business Dashboards
Objective: Design and create comprehensive, multi-chart interactive dashboards that communicate complex business insights clearly and professionally for executive audiences.
Scenario: You’ve been promoted to Lead Business Intelligence Developer at “DataVision Corp.” Your first major assignment: create three distinct dashboards for different stakeholder groups at your client, “MegaMart Retail” - a national retail chain preparing for their annual investor meeting, board presentation, and operational review. Each dashboard must tell a clear story, be visually impressive, and provide actionable insights through interactivity.
Pre-Lab Setup:
M4L03_YourName_Dashboards.pyimport plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import pandas as pd
import numpy as npPart A: Executive KPI Dashboard (30 points)
Context: The CEO needs a clean, high-level dashboard for the investor meeting showing key performance indicators, trends, and status against targets. Must fit on one screen, be immediately understandable, and look professional.
Data Generation:
np.random.seed(42)
# Generate 2024 monthly data
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
df_executive = pd.DataFrame({
'month': months,
'revenue': np.random.uniform(8000000, 12000000, 12) + np.arange(12) * 200000,
'operating_costs': np.random.uniform(5000000, 7000000, 12) + np.arange(12) * 100000,
'new_customers': np.random.randint(1500, 3000, 12),
'churned_customers': np.random.randint(200, 600, 12),
'nps_score': np.random.uniform(45, 75, 12),
'employee_satisfaction': np.random.uniform(3.8, 4.6, 12)
})
df_executive['profit'] = df_executive['revenue'] - df_executive['operating_costs']
df_executive['profit_margin'] = df_executive['profit'] / df_executive['revenue']
df_executive['net_customer_growth'] = df_executive['new_customers'] - df_executive['churned_customers']
# Year-over-year data for comparison
ytd_revenue = df_executive['revenue'].sum()
previous_ytd_revenue = ytd_revenue * 0.85
ytd_customers = df_executive['new_customers'].sum()
previous_ytd_customers = int(ytd_customers * 0.92)Tasks:
Create KPI indicator row (10 points):
go.Indicator for each KPICreate main dashboard body (15 points):
Professional finishing (5 points):
M4L03_YourName_ExecutiveDashboard.htmlPart B: Operational Performance Dashboard (35 points)
Context: The COO needs a detailed operational dashboard showing store performance, inventory metrics, employee productivity, and supply chain efficiency. More detailed than executive dashboard, with drill-down capabilities.
Data Generation:
np.random.seed(42)
# Store performance data
stores = [f'Store {str(i).zfill(3)}' for i in range(1, 26)] # 25 stores
regions = ['North', 'South', 'East', 'West', 'Central']
store_data = []
for store in stores:
region = np.random.choice(regions)
store_data.append({
'store_id': store,
'region': region,
'monthly_sales': np.random.uniform(200000, 600000),
'foot_traffic': np.random.randint(5000, 15000),
'conversion_rate': np.random.uniform(0.15, 0.45),
'avg_transaction': np.random.uniform(45, 120),
'inventory_turnover': np.random.uniform(4, 12),
'employee_count': np.random.randint(15, 45),
'customer_rating': np.random.uniform(3.5, 4.9)
})
df_operations = pd.DataFrame(store_data)
df_operations['sales_per_employee'] = df_operations['monthly_sales'] / df_operations['employee_count']
df_operations['sales_efficiency'] = df_operations['monthly_sales'] / df_operations['foot_traffic']
# Time series for inventory
weeks = pd.date_range('2024-01-01', '2024-12-31', freq='W')
inventory_levels = np.random.uniform(8000000, 12000000, len(weeks))
df_inventory = pd.DataFrame({'week': weeks, 'inventory_value': inventory_levels})
# Regional aggregations
df_regional = df_operations.groupby('region').agg({
'monthly_sales': 'sum',
'foot_traffic': 'sum',
'conversion_rate': 'mean',
'customer_rating': 'mean'
}).reset_index()Tasks:
Create regional overview section (12 points):
Create store performance scatter analysis (12 points):
Create inventory and efficiency panels (11 points):
Add interactive filters and insights (10 points):
M4L03_YourName_OperationalDashboard.htmlPart C: Marketing Analytics Report Dashboard (35 points)
Context: The CMO needs a narrative-driven dashboard that tells the story of 2024 marketing performance, channel effectiveness, customer acquisition, and ROI. Should be presentation-ready with clear flow from overview to recommendations.
Data Generation:
np.random.seed(42)
# Campaign data
channels = ['Email', 'Social Media', 'PPC', 'Display Ads', 'Influencer', 'TV', 'Radio']
months = pd.date_range('2024-01-01', '2024-12-31', freq='M')
campaign_data = []
for month in months:
for channel in channels:
spend = np.random.uniform(10000, 100000)
# Different channels have different effectiveness
if channel == 'Email':
roi = np.random.uniform(3.5, 6.0)
leads = int(spend * np.random.uniform(0.8, 1.5))
elif channel == 'Social Media':
roi = np.random.uniform(2.5, 5.0)
leads = int(spend * np.random.uniform(0.6, 1.2))
elif channel == 'PPC':
roi = np.random.uniform(2.0, 4.5)
leads = int(spend * np.random.uniform(0.4, 1.0))
elif channel == 'Influencer':
roi = np.random.uniform(2.8, 5.5)
leads = int(spend * np.random.uniform(0.5, 1.3))
else:
roi = np.random.uniform(1.5, 3.5)
leads = int(spend * np.random.uniform(0.3, 0.8))
revenue = spend * roi
conversions = int(leads * np.random.uniform(0.15, 0.35))
campaign_data.append({
'month': month,
'channel': channel,
'spend': spend,
'revenue': revenue,
'roi': roi,
'leads': leads,
'conversions': conversions
})
df_marketing = pd.DataFrame(campaign_data)
df_marketing['cpa'] = df_marketing['spend'] / df_marketing['conversions'] # Cost per acquisition
df_marketing['conversion_rate'] = df_marketing['conversions'] / df_marketing['leads']
# Customer journey data
touchpoints = ['Awareness', 'Consideration', 'Decision', 'Purchase', 'Loyalty']
funnel_values = [50000, 25000, 12000, 8000, 5500]
df_funnel = pd.DataFrame({'stage': touchpoints, 'customers': funnel_values})Tasks:
Create executive summary section (10 points):
Create channel performance comparison (12 points):
Create temporal trends section (8 points):
Create customer journey funnel (5 points):
Create recommendations section (10 points):
M4L03_YourName_MarketingReport.htmlBonus Challenge (+30 points):
Create an Integrated Master Dashboard with Tab Navigation:
Build a single HTML file with tabbed interface allowing users to switch between: 1. Executive Dashboard (Part A) 2. Operations Dashboard (Part B) 3. Marketing Report (Part C)
Requirements:
updatemenus with buttons for tab switchingM4L03_YourName_MasterDashboard.htmlHint: Use visibility toggling on subplot traces with button controls.
Deliverables:
M4L03_YourName_Dashboards.pyM4L03_YourName_ExecutiveDashboard.htmlM4L03_YourName_OperationalDashboard.htmlM4L03_YourName_MarketingReport.htmlM4L03_YourName_MasterDashboard.html (bonus)Grading Rubric:
Success Criteria:
Dashboard Design Checklist:
Visual Hierarchy:
Interactivity:
Professionalism:
Business Value:
Common Mistakes to Avoid:
The Complete Data Analysis Workflow
Professional Analysis Process:
Real-world business analysis follows a structured workflow:
1. Business Understanding:
2. Data Collection:
3. Data Cleaning:
4. Exploratory Analysis:
5. Visualization:
6. Insights & Recommendations:
7. Presentation:
Project Specification and Requirements
Your Final Project Mission:
You will complete a comprehensive analysis of a business dataset, applying every technique learned in this course.
Deliverables Required:
1. Python Analysis Script:
2. Static Visualizations (Matplotlib/Seaborn):
3. Interactive Dashboard (Plotly):
4. Written Report:
Sample Project Structure
Example: Retail Sales Analysis Project
"""
Final Project: Comprehensive Retail Sales Analysis
Course: Data Visualization Analysis
Author: [Your Name]
Date: [Submission Date]
Business Question:
Analyze 2024 sales performance across products, regions, and time periods
to identify growth opportunities and operational improvements for 2025 planning.
Dataset: Retail sales data with 10,000+ transactions
"""
# ============================================================================
# SECTION 1: SETUP AND DATA LOADING
# ============================================================================
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
# Set visualization styles
sns.set_theme(style='whitegrid', context='talk', palette='colorblind')
plt.rcParams['figure.figsize'] = (12, 6)
plt.rcParams['font.size'] = 11
print("="*70)
print("RETAIL SALES ANALYSIS PROJECT - 2024")
print("="*70)
# ============================================================================
# SECTION 2: DATA IMPORT AND INITIAL EXPLORATION
# ============================================================================
# Load data (in actual project, this would be from file)
# For demonstration, we'll generate realistic sample data
np.random.seed(42)
# Generate comprehensive retail dataset
n_transactions = 10000
dates = pd.date_range('2024-01-01', '2024-12-31', freq='H')
products = ['Electronics', 'Clothing', 'Home Goods', 'Sports Equipment',
'Books', 'Toys', 'Food & Beverage', 'Health & Beauty']
regions = ['North', 'South', 'East', 'West', 'Central']
channels = ['Online', 'In-Store', 'Mobile App']
transactions = []
for i in range(n_transactions):
product = np.random.choice(products, p=[0.15, 0.18, 0.12, 0.10, 0.08, 0.09, 0.15, 0.13])
region = np.random.choice(regions)
channel = np.random.choice(channels, p=[0.45, 0.40, 0.15])
# Price varies by product category
price_ranges = {
'Electronics': (50, 500), 'Clothing': (20, 150),
'Home Goods': (30, 300), 'Sports Equipment': (40, 400),
'Books': (10, 50), 'Toys': (15, 100),
'Food & Beverage': (5, 50), 'Health & Beauty': (10, 100)
}
price = np.random.uniform(*price_ranges[product])
# Quantity varies by channel
if channel == 'Online':
quantity = np.random.randint(1, 5)
else:
quantity = np.random.randint(1, 3)
# Customer satisfaction varies
satisfaction = np.random.uniform(3.0, 5.0)
# Shipping time (online only)
shipping_days = np.random.randint(2, 10) if channel == 'Online' else 0
transactions.append({
'transaction_id': f'TXN{i:06d}',
'date': np.random.choice(dates),
'product_category': product,
'region': region,
'channel': channel,
'unit_price': price,
'quantity': quantity,
'customer_satisfaction': satisfaction,
'shipping_days': shipping_days
})
df = pd.DataFrame(transactions)
# Calculate derived fields
df['total_amount'] = df['unit_price'] * df['quantity']
df['year_month'] = df['date'].dt.to_period('M')
df['day_of_week'] = df['date'].dt.day_name()
df['hour'] = df['date'].dt.hour
print("\n1. Dataset Overview:")
print("-" * 70)
print(f"Total Transactions: {len(df):,}")
print(f"Date Range: {df['date'].min()} to {df['date'].max()}")
print(f"Total Revenue: ${df['total_amount'].sum():,.2f}")
print(f"Average Transaction Value: ${df['total_amount'].mean():.2f}")
print("\n2. Data Structure:")
print(df.info())
print("\n3. Sample Records:")
print(df.head())
# ============================================================================
# SECTION 3: DATA CLEANING AND PREPARATION
# ============================================================================
print("\n" + "="*70)
print("DATA CLEANING AND PREPARATION")
print("="*70)
# Check for missing values
print("\n1. Missing Values Check:")
print(df.isnull().sum())
# Check for duplicates
duplicates = df.duplicated(subset=['transaction_id']).sum()
print(f"\n2. Duplicate Transactions: {duplicates}")
# Data quality checks
print("\n3. Data Quality Checks:")
print(f" - Negative prices: {(df['unit_price'] < 0).sum()}")
print(f" - Zero quantities: {(df['quantity'] == 0).sum()}")
print(f" - Invalid satisfaction scores: {((df['customer_satisfaction'] < 1) | (df['customer_satisfaction'] > 5)).sum()}")
# Outlier detection (IQR method)
Q1 = df['total_amount'].quantile(0.25)
Q3 = df['total_amount'].quantile(0.75)
IQR = Q3 - Q1
outliers = df[(df['total_amount'] < Q1 - 1.5*IQR) | (df['total_amount'] > Q3 + 1.5*IQR)]
print(f"\n4. Statistical Outliers Detected: {len(outliers)} ({len(outliers)/len(df)*100:.2f}%)")
# Clean dataset
df_clean = df.copy()
# Keep outliers but flag them
df_clean['is_outlier'] = ((df_clean['total_amount'] < Q1 - 1.5*IQR) |
(df_clean['total_amount'] > Q3 + 1.5*IQR))
print(f"\n5. Clean Dataset: {len(df_clean):,} transactions ready for analysis")
# ============================================================================
# SECTION 4: EXPLORATORY DATA ANALYSIS
# ============================================================================
print("\n" + "="*70)
print("EXPLORATORY DATA ANALYSIS")
print("="*70)
# Summary statistics
print("\n1. Summary Statistics:")
print(df_clean[['unit_price', 'quantity', 'total_amount', 'customer_satisfaction']].describe())
# Category analysis
print("\n2. Performance by Product Category:")
category_summary = df_clean.groupby('product_category').agg({
'total_amount': ['sum', 'mean', 'count'],
'customer_satisfaction': 'mean'
}).round(2)
category_summary.columns = ['Total_Revenue', 'Avg_Transaction', 'Count', 'Avg_Satisfaction']
print(category_summary.sort_values('Total_Revenue', ascending=False))
# Regional analysis
print("\n3. Performance by Region:")
regional_summary = df_clean.groupby('region').agg({
'total_amount': ['sum', 'mean'],
'transaction_id': 'count'
}).round(2)
regional_summary.columns = ['Total_Revenue', 'Avg_Transaction', 'Transaction_Count']
print(regional_summary.sort_values('Total_Revenue', ascending=False))
# Channel analysis
print("\n4. Performance by Channel:")
channel_summary = df_clean.groupby('channel').agg({
'total_amount': ['sum', 'mean'],
'customer_satisfaction': 'mean'
}).round(2)
channel_summary.columns = ['Total_Revenue', 'Avg_Transaction', 'Avg_Satisfaction']
print(channel_summary.sort_values('Total_Revenue', ascending=False))
# Correlation analysis
print("\n5. Correlation Analysis:")
correlation_vars = df_clean[['unit_price', 'quantity', 'total_amount',
'customer_satisfaction', 'shipping_days']].corr()
print(correlation_vars.round(3))
# ============================================================================
# SECTION 5: STATIC VISUALIZATIONS (Matplotlib & Seaborn)
# ============================================================================
print("\n" + "="*70)
print("CREATING STATIC VISUALIZATIONS")
print("="*70)
# Create output directory for charts
import os
os.makedirs('FinalProject_Outputs', exist_ok=True)
# Visualization 1: Revenue trend over time
print("\n1. Creating: Monthly revenue trend...")
monthly_revenue = df_clean.groupby('year_month')['total_amount'].sum()
fig, ax = plt.subplots(figsize=(14, 6))
ax.plot(monthly_revenue.index.astype(str), monthly_revenue.values,
marker='o', linewidth=3, markersize=8, color='#2E86AB')
ax.fill_between(range(len(monthly_revenue)), monthly_revenue.values, alpha=0.3, color='#2E86AB')
ax.set_title('Monthly Revenue Trend - 2024', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('Month', fontsize=12)
ax.set_ylabel('Revenue ($)', fontsize=12)
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1e6:.2f}M'))
ax.grid(True, alpha=0.3)
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_01_Revenue_Trend.png', dpi=300, bbox_inches='tight')
plt.close()
# Visualization 2: Category performance comparison
print("2. Creating: Category performance bars...")
category_rev = df_clean.groupby('product_category')['total_amount'].sum().sort_values(ascending=True)
fig, ax = plt.subplots(figsize=(12, 8))
colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(category_rev)))
ax.barh(category_rev.index, category_rev.values, color=colors, edgecolor='black', linewidth=1.5)
ax.set_title('Total Revenue by Product Category', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('Revenue ($)', fontsize=12)
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1e6:.1f}M'))
# Add value labels
for i, v in enumerate(category_rev.values):
ax.text(v + 50000, i, f'${v/1e6:.2f}M', va='center', fontsize=10, fontweight='bold')
ax.grid(axis='x', alpha=0.3)
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_02_Category_Revenue.png', dpi=300, bbox_inches='tight')
plt.close()
# Visualization 3: Customer satisfaction distribution
print("3. Creating: Satisfaction distribution...")
fig, axes = plt.subplots(1, 2, figsize=(14, 6))
# Overall distribution
sns.histplot(data=df_clean, x='customer_satisfaction', bins=30, kde=True,
color='#06A77D', ax=axes[0])
axes[0].set_title('Overall Customer Satisfaction Distribution', fontsize=14, fontweight='bold')
axes[0].set_xlabel('Satisfaction Score (1-5)', fontsize=11)
axes[0].axvline(df_clean['customer_satisfaction'].mean(), color='red',
linestyle='--', linewidth=2, label=f"Mean: {df_clean['customer_satisfaction'].mean():.2f}")
axes[0].legend()
# By channel
sns.boxplot(data=df_clean, x='channel', y='customer_satisfaction',
palette='Set2', ax=axes[1])
axes[1].set_title('Satisfaction by Channel', fontsize=14, fontweight='bold')
axes[1].set_xlabel('Channel', fontsize=11)
axes[1].set_ylabel('Satisfaction Score', fontsize=11)
axes[1].axhline(4.0, color='red', linestyle='--', linewidth=2, alpha=0.5, label='Target: 4.0')
axes[1].legend()
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_03_Satisfaction_Analysis.png', dpi=300, bbox_inches='tight')
plt.close()
# Visualization 4: Regional performance heatmap
print("4. Creating: Regional performance heatmap...")
regional_channel = df_clean.pivot_table(values='total_amount',
index='region',
columns='channel',
aggfunc='sum')
fig, ax = plt.subplots(figsize=(8, 5))
sns.heatmap(regional_channel, annot=True, fmt=',.0f', cmap='YlGnBu',
linewidths=1, cbar_kws={'label': 'Revenue ($)'}, ax=ax)
ax.set_title('Revenue by Region and Channel', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('Channel', fontsize=12)
ax.set_ylabel('Region', fontsize=12)
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_04_Regional_Heatmap.png', dpi=300, bbox_inches='tight')
plt.close()
# Visualization 5: Price vs Quantity relationship
print("5. Creating: Price-quantity scatter...")
fig, ax = plt.subplots(figsize=(12, 7))
for category in df_clean['product_category'].unique():
df_cat = df_clean[df_clean['product_category'] == category]
ax.scatter(df_cat['unit_price'], df_cat['quantity'],
alpha=0.6, s=50, label=category)
ax.set_title('Unit Price vs Quantity Sold by Category', fontsize=16, fontweight='bold', pad=20)
ax.set_xlabel('Unit Price ($)', fontsize=12)
ax.set_ylabel('Quantity', fontsize=12)
ax.legend(title='Product Category', bbox_to_anchor=(1.05, 1), loc='upper left')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_05_Price_Quantity_Scatter.png', dpi=300, bbox_inches='tight')
plt.close()
# Visualization 6: Correlation heatmap
print("6. Creating: Correlation matrix...")
fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(correlation_vars, annot=True, fmt='.3f', cmap='coolwarm',
center=0, square=True, linewidths=1, cbar_kws={'label': 'Correlation'}, ax=ax)
ax.set_title('Correlation Matrix: Key Metrics', fontsize=16, fontweight='bold', pad=20)
plt.tight_layout()
plt.savefig('FinalProject_Outputs/FP_06_Correlation_Matrix.png', dpi=300, bbox_inches='tight')
plt.close()
print("\n All static visualizations saved to FinalProject_Outputs/")
# ============================================================================
# SECTION 6: INTERACTIVE DASHBOARD (Plotly)
# ============================================================================
print("\n" + "="*70)
print("CREATING INTERACTIVE DASHBOARD")
print("="*70)
# Prepare aggregated data for dashboard
monthly_data = df_clean.groupby('year_month').agg({
'total_amount': 'sum',
'transaction_id': 'count',
'customer_satisfaction': 'mean'
}).reset_index()
monthly_data['year_month'] = monthly_data['year_month'].astype(str)
category_data = df_clean.groupby('product_category').agg({
'total_amount': 'sum',
'customer_satisfaction': 'mean',
'transaction_id': 'count'
}).reset_index()
# Create comprehensive dashboard
fig = make_subplots(
rows=3, cols=3,
row_heights=[0.15, 0.40, 0.45],
column_widths=[0.33, 0.33, 0.34],
specs=[
[{'type': 'indicator'}, {'type': 'indicator'}, {'type': 'indicator'}],
[{'type': 'scatter', 'colspan': 2}, None, {'type': 'bar'}],
[{'type': 'bar', 'colspan': 2}, None, {'type': 'pie'}]
],
subplot_titles=['', '', '',
'Monthly Revenue Trend', '', 'Top Categories',
'Regional Performance', '', 'Channel Distribution'],
vertical_spacing=0.10,
horizontal_spacing=0.08
)
# Row 1: KPI Indicators
total_revenue = df_clean['total_amount'].sum()
total_transactions = len(df_clean)
avg_satisfaction = df_clean['customer_satisfaction'].mean()
fig.add_trace(go.Indicator(
mode='number',
value=total_revenue,
title={'text': 'Total Revenue'},
number={'prefix': '$', 'valueformat': ',.0f'},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=1)
fig.add_trace(go.Indicator(
mode='number',
value=total_transactions,
title={'text': 'Total Transactions'},
number={'valueformat': ','},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=2)
fig.add_trace(go.Indicator(
mode='gauge+number',
value=avg_satisfaction,
title={'text': 'Avg Satisfaction'},
gauge={
'axis': {'range': [1, 5]},
'bar': {'color': '#06A77D'},
'threshold': {
'line': {'color': 'red', 'width': 4},
'thickness': 0.75,
'value': 4.0
}
},
domain={'x': [0, 1], 'y': [0, 1]}
), row=1, col=3)
# Row 2: Monthly trend and Top categories
fig.add_trace(go.Scatter(
x=monthly_data['year_month'],
y=monthly_data['total_amount'],
mode='lines+markers',
line=dict(color='#2E86AB', width=3),
marker=dict(size=10),
name='Revenue',
hovertemplate='<b>%{x}</b><br>Revenue: $%{y:,.0f}<extra></extra>'
), row=2, col=1)
top_categories = category_data.nlargest(5, 'total_amount')
fig.add_trace(go.Bar(
x=top_categories['total_amount'],
y=top_categories['product_category'],
orientation='h',
marker_color='#FF6B6B',
name='Categories',
hovertemplate='<b>%{y}</b><br>$%{x:,.0f}<extra></extra>'
), row=2, col=3)
# Row 3: Regional bars and Channel pie
regional_totals = df_clean.groupby('region')['total_amount'].sum().sort_values(ascending=False)
fig.add_trace(go.Bar(
x=regional_totals.index,
y=regional_totals.values,
marker_color='#4ECDC4',
name='Regions',
hovertemplate='<b>%{x}</b><br>$%{y:,.0f}<extra></extra>'
), row=3, col=1)
channel_totals = df_clean.groupby('channel')['total_amount'].sum()
fig.add_trace(go.Pie(
labels=channel_totals.index,
values=channel_totals.values,
marker_colors=['#45B7D1', '#FFA07A', '#98D8C8'],
name='Channels',
hovertemplate='<b>%{label}</b><br>$%{value:,.0f}<br>%{percent}<extra></extra>'
), row=3, col=3)
# Update layout
fig.update_layout(
title_text='<b>Retail Sales Analytics Dashboard - 2024</b><br>' +
'<sub>Interactive Performance Overview</sub>',
title_x=0.5,
title_font_size=20,
showlegend=False,
height=1100,
plot_bgcolor='#F8F9FA',
paper_bgcolor='white'
)
# Update axes
fig.update_xaxes(showgrid=True, gridcolor='white')
fig.update_yaxes(showgrid=True, gridcolor='white')
fig.update_yaxes(tickformat='$,.0f', row=2, col=1)
fig.update_xaxes(tickformat='$,.0f', row=2, col=3)
fig.update_yaxes(tickformat='$,.0f', row=3, col=1)
# Save dashboard
fig.write_html('FinalProject_Outputs/FP_Interactive_Dashboard.html')
print("\n Interactive dashboard saved: FP_Interactive_Dashboard.html")
# ============================================================================
# SECTION 7: KEY FINDINGS AND RECOMMENDATIONS
# ============================================================================
print("\n" + "="*70)
print("KEY FINDINGS AND RECOMMENDATIONS")
print("="*70)
print("\n📊 KEY FINDINGS:")
print("-" * 70)
# Finding 1: Revenue trends
total_rev = df_clean['total_amount'].sum()
print(f"\n1. REVENUE PERFORMANCE:")
print(f" • Total 2024 revenue: ${total_rev:,.2f}")
print(f" • Average monthly revenue: ${total_rev/12:,.2f}")
best_month = df_clean.groupby('year_month')['total_amount'].sum().idxmax()
print(f" • Best performing month: {best_month}")
# Finding 2: Category insights
top_category = category_data.nlargest(1, 'total_amount').iloc[0]
print(f"\n2. PRODUCT CATEGORIES:")
print(f" • Top category: {top_category['product_category']}")
print(f" • Category revenue: ${top_category['total_amount']:,.2f}")
print(f" • Category satisfaction: {top_category['customer_satisfaction']:.2f}/5.0")
# Finding 3: Regional performance
best_region = df_clean.groupby('region')['total_amount'].sum().idxmax()
worst_region = df_clean.groupby('region')['total_amount'].sum().idxmin()
print(f"\n3. REGIONAL ANALYSIS:")
print(f" • Best region: {best_region}")
print(f" • Underperforming region: {worst_region}")
# Finding 4: Channel effectiveness
channel_perf = df_clean.groupby('channel').agg({
'total_amount': 'sum',
'customer_satisfaction': 'mean'
})
best_channel = channel_perf['total_amount'].idxmax()
print(f"\n4. CHANNEL PERFORMANCE:")
print(f" • Leading channel: {best_channel}")
print(f" • Overall satisfaction: {avg_satisfaction:.2f}/5.0")
print("\n" + "="*70)
print("💡 STRATEGIC RECOMMENDATIONS:")
print("="*70)
print(f"""
1. INVESTMENT PRIORITIES:
• Expand {top_category['product_category']} inventory (top performer)
• Increase {best_channel} capacity (highest revenue channel)
• Deploy best practices from {best_region} to other regions
2. IMPROVEMENT AREAS:
• Focus on {worst_region} region - investigate and address gap
• Improve satisfaction in lower-rated categories
• Optimize shipping times for online orders
3. GROWTH OPPORTUNITIES:
• Launch targeted campaigns in underperforming regions
• Develop mobile app features (growing channel)
• Create bundle offers for complementary categories
4. OPERATIONAL EXCELLENCE:
• Maintain satisfaction above 4.0 benchmark
• Standardize processes across high-performing regions
• Monitor and address outlier transactions
5. 2025 STRATEGIC INITIATIVES:
• Set aggressive growth targets for {worst_region} (+30%)
• Expand {top_category['product_category']} product line
• Enhance {best_channel} customer experience
• Implement predictive analytics for inventory management
""")
print("\n" + "="*70)
print("PROJECT COMPLETE - All deliverables generated!")
print("="*70)
print("\nDeliverables created:")
print(" 6 static visualizations (Matplotlib/Seaborn)")
print(" 1 interactive dashboard (Plotly)")
print(" Comprehensive analysis script")
print(" Business insights and recommendations")
print("\nAll files saved to: FinalProject_Outputs/")======================================================================
RETAIL SALES ANALYSIS PROJECT - 2024
======================================================================
1. Dataset Overview:
----------------------------------------------------------------------
Total Transactions: 10,000
Date Range: 2024-01-01 00:00:00 to 2024-12-30 23:00:00
Total Revenue: $2,335,875.78
Average Transaction Value: $233.59
2. Data Structure:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 13 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 transaction_id 10000 non-null object
1 date 10000 non-null datetime64[ns]
2 product_category 10000 non-null object
3 region 10000 non-null object
4 channel 10000 non-null object
5 unit_price 10000 non-null float64
6 quantity 10000 non-null int64
7 customer_satisfaction 10000 non-null float64
8 shipping_days 10000 non-null int64
9 total_amount 10000 non-null float64
10 year_month 10000 non-null period[M]
11 day_of_week 10000 non-null object
12 hour 10000 non-null int32
dtypes: datetime64[ns](1), float64(3), int32(1), int64(2), object(5), period[M](1)
memory usage: 976.7+ KB
None
3. Sample Records:
transaction_id date product_category region channel \
0 TXN000000 2024-07-03 10:00:00 Home Goods Central Online
1 TXN000001 2024-10-16 13:00:00 Sports Equipment Central In-Store
2 TXN000002 2024-12-27 02:00:00 Electronics West Online
3 TXN000003 2024-05-05 05:00:00 Books South Online
4 TXN000004 2024-08-12 17:00:00 Clothing West In-Store
unit_price quantity customer_satisfaction shipping_days total_amount \
0 240.516570 1 3.312037 4 240.516570
1 294.906128 2 3.112823 0 589.812256
2 186.909009 2 3.014133 2 373.818019
3 48.950221 3 3.912140 8 146.850662
4 26.038554 1 4.360615 0 26.038554
year_month day_of_week hour
0 2024-07 Wednesday 10
1 2024-10 Wednesday 13
2 2024-12 Friday 2
3 2024-05 Sunday 5
4 2024-08 Monday 17
======================================================================
DATA CLEANING AND PREPARATION
======================================================================
1. Missing Values Check:
transaction_id 0
date 0
product_category 0
region 0
channel 0
unit_price 0
quantity 0
customer_satisfaction 0
shipping_days 0
total_amount 0
year_month 0
day_of_week 0
hour 0
dtype: int64
2. Duplicate Transactions: 0
3. Data Quality Checks:
- Negative prices: 0
- Zero quantities: 0
- Invalid satisfaction scores: 0
4. Statistical Outliers Detected: 860 (8.60%)
5. Clean Dataset: 10,000 transactions ready for analysis
======================================================================
EXPLORATORY DATA ANALYSIS
======================================================================
1. Summary Statistics:
unit_price quantity total_amount customer_satisfaction
count 10000.000000 10000.000000 10000.000000 10000.000000
mean 118.766838 1.944400 233.587578 4.002569
std 113.137355 0.978062 279.952363 0.579371
min 5.000923 1.000000 5.000923 3.000187
25% 37.734280 1.000000 59.998455 3.500078
50% 75.963489 2.000000 129.944937 3.999127
75% 158.451559 2.000000 288.479541 4.506900
max 499.536384 4.000000 1990.977645 4.999683
2. Performance by Product Category:
Total_Revenue Avg_Transaction Count Avg_Satisfaction
product_category
Electronics 840280.20 552.82 1520 3.99
Sports Equipment 440906.46 430.15 1025 4.03
Home Goods 398465.69 326.88 1219 4.00
Clothing 300595.81 164.26 1830 3.98
Health & Beauty 138059.57 106.12 1301 4.00
Toys 96344.48 111.77 862 3.99
Food & Beverage 76797.75 53.26 1442 4.02
Books 44425.83 55.46 801 4.03
3. Performance by Region:
Total_Revenue Avg_Transaction Transaction_Count
region
South 496937.18 238.00 2088
West 475658.66 236.18 2014
Central 473889.49 239.10 1982
East 445001.13 226.46 1965
North 444389.32 227.78 1951
4. Performance by Channel:
Total_Revenue Avg_Transaction Avg_Satisfaction
channel
Online 1351971.92 303.47 3.99
In-Store 710902.78 174.71 4.01
Mobile App 273001.08 184.96 4.00
5. Correlation Analysis:
unit_price quantity total_amount \
unit_price 1.000 0.024 0.809
quantity 0.024 1.000 0.447
total_amount 0.809 0.447 1.000
customer_satisfaction 0.005 -0.003 -0.002
shipping_days -0.006 0.451 0.188
customer_satisfaction shipping_days
unit_price 0.005 -0.006
quantity -0.003 0.451
total_amount -0.002 0.188
customer_satisfaction 1.000 -0.020
shipping_days -0.020 1.000
======================================================================
CREATING STATIC VISUALIZATIONS
======================================================================
1. Creating: Monthly revenue trend...
2. Creating: Category performance bars...
3. Creating: Satisfaction distribution...4. Creating: Regional performance heatmap...
5. Creating: Price-quantity scatter...
6. Creating: Correlation matrix...
All static visualizations saved to FinalProject_Outputs/
======================================================================
CREATING INTERACTIVE DASHBOARD
======================================================================
Interactive dashboard saved: FP_Interactive_Dashboard.html
======================================================================
KEY FINDINGS AND RECOMMENDATIONS
======================================================================
📊 KEY FINDINGS:
----------------------------------------------------------------------
1. REVENUE PERFORMANCE:
• Total 2024 revenue: $2,335,875.78
• Average monthly revenue: $194,656.31
• Best performing month: 2024-03
2. PRODUCT CATEGORIES:
• Top category: Electronics
• Category revenue: $840,280.20
• Category satisfaction: 3.99/5.0
3. REGIONAL ANALYSIS:
• Best region: South
• Underperforming region: North
4. CHANNEL PERFORMANCE:
• Leading channel: Online
• Overall satisfaction: 4.00/5.0
======================================================================
💡 STRATEGIC RECOMMENDATIONS:
======================================================================
1. INVESTMENT PRIORITIES:
• Expand Electronics inventory (top performer)
• Increase Online capacity (highest revenue channel)
• Deploy best practices from South to other regions
2. IMPROVEMENT AREAS:
• Focus on North region - investigate and address gap
• Improve satisfaction in lower-rated categories
• Optimize shipping times for online orders
3. GROWTH OPPORTUNITIES:
• Launch targeted campaigns in underperforming regions
• Develop mobile app features (growing channel)
• Create bundle offers for complementary categories
4. OPERATIONAL EXCELLENCE:
• Maintain satisfaction above 4.0 benchmark
• Standardize processes across high-performing regions
• Monitor and address outlier transactions
5. 2025 STRATEGIC INITIATIVES:
• Set aggressive growth targets for North (+30%)
• Expand Electronics product line
• Enhance Online customer experience
• Implement predictive analytics for inventory management
======================================================================
PROJECT COMPLETE - All deliverables generated!
======================================================================
Deliverables created:
6 static visualizations (Matplotlib/Seaborn)
1 interactive dashboard (Plotly)
Comprehensive analysis script
Business insights and recommendations
All files saved to: FinalProject_Outputs/Output:
[Heatmap: “Monthly Revenue Trend - 2024”, 1×2 subplot grid, x: Month, y: Revenue ($)]
Final Project: Comprehensive Business Data Analysis
Objective: Apply all skills learned throughout the course to complete a professional, end-to-end business intelligence project demonstrating mastery of Python, data analysis, and visualization.
Scenario: You are the Senior Business Intelligence Analyst at a company of your choice. The executive team has commissioned a comprehensive annual analysis to guide strategic planning for the coming year. Your mission is to analyze the provided dataset (or one you choose), uncover actionable insights, and present findings through a combination of static reports and interactive dashboards.
Project Options (Choose One):
Option A: E-commerce Performance Analysis
Option B: HR Analytics and Employee Retention
Option C: Marketing Campaign Effectiveness
Option D: Financial Performance and Profitability
You may also choose your own business scenario with instructor approval.
Project Requirements:
Part 1: Data Preparation and Cleaning (20 points)
Deliverable: Python script section demonstrating:
Success Criteria:
Part 2: Exploratory Analysis (20 points)
Deliverable: Python script section with:
Success Criteria:
Part 3: Static Visualizations (25 points)
Deliverable: Minimum 8 high-quality static charts using Matplotlib and Seaborn:
Required Chart Types (must include):
Additional Charts (choose 2):
Each chart must:
Success Criteria:
Part 4: Interactive Dashboard (25 points)
Deliverable: Comprehensive Plotly dashboard (single HTML file) containing:
Dashboard Structure:
Interactive Features (must include at least 3):
Success Criteria:
Part 5: Executive Report (10 points)
Deliverable: Written document (PDF or Markdown) containing:
Structure:
Executive Summary (1 page):
Methodology (½ page):
Findings (2-3 pages):
Recommendations (1 page):
Appendix:
Success Criteria:
Final Deliverables Checklist:
Submit all of the following:
FinalProject_YourName_Analysis.py
Static_Charts/
FinalProject_YourName_Dashboard.html
FinalProject_YourName_Report.pdf
README.md
Grading Rubric:
| Component | Points | Criteria |
|---|---|---|
| Data Preparation | 20 | Cleaning thoroughness, documentation |
| Exploratory Analysis | 20 | Statistical rigor, insight depth |
| Static Visualizations | 25 | Quality, variety, appropriateness |
| Interactive Dashboard | 25 | Functionality, design, interactivity |
| Executive Report | 10 | Clarity, professionalism, actionability |
| Total | 100 |
Bonus Opportunities (+20 points):
Evaluation Criteria:
Technical Excellence (40%):
Analytical Depth (30%):
Visual Communication (20%):
Business Value (10%):
Common Mistakes to Avoid:
Tips for Success:
Submission Instructions:
FinalProject_YourName.zipAcademic Integrity:
** CONGRATULATIONS!**
Upon completing this project, you will have demonstrated:
You are now prepared for professional roles in: