Python in Seven Days

Install first. Then type the surface of the language. Then the memory picture. Then a map of the frameworks you will hear in every Python shop — each with a use case and an architecture — plus the shapes underneath, including events. Day 1 is still names-on-a-heap, not a framework tour you claim as scar tissue.

• 0.1 Setup and positioning — toolchain, conversion sentence
• 0.2 pyproject.toml — [project], extras versus groups, uv lock
• 0.3 Packages — __init__.py, regular versus namespace, __all__
• 0.4 Language familiarisation — def, if/elif, the for-loop family, lambda, literals, f-strings, string methods
• 0.5 How memory works — names, heap, refcount, cyclic GC
• 0.6 Django — full-site MTV, admin, ORM; versus React and Next.js
• 0.7 Flask — small HTTP surface you compose
• 0.8 FastAPI — typed JSON APIs, Pydantic, OpenAPI, hosting, enterprise consumption
• 0.9 Uvicorn — ASGI server, bind address, workers, gunicorn
• 0.10 Pydantic — BaseModel, validation, dump; not an ORM
• 0.11 Database — layers, SQLAlchemy, Alembic; not the Django ORM
• 0.12 Streamlit — data apps, rerun model
• 0.13 PyTorch — tensors, autograd, training loop
• 0.14 TensorFlow — Keras, SavedModel, serving
• 0.15 pytest — collection, fixtures, assert rewriting
• 0.16 Airflow — DAGs, scheduler, workers
• 0.17 Scheduled tasks — cron, APScheduler, Celery Beat, CronJob
• 0.18 Tkinter — desktop mainloop
• 0.19 Common architectures — script, service, pipeline, worker, CLI
• 0.20 Event-based architectures — signals, queues, brokers, not event sourcing

Choose the right structure, then write cleaner Python: decorators, generators, and with. 0.24 is the decorator lab, including stacked wrappers. 0.25 is raise, ValueError, and custom exception types. 0.26 is dictionary handling — .get, views, aggregates on .values(). 0.27 is lambdas: key=, map / filter, and when a comprehension is clearer. 0.28 is dunder methods — __str__, __eq__, __len__, __call__; Day 3 still types the hash contract. Name metaclasses and introspection without claiming you wrote an ORM. Days 2–3 are where you type the decorator and the generator; Day 4 still types exception chaining; the six-week Data Structures & Algorithms course is where you implement graphs under load. Tonight is vocabulary you can defend.

• 0.21 Data structures — list, dict, set; stack, queue, heap, graph, tree; when a linked list is the wrong default
• 0.22 Decorators, generators, context managers — @, yield, with; Day 2–3 still own the typing
• 0.23 Metaclasses and introspection — type, inspect; you name them, you do not ship a metaclass
• 0.24 Decorators — wrapping, wraps, factories, stacked @a @b (bottom first, call onion outside-in)
• 0.25 Exceptions — raise, ValueError versus TypeError, custom types inherit Exception; Day 4 still owns chaining
• 0.26 Dictionary handling — .get versus [], in on keys, views, aggregates on .values(); Day 2 still owns defaultdict
• 0.27 Lambdas — lambda args: expression; map / filter / sorted / max do the looping; Day 2 still prefers a comprehension; Day 3 still owns late binding
• 0.28 Dunder methods — __init__, __str__ versus __repr__, __eq__, operators, containers, __call__, with; Day 3 still owns __hash__

A pattern is a named solution. In Java and C# that name often arrives as a class hierarchy. In Python it is frequently a function, a module, a Protocol, or a builtin you already typed. You map the name; you do not ship 23 UML folders as this week’s scar tissue. Strategy is a callable. Singleton is usually a module. The decorator pattern wraps an object; @ rebinds a function (0.24). Observer is 0.20.

• 0.29 The Python map — when a class is unnecessary; Strategy / Singleton / Decorator as names
• 0.30 Creational — module as Singleton, function / classmethod as Factory, kwargs as Builder
• 0.31 Structural — Adapter, Facade, Proxy; GoF Decorator versus @
• 0.32 Behavioral — Strategy, Observer, Command, Template; Iterator and middleware you already have

Three labs, one day. 1.1 is the object model. 1.2 is calls and scope. 1.3 is the spoken gate — until twelve near-certain cards are clean twice, Day 1 is not finished.

• 1.1 Mental model — names, aliasing, is/==, copy, None, mutable defaults
• 1.2 Calls and scope — *args/**kwargs, keyword-only, LEGB, enumerate/zip, slicing, truthiness
• 1.3 Speak it — same bank, follow-ups, freeze tracking. Day 1 ends here.

Highest-leverage day. Stop sounding like a Java developer: comprehensions, generators, EAFP, and the standard library that makes you look fluent.

• Comprehensions and yield
• Iterator protocol
• EAFP over LBYL
• collections and itertools
• pathlib, Counter, enumerate

The “explain how X works” questions: closures and late binding, decorators with wraps, context managers, dunders, MRO, dataclasses.

• Late binding in loops
• Decorators and wraps
• Context managers
• __eq__/__hash__
• Protocol, ABC, dataclasses

The questions that separate senior from mid-level. The GIL in ninety seconds, threads vs processes vs asyncio, memory and exceptions.

• GIL and PEP 703
• ThreadPool vs ProcessPool
• asyncio vs parallelism
• Refcount and cyclic GC
• Exception chaining

Sound like someone who ships Python: packages, venv/uv, pytest, type hints, then one role-shaped afternoon. You already mapped Django, Flask, FastAPI, Uvicorn, Pydantic, the database layers, scheduled tasks and the rest in 0.6–0.20, you already read pyproject.toml in 0.2, and you already walked __init__.py in 0.3 — today you install for a track.

• src/ layout and imports (you already walked __init__.py in 0.3)
• uv, venv, pyproject.toml (you already walked the file in 0.2)
• pytest fixtures and mocks
• Type hints and mypy
• Role track: FastAPI, pandas, LLM APIs, or CLI

Ten timed problems out loud, then something genuinely yours — the honest answer to “what have you built in Python?”

• Twenty-minute drills
• Counter, defaultdict, unpacking
• Build with tests and README
• Honest conversion narrative

Spoken drilling on the question bank, two mocks, then attack weak spots. Prepare questions about their stack, tests and typing.

• Near-certain questions
• Senior three-way GIL/asyncio
• Live-coding survival kit
• Questions that signal seniority