The previous lesson ended with the answers in tables: Saturday 130 units, April 168, Faust with 11.9% conversion. Correct — but Ana doesn't think in tables, and her brain, like everyone's, processes one bar being taller than another in milliseconds and a column of numbers in... considerably longer. Matplotlib is the reference visualization library in Python: the oldest, the most flexible, and the foundation on which almost all the others are built. This lesson teaches you to pick the chart based on the question, to assemble it piece by piece and not to lie along the way — ending with a dashboard of the semester's numbers hanging in Papyrus's back room.

1. Why visualize: the Anscombe lesson
2. Anatomy of a figure
3. plt.plot: the monthly evolution (and Sant Jordi)
4. bar and barh: comparing titles
5. hist: the distribution of amounts
6. scatter: price against units
7. pie and when not to use it
8. subplots: the store's 2×2 dashboard
9. Style and readability
10. The df.plot shortcut and savefig
11. Which chart for which question

In 1973 the statistician Francis Anscombe built four datasets with the same statistics — same mean of x and y, same variance, same regression line — that, when drawn, turn out to be four completely different stories: a linear cloud, a curve, a perfect line with one rebel point, and a degenerate case where a single point manufactures all the correlation. The moral is twofold and governs this lesson:

• Numerical summaries hide the shape. 11-03's describe() can't tell those four worlds apart; one glance can.
• Always draw before concluding. Especially before fitting the 11-05 model: Anscombe's regression was "correct" in all four cases and only made sense in one.

Matplotlib distinguishes the canvas (Figure) from each drawing area (Axes — a set of axes with its data, title and legend; a Figure can contain several). Almost every "where do I put the title?" problem is solved by knowing which of the two each piece belongs to.

The recommended way to work is the object-oriented interface: plt.subplots() hands you the fig, ax pair and from there everything is a method on ax — no hidden global state:

Lines tell evolution over time. The data: the monthly units that groupby gave us in 11-03.

The marker="o" flags the real data points (there are only 6; the line between them is a visual guide, not a measurement), and annotate pins the arrow on the peak: April, 168 units, more than double a normal month. It's the same number from 11-02's axis=0 and 11-03's groupby — but now you can see it, and Ana understands it without knowing Python.

Bars compare categories. Units per title (11-03):

Two tips worth their weight in gold: sort the bars by value (they already are: that's 11-03's sort_values working for the chart) and, with long names or many categories, use barh (horizontal bars): the labels read straight through without tilting your head — ax.barh(titles[::-1], title_units[::-1]) (reversed so the biggest ends up on top).

And an honesty rule: a bar chart's axis starts at 0. A bar starting at 100 turns a 5% difference into a visual chasm. Matplotlib gets this right by default; don't "fix" it.

A histogram slices a range into intervals (bins) and counts how many values fall into each one: it's the shape of the data, the thing describe() summarizes blindly.

The drawing confirms 11-01's suspicion: a mountain concentrated between 9 and 16 EUR (the single-copy sales) and a long tail to the right — the Sant Jordi bundles up to 63.60 EUR — which is what separates the mean (15.03) from the median (12.50). Try bins=5 and bins=50: too few bins hide the shape, too many turn it into noise. There is no magic number; you feel it out.

The scatter plot looks for a relationship between two numeric variables:

Four points and one story: there's no clean line (Don Quixote, at 15.90, is the bestseller), but Faust sits alone in its corner — the most expensive and the worst seller, consistent with its 11.9% conversion from 11-03. With only 4 points this is a clue, not a law: exactly the caution we'll need when fitting the 11-05 regression on this same pair of variables.

The honest warning: the human eye compares lengths far better than angles. Is The Odyssey's slice (30%) bigger than Hamlet's (23%)? In the pie it's hard work; in a bar it's obvious. The pie only works with few categories (2-4), parts of a whole, and big differences — the store/web split (60/40) passes the cut; almost everything else is better as bars. If in doubt, bars.

Everything together: the dashboard Ana wants to print and hang in the back room.

subplots(2, 2) returns the Figure and a 2×2 matrix of Axes indexed like the 11-02 arrays (axs[1, 1] = bottom right). suptitle titles the whole canvas and tight_layout() repositions everything so nothing overlaps — without it, the top titles trample the bottom axes.

• Labels, ALWAYS. A chart without xlabel/ylabel/title is a riddle. If the axis is euros, say so; "I know what it is" expires in a week.
• Colors with intent. The default blue is fine; the rainbow is not. Use one neutral color for everything and a single accent for the data point that matters (Faust in the scatter, April in the line). Color should mean something or not be there. And remember that ~8% of men confuse red and green: don't hang the only distinction on that pair.
• Rotated dates. With many dates on the X axis they pile up: ax.tick_params(axis="x", rotation=45) or fig.autofmt_xdate().
• Less is more. Every element (grid, border, single-series legend) must earn its ink. ax.grid(alpha=0.3) at most.

pandas wraps Matplotlib: every Series or DataFrame has .plot, ideal for quick looks while exploring:

One line from the groupby to the drawing. It returns the usual ax, so you can keep tweaking (ax.set_ylabel(...)). To explore, df.plot; for the final, made-to-measure figure, the fig, ax interface.

And the last step — Ana doesn't run Python, Ana receives a PNG:

Into M6's reports/ directory, like the CSVs from 11-03. dpi=150 gives reasonable print quality and bbox_inches="tight" trims dead margins. Important: call savefig before show() — after showing, the figure may come out blank.

When this table falls short: seaborn (elegant statistical charts on top of Matplotlib, in one line what here takes ten) and plotly (interactive charts with zoom and tooltips, perfect for the M10 website) are the natural next stops. Everything learned here — figures, axes, chart types, honesty — transfers as is.

• Forgetting plt.show() in scripts. In Jupyter the figure appears on its own; in a .py without show() the program ends showing nothing. (And savefig goes before show.)
• Reusing the figure by accident. Drawing two charts in a row on the same ax overlays them. Every new figure gets its own fig, ax = plt.subplots().
• Truncating the Y axis on bars. The classic of lying charts: tiny differences look enormous. Bars start at 0; on lines, cropping is acceptable if it's flagged.
• Too many series on one chart. Five crossing lines are spaghetti. Better subplots with one per panel, or highlight one and dim the rest in grey.
• Axes without units. "168 what? Euros, units, visits?" Every report that leaves reports/ must survive without you standing next to it explaining.

1. Draw the monthly evolution of revenue (sum of amount per month) as a line with markers, annotating Sant Jordi, starting from the corresponding 11-03 groupby. Label the axes with units (EUR) and save it to reports/monthly_revenue.png.
2. Make a grouped bar chart with units per title and channel (the 11-03 unstack() table: store 121/38/74/79, web 61/25/47/75). Hint: table.T.plot(kind="bar") does it in one line; interpret the story it tells.
3. The lesson's 2×2 dashboard uses the same color for everything. Modify it so that only the Saturday bar (in the days chart) and the April point (in the monthly line) get an accent color, and the rest stays grey. Hint: bar accepts a list of colors, and you can overlay an ax.plot of a single point.

1. rev = df.groupby(df["date"].dt.month)["amount"].sum()
   fig, ax = plt.subplots(figsize=(8, 4))
   ax.plot(["Jan", "Feb", "Mar", "Apr", "May", "Jun"], rev.values, marker="o")
   ax.annotate("Sant Jordi", xy=("Apr", rev[4]), xytext=("Feb", rev[4] * 0.9),
               arrowprops=dict(arrowstyle="->"))
   ax.set_title("Papyrus — monthly revenue 2026")
   ax.set_xlabel("Month"); ax.set_ylabel("Revenue (EUR)")
   fig.savefig("reports/monthly_revenue.png", dpi=150, bbox_inches="tight")
   plt.show()
   

   The curve traces the units one — peak in April — because the average basket barely changes between months. Confirming that two metrics tell the same story is a finding too.

2. table = df.groupby(["channel", "title"])["units"].sum().unstack()
   ax = table.T.plot(kind="bar", figsize=(8, 4))   # .T: titles on the X axis, one bar per channel
   ax.set_ylabel("Units"); ax.set_title("Sales per title and channel")
   ax.tick_params(axis="x", rotation=0)
   plt.show()
   

   The story: on almost every title the store bar wins... except on The Odyssey, where the web nearly matches the store (75 vs 79) and clearly beats web Quixote. The 11-03 finding, now visible in one shot.

3. colors = ["#9e9e9e"] * 7
   colors[5] = "#d62728"                     # Saturday, index 5
   axs[1, 1].bar(days, day_units, color=colors)
   
   axs[0, 0].plot(months, units, marker="o", color="#9e9e9e")
   axs[0, 0].plot(["Apr"], [168], marker="o", color="#d62728", markersize=10)
   

   Grey mutes the secondary and the accent steers the eye exactly to the two numbers holding up Ana's decision: Saturday and Sant Jordi. That "dim to highlight" is probably the communication trick with the highest return per line of code in the whole lesson.

You now know how to turn Papyrus's numbers into stories: lines for evolution (with the arrow pinned on Sant Jordi), bars for comparing titles and days, histograms to see the shape describe() hides, scatter to suspect relationships — with Faust alone in its expensive corner —, the pie chart out on bail, and the 2×2 dashboard saved as a PNG in reports/ for the back room. And the principle governing it all, Anscombe's legacy: draw before concluding, because summaries hide the shape. That advice is about to become immediately practical: the question still standing — how much stock to order for next Sant Jordi? — isn't answered by describing the past, but by projecting it. Learning patterns from the history to predict what's coming is machine learning, and the module's final lesson does it for real, with scikit-learn, two complete cases, and the honest warnings marketing usually skips.