Plotting with matplotlib and pandas

One shop needs a monthly revenue line and a category ranking in the same report. Start with a Figurematplotlib Figure: The complete matplotlib image that owns one or more plotting areas and can be saved to a file., the whole image, and one or more Axesmatplotlib Axes: One matplotlib plotting area with its own data artists, title, scales, axis labels and ticks., its plotting areas. fig, ax = plt.subplots() creates both. Draw a line with ax.plot, bars with ax.bar or ax.barh, points with ax.scatter, and a histogram with ax.hist.

pandas draws from a DataFrame using matplotlib underneath. Pass ax=ax so it draws into your named Axes, then refine the result with titles, labels and formatters. fig.savefig("chart.svg") writes the Figure to a file. The examples use twelve monthly rows, six categories and 160 invented orders to show the objects each chart creates.

Named Axes make the destination of every plotting call explicit

matplotlib can be called in two styles. In the object-oriented style you create the Figure and the Axes and call their methods. In the pyplot style, functions such as plt.plot and plt.title draw on a “current” Figure and Axes that pyplot keeps for you. Both draw the same chart:

import matplotlib.pyplot as plt
import pandas as pd

monthly = pd.read_csv("monthly.csv")

# Object-oriented style: make the Figure and the Axes, then call methods on the Axes.
fig, ax = plt.subplots()
ax.plot(monthly["month"], monthly["revenue"])
ax.set_title("Revenue by month")

# pyplot style: pyplot keeps a "current" Figure and Axes and draws on them.
plt.figure()
plt.plot(monthly["month"], monthly["revenue"])
plt.title("Revenue by month")
current = plt.gca()

for name, a in [("object-oriented", ax), ("pyplot", current)]:
    line = a.get_lines()[0]
    print(f"{name:>15}: {type(a.figure).__name__} with {len(a.figure.axes)} Axes, "
          f"{len(a.get_lines())} line of {len(line.get_xdata())} points, title {a.get_title()!r}")
same = list(ax.get_lines()[0].get_ydata()) == list(current.get_lines()[0].get_ydata())
print("same data in both:", same)
print("open figures:", plt.get_fignums())

object-oriented: Figure with 1 Axes, 1 line of 12 points, title 'Revenue by month'
         pyplot: Figure with 1 Axes, 1 line of 12 points, title 'Revenue by month'
same data in both: True
open figures: [1, 2]

The matplotlib documentation suggests the object-oriented style for complicated charts and for code you will reuse, and pyplot for quick interactive looks. Plotting with matplotlib in a script or a report is the reusable kind, so this track writes fig, ax = plt.subplots() and calls Axes methods. Note the last line: pyplot keeps every figure it made, here two, until they are closed.

Follow the ownership chain used by the shop’s monthly chart.

Naming the objects keeps a second chart from silently becoming the destination.

Four plotting methods create four inspectable kinds of marks

The shop’s sales live in two small tables, monthly.csv (orders and revenue for 12 months) and categories.csv (revenue per category for the year), plus 160 invented orders made from a fixed random seed. One figure holds a line, a bar chart, a scatter plot and a histogram. Two are drawn with Axes methods and two with pandas, into the Axes the figure already has:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

plt.style.use("house.mplstyle")
monthly = pd.read_csv("monthly.csv")
categories = pd.read_csv("categories.csv")
rng = np.random.default_rng(42)                    # 160 invented orders, the same on every run
items = rng.integers(1, 9, size=160)
orders = pd.DataFrame({"items": items, "value": (items * rng.normal(420, 90, size=160)).round()})

fig, axs = plt.subplots(2, 2, figsize=(8.4, 6.0), layout="constrained")
line, bars, points, spread = axs.flat

# Axes methods: you pass the values.
line.plot(monthly["month"], monthly["revenue"] / 1e6)
line.set(title="Line: revenue by month", ylabel="Million", ylim=(0, 2.2))
line.set_xticks(monthly["month"][::3])

# pandas .plot: you pass column names and the Axes to draw on.
categories.sort_values("revenue").plot.barh(x="category", y="revenue", ax=bars, legend=False)
bars.set(title="Bar: revenue by category", xlabel="", ylabel="")
bars.xaxis.set_major_formatter(lambda v, pos: f"{v / 1e6:.0f}M")

orders.plot.scatter(x="items", y="value", ax=points, s=14, alpha=0.7, color="#1d5fcb")
points.set(title="Scatter: items and order value", xlabel="Items in the order", ylabel="Order value")

spread.hist(orders["value"], bins=20)
spread.set(title="Histogram: order values", xlabel="Order value")
fig.savefig("four-kinds.svg", metadata={"Date": None})

print("line:", len(line.get_lines()), "Line2D with", len(line.get_lines()[0].get_xdata()), "points")
print("bars:", len(bars.patches), "rectangles, longest at the top:", bars.get_yticklabels()[-1].get_text())
print("scatter:", len(points.collections[0].get_offsets()), "points in one collection")
print("histogram:", len(spread.patches), "bins, tallest holds", int(max(p.get_height() for p in spread.patches)), "orders")

line: 1 Line2D with 12 points
bars: 6 rectangles, longest at the top: Books
scatter: 160 points in one collection
histogram: 20 bins, tallest holds 18 orders

Each chart type adds its own kind of object to its Axes, and the run counts them: one Line2D with 12 points, 6 bar rectangles, one collection of 160 points and 20 histogram rectangles. Knowing these objects is what lets a check, or a test, inspect a chart without looking at its pixels. Two smaller habits show in the code as well: ax.set(title=..., ylabel=...) sets several properties in one call, and layout="constrained" makes matplotlib leave room for every title and label, so the four charts do not overlap.

pandas fills in some decisions for you, which is convenient until it is not:

import matplotlib.pyplot as plt
import pandas as pd

monthly = pd.read_csv("monthly.csv")

fig, ax = plt.subplots()
returned = monthly.plot(x="month", y=["orders"], ax=ax)
print("returns the Axes it drew on:", returned is ax)
print("x label from the column name:", repr(ax.get_xlabel()))
print("legend added:", ax.get_legend() is not None, [t.get_text() for t in ax.get_legend().get_texts()])

monthly.set_index("month")["revenue"].plot(ax=ax, secondary_y=False, legend=False)
print("lines after a second call:", [line.get_label() for line in ax.get_lines()])

fig2, ax2 = plt.subplots()
monthly.plot.bar(x="month", y="orders", ax=ax2, legend=False, rot=0)
print("bar chart x tick labels:", [t.get_text() for t in ax2.get_xticklabels()][:4], "...")

returns the Axes it drew on: True
x label from the column name: 'month'
legend added: True ['orders']
lines after a second call: ['orders', 'revenue']
bar chart x tick labels: ['Jan', 'Feb', 'Mar', 'Apr'] ...

It returned the very Axes it was given, labelled the x-axis with the column name and added a legend for one line. A second call on the same Axes added a second line, which is how pandas charts are layered. Pass legend=False, or set the labels yourself, when the defaults do not fit the report.

Follow the tables into the four kinds of artists in four_kinds.py.

The object counts describe this input and these calls; they are not universal counts for each chart kind.

Labels and a chosen file format make a chart usable in a report

A report’s twelve monthly points need a title, units and a suitable output file. The reader should be able to read the chart without its code. Three Axes methods do most of that work: ax.set_title, ax.set_xlabel and ax.set_ylabel. For the numbers along an axis, matplotlib uses formatters. StrMethodFormatter formats every tick with one format string, such as "{x:,.0f}" for thousands separators. FuncFormatter turns each tick value into text with a function you write. ax.bar_label writes each bar’s value next to the bar.

fig.savefig writes the figure to a file and picks the format from the extension: .svg for vector graphics that stay sharp at any size, .png for a picture made of pixels. For a PNG, dpi sets how many pixels the file gets for each inch of figure size, and bbox_inches="tight" trims the empty margin around the chart. With these few calls, plotting with matplotlib covers the everyday charts of a report.

Follow the decisions that come after drawing the shop’s values.

A file extension chooses an output format; it does not repair missing units or ambiguous labels.

Tick labels and value labels that read like a report Pro: opens with a Pro, Premium or Ultimate pass

Saving figures at a fixed size, with identical files on every run Pro: opens with a Pro, Premium or Ultimate pass

Practice

Test your Figure and Axes choices on a shop report: select the destination, put the largest horizontal bar at the top and calculate an export size.

Interview questions

Key takeaways

• fig, ax = plt.subplots() gives you the Figure and its Axes; draw with ax.plot, ax.bar, ax.barh, ax.scatter and ax.hist.
• pandas df.plot(..., ax=ax) draws into your Axes and returns it, so pandas charts can be refined with matplotlib.
• Each chart type adds its own objects to the Axes, which is what checks and tests can inspect.
• Label every axis, format the ticks for the reader, and save with fig.savefig, choosing SVG or PNG by where the chart will be shown.