Python — Engineering
Notes for Working Code

$ python3 script.py        # run a file
$ python3                   # interactive REPL
$ python3 -m http.server   # run a module as a script

$ python3 -m venv .venv
$ source .venv/bin/activate   # Windows: .venv\\Scripts\\activate
$ pip install requests
$ pip freeze > requirements.txt

x = 42            # x is a name bound to an int object
y = x             # y binds to the SAME object
type(x)           # <class 'int'>
id(x) == id(y)   # True — same object

# int, float, complex, bool, str, bytes,
# list, tuple, dict, set, frozenset, None

def add(x, items=[]):   # DANGER: shared default
    items.append(x)
    return items
add(1); add(2)      # [1, 2] — surprise!

def add(x, items=None):  # correct pattern
    items = items if items is not None else []

name, n = "omar", 3
f"hi {name.title()}, x{n:03d}"   # 'hi Omar, x003'
f"{n=}"                          # 'n=3'  (debug form)
f"{3.14159:.2f}"                  # '3.14'

"  hi  ".strip()            # 'hi'
"a,b,c".split(",")        # ['a','b','c']
"-".join(["a","b"])        # 'a-b'
"Hello".startswith("He")   # True
"abcabc".replace("a","X")   # 'XbcXbc'

# text is str; raw I/O is bytes — encode/decode at the edge
"é".encode("utf-8")          # b'\\xc3\\xa9'

2 ** 100              # exact — Python ints are unbounded
7 // 2, 7 % 2         # 3, 1  (floor div, mod)
0.1 + 0.2 == 0.3      # False — binary float

from decimal import Decimal
Decimal("0.1") + Decimal("0.2")  # Decimal('0.3') — use for money

# Falsy: 0, 0.0, '', [], , set(), None, False
if not items: ...        # pythonic empty check

while (line := f.readline()):  # walrus: assign + test
    process(line)

match command.split():
    case ["go", direction]:
        move(direction)
    case ["quit"]:
        return
    case _:
        print("unknown")

xs = [1, 2, 3]
xs.append(4); xs.pop(); xs.insert(0, 9)
a, *rest = xs            # a=9, rest=[1,2,3]
first, *_, last = xs     # ignore the middle

pt = (3, 4)              # tuple — fixed, hashable
x, y = pt                # unpack

d = {"a": 1}
d.get("b", 0)              # 0 — no KeyError
d.setdefault("c", []).append(1)
{**d, "b": 2}             # merge (3.9+: d1 | d2)

from collections import Counter, defaultdict
Counter("abracadabra").most_common(2)
g = defaultdict(list); g["k"].append(1)

seen = set(); seen.add(x)
list(dict.fromkeys(xs))   # dedup, order-preserving
a & b, a | b, a - b      # intersection, union, difference

[x*x for x in range(5) if x % 2]   # [1, 9]
{k: v for k, v in pairs}            # dict comp
{c for c in word}                   # set comp
(x*x for x in range(10**9))      # lazy generator — O(1) memory

xs[1:4]      # items 1,2,3
xs[:3], xs[3:]   # head / tail
xs[::-1]      # reversed copy
xs[::2]       # every other
xs[:] = [1,2]   # replace contents in place
s[1:4]       # works on strings/tuples too

def counter():
    n = 0
    def inc():
        nonlocal n; n += 1; return n
    return inc

sorted_items = sorted(items, key=lambda x: x.score, reverse=True)

def f(pos, /, normal, *args, kw_only, **kwargs):
    ...
# pos: positional-only  (before /)
# kw_only: keyword-only (after *)

def wrap(*args, **kwargs):
    return target(*args, **kwargs)   # transparent pass-through

from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)
class Point:
    x: float
    y: float = 0.0
    tags: list = field(default_factory=list)

p = Point(1, 2)   # __init__, __repr__, __eq__ generated

class C:
    @property
    def area(self): return self._w * self._h
    @area.setter
    def area(self, v): raise AttributeError("read-only")

class Vec:
    def __init__(self, x, y): self.x, self.y = x, y
    def __repr__(self): return f"Vec({self.x}, {self.y})"
    def __add__(self, o): return Vec(self.x+o.x, self.y+o.y)
    def __eq__(self, o): return (self.x, self.y) == (o.x, o.y)
    def __len__(self): return 2

import functools, time

def timed(fn):
    @functools.wraps(fn)        # preserve name/docstring
    def wrapper(*a, **kw):
        t = time.perf_counter()
        r = fn(*a, **kw)
        print(fn.__name__, time.perf_counter()-t)
        return r
    return wrapper

@functools.lru_cache(maxsize=None)   # memoise
def fib(n): return n if n < 2 else fib(n-1)+fib(n-2)

def read_chunks(path, size=8192):
    with open(path, "rb") as f:
        while (b := f.read(size)):
            yield b      # pauses here, resumes on next()

import itertools as it
it.islice(stream, 10)        # first 10 without materialising
it.chain(a, b); it.groupby(xs)

with open("f.txt") as f, lock:   # multiple, nested
    data = f.read()

from contextlib import contextmanager
@contextmanager
def timer():
    t = time.perf_counter()
    try: yield
    finally: print(time.perf_counter()-t)

try:
    v = cache[key]
except KeyError:
    v = compute(); cache[key] = v
except (IOError, ValueError) as e:
    raise AppError("failed") from e   # chain the cause
else:
    commit()      # ran only if no exception
finally:
    release()

from pkg.mod import thing      # absolute (preferred)
from . import sibling           # explicit relative

if __name__ == "__main__":
    main()   # runs only when executed, not imported

def parse(raw: str) -> dict[str, int] | None:
    ...

from typing import Protocol
class Reader(Protocol):       # structural typing
    def read(self, n: int) -> bytes: ...

a, b = b, a                      # swap
"".join(parts)                  # build strings (never +=)
for i, x in enumerate(xs): ...   # index + value
for a, b in zip(xs, ys): ...    # parallel iterate
x = a if cond else b           # ternary
val = d.get(k, default)
sorted(xs, key=lambda r: r.ts)
with open(p) as f: ...          # always context-manage I/O