HoloViews Cheat Sheet

1Setup & extension1.23

import holoviews as hv from holoviews import opts hv.extension("bokeh")★
Load a backend first — "bokeh" (interactive, default), "matplotlib" (static/publication), or "plotly" (3-D). opts holds the option builders.
hv.extension("bokeh", "matplotlib") # load several, switch later
Register multiple backends; the first is active. Swap with hv.output(backend="matplotlib").
pip install holoviews # or: conda install -c pyviz holoviews
In a notebook, an element displays itself automatically. In scripts, use hv.save/hv.render (card 8).

2Elements from datadata + semantics

hv.Curve(df, "time", "value") # line hv.Scatter(df, "x", "y") · hv.Points(df, ["x", "y"])★
An Element wraps your data with meaning. Accepts pandas, arrays, dicts, xarray. Curve=continuous, Scatter=y-vs-x, Points=2-D positions.
hv.Bars · hv.Histogram · hv.Area · hv.HeatMap · hv.BoxWhisker★
The everyday chart vocabulary. Also Distribution, Violin, Spikes, Path, Segments, Sankey.
hv.Image(arr) · hv.RGB(arr) · hv.QuadMesh · hv.Contours
Gridded/raster elements — feed 2-D arrays or xarray DataArrays (great with weather/imagery data).

3Dimensionskdims vs vdims

hv.Curve(df, kdims="time", vdims="price")★
The key idea: kdims = key/independent dims (the x you index by), vdims = value/dependent dims (the y measured). Positional args are (kdims, vdims) in that order.
hv.Dimension("temp", label="Temperature", unit="°C", range=(0, 40))
Rich dimensions carry a label, unit, and range — which drive axis titles, colorbars, and slider bounds automatically.
curve.redim.label(price="Price (USD)").redim.range(price=(0, 500))
.redim relabels or re-ranges a dimension after the fact — without rebuilding the element.

4Compose (+ and *)algebra of plots

layout = curve + scatter # side by side (Layout)★
+ lays out panels next to each other. layout.cols(2) wraps to a grid of 2 columns.
overlay = curve * scatter * hv.HLine(0) # superimposed★
* overlays elements on shared axes — multiple series, annotations (HLine/VLine/Text), etc.
hv.Overlay([a, b, c]) · hv.Layout([a, b, c])
Build the same compositions from a list — handy when the pieces are generated in a loop.

5Options (.opts)appearance, kept separate

curve.opts(color="red", line_width=2, width=600, height=400, tools=["hover"])★
Inline styling on one element. Mixes style options (color, cmap) and plot options (width, tools, axes). hv.help(hv.Curve) lists them all.
layout.opts( opts.Curve(color="navy", width=500), opts.Scatter(size=8, cmap="viridis"))★
Per-type options inside a composite — the opts.<Element>(...) builders target each element type in a Layout/Overlay.
opts.defaults(opts.Curve(tools=["hover"], show_grid=True))
Session-wide defaults for every element of a type. Set once at the top of a notebook.
# Keep data and styling separate — the core design principle
Declare elements/containers by what the data is; apply .opts() at the end for how it looks. Don't rebuild data to restyle.

6Containers & DynamicMapmany plots, one object

hmap = hv.HoloMap({yr: hv.Curve(data[yr]) for yr in years}, kdims="year")★
HoloMap maps key values → elements and auto-generates widgets/sliders. All frames are computed & embedded up front.
dmap = hv.DynamicMap(make_curve, kdims="year") dmap.redim.values(year=years)★
DynamicMap calls your function lazily — only the visible frame is computed. Use it for large parameter spaces or big data.
df_curves = hv.Dataset(df).to(hv.Curve, "x", "y", groupby="category") df_curves.overlay() · .layout() · .grid()
Tabular → plots: Dataset.to(...) pivots a dataframe into a HoloMap keyed by a column, then .overlay()/.layout()/.grid() arranges it.

7Interactivitystreams + Panel

# Bokeh gives pan / zoom / hover for free curve.opts(tools=["hover", "box_select"])★
With the Bokeh backend, interactivity is built in — just enable the tools you want.
from holoviews.streams import RangeXY, Tap, Selection1D dmap = hv.DynamicMap(cb, streams=[RangeXY()])★
Streams push interaction events (zoom range, tap, selection) into a DynamicMap callback — the basis of linked, responsive plots.
import panel as pn pn.panel(layout).servable() # dashboard app
Wrap HoloViews objects in Panel for full dashboards with widgets, then panel serve app.py.

8Big data & exportrasterize + save

from holoviews.operation.datashader import rasterize, datashade rasterize(hv.Points(big_df)) # server-side aggregation★
Millions of points overwhelm the browser — rasterize/datashade (via Datashader) aggregate to an image that re-renders on zoom. Essential for large data.
hv.save(obj, "plot.html") · hv.save(obj, "plot.png")★
Export to standalone HTML (interactive, Bokeh) or PNG/SVG (Matplotlib). Backend determines the formats available.
fig = hv.render(obj) # -> Bokeh/Matplotlib figure object hv.output(backend="matplotlib", fig="svg")
render drops to the native figure for further tweaking; hv.output sets global backend/format.

!Common gotchasread before shipping

load hv.extension() before building
Nothing renders until a backend is loaded. In notebooks, run hv.extension("bokeh") near the top before displaying elements.
kdims vs vdims order matters
Positional dims are (kdims, vdims) = (x, y). Swapping them silently plots the wrong axes. Be explicit with kdims=/vdims= when unsure.
keep data and .opts() separate
.opts() is presentation only. Don't encode appearance into the data step, and don't rebuild elements just to restyle — call .opts() at the end.
HoloMap embeds every frame
A big HoloMap computes and ships all frames — slow/heavy. For large parameter spaces or big data, use DynamicMap (lazy).
DynamicMap callback must be consistent
The callback should return the same element type every call; returning different types breaks the display pipeline.
don't scatter millions of raw points
Native Bokeh chokes on huge point counts. Wrap in rasterize/datashade instead of plotting every marker.
%%opts magic is legacy
Old notebooks use %%opts/%%output magics. Prefer the .opts() method and hv.output() function — they work in scripts too.

HoloViews cheat sheet