Python — The Full Picture

Basics, Pythonic patterns, OOP, async, type hints, data, tooling, and Rust extensions

🔗Basics

🔗Variables, types, and truthiness

Python is dynamically typed — variables hold references, not values.

 1    # Primitives
 2    name  : str   = "alice"
 3    age   : int   = 30
 4    score : float = 9.5
 5    active: bool  = True
 6    nothing         = None
 7
 8    # Multiple assignment
 9    x = y = z = 0
10    a, b, c = 1, 2, 3
11    first, *rest = [1, 2, 3, 4]   # first=1, rest=[2,3,4]
12
13    # Falsy values — memorise these
14    # False, None, 0, 0.0, "", [], {}, set(), ()
15    if not []:    print("empty list is falsy")
16    if not "":   print("empty string is falsy")
17
18    # type() vs isinstance()
19    isinstance(3, (int, float))    # True — prefer this
20    type(3) is int                  # True — exact type only

🔗Strings

 1    s = "hello world"
 2    s.upper()           # "HELLO WORLD"
 3    s.split(" ")         # ["hello", "world"]
 4    s.strip()            # remove leading/trailing whitespace
 5    s.replace("l","L")  # "heLLo worLd"
 6    s.startswith("he") # True
 7    s.count("l")         # 3
 8    ", ".join(["a","b","c"])  # "a, b, c"
 9
10    # f-strings (use these always)
11    name = "Alice"
12    print(f"Hello, {name}!")
13    print(f"Pi ≈ {3.14159:.2f}")  # "Pi ≈ 3.14"
14    print(f"{score = }")           # "score = 9.5"  (debug format, 3.8+)
15
16    # Multiline
17    text = """
18      Line one
19      Line two
20    """.strip()
21
22    # Raw strings (no escape processing)
23    pattern = r"\d+\.\d+"

🔗Control flow

 1    # if / elif / else
 2    if score >= 90:      grade = "A"
 3    elif score >= 70:   grade = "B"
 4    else:               grade = "C"
 5
 6    # One-liner ternary
 7    label = "pass" if score >= 50 else "fail"
 8
 9    # match / case (Python 3.10+) — structural pattern matching
10    match command:
11        case "quit":             quit()
12        case "hello":            print("Hi!")
13        case {"action": action}: print(action)
14        case [x, y]:             print(f"coords {x},{y}")
15        case _:                  print("unknown")
16
17    # for loops
18    for i, val in enumerate(["a","b","c"]):
19        print(i, val)   # 0 a, 1 b, 2 c
20
21    for a, b in zip([1,2,3], ["x","y","z"]):
22        print(a, b)     # 1 x, 2 y, 3 z
23
24    # for...else (runs if loop didn't break)
25    for item in items:
26        if item.found: break
27    else:
28        print("nothing found")
29
30    # while
31    while queue:
32        task = queue.pop(0)
33        process(task)

🔗Exception handling

 1    try:
 2        result = risky()
 3    except (ValueError, TypeError) as e:
 4        print(f"bad input: {e}")
 5    except Exception as e:
 6        logger.error(f"unexpected: {e}")
 7        raise               # re-raise
 8    else:
 9        save(result)         # runs only if no exception
10    finally:
11        cleanup()            # always runs
12
13    # Custom exception
14    class AppError(Exception):
15        def __init__(self, message: str, code: int = 400):
16            super().__init__(message)
17            self.code = code
18
19    raise AppError("not found", code=404)

🔗Collections

🔗Lists

 1    nums = [3, 1, 4, 1, 5, 9]
 2
 3    # Slicing: [start:stop:step]  — stop is exclusive
 4    nums[1:4]      # [1, 4, 1]
 5    nums[:-1]     # reversed copy
 6    nums[::2]      # every 2nd: [3, 4, 5]
 7
 8    # Mutations
 9    nums.append(2)
10    nums.extend([6, 5])
11    nums.insert(0, 0)
12    nums.remove(1)         # removes first occurrence
13    popped = nums.pop()    # removes & returns last
14    nums.sort(reverse=True)
15    nums.sort(key=lambda x: -x)
16
17    # Non-mutating
18    sorted(nums)                  # returns new list
19    sorted(people, key=lambda p: p.age)
20    list(reversed(nums))          # returns iterator
21
22    # Useful builtins on lists
23    sum(nums); min(nums); max(nums); len(nums)
24    any(x > 5 for x in nums)   # True if at least one
25    all(x > 0 for x in nums)   # True if all

🔗Dictionaries

 1    user = {"name": "Alice", "age": 30, "role": "admin"}
 2
 3    # Access
 4    user["name"]              # "Alice" — raises KeyError if missing
 5    user.get("city", "N/A")   # "N/A" — safe default
 6
 7    # Mutate
 8    user["email"] = "alice@x.com"
 9    user.update({"age": 31, "city": "Paris"})
10    user.pop("role", None)    # remove, return None if missing
11
12    # Merge dicts (3.9+)
13    merged = base | overrides     # new dict
14    base |= overrides              # in-place
15
16    # Iterate
17    for key in user:              # iterates keys
18    for key, val in user.items():
19    for val in user.values():
20
21    # setdefault — initialise if key missing
22    groups.setdefault("admin", []).append(user)
23
24    # defaultdict    from collections import defaultdict
25    groups = defaultdict(list)
26    groups["admin"].append(user)   # no KeyError
27
28    # Counter
29    from collections import Counter
30    c = Counter("banana")     # Counter({'a':3,'n':2,'b':1})
31    c.most_common(2)          # [('a', 3), ('n', 2)]
32
33    # OrderedDict (dicts are ordered since 3.7, but OrderedDict has .move_to_end)
34    from collections import OrderedDict

🔗Sets and Tuples

 1    # Set — unordered, unique, mutable
 2    tags = {"python", "web", "api"}
 3    tags.add("async")
 4    tags.discard("missing")   # no error if absent
 5
 6    a = {1,2,3};  b = {2,3,4}
 7    a & b   # intersection: {2,3}
 8    a | b   # union:        {1,2,3,4}
 9    a - b   # difference:   {1}
10    a ^ b   # symmetric diff:{1,4}
11    a.issubset(b)   # False
12
13    # Tuple — ordered, immutable
14    point = (3, 4)
15    x, y = point          # unpack
16    single = (42,)        # note the trailing comma
17
18    # namedtuple
19    from collections import namedtuple
20    Point = namedtuple("Point", ["x", "y"])
21    p = Point(3, 4)
22    print(p.x, p.y)   # 3 4

🔗Pythonic Patterns

🔗List, dict, and set comprehensions

 1Comprehensions are faster than equivalent for-loops and far more readable when kept short.
 2
 3    nums = [1, 2, 3, 4, 5, 6]
 4
 5    # List comprehension:  [expression for item in iterable if condition]
 6    squares  = [x**2 for x in nums]
 7    evens_sq = [x**2 for x in nums if x % 2 == 0]
 8    flat     = [item for sub in matrix for item in sub]
 9
10    # Dict comprehension
11    sq_map  = {x: x**2 for x in range(5)}         # {0:0,1:1,2:4,...}
12    inverted = {v: k for k, v in original.items()}  # flip keys/values
13    filtered = {k: v for k, v in d.items() if v is not None}
14
15    # Set comprehension
16    unique_domains = {email.split("@")[1] for email in emails}
17
18    # Generator expression — lazy, no brackets
19    total = sum(x**2 for x in range(1_000_000))   # no list in memory

🔗Walrus operator := (Python 3.8+)

 1    # Assign and use in same expression
 2    if (n := len(data)) > 10:
 3        print(f"Too much data: {n} items")
 4
 5    # Avoid calling the same function twice
 6    while chunk := file.read(8192):
 7        process(chunk)
 8
 9    # Filter and transform in one pass
10    results = [y for x in data if (y := process(x)) is not None]

🔗Unpacking

 1    a, b = b, a                   # swap — no temp variable
 2    first, *middle, last = items  # star unpacking
 3    _, important, *_ = record     # ignore parts with _
 4
 5    # Unpack into function args
 6    args   = [3, 14]
 7    kwargs = {"sep": ",", "end": "\n"}
 8    print(*args, **kwargs)
 9
10    # Dict merge via unpacking (< 3.9 compat)
11    merged = {**base, **overrides}

🔗Lambdas

Lambdas are anonymous functions — use them for short, throwaway operations. For anything with logic, name it.

 1    # lambda arguments: expression
 2    square = lambda x: x**2
 3    add    = lambda x, y: x + y
 4
 5    # Common use: as sort key
 6    people.sort(key=lambda p: (p.age, p.name))
 7    sorted(words, key=lambda w: w.lower())
 8
 9    # With map/filter (generator-based, lazy)
10    doubled  = list(map(lambda x: x*2, nums))
11    positive = list(filter(lambda x: x > 0, nums))
12    # ↑ Prefer list comprehensions: [x*2 for x in nums]
13
14    # With max/min/sorted key
15    most_exp = max(products, key=lambda p: p.price)

🔗Context managers

 1    # with statement — guarantees cleanup
 2    with open("file.txt", "r") as f:
 3        data = f.read()           # auto-closes even on exception
 4
 5    # Multiple at once
 6    with open("in.txt") as src, open("out.txt", "w") as dst:
 7        dst.write(src.read())
 8
 9    # Custom context manager via class
10    class Timer:
11        def __enter__(self):
12            import time
13            self.start = time.monotonic()
14            return self
15        def __exit__(self, *args):
16            self.elapsed = time.monotonic() - self.start
17            print(f"Elapsed: {self.elapsed:.3f}s")
18
19    # Custom via @contextmanager (simpler)
20    from contextlib import contextmanager
21
22    @contextmanager
23    def managed_resource(name):
24        print(f"Opening {name}")
25        try:
26            yield name          # value bound to 'as' variable
27        finally:
28            print(f"Closing {name}")

🔗Functions in Depth

🔗Arguments

 1    # All argument kinds
 2    def example(
 3        pos_only,        # positional only (before /)
 4        /,
 5        normal,          # positional or keyword
 6        *,               # everything after is keyword-only
 7        kw_only,
 8        default = 10,
 9    ):
10        ...
11
12    # *args and **kwargs
13    def variadic(*args: int, **kwargs: str):
14        # args = tuple, kwargs = dict
15        for a in args:    print(a)
16        for k, v in kwargs.items(): print(k, v)
17
18    # Mutable defaults — the classic gotcha
19    def bad(items=[]):           # ← shared across all calls!
20        items.append(1)
21        return items
22
23    def good(items=None):        # ← correct pattern
24        if items is None:
25            items = []
26        items.append(1)
27        return items

🔗Closures and decorators

 1    # Closure — inner function captures outer scope
 2    def make_counter(start=0):
 3        count = [start]                 # list to allow mutation
 4        def counter():
 5            count[0] += 1
 6            return count[0]
 7        return counter
 8
 9    c = make_counter()
10    c()   # 1
11    c()   # 2
12
13    # Decorator — a function that wraps another
14    import functools
15
16    def timing(func):
17        @functools.wraps(func)          # preserves __name__, __doc__
18        def wrapper(*args, **kwargs):
19            import time
20            t = time.perf_counter()
21            result = func(*args, **kwargs)
22            print(f"{func.__name__} took {time.perf_counter()-t:.4f}s")
23            return result
24        return wrapper
25
26    @timing
27    def slow_function():
28        import time; time.sleep(0.1)
29
30    # Decorator with arguments
31    def retry(times=3, exceptions=(Exception,)):
32        def decorator(func):
33            @functools.wraps(func)
34            def wrapper(*args, **kwargs):
35                for attempt in range(times):
36                    try:
37                        return func(*args, **kwargs)
38                    except exceptions as e:
39                        if attempt == times - 1: raise
40                        print(f"Retry {attempt+1}: {e}")
41            return wrapper
42        return decorator
43
44    @retry(times=3, exceptions=(ConnectionError,))
45    def fetch(url): ...

🔗Generators

 1    # Generator function — yields values lazily
 2    def fibonacci():
 3        a, b = 0, 1
 4        while True:
 5            yield a
 6            a, b = b, a + b
 7
 8    fib = fibonacci()
 9    next(fib)    # 0
10    next(fib)    # 1
11    next(fib)    # 1
12
13    # Consume with for or itertools
14    import itertools
15    first10 = list(itertools.islice(fibonacci(), 10))
16
17    # Generator for file processing (memory-efficient)
18    def read_chunks(path, size=8192):
19        with open(path, "rb") as f:
20            while chunk := f.read(size):
21                yield chunk
22
23    # yield from — delegate to sub-generator
24    def chain(*iterables):
25        for it in iterables:
26            yield from it

🔗Object-Oriented Programming

🔗Class anatomy

 1    class Animal:
 2        species_count: int = 0    # class attribute
 3
 4        def __init__(self, name: str, sound: str) -> None:
 5            self.name  = name       # instance attribute
 6            self._sound = sound     # convention: "private"
 7            Animal.species_count += 1
 8
 9        def speak(self) -> str:
10            return f"{self.name} says {self._sound}"
11
12        @property
13        def sound(self) -> str:
14            return self._sound
15
16        @sound.setter
17        def sound(self, value: str):
18            if not value:
19                raise ValueError("sound can't be empty")
20            self._sound = value
21
22        @classmethod
23        def from_dict(cls, data: dict) -> "Animal":
24            return cls(data["name"], data["sound"])
25
26        @staticmethod
27        def validate_name(name: str) -> bool:
28            return bool(name.strip())
29
30        def __repr__(self) -> str:   # for developers
31            return f"Animal({self.name!r})"
32
33        def __str__(self) -> str:    # for users
34            return self.name

🔗Dunder (magic) methods

 1    class Vector:
 2        def __init__(self, x, y): self.x, self.y = x, y
 3        def __repr__(self):   return f"Vector({self.x}, {self.y})"
 4        def __add__(self, o):  return Vector(self.x+o.x, self.y+o.y)
 5        def __sub__(self, o):  return Vector(self.x-o.x, self.y-o.y)
 6        def __mul__(self, n):  return Vector(self.x*n, self.y*n)
 7        def __abs__(self):    return (self.x**2 + self.y**2)**0.5
 8        def __bool__(self):   return bool(abs(self))
 9        def __eq__(self, o):  return self.x==o.x and self.y==o.y
10        def __hash__(self):   return hash((self.x, self.y))  # needed if __eq__
11        def __len__(self):    return 2
12        def __iter__(self):   yield self.x; yield self.y
13        def __getitem__(self, i): return (self.x, self.y)[i]
14        def __contains__(self, v): return v in (self.x, self.y)

🔗Inheritance and MRO

 1    class Dog(Animal):
 2        def __init__(self, name: str, breed: str):
 3            super().__init__(name, "woof")   # call parent __init__
 4            self.breed = breed
 5
 6        def speak(self) -> str:            # override
 7            base = super().speak()
 8            return f"{base}! ({self.breed})"
 9
10    # Multiple inheritance — MRO (Method Resolution Order)
11    class A:
12        def hello(self): print("A")
13
14    class B(A):
15        def hello(self): print("B"); super().hello()
16
17    class C(A):
18        def hello(self): print("C"); super().hello()
19
20    class D(B, C): ...   # MRO: D → B → C → A
21    D().hello()  # prints B C A
22
23    # Abstract classes
24    from abc import ABC, abstractmethod
25
26    class Shape(ABC):
27        @abstractmethod
28        def area(self) -> float: ...
29
30        @abstractmethod
31        def perimeter(self) -> float: ...
32
33    class Circle(Shape):
34        def __init__(self, r): self.r = r
35        def area(self): return 3.14159 * self.r**2
36        def perimeter(self): return 2 * 3.14159 * self.r

🔗Dataclasses

 1    from dataclasses import dataclass, field, asdict, astuple
 2
 3    @dataclass
 4    class User:
 5        name:  str
 6        email: str
 7        age:   int = 0
 8        tags:  list[str] = field(default_factory=list)
 9
10        def __post_init__(self):
11            self.email = self.email.lower()
12
13    # Auto-generates __init__, __repr__, __eq__
14    u = User("Alice", "ALICE@EX.COM", age=30)
15    asdict(u)   # {'name': 'Alice', 'email': 'alice@ex.com', ...}
16
17    @dataclass(frozen=True)   # immutable — usable as dict key
18    class Point:
19        x: float; y: float
20
21    @dataclass(order=True)    # adds __lt__, __le__, etc.
22    class Task:
23        priority: int
24        name:     str

🔗Type Hints

🔗Basic annotations

 1    # Variables
 2    name: str = "Alice"
 3    count: int = 0
 4    ratio: float = 0.5
 5    active: bool = True
 6    data: bytes = b""
 7
 8    # Collections (use built-in types, Python 3.9+)
 9    names: list[str]
10    mapping: dict[str, int]
11    pair: tuple[int, str]
12    unique: set[float]
13
14    # Optional — None or a value
15    from typing import Optional
16    maybe: Optional[str] = None
17    maybe: str | None = None    # 3.10+ union syntax
18
19    # Union types
20    result: int | str | None
21
22    # Function signatures
23    def greet(name: str, times: int = 1) -> str:
24        return (f"Hello {name}!\n") * times
25
26    def nothing() -> None: ...   # explicit None return

🔗Advanced types

 1    from typing import (
 2        Any, Callable, Generator, Iterator,
 3        TypeVar, Generic, Literal, Final,
 4        TypedDict, Protocol, overload
 5    )
 6
 7    # Callable
 8    handler: Callable[[str, int], bool]   # (str, int) -> bool
 9    callback: Callable[..., None]            # any args, returns None
10
11    # TypeVar — generic programming
12    T = TypeVar("T")
13    K = TypeVar("K")
14    V = TypeVar("V")
15
16    def first(items: list[T]) -> T | None:
17        return items[0] if items else None
18
19    # Generic class
20    class Stack(Generic[T]):
21        def __init__(self): self._items: list[T] = []
22        def push(self, item: T) -> None: self._items.append(item)
23        def pop(self) -> T: return self._items.pop()
24
25    # Literal — restrict to specific values
26    Mode = Literal["read", "write", "append"]
27    def open_file(path: str, mode: Mode) -> ...: ...
28
29    # TypedDict — typed dict structure
30    class UserDict(TypedDict):
31        name: str
32        email: str
33        age: int
34
35    # Protocol — structural subtyping ("duck typing" formalized)
36    class Drawable(Protocol):
37        def draw(self) -> None: ...
38
39    # Any class with a draw() method satisfies Drawable — no inheritance needed
40    def render(item: Drawable) -> None:
41        item.draw()
42
43    # Final — constant that cannot be reassigned
44    MAX_SIZE: Final = 100

Run mypy for static checks: mypy --strict mymodule.py. Type hints are not enforced at runtime — they're for tools and documentation only.

🔗Async Python

🔗The basics

Python's asyncio uses a single-threaded event loop. Use it for I/O-bound tasks (HTTP, DB, files). For CPU-bound work, use ProcessPoolExecutor.

 1    import asyncio
 2
 3    # Basic coroutine
 4    async def fetch(url: str) -> str:
 5        await asyncio.sleep(1)   # non-blocking wait
 6        return f"data from {url}"
 7
 8    # Run it
 9    result = asyncio.run(fetch("http://example.com"))
10
11    # Run concurrently with gather
12    async def main():
13        results = await asyncio.gather(
14            fetch("http://a.com"),
15            fetch("http://b.com"),
16            fetch("http://c.com"),
17        )   # all 3 run concurrently, total ~1s not 3s
18        return results
19
20    # Tasks — schedule and forget
21    async def main():
22        task = asyncio.create_task(fetch("http://a.com"))
23        # do other work here...
24        result = await task    # retrieve when ready

🔗HTTP with httpx

 1    import httpx
 2
 3    async def get_users() -> list:
 4        async with httpx.AsyncClient() as client:
 5            resp = await client.get("https://api.example.com/users")
 6            resp.raise_for_status()
 7            return resp.json()
 8
 9    # Concurrent requests with rate limiting
10    async def fetch_all(urls: list[str]) -> list:
11        sem = asyncio.Semaphore(10)    # max 10 concurrent
12        async def bounded(url):
13            async with sem:
14                async with httpx.AsyncClient() as c:
15                    return (await c.get(url)).json()
16        return await asyncio.gather(*[bounded(u) for u in urls])

🔗Queues and producer/consumer

 1    async def producer(queue: asyncio.Queue):
 2        for i in range(10):
 3            await queue.put(i)
 4        await queue.put(None)     # sentinel
 5
 6    async def consumer(queue: asyncio.Queue):
 7        while True:
 8            item = await queue.get()
 9            if item is None: break
10            print(f"Consuming {item}")
11            queue.task_done()
12
13    async def main():
14        q = asyncio.Queue(maxsize=5)
15        await asyncio.gather(producer(q), consumer(q))

🔗asyncio patterns and gotchas

 1    # Timeout
 2    try:
 3        result = await asyncio.wait_for(fetch(url), timeout=5.0)
 4    except asyncio.TimeoutError:
 5        print("timed out")
 6
 7    # gather with exception handling per task
 8    results = await asyncio.gather(*tasks, return_exceptions=True)
 9    for r in results:
10        if isinstance(r, Exception): handle_error(r)
11
12    # Run sync code in executor (thread or process pool)
13    import time
14    result = await asyncio.get_event_loop().run_in_executor(
15        None, time.sleep, 1   # None = default ThreadPoolExecutor
16    )
17
18    # CPU-bound: ProcessPoolExecutor
19    from concurrent.futures import ProcessPoolExecutor
20    async def cpu_work():
21        loop = asyncio.get_event_loop()
22        with ProcessPoolExecutor() as pool:
23            return await loop.run_in_executor(pool, heavy_computation)

🔗Standard Library Gems

🔗pathlib

 1    from pathlib import Path
 2
 3    p = Path("data/reports")
 4    p.mkdir(parents=True, exist_ok=True)
 5
 6    # Navigate
 7    base = Path.home() / "projects" / "myapp"
 8    cfg  = base / "config.toml"
 9    cfg.exists(); cfg.is_file(); cfg.is_dir()
10
11    # Read / write
12    text = cfg.read_text(encoding="utf-8")
13    cfg.write_text("content", encoding="utf-8")
14    data = cfg.read_bytes()
15
16    # Glob
17    py_files = list(base.rglob("*.py"))   # recursive
18    configs   = list(base.glob("*.toml")) # non-recursive
19
20    # Info
21    cfg.name       # "config.toml"
22    cfg.stem       # "config"
23    cfg.suffix     # ".toml"
24    cfg.parent     # Path("~/projects/myapp")
25    cfg.stat().st_size

🔗itertools and functools

 1    import itertools as it
 2    import functools
 3
 4    # itertools
 5    it.chain([1,2], [3,4])        # 1 2 3 4
 6    it.chain.from_iterable([[1,2],[3]])  # flatten one level
 7    it.islice(gen, 5)             # first 5 items from generator
 8    it.groupby(sorted_items, key=lambda x: x.status)
 9    it.combinations([1,2,3], 2)  # (1,2)(1,3)(2,3)
10    it.permutations([1,2,3], 2)  # (1,2)(1,3)(2,1)...
11    it.product("AB", repeat=2)    # AA AB BA BB
12    it.accumulate([1,2,3,4])     # 1 3 6 10 (running sum)
13    it.takewhile(lambda x: x<5, nums)
14    it.dropwhile(lambda x: x<5, nums)
15    it.repeat(0, times=3)          # 0 0 0
16
17    # functools
18    functools.lru_cache(maxsize=128)   # memoize
19    functools.cache                      # unbounded cache (3.9+)
20    functools.partial(pow, exp=2)      # partial application
21    functools.reduce(lambda a, b: a+b, [1,2,3])  # fold left: 6
22
23    @functools.lru_cache(maxsize=None)
24    def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)

🔗Pandas & NumPy

🔗NumPy

 1    import numpy as np
 2
 3    # Create arrays
 4    a = np.array([1, 2, 3, 4, 5], dtype=np.float64)
 5    z = np.zeros((3, 4))         # 3×4 of zeros
 6    o = np.ones((2, 3))          # 2×3 of ones
 7    r = np.random.rand(5, 5)    # 5×5 uniform [0,1)
 8    n = np.random.randn(1000)   # normal distribution
 9    l = np.linspace(0, 1, 100)  # 100 evenly spaced points
10    e = np.arange(0, 10, 0.5)   # 0, 0.5, 1.0, ..., 9.5
11
12    # Vectorised operations (NO loops needed)
13    a * 2            # element-wise multiply
14    a + b            # element-wise add
15    np.sqrt(a)       # element-wise sqrt
16    a[a > 3]        # boolean indexing: [4, 5]
17
18    # Shape operations
19    m = np.arange(12).reshape(3, 4)
20    m.T              # transpose
21    m.flatten()     # → 1D
22    np.concatenate([a, b])
23    np.vstack([row1, row2])
24    np.hstack([col1, col2])
25
26    # Stats
27    a.mean(); a.std(); a.min(); a.max()
28    np.median(a); np.percentile(a, 75)
29    np.dot(A, B)     # matrix multiplication
30    A @ B            # same (3.5+)

🔗Pandas

 1    import pandas as pd
 2
 3    # Create
 4    df = pd.read_csv("data.csv", parse_dates=["created_at"])
 5    df = pd.read_json("data.json")
 6    df = pd.DataFrame({
 7        "name":  ["Alice", "Bob", "Carol"],
 8        "score": [90, 75, 88],
 9        "dept":  ["eng", "eng", "hr"],
10    })
11
12    # Inspect
13    df.head(10); df.tail(5)
14    df.info()         # dtypes, nulls, memory
15    df.describe()     # count, mean, std, quartiles
16    df.shape          # (rows, cols)
17    df.dtypes
18    df.isnull().sum() # null counts per column
19
20    # Select
21    df["name"]               # Series
22    df[["name", "score"]]    # DataFrame subset
23    df.iloc[0]              # row by integer position
24    df.loc[0]               # row by label
25    df.loc[df["score"] > 80]    # filter rows
26    df.query("score > 80 and dept == 'eng'")
27
28    # Transform
29    df["grade"] = df["score"].apply(lambda s: "A" if s>=90 else "B")
30    df["score"] = df["score"] * 1.1           # vectorised
31    df.rename(columns={"name": "full_name"})
32    df.drop(columns=["dept"])
33    df.fillna(0)
34    df.dropna(subset=["score"])
35    df.astype({"score": int})
36
37    # Aggregate
38    df.groupby("dept")["score"].mean()
39    df.groupby("dept").agg({"score": ["mean","max","count"]})
40    df.pivot_table(values="score", index="dept", aggfunc="mean")
41
42    # Join / merge
43    pd.merge(df, other, on="id", how="left")
44    pd.concat([df1, df2], ignore_index=True)
45
46    # Export
47    df.to_csv("out.csv", index=False)
48    df.to_json("out.json", orient="records")
49    df.to_parquet("out.parquet")   # columnar, fast

🔗Python Tooling

🔗pyproject.toml — the modern Python config

    [project]
    name = "myapp"
    version = "0.1.0"
    requires-python = ">=3.12"
    dependencies = [
        "fastapi>=0.111",
        "pydantic>=2",
    ]

    [project.optional-dependencies]
    dev = ["pytest", "mypy", "ruff"]

    [tool.ruff]
    line-length = 100
    target-version = "py312"

    [tool.ruff.lint]
    select = ["E", "F", "I", "UP", "N"]   # pycodestyle, pyflakes, isort, pyupgrade, pep8-naming

    [tool.mypy]
    strict = true
    python_version = "3.12"

    [tool.pytest.ini_options]
    testpaths = ["tests"]
    addopts = "--tb=short -q"

🔗pytest patterns

 1    # tests/test_example.py
 2    import pytest
 3
 4    def test_basic():
 5        assert 1 + 1 == 2
 6
 7    # Parametrize
 8    @pytest.mark.parametrize("n,expected", [(2,4), (3,9), (5,25)])
 9    def test_square(n, expected):
10        assert n**2 == expected
11
12    # Fixtures
13    @pytest.fixture
14    def db_session():
15        db = create_test_db()
16        yield db           # setup before / teardown after
17        db.rollback()
18        db.close()
19
20    def test_create_user(db_session):
21        user = db_session.create_user("alice")
22        assert user.id is not None
23
24    # Expect exception
25    def test_raises():
26        with pytest.raises(ValueError, match="too short"):
27            validate("")
28
29    # Mock
30    from unittest.mock import patch, MagicMock
31
32    def test_email():
33        with patch("myapp.email.send") as mock_send:
34            notify_user("alice@ex.com")
35            mock_send.assert_called_once_with("alice@ex.com", subject="Welcome")

🔗Rust Extensions for Python (PyO3 + maturin)

PyO3 lets you write Python extension modules in Rust. Use this when Python is too slow for a specific function — image processing, parsers, math-heavy code. The Rust function becomes a regular importable Python module.

🔗Setup

    # Install maturin (the build tool)
    uv add maturin --dev
    # or:
    pip install maturin

    # Create a new Rust extension project
    maturin new mylib --bindings pyo3
    # Creates: mylib/Cargo.toml + src/lib.rs + pyproject.toml

    # Install in current virtualenv (dev mode)
    cd mylib
    maturin develop

    # Build a release wheel
    maturin build --release

🔗Writing the Rust extension

    // src/lib.rs
    use pyo3::prelude::*;
    use pyo3::wrap_pyfunction;

    /// A simple function exposed to Python
    #[pyfunction]
    fn add(a: i64, b: i64) -> i64 {
        a + b
    }

    /// Compute sum of squares — vectorised over a Python list
    #[pyfunction]
    fn sum_of_squares(nums: Vec<f64>) -> f64 {
        nums.iter().map(|x| x * x).sum()
    }

    /// A Rust class exposed to Python
    #[pyclass]
    struct Counter {
        count: u64,
    }

    #[pymethods]
    impl Counter {
        #[new]
        fn new() -> Self {
            Counter { count: 0 }
        }

        fn increment(&mut self) {
            self.count += 1;
        }

        fn value(&self) -> u64 {
            self.count
        }
    }

    /// The module name must match the package name in pyproject.toml
    #[pymodule]
    fn mylib(m: &Bound<'_, PyModule>) -> PyResult<()> {
        m.add_function(wrap_pyfunction!(add, m)?)?;
        m.add_function(wrap_pyfunction!(sum_of_squares, m)?)?;
        m.add_class::<Counter>()?;
        Ok(())
    }

🔗Using the extension in Python

 1    import mylib
 2
 3    result = mylib.add(3, 4)          # 7
 4    total  = mylib.sum_of_squares([1.0, 2.0, 3.0])  # 14.0
 5
 6    c = mylib.Counter()
 7    c.increment()
 8    c.increment()
 9    print(c.value())  # 2

🔗Cargo.toml

    [package]
    name = "mylib"
    version = "0.1.0"
    edition = "2021"

    [lib]
    name = "mylib"
    crate-type = ["cdylib"]   # dynamic lib loadable by Python

    [dependencies]
    pyo3 = { version = "0.21", features = ["extension-module"] }

When to use Rust extensions: JSON parsers, image processing, graph algorithms, cryptography, any hot loop that runs millions of iterations. For most business logic, pure Python is fine.

NumPy interop: Use the numpy crate in Rust (pyo3-numpy) to pass NumPy arrays directly to Rust with zero copies. Enables massively fast numerical code with a clean Python interface.