{
"cells": [
{
"cell_type": "markdown",
"id": "0",
"metadata": {},
"source": [
"---\n",
"title: \"Chapter 14: Matplotlib and Seaborn\"\n",
"---"
]
},
{
"cell_type": "markdown",
"id": "1",
"metadata": {},
"source": [
"[](https://colab.research.google.com/github/sambaiga/ds-mlops-path/blob/main/tutorials/01-python-basics/14-matplotlib.ipynb) [](https://raw.githubusercontent.com/sambaiga/ds-mlops-path/main/tutorials/01-python-basics/14-matplotlib.ipynb)"
]
},
{
"cell_type": "markdown",
"id": "2",
"metadata": {},
"source": [
"You have just finished cleaning `university_analytics.csv`. The head looks right, the dtypes are correct, the nulls are gone. Then your manager asks: *\"What does the score distribution actually look like?\"* You could print quartiles. You could sort and read 2,400 rows. Or you could write three lines of matplotlib and see the entire shape in half a second.\n",
"\n",
"Chapter 7 introduced NumPy arrays as the numerical backbone. This notebook puts those arrays on screen. You will build every standard chart type, compose multi-panel figures, and learn the seaborn shortcut for statistical graphics. Chapter 15 (`15-lets-plot.ipynb`) introduces a different approach entirely: the grammar of graphics.\n",
"\n",
"> Callout markers: [book cover page](../../index.qmd#callout-guide)."
]
},
{
"cell_type": "markdown",
"id": "3",
"metadata": {},
"source": [
"## Python's plotting landscape\n",
"\n",
"That chart needs a library. Python has several, and they make different trade-offs:\n",
"\n",
"| Library | Style | Strengths | Best for |\n",
"| --- | --- | --- | --- |\n",
"| **Matplotlib** ([matplotlib.org](https://matplotlib.org)) | Imperative (OO API) | Total control, publication quality, runs everywhere | Custom figures, fine-grained layout, saving to PNG/PDF/SVG |\n",
"| **Seaborn** ([seaborn.pydata.org](https://seaborn.pydata.org)) | High-level on top of Matplotlib | Statistical plots in one line, beautiful defaults | Distribution plots, pair plots, heatmaps |\n",
"| **Lets-Plot** ([lets-plot.org](https://lets-plot.org)) | Declarative, Grammar of Graphics | Expressive, ggplot2-compatible, interactive-ready | Layered charts, Chapter 15 of this book |\n",
"| **Plotly** ([plotly.com/python](https://plotly.com/python)) | Declarative, interactive | Hover, zoom, dash integration | Dashboards, interactive reports |\n",
"| **Bokeh** ([bokeh.org](https://docs.bokeh.org)) | Declarative, interactive | Streaming, large data | Real-time visualisations |\n",
"| **Altair** ([altair-viz.github.io](https://altair-viz.github.io)) | Declarative, grammar of graphics | Concise, tidy-data native, composable | Exploratory charts, smaller datasets |\n",
"\n",
"This chapter focuses on Matplotlib and Seaborn. Every other library in the list either wraps Matplotlib, exports to it, or assumes you understand it. Matplotlib is the bedrock: learn it once and every other plotting library becomes a set of shortcuts on top of something you already know.\n",
"\n",
"### Already in your environment\n",
"\n",
"Both libraries are in `pyproject.toml`. For a standalone project:\n",
"\n",
"```bash\n",
"uv add matplotlib seaborn\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "4",
"metadata": {},
"source": [
"::: {.callout-note collapse=\"true\" icon=false}\n",
"## Learning objectives\n",
"\n",
"By the end of Chapter 14 you will be able to:\n",
"\n",
"| # | Skill | Covered in |\n",
"|---|---|---|\n",
"| 1 | Explain the Figure/Axes object model and why it matters | Sec. 1 |\n",
"| 2 | Build line, scatter, bar, and histogram charts with the object-oriented API | Sec. 2 |\n",
"| 3 | Lay out and compare multiple Axes in one Figure | Sec. 3 |\n",
"| 4 | Save a figure at the right resolution and format for its destination | Sec. 3 |\n",
"| 5 | Use seaborn for one-line statistical graphics, then keep customising with matplotlib | Sec. 4 |\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "5",
"metadata": {},
"source": [
"## 1. Why visualise? The figure and axes\n",
"\n",
"A table of a thousand exam scores tells you nothing at a glance. A histogram of the same thousand scores tells you the shape of the distribution in about half a second. That is the entire case for visualisation: it trades a small amount of precision for a large amount of immediate understanding, which is exactly what you want before you have decided which question to ask next."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"\n",
"df = pd.read_csv(\"data/university_analytics.csv\")\n",
"final_scores = df[\"final_score\"]\n",
"\n",
"print(f\"mean : {final_scores.mean():.1f}\")\n",
"print(f\"median : {final_scores.median():.1f}\")\n",
"print(f\"std : {final_scores.std():.1f}\")\n",
"# The numbers alone do not tell you whether the distribution is symmetric,\n",
"# has a long tail, or is bimodal. A histogram answers that in one look."
]
},
{
"cell_type": "markdown",
"id": "7",
"metadata": {},
"source": [
"matplotlib has two APIs for building the same chart. The older one, `pyplot` (`plt.plot(...)`), is a state machine: it always draws onto \"whichever figure was most recently touched,\" which is fine for a single quick chart and confusing the moment you need two charts side by side. The **object-oriented API** is explicit instead: you ask for a `Figure` (the whole canvas) and one or more `Axes` (an individual plot inside it), then call methods directly on the `Axes` you want to draw on."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"# The object-oriented pattern you will use for almost every chart in this\n",
"# notebook: ask for a Figure and an Axes, then call methods on the Axes.\n",
"fig, ax = plt.subplots(figsize=(5, 3))\n",
"ax.hist(final_scores, bins=20, color=\"#4477AA\", edgecolor=\"white\")\n",
"ax.set_xlabel(\"Final score\")\n",
"ax.set_ylabel(\"Number of students\")\n",
"ax.set_title(\"Final score distribution\");"
]
},
{
"cell_type": "markdown",
"id": "9",
"metadata": {},
"source": [
"\n",
" Key Concept: Figure vs. Axes
\n",
"A Figure is the whole canvas: the window or page a chart is drawn on, and the thing you save to a file. An Axes is one plot inside that canvas, with its own x-axis, y-axis, title, and data. fig, ax = plt.subplots() gives you one of each. Every method that actually draws data (.plot(), .scatter(), .bar(), .hist()) lives on the Axes, not the Figure.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "10",
"metadata": {},
"source": [
"The dashed boundary below is the one thing in this diagram that has no real line of code behind it: it's just there to make the Figure's own edge visible, since otherwise it's easy to forget it exists at all."
]
},
{
"cell_type": "markdown",
"id": "11",
"metadata": {},
"source": [
"{fig-alt=\"Outer blue-bordered rectangle labeled Figure containing a gray-bordered rectangle labeled Axes with a bar chart inside. Callout annotations point to title, xlabel, ylabel, ticks, and legend.\"}"
]
},
{
"cell_type": "markdown",
"id": "12",
"metadata": {},
"source": [
"\n",
" Common Mistake: mixing plt.plot() and ax.plot()
\n",
"plt.title(\"x\") sets the title of whichever Axes pyplot thinks is \"current\", which silently changes after you create a new subplot. The moment you have more than one Axes, calling plt.xlabel() instead of ax.set_xlabel() is a common way to label the wrong chart. Once you have an ax object, call methods on it directly and skip plt.* entirely.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "13",
"metadata": {},
"source": [
"\n",
" Activity 1: your first figure/axes chart
\n",
"Build a histogram using the object-oriented pattern.
1. Create 500 normally distributed exam scores: scores = np.random.default_rng(42).normal(72, 12, 500).clip(0, 100).
2. Call fig, ax = plt.subplots(figsize=(7, 4)).
3. Plot a histogram with 20 bins: ax.hist(scores, bins=20, color='#0369A1', edgecolor='white').
4. Add a title and x/y labels with ax.set_title(), ax.set_xlabel(), ax.set_ylabel().
5. Add a vertical line at the mean: ax.axvline(scores.mean(), color='#DC2626', lw=2, label='mean').
Expected: a labelled histogram with a red mean line.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "14",
"metadata": {},
"source": [
"## 2. Core chart types\n",
"\n",
"Four chart types cover most of what you will plot day to day. Each answers a different question, and picking the wrong one is the fastest way to make a chart that looks fine but says nothing useful."
]
},
{
"cell_type": "markdown",
"id": "15",
"metadata": {},
"source": [
"\n",
" Key Concept: Match chart type to the question, not the data
\n",
"Each chart type answers one question well and others poorly:
Line: how does a value change over time or sequence?
Scatter: is there a relationship between two continuous variables?
Bar: how do discrete categories compare?
Histogram: what is the distribution of a single variable?
Picking the wrong type is the fastest way to make a chart that looks fine but says nothing.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "16",
"metadata": {},
"outputs": [],
"source": [
"# Three courses share the same Fall track and run across three real\n",
"# cohorts: Fall 2022, Fall 2023, and Fall 2024. Filtering to them turns\n",
"# the 2,400-row platform export into one comparable slice for this section.\n",
"courses = np.array([\"Machine Learning\", \"Data Structures\", \"Python Programming\"])\n",
"semesters = np.array([\"Fall 2022\", \"Fall 2023\", \"Fall 2024\"])\n",
"\n",
"results = df[df[\"course\"].isin(courses) & df[\"semester\"].isin(semesters)].copy()\n",
"course_col = results[\"course\"].to_numpy()\n",
"semester_col = results[\"semester\"].to_numpy()\n",
"final_score = results[\"final_score\"].to_numpy()\n",
"study_hours = results[\"study_hours\"].to_numpy()\n",
"attendance_pct = results[\"attendance_pct\"].to_numpy()\n",
"\n",
"print(f\"rows: {len(results)}\")\n",
"print(f\"courses: {courses}\")"
]
},
{
"cell_type": "markdown",
"id": "17",
"metadata": {},
"source": [
"**Line chart**, for a trend across an ordered sequence. Here, average score per course across three Fall cohorts:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18",
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots(figsize=(5, 3))\n",
"\n",
"for course in courses:\n",
" course_mask = course_col == course\n",
" means = [final_score[course_mask & (semester_col == s)].mean() for s in semesters]\n",
" ax.plot(semesters, means, marker=\"o\", label=course)\n",
"\n",
"ax.set_ylabel(\"Average final score\")\n",
"ax.set_title(\"Average score by course, Fall 2022 to Fall 2024\")\n",
"ax.legend();"
]
},
{
"cell_type": "markdown",
"id": "19",
"metadata": {},
"source": [
"**Scatter plot**, for the relationship between two continuous variables. Here, study hours against final score:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "20",
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots(figsize=(5, 3))\n",
"ax.scatter(study_hours, final_score, alpha=0.4, color=\"#4477AA\")\n",
"ax.set_xlabel(\"Study hours\")\n",
"ax.set_ylabel(\"Final score\")\n",
"ax.set_title(\"Study hours vs. final score\");"
]
},
{
"cell_type": "markdown",
"id": "21",
"metadata": {},
"source": [
"\n",
" Pro Tip: Add an infinite reference line with ax.axline()
\n",
"ax.axline(xy1, slope=m) draws an infinite line through point xy1 at gradient m. Unlike ax.plot(), which clips to the data you provide, axline always extends to the full axis range even when the axes limits change later. Use it to add a y = x diagonal (slope 1 through the origin) on any scatter of two variables that should ideally be equal.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "22",
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots(figsize=(5, 5))\n",
"ax.scatter(study_hours, final_score, alpha=0.2, s=8, color=\"#38BDF8\")\n",
"ax.axline((0, 0), slope=4, color=\"#DC2626\", linewidth=1.5, linestyle=\"--\", label=\"reference slope\")\n",
"ax.set_xlabel(\"Study Hours\")\n",
"ax.set_ylabel(\"Final Score\")\n",
"ax.set_title(\"Are high study hours linked to higher scores?\")\n",
"ax.legend()\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "23",
"metadata": {},
"source": [
"**Bar chart**, for comparing a single number across categories. Here, average score per course:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "24",
"metadata": {},
"outputs": [],
"source": [
"course_means = [final_score[course_col == c].mean() for c in courses]\n",
"\n",
"fig, ax = plt.subplots(figsize=(5, 3))\n",
"ax.bar(courses, course_means, color=[\"#4477AA\", \"#EE6677\", \"#228833\"])\n",
"ax.set_ylabel(\"Average final score\")\n",
"ax.set_title(\"Average score by course\")\n",
"ax.tick_params(axis=\"x\", labelrotation=15);"
]
},
{
"cell_type": "markdown",
"id": "25",
"metadata": {},
"source": [
"\n",
"
Pro Tip: Use ax.bar_label() to annotate bar values automatically\n",
"Adding the numeric value above each bar used to mean a manual loop calling
ax.text() for each rectangle. Since matplotlib 3.4,
ax.bar_label(container) does it in one line.
ax.bar() returns a
BarContainer; pass it to
bar_label and optionally format the numbers with
fmt:\n",
"\n",
"
bars = ax.bar(courses, course_means, color=[\"#4477AA\", \"#EE6677\", \"#228833\"])\n",
"ax.bar_label(bars, fmt=\"{:.1f}\", padding=3)\n",
"\n",
"
fmt accepts a format string (applied to each value) or a
labels keyword with an explicit list.
padding pushes the text a few points above the bar top.\n",
"
\n",
"
Activity 2: attendance histogram\n",
"\n",
"Plot a histogram of
attendance_pct with 15 bins, label both axes, and give it a title. Use the object-oriented pattern:
fig, ax = plt.subplots(), then call methods on
ax.\n",
"
fig, ax = plt.subplots(figsize=(5, 3))\n",
"ax.hist(attendance_pct, bins=15, ...)\n",
"# expect a rough bell shape centred around 75%, with a scattering\n",
"# of students down near 30%\n",
"
\n",
" Pro Tip: A trailing bare fig displays the figure in Jupyter
\n",
"Jupyter displays the last expression in a cell automatically, the same way it prints a bare x on its own line. Ending a plotting cell with fig (or letting ax.hist(...) be the last call) shows the chart without an explicit plt.show(), which you only need outside a notebook.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "29",
"metadata": {},
"source": [
"## 3. Multiple axes and saving figures\n",
"\n",
"Real analysis rarely stops at one chart. `plt.subplots(nrows, ncols)` returns a whole grid of `Axes` at once, as a NumPy array, so you can loop over it the same way you looped over any other array in Chapter 6."
]
},
{
"cell_type": "markdown",
"id": "30",
"metadata": {},
"source": [
"\n",
" Key Concept: subplots returns a NumPy array of axes: loop with .flat
\n",
"fig, axes = plt.subplots(2, 3) gives you a (2, 3) NumPy array of Axes objects. Use axes.flat to iterate over all six in order, regardless of grid shape. sharey=True links the y-axis scale across all panels so comparisons stay honest.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "31",
"metadata": {},
"outputs": [],
"source": [
"fig, axes = plt.subplots(1, 3, figsize=(11, 3), sharey=True)\n",
"\n",
"for ax, course in zip(axes.flat, courses, strict=True):\n",
" course_scores = final_score[course_col == course]\n",
" ax.hist(course_scores, bins=15, color=\"#4477AA\", edgecolor=\"white\")\n",
" ax.set_title(course, fontsize=10)\n",
" ax.set_xlabel(\"Final score\")\n",
"\n",
"axes[0].set_ylabel(\"Number of students\")\n",
"fig.suptitle(\"Score distribution per course\");"
]
},
{
"cell_type": "markdown",
"id": "32",
"metadata": {},
"source": [
"`axes.flat` works regardless of the grid shape: a `2x2` grid of `Axes` is a 2D array, but `.flat` always gives you a flat iterator over all of them, in row-major order. `sharey=True` forces every Axes in the grid to use the same y-axis range, which is what makes the three histograms above honestly comparable instead of each rescaled to its own data."
]
},
{
"cell_type": "markdown",
"id": "33",
"metadata": {},
"source": [
"\n",
" Common Mistake: Comparing histograms with different y-axis scales
\n",
"Without sharey=True, matplotlib autoscales each Axes to its own data. Three histograms that look like they have the same number of students can actually have wildly different counts, because each y-axis silently uses a different scale. Whenever you put similar charts side by side for comparison, force a shared scale.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "34",
"metadata": {},
"source": [
"Saving a figure has two choices that matter: resolution (`dpi`, dots per inch) and file format. A raster format (PNG) at low `dpi` looks blurry when scaled up; a vector format (SVG or PDF) stays sharp at any size because it stores shapes, not pixels. Call `fig.tight_layout()` before saving to close any gaps between subplots and prevent axis labels from being clipped:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "35",
"metadata": {},
"outputs": [],
"source": [
"from pathlib import Path\n",
"\n",
"output_dir = Path(\"tmp_plots\")\n",
"output_dir.mkdir(exist_ok=True)\n",
"\n",
"fig, ax = plt.subplots(figsize=(5, 3))\n",
"ax.hist(final_scores, bins=20, color=\"#4477AA\", edgecolor=\"white\")\n",
"ax.set_title(\"Final score distribution\")\n",
"fig.tight_layout()\n",
"\n",
"# PNG: fine for slides and notebooks, blurry if you zoom in or print large\n",
"fig.savefig(output_dir / \"scores.png\", dpi=150, bbox_inches=\"tight\")\n",
"# SVG: vector format, stays crisp at any size, the right choice for reports\n",
"fig.savefig(output_dir / \"scores.svg\", bbox_inches=\"tight\")\n",
"\n",
"print(sorted(p.name for p in output_dir.iterdir()))\n",
"\n",
"import shutil\n",
"\n",
"shutil.rmtree(output_dir)"
]
},
{
"cell_type": "markdown",
"id": "36",
"metadata": {},
"source": [
"\n",
" Pro Tip: Default to vector formats for anything that gets printed or zoomed
\n",
"PNG and JPEG store a fixed grid of pixels: stretch them and they blur. SVG and PDF store the actual shapes and text, so they render sharp at any zoom level or print size. Save PNG for quick previews and web thumbnails; save SVG or PDF for anything that ends up in a report, slide deck, or paper.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "37",
"metadata": {},
"source": [
"\n",
" Activity 3: three-panel score comparison
\n",
"Create a 1x3 grid comparing scores across three groups.
1. Create three arrays: maths = np.array([78,82,91,65,88,74,95,61,83,79]), stats = np.array([72,88,65,91,77,83,69,94,71,86]), prog = np.array([85,79,92,68,88,76,93,71,84,90]).
2. Call fig, axes = plt.subplots(1, 3, figsize=(11, 3.5), sharey=True).
3. Loop over zip(axes.flat, ['Maths','Stats','Programming'], [maths, stats, prog]) and plot a histogram on each axis.
4. Set a title on each axis and a shared y-label on the leftmost axis only.
Expected: three side-by-side histograms sharing the same y-scale.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "38",
"metadata": {},
"source": [
"## 4. Seaborn: statistical graphics in one line\n",
"\n",
"Seaborn is built directly on matplotlib. It does not replace anything from Sections 1-3: it adds a layer of functions that know how to take a whole DataFrame, split it by a category, color each group, and draw a legend, all in a single call. Reaching for seaborn first whenever your chart needs grouping or a statistical summary saves a genuine amount of code."
]
},
{
"cell_type": "markdown",
"id": "39",
"metadata": {},
"source": [
"Seaborn expects **tidy data**: one row per observation, one column per variable. That is exactly the shape `results` is already in from Section 2, so there is nothing to build: reuse it directly."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "40",
"metadata": {},
"outputs": [],
"source": [
"results.head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "41",
"metadata": {},
"outputs": [],
"source": [
"import seaborn as sns\n",
"\n",
"fig, ax = plt.subplots(figsize=(6, 3.5))\n",
"sns.histplot(data=results, x=\"final_score\", hue=\"course\", kde=True, ax=ax)\n",
"ax.set_title(\"Final score distribution by course\");"
]
},
{
"cell_type": "markdown",
"id": "42",
"metadata": {},
"source": [
"\n",
" Key Concept: Seaborn returns a matplotlib Axes
\n",
"sns.histplot(..., ax=ax) draws onto the Axes you pass it and returns that same Axes. Nothing from Sections 1-3 is wasted: every ax.set_title(), ax.set_xlabel(), or fig.savefig() you already know still works on a seaborn chart. Seaborn only replaces the part where you would otherwise have looped over groups and called ax.hist() once per group yourself.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "43",
"metadata": {},
"source": [
"`hue` is seaborn's primary grouping parameter: pass a column name and seaborn splits the data by that column, assigns each group a colour from its default palette, and draws a legend automatically. `palette` overrides those colours, accepting a named seaborn palette (`\"tab10\"`, `\"Set2\"`) or a list of hex codes. `style` (available in `sns.lineplot` and `sns.scatterplot`) adds a second visual channel by varying the marker shape or line style per group, which helps when a chart may be viewed in greyscale."
]
},
{
"cell_type": "markdown",
"id": "44",
"metadata": {},
"source": [
"`sns.boxplot` summarises a whole distribution (median, quartiles, outliers) per category in one call, the kind of comparison that would take a loop and several `ax.hist()` calls in raw matplotlib:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "45",
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots(figsize=(6, 3.5))\n",
"sns.boxplot(data=results, x=\"course\", y=\"final_score\", hue=\"semester\", ax=ax)\n",
"ax.set_title(\"Final score by course and semester\");"
]
},
{
"cell_type": "markdown",
"id": "46",
"metadata": {},
"source": [
"`sns.violinplot()` shows the full shape of the distribution on both sides of a central axis, not just the five-number summary a boxplot gives. Use it when you suspect a distribution is skewed or has more than one peak in a way the box would hide:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "47",
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots(figsize=(6, 3.5))\n",
"sns.violinplot(data=results, x=\"course\", y=\"final_score\", hue=\"semester\", ax=ax)\n",
"ax.set_title(\"Final score distribution by course and semester\");"
]
},
{
"cell_type": "markdown",
"id": "48",
"metadata": {},
"source": [
"`sns.heatmap` is the standard way to visualise a correlation matrix. Pass it `results[numeric_cols].corr()`, a small DataFrame seaborn happily turns into a colour grid with the actual numbers annotated:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "49",
"metadata": {},
"outputs": [],
"source": [
"numeric_cols = [\"final_score\", \"study_hours\", \"attendance_pct\"]\n",
"corr = results[numeric_cols].corr()\n",
"\n",
"fig, ax = plt.subplots(figsize=(4, 3.5))\n",
"sns.heatmap(corr, annot=True, fmt=\".2f\", cmap=\"coolwarm\", center=0, ax=ax)\n",
"ax.set_title(\"Feature correlation\");"
]
},
{
"cell_type": "markdown",
"id": "50",
"metadata": {},
"source": [
"\n",
"
Activity 4: compare study habits across courses\n",
"\n",
"Use
sns.boxplot to compare
study_hours across the three courses (x-axis:
course, y-axis:
study_hours), then add a title with
ax.set_title().\n",
"
fig, ax = plt.subplots(figsize=(6, 3.5))\n",
"sns.boxplot(data=results, x=\"course\", y=\"study_hours\", ax=ax)\n",
"ax.set_title(...)\n",
"
Hint: This is almost identical to the boxplot above, just with a different y-axis and no
hue.\n",
"
\n",
" Pro Tip: Exploratory charts and presentation charts have different goals
\n",
"Seaborn's defaults are optimised for exploratory use: fast, readable charts that help you understand the data before you have decided what question to ask. A presentation chart, one headed for a report or a slide deck, needs deliberate title wording, axis labels in the reader's language, and a colour palette that matches the project's house style. Chapter 16 covers that transition.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "53",
"metadata": {},
"source": [
"\n",
"
Pro Tip: seaborn 0.12+ ships a declarative objects API alongside the classic functions\n",
"Seaborn 0.12 introduced
seaborn.objects (
so.Plot()), a fully composable layer built on the same grammar-of-graphics ideas as Chapter 15's Lets-Plot. It's worth knowing even if you do not switch immediately:\n",
"\n",
"
import seaborn.objects as so\n",
"\n",
"(\n",
" so.Plot(results, x=\"study_hours\", y=\"final_score\", color=\"course\")\n",
" .add(so.Dot(alpha=0.4))\n",
" .label(title=\"Study hours vs. final score\")\n",
")\n",
"\n",
"
so.Plot() is lazy (nothing renders until you call
.show() or display it), composable (chain
.add() calls to layer marks), and consistent with the Lets-Plot mental model from Chapter 15. For exploratory work the classic
sns.* functions are still faster to type;
so.Plot() pays off when a chart needs several layers or custom marks.\n",
"
\n",
" Key Concept: Mosaic layouts use repeated letters to span cells
\n",
"The mosaic [[\"hist\", \"hist\"], [\"scatter\", \"box\"]] means: row 1 has one panel called \"hist\" spanning two columns; row 2 has \"scatter\" and \"box\" side by side. Repeated letters span multiple cells. Reference each panel by name via axes[\"hist\"]. The layout reads like ASCII art, which makes it easy to reason about before you see the output.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "59",
"metadata": {},
"source": [
"## Capstone: a three-panel course report\n",
"\n",
"Combine everything from this notebook into one Figure with three Axes side by side: a histogram of scores for one course, a scatter of study hours against score for the same course, and a bar chart comparing average scores across all three courses. This is the shape of report you would actually hand to a department head."
]
},
{
"cell_type": "markdown",
"id": "60",
"metadata": {},
"source": [
"\n",
"
Capstone exercise: three-panel report\n",
"\n",
"Build a
(1, 3) grid of Axes:\n",
"
\n",
"- Axes 0: histogram of
final_score for \"Machine Learning\" only \n",
"- Axes 1: scatter of
study_hours vs. final_score, same course only \n",
"- Axes 2: bar chart of average
final_score per course (all courses) \n",
"
\n",
"Give the Figure an overall title with
fig.suptitle() and each Axes its own
ax.set_title().
Hint: Filter with
ml_mask = results[\"course\"] == \"Machine Learning\", then index
results[ml_mask] for the first two panels.\n",
"