Advanced Data Visualization Techniques in Python

Table of Contents

1. Interactive Visualizations with Plotly
2. Geospatial Visualizations with Folium & GeoPandas
3. Network Graphs for Relationship Mapping
4. 3D Visualizations with Matplotlib
5. Heatmaps & Correlation Matrices with Seaborn
6. Animated Plots for Time-Series Data
7. Treemaps & Sunbursts for Hierarchical Data
8. Custom Visualizations with Matplotlib
9. Best Practices for Advanced Visualization
10. References

1. Interactive Visualizations with Plotly

Static plots (e.g., Matplotlib) are great for publications, but interactive visualizations allow users to explore data by zooming, panning, hovering, or filtering—critical for dashboards or exploratory analysis. Plotly, a Python library built on D3.js, excels at creating interactive plots with minimal code.

When to Use:

• Exploratory data analysis (EDA)
• Dashboards and web-based reports
• Presentations where audience interaction is key

Example: Interactive Scatter Plot with Hover Tooltips

import plotly.express as px  
import pandas as pd  

# Load sample dataset (Iris)  
df = px.data.iris()  

# Create interactive scatter plot  
fig = px.scatter(  
    df,  
    x="sepal_width",  
    y="sepal_length",  
    color="species",  # Color by species  
    size="petal_length",  # Size points by petal length  
    hover_data=["petal_width"],  # Show petal width on hover  
    title="Iris Dataset: Sepal Width vs. Length",  
    labels={"sepal_width": "Sepal Width (cm)", "sepal_length": "Sepal Length (cm)"}  # Custom labels  
)  

# Customize layout  
fig.update_layout(  
    plot_bgcolor="white",  
    xaxis=dict(showgrid=True, gridwidth=1, gridcolor="lightgray"),  
    yaxis=dict(showgrid=True, gridwidth=1, gridcolor="lightgray")  
)  

# Show plot (opens in browser or Jupyter notebook)  
fig.show()  

Key Features:

• Hover tooltips display detailed data points.
• Zoom/pan with mouse drag.
• Toggle species visibility via legend.
• Export plots as PNG/SVG or embed in web apps (with Plotly Dash).

2. Geospatial Visualizations with Folium & GeoPandas

Geospatial data (e.g., coordinates, regions) requires specialized visualization. Folium (for interactive maps) and GeoPandas (for geospatial data manipulation) are powerful tools for this.

When to Use:

• Visualizing regional trends (e.g., sales by state).
• Mapping geographic events (e.g., weather patterns).

Example: Choropleth Map with Folium

A choropleth map shades regions based on a numerical value (e.g., population density).

import folium  
import pandas as pd  

# Load country GDP data (simplified example)  
data = pd.DataFrame({  
    "country": ["USA", "China", "Japan", "Germany", "India"],  
    "gdp_2020": [20.94, 14.72, 5.06, 3.85, 2.66]  # in trillions USD  
})  

# Create a base map centered on the world  
m = folium.Map(location=[20, 0], zoom_start=2)  

# Add choropleth layer (using country codes)  
folium.Choropleth(  
    geo_data="https://raw.githubusercontent.com/python-visualization/folium/main/examples/data/world-countries.json",  
    name="choropleth",  
    data=data,  
    columns=["country", "gdp_2020"],  
    key_on="feature.id",  # Matches country codes in geo_data  
    fill_color="YlOrRd",  
    fill_opacity=0.7,  
    line_opacity=0.2,  
    legend_name="GDP (trillions USD, 2020)"  
).add_to(m)  

# Add layer control to toggle choropleth  
folium.LayerControl().add_to(m)  

# Save map to HTML file  
m.save("gdp_choropleth.html")  

Output:

An interactive map where clicking on a country shows its GDP, and regions are shaded by GDP magnitude.

3. Network Graphs for Relationship Mapping

Network graphs (nodes and edges) visualize relationships between entities (e.g., social networks, supply chains). NetworkX (for graph theory) and PyVis (for interactive networks) are popular libraries.

When to Use:

• Social network analysis (e.g., Twitter followers).
• Dependency mapping (e.g., software packages).
• Knowledge graphs (e.g., entity relationships).

Example: Interactive Network Graph with PyVis

from pyvis.network import Network  
import networkx as nx  

# Create a sample graph with NetworkX  
G = nx.karate_club_graph()  # Classic social network dataset  

# Convert to PyVis network for interactivity  
net = Network(notebook=True, height="600px", width="100%")  
net.from_nx(G)  

# Customize nodes/edges  
for node in net.nodes:  
    node["size"] = 15  # Adjust node size  
    node["color"] = "#00b4d8" if G.nodes[node["id"]]["club"] == "Mr. Hi" else "#7f7f7f"  # Color by club  

# Show interactive network  
net.show("karate_club_network.html")  

Key Features:

• Drag nodes to reposition.
• Hover to see node details.
• Zoom/pan to explore dense networks.

4. 3D Visualizations with Matplotlib

While 2D plots work for most cases, 3D visualizations reveal relationships in three variables (e.g., x, y, z). Matplotlib’s mplot3d toolkit enables 3D scatter plots, surface plots, and more.

When to Use:

• Scientific data (e.g., molecular structures, climate models).
• Multivariate analysis (e.g., sales vs. time vs. region).

Example: 3D Scatter Plot

import matplotlib.pyplot as plt  
import numpy as np  
from mpl_toolkits.mplot3d import Axes3D  

# Generate sample 3D data  
np.random.seed(42)  
n = 100  
x = np.random.rand(n) * 10  
y = np.random.rand(n) * 10  
z = x * 0.5 + y * 0.3 + np.random.randn(n)  # Linear relationship + noise  

# Create 3D plot  
fig = plt.figure(figsize=(10, 7))  
ax = fig.add_subplot(111, projection='3d')  

# Plot scatter points  
scatter = ax.scatter(x, y, z, c=z, cmap='viridis', s=50, alpha=0.8)  

# Add labels and color bar  
ax.set_xlabel('X Variable', fontsize=12)  
ax.set_ylabel('Y Variable', fontsize=12)  
ax.set_zlabel('Z Variable', fontsize=12)  
ax.set_title('3D Scatter Plot of X, Y, Z Variables', fontsize=14)  
fig.colorbar(scatter, ax=ax, label='Z Value')  

plt.show()  

Tip:

Use 3D plots sparingly—they can be harder to interpret than 2D. Reserve them for cases where the third dimension adds critical insight.

5. Heatmaps & Correlation Matrices with Seaborn

Heatmaps visualize data density using color gradients, making them ideal for correlation matrices, time-series matrices, or confusion matrices. Seaborn simplifies creating publication-ready heatmaps.

When to Use:

• Correlation analysis (e.g., feature relationships in ML).
• Confusion matrices (model performance).
• Time-series data (e.g., hourly temperature over weeks).

Example: Correlation Matrix Heatmap

import seaborn as sns  
import pandas as pd  
import matplotlib.pyplot as plt  

# Load dataset (wine quality)  
df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv", sep=";")  

# Compute correlation matrix  
corr = df.corr()  

# Create heatmap  
plt.figure(figsize=(12, 8))  
sns.heatmap(  
    corr,  
    annot=True,  # Show correlation values  
    cmap="coolwarm",  # Color gradient  
    fmt=".2f",  # Decimal precision  
    linewidths=0.5,  # Separate cells  
    cbar_kws={"shrink": 0.8}  # Adjust color bar size  
)  
plt.title("Correlation Matrix of Wine Quality Features", fontsize=14)  
plt.show()  

Output:

A heatmap where red indicates strong positive correlation, blue indicates strong negative correlation, and numbers show exact values.

6. Animated Plots for Time-Series Data

Animated plots show how data evolves over time, making them perfect for storytelling (e.g., population growth, COVID cases). Plotly Express simplifies creating animations with a single line of code.

When to Use:

• Time-series data with clear temporal trends.
• Presentations or dashboards needing dynamic storytelling.

Example: Animated Scatter Plot (Gapminder Dataset)

import plotly.express as px  

# Load Gapminder dataset (life expectancy vs. GDP per capita over time)  
df = px.data.gapminder()  

# Create animation  
fig = px.scatter(  
    df,  
    x="gdpPercap",  
    y="lifeExp",  
    color="continent",  
    size="pop",  # Size by population  
    size_max=60,  
    animation_frame="year",  # Animate over years  
    animation_group="country",  
    log_x=True,  # Log scale for GDP  
    range_x=[100, 100000],  
    range_y=[25, 90],  
    labels={"gdpPercap": "GDP per Capita (USD)", "lifeExp": "Life Expectancy (Years)"},  
    title="Life Expectancy vs. GDP per Capita (1952-2007)"  
)  

fig.show()  

Key Features:

• Play/pause animation controls.
• Slider to scrub through time.
• Hover to see country-specific data.

7. Treemaps & Sunbursts for Hierarchical Data

Treemaps (rectangular) and sunbursts (circular) visualize hierarchical data by nesting categories. They’re ideal for showing part-to-whole relationships.

When to Use:

• Product categories (e.g., sales by department → category → subcategory).
• Organizational hierarchies.
• File system sizes.

Example: Treemap with Plotly Express

import plotly.express as px  

# Load sample hierarchical dataset (coffee production)  
df = px.data.tips()  # Tips dataset (simplified for demo)  
# For a better hierarchy, use a dataset like:  
# df = px.data.gapminder().query("year == 2007")  

# Create treemap  
fig = px.treemap(  
    df,  
    path=[px.Constant("all"), "day", "time", "sex"],  # Hierarchy: all → day → time → sex  
    values="total_bill",  # Size by total bill  
    color="total_bill",  
    color_continuous_scale="RdBu",  
    title="Treemap of Restaurant Tips by Day, Time, and Sex"  
)  
fig.update_layout(margin=dict(t=50, l=25, r=25, b=25))  
fig.show()  

Sunburst Alternative:

Replace px.treemap with px.sunburst for a radial view of the same hierarchy.

8. Custom Visualizations with Matplotlib

For unique use cases, combine Matplotlib’s building blocks (lines, bars, text) to create custom plots. This flexibility lets you tailor visuals to specific needs.

Example: Dual-Axis Plot with Annotations

import matplotlib.pyplot as plt  
import pandas as pd  

# Sample data: Sales and advertising spend over months  
months = ["Jan", "Feb", "Mar", "Apr", "May"]  
sales = [150, 220, 180, 250, 300]  
ad_spend = [20, 35, 25, 40, 45]  

# Create figure and primary axis (sales)  
fig, ax1 = plt.subplots(figsize=(10, 6))  
color = 'tab:blue'  
ax1.set_xlabel('Month', fontsize=12)  
ax1.set_ylabel('Sales (USD)', color=color, fontsize=12)  
ax1.bar(months, sales, color=color, alpha=0.6, label='Sales')  
ax1.tick_params(axis='y', labelcolor=color)  

# Add secondary axis (ad spend)  
ax2 = ax1.twinx()  
color = 'tab:red'  
ax2.set_ylabel('Ad Spend (USD)', color=color, fontsize=12)  
ax2.plot(months, ad_spend, color=color, marker='o', linewidth=2, label='Ad Spend')  
ax2.tick_params(axis='y', labelcolor=color)  

# Add title and legend  
fig.suptitle('Monthly Sales vs. Advertising Spend', fontsize=14)  
fig.legend(loc='upper left')  

plt.tight_layout()  
plt.show()  

Customization Tips:

• Use ax.annotate() to add text labels (e.g., peak sales values).
• Combine ax.bar() (primary axis) with ax.plot() (secondary axis) for mixed data types.

9. Best Practices for Advanced Visualization

Even advanced techniques can fail without careful design. Follow these principles:

1. Clarity Over Complexity: Prioritize readability. Avoid overloading plots with unnecessary elements.
2. Color Choices: Use colorblind-friendly palettes (e.g., seaborn.color_palette("colorblind")).
3. Interactivity: For large datasets, use tools like Plotly or Bokeh to let users filter data.
4. Accessibility: Add alt text, descriptive labels, and avoid relying solely on color (use patterns for colorblind users).
5. Performance: For massive datasets, downsample data or use WebGL (via Plotly) to avoid lag.

10. References

• Plotly Documentation
• Matplotlib 3D Tutorial
• Seaborn Heatmaps
• PyVis Network Documentation
• Folium Documentation
• Gapminder Dataset

By mastering these advanced techniques, you’ll transform raw data into compelling stories that drive decision-making. Experiment with different libraries, datasets, and customization options to find what works best for your use case!