itertools and collections

from itertools import (count, cycle, repeat, chain, zip_longest, islice,
                       takewhile, dropwhile, filterfalse, compress, starmap,
                       tee, pairwise, batched, accumulate, groupby)
import operator

list(islice(count(1), 5))                   # [1, 2, 3, 4, 5]
list(chain.from_iterable([[1, 2], [3], []]))# [1, 2, 3]
list(zip_longest("AB", "xyz", fillvalue="-"))
# [('A', 'x'), ('B', 'y'), ('-', 'z')]
list(batched("ABCDE", 2))                   # [('A','B'), ('C','D'), ('E',)]
list(batched("ABCDE", 2, strict=True))      # 3.13+, raises if the tail is short
list(accumulate([1, 2, 3, 4], operator.mul, initial=1))  # [1, 1, 2, 6, 24]
list(accumulate([3, 1, 4, 1, 5], max))      # [3, 3, 4, 4, 5]

from itertools import product, permutations, combinations
from itertools import combinations_with_replacement as cwr

["".join(p) for p in permutations("ABC", 2)]  # ['AB','AC','BA','BC','CA','CB']
["".join(c) for c in combinations("ABC", 2)]  # ['AB', 'AC', 'BC']
["".join(c) for c in cwr("ABC", 2)]           # ['AA','AB','AC','BB','BC','CC']
list(product([0, 1], repeat=3))               # 8 binary triples
list(product("ab", range(2)))  # [('a',0), ('a',1), ('b',0), ('b',1)]

# product replaces nested loops over a grid of settings
for lr, batch in product([0.01, 0.1], [16, 32]):
    ...

from itertools import groupby
from operator import itemgetter

rows = [{"dept": "eng", "n": 1}, {"dept": "ops", "n": 2},
        {"dept": "eng", "n": 3}]

# WRONG, eng appears twice
[(k, len(list(g))) for k, g in groupby(rows, key=itemgetter("dept"))]
# [('eng', 1), ('ops', 1), ('eng', 1)]

# RIGHT, sort by the same key first
rows.sort(key=itemgetter("dept"))
{k: [r["n"] for r in g] for k, g in groupby(rows, key=itemgetter("dept"))}
# {'eng': [1, 3], 'ops': [2]}

groups = list(groupby("aabbb"))          # [('a', <it>), ('b', <it>)]
[list(g) for _, g in groups]             # [[], []]  every group is empty now

# Materialize as you go
{k: list(g) for k, g in groupby("aabbb")}   # {'a': ['a','a'], 'b': ['b','b','b']}

# Run-length encode
[(k, len(list(g))) for k, g in groupby("aaabbc")]   # [('a',3), ('b',2), ('c',1)]

from collections import Counter

c = Counter("mississippi")        # Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})
c = Counter(["a", "b", "a"])      # from any iterable
c = Counter({"a": 2}, b=1)        # from a mapping or kwargs

c["z"]                   # 0, no KeyError, and 'z' is NOT added
c.most_common(2)         # [('i', 4), ('s', 4)]  ties in insertion order
c.most_common()[::-1]    # least common first
c.total()                # 11, sum of counts (3.10+)
list(c.elements())       # each key repeated count times
c.update("pi")           # ADDS counts (dict.update would overwrite)
c.subtract("pi")         # subtracts, allows zero and negatives
+c, -c                   # keep only positive · only negative, flipped
c.pop("m"); del c["p"]   # plain dict removal

Counter("aab") - Counter("ab")            # Counter({'a': 1})
Counter("aab") & Counter("abb")           # Counter({'a': 1, 'b': 1})
sum(Counter(line.split()) for line in lines)   # merge word counts

from collections import defaultdict, ChainMap, OrderedDict

d = defaultdict(list)             # factory is called with NO arguments
d["a"].append(1)                  # {'a': [1]}, key created on read
defaultdict(int)["x"] += 1        # counters
defaultdict(set)                  # unique members per key
defaultdict(lambda: defaultdict(int))   # nested, works to any depth

d["missing"]           # creates an empty list. Reading MUTATES the dict.
d.get("missing")       # None, and does not create anything
dict(d)                # plain dict, drops the factory

plain = {}
plain.setdefault("a", []).append(1)     # same effect, allocates [] each time

cfg = ChainMap(cli_args, env_vars, defaults)   # first hit wins
cfg["debug"]
cfg.maps                        # the underlying list, mutable
cfg.new_child({"tmp": 1})       # push a scratch layer
cfg.parents                     # everything except the first map
dict(cfg)                       # flatten to one plain dict

OrderedDict(a=1, b=2) == OrderedDict(b=2, a=1)   # False, order matters
dict(a=1, b=2) == dict(b=2, a=1)                 # True
od.move_to_end("a")             # or last=False for the front
od.popitem(last=False)          # FIFO pop, an LRU building block

from collections import deque

q = deque([1, 2, 3], maxlen=3)
q.append(4)            # deque([2, 3, 4]), 1 is silently DISCARDED
q.appendleft(0)        # pushes 4 off the right instead
q.pop(), q.popleft()   # both O(1)
q.extend([7, 8]); q.extendleft([9])   # extendleft REVERSES its argument
q.rotate(1)            # right by 1: [a,b,c] → [c,a,b]
q.rotate(-1)           # left by 1
q.maxlen               # read-only, None when unbounded

with open("app.log") as f:
    last10 = deque(f, maxlen=10)          # constant memory over any file size

from collections import namedtuple

Point = namedtuple("Point", "x y")                 # or ["x", "y"]
Point = namedtuple("Point", "x y z", defaults=(0,))  # defaults fill from the RIGHT
p = Point(1, 2)
p.x, p[0]                     # attribute or index access
x, y = p                      # unpacks like a tuple
p._replace(y=99)              # a NEW Point, tuples are immutable
p._asdict()                   # {'x': 1, 'y': 2}
Point._fields                 # ('x', 'y')
Point._make([1, 2])           # build from an iterable, e.g. a csv row
p == (1, 2)                   # True, it IS a tuple

from collections import UserDict

class CaseInsensitive(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key.lower(), value)
    def __getitem__(self, key):
        return super().__getitem__(key.lower())

h = CaseInsensitive()
h["Content-Type"] = "text/html"
h["content-type"]              # 'text/html'

from functools import cache, lru_cache, cached_property, partial, reduce
from functools import wraps, total_ordering, singledispatch
import operator

@cache
def fib(n): return n if n < 2 else fib(n - 1) + fib(n - 2)
fib(100)                       # instant, 354224848179261915075
fib.cache_info()               # CacheInfo(hits=98, misses=101, ...)
fib.cache_clear()

reduce(operator.mul, [1, 2, 3, 4])        # 24
reduce(operator.or_, [{1}, {2}, {3}])     # {1, 2, 3}
int2 = partial(int, base=2); int2("1011") # 11

class Report:
    @cached_property
    def rows(self): return expensive_query()   # runs once per instance

@singledispatch
def size(x): raise TypeError(type(x))
@size.register
def _(x: str): return len(x)
@size.register
def _(x: int): return x

from operator import itemgetter, attrgetter, methodcaller

rows = [{"name": "b", "age": 30}, {"name": "a", "age": 30}]
sorted(rows, key=itemgetter("age", "name"))    # multi-key, one pass
sorted(pairs, key=itemgetter(1), reverse=True) # by tuple element
max(objs, key=attrgetter("score"))
sorted(objs, key=attrgetter("dept.name"))     # dotted paths work
list(map(methodcaller("strip"), lines))
list(map(methodcaller("split", ","), lines))
itemgetter(2, 0)("abcd")                       # ('c', 'a')

import operator
operator.add, operator.mul, operator.itruediv  # arithmetic
operator.eq, operator.lt, operator.contains    # comparisons and `in`
operator.getitem, operator.setitem, operator.delitem

from collections import Counter, defaultdict, deque
from itertools import chain, groupby, islice, pairwise, product, tee
from operator import itemgetter

# 1. Flatten one level
list(chain.from_iterable([[1, 2], [3], [4, 5]]))        # [1, 2, 3, 4, 5]

# 2. Chunk into fixed sizes
from itertools import batched
list(batched(range(7), 3))                    # 3.12+  [(0,1,2), (3,4,5), (6,)]
def chunks(it, n):                            # any version, works on iterators
    it = iter(it)
    while part := list(islice(it, n)):
        yield part

# 3. Dedupe, preserving first-seen order
list(dict.fromkeys([3, 1, 3, 2, 1]))                    # [3, 1, 2]

# 4. Sliding window of size n
def window(it, n):
    it = iter(it)
    d = deque(islice(it, n), maxlen=n)
    if len(d) == n: yield tuple(d)
    for x in it:
        d.append(x); yield tuple(d)
list(pairwise([1, 2, 3, 4]))                  # n=2  [(1,2), (2,3), (3,4)]

# 5. Group by a key, one pass, no sort
by_dept = defaultdict(list)
for r in rows: by_dept[r["dept"]].append(r)

# 6. Frequency count and the top n
Counter("abracadabra").most_common(3)         # [('a',5), ('b',2), ('r',2)]

# 7. Cartesian grid instead of nested loops
list(product(range(2), "xy"))     # [(0,'x'), (0,'y'), (1,'x'), (1,'y')]

# 8. Transpose rows to columns
list(zip(*[(1, 2), (3, 4), (5, 6)]))          # [(1, 3, 5), (2, 4, 6)]

# 9. Consume an iterator without building a list
deque(gen, maxlen=0)