Data Visualization

The grammar of a chart

Every statistical chart can be described with a few ingredients. This way of thinking, called the grammar of graphics (Leland Wilkinson; popularized by R's ggplot2), turns "make a chart" into a set of explicit decisions:

• Data: a tidy table, one row per observation.
• Marks (geometries): what is drawn for each observation: points, lines, bars, areas.
• Encodings (aesthetic mappings): which column controls which visual property of a mark: x position, y position, color, size, shape, opacity.
• Scales: how data values map to visual values (linear or log axis, which colors).
• Facets: small multiples, the same chart repeated for each subgroup.
• Guides and annotations: axes, legends, titles, and labels that let a reader decode it.

Not all encodings are equally accurate. Research on graphical perception (Cleveland and McGill, 1984) ranks how precisely people compare values: position on a common scale is best, then length, then angle and area, with color saturation and hue last. That ranking explains much of the conventional advice: bar charts (length from a common baseline) beat pie charts (angles), and color is better for categories than for precise quantities.

Remember: decide data, marks, and encodings on purpose. Put the most important comparison on position; use color for categories, not for fine quantities.

Choosing the right chart

Start from the question, not the chart type. Most questions fall into a handful of families:

Remember: name the question first; then pick the chart family. Sort categories by value, start bars at zero, and prefer small multiples over clutter.

The matplotlib object model: Figure, Axes, Artists

matplotlib draws everything with objects called Artists. Three levels matter:

• The Figure is the whole canvas (the image or window). It holds one or more Axes, plus figure-level titles and legends.
• An Axes (note the spelling: one Axes, several Axes) is one plot area with its own data coordinates: an x-axis and a y-axis, a title, and the plotted marks. Almost every plotting method lives on the Axes: ax.plot, ax.bar, ax.set_title.
• Each Axis (singular) is the ruler along one edge: its ticks, tick labels, scale, and label.

Two interfaces: pyplot vs object-oriented

matplotlib.pyplot (imported as plt) offers MATLAB-style functions like plt.plot() and plt.title() that act on an implicit "current" figure and axes. That is quick at an interactive prompt but becomes confusing with several panels or inside functions: which axes is current right now? The object-oriented (OO) API is explicit: create the objects, then call methods on them.

plt.plot(weeks, sales)
plt.title("Weekly sales")
plt.xlabel("Week")

fig, ax = plt.subplots()
ax.plot(weeks, sales)
ax.set_title("Weekly sales")
ax.set_xlabel("Week")

Use plt.subplots() to create the figure and axes, then the OO methods for everything else. Functions that draw should accept an ax (or return the fig), which makes them composable and testable.

Remember: Figure contains Axes; Axes holds the plot. Create both with plt.subplots() and call methods on ax; inspecting those objects is also how you test plotting code.

The five workhorse plots

Remember: line for trends, bar for categories, scatter for relationships, histogram for one distribution, box plot for comparing distributions.

Subplots, layouts, and annotations

plt.subplots(nrows, ncols) returns a NumPy array of Axes. Key options:

• sharex=True / sharey=True: panels share limits, which is essential for honest small multiples (otherwise each panel autoscales and differences become invisible).
• layout="constrained" (or fig.tight_layout()): automatically spaces panels so labels do not overlap.
• plt.subplot_mosaic("AAB;CCB"): named panels of different sizes from an ASCII-art layout.

Annotations turn a chart into an explanation. ax.annotate(text, xy=point, xytext=label_position, arrowprops=...) points at a data value; ax.axhline / ax.axvline draw reference lines; ax.axvspan shades a period; ax.text places free text (in data coordinates by default, or transform=ax.transAxes for 0-1 axes coordinates).

Remember: share axes across small multiples; use constrained layout; annotate the point you want readers to notice, and write titles that state the finding.

Color and accessibility

About 1 in 12 men and 1 in 200 women have some form of color vision deficiency, most often difficulty telling red from green. Charts are also printed in grayscale, projected in bright rooms, and viewed on phones. Design so color helps but is never the only channel:

• Categorical (qualitative) palettes for unordered groups. The Okabe-Ito palette was designed to be distinguishable with common color vision deficiencies: orange #E69F00, sky blue #56B4E9, green #009E73, yellow #F0E442, blue #0072B2, vermillion #D55E00, purple #CC79A7, and black. matplotlib's "tab10" is a reasonable default too. Keep to about 6-8 categories; beyond that, group or facet.
• Sequential colormaps for ordered magnitudes (low to high): viridis, cividis, magma. They are perceptually uniform (equal data steps look like equal color steps) and readable in grayscale.
• Diverging colormaps for values around a meaningful midpoint (change from baseline, correlation): RdBu, coolwarm, with the midpoint pinned at zero.
• Avoid rainbow maps like jet: their brightness rises and falls, creating false boundaries and hiding real ones.
• Redundant encoding: pair color with marker shape, line style, or direct labels, so the chart still works without color.
• Highlight with gray: draw context in gray and the one series that matters in a strong color.

Remember: qualitative palettes for categories, sequential for magnitude, diverging around a midpoint; never rely on color alone; gray for context, color for the point.

Plotting from pandas, and saving figures

pandas objects have a .plot accessor that calls matplotlib for you, using the index as x and each column as a series: df.plot() (line), df.plot.bar(), .barh(), .hist(), .box(), .scatter(x=, y=), .area(). It returns the matplotlib Axes, and accepts ax= to draw into one you created, so you can mix quick pandas plotting with full OO control.

Saving figures

fig.savefig(path) picks the format from the extension. Vector formats (SVG, PDF) scale without blurring and are best for print and documents; raster PNG is best for web pages, dashboards, and images with many points. Useful options: dpi=200 for crisp PNGs, bbox_inches="tight" to trim whitespace, transparent=True for slides.

In scripts, servers, tests, and CI there is no screen, so use a non-interactive backend (the renderer matplotlib draws with). Either call matplotlib.use("Agg") before importing pyplot, set the environment variable MPLBACKEND=Agg, or skip pyplot entirely and build matplotlib.figure.Figure() objects directly, which never touch a GUI and keep no global state. Close pyplot figures you no longer need with plt.close(fig); otherwise long-running programs leak memory.

Remember: df.plot(ax=ax) mixes pandas convenience with OO control; save vector for print and PNG for the web; use Agg or Figure() when there is no display.

Beyond matplotlib: seaborn and plotly

matplotlib is the foundation; two higher-level libraries are worth knowing:

• seaborn builds statistical charts from tidy DataFrames in one call, with the grammar-of-graphics idea of mapping columns to x, y, hue, and facets (col=, row=). It draws on matplotlib Axes, so everything in this module still applies. Its seaborn.objects interface is a direct grammar-of-graphics API.
• plotly produces interactive HTML charts (hover, zoom, pan) for notebooks and dashboards. plotly.express has a similar column-mapping style.

Remember: seaborn for quick statistical and faceted charts on top of matplotlib; plotly when readers need interactivity.

Storytelling: redesigning a cluttered chart

Exploratory charts are for you; explanatory charts are for an audience. An explanatory chart has one message, and every element either supports it or is removed. Edward Tufte called the ink that does not show data "chart junk"; Cole Nussbaumer Knaflic's Storytelling with Data turns this into a process:

1. Say the message in one sentence first, and make it the title ("Online overtook in-store sales in August"), not a label ("Sales by channel").
2. Choose the chart that makes that comparison easiest.
3. Remove clutter: heavy borders, unnecessary gridlines, legends that can be direct labels, redundant tick labels, 3-D effects, decimals no one needs.
4. Focus attention: gray for context, one accent color for what matters, annotations for the key moment.

Remember: one message per chart, stated in the title; remove what does not support it; gray for context, color and annotation for the point.

Practice

Each function returns a matplotlib Figure; the tests inspect its Axes, lines, bars, and text, which is exactly how you unit-test plotting code in real projects.

import matplotlib.pyplot as plt

def line_chart(x, series, title):
    fig, ax = plt.subplots()
    for name, ys in series.items():
        ax.plot(x, ys, label=name)
    ax.set_title(title)
    ax.set_xlabel("Week")
    ax.set_ylabel("Sales")
    ax.legend()
    return fig

import matplotlib.pyplot as plt

def ranked_bars(counts):
    items = sorted(counts.items(), key=lambda kv: kv[1])
    fig, ax = plt.subplots()
    ax.barh([name for name, _ in items], [value for _, value in items], color="#0072B2")
    ax.set_xlim(left=0)
    return fig

import matplotlib.pyplot as plt

def small_multiples(groups):
    fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, layout="constrained")
    for ax, (name, values) in zip(axs.flat, groups.items()):
        ax.hist(values, bins=20, color="#0072B2")
        ax.set_title(name)
    return fig

import matplotlib.pyplot as plt

def plot_with_peak(x, y):
    fig, ax = plt.subplots()
    ax.plot(x, y, color="#0072B2")
    i = max(range(len(y)), key=y.__getitem__)
    ax.axhline(sum(y) / len(y), color="#999999", linestyle="--")
    ax.annotate(f"peak: {y[i]:.0f}", xy=(x[i], y[i]), xytext=(x[i] + 0.5, y[i] * 0.8),
                arrowprops=dict(arrowstyle="->"))
    return fig

import matplotlib.pyplot as plt

OKABE_ITO = ["#E69F00", "#56B4E9", "#009E73", "#0072B2", "#D55E00", "#CC79A7"]
MARKERS = ["o", "s", "^", "D", "v", "P"]

def scatter_groups(groups):
    fig, ax = plt.subplots()
    for i, (name, (xs, ys)) in enumerate(groups.items()):
        ax.scatter(xs, ys, color=OKABE_ITO[i], marker=MARKERS[i], label=name)
    ax.legend()
    return fig

Mini-project: a one-page visual report

pixi init visual-report && cd visual-report
pixi add python=3.14 matplotlib pandas numpy
pixi add seaborn plotly          # optional, for the stretch goals
pixi run python report.py        # writes report.png and report.pdf

Quiz

Recap

• Charts are data + marks + encodings + scales + guides; position is the most accurate encoding.
• Pick by question: trend = line, comparison/ranking = sorted bar, distribution = histogram/box, relationship = scatter.
• Figure contains Axes; use plt.subplots() and OO methods; inspect artists to test plots.
• Share axes for small multiples; use constrained layout; annotate the key point.
• Colorblind-safe palettes, perceptually uniform colormaps, redundant encodings, gray for context.
• df.plot(ax=ax) for quick pandas plots; save vector for print, PNG for web; Agg when headless.
• Explanatory charts have one message stated in the title and no clutter.

Going further

• matplotlib Quick start and the gallery
• Choosing colormaps in matplotlib
• seaborn tutorial and plotly express
• Fundamentals of Data Visualization by Claus O. Wilke (free online)
• Next: M54 Statistics & Probability