Lists in R: Create, Access ([[ vs $ vs [) and Modify

A List Holds Anything

A vector has one hard rule: every element must be the same type. A list has no such rule. Each element of a list can be a different type, a different length, even another list. It's R's general-purpose container:

person <- list(
  name = "Rosa",
  age = 30,
  scores = c(70, 85, 92),
  active = TRUE
)

print(length(person))
str(person)

length() reports 4 - four elements, even though one of them (scores) contains three numbers itself. A list counts its compartments, not what's inside them. str() (structure) is the fastest way to see what a list actually holds - one line per element with its name, type, and a preview. Make str() a reflex: whenever a function hands you something and you're not sure what it is, str() it.

Names are optional (list(1, "a", TRUE) is legal) but almost always worth having - a named list documents itself.

The Three Ways In: [, [[ and $

This is the part of lists that everyone gets wrong once, so let's get it exactly right. There are three access operators, and they do two different jobs:

• [ returns a smaller list - a container of the same kind, holding whatever you selected.
• [[ returns the element itself - the actual value inside the compartment.
• $ is shorthand for [[ with a literal name: person$age is person[["age"]].

The difference is invisible when you print casually and very visible the moment you try to compute:

person <- list(name = "Rosa", age = 30, scores = c(70, 85, 92))

print(class(person["scores"]))
print(class(person[["scores"]]))

print(mean(person[["scores"]]))
print(person$age + 1)

person["scores"] has class "list" - a list of length 1 with the scores vector inside it. person[["scores"]] has class "numeric" - the vector itself, ready for mean(). Call mean() on the single-bracket version and you get an error about the argument not being numeric; that error message is almost always a sign you used [ where you meant [[.

A metaphor that sticks: a list is a train. [ gives you a shorter train - still a train. [[ opens a carriage and hands you the cargo.

So when is [ the right tool? When you want several elements and want to keep them packaged:

person <- list(name = "Rosa", age = 30, scores = c(70, 85, 92))

subset <- person[c("name", "age")]
str(subset)

You can't pull two elements "themselves" at once - two values need a container - so multi-element selection is always single-bracket, and always yields a list.

One more difference: $ uses partial matching (person$sc finds scores if it's unambiguous), which is convenient in the console and a liability in scripts. In code that has to keep working, prefer [[ with the full name - it also accepts a name stored in a variable, which $ can't do.

Adding, Changing, Removing

Lists grow and shrink by plain assignment - no special append method needed:

person <- list(name = "Rosa", age = 30)

person$email <- "rosa@example.com"
person[["age"]] <- 31
person[[length(person) + 1]] <- "extra"

str(person)

person$email <- NULL
print(names(person))

• Assigning to a name that doesn't exist yet adds the element.
• Assigning to an existing name replaces it.
• Assigning to position length(x) + 1 appends an unnamed element.
• Assigning NULL removes the element entirely - the list gets shorter. (This is the one place NULL acts as a deletion command; if you genuinely need to store "nothing" in a compartment, use x["k"] <- list(NULL).)

To glue two lists end to end, c() works on lists just as it does on vectors: c(list_a, list_b) returns one longer list.

Nested Lists

Because a list element can be another list, lists nest to any depth - which makes them R's natural shape for structured data like parsed JSON or grouped results:

company <- list(
  name = "Acme",
  ceo = list(name = "Mia", start_year = 2019),
  offices = list(
    berlin = list(staff = 12),
    tokyo = list(staff = 31)
  )
)

print(company$ceo$name)
print(company[["offices"]][["tokyo"]][["staff"]])

Drilling in is just chaining accessors - each $ or [[ steps one level deeper. When a nested structure gets confusing, str(company) shows the whole tree at once, and str(company, max.level = 1) shows just the top layer.

Flattening with unlist()

unlist() collapses a list - however deeply nested - into a single vector:

grades <- list(math = c(80, 90), art = 75)

flat <- unlist(grades)
print(flat)
print(class(flat))

mixed <- unlist(list(a = 1, b = "two"))
print(mixed)
print(class(mixed))

Two things to notice. First, unlist() builds names for you (math1, math2, art) so you can still tell where each value came from. Second - and this is the trap - a vector holds only one type, so unlisting a mixed list coerces everything to the most flexible type present. The number 1 came back as the string "1". If you unlist and your numbers turn into text, the list wasn't as uniform as you thought.

Why Lists Matter

Lists can feel like a beginner topic you'll outgrow. It's the opposite - they're load-bearing across the whole language:

• Functions that return several things return a list. R functions return one object; a list makes that one object carry a fitted value here, a coefficient table there. When you run a regression, the model object you get back is a (large, classed) list - str() on it proves it.
• A data frame is a list of columns - equal-length vectors with some extra behavior on top. Everything you just learned ($, [[, assigning NULL to drop an element) applies verbatim to data frame columns.
• The apply family - lapply() and friends - takes a list, applies a function to each element, and hands back a list. Lists in, lists out is the standard shape of repeated computation in R.

What You Take Away

• Lists hold anything: mixed types, unequal lengths, other lists, whole data frames.
• [ returns a smaller list; [[ returns the element itself; $ is [[ with a literal name. Reaching for math? You want [[ or $.
• Add by assigning to a new name, remove by assigning NULL, combine with c().
• unlist() flattens to a vector and coerces mixed types on the way - check the result's class.
• Data frames are lists of columns, so this knowledge transfers directly.

Next up: matrices - the all-one-type, rows-and-columns counterpart to the list.