Turn analysis into charts people read correctly: visual principles, matplotlib and seaborn, small multiples, dashboards and a short data story.

Data Visualization & Storytelling

## Why it matters

Matplotlib is the foundation of plotting in Python. pandas' `.plot()`, seaborn and many other libraries draw with it underneath, so knowing its core model lets you fix any chart, whatever library made it. You will run the plotting code on your own machine (Jupyter, VS Code or Google Colab); the in-browser activity focuses on the data preparation that every chart needs.

## The core model: figure and axes

Matplotlib has two layers you will use constantly:

- **Figure**: the whole canvas (the image file or window).
- **Axes**: one plotting area inside the figure, with its own x-axis, y-axis, title and data. A figure can hold several axes.

Always start with `plt.subplots()`, which returns both:

```python
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 4))   # width, height in inches
```

Then call methods on `ax`: `ax.plot`, `ax.bar`, `ax.set_title`, `ax.set_xlabel`. This "object-oriented" style is clearer than calling `plt.plot` repeatedly, especially once you have more than one chart in a figure.

## A labelled line chart

```python
import pandas as pd
import matplotlib.pyplot as plt

orders = pd.read_csv("orders.csv", parse_dates=["date"])
monthly = orders.groupby(orders["date"].dt.strftime("%Y-%m"))["revenue"].sum()

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(monthly.index, monthly.values, marker="o", color="#1b9e77", linewidth=2)
ax.set_title("Monthly revenue, Jan to May 2026", loc="left")
ax.set_xlabel("Month")
ax.set_ylabel("Revenue ($)")
ax.set_ylim(bottom=0)                     # honest baseline
ax.spines[["top", "right"]].set_visible(False)
ax.grid(axis="y", color="#dddddd", linewidth=0.8)
fig.tight_layout()
fig.savefig("monthly_revenue.png", dpi=150)
```

What each part does:

- `groupby(...).sum()` turns many orders into one value per month. Getting this step right is most of the work, which is why the activity practises it.
- `marker="o"` shows where the actual data points are, useful with few periods.
- `set_ylim(bottom=0)` is optional for line charts, but it avoids exaggerating small changes when your audience might over-read the slope.
- `tight_layout()` stops labels being cut off; `savefig` writes a file at a sensible resolution.

## A sorted bar chart

```python
by_region = orders.groupby("region")["revenue"].sum().sort_values()

fig, ax = plt.subplots(figsize=(6, 3))
bars = ax.barh(by_region.index, by_region.values, color="#7570b3")
ax.bar_label(bars, fmt="{:,.0f}", padding=3)
ax.set_title("Revenue by region", loc="left")
ax.set_xlabel("Revenue ($)")
ax.spines[["top", "right"]].set_visible(False)
fig.tight_layout()
```

`barh` draws horizontal bars, which suit text labels. Matplotlib draws the first bar at the bottom, so sorting ascending puts the largest at the top. `bar_label` (matplotlib 3.4+) adds value labels, and `fmt="{:,.0f}"` adds thousands separators.

## Several charts in one figure

```python
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4))
ax1.plot(monthly.index, monthly.values)
ax2.barh(by_region.index, by_region.values)
fig.suptitle("Q1 to Q2 sales overview")
```

`plt.subplots(rows, cols)` returns an array of axes. You will use this for small multiples later in the module.

## Saving and sharing

- Use `savefig("name.png", dpi=150)` for slides and documents, or `.svg` for crisp scaling on the web.
- Set `figsize` before plotting; resizing an image afterwards blurs text.
- In Jupyter, a chart shows automatically at the end of a cell; in scripts, call `plt.show()`.

## Common mistakes

- **Mixing the `plt.` and `ax.` styles** in the same figure. Titles end up on the wrong chart. Pick `ax.` methods.
- **Plotting unaggregated data.** Plotting 10,000 raw orders as a line gives a scribble. Aggregate first.
- **Unsorted time.** If months are strings, make sure they are sorted ("2026-10" sorts correctly; "Oct 2026" does not). Using ISO "YYYY-MM" strings or real dates avoids this.
- **Missing units.** "Revenue" alone does not say dollars or thousands of dollars.
- **Default titles.** Matplotlib adds none by default; always add one, ideally stating the takeaway.

## Quick recap

- `fig, ax = plt.subplots()` then call methods on `ax`.
- Aggregate with pandas, then plot: `ax.plot` for time, `ax.barh` for sorted categories.
- Label axes with units, set honest baselines, remove extra spines, `tight_layout()`, `savefig`.

## Try it

In the **Do** tab, use pandas to compute the monthly series and the sorted region totals that feed these two charts, plus a takeaway title.


Build a clearly labelled line chart and bar chart with matplotlib's figure and axes interface.

Matplotlib essentials

Matplotlib Tutorial (Part 1): Creating and Customizing Our First Plots

Matplotlib Tutorial (Part 2): Bar Charts and Analyzing Data from CSVs

## Why it matters

Many questions analysts get are about **spread** and **association**: how variable are delivery times, do longer distances mean longer deliveries, is one group different from another? seaborn is a Python library built on matplotlib that draws these statistical charts in one line, straight from a pandas DataFrame. It is fast for exploration and produces clean defaults. The catch is that it makes decisions for you (bin widths, smoothing, confidence bands) that you need to understand before you show the chart to anyone.

## Setup

```python
import seaborn as sns
import matplotlib.pyplot as plt

df = sns.load_dataset("tips")   # restaurant bills, tips, day, time, party size
sns.set_theme(style="whitegrid")
```

seaborn functions take `data=` (a DataFrame) and column names as strings for `x`, `y` and `hue`. Each returns a matplotlib Axes, so you can still use `ax.set_title` and everything from the previous lesson.

## Distributions

**Histogram:**

```python
ax = sns.histplot(data=df, x="total_bill", binwidth=5)
ax.set(title="Most bills are between $10 and $25", xlabel="Total bill ($)", ylabel="Number of bills")
```

A histogram splits the range into **bins** and counts how many values fall in each. The bin width changes the story: very wide bins hide detail, very narrow bins show noise. seaborn picks a width automatically; set `binwidth` (or `bins`) yourself and try two or three values before choosing. Starting bins on round numbers (0, 5, 10) makes the chart easier to read, which is what you will compute in the activity.

**Density (KDE) curve:** `sns.kdeplot(data=df, x="total_bill")` draws a smoothed version. It is good for comparing shapes, but it can suggest values that do not exist (for example, negative bills near zero). Use histograms when your audience is not used to density plots.

**Comparing groups:** box plots and violin plots compare a distribution across categories.

```python
ax = sns.boxplot(data=df, x="day", y="total_bill", order=["Thur", "Fri", "Sat", "Sun"])
```

A box plot shows the median (middle line), the interquartile range (the box, the middle 50% of values) and outliers (dots beyond 1.5 times the IQR). It is compact, but it hides the number of observations and multi-peaked shapes; adding `sns.stripplot(..., color="0.3", size=3)` on top shows the raw points.

## Relationships

**Scatter plot:**

```python
ax = sns.scatterplot(data=df, x="total_bill", y="tip", hue="time", alpha=0.7)
```

Each dot is one row. `hue` colours dots by a category; `alpha` makes overlaps visible.

**Scatter with a fitted line:**

```python
ax = sns.regplot(data=df, x="total_bill", y="tip", scatter_kws={"alpha": 0.5})
```

`regplot` adds a least-squares line and a shaded 95% confidence band for the line. Say what that band is if you present it; it is not a range for individual points.

**Putting a number on it.** The Pearson correlation coefficient *r* runs from -1 to 1 and measures how close the points are to a straight line:

```python
r = df["total_bill"].corr(df["tip"])   # about 0.68
```

Values near 0 mean no linear relationship (there could still be a curved one, which is why you always look at the scatter plot). Correlation does not show cause: bigger bills and bigger tips both come from bigger parties.

## Figure-level functions

`sns.displot`, `sns.relplot` and `sns.catplot` are "figure-level" versions that can split into panels with `col=` and `row=`. You will use them for small multiples in the next lesson.

## Common mistakes

- **Accepting default bins.** Always try a few bin widths, and say what width you used.
- **Overplotting.** Thousands of opaque dots form a blob. Use `alpha`, smaller markers, or `sns.histplot(x=..., y=...)` for a 2D histogram.
- **Reading the regression band as a prediction range.** It shows uncertainty in the line, not where individual points will fall.
- **Using r alone.** Very different datasets can share the same r (Anscombe's quartet is the classic demonstration). Plot first.
- **Box plots for tiny groups.** With five observations, show the points instead.

## Quick recap

- seaborn draws statistical charts from DataFrame columns and returns matplotlib Axes.
- Distributions: `histplot` (choose the bin width), `kdeplot`, `boxplot`, `violinplot`.
- Relationships: `scatterplot`, `regplot`; summarise with Pearson's r, but always look at the plot.

## Try it

In the **Do** tab, compute histogram bin edges, bin counts and a correlation coefficient with NumPy: the numbers behind a seaborn histogram and scatter plot.


Use seaborn to plot distributions and relationships, and understand the bins and statistics behind each plot.

Statistical charts

Seaborn histplot | How to make a Seaborn histogram plot with Python code

Seaborn scatter plot | How to make and style a scatterplot in Python seaborn

## Why it matters

Plot monthly sales for five regions on one line chart and you get five crossing lines in five colours, a legend, and a reader squinting to work out which line is South. Plot 20 regions and the chart is unreadable. **Small multiples**, a term popularised by Edward Tufte, solve this: draw one small chart per group, with identical axes and scales, arranged in a grid. The reader learns how to read one panel, then compares all of them at a glance. Analysts also call these facet plots, trellis charts or panel charts.

## What makes small multiples work

1. **Same chart type in every panel.** Every panel is a line chart, or every panel is a histogram.
2. **Shared scales.** The y-axis must run from the same minimum to the same maximum in every panel. Otherwise a flat line in one panel can look as steep as a big rise in another. This is the most important rule.
3. **Meaningful order.** Order panels by something useful (largest total first, or geography), not alphabetically by default.
4. **Minimal labels.** Put axis labels only on the outer edge of the grid and a short title on each panel.
5. **A shared highlight or reference** when useful, such as the company average drawn in grey in every panel.

## Small multiples in matplotlib

```python
import math
import matplotlib.pyplot as plt

regions = ["North", "West", "South", "East", "Central"]   # ordered by total
ncols = 3
nrows = math.ceil(len(regions) / ncols)
fig, axes = plt.subplots(nrows, ncols, figsize=(10, 5), sharex=True, sharey=True)

for ax, region in zip(axes.flat, regions):
    data = sales[sales["region"] == region].sort_values("month")
    ax.plot(data["month"], data["units"], color="#1b9e77")
    ax.set_title(region, loc="left", fontsize=10)
    ax.set_ylim(0, 200)
    ax.tick_params(axis="x", labelrotation=45)

for ax in axes.flat[len(regions):]:
    ax.set_visible(False)          # hide the unused sixth panel

fig.suptitle("North is growing fastest; West is declining", x=0.01, ha="left")
fig.tight_layout()
```

`sharex=True, sharey=True` keeps scales identical and removes repeated tick labels. The loop over `axes.flat` fills the grid row by row. Five panels in a 3-column grid need 2 rows, leaving one empty panel to hide.

## Small multiples in seaborn

seaborn's figure-level functions do the grid for you with `col=` (and `row=`):

```python
import seaborn as sns

g = sns.relplot(
    data=sales, x="month", y="units", col="region",
    col_wrap=3, kind="line", height=2.5,
    col_order=["North", "West", "South", "East", "Central"],
)
g.set_titles("{col_name}")
g.set_axis_labels("", "Units sold")
```

`col_wrap=3` wraps panels into rows of three. `displot(..., col="region")` does the same for histograms, and `catplot` for bar and box plots. These functions share axes by default; pass `facet_kws={"sharey": False}` only if you have a strong reason, and say so on the chart.

## Worked example: when to share and when not

Five regions sell between 45 and 171 units a month. With a shared y-axis from 0 to 200, the reader immediately sees North growing, West shrinking and Central small but steady.

Now imagine one region sells 10,000 units and the others about 100. A shared axis squashes the small regions into flat lines at the bottom. Options:

- Show the big region separately and share the axis across the rest.
- Plot **percentage change from the first month** instead of raw units, so every region is on a comparable scale.
- Use independent axes, but label clearly ("each panel has its own scale").

## Common mistakes

- **Independent y-axes by accident.** Many tools default to auto-scaling each panel. Check.
- **Too many panels.** Beyond about 20 to 30, consider grouping or showing the top ones plus "all others".
- **Panels that are too small to read.** Each one should still show its pattern; drop tick labels before shrinking further.
- **Alphabetical ordering** when a value-based order would make the pattern obvious.
- **Colour that means different things in different panels.** Keep encodings identical.

## Quick recap

- Small multiples are a grid of identical small charts, one per group.
- Share scales, order panels meaningfully, and keep labels on the outer edge.
- matplotlib: `plt.subplots(rows, cols, sharex=True, sharey=True)`; seaborn: `relplot`/`displot`/`catplot` with `col=` and `col_wrap=`.

## Try it

In the **Do** tab, prepare the data for a small-multiples chart: per-panel series, a shared y-limit, the grid shape and the panel order.


Compare many groups with a grid of small, consistent charts instead of one tangled chart.

Small multiples

Seaborn FacetGrid | How to make Small Multiples with Python Seaborn | Titles, Hue, Legend

Matplotlib Tutorial (Part 10): Subplots

Build labelled line and bar charts with matplotlib, distribution and relationship plots with seaborn, and small multiples for comparing groups.