gt Tables Exercises in R: 22 Real-World Practice Problems

Explanation: gt() accepts any data frame or tibble and returns a gt_tbl object that renders as HTML. Because mtcars stores model names in row names, rownames_to_column() lifts them into a real column before you call gt(), which is critical: gt() silently drops row names. Pipe order matters here, slice first or after the rename, but the rename must precede gt().

Explanation: The stub is gt's special leftmost label column. Passing rowname_col at construction time turns that column into the stub, which unlocks features like summary rows, row group labels, and the cells_stub() location helper for tab_style(). A regular column has none of those affordances, so the choice between "data column" and "stub" sets the entire downstream styling vocabulary.

Explanation: Inline tibbles are how analysts prototype gt outputs without dragging in a large dataset. Building the data with tibble() and piping directly into gt() is a fast iteration loop for stand-up reports. Once the styling is locked, you swap the inline tibble for the real query result with one line and the table format stays identical.

Explanation: tab_header() adds a two-tier title block above the column labels: title is bold, subtitle smaller and lighter. Both accept md() or html() helpers if you need bold or links inline. Putting the title in the gt object itself (rather than the report prose) keeps the artifact self-describing when stakeholders screenshot it and paste it into Slack.

Explanation: cols_label() changes only the display label, not the underlying column name. This is important because every other gt verb (fmt_number(), tab_style(), summary_rows()) still references the raw column name. Keep the raw names lowercase snake_case in the tibble and treat cols_label() as the presentation layer, the same separation ggplot2::labs() enforces in plots.

Explanation: Spanners are the gt analogue of merged header cells in Excel. They group columns visually without changing the data shape and are essential when a wide table mixes, say, "Q1" and "Q2" blocks of three columns each. You reference columns with tidy-select (c(...), starts_with("q1_"), where(is.numeric)) inside columns =, exactly like dplyr::select().

Explanation: cols_move() and cols_hide() re-order and suppress columns at the presentation layer without mutating the data, so you can pass a single canonical tibble to gt() and customise every output for its audience. Compare with select() upstream: cols_hide() keeps the data accessible for summary_rows() or tab_footnote() references, while select() removes it from gt entirely.

Explanation: fmt_number() is the workhorse formatter. decimals = 0 rounds for display only, the underlying value is preserved for sorting and summaries. use_seps = TRUE honours the system locale, so en_US gives commas and de_DE gives points; pass sep_mark = "," to override. Format only the columns that need it: applying number formatting to ID columns is a frequent rookie mistake that turns "1001" into "1,001".

Explanation: fmt_currency() is fmt_number() plus a currency glyph and ISO-aware decimal rules (most currencies default to 2 decimals, JPY to 0). Pass currency = "EUR" for Euros, currency = "GBP" for pounds, etc. For multi-currency reports, format each row group separately using the rows = argument or use fmt() with a custom function.

Explanation: fmt_percent() assumes the underlying value is a proportion in [0, 1] and multiplies by 100 for display. If your data already stores percentages (4.2 instead of 0.042) pass scale_values = FALSE to suppress the multiplication. Mixing pre-scaled and proportion data inside one column is the single most common source of "my conversion rate is 4200%" bugs, audit the source once and stick to one convention.

Explanation: fmt_date() takes a date_style argument with named conventions like "iso", "month_day_year", "day_m_year", "yMMMd". Run info_date_style() to see the full table inside R. The column must already be a Date or POSIXt, gt does not parse strings, so as.Date() upstream is required. For datetimes with hour and minute use fmt_datetime() instead.

Explanation: tab_style() is gt's universal styling primitive: a style = argument (built from cell_text(), cell_fill(), cell_borders()) plus a locations = argument (one of cells_body(), cells_column_labels(), cells_stub(), cells_title(), cells_row_groups(), etc.). The split lets you describe what you want and where it goes orthogonally, which is why gt scales to dense, multi-block tables without spaghetti styling code.

Explanation: cells_body() accepts rows = as a tidy-eval expression evaluated against the original data, so revenue_usd == max(revenue_usd) resolves to a logical mask over rows. This is how gt does conditional formatting without a loop: declare the predicate and gt picks the right cells. The same expression works inside tab_footnote() or summary_rows() for matched annotations.

Explanation: data_color() linearly maps the column's numeric range onto the palette and applies cell_fill() per row. Pass a two-colour vector for a simple gradient, or a named viridis palette via palette = "viridis". For divergent data (gains vs losses) supply three colours and centre the scale with domain = c(-x, 0, x). It is the lazy analyst's heatmap, no manual breaks required.

Explanation: Stacking two tab_style() calls with mutually exclusive rows = predicates is the canonical gt pattern for two-sided conditional formatting. The order matters when predicates overlap: later calls win, so put the more specific predicate last. For traffic-light tables (red/yellow/green) chain three tab_style() blocks with breakpoints like pnl < 0, pnl == 0, pnl > 0.

Explanation: grand_summary_rows() aggregates the entire body (ignoring row groups), whereas summary_rows() aggregates within each row group. fns = is a named list of functions or lambdas; the names become row labels. fmt = reapplies number formatting because the aggregate value enters the table fresh and needs its own format pass, the column-level fmt_number() does not propagate.

Explanation: tab_footnote() accepts the same locations = helpers as tab_style(), so you can attach notes to column labels, the title, summary rows, or any specific body cell. gt auto-numbers footnotes and rebuilds the markers if you add more later. For glyph-style markers (asterisks, daggers) pass opt_footnote_marks(marks = "standard") once at the end of the pipeline.

Explanation: Source notes sit at the very bottom of the table, below footnotes. They are conventionally used for citations, retrieval timestamps, or methodology pointers ("Excludes refunds"). The md() helper turns Markdown into HTML inside any gt string slot, so bold, italic, and [links](url) work. Use html() instead if you need raw tags or <sub>/<sup>.

Explanation: summary_rows() with groups = TRUE runs the summary functions inside each row group, the table-level analogue of dplyr::group_by() |> summarise(). The groupname_col argument to gt() is what triggers the grouping; without it gt sees a flat table and summary_rows() has nothing to partition. Pair with grand_summary_rows() to get both per-group subtotals and a grand total.

Explanation: groupname_col tells gt which existing column to lift into row group banners. Rows are presented in the order they appear in the data, so to get a clean group order you typically arrange(cyl) first. The grouped layout is the foundation for summary_rows(groups = TRUE), group-level styling with cells_row_groups(), and row_group_order() to override the natural order.

Explanation: Group labels are stored as character strings, so even if the original column is numeric you pass the values as strings to row_group_order(). The function reorders only the named groups and leaves any unmentioned groups in their natural position. For full alphabetical or numeric reordering, arrange(desc(cyl)) upstream is simpler than enumerating groups.

Explanation: cols_align() accepts "left", "center", "right", or "auto" and applies it to both the column label and every body cell. gt picks "right" for numerics and "left" for character columns by default, but forcing alignment explicitly makes the pipeline robust against data-type drift (a column that was numeric in dev but lands as character in prod). For the stub specifically, cols_align(columns = model) is the right move since the stub is just another column from gt's API perspective.

Explanation: gtsave() infers the export format from the extension: .html writes a self-contained page (CSS inlined), .png/.pdf shell out to webshot2/Chromium, .tex/.rtf/.docx go through dedicated converters. HTML is the lossless default; PNG is great for slide decks but rasterised, and PDF requires a working headless Chrome. For automated pipelines, gtsave to HTML and then post-process with pagedown::chrome_print() if you need a deterministic PDF.