Lists

grid = [[0] * 3 for _ in range(2)]  # 2 rows, 3 columns
grid[0][0] = 1
print(grid)  # [[1, 0, 0], [0, 0, 0]]
 
bad = [[0] * 3] * 2  # the same row object, twice
bad[0][0] = 1
print(bad)  # [[1, 0, 0], [1, 0, 0]]

xs = [10, 20, 30, 40, 50]
evens = slice(None, None, 2)  # a reusable, named slice
xs[evens]  # [10, 30, 50]
evens.indices(len(xs))  # (0, 5, 2): resolved bounds
 
first, *rest = xs  # 10 and [20, 30, 40, 50]
*init, last = xs  # [10, 20, 30, 40] and 50
head = xs[0] if xs else None  # no xs.get(i, default)

xs = ["a", "d"]
xs.insert(1, "b")  # ['a', 'b', 'd']
xs[2:2] = ["c"]  # insert at 2: ['a', 'b', 'c', 'd']
xs[1:3] = ["X"]  # 2 items become 1: ['a', 'X', 'd']
xs[len(xs) :] = ["e", "f"]  # same as extend
del xs[-2:]  # ['a', 'X', 'd']
xs += "pq"  # ['a', 'X', 'd', 'p', 'q']
xs.pop()  # 'q'
xs.remove("X")  # ['a', 'd', 'p']
 
ys = [0, 1, 2, 3, 4, 5]
ys[::2] = [9, 9, 9]  # [9, 1, 9, 3, 9, 5]
del ys[1::2]  # [9, 9, 9]
 
zs: list[object] = [1, 2]
zs.append([3, 4])  # nests: [1, 2, [3, 4]]
zs.extend([3, 4])  # [1, 2, [3, 4], 3, 4]

xs = [3, 1, 4, 1, 5, 9, 2, 6]
4 in xs  # True
xs.index(1), xs.index(1, 2)  # (1, 3)
xs.count(1)  # 2
max(xs), min(xs, key=lambda n: abs(n - 7))  # (9, 6)
max([], default=None)  # None
next((n for n in xs if n > 4), None)  # 5
max(range(len(xs)), key=xs.__getitem__)  # 5: argmax
[i for i, n in enumerate(xs) if n == 1]  # [1, 3]
 
[1, 2] < [1, 2, 0], [2] > [1, 99]  # (True, True)

from operator import attrgetter, itemgetter
 
words = ["banana", "Cherry", "apple", "fig"]
sorted(words)  # ['Cherry', 'apple', 'banana', 'fig']
sorted(words, key=str.casefold)
# ['apple', 'banana', 'Cherry', 'fig']
sorted(words, key=len, reverse=True)  # stable ties
# ['banana', 'Cherry', 'apple', 'fig']
 
rows = [("ann", 31), ("bo", 25), ("cy", 31)]
sorted(rows, key=itemgetter(1))  # by age
# [('bo', 25), ('ann', 31), ('cy', 31)]
sorted(rows, key=lambda r: (-r[1], r[0]))  # age desc, name
# [('ann', 31), ('cy', 31), ('bo', 25)]
 
nums = [3, None, 1]
sorted(nums, key=lambda n: (n is None, n))  # None last
# [1, 3, None]
 
by = attrgetter("last", "first")  # objects: key=by

from itertools import accumulate, pairwise
 
names = ["ann", "bo", "cy"]
scores = [90, 72, 85]
 
for rank, name in enumerate(names, start=1):
    print(rank, name)  # 1 ann, 2 bo, 3 cy
 
passed = [n for n, s in zip(names, scores) if s >= 80]
# ['ann', 'cy']
by_name = dict(zip(names, scores, strict=True))
# {'ann': 90, 'bo': 72, 'cy': 85}
list(accumulate([1, 2, 3, 4]))  # [1, 3, 6, 10]
[b - a for a, b in pairwise([1, 4, 9, 16])]  # [3, 5, 7]

xs = [1, 2, 2, 3]
for x in xs:
    if x == 2:
        xs.remove(x)  # ❌ skips the item after x
print(xs)  # [1, 2, 3]
 
xs = [1, 2, 2, 3]
xs[:] = [x for x in xs if x != 2]  # ✅ [1, 3], same list
for x in xs.copy():  # ✅ or loop over a copy
    if x == 1:
        xs.remove(x)

import copy
 
a = [[1, 2], [3]]
b = a  # alias
c = a.copy()  # new outer list, same inner lists
d = copy.deepcopy(a)  # nothing shared
 
a[0].append(99)
a.append([4])
print(b)  # [[1, 2, 99], [3], [4]]
print(c)  # [[1, 2, 99], [3]]
print(d)  # [[1, 2], [3]]
 
xs = [1]
ys = xs
xs += [2]  # in place: ys is [1, 2]
xs = xs + [3]  # new list: ys stays [1, 2]
 
 
def tag(items: list[str]) -> None:
    items.append("seen")  # mutates the caller's list
 
 
names = ["ann"]
tag(names)  # names is ['ann', 'seen']

import sys
from array import array
 
sys.getsizeof([])  # 56: header only (64-bit CPython)
sys.getsizeof([None] * 3)  # 80: plus 3 pointers of 8 bytes
sys.getsizeof(1.0)  # 24: each float is its own object
 
prices = array("d", [1.5, 2.25])  # packed C doubles
prices.append(3.0)  # 8 bytes per item, no objects

import heapq
from bisect import bisect_left, bisect_right
from itertools import accumulate
 
jobs = [(2, "b"), (1, "a"), (2, "c")]
h: list[tuple[int, int, str]] = []
for i, (prio, name) in enumerate(jobs):
    heapq.heappush(h, (prio, i, name))  # i breaks ties
heapq.heappop(h)  # (1, 1, 'a')
 
xs = [1, 3, 3, 3, 7]
bisect_left(xs, 3), bisect_right(xs, 3)  # (1, 4)
bisect_right(xs, 3) - bisect_left(xs, 3)  # 3 copies of 3
bisect_left(range(100), True, key=lambda m: m * m >= 50)
# 8: the smallest m with m * m >= 50
 
pre = [0, *accumulate([2, 4, 1, 5])]  # [0, 2, 6, 7, 12]
pre[3] - pre[1]  # 5: items 1 and 2 summed in O(1)
 
grid = ["..#", "...", "#.."]
R, C = len(grid), len(grid[0])
r, c = 0, 0
nbrs = [
    (r + dr, c + dc)
    for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1))
    if 0 <= r + dr < R and 0 <= c + dc < C
]
print(nbrs)  # [(1, 0), (0, 1)]: no wrap to row -1
 
 
def subsets(nums: list[int]) -> list[list[int]]:
    out: list[list[int]] = []
    path: list[int] = []
 
    def go(i: int) -> None:
        if i == len(nums):
            out.append(path[:])  # copy: path keeps changing
            return
        go(i + 1)  # skip nums[i]
        path.append(nums[i])  # take nums[i]
        go(i + 1)
        path.pop()  # undo
 
    go(0)
    return out
 
 
print(subsets([1, 2]))  # [[], [2], [1], [1, 2]]

from collections.abc import Iterable, Sequence
 
 
def mean(xs: Sequence[float]) -> float:  # read-only
    return sum(xs) / len(xs)
 
 
def add_all(dst: list[int], src: Iterable[int]) -> None:
    dst.extend(src)  # needs a real list
 
 
ints: list[int] = [1, 2]
mean(ints)  # OK: Sequence is covariant
nums: list[float] = ints  # ❌ type error: list is invariant
empty: list[str] = []  # annotate empty lists
maybe: list[int | None] = [1, None]
type Matrix = list[list[float]]  # alias (3.12+)
 
 
def first[T](xs: Sequence[T]) -> T | None:  # 3.12+
    return xs[0] if xs else None

from collections import deque
from collections.abc import Iterable, Iterator
from itertools import islice
 
 
def windows[T](
    items: Iterable[T], k: int
) -> Iterator[tuple[T, ...]]:
    it = iter(items)
    win = deque(islice(it, k), maxlen=k)
    if len(win) == k:
        yield tuple(win)
    for x in it:
        win.append(x)  # maxlen drops the oldest
        yield tuple(win)
 
 
prices = [10, 11, 13, 12, 15]
print([sum(w) / 3 for w in windows(prices, 3)])
# [11.333333333333334, 12.0, 13.333333333333334]

from collections.abc import Callable, Iterable
 
 
def partition[T](
    items: Iterable[T], pred: Callable[[T], bool]
) -> tuple[list[T], list[T]]:
    yes: list[T] = []
    no: list[T] = []
    for x in items:
        (yes if pred(x) else no).append(x)
    return yes, no
 
 
evens, odds = partition(range(7), lambda n: n % 2 == 0)
print(evens, odds)  # [0, 2, 4, 6] [1, 3, 5]

from dataclasses import dataclass
from operator import attrgetter
 
 
@dataclass
class Player:
    team: str
    score: int
    name: str
 
 
players = [
    Player("red", 10, "cy"),
    Player("blue", 10, "ann"),
    Player("red", 12, "bo"),
]
# numeric keys can be negated: team, score desc, name
players.sort(key=lambda p: (p.team, -p.score, p.name))
 
# strings can't: sort by the minor key first, then the
# major one; stability keeps the minor order in ties
players.sort(key=attrgetter("name"), reverse=True)
players.sort(key=attrgetter("team"))
print([(p.team, p.name) for p in players])
# [('blue', 'ann'), ('red', 'cy'), ('red', 'bo')]

import re
 
 
def natural_key(s: str) -> list[int | str]:
    parts = re.split(r"(\d+)", s.casefold())
    return [int(p) if p.isdecimal() else p for p in parts]
 
 
files = ["file10.txt", "File2.txt", "file1.txt"]
print(sorted(files, key=natural_key))
# ['file1.txt', 'File2.txt', 'file10.txt']

import bisect
from dataclasses import dataclass
 
 
@dataclass
class Job:
    due: int
    name: str
 
 
queue: list[Job] = []
for job in [Job(5, "b"), Job(1, "a"), Job(9, "c")]:
    bisect.insort(queue, job, key=lambda j: j.due)
print([j.name for j in queue])  # ['a', 'b', 'c']
 
i = bisect.bisect_left(queue, 5, key=lambda j: j.due)
print(queue[i].name)  # b

def move[T](xs: list[T], src: int, dst: int) -> None:
    xs.insert(dst, xs.pop(src))
 
 
def rotate[T](xs: list[T], k: int) -> list[T]:
    if not xs:
        return []
    k %= len(xs)  # also handles k < 0 and k > len
    return xs[-k:] + xs[:-k]
 
 
tasks = ["a", "b", "c", "d"]
move(tasks, 0, 2)
print(tasks)  # ['b', 'c', 'a', 'd']
print(rotate([1, 2, 3, 4, 5], 2))  # [4, 5, 1, 2, 3]
tasks[0], tasks[-1] = tasks[-1], tasks[0]  # swap
print(tasks)  # ['d', 'c', 'a', 'b']

m = [[1, 2, 3], [4, 5, 6]]
print([list(col) for col in zip(*m)])
# [[1, 4], [2, 5], [3, 6]]
print([list(row) for row in zip(*m[::-1])])  # 90° right
# [[4, 1], [5, 2], [6, 3]]
print([list(row) for row in zip(*m)][::-1])  # 90° left
# [[3, 6], [2, 5], [1, 4]]

from collections import Counter
 
old = ["a", "b", "c", "d"]
new = ["b", "d", "e"]
old_set, new_set = set(old), set(new)
added = [x for x in new if x not in old_set]  # ['e']
removed = [x for x in old if x not in new_set]
print(added, removed)  # ['e'] ['a', 'c']
 
# with duplicates: multiset difference
extra = Counter([1, 1, 2, 3]) - Counter([1, 3])
print(sorted(extra.elements()))  # [1, 2]