Rich Iannone

cheatsheets

How to use {pointblank} to understand, validate, and document your data

How to use {pointblank} to understand, validate, and document your data - Rich Iannone

Abstract: This workshop will focus on the data quality and data documentation workflows that the pointblank package makes possible. We will use functions that allow us to: (1) quickly understand a new dataset (2) validate tabular data using rules that are based on our understanding of the data (3) fully document a table by describing its variables and other important details. The pointblank package was created to scale from small validation problems (“Let’s make certain this table fits my expectations before moving on”) to very large (“Let’s validate these 35 database tables every day and ensure data quality is maintained”) and we’ll delve into all sorts of data quality scenarios so you’ll be comfortable using this package in your organization. Data documentation is seemingly and unfortunately less common in organizations (maybe even less than the practice of data validation). We’ll learn all about how this doesn’t have to be a tedious chore. The pointblank package allows you to create informative and beautiful data documentation that will help others understand what’s in all those tables that are so vital to an organization.

Resources mentioned in the workshop:

Making Things Nice in Python (Rich Iannone, Posit) | posit::conf(2025)

Making Things Nice in Python

Speaker(s): Rich Iannone

Abstract:

When working on the Great Tables and Pointblank Python packages, we’ve tried to make them ’nice’. These packages give you a lot of convenient options, and a large volume of docs and examples. In the Python world, this might be received differently than it would be in R. Whether it was integrating Polars selectors in Great Tables or accepting a multitude of DataFrames and DB tables in Pointblank, these design choices can be seen as surprising things to established Python developers.

Tables in Python with Great Tables

Tables in Python with Great Tables - Rich Iannone, Michael Chow

Resources mentioned in the workshop:

We want GREAT tables! | Richard Iannone & Michael Chow | Data Science Hangout

Great Tables: Make beautiful, publication quality tables in Python | Rich Iannone & Michael Chow

Tables are undeniably useful for data work. We have many great DataFrame libraries available in Python, and they give us flexibility in terms of manipulating data at will, but what happens when presenting tables to others?

It’s nice to display tables. Tables can efficiently carry information, just like plots do, and at times it is the better way of presenting data. Indeed, it is time to bridge the divide between raw DataFrame output and wondrously structured tables suitable for publication.

Now, let us turn our attention to the state of ‘display tables’ in 2024. Let us go over what comprises key components for building effective information displays in tables. It may surprise one how new a well-crafted table can be hewn. We’ll take a look at the combinations of Python packages that fit together to make this important task possible, and marvel together at the tabular results they can provide!

Can I Have a Word? - posit::conf(2023)

Presented by Ellis Hughes

Since its release, {gt} has won over the hearts of many due to its flexible and powerful table-generating abilities. However, in cases where office products were required by downstream users, {gt}’s potential remained untapped. That all changed in 2022 when Rich Iannone and I collaborated to add Word documents as an official output type. Now, data scientists can engage stakeholders directly, wherever they are.

Join me for an upcoming talk where I’ll share my excitement about the new opportunities this update presents for the R community as well as future developments we can look forward to.

Eric Nantz, Alex Lauer, Rich Iannone - A Pivotal Year of Milestones in R Consortium Working Groups

A Pivotal Year of Milestones: R Submissions Working Group and R Tables for Regulatory Submissions updates - Eric Nantz, Alexandra Lauer, and Rich Iannone

Resources mentioned in the presentation:

Rich Iannone | What’s new and exciting in gt 0.8.0 | Posit

With the gt package, anyone can make wonderful-looking tables using the R programming language. Rich Iannone, maintainer of gt, shows what’s new and improved in gt 0.8.0!

00:00 Introduction 00:42 Find/Replace values with sub_values() 02:46 Find values and style them with tab_style_body() 05:00 Place a cell in your Quarto/RMarkdown doc with extract_cells() 07:13 Make numbers more readable with cols_align_decimal() 08:54 See column id info with tab_info() 11:03 Date and time formatting improvements

How to Use {pointblank} to Understand, Validate, and Document your Data

Workshop recorded as part of the R/Pharma Workshop Series (October 27, 2022) Instructor: Rich Iannone (Posit)

Resources mentioned in the workshop:

Open Source Chat - {gt} with Rich Iannone

Join Rich Iannone, maintainer of the {gt} package, as he takes questions from the community about the latest in {gt} v0.7.0, and building great looking data display tables with R.

What’s New in {gt} 0.7.0?

gt 0.7.0 was just released. Rich Iannone, maintainer of gt, dives into the 7 new features added.

Submitting Your Work to the Table Contest | 2022 Table Contest

Rich Iannone walks through how to submit a table to the 2022 Table Contest. He explains considerations for each field, and how to update & edit your entry afterwards.

Rich Iannone || New features in {gt} 0.6.0! || RStudio

00:00 Introduction 00:18 sub_missing() 03:51 Markdown formatting in sub_missing() 04:51 sub_zero() 07:34 sub_small_vals() 13:08 sub_large_vals() 16:25 final thoughts

A new version of the R package {gt} has been released! We are now at version 0.6.0 and there are now even more features that’ll make your display/summary tables look and work much, much better. Let’s run through some of the bigger changes and see the benefits they can bring!

New functions for substituting cell data We now have four new functions that allow you to make precise substitutions of cell values with perhaps something more meaningful. They all begin with sub_ and that’s short for substitution!

sub_missing() (formerly known as fmt_missing()) Here’s something that’s both old and new. The sub_missing() function (for replacing NAs with… something) is new, but it’s essentially replacing a function that is old (fmt_missing()).

The missing_text replacement of “—” is actually an em dash (the longest of the dash family). This can be downgraded to an en dash with “–” or we can go further with “-”, giving us a hyphen replacement. Or, you can use another piece of text.

If you’re using and loving fmt_missing(), it’s okay! You’ll probably receive a warning about it when you upgrade to {gt} 0.6.0 though. Best to just substitute fmt_missing() with sub_missing() anyway!

sub_zero() The sub_zero() function allows for substituting zero values in the table body.

sub_small_vals() Next up is the sub_small_vals() function. Ever have really, really small values and really just want to say they are small?

With sub_small_vals() we can reformat smaller numbers using the default threshold of 0.01.

Small and negative values can also be handled but they are handled specially by the sign parameter. Setting that to “-” will format only the small, negative values.

You don’t have to settle with the default threshold value or the default replacement pattern (in small_pattern). This can be changed and the “x” in small_pattern (which uses the threshold value) can even be omitted.

sub_large_vals() Okay, there’s one more substitution function to cover, and this one’s for all the large values in your table: sub_large_vals(). With this you can substitute what you might consider as too large values in the table body.

Large negative values can also be handled but they are handled specially by the sign parameter. Setting that to “-” will format only the large values that are negative. You don’t have to settle with the default threshold value or the default replacement pattern (in large_pattern). This can be changed and the “x” in large_pattern (which uses the threshold value) can even be omitted.

Final thoughts We are always trying to improve the gt package with a mix of big features (some examples: improving rendering, adding new families of functions) and numerous tiny features (like improving existing functions, clarifying documentation, etc.). It’s hoped that the things delivered in gt 0.6.0 lead to improvements in how you create and present summary tables in R. If there are features you really want, always feel free to:

{gt} Table Battles || Eurovision || RStudio

00:00 Introduction 00:07 Jesse’s gt table, with a focus on flag emoji and interactivity via a Shiny app 09:50 Rich’s gt table, with a focus on CSS and embedded animations

{gt} Table Battles || Crosswords || RStudio

00:00 Introduction 00:34 Rich’s gt table, with a focus on creating audio within a table 07:28 Jesse’s gt table, with a focus on sentiment analysis

{gt} Table Battles || Digital Publications || RStudio

00:00 Introduction 00:32 Jesse’s gt table, with a focus on changing background cell color 07:11 Rich’s gt table, which uses three different tables to create a fixed-size scrollable gt table

Rich Iannone || {gt} Intendo Game Data Project Walkthrough || RStudio

00:00 Introduction 00:11 Setting up our environment 01:21 Importing data 01:56 Data preparation using the tidyverse 14:12 Basic gt table 16:25 Specifying row order with row_group_order() 17:20 Formatting currency with fmt_currency() 18:10 Formatting missing values with fmt_missing() 18:55 Creating row groups with tab_options() 19:50 Relabel column names with cols_label() 20:41 Creating tab spanners with tab_spanner() 23:00 Creating a table title and subtitle with tab_header() 24:40 Aligning table title and subtitle with opt_align_table_header() 25:16 Creating a stubhead label with tab_stubhead() 26:00 Format all table cell text using tab_style() 27:25 Automatically format data color based on value using data_color() 30:45 Creating Markdown-friendly source notes using tab_source_note() 32:45 Creating Markdown-friendly footnotes using tab_footnote() 39:28 Adjust table column width using cols_width() 40:55 Adjust cell padding using opt_horizontal_padding() and opt_vertical_padding() 42:22 Change row group headers using tab_style() 43:40 Convert all table text to small caps using opt_all_caps() 43:58 Change all table text font using opt_table_font() 44:28 Changing table, table heading, footnotes, and source notes background color using tab_options() 46:41 Add a table “cap” at the top and bottom using table.border.top.width() and table.border.bottom.width() 47:23 Use multiline formatting with footnotes using footnotes.multiline() 47:34 Change line style using table_body.hlines.style() 47:55 Change table title and subtitle font sizes using heading.title.font.size() and heading.subtitle.font.size() 48:11 Checking out our final table!

Rich Iannone || Making Beautiful Tables with {gt} || RStudio

00:00 Introduction 00:37 Adding a title with tab_header() (using Markdown!) 01:47 Adding a subtitle 02:48 Aligning table headers with opt_align_table_header() 03:48 Using {dplyr} with {gt} 06:03 Create a table stub with rowname_col() 07:35 Customizing column labels with col_label() 09:45 Formatting table numbers with fmt_number() 12:10 Adjusting column width with cols_width() 15:39 Adding source notes with tab_source_note() 16:55 Adding footnotes with tab_footnote() 18:55 Customizing footnote marks with opt_footnote_marks() 19:10 Demo of how easy managing multiple footnotes is with {gt} 23:41 Customizing cell styles with tab_style() 27:07 Adding label text to the stubhead with tab_stubhead() 28:15 Changing table font with opt_table_font() 29:25 Automatically scaling cell color based on value using data_color()

With the gt package, anyone can make wonderful-looking tables using the R programming language. The gt philosophy: we can construct a wide variety of useful tables with a cohesive set of table parts. These include the table header, the stub, the column labels and spanner column labels, the table body, and the table footer.

It all begins with table data (be it a tibble or a data frame). You then decide how to compose your gt table with the elements and formatting you need for the task at hand. Finally, the table is rendered by printing it at the console, including it in an R Markdown document, or exporting to a file using gtsave(). Currently, gt supports the HTML, LaTeX, and RTF output formats.

The gt package is designed to be both straightforward yet powerful. The emphasis is on simple functions for the everyday display table needs.

Webinar Summary | Avoid Dashboard Fatigue | RStudio (2020)

0:00 Introduction 0:07 The Problem 1:05 The Solution 3:20 Real Life Success Stories 5:27 Demo (with code)

Don’t have an hour to watch a webinar? We’ve made a summary video that covers the main points of our “Avoid Dashboard Fatigue” webinar from Sean Lopp and Rich Iannone.

The full webinar covered: Data science teams face a challenging task. Not only do they have to gain insight from data, they also have to persuade others to make decisions based on those insights. To close this gap, teams rely on tools like dashboards, apps, and APIs. But unfortunately data organizations can suffer from their own success - how many of those dashboards are viewed once and forgotten? Is a dashboard of dashboards really the right solution? And what about that pesky, precisely formatted Excel spreadsheet finance still wants every week?

In this webinar, we’ll show you an easy way teams can solve these problems using proactive email notifications through the blastula and gt packages, and how RStudio pro products can be used to scale out those solutions for enterprise applications. Dynamic emails are a powerful way to meet decision makers where they live - their inbox - while displaying exactly the results needed to influence decision-making. Best of all, these notifications are crafted with code, ensuring your work is still reproducible, durable, and credible.

We’ll demonstrate how this approach provides solutions for data quality monitoring, detecting and alerting on anomalies, and can even automate routine (but precisely formatted) KPI reporting.

Sean Lopp & Rich Iannone | Avoid Dashboard Fatigue | RStudio (2020)

Data science teams face a challenging task. Not only do they have to gain insight from data, they also have to persuade others to make decisions based on those insights. To close this gap, teams rely on tools like dashboards, apps, and APIs. But unfortunately data organizations can suffer from their own success - how many of those dashboards are viewed once and forgotten? Is a dashboard of dashboards really the right solution? And what about that pesky, precisely formatted Excel spreadsheet finance still wants every week?

In this webinar, we’ll show you an easy way teams can solve these problems using proactive email notifications through the blastula and gt packages, and how RStudio pro products can be used to scale out those solutions for enterprise applications. Dynamic emails are a powerful way to meet decision makers where they live - their inbox - while displaying exactly the results needed to influence decision-making. Best of all, these notifications are crafted with code, ensuring your work is still reproducible, durable, and credible.

We’ll demonstrate how this approach provides solutions for data quality monitoring, detecting and alerting on anomalies, and can even automate routine (but precisely formatted) KPI reporting.

Rich Iannone | Introducing the gt package | RStudio (2019)

With the gt package, anyone can make great-looking display tables. Though the package is still early in development, you can do some really great things with it right now! I’ll walk through a few examples that touch upon the more common table-making use cases. These will include features like adding table parts, integrating footnotes, styling/transforming table cells, using tables in R Markdown documents, and even including gt tables in email messages.