Python List Methods Cheat Sheet

Mutable ordered sequence. Indexable, sliceable, allows duplicates and mixed types. For the full tutorial, see Lists.

Creating

python

a = [1, 2, 3]
b = list()                  # []
c = list("abc")             # ['a','b','c']
d = list(range(5))          # [0,1,2,3,4]
e = [0] * 5                 # [0,0,0,0,0]
f = [[0] * 3 for _ in range(3)]   # 3x3 grid — correct way

# TRAP: shared inner refs
bad = [[0] * 3] * 3         # all rows are the SAME list!
bad[0][0] = 9               # mutates all three rows

Indexing & Slicing

python

x = [10, 20, 30, 40, 50]
x[0]        # 10
x[-1]       # 50
x[1:4]      # [20, 30, 40]
x[::2]      # [10, 30, 50]
x[::-1]     # [50, 40, 30, 20, 10]   reverse copy
x[1:3] = [99]   # slice assignment: [10, 99, 40, 50]

Adding

Method	What it does	Example	Result
`.append(x)`	Add single item	`[1,2].append(3)`	`[1,2,3]`
`.extend(it)`	Add all items from iterable	`[1].extend([2,3])`	`[1,2,3]`
`.insert(i, x)`	Insert at index	`[1,3].insert(1,2)`	`[1,2,3]`
`a + b`	Concatenate (new list)	`[1] + [2]`	`[1,2]`
`a += b`	In-place extend	`a += [4]`	mutates `a`
`a * n`	Repeat	`[0] * 3`	`[0,0,0]`

python

# append vs extend
xs = [1, 2]
xs.append([3, 4])    # [1, 2, [3, 4]]   nested
xs = [1, 2]
xs.extend([3, 4])    # [1, 2, 3, 4]     flat

Removing

Method	What it does	Raises
`.pop()`	Remove & return last	`IndexError` if empty
`.pop(i)`	Remove & return at i	`IndexError` if oob
`.remove(x)`	Remove first occurrence of value	`ValueError` if missing
`del a[i]`	Remove by index, no return	`IndexError`
`del a[i:j]`	Remove slice	—
`.clear()`	Empty the list	—

python

xs = [1, 2, 3, 2]
xs.remove(2)        # [1, 3, 2]    first match only
xs.pop()            # returns 2, xs = [1, 3]
del xs[0]           # xs = [3]
xs.clear()          # []

Searching

python

3 in [1, 2, 3]              # True
4 not in [1, 2, 3]          # True
[1, 2, 2, 3].count(2)       # 2
[1, 2, 3].index(2)          # 1
[1, 2, 3].index(9)          # ValueError
[1, 2, 3, 2].index(2, 2)    # 3      start search from idx 2

Sorting

python

xs = [3, 1, 2]
xs.sort()                       # in place, returns None
sorted(xs)                      # new list, original untouched

xs.sort(reverse=True)           # descending
sorted(["bb", "a", "ccc"], key=len)         # ['a','bb','ccc']
sorted(items, key=lambda x: x.age)
sorted(items, key=lambda x: (x.age, x.name))  # multi-key

# Stable sort: ties keep original order

+ setup added so this can run · defines items

# Lightweight mock for objects whose attributes/methods aren't critical
class _AutoMock:
    def __init__(self, name='mock'): self._name = name
    def __getattr__(self, k): return _AutoMock(self._name + '.' + k)
    def __call__(self, *a, **kw):
        print('-> ' + self._name + '() called')
        return _AutoMock(self._name + '()')
    def __repr__(self): return '<mock ' + self._name + '>'
    def __str__(self): return '<mock ' + self._name + '>'
    def __bool__(self): return True
    def __iter__(self): return iter([])
    def __len__(self): return 0
    def __getitem__(self, k): return _AutoMock(self._name + '[...]')
    def __setitem__(self, k, v): pass
    def __enter__(self): return self
    def __exit__(self, *a): return False
    async def __aenter__(self): return self
    async def __aexit__(self, *a): return False
    def __add__(self, o): return self
    def __radd__(self, o): return self
    def __sub__(self, o): return self
    def __mul__(self, o): return self
    def __rmul__(self, o): return self
    def __truediv__(self, o): return self
    def __eq__(self, o): return isinstance(o, _AutoMock)
    def __hash__(self): return hash(self._name)
    def __lt__(self, o): return True
    def __le__(self, o): return True
    def __gt__(self, o): return False
    def __ge__(self, o): return False
    def __mro_entries__(self, bases): return (object,)

items = _AutoMock('items')

Reversing

python

xs = [1, 2, 3]
xs.reverse()        # in place: [3, 2, 1]
list(reversed(xs))  # new list iterator
xs[::-1]            # new reversed list

Copying

python

a = [1, 2, 3]
b = a               # SAME list (alias) — mutations shared
b = a.copy()        # shallow copy
b = a[:]            # shallow copy
b = list(a)         # shallow copy

import copy
b = copy.deepcopy(a)  # full recursive copy (for nested)

Shallow copy duplicates the outer list only; nested objects remain shared. See Deep vs shallow copy.

Iterating

python

for x in xs:                    ...
for i, x in enumerate(xs):      ...
for i, x in enumerate(xs, 1):   ...   # start at 1
for a, b in zip(xs, ys):        ...
for a, b, c in zip(xs, ys, zs): ...

+ setup added so this can run · defines xs, ys, zs

# Lightweight mock for objects whose attributes/methods aren't critical
class _AutoMock:
    def __init__(self, name='mock'): self._name = name
    def __getattr__(self, k): return _AutoMock(self._name + '.' + k)
    def __call__(self, *a, **kw):
        print('-> ' + self._name + '() called')
        return _AutoMock(self._name + '()')
    def __repr__(self): return '<mock ' + self._name + '>'
    def __str__(self): return '<mock ' + self._name + '>'
    def __bool__(self): return True
    def __iter__(self): return iter([])
    def __len__(self): return 0
    def __getitem__(self, k): return _AutoMock(self._name + '[...]')
    def __setitem__(self, k, v): pass
    def __enter__(self): return self
    def __exit__(self, *a): return False
    async def __aenter__(self): return self
    async def __aexit__(self, *a): return False
    def __add__(self, o): return self
    def __radd__(self, o): return self
    def __sub__(self, o): return self
    def __mul__(self, o): return self
    def __rmul__(self, o): return self
    def __truediv__(self, o): return self
    def __eq__(self, o): return isinstance(o, _AutoMock)
    def __hash__(self): return hash(self._name)
    def __lt__(self, o): return True
    def __le__(self, o): return True
    def __gt__(self, o): return False
    def __ge__(self, o): return False
    def __mro_entries__(self, bases): return (object,)

xs = ["alpha", "beta", "gamma"]
ys = _AutoMock('ys')
zs = _AutoMock('zs')

Comprehensions

python

[x * 2 for x in xs]
[x for x in xs if x > 0]
[x if x > 0 else 0 for x in xs]
[(i, x) for i, x in enumerate(xs)]
[x for row in matrix for x in row]      # flatten 2D

+ setup added so this can run · defines xs, matrix

xs = [3, -1, 4, -1, 5]
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

See List Comprehensions.

Common Patterns

python

# Flatten one level
flat = [x for row in matrix for x in row]

# Dedup preserving order
seen = set()
unique = [x for x in xs if not (x in seen or seen.add(x))]
# Or 3.7+: list(dict.fromkeys(xs))

# Chunked into size n
chunks = [xs[i:i+n] for i in range(0, len(xs), n)]

# Min/max/sum
min(xs);  max(xs);  sum(xs)
max(items, key=lambda x: x.score)

# All / any
all(x > 0 for x in xs)
any(x == target for x in xs)

# Swap two
xs[i], xs[j] = xs[j], xs[i]

+ setup added so this can run · defines xs, items, matrix, j, n, target

# Lightweight mock for objects whose attributes/methods aren't critical
class _AutoMock:
    def __init__(self, name='mock'): self._name = name
    def __getattr__(self, k): return _AutoMock(self._name + '.' + k)
    def __call__(self, *a, **kw):
        print('-> ' + self._name + '() called')
        return _AutoMock(self._name + '()')
    def __repr__(self): return '<mock ' + self._name + '>'
    def __str__(self): return '<mock ' + self._name + '>'
    def __bool__(self): return True
    def __iter__(self): return iter([])
    def __len__(self): return 0
    def __getitem__(self, k): return _AutoMock(self._name + '[...]')
    def __setitem__(self, k, v): pass
    def __enter__(self): return self
    def __exit__(self, *a): return False
    async def __aenter__(self): return self
    async def __aexit__(self, *a): return False
    def __add__(self, o): return self
    def __radd__(self, o): return self
    def __sub__(self, o): return self
    def __mul__(self, o): return self
    def __rmul__(self, o): return self
    def __truediv__(self, o): return self
    def __eq__(self, o): return isinstance(o, _AutoMock)
    def __hash__(self): return hash(self._name)
    def __lt__(self, o): return True
    def __le__(self, o): return True
    def __gt__(self, o): return False
    def __ge__(self, o): return False
    def __mro_entries__(self, bases): return (object,)

xs = _AutoMock('xs')
items = _AutoMock('items')
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
j = _AutoMock('j')
n = _AutoMock('n')
target = _AutoMock('target')

Common Errors

Error	Cause	Fix
`IndexError: list index out of range`	`xs[i]` where `i >= len(xs)`	Check `len(xs)` or guard with `if i < len(xs)`
`ValueError: list.remove(x): x not in list`	`.remove(x)` when x absent	Test `if x in xs` first
`TypeError: 'NoneType' object is not iterable`	`xs = xs.sort()` — `.sort()` returns `None`	Use `sorted(xs)` or call `.sort()` separately
All rows share state in 2D list	`[[0]3]3` repeats same inner ref	Use `[[0]*3 for _ in range(3)]`
Skipped/duplicate items during loop	Mutating list while iterating	Iterate over a copy `for x in xs[:]:` or build new list
`TypeError: '<' not supported between instances of 'str' and 'int'`	Mixed types in `.sort()`	Sort homogeneous data or use `key=str`

1 · The lesson

Creating

Indexing & Slicing

Adding

Removing

Searching

Sorting

Reversing

Copying

Iterating

Comprehensions

Common Patterns

Common Errors

See Also

Practice this