Complete Python Tutorial

Python's design goal was that reading code should be easy, and it succeeded so thoroughly that it is possible to be productive for years without learning what the interpreter is actually doing. That works until it does not — until a default argument accumulates state between calls, a closure in a loop captures the wrong thing, or a threaded program refuses to use more than one core.

Every one of those is the same phenomenon: Python's syntax hides a mechanism, and the mechanism eventually asserts itself. The topics that reward real study are exactly the ones where the gap is widest — the data model, name binding and scope, the iterator protocol, and the concurrency story.

Names are bindings, not boxes

In Python a variable is a name bound to an object, not a container holding a value. Assignment rebinds the name; it never copies. That one sentence explains the mutable-default-argument surprise, why passing a list to a function lets the function modify your list, why a = b on a list gives you two names for one object, and why is and == can disagree.

The practical consequence worth internalising: ask whether an object is mutable before assuming an operation is safe. Mutable default arguments and shared nested structures after a shallow copy are the same bug seen from two angles.

def add(item, bucket=[]):        # evaluated ONCE, at definition
    bucket.append(item)
    return bucket

add(1); add(2)                   # [1, 2] - one list shared by every call

def add(item, bucket=None):      # the correct idiom
    bucket = [] if bucket is None else bucket
    bucket.append(item)
    return bucket

import copy
a = {"tags": ["x"]}
b = copy.copy(a)                 # shallow: the inner list is SHARED
b["tags"].append("y")
a["tags"]                        # ['x', 'y'] - surprised?
c = copy.deepcopy(a)             # independent all the way down

Generators change what is possible, not just what is tidy

A list comprehension builds the whole result in memory. A generator produces one item at a time and holds nothing else. On small data the difference is style; on a ten-gigabyte log file it is the difference between working and a memory error.

The broader idea is the iterator protocol, and once it is clear, a lot of Python stops looking like magic: for loops, unpacking, zip, itertools and file objects are all the same interface. Composing generators gives you a streaming pipeline with constant memory and no framework.

# Constant memory regardless of file size - each stage pulls one line
def lines(path):
    with open(path) as f:
        yield from f

def parsed(rows):
    for r in rows:
        if r.strip():
            yield json.loads(r)

def errors(records):
    for rec in records:
        if rec.get("level") == "ERROR":
            yield rec

for rec in errors(parsed(lines("app.log"))):
    handle(rec)

# Nothing is read until the for loop asks for it, and only one
# line exists in memory at a time.

Concurrency: classify the work before choosing a tool

The GIL means one thread executes Python bytecode at a time. That makes threads useless for CPU-bound work and perfectly fine for I/O-bound work, because the GIL is released while waiting on I/O. Get the classification right and the tool follows.

Two failure modes are worth naming. A blocking call inside an async function stalls the entire event loop, not just that coroutine — wrap it in run_in_executor. And multiprocessing must pickle everything it sends, so passing large objects to workers can cost more than the work saves.

Packaging and environments, where most lost hours go

More Python time is lost to environment problems than to language problems. The rules that prevent nearly all of them: one virtual environment per project, never install into the system interpreter, pin exact versions in a lock file while keeping loose ranges in the project declaration, and make the environment reproducible from a file rather than from memory.

ModuleNotFoundError is almost always this and not a missing package — the wrong interpreter is running. Checking sys.executable resolves it in seconds, and is the first thing to check rather than the last.

# Which interpreter is actually running, and what can it see?
python -c "import sys; print(sys.executable); print(sys.path)"

# Modern, fast, and reproducible
uv venv && source .venv/bin/activate
uv pip install -r requirements.txt

# Run a tool without polluting the project environment
uvx ruff check .