R for Statistics

There are two great open-source languages for working with data, and this book has taught you one of them. The other is R, and it comes at the same problems from the opposite direction. Python is a general-purpose programming language that grew a superb data ecosystem on top. R is a language designed from the start for statistics and graphics, where a t-test, a linear model, and a polished chart are built-in verbs rather than imported tools. This chapter is a guided overview: what R is, how it compares to Python, how its libraries line up with the ones you know, and why none of the statistics you have learned has to be relearned to use it.

R began in the early 1990s when Ross Ihaka and Robert Gentleman at the University of Auckland built a free implementation of S, the statistical language John Chambers had created at Bell Labs. It became part of the GNU project, and today it is maintained by a global core team and a vast community. That heritage matters: R was written by statisticians for statistical work, and the design shows everywhere.

Three things sit at R's core. Its everyday container is the vector, and like a NumPy array it is vectorized, so operations apply to whole vectors at once. Its table is the data frame, the direct ancestor of the pandas DataFrame. And its formula syntax, writing a model as outcome ~ predictor, lets you state a regression or an ANOVA almost exactly as you would on paper. One friendly warning for Python users: R counts from 1, not 0, so x[1] is the first element.

The most common question a new analyst asks is “which one should I learn?” The honest answer is that they overlap enormously and the best analysts read both. They differ most in the direction they were built from, and that origin still shapes where each one shines.

A fair summary: reach for R when the work is statistics-first, when you want the best exploratory graphics, or when you are writing a reproducible statistical report; reach for Python when the work heads toward machine learning, production systems, or general software. And you need not choose permanently. R's reticulate package lets R call Python, tools like Quarto run both in one document, and many teams use each where it is strongest. The rivalry is friendlier than the internet suggests.

Because you already know the Python stack from the previous chapter, the fastest way to learn R's is by translation. Almost every tool you have met has a close R counterpart, and often the correspondence is nearly one to one.

A word on ggplot2, R's signature contribution to data visualization. It implements the grammar of graphics: you build a chart by declaring a mapping from data columns to visual properties (position, color, size) and adding layers (points, lines, bars) on top. It is so influential that Python's own plotting libraries have borrowed from it, and for many statisticians it is the single best reason to open R.

Nothing makes the transfer clearer than seeing it. Here is the exact workflow from the Python chapter, read a file, group by a column, summarize, and plot, written in R beside the pandas you already know. Read them side by side and notice how the steps are identical even where the words differ.

Read the data and peek at it.

# readxl + the tidyverse
library(tidyverse)
library(readxl)
orders <- read_excel("store-orders.xlsx")
head(orders)
summary(orders)

# pandas
import pandas as pd
orders = pd.read_excel(
    "store-orders.xlsx")
orders.head()
orders.describe()

Group by region and total the revenue. This is the split-apply-combine you learned, in two dialects.

orders |>
  group_by(region) |>
  summarise(revenue = sum(revenue)) |>
  arrange(desc(revenue))

(orders
  .groupby("region")
  .revenue.sum()
  .sort_values(ascending=False))

R's pipe |> plays the exact role of pandas method chaining: it passes the result of one step into the next, so both read top to bottom as a pipeline. Run either one on the store-orders file from the last chapter and both report the same answer, North leading at 56,668 dollars, because the data and the arithmetic are the same; only the language differs.

Fit a model, and draw a chart. Here R's statistical heritage shows: the model is a one-liner in the base language, and ggplot2 builds the plot in readable layers.

# a linear model, built in
model <- lm(revenue ~ quantity, data = orders)
summary(model)

# grammar of graphics
ggplot(orders, aes(quantity, revenue)) +
  geom_point() +
  geom_smooth(method = "lm")

# statsmodels
import statsmodels.formula.api as smf
model = smf.ols(
    "revenue ~ quantity", orders).fit()
model.summary()

# seaborn
import seaborn as sns
sns.regplot(data=orders,
    x="quantity", y="revenue")

Look at what just happened. The formula revenue ~ quantity is identical in both, because statsmodels deliberately borrowed R's formula notation. The regression coefficients, the standard errors, the R-squared, the p-values will match. Everything you learned about reading a regression table in the regression chapters applies letter for letter. That is the whole point of this chapter in a single example.

R's center of gravity is statistics, and in depth of statistical method it is second to none. Where a technique is recent or specialized, there is very often an R package for it years before anywhere else, written by the researchers who invented it.

Where does Python pull ahead? Chiefly in deep learning and production AI. The frameworks that define modern neural networks, PyTorch and TensorFlow, are Python-first, and the engineering ecosystem for serving models at scale, the subject of the MLOps chapter, is largely Python too. R can reach these through interfaces, but this is Python's home turf. The practical reading of the whole landscape is simple: for statistical modeling, inference, and graphics, R is a first-class and often superior choice; for deep learning and shipping systems, lean Python. Many strong data scientists keep both within reach.

Eight questions on R, its comparison to Python, and how the two toolkits line up. Answer them, hit Check Answers, and keep refining until you score 100%. Your progress is saved.