Python.CodeCompared.To/R

R's cat() writes its arguments as plain text with no quotes and no index marker, but it does not add a trailing newline — you supply "\n" yourself. A top-level statement is a complete program, as in Python; there is no main.

R has two output functions. print() shows a value the way the console does — with a [1] position marker and quotes around strings ([1] "hi") — while cat() writes plain text. Python's print() is closer to R's cat().

R has no f-strings. The closest tools are sprintf() (C-style format) and paste(). Note that %d requires an integer, so age is written 30L; a plain 30 is a double and would error with %d.

R uses # for comments exactly like Python. Unlike Python's triple-quoted strings, R has no block-comment syntax — every line needs its own #.

An R script is run with Rscript, the counterpart to invoking python3. These are shell commands, not language statements, so they cannot run in the browser.

The idiomatic assignment operator in R is <-. Plain = also works for assignment, but convention reserves = for passing named arguments to functions, so <- is what you will see everywhere.

Like Python, R is dynamically typed: a variable can be rebound to a value of any type at any time. No declaration is needed.

A bare numeric literal in R is a double, even when it looks like an integer — class(5) is "numeric". To get a true integer you append L, as in 5L. Python instead infers int from 5 and float from 5.0.

R's boolean literals are the fully capitalised TRUE and FALSE (the abbreviations T and F also work but are discouraged). The operators are &&, ||, and ! rather than the words and, or, not.

Where Python has a single None, R has two distinct ideas: NULL is the absence of a value (an empty object), while NA is a present-but-unknown value used for missing data. Statistical code relies on this distinction constantly.

The everyday R collection is the atomic vector, built with c() ("combine"). All elements must share one type. It is closer to a typed array than to a Python list, and it is the foundation of nearly everything in R.

In R there is no separate scalar type — 42 is simply a numeric vector of length 1. You can take its length() (1) and index its first element with [1]. This is why operations generalise so naturally to whole vectors.

Arithmetic in R applies element-wise to a whole vector, so numbers * 2 needs no loop or comprehension. This is the single biggest day-to-day difference from Python: you describe the operation on the whole vector, not on each element.

R indexes from 1, not 0, so the first element is letters[1] and the last of three is letters[3]. This matches mathematical convention and is shared with Julia, Fortran, and MATLAB.

This is a classic trap. In Python a negative index counts from the end (-1 is the last element). In R a negative index excludes those positions, so numbers[-1] returns everything except the first element. To get the last element in R, use numbers[length(numbers)] or tail(numbers, 1).

R ranges are written start:end and are inclusive on both ends, so 2:3 selects the 2nd and 3rd elements and 1:5 is 1, 2, 3, 4, 5. Python slices are half-open and 0-based, so numbers[1:3] yields two elements and range(1, 6) stops before 6.

When two vectors differ in length, R recycles the shorter one to match the longer, so c(1,2,3,4) + c(10,20) gives 11 22 13 24. This is powerful but can hide bugs; R warns when the longer length is not a multiple of the shorter. Python has no built-in recycling.

Indexing a vector with a logical vector keeps the elements where the condition is TRUE. Here numbers > 10 produces a logical mask, and numbers[mask] selects the matching values — the idiomatic R replacement for a filtering comprehension.

R's reason for existing is statistics, so mean(), median(), sd(), var(), and quantile() are all in the base language with no import. Python needs the statistics module (or NumPy) for the mean.

The operators line up except for exponentiation: R writes powers with ^ (and also accepts **), whereas Python uses ** only.

R spells integer (floor) division %/% and the remainder %%. Python uses // and %. R's percent-delimited operators are a general mechanism — you can even define your own.

Math functions such as sqrt(), exp(), log(), sin(), and abs() are part of base R — no import math equivalent is needed because they live in the global namespace.

R rounds with round(), takes the floor with floor(), and rounds up with ceiling() — note the full spelling ceiling, not ceil. All are base functions.

R seeds its generator with set.seed() and draws with sample() (for discrete draws), runif() (uniform), or rnorm() (normal). The drawn value differs from Python's because the two languages use different generators, but each is reproducible once seeded.

R has the built-in literals Inf, -Inf, and NaN (not-a-number), alongside NA for missing data. Python expresses infinity and NaN through float("inf") and float("nan").

R does not concatenate strings with +. Use paste(), which joins with a space by default, or paste0(), which joins with no separator. Both are vectorised, joining corresponding elements of multiple vectors.

Use nchar() for the number of characters. A common surprise: length() of a single string is 1, because that string is a character vector of length 1 — length() counts elements, not characters.

R changes case with the standalone functions toupper() and tolower(), rather than the methods .upper()/.lower(). Almost everything in R is a function call on a value, not a method on an object.

A substring comes from substr(text, start, stop), with 1-based, inclusive positions — so 1, 4 takes the first four characters. You cannot slice a string with [] in R the way you can in Python; [] indexes vector elements, and a string is a single element.

R splits with strsplit(). Because it is vectorised over many strings at once, it returns a list of character vectors; [[1]] pulls out the result for the first (here only) string.

R replaces with gsub() (all matches) or sub() (first match only). The pattern is a regular expression by default; pass fixed = TRUE to match literally, the way Python's .replace() always does.

To test whether a string contains a pattern, R uses grepl() (read "grep logical"), which returns TRUE/FALSE. As with gsub(), the pattern is a regular expression unless you pass fixed = TRUE.

To collapse a character vector into one string, give paste() a collapse argument. Python instead calls .join() on the separator string. The R form keeps the separator and the data as separate arguments.

R's list() is the heterogeneous container — it can hold values of different types, each optionally named. A named list is the nearest thing to a Python dict, though its keys are positions-with-names rather than a hash map.

Two equivalent ways reach a named element: person$name (concise, for a literal name) and person[["name"]] (works when the name is in a variable). Single brackets person["name"] return a one-element sub-list, not the value — a frequent source of confusion.

Assigning to a name that does not yet exist adds it; assigning to one that does replaces it — the same as Python dicts. R uses person$age <- 30 or person[["age"]] <- 30.

The names of a list come from names(), the counterpart to dict.keys(). There is no single .values(); unlist() flattens the values into a vector (coercing to a common type), which is the usual way to see them together.

R has no direct .items(); the idiom is to loop over names() and look each value up with [[ ]]. (For transforming a list, the apply family is usually preferred over an explicit loop.)

The key R distinction Python does not make: c() builds an atomic vector and forces every element to one type (here everything becomes a string), while list() keeps each element's own type. A Python list behaves like R's list(), not its vector.

The data.frame is built into base R — it is the structure that inspired pandas, so a column-per-named-vector layout feels immediately familiar. The Python column needs pandas (pip install pandas) and so does not run here; the R column runs live with no package install.

A column is just a named element of the data frame, reached with df$age — the same $ used on lists, because a data frame is a list of equal-length columns. The result is an ordinary vector you can compute on directly.

Data frames are indexed df[rows, columns]. A logical vector in the row slot keeps matching rows; the empty column slot (after the comma) keeps every column. The trailing comma is required — df[df$age > 28] without it selects columns, not rows.

Assigning to a new name with $ adds a column, and because column arithmetic is vectorised, df$age * 12 computes the whole new column at once — no row loop.

Calling summary() on a data frame reports the min, quartiles, median, and mean of every column — the base-R analogue of pandas' .describe(). summary() is a generic that adapts its output to whatever it is given.

Base R groups with aggregate() using a formula: score ~ team reads as "score by team". The ~ formula notation, which expresses a relationship between variables, is pervasive in R's modelling functions and has no Python equivalent.

R's conditional uses parentheses around the test and braces around each block, and spells the middle branch else if (two words) rather than Python's elif. The else must sit on the same line as the closing brace of the previous block.

R has two pairs of logical operators. The single forms & and | are vectorised, combining vectors element-wise. The double forms && and || take only single values and are what you use in an if condition.

For a choice applied across a whole vector, R provides ifelse(test, yes, no), which evaluates the condition element-wise and picks from yes or no position by position. A plain if is for a single decision; ifelse() is for a vector of them.

R's switch() matches a string against named branches; a final unnamed argument acts as the default. It is an expression that returns a value, closer to Python's match used for simple value dispatch than to a C-style switch.

R has no truthiness for containers: you cannot write if (items) for an empty vector — test length(items) == 0 instead. An if condition must be a single logical value, and supplying a longer vector is an error, as the caught message shows.

A function in R is a value created with function(...) and bound to a name like any other variable. The value of the last expression is returned automatically, so an explicit return() is usually omitted.

Default argument values work just as in Python, written with = in the parameter list. R goes further: a default can even reference other arguments, because defaults are evaluated lazily, only when the argument is first used.

R's lambda is the backslash shorthand \(x) x ^ 2 (added in R 4.1), equivalent to the longer function(x) x ^ 2. Unlike a Python lambda, the body is an ordinary expression and can be any single expression, including a braced block.

R collects extra arguments with ... (the "dots"), the counterpart to Python's *args. The dots can be passed straight through to another function, which is how wrappers forward arguments they do not name themselves.

R functions return a single object, so to hand back several values you wrap them in a (usually named) list and unpack them afterward with $. Python instead returns a tuple and destructures it on assignment.

A nested function captures its enclosing environment, exactly like a Python closure. To assign to a captured variable, R uses the super-assignment operator <<-, which walks outward to find an existing binding — the role Python's nonlocal plays.

R's for loop iterates directly over the elements of a vector, like Python's. It works, but R programmers reach for the vectorised apply family below far more often than for explicit loops.

When you do need to apply a function element by element, sapply() maps it over a vector and simplifies the result back to a vector — the closest match to Python's map() or a list comprehension.

When results have differing shapes, use lapply(), which always returns a list (one element per input) without trying to simplify. Here each element is a vector of a different length, so a list is the right container.

R's Reduce() folds a binary function across a vector, the same idea as Python's functools.reduce. (For a plain sum you would just call sum(); Reduce() is for accumulations with no dedicated function.)

mapply() applies a function to corresponding elements of several vectors at once — the role Python fills by pairing zip() with a comprehension. (For simple addition, recycling already gives a + b directly.)

The while loop is nearly identical; R wraps the condition in parentheses and the body in braces. R has no +=, so the counter is advanced with count <- count + 1.

R's NA is a first-class missing value that lives inside numeric vectors. Any arithmetic touching it yields NA — so sum(c(1, NA, 3)) is NA — which forces you to decide explicitly how to handle missingness rather than silently ignoring it.

Test for missing values with is.na(), which returns a logical vector marking each NA. Crucially, you cannot compare with == NA — that itself returns NA — so is.na() is the only correct check.

Most R summary functions accept na.rm = TRUE to drop missing values before computing — mean(), sum(), sd(), and so on. This built-in switch is far tidier than filtering the data first, as Python requires.

A factor is R's type for categorical data: it stores the values as codes plus a set of levels (the distinct categories). Factors are how R represents groups in models and tables — a concept base Python leaves to plain strings.

Declaring a factor ordered = TRUE with explicit levels gives the categories a rank, so comparisons like ratings < "high" work directly. In Python you would maintain a lookup table of ranks yourself.

R's simplest object system, S3, is remarkably lightweight: an object is just an ordinary value (here a list) with a class attribute attached. There is no class declaration — you label the data and that label drives method dispatch.

S3 methods live outside the object. A generic calls UseMethod("speak"), and R dispatches to speak.Dog based on the class of the first argument. So methods are named generic.class and belong to the function, not the data — the reverse of Python's object-owns-its-methods model.

Because print() is itself a generic, defining print.Point customises how points display — the S3 counterpart to Python's __repr__. The same pattern extends built-in generics like summary() and format() to your own types.

R signals an error with stop(), the counterpart to Python's raise. The message text is read back from a caught error with conditionMessage().

tryCatch() is R's try/except. You supply a handler keyed by condition class — error = function(e) ... — that runs if the expression raises that condition, and whose value becomes the result. (Note R divides by zero numerically to Inf, so the example raises its own error to illustrate handling.)

A warning() is a non-fatal signal that, unlike stop(), does not abort execution by default. tryCatch() can intercept warnings too by supplying a warning = handler, mirroring how Python can promote warnings to exceptions.

tryCatch() takes a finally argument that always runs, whether or not an error occurred — the same guarantee as Python's finally block, useful for releasing resources.