R.CodeCompared.To/Python

Python’s print adds the newline cat makes you write — and unlike R’s print, it does not prefix output with [1], because what it prints is not a vector (a running theme on this page).

Python has one assignment operator, =, with no arrow and no right-assign ->. Note print takes multiple arguments the way cat does. (Python’s := "walrus" exists but only inside expressions — closer to a special case than to <-.)

Capitalization changes: True/False/None. There is no T/F shorthand — which also removes R’s classic footgun of T being an ordinary variable someone can overwrite. Note the block syntax: a colon and indentation, no braces — whitespace is the structure.

Counting starts at zero: element one lives at [0], and the last element of n items lives at [n - 1]. Every off-by-one instinct from R needs one turn of adjustment — the next two rows are where it bites hardest.

The single nastiest trap for an R user, because both languages accept the same syntax and mean opposite things: R’s negative index excludes ("everything but position 1"); Python’s negative index selects from the end. Exclusion in Python is a slice or a comprehension, never a minus.

A Python slice [start:stop] includes start and excludes stop — so R’s 2:4 becomes [1:4] after both the zero-shift and the open end. The consolation prizes: stop - start is always the length, and either end may be omitted.

R has no scalars — 5 is a length-one vector, which is why everything vectorizes. Python inverts this: 5 is a plain int with no length, lists are containers of scalars, and nothing vectorizes by default (next row).

Arithmetic on lists is sequence algebra, not math: * repeats and + concatenates. Elementwise work on plain lists is a comprehension — or numpy, next row, where the R instinct is restored. (There is also no recycling anywhere: mismatched lengths are an error, not a warning.)

A numpy array behaves like an R vector: elementwise arithmetic, vectorized math functions, comparisons producing boolean masks. The mental translation is that base-R’s vector semantics are a library in Python — the one nearly every scientific package is built on. Note doses.mean(): functions become methods called on the data.

range(start, stop) excludes its stop, consistent with slicing — R’s 1:5 is range(1, 6). A range is also lazy: it produces values on demand (hence list(...) to print them), and range(len(items)) is usually a smell — iterate the items directly.

seq(by =) maps to range’s third argument for integers; fractional steps and length.out belong to numpy (arange, linspace). The split is the theme again: base Python for counting, numpy for numerics.

pandas is R’s data frame transplanted (its author was porting R idioms to Python), built from a dictionary of columns. nrow becomes len, str() becomes .info(), and the printed frame shows pandas’ row index — a first hint that rows have names the way R’s row numbers never quite did.

df$column becomes df["column"] — and a column is a Series, pandas’ vector, which vectorizes like one (> 40 yields a boolean Series). Attribute access patients.age also works for reading but breaks on names that clash with methods, so the brackets are the durable habit.

Boolean-mask filtering translates directly — minus the trailing comma, since pandas indexing selects rows by default. .query() plays subset(), evaluating column names inside a string. Two spellings to note: combined masks need &/| with parentheses (never and/or), and .loc[] is the explicit row/column selector R’s [rows, columns] becomes.

The split-apply-combine idiom reads left to right as a method chain: group, select, aggregate. There is no formula interface (value ~ group has no Python equivalent) — the chain of named steps is how pandas spells what R distributes between formulas, aggregate, and dplyr verbs.

The safety net is gone: R’s copy-on-modify means assignment behaves like a copy; Python assignment just points a second name at the same object, and mutation is visible through every alias. .copy() (or df.copy() in pandas) restores the R behavior — explicitly, every time.

In R, a function cannot change your data — arguments are effectively copies. In Python, mutable arguments are passed as references, and append-style methods change the caller’s object. Well-behaved code either mutates deliberately and documents it, or builds new values (values + [new_value]) — but the language no longer enforces the choice.

A Python function without return returns None — silently. R’s last-expression-is-the-value habit is the source of a classic migration bug: a function that computes everything and returns nothing. Note also base Python has no mean/sd; they live in statistics or numpy.

R’s single ... splits into two: *values collects extra positional arguments as a tuple, **options collects extra named arguments as a dictionary. Argument passing is otherwise familiar — positional, named (verbose=True), defaults in the signature — with one famous trap: default values are evaluated once, so a mutable default like def f(items=[]) is shared across calls.

R’s \(x) shorthand becomes lambda x: — limited to a single expression, and style guides prefer a named def for anything reused. The second line foreshadows the next section: where R reaches for sapply + lambda, Python usually reaches for a comprehension and skips the lambda entirely. Exponentiation is **, not ^ (which is XOR!).

The comprehension is Python’s sapply, with the filter clause built in — [expr for item in items if condition] covers sapply + logical-subsetting in one readable line. It is the single most idiomatic construct in the language, the way vectorized subsetting is in R.

R’s named list is Python’s dict — the workhorse container, with .items() yielding name/value pairs. The dict comprehension plays lapply over one, preserving names. (Loops are also perfectly idiomatic Python — there is no vectorize-or-else performance culture for ordinary code.)

R’s single, typed, propagating NA splits into pieces: None (generic absence, not numeric, raises on arithmetic) and the float nan (numeric, propagates, unequal even to itself). Base Python has no na.rm story at all — that lives in pandas, next row.

pandas restores an R-like missing story (None becomes NaN in a Series, isna() plays is.na) with one default flipped: aggregations skip missing values unless told otherwise — the opposite of R’s conservative NA-propagation. Know which default you are standing on.

The f-string covers both paste and sprintf: expressions interpolate inside {}, and format specs ride after a colon (:.1f). Joining a vector of strings inverts subject and verb — R’s paste(words, collapse = ", ") is Python’s ", ".join(words), called on the separator.

Function-wrapping becomes method-calling: toupper(x) → x.upper(), and the strsplit(...)[[1]] dance disappears because split returns a plain list. Membership is the readable in operator; regular expressions move to the re module (replace here is literal, unlike sub).

The dispatch direction flips: S3 attaches a class tag to data and lets generic functions choose an implementation; Python puts the methods inside the class, and dunder methods like __str__ are the hooks built-ins consult. self is explicit in every method signature, and __init__ plays the constructor R never quite formalized.

Much of the standard library hangs off the values themselves — and method spelling often signals mutation: values.sort() sorts in place and returns None (assigning its result is another classic migration bug), while the function sorted(values) returns a new list like R’s sort always did.

stop becomes raise with a typed exception, and the handler is a block rather than a function — except RuntimeError as error plays the error = handler, finally transfers by name. Exceptions are classes, so handlers can be as specific (FileNotFoundError) or broad (Exception) as the R condition system’s classes allowed.

Warnings survive as a module rather than a language feature: warnings.warn emits without halting, and filters control whether warnings print once, always, or escalate to errors — the machinery behind the deprecation notices every Python data library uses.

Method chaining is Python’s pipe: each call returns an object whose methods continue the sentence, wrapped in parentheses for the multi-line layout. Where R bolted |> onto a function-first language, pandas was designed around chains from the start — the dplyr feel without the operator.

The rough map: pandas absorbs dplyr, tidyr, and readr; numpy is the vector substrate; matplotlib is base plotting with seaborn on top (and plotnine is a literal ggplot2 port, grammar of graphics included); scikit-learn anchors modeling. install.packages becomes pip install into a per-project virtual environment. Both cells are import inventories, shown display-only.