The Python Reference

The smallest possible working program, and the four ideas under it: printing, storing values, building text from data, and turning text into numbers.

1. print() and stringsprint() · strings
2. Variables and typesvariables · types
3. f-strings (string interpolation)f-strings · interpolation
4. Converting between strings and numbersstring → int conversion

Code that makes decisions and repeats itself — reading errors, branching with if/elif/else, combining conditions, and the two loop shapes (while and for).

1. Reading errors and debuggingdebugging · TypeError
2. if / elif / elseif / elif / else
3. Boolean logic: and / or / notboolean logic · and/or
4. while loopswhile loops
5. for loops and accumulationfor loops · accumulation

The tools that turn scripts into real programs: functions and scope to organise code, and the core data structures — lists, dicts, tuples and sets — to hold the data.

1. Functions: def and returndef · return vs print
2. Parameters, defaults and keyword argumentsparameters · defaults · keyword args
3. Scope and namespacesscope · namespaces
4. Loop control: continue, break, and skipping invalid inputfor loop · continue · skipping invalid input
5. Built-ins: len, max, min, sum, sortedlen · max · min · sum · sorted
6. Composing functions and single responsibilitycomposing functions · single responsibility
7. Lists: indexing, slicing, methodslists · indexing · slicing · append/pop/remove · in
8. enumerate and building lists in a loopenumerate · build-list-in-loop · filter
9. Dictionariesdicts · .get() · .items()
10. Tuples, sets and unpackingtuples · sets · unpacking
11. List comprehensionslist comprehensions

Reaching past your own code: the standard library, reading and writing files and JSON, calling APIs, keeping secrets in env vars, handling errors, and the two foundations of larger programs — objects (classes) and tests.

1. The standard library: random, datetime, pathlibrandom · datetime · pathlib — stdlib tour
2. Reading and writing filesopen() · with · read/write modes
3. JSON persistencejson.dump · json.load · dict↔file
4. Calling an API with requestsrequests.get() · status codes · .json()
5. API keys, secrets and environment variablesenv vars · never hardcode secrets · query params
6. Error handling: try / except / raisetry/except · raise · specific exceptions
7. Your first class: __init__, methods, selfclass · __init__ · methods · self
8. Dunders and dataclasses__repr__ · __str__ · @dataclass
9. Inheritance and super()inheritance · super() · override
10. Writing tests: assert and pytest-stylepytest-style testing · assert · red→green

The building blocks of a machine-learning pipeline — validating records, engineering features, classifying with rules, measuring with the right metrics, aggregating, and wiring it all into a hand-rolled train→predict→evaluate loop.

1. Schema validationvalidate record · required fields · type + range guards
2. Validating a batchbatch validation · reject/accept split · error reporting
3. Feature engineeringnormalise · bucket · one-hot encode · feature transforms
4. Rule-based classifierrule classifier · threshold predict · deterministic ML shape
5. Evaluation metricsaccuracy · precision · recall · confusion matrix
6. Aggregation pipelinegroup-by · aggregate · sort pipeline
7. Train → predict → evaluatethreshold learner · train/test split · evaluate pipeline

The advanced pure-Python patterns that separate solid code from senior code — lazy generators, decorators, context managers, asyncio, plugin registries, the LRU cache, and state machines.

1. Generators and lazy evaluationgenerators · yield · lazy evaluation · iterator protocol
2. Decoratorsdecorators · functools.wraps · higher-order functions · memoization
3. Context managers (with)context managers · __enter__ / __exit__ · contextlib · resource cleanup
4. asyncio basicsasyncio · async def · await · asyncio.gather · concurrent tasks
5. The plugin registry patternplugin registry · decorator registration · dynamic dispatch · extensibility
6. LRU cache and data-structure choiceLRU cache · OrderedDict · eviction policy · data-structure trade-offs
7. State machinesstate machine · finite automaton · transitions · event dispatch

LLM-from-code fundamentals in pure Python: prompting, conversation memory, parsing responses, tool-call dispatch, and JSON guardrails.

1. Prompt engineering with string transformsprompt engineering · string transforms · template filling
2. System prompts and conversation memorysystem prompt · conversation list · multi-turn structure
3. Request → parse → validate (handling an LLM response)request→parse→validate · stubbed LLM · response handling
4. Detecting a tool calltool-call detection · intent parsing · string inspection
5. Dispatching tool calls (a tool registry)tool dispatch · function registry · tool-use loop
6. JSON output guardrails: force and validateJSON output · validate schema · retry on failure
7. Parsing structured metadata (git log example)git log parsing · commit metadata · branch reasoning

The production-ops patterns that make a script survive the real world: retry with backoff, idempotent re-runs, config-driven dispatch, rate-limiting and batching, dead-letter handling, dependency-ordered pipelines, and deterministic scheduling.

1. Retry with exponential backoffretry logic · exponential backoff · delay sequences
2. Idempotent operationsidempotency · state guards · safe re-runs
3. Config-driven dispatchhandler registry · config dispatch · plugin pattern
4. Rate limiting and batchingbatching · rate cap · chunked processing
5. Dead-letter handlingerror recovery · dead-letter queue · partial failure
6. Step pipelines with dependenciespipeline · dependency order · step chaining
7. Scheduling logiccron-style scheduling · deterministic time checks · interval math

Building real AI features in plain Python — few-shot prompting, validated function-calling, embeddings and RAG, an agent loop with guardrails, and evals to prove it works.

1. Few-shot and structured promptingfew-shot examples · output schema · prompt assembly
2. Robust function-callingargument validation · type coercion · reject bad tool calls
3. Embeddings and cosine similaritytext → vector · cosine similarity · ranking by relevance
4. A tiny vector storeindex documents · retrieve top-k by similarity · in-memory store
5. RAG: grounding answers in retrieved contextretrieve → stuff context → grounded answer · 'I don't know' path
6. A minimal agent loopthink → act → observe · feed results back · stop on final answer
7. Guardrails for agentsmax-steps cap · allow-list tools · block forbidden actions · audit log
8. Evals: scoring model outputeval harness · metric · pass-rate · regression detection

The systems view of an AI product: orchestrating many agents, designing a vector store, modelling pipelines as DAGs, scaling under a concurrency cap, controlling token cost, tracing every step, and designing for the failures that will happen.

1. Multi-agent orchestrationcoordinator · agent registry · task routing · result merge
2. Vector-DB design and metadata filteringvector store · metadata filter · top-k similarity retrieval
3. Pipeline / DAG designDAG · dependencies · topological sort · cycle detection
4. Scaling: batching and concurrencybatching · concurrency cap · throughput simulation · completion order
5. Cost control and token budgetingtoken estimation · price table · budget enforcement · model-tier downgrade
6. Observability and tracingtracer · spans · parent links · trace tree · slowest-span analysis
7. Failure-mode designtransient vs permanent · retry · dead-letter · fallback · graceful degradation

The durable skill of reviewing code you didn't write — spotting bugs and edge cases, judging structure, catching security holes, and giving feedback that's specific, kind, and ranked by severity.

1. Reading a diff, finding the bugdiff review — spot the off-by-one / wrong operator
2. Spotting the missing edge caseedge cases — empty / None / zero guards
3. Judging naming and structurebehaviour-preserving refactor — extract a named helper
4. Catching the security issuesecurity review — replace eval() of untrusted input
5. Writing good review feedbackJUDGE mode — classify each finding (bug/security/style/nit)

Reviewing and verifying AI-generated code — catching confident-but-wrong logic, hallucinated APIs, insecure patterns and missing tests, then making the accept/reject/revise call with evidence rather than trust.

1. The confident-but-wrong outputhappy-path green ≠ correct
2. The hallucinated APIhallucinated APIs
3. Plausible-but-insecureAI security review
4. The missing testwrite the verification the AI skipped
5. Silent edge-case failurewrong at the boundary
6. Accept / reject / reviseJUDGEMENT — classify with evidence