Glossary

127 terms from Data Visualization, in plain words, each with the chapter that teaches it.

Search the glossary

A

Accessible: A chart is accessible when everyone can use it, including people with low vision, color vision deficiency, or who use a screen reader. Kettle & Crane's charts get alt text, enough contrast and readable text.
aggfunc: The argument to `pivot_table` that says how to combine values in each cell, such as "sum" or "count". It decides whether a cell shows total revenue or a number of orders.
alpha: A setting for how see-through a mark is, from 0 (invisible) to 1 (solid). Using `alpha=0.7` on café dots makes overlapping dots show as darker patches.
Alt text: A short written description of an image that a screen reader reads aloud in its place. It should say the chart type, what it shows and the takeaway.
annotate: A matplotlib method that writes text on a chart with an arrow pointing at a spot, such as the 'Holiday gifts' note on Sam's December peak. Use it for one to three key moments.
Array: A grid of values from NumPy. `plt.subplots(2, 3)` gives back a 2 by 3 array of Axes that you index like `axes[0, 1]`.
Aspect ratio: The shape of a chart, width compared with height. A wide strip makes trends look gentle and a tall narrow chart makes them look steep, so choose a shape that shows slopes fairly.
Axes: One chart area on a figure, with its own data, axes and labels; you draw on it. A figure can hold several Axes.
Axes coordinates: A way to position text relative to the plot area, where (0, 0) is the bottom left and (1, 1) the top right, instead of using data values. It is used for the subtitle and the dashboard's big numbers.
Axes-level function: A seaborn function such as `histplot` or `heatmap` that draws on one Axes. You can pass `ax=` to place it in your own figure.
Axis: The x (across) or y (up) scale of an Axes. Don't confuse it with Axes, which is the whole chart area.

B

Bar chart: A chart where bar length shows a value, best for comparing categories such as products. Sort the bars, use horizontal bars for long names, and always start at zero.
bar_label: A method that writes each bar's value (or your own text) next to the bar. `ax.barh()` returns a BarContainer, the group of bars you pass to it.
Bins: The equal ranges a histogram cuts values into, with one bar per range. Different bin widths can change the story, such as showing clumps at $15, $32 and $48.
Bootstrapping: Refitting a line to many random resamples of the rows to see how uncertain it is. seaborn uses it to draw the shaded band around `regplot`'s line.
Box plot: A chart that summarizes a distribution with the median, quartiles, whiskers and outliers, so groups such as carriers can be compared side by side. It can hide the real shape, especially for whole numbers with few values.
Bubble chart: A scatter plot whose dot sizes show a third measure, like each city's total revenue. Scale the area, not the width, and remember people judge area only roughly.

C

Categorical palette: A set of distinct colors used to tell groups apart, such as online versus wholesale. The colors should not suggest an order, and you should use as few as possible.
catplot: A seaborn figure-level function for categorical charts (box, violin, bar, strip) that can split into small multiples with `col=`.
CDN: A content delivery network, a server that hosts shared files. With `include_plotlyjs="cdn"` the saved HTML file loads plotly's JavaScript from the internet, making the file small but needing a connection.
Color vision deficiency: Difficulty telling certain colors apart, most often red and green. Charts should use colorblind-safe palettes and never rely on color alone.
Colorbar: The scale beside a chart that explains what each shade of a colormap means, so readers can decode a heatmap or colored dots.
Colormap: matplotlib's name for a smooth range of colors used to show numbers, such as "viridis" or "Blues". You choose it with `cmap=`.
Conditional expression: A one-line choice in Python like `"#c2410c" if focus else "#cccccc"`, which gives the first value when the test is true and the second otherwise. It lets one loop color the highlighted line differently.
Confidence interval: A range showing how uncertain an estimate is, such as the band around a trend line or the error bars on a carrier's average order value. If two intervals overlap almost entirely, the difference may not be real.
Contrast ratio: How much brighter one color is than another, from 1:1 to 21:1. WCAG asks for at least 4.5:1 for normal text and 3:1 for large text and chart lines or bars.
Correlation: A number from -1 to 1 for how closely two measures move together in a straight line. Seats and bags per month for Kettle & Crane's cafés have 0.78, a strong link, but this doesn't prove one causes the other.

D

Dashboard: One page of key numbers and charts that answers "how are we doing?", like Sam's Q3 2026 page for the team.
Data-ink: Edward Tufte's name for the ink (or pixels) that shows the data itself. The idea is to remove other marks that don't help the reader.
Default value: The value a function parameter takes when you leave it out, like `note=""` in the `kpi()` function, which leaves the third line blank.
Direct labeling: Writing each line's name at its end instead of using a legend, so the reader doesn't look back and forth to match colors.
displot: A seaborn figure-level function for distributions, with `kind="hist"`, `"kde"` or `"ecdf"`, that can split into panels with `col=`.
Distribution: How a set of values is spread out: where most are, how far they range and whether there are odd ones. Order values and delivery days are examples.
Diverging palette: Colors running outward in two hues from a neutral middle, for values below and above a meaningful midpoint such as 0% growth.
dpi: Dots per inch: the sharpness of a raster image, where pixels equal inches times dpi. About 150 to 200 suits screens and 300 suits print.
Dual-axis chart: A chart with two series on one plot using separate left and right scales, made with `ax.twinx()`. The scales are arbitrary so any two series can be made to match; use a scatter plot or panels instead.

E

ECDF: A line that climbs from 0 to 1 showing what share of values is at or below each x, so you can read percentiles straight off it.
Error bars: Short lines through a dot showing how far the value might be off, drawn with `ax.errorbar(x, y, yerr=...)`. They stop you reading a small gap as a real finding.

F

Facet, FacetGrid: seaborn's name for small multiples, and the object that holds the panels and figure. Figure-level functions like `relplot` return one.
Figure: The whole image, like a sheet of paper, holding one or more Axes. You size it, give it an overall title and save it.
Figure-level function: A seaborn function such as `relplot`, `displot` or `catplot` that makes a whole figure and can split it into small multiples with `col=` and `row=`.
fill_between: A method that shades the area between two lines, used to draw an uncertainty band such as one standard deviation around a 7-day average.
First quartile, third quartile: The values with 25% and 75% of the data below them. A box plot's box runs from the first to the third quartile.
Five kinds of question: Almost every business question is a comparison, trend, distribution, relationship or part-to-whole question, and each has a best-fit chart: sorted bars, line, histogram or box/violin, scatter, stacked bar.
Format string: A pattern describing how a number is shown, like `"${:,.0f}"` for dollars with thousands commas and no decimals. `.1%` shows a fraction as a percentage.
Formatter, locator: The two parts of an axis that control ticks: a locator decides where ticks go, and a formatter decides what the tick labels say. Examples are `MonthLocator` and `ConciseDateFormatter`.

G

Grouped bars: Bars placed side by side within each category, such as 2025 next to 2026, to compare series within each group. `ax.grouped_bar()` is new and provisional in matplotlib 3.11.

H

Heatmap: A grid of cells colored by value, ideal for a count for every pair of two categories, such as orders by weekday and hour.
Hex code: A color written as `#` followed by six hexadecimal digits for red, green and blue, such as `#1f77b4`. Each pair runs from 00 to ff (0 to 255).
Highlight: A color trick that draws the one important series in a strong color and everything else in light gray. `zorder=` keeps the highlighted line drawn on top.
Histogram: Bars counting how many values fall in each bin, showing a distribution's shape. Try more than one bin width, since order values look smooth with wide bins and clumped with narrow ones.
House style: One set of fonts, colors, gridlines and title position that every chart uses automatically. Kettle & Crane keeps theirs in `kc_style.py` and switches it on by calling `kc_style()`.
Hover: In an interactive chart, moving the mouse over a mark to see a box with its exact values. In plotly you control the box with `hover_name=` and `hover_data=`.
hue: A seaborn argument naming a column whose values get different colors, such as `hue="customer"`.

I

Index (rebased series): Each value divided by the series' starting value, times 100, so different series start at 100 and can share one scale. It's an honest alternative to a dual-axis chart.
Interactive chart: A chart the reader can explore, by hovering for exact values, zooming or hiding series. plotly makes these.
Interquartile range (IQR): The height of a box plot's box, covering the middle half of the values from the first to the third quartile. Whiskers reach out to the furthest values within 1.5 IQRs of the box.

J

Jitter: Small random shifts added so dots stacked on the same whole-number value spread out and can be counted, for example items per order.

K

kaleido: A Python package plotly needs to save static images such as PNGs with `fig.write_image()`. Version 1.x also needs Google Chrome, which `plotly_get_chrome` downloads.
KDE: Kernel density estimate: a smooth curve version of a histogram, the outline a violin plot uses.
KPI: Key performance indicator: a number a business tracks to judge how it's doing, like Q3 revenue or the number of wholesale cafés on the dashboard.

L

layout="constrained": A figure option that makes matplotlib fit titles, labels and legends inside the figure without overlaps, and keep doing so as you add things. It replaces `plt.tight_layout()`.
Legend: The key saying which color or style is which, added with `ax.legend()`. With a few lines, labeling them directly is often better.
List comprehension: A loop written inside square brackets that builds a list in one line, such as building the list of delivery-day Series, one per carrier.
Log scale: An axis where equal distances mean equal ratios, so 10 to 100 is the same height as 100 to 1,000. Useful for growth across many times over, and it should be stated on the chart.
Long (tidy), wide data: Long (tidy) data has one row per observation and one column per variable, like `orders.csv`; wide data has one column per group. seaborn wants long data.

M

marker: A dot drawn at each data point on a line, set with `marker=` and sized by `markersize`. Useful when there are few points.
matplotlib: The Python library that draws any chart and controls every detail; seaborn and pandas' `.plot()` build on it.
matplotlib.dates: matplotlib's module of date tools, imported as `mdates`, holding locators and formatters such as `MonthLocator` and `ConciseDateFormatter`.
matplotlib.ticker: A module of ready-made tick formatters, imported as `mticker`, such as `StrMethodFormatter("${x:,.0f}")` for dollars and `PercentFormatter` for percentages.
Median, quartile, percentile: The median is the middle value; quartiles are the 25% and 75% points; a percentile is the value a given percent of the data falls below. The 95th percentile of USPS delivery days (6) supports a promise that holds for nearly every parcel.
Method: A function that belongs to an object, such as `ax.plot()` on an Axes.

N

Noisy data: Values that jump around from day to day for no lasting reason, hiding the underlying trend.
Notebook: An environment (Jupyter, VS Code or Colab) where code runs in cells and charts appear right under them.
NumPy: A Python library for fast numerical computing on arrays of numbers, and the foundation pandas is built on. It is usually imported as `np` and provides tools such as `np.polyfit` for fitting a line and `np.random.uniform` for random numbers.

O

Object-oriented style: Drawing by calling methods on the `fig` and `ax` you created, such as `ax.plot()`, instead of the pyplot style's `plt` functions that act on the current chart. It says clearly which chart you mean when there are several.
objects interface: seaborn's newer, alternative way to build a chart by combining parts, such as `so.Plot(...).add(so.Dot())`. It is imported with `import seaborn.objects as so` and offers a different style from seaborn's usual one-call plotting functions.
Okabe-Ito palette: A categorical palette designed to stay distinct for common kinds of color vision deficiency; it ships with matplotlib 3.11 as `mpl.color_sequences["okabe_ito"]`.
Outlier: A value far from the rest, drawn as a single point beyond a box plot's whiskers.
Overplotting: Dots piling on top of each other so a scatter plot becomes a solid blob and hides the pattern. Fix it with small see-through dots, jitter or a summary chart.

P

Palette: A set of colors used together in a chart. Color does one of three jobs: telling groups apart, showing low to high, or showing distance from a middle.
Pie chart: A circle cut into slices sized by share of a whole. Use it only for two or three parts; for anything else, sorted bars are easier to compare.
pip: Python's tool for installing packages from the terminal, such as `pip install --upgrade pandas matplotlib seaborn plotly`.
pivot_table: A pandas method that turns the values of one column into separate columns, with a summary in each cell, such as one row per month and one column per channel. It builds grids for stacked bars and heatmaps.
plotly: A library that draws interactive charts in the browser using JavaScript while you write only Python. Its quick interface, plotly Express (`px`), takes a DataFrame and column names.
Point: A unit equal to 1/72 of an inch, used by matplotlib for text sizes, line widths and spacing.
polyfit: A NumPy function that finds the straight line that best fits the points and returns its slope (how much y rises per 1 of x) and intercept (y where x is 0). It supplies the trend line on the café scatter plot.
Property cycle: The list of colors that each new line or bar set takes in turn. You can replace it with `plt.cycler(color=...)`.
pyplot: matplotlib's module (imported as `plt`) whose functions act on 'the current chart'. This style gets confusing with more than one chart.

Q

Quarter: Three months of the year, used as a standard reporting period; Q3 is July to September. For example, Kettle & Crane's Q3 2025 and Q3 2026 each cover those three months.

R

Raster, vector: A raster image (PNG, JPG) is a grid of pixels that blurs when enlarged; a vector image (SVG, PDF) stores shapes and text and stays sharp at any size. Use PNG for charts with many points, SVG for the web and PDF for print.
rcParams: matplotlib's dictionary of default settings. Changing it once, as in Kettle & Crane's `kc_style()`, makes every later chart follow.
Reference line: A line showing a target, an average or an event, such as the $1,100-a-day target. `ax.axhline()`, `ax.axvline()` and `ax.axhspan()` draw them.
regplot: A seaborn axes-level function that draws a scatter plot, a best-fit line and a shaded confidence band.
Relative luminance: A color's brightness as the eye sees it, from 0 for black to 1 for white. It is used to compute a contrast ratio.
relplot: A seaborn figure-level function for relationship charts (scatter or line) that makes one panel per group with `col=`, all on shared axes.
resample: A pandas method that groups a series with a date index into periods such as weeks, like `groupby` for time. `"W"` means weeks ending on Sunday.
Rolling average: The mean of each value and the few before it, used to smooth a noisy daily series. A 7-day window also cancels the weekly pattern.

S

savefig: The Figure method that writes the image to a file, choosing the format from the file ending. `plt.close(fig)` then frees it from memory.
Scatter plot: One dot per row, placed by two values, used to show whether two measures move together. A trend line shows association, not cause.
Screen reader: Software that reads the screen aloud for people who can't see it well, which is why images need alt text.
seaborn: A library built on matplotlib that draws statistical charts, like grouped distributions and trend lines, in one line each from a DataFrame and column names.
Sequential palette: A range running from light to dark in one hue, to show low to high, such as order counts. Darker means more.
sharex / sharey: Options that give every panel in a grid the same scale and hide repeated tick labels on inner panels. Shared scales keep small multiples honest.
Slope chart: Lines joining each item's value at two times. Jo's version shows each coffee's units from Q3 2025 to Q3 2026, with Cold Brew Blend highlighted.
Small multiples: The same small chart repeated once per group on shared scales, so shapes compare at a glance. It fixes 'spaghetti', a tangle of many colored lines.
Spine: One of the four lines around the plot area. Removing the top and right spines is a common declutter step.
Stacked bars: Bars with parts piled on top of each other, so total height is the whole and each segment a part. Only the bottom segment is easy to compare, so stack two or three parts at most.
Standard deviation: A measure of how far values typically sit from their mean. A band of one SD around the 7-day average shows a normal day's range.
Style sheet: A text file of matplotlib settings, such as `kettle.mplstyle`, applied with `plt.style.use()` or for a few charts with `plt.style.context()`.
subplot_mosaic: A matplotlib function that takes a picture of the layout as a list of rows of panel names and returns the figure and a dict of Axes. It builds panels of different sizes, like the dashboard.
subplots: The matplotlib function that creates a Figure and one or more Axes in one call, such as `fig, ax = plt.subplots()`.
Subtitle: A smaller gray line under the title giving the description: what, where, when and units.

T

Takeaway title: A title that states the finding, such as 'Wholesale has nearly caught up with online', instead of only describing the data. Check the claim against the numbers first.
Tick, tick label: A tick is a small mark on an axis, and the tick label is the number or name beside it.
Time series: Values measured at regular times, such as daily revenue or monthly orders. Lines suit them best.
Timedelta: A length of time, such as the gap between two dates. The dashboard subtracts the first date to count days into the quarter.
Trend line: A straight line through a scatter plot that best fits the points, drawn dashed so it reads as a guide. It shows that two measures move together, not that one causes the other.
Truncated axis: An axis that starts above zero so differences look bigger. A 12% rise in online revenue looks like a fivefold jump when the bars start at $85,000.

U

Uncertainty: How far a number might be off. Honest charts show it with bands or error bars.

V

Violin plot: A mirrored, smoothed outline of a distribution, wide where values are common and thin where they are rare. It shows the real shape that a box plot can hide.
viridis: matplotlib's default colormap, running from dark purple to yellow, designed to avoid the false edges and unclear order of rainbow colormaps like "jet".
Virtual environment: A private set of installed packages for one project, so installs for it don't affect other projects.
Visual cue ranking: People judge position and length most accurately, then angle and slope, then area, then color shade. Put the main comparison on position or length and use area and color for extras.

W

WCAG: The Web Content Accessibility Guidelines, which set minimum contrast ratios: 4.5:1 for normal text and 3:1 for large text and graphic parts such as lines and bars.
Whiskers: The lines on a box plot that reach out from the box to the furthest values within 1.5 IQRs of it. Values beyond them are drawn as outliers.
write_html: A plotly method that saves a chart as a web page anyone can open in a browser, with no Python needed. Leaving out `include_plotlyjs="cdn"` makes the file large but works offline.