Python
from first principles

No declaration keyword

Write name = "Alice" — no var, let, or int. The type is attached to the value, not the variable. The same variable can hold different types at different times (though doing so is bad practice).

Boolean literals are capitalised

True and False — not true/false. Python's null is None, not null or nil.

Type system

Truthiness

Everything is truthy except: None, False, 0, 0.0, "", [], {}, ().

So if my_list: means "if the list is non-empty" — idiomatic Python.

Type hints (Python 3.5+)

Hints are documentation for tools (mypy, your IDE). Python ignores them at runtime. Write def greet(name: str) -> str: to document intent without enforcing it.

Three quoting styles

'single' and "double" are identical — use whichever avoids escaping. """triple""" spans multiple lines and is also used for docstrings.

f-strings — the preferred formatting method

f"Hello, {name}!" evaluates the expression inside {} and converts it to a string. You can put any expression inside: f"{2 + 2}", f"{obj.method()}".

Format specifiers go after a colon: f"{value:.2f}" → 2 decimal places. f"{n:05d}" → zero-padded 5-digit int.

Slicing — [start:stop:step]

All three parts are optional. Negative indices count from the end: s[-1] is the last character. s[::-1] reverses the string.

Raw strings

Prefix r: r"C:\Users\Alice" — backslashes are literal. Essential for file paths on Windows and for regex patterns.

Essential string methods

• .strip()Remove leading/trailing whitespace. .lstrip() / .rstrip() for one side.
• .split()Split on whitespace (default) or delimiter. Returns a list.
• .join()Opposite of split: ", ".join(["a","b","c"]) → "a, b, c"
• .replace()Replace all occurrences: "hello".replace("l","r") → "herro"
• .startswith()Returns bool. Useful for if line.startswith("#"):
• .upper() .lower()Case conversion. .title() for Title Case.

Indentation IS syntax

Unlike C, Java, or JavaScript, indentation is not optional. Inconsistent indentation raises IndentationError. The standard is 4 spaces — configure your editor to insert spaces on Tab.

for loops iterate directly

Python's for loop iterates over any iterable — lists, strings, dicts, generators. You rarely need an index counter. When you do, use enumerate().

range(start, stop, step)

Generates integers lazily. range(10) → 0–9. range(2, 10, 2) → 2, 4, 6, 8. range(10, 0, -1) → 10 down to 1.

for...else — a Python exclusive

The else block on a for loop runs only if the loop completed without hitting a break. Useful for "search and report not found" patterns.

match / case (Python 3.10+)

Structural pattern matching. More powerful than a switch statement — it can match values, types, sequences, and structures with guard clauses (if). Wildcard: case _.

Defining a function

def name(params): ... — the body must be indented. return exits with a value. A function without return returns None.

Default arguments

def greet(name, greeting="Hello"): — parameters with defaults are optional. Critical rule: default arguments are evaluated once at function definition, not each call. Never write def f(x, items=[]): — that list is shared across all calls.

*args and **kwargs

• *argsCollects extra positional arguments into a tuple. def total(*nums): return sum(nums)
• **kwargsCollects extra keyword arguments into a dict. def config(**opts): ...
• *A bare * in the signature makes all following params keyword-only: def f(a, *, b): — b must be named at call site.

lambda — anonymous functions

lambda x: x * 2 is a single-expression function. Useful as a key= argument to sorted()/max() etc. Prefer a named def for anything more complex.

Closures

An inner function that references a variable from its enclosing scope creates a closure — the variable is captured. Used to build factory functions.

List methods

sorted() vs .sort()

sorted(lst) returns a new sorted list, leaving the original unchanged. lst.sort() sorts in-place and returns None. Prefer sorted() when you want to keep the original.

Tuple unpacking

x, y = (3, 4) — assigns each element to a variable. first, *rest = [1,2,3,4] uses the starred expression to collect the tail. Useful for swapping: a, b = b, a.

namedtuple — a lightweight struct

from collections import namedtuple
Point = namedtuple("Point", ["x","y"])
Access by name: p.x and by index: p[0]. Immutable like a regular tuple.

Dict access patterns

• d[key]Direct access — raises KeyError if key absent. Use when you expect the key to exist.
• .get(k,v)Safe access — returns None (or default v) if key missing. Never raises. Preferred for uncertain keys.
• .setdefault(k,v)Returns value if key exists; otherwise inserts v and returns it. Useful for building dicts of lists.
• k in dMembership test — O(1). Tests keys only. k in d.values() is O(n).
• .items()Returns view of (key, value) pairs. Use in for k, v in d.items():

Dict merging (Python 3.9+)

merged = dict1 | dict2 creates a new merged dict. dict1 |= dict2 updates in-place. Before 3.9: {**dict1, **dict2}.

Set operations

defaultdict

from collections import defaultdict
dd = defaultdict(list) — accessing a missing key auto-creates it with list() as the default value. Great for grouping: dd["key"].append(item) without checking if the key exists first.

The pattern

[expression for item in iterable if condition]

All three parts: the expression transforms each item, the for iterates, and the if filters. The if clause is optional.

Four flavours

Generator expressions save memory

sum(x**2 for x in range(1_000_000)) — the generator produces values one at a time without building a million-element list. Use generators inside function calls like sum(), max(), any(), all().

Nested comprehension — flattening

[x for row in matrix for x in row] — two for clauses flatten a 2D list. Read left to right as nested loops: outer loop first, inner second.

__init__ — the initialiser

Called when you write Dog("Rex", "Labrador"). Sets up instance variables on self. It is not a constructor — the object is already created when __init__ runs.

Instance vs class variables

@property

Turns a method into an attribute: callers write dog.weight instead of dog.weight(). Add a setter with @weight.setter to validate on assignment.

@classmethod vs @staticmethod

• @classmethodFirst arg is cls (the class). Use as alternate constructors: Dog.from_dict(data).
• @staticmethodNo implicit first arg. Just a function attached to the class for organisation. Doesn't know about self or cls.

@dataclass — zero-boilerplate classes

Automatically generates __init__, __repr__, and __eq__. Write x: type = default for each field. Use field(default_factory=list) for mutable defaults.

Key dunder methods

Subclassing

class Dog(Animal): — Dog inherits all methods and class variables from Animal. Override by defining the same method name in the subclass.

super() — calling the parent

super().__init__(name, sound) calls Animal.__init__. Without super(), the parent's __init__ is skipped and instance variables won't be set.

isinstance vs type()

isinstance(rex, Animal) returns True for instances of Animal and any subclass. type(rex) is Animal returns False for subclass instances. Almost always prefer isinstance().

Abstract base classes

from abc import ABC, abstractmethod — a class inheriting ABC can declare @abstractmethod methods that subclasses must implement. Instantiating the ABC directly raises TypeError.

Multiple inheritance & MRO

class C(A, B): — Python resolves method lookup in a consistent left-to-right order (C3). Inspect with C.__mro__. Keep multiple inheritance shallow; prefer composition for complex cases.

try / except / else / finally

• tryThe block that might raise an exception.
• exceptCatches a specific exception type. List multiple types in a tuple: except (TypeError, ValueError):
• elseRuns only if the try block succeeded (no exception). Cleaner than putting success code in try.
• finallyAlways runs — cleanup code (close files, release locks). Runs even if an exception was raised and not caught.

raise — throwing exceptions

raise ValueError("must be positive") — raises with a message. Plain raise inside an except block re-raises the current exception.

Custom exceptions

Inherit from Exception (or a more specific built-in). Add custom attributes in __init__. Use a hierarchy for your app: class AppError(Exception) as the base, then class NotFoundError(AppError).

Common exceptions

File modes

pathlib — the modern way

Use Path instead of string concatenation for paths. The / operator joins paths: Path.home() / "Documents" / "data.txt" — this works on Mac, Linux, and Windows.

Import styles

Virtual environments on Mac

Package structure

myproject/
├── .venv/
├── mypackage/
│   ├── __init__.py      ← makes it a package
│   ├── utils.py
│   └── models/
│       ├── __init__.py
│       └── user.py
├── main.py
└── requirements.txt

__name__ guard — always use it

if __name__ == "__main__": — code inside only runs when the file is executed directly, not when imported as a module. Without it, importing your module would execute its side effects.

Anatomy of a decorator

Three layers: the outer function receives the function to wrap, the inner wrapper adds before/after logic and calls the original, and the outer function returns wrapper.

@functools.wraps — always use it

Without @functools.wraps(func), your decorator replaces func.__name__ and func.__doc__ with "wrapper". @wraps copies the original's metadata onto the wrapper, preserving tracebacks and documentation.

Decorators with arguments

Add another level: the outermost function takes the arguments and returns the actual decorator. @retry(times=3) requires: outer function retry(times) → returns decorator → returns wrapper.

Stacking decorators

Decorators are applied bottom-up. @a above @b above def f means f = a(b(f)).

@functools.lru_cache

Built-in memoisation decorator. Caches function results by arguments. @lru_cache(maxsize=128) — ideal for recursive functions like Fibonacci. @cache (Python 3.9+) is lru_cache with unlimited size.

How generators work

When Python sees yield, calling the function returns a generator object without executing any code. Each next() call runs until the next yield, then suspends. When the function returns, StopIteration is raised.

yield from — delegating

yield from other_iterable delegates to another iterable, yielding each of its values. Cleaner than a nested for loop with yield.

Context managers

The with statement calls __enter__ on entry and __exit__ on exit — even if an exception occurs. Implement with a class or with @contextlib.contextmanager.

@contextmanager — the easy way

Write a generator function with a single yield inside a try/finally. Code before yield is __enter__; code after is __exit__. The yielded value becomes the as target.

itertools — lazy combinatorics

Most-used modules