Python Fundamentals — Statistical Visualization with Seaborn II

Before you begin, take a few minutes to check what you already know and how confident you feel. You will see the same questions again at the end of the module — this helps both you and us measure what you have learned. Click an option for every question and confidence rating, then click Next to continue.

In Part I you drew the everyday single-question plots: counts and means by category, the shape of a distribution, and the relationship between two numeric columns. Real analysis rarely stops at a single chart, though.

This second part is about composition and presentation — taking those plots and combining them:

• Heatmaps — coloured grids for correlation matrices and contingency tables, when you want every pairwise number on one page.
• Combining and faceting — small multiples and multi-panel figures for splitting a plot across the levels of another category.
• Themes and palettes — the one-line settings that turn an exploratory chart into a polished, presentation-ready one.

To follow along with this module, you will need the same two standard imports at the top of every script: seaborn (aliased as sns) and matplotlib.pyplot (aliased as plt). When you are ready to see your chart, calling plt.show() will pop the figure onto your screen.

Be sure to test out each snippet in the Python Scratchpad on the right as you go. By the time you finish this module, you will know how to take a raw CSV of patient measurements and turn it into a comprehensive, multi-panel figure that summarizes the entire cohort in one shot.

Sometimes you do not just want a single chart. You want a grid. Whether you are looking at how strongly every pair of variables correlates or how often different categories overlap, a raw table of numbers is tough to scan.

A heatmap solves this by turning that table into a colored grid, where dark and light squares let you read the patterns in seconds.

The most common way to use sns.heatmap is for a correlation matrix. Pandas makes the math easy: calling df.corr() gives you a square DataFrame showing the correlation coefficient between every pair of numeric columns. You just hand that DataFrame to sns.heatmap, and you instantly have a publication-quality map.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    "age": [54, 61, 47, 72, 38, 55, 49, 67, 41, 58],
    "bmi": [27.3, 28.4, 26.1, 30.2, 24.5, 27.0,
             25.8, 29.7, 24.0, 28.1],
    "glucose": [5.4, 6.1, 4.9, 6.8, 4.5, 5.5, 5.0, 6.4, 4.7, 5.7],
    "chol": [4.8, 5.5, 4.6, 6.2, 4.0, 5.0, 4.5, 5.9, 4.2, 5.1],
})
corr = df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm", vmin=-1, vmax=1, center=0)
plt.show()

There are a few keyword arguments that will do the heavy lifting for you here:

• annot=True: This writes the actual number inside each cell. It is almost always worth turning on, since colors alone can be hard to read precisely.
• cmap: This chooses your color palette. Use "viridis" for values going in one direction (like zero to large positive numbers), or "coolwarm" for diverging values that range from negative to positive (like correlations).
• vmin, vmax, and center: These pin your color scale to fixed limits. For correlations, setting vmin=-1, vmax=1, and center=0 ensures your colors mean the exact same thing every time, which is critical if you are comparing multiple heatmaps side-by-side.

The other common use case is a contingency table, which simply shows how many records fall into specific combinations of two categories. To get the numbers, use pd.crosstab on two columns. Hand that resulting table to sns.heatmap, and you get a clear visual of your joint distribution.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    "clinic": ["A", "A", "A", "B", "B", "B", "C", "C"],
    "sex": ["F", "F", "M", "M", "F", "M", "F", "M"],
})
table = pd.crosstab(df["clinic"], df["sex"])
sns.heatmap(table, annot=True, cmap="viridis", fmt="d")
plt.show()

Notice the fmt="d" argument in that snippet?

That forces the cell labels to display as clean integers. Without it, annot=True defaults to writing them as floats with a bunch of messy decimal places. You can also use fmt=".2f" for two decimal places, or fmt=".0%" for percentages.

One final, important note: sns.heatmap does not actually compute anything. It strictly draws whatever 2D table you hand it. All the mathematical thinking happens in pandas before you call Seaborn.

Real data analysis usually requires you to break down distributions by categories. Instead of writing messy for loops to generate multiple separate charts, Seaborn uses faceting.

Faceting takes one plot and repeats it across different categories, lining up the panels side-by-side so your eye can compare them instantly.

To use faceting, you must understand Seaborn's two distinct types of functions. This is the most common stumbling block for beginners:

• Axes-level functions (scatterplot, boxplot, histplot): draw onto a single, specific chart.
• Figure-level functions (relplot, catplot, displot): control the entire figure canvas. Can split the figure into a grid using the col= (columns) or row= (rows) arguments.

Think of figure-level functions as "families." To facet your data, you call the family function, then tell it exactly which chart to draw using the kind= argument:

• Categorical plots (boxplot, barplot) become catplot (e.g., kind="box")
• Relational plots (scatterplot, lineplot) become relplot (e.g., kind="scatter")
• Distributions (histplot, kdeplot) become displot (e.g., kind="hist")

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    "clinic": ["A"]*8 + ["B"]*8,
    "sex": (["F"]*4 + ["M"]*4) * 2,
    "bmi": [22.5, 23.0, 24.0, 25.5, 28.0, 29.0, 30.5, 31.0,
             24.0, 25.0, 26.5, 27.0, 28.5, 29.5, 30.0, 31.5],
})
sns.catplot(data=df, x="clinic", y="bmi", col="sex", kind="box")
plt.show()

That single line above draws two side-by-side boxplots—one for female patients and one for male—each comparing clinics A and B.

If you pass both row= and col=, you get a full grid of panels. You can control the size of these panels using the height and aspect arguments (for example, height=4, aspect=1.2 is a standard starting point for professional reports).

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    "age": [54, 61, 47, 72, 38, 55, 49, 67, 41, 58, 63, 45],
    "bmi": [27.3, 28.4, 26.1, 30.2, 24.5, 27.0,
             25.8, 29.7, 24.0, 28.1, 29.5, 25.5],
    "sex": ["F", "M"] * 6,
    "clinic": ["A", "A", "B", "B"] * 3,
})
sns.relplot(data=df, x="age", y="bmi", col="sex", row="clinic", kind="scatter")
plt.show()

There are two dedicated figure-level functions built specifically for data exploration.

sns.pairplot is the chart you should draw on day one with any new multi-column numeric dataset. It automatically draws scatterplots for every possible pair of numeric columns, plus histograms down the diagonal.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from pyodide.http import open_url

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
iris = pd.read_csv(open_url(url))

sns.pairplot(iris, hue="species")
plt.show()

sns.jointplot is a highly focused tool for deep-diving into a single pair of variables. It places a scatterplot in the center and attaches the individual distributions along the top and right edges.

You can pass kind="reg" to add a regression line, or kind="hex" if you have so many data points that a standard scatterplot turns into an unreadable black blob.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
 "bmi": [25.0, 27.2, 24.1, 28.5, 29.0, 26.3],
 "glucose": [5.4, 6.1, 4.9, 5.8, 6.7, 5.1],
})
sns.jointplot(data=df, x="bmi", y="glucose", kind="reg")
plt.show()

When do you use the different plots?

• catplot, relplot, displot: Use these whenever you need to facet data into rows or columns.
• pairplot: Use this for first-day exploration on a new dataset.
• jointplot: Use this to deep-dive into two specific variables and their marginals.
• Axes-level functions (scatterplot, boxplot, etc.): Keep these for situations where you are manually managing a single set of axes yourself, usually as part of a highly custom matplotlib figure.

Seaborn's default theme is perfectly fine when you are just exploring your data, but it can look a bit too plain for a slide deck or a final report.

To fix this, you can use sns.set_theme(). Calling this once at the top of your script instantly updates the look of every plot that follows. It uses two incredibly helpful arguments:

• The style argument changes the background layout. Your options are "whitegrid", "darkgrid", "white", or "ticks".
• The context argument automatically scales your font sizes and line widths so they are easily readable in their final destination. Your options are "paper", "notebook", "talk", or "poster".

You also have full control over the colors. You can change the global color scheme using sns.set_palette(), or you can just add the palette= argument to an individual plot. Two excellent, highly accessible defaults to keep in your back pocket are "viridis" and "colorblind".

Here is how all of that comes together to create a presentation-ready chart:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

sns.set_theme(style="whitegrid", context="talk")

df = pd.DataFrame({
    "clinic": ["A", "A", "B", "B", "C", "C"],
    "sex": ["F", "M", "F", "M", "F", "M"],
    "bmi": [27.4, 29.0, 31.1, 30.5, 24.8, 26.1],
})
sns.barplot(data=df, x="clinic", y="bmi", hue="sex", palette="colorblind")
plt.show()

The plot families across both parts of this Seaborn module are usually used together. A typical first look at a new clinical dataset is a four-panel summary: a barplot showing the mean of an outcome per clinic, a boxplot of a key measurement per group, a scatter or regplot of two related measurements, and a heatmap of all the pairwise correlations. The worked example below builds something close to that on a small inline DataFrame.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("patients.csv")

g = sns.catplot(data=df, x="clinic", y="bmi", col="sex", kind="box")
g.savefig("bmi_by_clinic_by_sex.png")

sns.lmplot(data=df, x="age", y="bmi", hue="sex")
plt.savefig("age_vs_bmi_by_sex.png")

corr = df[["age", "bmi", "glucose", "chol"]].corr()
sns.heatmap(corr, annot=True, cmap="coolwarm", vmin=-1, vmax=1, center=0)
plt.savefig("correlation_heatmap.png")

You have reached the end of the module. Try the same questions again — your answers here, paired with your pre-test answers, are how we measure what the module taught you. Answer every question and confidence rating, then click Submit and see results to view your score.

Here is how your post-test answers compare with your pre-test answers. The pre/post pairing is the most reliable way to see what this module actually taught you.