Zum Hauptinhalt springen

Book Completion Checklist

Chapters 1–4 — Mental model​

  • I understand names as bindings.
  • I distinguish identity and equality.
  • I understand shallow and deep copying.
  • I understand dynamic but strong typing.
  • I can explain LEGB scope.
  • I understand closures and late binding.
  • I avoid mutable default arguments.

Chapters 5–8 — Functions​

  • I distinguish missing, None, empty, and falsy.
  • I can design sentinel-based APIs.
  • I treat functions as first-class objects.
  • I understand bound methods.
  • I can design positional-only and keyword-only signatures.
  • I can write typed decorators.
  • I preserve metadata with wraps.

Chapters 9–12 — Iteration and object model​

  • I distinguish iterable and iterator.
  • I understand generator exhaustion.
  • I can design lazy pipelines.
  • I know when a comprehension becomes unreadable.
  • I understand instance and class attributes.
  • I understand the Python data model.
  • I can implement equality and hashing safely.
  • I can create context-manageable and callable objects.

Chapters 13–16 — Advanced object system​

  • I understand MRO.
  • I understand cooperative super().
  • I prefer composition when inheritance is not substitutable.
  • I can design value objects with dataclasses.
  • I understand shallow immutability.
  • I understand properties and descriptors.
  • I understand class-body execution.
  • I know when not to use a metaclass.

Chapters 17–20 — Typing​

  • I understand that hints do not validate runtime values.
  • I can use unions, literals, Self, Final, and ClassVar.
  • I understand TypeIs and TypeGuard.
  • I can write generic functions and classes.
  • I understand bounds and constraints.
  • I understand invariance, covariance, and contravariance.
  • I can design small protocols.
  • I understand TypedDict.
  • I validate external data before trusting it.

Chapters 21–24 — Runtime and concurrency​

  • I classify failures.
  • I translate exceptions with explicit chaining.
  • I can use exception groups.
  • I understand context-manager ownership.
  • I can use ExitStack.
  • I understand reachability and cycles.
  • I can investigate memory with tracemalloc.
  • I distinguish concurrency and parallelism.
  • I can choose threads, processes, or asyncio.
  • I understand structured concurrency.
  • I handle cancellation safely.

Chapters 25–28 — Production engineering​

  • I benchmark before optimizing.
  • I can use timeit and cProfile.
  • I understand import caching and circular imports.
  • I avoid import-time side effects.
  • I understand distribution versus import packages.
  • I can configure pyproject.toml.
  • I can build and test a wheel.
  • I understand dependency groups, locks, and constraints.
  • I can design layered tests.
  • I know when to use fakes versus mocks.
  • I patch where a dependency is looked up.
  • I test the built artifact.

Chapters 29–30 — Architecture and capstone​

  • I can separate domain, application, infrastructure, and delivery.
  • I can define ports and adapters.
  • I can design repositories and a unit of work.
  • I understand local and distributed transactions.
  • I can design a transactional outbox.
  • I understand idempotency and reconciliation.
  • I can design structured logs, metrics, and traces.
  • I understand health checks and graceful shutdown.
  • I can plan database migrations.
  • I can design a modular monolith.
  • I can justify microservice extraction.
  • I can migrate one TypeScript use case incrementally.
  • I can present the architecture in English.
  • I have completed the capstone.