{
"cells": [
{
"cell_type": "markdown",
"id": "0",
"metadata": {},
"source": [
"---\n",
"title: \"Chapter 15: Grammar of graphics with lets-plot\"\n",
"---"
]
},
{
"cell_type": "markdown",
"id": "1",
"metadata": {},
"source": [
"[](https://colab.research.google.com/github/sambaiga/ds-mlops-path/blob/main/tutorials/01-python-basics/15-lets-plot.ipynb) [](https://raw.githubusercontent.com/sambaiga/ds-mlops-path/main/tutorials/01-python-basics/15-lets-plot.ipynb)"
]
},
{
"cell_type": "markdown",
"id": "2",
"metadata": {},
"source": [
"You want to colour the scatter points by course. In matplotlib that means adding `c=results['course']` to `ax.scatter()`, but scatter expects a numeric array, not strings, so you need a colour map. The legend does not appear automatically, so you add `ax.legend()`. Now you manage the colour assignment yourself. Adding one data dimension turned a three-line chart into fifteen lines of housekeeping.\n",
"\n",
"The grammar of graphics solves this differently. You describe *what the data means* and let the library handle the rendering. `aes(color='course')` says 'colour represents course': the library picks the palette, maps it, and adds the legend automatically. The trend line is just `+ geom_smooth()`: one more layer, no manual computation.\n",
"\n",
"The tool is lets-plot, a Python port of R's ggplot2. By the end you will build any chart by composing three parts: data, aesthetics, and geometry. Chapter 16 (`16-data-storytelling.ipynb`) then applies a house style to both libraries.\n",
"\n",
"> Callout markers: [book cover page](../../index.qmd#callout-guide)."
]
},
{
"cell_type": "markdown",
"id": "3",
"metadata": {},
"source": [
"## Why the grammar of graphics?\n",
"\n",
"There is another way to think about it. A chart isn't a list of drawing commands: it's a **mapping** from data columns to visual channels (position, colour, shape, size). State that mapping once, and the library figures out how to draw it. Add a layer (a trend line, a rug, a label) and you extend the mapping rather than calling a new drawing function. This is the Grammar of Graphics, introduced by Leland Wilkinson in 1999 and popularised by Hadley Wickham's **ggplot2** for R.\n",
"\n",
"**Lets-Plot** ([lets-plot.org](https://lets-plot.org)) is JetBrains' Python implementation of the same grammar. Its API mirrors ggplot2 so closely that R users can read Lets-Plot code without a translation guide. It renders to HTML in Jupyter, to PNG for reports, and (in its Pro edition) to interactive Datalore dashboards.\n",
"\n",
"### Alternatives that use the same grammar\n",
"\n",
"| Library | Language | Notes |\n",
"| --- | --- | --- |\n",
"| **ggplot2** ([ggplot2.tidyverse.org](https://ggplot2.tidyverse.org)) | R | The original; Lets-Plot mirrors it deliberately |\n",
"| **plotnine** ([plotnine.org](https://plotnine.org)) | Python | ggplot2 port; similar API, Matplotlib backend |\n",
"| **Lets-Plot** ([lets-plot.org](https://lets-plot.org)) | Python / Kotlin | HTML-first output, fast, maintained by JetBrains |\n",
"| **Vega-Altair** ([altair-viz.github.io](https://altair-viz.github.io)) | Python | Different grammar (Vega-Lite), interactive |\n",
"\n",
"### Already in your environment\n",
"\n",
"```bash\n",
"uv add lets-plot # for a standalone project\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "4",
"metadata": {},
"source": [
"::: {.callout-note collapse=\"true\" icon=false}\n",
"## Learning objectives\n",
"\n",
"By the end of Chapter 15 you will be able to:\n",
"\n",
"| # | Skill | Covered in |\n",
"|---|---|---|\n",
"| 1 | Explain the difference between declarative and imperative plotting | Sec. 1 |\n",
"| 2 | Build a chart from `ggplot()`, `aes()`, and a `geom_*()` | Sec. 2 |\n",
"| 3 | Distinguish mapping a variable from setting a fixed value | Sec. 3 |\n",
"| 4 | Layer a statistical summary on top of raw data | Sec. 4 |\n",
"| 5 | Facet one chart into many panels instead of looping over subplots | Sec. 5 |\n",
"| 6 | Add titles, axis labels, and control colours with `labs()` and scale functions | Sec. 6 |\n",
"| 7 | Name stat, position, and coord as grammar components, not one-off options | Sec. 7 |\n",
":::\n"
]
},
{
"cell_type": "markdown",
"id": "5",
"metadata": {},
"source": [
"## 1. Declarative vs. imperative\n",
"\n",
"In Chapter 14, building a scatter plot meant calling `ax.scatter()` directly: you were the one deciding which function draws which shape. The grammar of graphics flips this around. You describe **what the data means** (this column is the x position, this column is the colour) and the library decides how to draw it. The same description works whether you add one point or one million, and stays valid even if you later change the chart type entirely."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import LetsPlot\n",
"\n",
"LetsPlot.setup_html()"
]
},
{
"cell_type": "markdown",
"id": "7",
"metadata": {},
"source": [
"Rebuild the same dataset from Chapter 14: final scores across three courses and three Fall cohorts."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8",
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"\n",
"df = pd.read_csv(\"data/university_analytics.csv\")\n",
"\n",
"# Three courses share the same Fall track and run across three real\n",
"# cohorts: Fall 2022, Fall 2023, and Fall 2024.\n",
"courses = [\"Machine Learning\", \"Data Structures\", \"Python Programming\"]\n",
"semesters = [\"Fall 2022\", \"Fall 2023\", \"Fall 2024\"]\n",
"\n",
"results = df[df[\"course\"].isin(courses) & df[\"semester\"].isin(semesters)].copy()\n",
"results.head()"
]
},
{
"cell_type": "markdown",
"id": "9",
"metadata": {},
"source": [
"Here is the Chapter 14 scatter plot (study hours vs. final score) again, this time declaratively. `ggsize(width, height)` sets a fixed pixel size instead of leaving it to the browser: every chart in this notebook uses the same `500, 320` so they sit consistently in the page:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "10",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import aes, geom_point, ggplot, ggsize\n",
"\n",
"ggplot(results, aes(x=\"study_hours\", y=\"final_score\")) + geom_point(alpha=0.4) + ggsize(500, 320)"
]
},
{
"cell_type": "markdown",
"id": "11",
"metadata": {},
"source": [
"\n",
" Key Concept: The Grammar of Graphics
\n",
"Every lets-plot chart is built from the same three pieces, combined with +: ggplot(data, aes(...)) declares the dataset and which columns map to which visual property, and one or more geom_*() layers say what shape to draw with that mapping. Change the geom_*() and the same aes() mapping produces a completely different chart type, often without touching anything else.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "12",
"metadata": {},
"source": [
"\n",
" Activity 1 - Rewrite a Scatter Plot Declaratively
\n",
"Take Chapter 14's matplotlib scatter and express it in three lets-plot layers.
Setup: reuse the results DataFrame from this notebook.
1. Write ggplot(results, aes(x='study_hours', y='final_score')).
2. Add + geom_point(alpha=0.5).
3. Add + geom_smooth(se=False) for a trend line.
4. Compare: how many lines did the matplotlib version take for the same result?
Expected: scatter with trend line in 3 lines of grammar.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "13",
"metadata": {},
"source": [
"## 2. The grammar: `ggplot`, `aes`, `geom`\n",
"\n",
"`aes()` (short for \"aesthetics\") maps DataFrame columns to visual properties: `x`, `y`, `color`, `fill`, `size`. The `geom_*()` you add decides what shape represents each row. Swapping `geom_point()` for `geom_line()` or `geom_bar()` is often the only change needed to turn one chart type into another:"
]
},
{
"cell_type": "markdown",
"id": "14",
"metadata": {},
"source": [
"\n",
" Key Concept: Three parts make every chart: ggplot, aes, geom
\n",
"ggplot(data, aes(...)) owns the data and the default aesthetic mappings. aes() maps DataFrame columns to visual channels (x, y, color, size). geom_*() decides the shape (point, line, bar, histogram). Every chart you build in lets-plot is some combination of exactly these three.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "15",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import coord_flip, geom_bar, geom_lollipop, scale_y_continuous\n",
"\n",
"course_means = results.groupby(\"course\", as_index=False)[\"final_score\"].mean()\n",
"\n",
"ggplot(course_means, aes(x=\"course\", y=\"final_score\")) + geom_bar(stat=\"identity\", fill=\"#4477AA\") + ggsize(500, 320)"
]
},
{
"cell_type": "markdown",
"id": "16",
"metadata": {},
"source": [
"`stat=\"identity\"` tells `geom_bar()` to plot the `final_score` column exactly as given, rather than its default behaviour of counting rows per category. Compare this to Chapter 14's bar chart: the data preparation (`groupby().mean()`) is identical, only the drawing step changed shape."
]
},
{
"cell_type": "markdown",
"id": "17",
"metadata": {},
"source": [
"`position=\"dodge\"` places bars for each group side by side instead of stacking them, useful when you want to compare values across two grouping variables at once. The data needs a category column on `x` and a group column on `fill`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18",
"metadata": {},
"outputs": [],
"source": [
"course_semester_means = results.groupby([\"course\", \"semester\"], as_index=False)[\"final_score\"].mean()\n",
"\n",
"(\n",
" ggplot(course_semester_means, aes(x=\"course\", y=\"final_score\", fill=\"semester\"))\n",
" + geom_bar(stat=\"identity\", position=\"dodge\")\n",
" + ggsize(500, 320)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "19",
"metadata": {},
"source": [
"\n",
"
Activity 2 - Histogram, Declaratively\n",
"\n",
"Rebuild the Chapter 14 histogram of
final_score using
geom_histogram(). Map
x=\"final_score\" in
aes(), and pass
bins=20 to
geom_histogram().\n",
"
ggplot(results, aes(x=\"final_score\")) + geom_histogram(bins=20, fill=\"#4477AA\")
\n",
"
\n",
" Pro Tip: Use geom_lollipop() to reduce ink on ranked comparisons
\n",
"For ranked comparisons with many categories, lollipop charts reduce ink without losing information. Replace geom_bar() with geom_lollipop(): it draws a dot at the value and a thin stem from the baseline, making individual values easier to read when bars would crowd together.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "22",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import labs\n",
"\n",
"pass_rate_by_course = (\n",
" results.groupby(\"course\")[\"final_score\"]\n",
" .apply(lambda x: (x >= 60).mean())\n",
" .reset_index()\n",
" .rename(columns={\"final_score\": \"pass_rate\"})\n",
" .sort_values(\"pass_rate\")\n",
")\n",
"\n",
"# Preserve sort order as a categorical so lets-plot respects it on the axis\n",
"# pandas 3 uses StringDtype by default, which lets-plot cannot introspect;\n",
"# pd.Index(..., dtype=object) keeps categories as plain numpy object dtype\n",
"_courses = pass_rate_by_course[\"course\"].tolist()\n",
"pass_rate_by_course = pass_rate_by_course.assign(\n",
" course=pd.Categorical(\n",
" _courses,\n",
" categories=pd.Index(_courses, dtype=object),\n",
" ordered=True,\n",
" )\n",
")\n",
"\n",
"(\n",
" ggplot(pass_rate_by_course, aes(x=\"course\", y=\"pass_rate\"))\n",
" + geom_lollipop(size=4, color=\"#0369A1\")\n",
" + coord_flip()\n",
" + scale_y_continuous(format=\".0%\")\n",
" + labs(title=\"Pass Rate by Course\", x=\"\", y=\"Pass Rate\")\n",
" + ggsize(500, 320)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "23",
"metadata": {},
"source": [
"\n",
" Activity 3 - Bar Chart from a Lollipop Chart
\n",
"Confirm what geom_lollipop() bought you by comparing it against the bar chart it replaced.
1. Take the pass-rate chart above.
2. Replace geom_lollipop(size=4, color=\"#0369A1\") with geom_bar(stat=\"identity\", fill=\"#0369A1\").
3. Compare: with three categories on the axis, does the bar or the lollipop version make the ranking easier to read?
Expected: the same ranking, with less visual weight in the lollipop version.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "24",
"metadata": {},
"outputs": [],
"source": [
"# TODO: replace geom_lollipop with geom_bar(stat=\"identity\") and compare\n",
"..."
]
},
{
"cell_type": "markdown",
"id": "25",
"metadata": {},
"source": [
"## 3. Mapping vs. setting\n",
"\n",
"`aes(color=\"course\")` **maps** the `course` column to colour: each course gets its own colour, chosen automatically, with a legend. `color=\"#4477AA\"` **sets** every point to the exact same fixed colour, with no legend, because there is nothing left to distinguish. Confusing the two is the single most common mistake when learning any grammar of graphics, in Python or R:"
]
},
{
"cell_type": "markdown",
"id": "26",
"metadata": {},
"source": [
"\n",
" Key Concept: Mapping encodes data; Setting hardcodes a constant
\n",
"aes(color='course') maps the course column to colour: the library assigns one colour per unique value and generates the legend automatically. geom_point(color='#0369A1') sets the colour to a fixed value for all points. Never put a constant inside aes(): that is the most common lets-plot mistake.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27",
"metadata": {},
"outputs": [],
"source": [
"# Mapping: course determines colour, one colour per course, with a legend\n",
"ggplot(results, aes(x=\"study_hours\", y=\"final_score\", color=\"course\")) + geom_point(alpha=0.6) + ggsize(500, 320)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28",
"metadata": {},
"outputs": [],
"source": [
"# Setting: every point is the same fixed colour, no legend needed\n",
"ggplot(results, aes(x=\"study_hours\", y=\"final_score\")) + geom_point(color=\"#4477AA\", alpha=0.6) + ggsize(500, 320)"
]
},
{
"cell_type": "markdown",
"id": "29",
"metadata": {},
"source": [
"\n",
" Common Mistake: Putting a fixed value inside aes()
\n",
"aes(color=\"#4477AA\") tries to map the literal string \"#4477AA\" as if it were a column name. Lets-plot will either error or, worse, silently treat it as a constant category and draw a one-entry legend that says #4477AA. A fixed value is a setting and belongs as a plain keyword argument to the geom_*(), outside aes(). A column name that should vary per row is a mapping and belongs inside aes().\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "30",
"metadata": {},
"source": [
"\n",
" Activity 4 - Mapping vs Setting in Practice
\n",
"Feel the difference by trying both on the same chart.
1. Build a scatter of study_hours vs final_score where color is mapped to 'semester'.
2. Now remove the mapping and instead set geom_point(color='#0369A1').
3. Observe: the mapped version gets a legend; the set version does not.
4. Try placing '#0369A1' inside aes(color='#0369A1') and note what goes wrong.
Expected: mapping creates a legend; setting applies one fixed colour.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "31",
"metadata": {},
"source": [
"## 4. Layering: raw data and a statistical summary together\n",
"\n",
"Because every `geom_*()` is its own layer, you can stack a raw-data layer and a computed-summary layer on the same `aes()` mapping. `geom_smooth()` fits a trend line to the data it's given, with a shaded confidence band, entirely declaratively:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "32",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import geom_smooth\n",
"\n",
"(\n",
" ggplot(results, aes(x=\"study_hours\", y=\"final_score\"))\n",
" + geom_point(alpha=0.3, color=\"#4477AA\")\n",
" + geom_smooth(color=\"#EE6677\", se=True)\n",
" + ggsize(500, 320)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "33",
"metadata": {},
"source": [
"`geom_smooth()` uses a LOESS (locally weighted) smoother by default, which follows local curves in the data. Pass `method='lm'` when you want a straight regression line instead; `se=True` shows the confidence band either way, though the LOESS smoother needs `statsmodels` installed and the linear one does not."
]
},
{
"cell_type": "markdown",
"id": "34",
"metadata": {},
"source": [
"Lets-Plot charts rendered in a Jupyter notebook are interactive by default: hovering over a data point shows a tooltip with the underlying values. The `layer_tooltips()` API lets you control exactly which fields appear and how they are labelled."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "35",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import layer_tooltips\n",
"\n",
"(\n",
" ggplot(df.sample(300, random_state=42), aes(x=\"midterm_score\", y=\"final_score\", color=\"program\"))\n",
" + geom_point(\n",
" tooltips=layer_tooltips()\n",
" .line(\"Student @student_id\")\n",
" .line(\"Program: @program\")\n",
" .line(\"Midterm: @midterm_score\")\n",
" .line(\"Final: @final_score\"),\n",
" size=3,\n",
" alpha=0.7,\n",
" )\n",
" + labs(title=\"Score Correlation by Program\", x=\"Midterm\", y=\"Final\")\n",
" + ggsize(500, 320)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "36",
"metadata": {},
"source": [
"`layer_tooltips().line('@col')` renders each `.line()` call as one row in the hover tooltip, with `@col` substituting the column value at that point. Omit `layer_tooltips()` entirely to fall back to the default, which shows every mapped column."
]
},
{
"cell_type": "markdown",
"id": "37",
"metadata": {},
"source": [
"`geom_density()` is the smooth-curve equivalent of a histogram, useful when comparing several distributions that would otherwise overlap into an unreadable stack of bars:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "38",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import geom_density\n",
"\n",
"ggplot(results, aes(x=\"final_score\", fill=\"course\")) + geom_density(alpha=0.4) + ggsize(500, 320)"
]
},
{
"cell_type": "markdown",
"id": "39",
"metadata": {},
"source": [
"`geom_boxplot()` summarises a distribution as median, quartiles, and outliers per group, the declarative equivalent of Chapter 14's `sns.boxplot()`. Because it's just another `geom_*()`, it composes with `aes()` and faceting exactly like any other layer:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "40",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import geom_boxplot\n",
"\n",
"ggplot(results, aes(x=\"course\", y=\"final_score\", fill=\"course\")) + geom_boxplot(alpha=0.7) + ggsize(500, 320)"
]
},
{
"cell_type": "markdown",
"id": "41",
"metadata": {},
"source": [
"A boxplot gives you five numbers: minimum, first quartile, median, third quartile, and maximum. Swap `geom_boxplot()` for `geom_violin()` when you need the full density shape instead: a violin reveals skew or multiple peaks that a box hides, and the `aes()` mapping stays identical."
]
},
{
"cell_type": "markdown",
"id": "42",
"metadata": {},
"source": [
"\n",
" Key Concept: Layers compose in the order you add them
\n",
"geom_point() + geom_smooth() draws points first, then the trend line on top. Reversing the order draws the line first and the points on top of it. This matters most when a layer has a solid fill that would otherwise hide whatever was drawn before it.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "43",
"metadata": {},
"source": [
"\n",
"
Pro Tip: Add marginal distribution plots with ggmarginal()\n",
"Lets-Plot's
ggmarginal() wraps any scatter plot with histograms or density curves along the x and y margins, letting you see both the bivariate relationship and the individual distributions without a separate figure:\n",
"\n",
"
from lets_plot import ggmarginal\n",
"\n",
"p = (\n",
" ggplot(results, aes(x=\"study_hours\", y=\"final_score\", color=\"course\"))\n",
" + geom_point(alpha=0.4)\n",
" + geom_smooth(method=\"lm\", se=False)\n",
")\n",
"ggmarginal(p, type=\"density\")\n",
"\n",
"
type accepts
\"density\" (KDE curves),
\"histogram\", or
\"boxplot\". The marginals automatically inherit the
color mapping so each course gets its own density curve.\n",
"
\n",
" Activity 5 - Layer a Raw Scatter with a Density Contour
\n",
"Stack two geoms to show individual points and their density together.
1. Start with ggplot(results, aes(x='study_hours', y='final_score')).
2. Add + geom_point(alpha=0.3, size=2).
3. Add + geom_density2d(color='#DC2626') as a second layer.
4. Add a trend line: + geom_smooth(se=True, color='#0369A1').
5. Add tooltips: + geom_point(tooltips=layer_tooltips().line('score: @final_score')).
Expected: three layers compose: points, contour lines, and trend band.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "45",
"metadata": {},
"source": [
"## 5. Faceting: one plot, many panels\n",
"\n",
"Chapter 14's three-panel histogram needed a manual loop over `axes.flat`, plus `sharey=True` to keep the comparison fair. `facet_wrap()` does both in one line, and **shares scales across panels by default**, the opposite of matplotlib's default and exactly what you want for a fair comparison:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "46",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import facet_wrap, geom_histogram, ggsize\n",
"\n",
"(\n",
" ggplot(results, aes(x=\"final_score\"))\n",
" + geom_histogram(bins=15, fill=\"#4477AA\")\n",
" + facet_wrap(facets=\"course\")\n",
" + ggsize(700, 250)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "47",
"metadata": {},
"source": [
"\n",
" Key Concept: Faceting replaces a loop with a declaration
\n",
"facet_wrap(facets=\"course\") splits the data by the course column and draws one panel per group, using the exact same aes() and geom_*() for every panel. There is no loop to write and no risk of accidentally giving one panel a different scale than the others, the bug from Chapter 14's Common Mistake callout. Add a second facet variable with facet_grid() for a full grid of panels.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "48",
"metadata": {},
"source": [
"When you have two grouping variables, `facet_grid()` builds a full grid of panels: one row per level of one variable and one column per level of the other. For this dataset, rows are semesters and columns are courses:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "49",
"metadata": {},
"outputs": [],
"source": [
"from lets_plot import facet_grid\n",
"\n",
"(\n",
" ggplot(results, aes(x=\"final_score\"))\n",
" + geom_histogram(bins=12, fill=\"#4477AA\")\n",
" + facet_grid(y=\"semester\", x=\"course\")\n",
" + ggsize(850, 450)\n",
")"
]
},
{
"cell_type": "markdown",
"id": "50",
"metadata": {},
"source": [
"\n",
"
Activity 6 - Facet by Semester\n",
"\n",
"Build a scatter plot of
study_hours vs.
final_score, coloured by
course, faceted into one panel per
semester.\n",
"
ggplot(results, aes(x=\"study_hours\", y=\"final_score\", color=\"course\")) \\\n",
" + geom_point(alpha=0.5) \\\n",
" + facet_wrap(facets=\"semester\")\n",
"
\n",
" Key Concept: labs() renames anything auto-generated from a column name
\n",
"labs(title=..., x=..., y=..., color=...) is one more + layer. The named argument matches the aesthetic: use color= when you have aes(color=\"course\") and fill= when you have aes(fill=\"course\"). scale_color_manual(values=[...]) takes over from the default palette entirely, one hex code per group, in the order the groups appear. Chapter 16 applies one shared palette and theme to every chart in the book; here, you are choosing colours by hand, one chart at a time.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "55",
"metadata": {},
"source": [
"\n",
"
Activity 7 - Label the Density Chart\n",
"\n",
"Take the
geom_density() chart from Section 4 and add a proper title, axis labels, and legend title with
labs().\n",
"
ggplot(results, aes(x=\"final_score\", fill=\"course\")) + geom_density(alpha=0.4) \\\n",
" + labs(title=..., x=..., y=..., fill=...)\n",
"
\n",
" Key Concept: Seven pillars, one grammar
\n",
"Every lets-plot chart is data + aes + geom, optionally refined by stat (how raw rows become the numbers drawn), position (what happens when marks overlap), coord (the space they are drawn into), and facet (how many panels). Swap any one piece and the rest of the chart definition does not change: that is the whole idea of the grammar of graphics.\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "65",
"metadata": {},
"source": [
"\n",
" Activity 8 - Rebuild the Course Bar Chart with stat_summary
\n",
"Recreate Section 2's course-average bar chart, this time letting the grammar do the aggregation.
1. Start from ggplot(results, aes(x='course', y='final_score')).
2. Add + stat_summary(fun='median', geom='bar', fill='#4477AA') to plot the median instead of the mean.
3. Add + coord_flip() so the course names are easier to read.
4. Compare: how many lines of setup did this take versus Section 2's groupby().mean() version?
Expected: a horizontal bar chart of median final score per course, built with zero manual aggregation.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "66",
"metadata": {},
"outputs": [],
"source": [
"# TODO: stat_summary bar chart of median final_score per course, flipped\n",
"..."
]
},
{
"cell_type": "markdown",
"id": "67",
"metadata": {},
"source": [
"## Capstone: the three-panel report, declaratively\n",
"\n",
"Chapter 14's capstone built a three-panel course report with a manual `(1, 3)` grid of Axes. Here, build the same idea (one histogram per course) as a **single faceted chart** instead of three separate panels assembled by hand."
]
},
{
"cell_type": "markdown",
"id": "68",
"metadata": {},
"source": [
"\n",
"
Capstone Exercise - Faceted Course Report\n",
"\n",
"Build one chart: a histogram of
final_score, faceted by
course, with
geom_vline() marking the overall mean score so each course's panel can be compared against it.\n",
"
overall_mean = results[\"final_score\"].mean()\n",
"\n",
"ggplot(results, aes(x=\"final_score\")) \\\n",
" + geom_histogram(bins=15, fill=\"#4477AA\") \\\n",
" + geom_vline(xintercept=overall_mean, color=\"#EE6677\", linetype=\"dashed\") \\\n",
" + facet_wrap(facets=\"course\") \\\n",
" + ggsize(700, 250)\n",
"
Hint: geom_vline() takes a fixed
xintercept, a setting, not a mapping, so it goes outside
aes() just like the fixed colours in Sec. 3.\n",
"