Lists

Python · Reference cheat sheet

📋 Overview

A list is an ordered, mutable sequence. Use for collections that grow, shrink, or change in place. Prefer list methods and comprehensions over manual index loops. Heterogeneous types are allowed; typed code usually keeps one element type.

🔧 Core concepts

Create / access

Operation	Example
Create	`[1, 2]`, `list(iterable)`, `[]`
Index / slice	`xs[0]`, `xs[-1]`, `xs[1:3]`, `xs[i:j:k]`
Assign slice	`xs[1:3] = [9, 8]`; can change length
Unpack	`a, *mid, z = xs`

Instance methods

Method	Mutates?	Notes
`append(x)`	yes	Add one at end — O(1) amort.
`extend(it)`	yes	Add all from iterable; `xs += it`
`insert(i, x)`	yes	Insert before index `i` — O(n)
`pop([i])`	yes	Remove/return at `i` (default last)
`remove(x)`	yes	Remove first `== x`; `ValueError` if missing
`clear()`	yes	Remove all
`index(x[, start[, stop]])`	no	First index; `ValueError` if missing
`count(x)`	no	Occurrences of `x`
`sort(*, key=None, reverse=False)`	yes	In-place; returns `None`
`reverse()`	yes	In-place reverse
`copy()`	no	Shallow copy (`xs[:]` / `list(xs)`)

Builtins that operate on lists / sequences

Builtin	Notes
`len(xs)`	Length
`x in xs` / `x not in xs`	Membership — O(n)
`min` / `max` / `sum`	Over elements; `sum` needs numbers
`sorted(xs, *, key=…, reverse=…)`	New sorted list
`reversed(xs)`	Reverse iterator
`enumerate(xs, start=0)`	`(i, x)` pairs
`zip(*seqs)`	Parallel tuples (stops at shortest)
`all` / `any`	Truth of all / any elements
`map(fn, xs)` / `filter(fn, xs)`	Lazy; wrap with `list(...)`
`slice` assignment / `del xs[i]` / `del xs[a:b]`	Delete or replace ranges

Lists are dynamic arrays; append/pop at the end is amortized O(1). Insert/delete at the front is O(n).

💡 Examples

Build and mutate:

nums: list[int] = [3, 1, 4]
nums.append(1)
nums.extend([5, 9])
nums.insert(0, 0)
last = nums.pop()          # 9
nums.remove(1)             # removes first 1
print(nums)                # [0, 3, 4, 1, 5]

Sort with key:

people = [{"name": "bob", "age": 30}, {"name": "ada", "age": 25}]
people.sort(key=lambda p: p["age"])
names = sorted(people, key=lambda p: p["name"])

Comprehension and unpacking:

squares = [n * n for n in range(6) if n % 2 == 0]
a, *mid, z = [10, 20, 30, 40]
# a=10, mid=[20, 30], z=40

Stack / queue patterns:

stack: list[str] = []
stack.append("a")
stack.pop()                # LIFO

from collections import deque
q: deque[str] = deque()
q.append("a")
q.popleft()                # FIFO — prefer deque over list.pop(0)

⚠️ Pitfalls

xs + ys creates a new list; xs.extend(ys) mutates in place.
xs *= n and [[] ] * n share references for mutable elements.
list.sort returns None — use sorted when you need a new list.
Shallow copy does not deep-copy nested lists — see copy / deepcopy.
Prefer deque for frequent left pops; lists are poor queues.

Lists

Lists

📋 Overview

🔧 Core concepts

💡 Examples

⚠️ Pitfalls

🔗 Related

On this page