How to Visualize Data in a Data Science Notebook

by

Data visualization is the bridge between raw numbers and actionable insights. In data science notebooks—whether you’re using Jupyter, Google Colab, or other interactive environments—the ability to create compelling visualizations can transform your analysis from a collection of statistics into a narrative that drives decision-making. This guide will walk you through the essential techniques, libraries, and best practices for creating effective data visualizations in your notebooks.

Understanding Your Visualization Environment

Data science notebooks offer a unique advantage for visualization: they combine code, output, and narrative in a single document. This interactive environment allows you to iterate quickly, experiment with different visual approaches, and document your thought process alongside the actual graphics. The immediate feedback loop—write code, see results, refine—makes notebooks ideal for exploratory data analysis and presentation-ready reports alike.

The notebook environment supports both static and interactive visualizations. Static plots are rendered as images directly in your notebook cells, perfect for documentation and reports that need to be shared as PDFs or HTML files. Interactive visualizations allow users to zoom, pan, hover for details, and explore data dynamically, making them invaluable for presentations and web-based dashboards.

Choosing the Right Visualization Library

Your choice of visualization library shapes both your workflow and the final output. Each library has distinct strengths, and understanding these differences will help you select the right tool for your specific needs.

Matplotlib serves as the foundation of Python’s visualization ecosystem. It offers complete control over every element of your plot, from axis labels to color gradients. While its syntax can feel verbose, this granularity means you can create exactly the visualization you envision. Matplotlib excels at creating publication-quality static graphics and serves as the backend for many other visualization libraries.

Seaborn builds on Matplotlib to provide a higher-level interface focused on statistical visualizations. With just a few lines of code, you can create distribution plots, correlation heatmaps, and regression visualizations that would require extensive Matplotlib customization. Seaborn’s default color palettes are designed with perception science in mind, ensuring your visualizations are both attractive and accessible.

Plotly represents the interactive visualization paradigm. Every chart Plotly creates includes built-in interactivity—hover tooltips, zooming, panning, and selection tools. This makes Plotly ideal for exploratory analysis where you need to investigate data points interactively, and for creating dashboard-style reports that stakeholders can explore themselves.

Pandas itself includes plotting capabilities that provide quick visualizations directly from DataFrames. For rapid exploratory analysis, calling .plot() on a DataFrame or Series gives you instant visual feedback without importing additional libraries. While these plots lack customization options, they’re perfect for quick checks during data cleaning and initial exploration.

Setting Up Your Notebook for Visualization

Before creating your first plot, proper setup ensures smooth rendering and optimal output quality. Start by importing your chosen libraries with standard conventions:

import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import pandas as pd
import numpy as np

For Matplotlib and Seaborn, enable inline plotting in Jupyter with the magic command %matplotlib inline. This renders plots directly beneath code cells. If you need higher resolution outputs for presentations or publications, set your DPI (dots per inch) higher:

%config InlineBackend.figure_format = 'retina'

Configure default styling early in your notebook to maintain consistency across all visualizations. Seaborn provides several attractive themes:

sns.set_style("whitegrid")
sns.set_palette("husl")
plt.rcParams['figure.figsize'] = (10, 6)

Creating Your First Visualizations

Let’s explore practical examples using a sample dataset. Consider a sales dataset with dates, products, regions, and revenue:

# Sample data
data = {
    'date': pd.date_range('2024-01-01', periods=100),
    'revenue': np.random.randint(1000, 5000, 100),
    'product': np.random.choice(['A', 'B', 'C'], 100),
    'region': np.random.choice(['North', 'South', 'East', 'West'], 100)
}
df = pd.DataFrame(data)

Time series visualization reveals trends over time. For revenue tracking:

plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['revenue'], linewidth=2, color='#2E86AB')
plt.title('Daily Revenue Trend', fontsize=16, fontweight='bold')
plt.xlabel('Date', fontsize=12)
plt.ylabel('Revenue ($)', fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Distribution analysis using Seaborn shows how your data spreads:

fig, axes = plt.subplots(1, 2, figsize=(14, 5))
sns.histplot(data=df, x='revenue', bins=20, kde=True, ax=axes[0])
axes[0].set_title('Revenue Distribution')
sns.boxplot(data=df, x='product', y='revenue', ax=axes[1])
axes[1].set_title('Revenue by Product')
plt.tight_layout()
plt.show()

Categorical comparisons work well with bar charts:

region_revenue = df.groupby('region')['revenue'].mean().sort_values()
plt.figure(figsize=(10, 6))
plt.barh(region_revenue.index, region_revenue.values, color='#A23B72')
plt.xlabel('Average Revenue ($)')
plt.title('Average Revenue by Region', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

Mastering Interactive Visualizations

Interactive visualizations transform passive viewers into active explorers. Plotly makes creating these experiences straightforward:

fig = px.scatter(df, x='date', y='revenue', color='product', 
                 size='revenue', hover_data=['region'],
                 title='Interactive Revenue Analysis')
fig.show()

This single line creates a scatter plot where users can hover over points to see exact values, click legend items to filter data, and zoom into specific time periods. The color parameter automatically creates a legend, while size maps point size to revenue magnitude, adding a third dimension to your two-dimensional plot.

For more complex dashboards, Plotly supports subplots and annotations:

from plotly.subplots import make_subplots
import plotly.graph_objects as go

fig = make_subplots(rows=2, cols=1, 
                    subplot_titles=('Revenue Trend', 'Product Distribution'))

fig.add_trace(go.Scatter(x=df['date'], y=df['revenue'], mode='lines'),
              row=1, col=1)

product_counts = df['product'].value_counts()
fig.add_trace(go.Bar(x=product_counts.index, y=product_counts.values),
              row=2, col=1)

fig.update_layout(height=700, showlegend=False, title_text="Sales Dashboard")
fig.show()

Advanced Visualization Techniques

Once you’re comfortable with basic plots, advanced techniques can reveal deeper insights.

Correlation heatmaps expose relationships between multiple variables:

# Create numeric features for correlation
df['month'] = df['date'].dt.month
df['day_of_week'] = df['date'].dt.dayofweek

# Calculate correlations
correlation_matrix = df[['revenue', 'month', 'day_of_week']].corr()

# Visualize
plt.figure(figsize=(8, 6))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', 
            center=0, square=True, linewidths=1)
plt.title('Feature Correlation Heatmap', fontsize=14)
plt.tight_layout()
plt.show()

Faceted plots display subsets of data side by side:

g = sns.FacetGrid(df, col='product', row='region', height=3, aspect=1.2)
g.map(plt.scatter, 'date', 'revenue', alpha=0.5)
g.add_legend()
g.fig.suptitle('Revenue Patterns by Product and Region', y=1.02)
plt.show()

Combined visualizations tell richer stories by layering multiple plot types:

fig, ax1 = plt.subplots(figsize=(12, 6))

# Line plot on primary axis
color = 'tab:blue'
ax1.set_xlabel('Date')
ax1.set_ylabel('Revenue', color=color)
ax1.plot(df['date'], df['revenue'], color=color, linewidth=2)
ax1.tick_params(axis='y', labelcolor=color)

# Bar plot on secondary axis
ax2 = ax1.twinx()
color = 'tab:orange'
ax2.set_ylabel('Transaction Count', color=color)
daily_counts = df.groupby('date').size()
ax2.bar(daily_counts.index, daily_counts.values, alpha=0.3, color=color)
ax2.tick_params(axis='y', labelcolor=color)

plt.title('Revenue and Transaction Volume', fontsize=14, fontweight='bold')
fig.tight_layout()
plt.show()

Best Practices for Effective Visualizations

Creating technically correct plots is only the first step. Effective visualizations communicate insights clearly and compellingly.

Choose appropriate chart types for your data and message:

  • Use line charts for trends over time
  • Choose bar charts for categorical comparisons
  • Apply scatter plots for relationship exploration
  • Deploy heatmaps for correlation matrices
  • Implement box plots for distribution comparisons

Prioritize clarity over complexity. Every element in your visualization should serve a purpose. Remove chart junk—unnecessary gridlines, excessive colors, or decorative elements that distract from your data. Use color strategically to highlight important information rather than decorating every element.

Design for accessibility. Approximately 8% of men and 0.5% of women have some form of color vision deficiency. Use colorblind-friendly palettes, and never rely solely on color to convey information. Combine color with different shapes, patterns, or annotations.

# Colorblind-friendly palette
sns.set_palette("colorblind")

Add context through annotations. Guide your viewer’s attention to important features:

plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['revenue'])

# Highlight maximum revenue
max_idx = df['revenue'].idxmax()
plt.annotate('Peak Revenue', 
             xy=(df.loc[max_idx, 'date'], df.loc[max_idx, 'revenue']),
             xytext=(10, 10), textcoords='offset points',
             bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.7),
             arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0'))

plt.title('Revenue Timeline with Key Events')
plt.show()

Optimize for your audience. Technical audiences may appreciate detailed, multi-faceted plots with extensive information. Executive audiences typically prefer simplified, focused visualizations that communicate a single key insight. Adjust complexity accordingly.

Exporting and Sharing Your Visualizations

Your visualizations need to leave the notebook environment to have impact. Different export formats serve different purposes.

Save static images for reports and presentations:

plt.figure(figsize=(10, 6))
# Your plotting code here
plt.savefig('revenue_analysis.png', dpi=300, bbox_inches='tight')

The dpi=300 parameter ensures high resolution suitable for printing, while bbox_inches='tight' removes excess whitespace.

Export interactive plots as standalone HTML files:

fig = px.scatter(df, x='date', y='revenue', color='product')
fig.write_html('interactive_revenue.html')

Recipients can open this HTML file in any browser and interact with your visualization without installing Python or any libraries.

Convert notebooks to presentations using nbconvert:

jupyter nbconvert --to slides notebook.ipynb --post serve

This generates a reveal.js presentation where your code, visualizations, and markdown text become slides.

Conclusion

Mastering data visualization in notebooks transforms how you analyze and communicate insights. By understanding your tools—from Matplotlib’s precision to Plotly’s interactivity—and applying best practices for clarity and design, you create visualizations that don’t just display data but tell compelling stories. The techniques covered here provide a foundation for exploring your data effectively and sharing your findings persuasively.

Start with simple plots, experiment with different chart types, and gradually incorporate advanced techniques as your needs grow. Remember that the best visualization is the one that helps your audience understand your data and take action based on your insights. Keep iterating, stay curious, and let your data’s story guide your visual choices.

Leave a Comment