🔥 BLACK FRIDAY SALE1 course ₹199·any 3 courses ₹399 for 3 months·ALL courses + 1 mock interview ₹599 for 6 monthsClaim offer →

Sections · Python

🐍

Python Mastery

LIVE

From first script to professional Python: data model, concurrency, testing, packaging and real projects.

A practical, deep Python path: core syntax and the data model, functions and closures, classes and protocols, iterators and generators, decorators and context managers, type hints, concurrency and asyncio, testing, packaging, performance, web APIs, data work and automation, with projects and interview preparation.

Python
₹500 ₹199

for 3 months · no auto-renewal

Black Friday offer: 1 course ₹199 · any 3 courses ₹399 for 3 months · all courses + 1 mock interview ₹599 for 6 months

Get this section
54in-depth lessons
26+hours of learning
409interview Q&As
4free lessons

What you will be able to do

  • ✓Understand how Python really works: names, objects and the data model
  • ✓Write clear, idiomatic code with comprehensions, generators and decorators
  • ✓Design classes with protocols, dataclasses and composition
  • ✓Use type hints and static checking to catch bugs early
  • ✓Choose the right concurrency model: threads, processes or asyncio
  • ✓Test confidently with pytest, fixtures and property-based testing
  • ✓Package, version and publish your own libraries
  • ✓Profile and speed up slow code, and build real APIs and tools

Who this is for

  • Beginners who want a deep, correct foundation
  • Developers from other languages who want to write idiomatic Python
  • Engineers preparing for Python interviews

What you need first

None for the first lessons. Later tracks assume you finished the earlier ones.

Hands-on projects

  • A log-analysis command-line tool
  • An async web crawler
  • A tested, typed, packaged library

Full curriculum: what you will learn, topic by topic

54 topics across 11 tracks. Open a track to see every topic and what it teaches.

🧭 Python Foundations7 topics

How Python runs, the object model, control flow, text, collections and files: the base every other topic builds on.

1How Python Really Runs: Interpreter, Bytecode and a Professional SetupSee what happens between typing a line of Python and getting a result. Learn how CPython compiles source to bytecode, why virtual environments exist, how to set up a modern toolchain with uv, ruff and pytest, and build your first useful script step by step.Foundation · 24 minFREE2Names, Objects and Mutability: The Python Object Model ExplainedUnderstand the single idea behind most Python surprises: names point to objects. Learn identity versus equality, mutable versus immutable types, aliasing bugs, shallow and deep copies, reference counting, and how numbers (int, float, Decimal) really behave, with practical debugging examples.Foundation · 26 minFREE3Python Control Flow and Structural Pattern Matching: if, for, while, match and Idiomatic LoopsWrite clear, idiomatic Python control flow. Master truthiness and conditional expressions, loops with enumerate, zip and for-else, the walrus operator, EAFP versus LBYL, and the match statement with literal, sequence, mapping, class and guarded patterns, with practical examples and the traps to avoid.Foundation · 26 minFREE4Python Strings, Unicode and Text Formatting: Encodings, f-strings, Format Specs and Safe Text HandlingHandle text correctly. Learn that str is a sequence of Unicode code points, bytes versus str and encodings, normalisation and case-folding, slicing and the everyday string methods, f-strings and the format mini-language, building strings efficiently, regular-expression basics, templates and escaping, and the classic bugs with encodings, whitespace and comparison.Foundation · 26 min🔒 Paid5Python Sequences in Practice: Lists, Tuples, Slicing, Sorting, Copying and PerformanceUse Python's sequence types with confidence. Learn lists as dynamic arrays and their costs, tuples and immutability, slicing and slice assignment, unpacking, sorting with key functions and stability, shallow versus deep copies and aliasing bugs, deque, bisect and heapq, array and range, comprehension patterns and choosing the right container.Foundation · 26 min🔒 Paid6Python Dictionaries, Sets and Hashing: How Hash Tables Work and Choosing the Right MappingMaster Python's fastest data structures. Learn how hash tables work, hashability and the hash/eq contract, dictionary API and patterns (get, setdefault, defaultdict, Counter, merging), insertion order, views, set operations, frozenset, performance and collisions, common bugs with mutable keys and iteration, and choosing between dict, set, Counter, ChainMap and friends.Foundation · 26 min🔒 Paid7Python Files, Paths and Text I/O: pathlib, open modes, Encodings, CSV, JSON and Atomic WritesRead and write data safely. Learn pathlib for cross-platform paths, opening files with modes and encodings, reading text and bytes, streaming large files, newline handling, the csv and json modules, temporary files and directories, atomic writes with os.replace, file permissions, directory traversal safely, and the mistakes that cause corrupted data and security holes.Foundation · 26 min🔒 Paid
ƒ Functions, Closures and Iteration6 topics

Arguments and scope, first-class functions, decorators, comprehensions, iterators and generators.

1Python Functions, Arguments and Scope: Defaults, *args, **kwargs, Keyword-Only Parameters and LEGBDesign Python functions that are easy to call and hard to misuse. Learn how arguments are passed, positional versus keyword parameters, defaults and the mutable default trap, *args and **kwargs, positional-only and keyword-only markers, return values, docstrings, and the LEGB scope rules with global and nonlocal.Foundation · 28 min🔒 Paid2First-Class Functions and Closures in Python: Callbacks, Late Binding, functools and Function FactoriesTreat functions as values. Learn higher-order functions, lambdas, key functions, closures and the nonlocal state they carry, the late-binding trap in loops, functools.partial and reduce, the operator module, callables, and when to choose a closure over a class.Intermediate · 28 min🔒 Paid3Python Decorators from First Principles: Closures, functools.wraps, Parameters and Real PatternsUnderstand decorators by building them from nothing. Start with functions as objects and closures, write timing, retry and caching decorators, add parameters, preserve metadata with functools.wraps, decorate async functions, type them with ParamSpec, and learn the pitfalls that surprise even experienced developers.Intermediate · 32 min🔒 Paid4Python Comprehensions and Expressions: List, Dict, Set, Generator Comprehensions, Walrus and Readable StyleWrite clear, fast transformations. Learn list, dict, set and generator comprehensions, nested loops and conditions, the scoping rules, the walrus operator inside comprehensions, conditional expressions, comparing with map, filter and loops, performance and memory, readability limits, and refactoring tangled comprehensions into named functions.Intermediate · 26 min🔒 Paid5Python Iterators and the Iteration Protocol: Writing Iterators, itertools Recipes and Iterator PitfallsGo deeper on iteration. Learn iterable versus iterator precisely, the two-method protocol and the __getitem__ fallback, writing re-iterable collections and one-shot iterators, iter with a sentinel, peeking and pushing back, batching and windowing, itertools recipes, zip and unpacking behaviour, consuming iterators safely, and async iteration.Intermediate · 26 min🔒 Paid6Iterators and Generators in Python: Lazy Pipelines, yield from and Streaming Large DataUnderstand the iteration protocol from the inside, then build memory-efficient generators. Learn how for loops really work, how yield suspends a function, generator expressions, send and close, yield from, itertools, and how to build streaming pipelines that process files far larger than memory.Intermediate · 32 min🔒 Paid
🧬 The Python Data Model6 topics

Special methods, containers, operators, hashing, context managers and descriptors: how Python objects really work.

1The Python Data Model: Special Methods, Protocols and How Objects Really WorkLearn the idea that makes Python consistent. Special (dunder) methods let your objects work with len, indexing, iteration, with, operators and printing. Build a playlist container and a duration class, understand repr versus str, truthiness, and why you call len(x) instead of x.len().Intermediate · 28 min🔒 Paid2Python Special Methods for Containers: Sequences, Mappings, Slicing and the collections.abc MixinsBuild custom containers that behave like built-ins. Learn the sequence and mapping protocols, __getitem__ with integers and slices, __len__, __contains__, __iter__, mutation methods, __missing__, using collections.abc base classes to get mixin methods for free, UserDict versus subclassing dict, and design guidance for ring buffers, case-insensitive mappings and matrices.Intermediate · 28 min🔒 Paid3Python Operator Overloading and Comparison: Arithmetic, Reflected Operators, total_ordering and Rich ComparisonsGive your types natural operators without surprises. Learn how binary operators dispatch (left operand, reflected right operand, subclass priority and NotImplemented), in-place operators, unary operators, comparison methods and functools.total_ordering, equality versus ordering, sorting custom objects, numeric tower pitfalls with Decimal, and design rules for readable operator use.Intermediate · 28 min🔒 Paid4Hashing, Equality and Immutability in Python: Safe Value Objects, Dict Keys and Frozen DataDesign objects that work correctly in sets and as dictionary keys. Learn identity versus equality, the hash/eq contract, how Python makes classes unhashable, building immutable value objects (frozen dataclasses, slots, __setattr__ guards, NamedTuple), caching hashes, MappingProxyType and frozenset, hashing pitfalls (mutable keys, NaN, float and int equality), and when immutability pays off.Intermediate · 26 min🔒 Paid5Python Context Managers: with Statements, contextlib, ExitStack and Exception-Safe CleanupMake resource handling reliable. Learn how the with statement works, write context managers as classes (__enter__ and __exit__) and with contextlib.contextmanager, handle exceptions inside exit, use suppress, closing, redirect_stdout and ExitStack, build timers, transactions and temporary-state managers, and write async context managers.Intermediate · 28 min🔒 Paid6Python Descriptors and Attribute Access: __get__, __set__, Properties, __getattr__ and Validated FieldsUnderstand how attribute access really works. Learn the attribute lookup algorithm, the descriptor protocol (__get__, __set__, __delete__, __set_name__), data versus non-data descriptors, how functions become bound methods and how property and cached_property work, write reusable validators and lazy attributes, use __getattr__, __getattribute__ and __setattr__ correctly, and avoid the common traps.Advanced · 30 min🔒 Paid
🏗️ Classes and Object Design6 topics

Classes, inheritance and the MRO, composition and protocols, dataclasses, abstract base classes and metaclasses.

1Classes and Objects Done Right in Python: Attributes, Properties, Class Methods and DesignDesign Python classes that stay simple and safe. Learn instance versus class attributes, how attribute lookup works, properties instead of getters and setters, classmethod and staticmethod, alternative constructors, encapsulation conventions, __slots__ and when not to use a class at all.Intermediate · 30 min🔒 Paid2Python Inheritance, the MRO and super(): Method Resolution, Mixins and When Not to InheritUnderstand how Python resolves methods across parent classes. Learn single and multiple inheritance, the C3 method resolution order, how super() really works (and why it is cooperative), mixins, designing __init__ in hierarchies, the Liskov substitution principle, and why composition is often the better choice.Intermediate · 30 min🔒 Paid3Python Composition, Protocols and Duck Typing: Designing with Has-A Instead of Is-ADesign flexible Python code without deep hierarchies. Learn why composition usually beats inheritance, how to delegate and inject collaborators, duck typing and the EAFP style, structural typing with typing.Protocol, the strategy and adapter patterns in Python, mixins and when they are acceptable, __getattr__ delegation, and a refactoring workflow from a class hierarchy to composed parts.Intermediate · 26 min🔒 Paid4Python Dataclasses, Enums and NamedTuples: Model Data Concisely and SafelyModel data without boilerplate. Learn dataclasses (fields, defaults, default_factory, frozen, slots, order, __post_init__, field options), NamedTuple and typing, Enum, IntEnum, StrEnum, Flag and auto, when to choose each, validation, serialisation, immutability and performance trade-offs.Intermediate · 30 min🔒 Paid5Python Abstract Base Classes: abc, abstractmethod, Virtual Subclasses and Designing InterfacesDefine and enforce interfaces in Python. Learn ABC and abstractmethod, abstract properties and class methods, how incomplete subclasses fail early, the template method pattern, register and __subclasshook__ for virtual subclasses, the collections.abc hierarchy, ABCs versus Protocols versus duck typing, and design guidance for plug-in architectures.Intermediate · 26 min🔒 Paid6Python Metaclasses and Class Decorators: How Classes Are Created and the Simpler Tools That Usually SufficeUnderstand how Python builds classes. Learn that classes are objects created by type, what a metaclass is, the class creation steps, __init_subclass__, __set_name__, class decorators, __class_getitem__, building a plugin registry, validating subclasses, how enums, dataclasses and ORMs use these hooks, and a decision guide for choosing the lightest tool.Advanced · 28 min🔒 Paid
🏷️ Types and Validation4 topics

Type hints, generics and protocols, static checking and data validation with Pydantic.

1Python Type Hints Fundamentals: Annotations, Optional, Unions, Generics and Real BenefitsLearn what type hints are and are not, how to annotate functions, collections, optional values and callables with modern syntax, how type checkers use them, and how to adopt typing gradually in a real codebase without slowing the team down.Intermediate · 28 min🔒 Paid2Python Generics and Protocols: TypeVar, Generic Classes, Bounds, ParamSpec and Structural TypingType reusable code without losing precision. Learn TypeVar and the new generic syntax, generic functions and classes, bounds and constraints, covariance in practice, Protocols for structural subtyping, runtime-checkable protocols, Callable and ParamSpec for decorators, TypedDict and Self, and how to design APIs that are flexible for callers and strict for implementers.Advanced · 30 min🔒 Paid3Static Type Checking in Python with mypy and pyright: Configuration, Strictness, Stubs and CIMake the type checker work for you. Learn how mypy and pyright analyse code, configuring them in pyproject.toml, strict flags and gradual adoption, reading and fixing common errors, narrowing and exhaustiveness checks, third-party stubs and py.typed, ignoring responsibly, editor integration, running in pre-commit and CI, and measuring progress on a large codebase.Intermediate · 26 min🔒 Paid4Data Validation in Python with Pydantic v2: Models, Validators, Strict Mode, Settings and JSON SchemaValidate untrusted data at the boundary. Learn Pydantic v2 models, field constraints, coercion versus strict mode, field and model validators, nested models and discriminated unions, serialisation with model_dump, error handling, TypeAdapter, configuration with pydantic-settings, JSON Schema generation, performance and where validation belongs in an architecture.Intermediate · 30 min🔒 Paid
⚡ Concurrency and Parallelism6 topics

The GIL, threads, processes, asyncio and how to choose a concurrency model with evidence.

1Python Concurrency Explained: The GIL, Threads, Processes and Asyncio ComparedBuild a correct mental model of concurrency in Python. Understand concurrency versus parallelism, CPU-bound versus I/O-bound work, what the GIL really does, how threads, processes and asyncio differ, and how to measure which one helps before writing complex code.Intermediate · 30 min🔒 Paid2Python Threads and Thread Pools: ThreadPoolExecutor, Futures, Locks, Queues and Safe ShutdownUse threads for I/O-bound work correctly. Learn threading.Thread basics, ThreadPoolExecutor with submit, map and as_completed, futures and exception handling, timeouts, locks, RLock, Event, Semaphore and Queue for coordination, race conditions and deadlocks, thread-local data, graceful shutdown, and when to choose threads over asyncio or processes.Intermediate · 30 min🔒 Paid3Python Multiprocessing: Process Pools, Start Methods, Shared Memory and CPU-Bound ParallelismUse all your CPU cores safely. Learn multiprocessing and ProcessPoolExecutor, spawn versus fork versus forkserver, pickling rules, chunksize and overhead, sharing data with shared_memory, queues, pipes and managers, initialisers and worker state, error handling, timeouts and shutdown, logging from workers, and when processes are not worth it.Advanced · 30 min🔒 Paid4Python asyncio Foundations: Coroutines, the Event Loop, Tasks, gather and Common MistakesUnderstand asyncio from first principles. Learn coroutines and await, what the event loop does, tasks and concurrency with create_task and gather, TaskGroup and timeouts, async context managers and iterators, mixing in blocking code with to_thread, why one blocking call freezes everything, and how to debug and test async programs.Intermediate · 30 min🔒 Paid5Python asyncio Patterns: gather, TaskGroup, Timeouts, Cancellation, Semaphores and QueuesMove from async basics to production patterns. Covers running coroutines concurrently with gather and TaskGroup, error handling and exception groups, timeouts with asyncio.timeout, cancellation and cleanup, limiting concurrency with semaphores, producer-consumer queues, mixing blocking code through to_thread, async iteration and context managers, graceful shutdown and testing async code.Advanced · 30 min🔒 Paid6Choosing a Python Concurrency Model: Threads, Processes, asyncio or Neither, with a Benchmark MethodDecide how to speed up Python programs with evidence. Classify workloads as I/O-bound or CPU-bound, understand the GIL and the free-threaded build, compare threads, processes and asyncio on cost and complexity, run a reproducible benchmark harness, combine models, avoid common mistakes, and follow a decision tree with checklist for production services and batch jobs.Advanced · 26 min🔒 Paid
✅ Quality, Errors and Testing5 topics

Exception design, logging, pytest, mocking and property-based testing, linting and CI.

1Python Exception Design: Hierarchies, Chaining, Context Managers and Failing ClearlyHandle errors deliberately. Learn how exceptions propagate, try/except/else/finally semantics, catching specific exceptions, custom exception hierarchies for libraries and applications, raise from and exception chaining, ExceptionGroup, EAFP, retry and cleanup patterns, error messages that help, and how to test failure paths.Intermediate · 28 min🔒 Paid2Python Logging Done Right: Loggers, Handlers, dictConfig, JSON Logs and Correlation IDsGo beyond print and basicConfig. Learn how the logging module really works (loggers, handlers, formatters, filters and propagation), configure it with dictConfig, emit structured JSON logs, attach request IDs with contextvars, log exceptions properly, keep logging fast with queues, and avoid the mistakes that cause silent or duplicated logs.Intermediate · 30 min🔒 Paid3Testing Python with pytest: Fixtures, Parametrization, Markers, Mocks and a Test Strategy That ScalesBuild a fast, trustworthy test suite. Learn pytest basics and assertions, fixtures and scopes, tmp_path, monkeypatch and capsys, parametrization, markers, testing exceptions, mocking with unittest.mock, coverage, test design (unit versus integration), speed, flaky tests and organising tests in a project and in CI.Intermediate · 30 min🔒 Paid4Python Mocking, Fixtures and Property-Based Testing: unittest.mock, pytest Fixtures, Fakes and HypothesisTest code that has dependencies. Learn when to mock, stub, fake or spy, unittest.mock and patch placement rules, autospec, side effects, pytest fixtures with scopes and factories, monkeypatch, tmp_path and capsys, test doubles for time, files, HTTP and databases, dependency injection for testability, property-based testing with Hypothesis (strategies, shrinking, stateful tests) and how to keep a fast, trustworthy suite.Intermediate · 30 min🔒 Paid5Python Linting, Formatting and CI: ruff, pre-commit, GitHub Actions and Quality GatesAutomate code quality. Learn what linters and formatters catch, configuring ruff for linting and formatting, choosing rule sets, pre-commit hooks, editor integration, type checking and security scanning, building a CI pipeline with caching and a Python version matrix, coverage and dependency audits, branch protection, and keeping checks fast and trusted.Intermediate · 26 min🔒 Paid
📦 Modules, Packaging and Dependencies3 topics

Imports, packages, pyproject.toml, publishing and reproducible dependency management.

🚀 Performance Engineering3 topics

Profiling, memory and garbage collection, and the practical ways to make Python fast.

🛠️ Building Real Applications5 topics

HTTP APIs with FastAPI, databases, data analysis with pandas, CLI tools and robust API clients.

1Build HTTP APIs with FastAPI: Routing, Pydantic Validation, Dependencies and TestingBuild a production-shaped REST API with FastAPI. Learn routes and parameters, request and response models with Pydantic, status codes and error handling, dependency injection, async versus sync endpoints, project structure, automatic OpenAPI docs, and testing with TestClient.Intermediate · 30 min🔒 Paid2Python Databases with SQLAlchemy 2.0: Engines, Sessions, ORM Models, Queries, Transactions and Alembic MigrationsWork with relational databases from Python using SQLAlchemy 2.0. Covers Core versus ORM, engines and connection pools, declarative models with Mapped and mapped_column, relationships and loading strategies, the select-based query API, sessions and the unit of work, transactions and isolation, avoiding N+1 queries, bulk operations, migrations with Alembic, testing with transactions, async usage and common production problems.Intermediate · 32 min🔒 Paid3Data Analysis with pandas: DataFrames, Cleaning, Grouping, Joins, Time Series and Performance for Real DatasetsAnalyse real data efficiently with pandas. Covers Series and DataFrame structure, loading data, selecting with loc and iloc and boolean masks, cleaning missing values and types, vectorised operations versus apply, groupby and aggregation, merges and concatenation, reshaping with pivot and melt, datetime and time-series work, categorical and memory optimisation, chunked processing, method chaining, correct handling of SettingWithCopy, testing data pipelines, and visualisation basics.Intermediate · 32 min🔒 Paid4Python CLI Tools and Automation: argparse, Typer, subprocess, Exit Codes, Config, Logging and Packaging ScriptsBuild command-line tools that other people can trust. Covers CLI design principles, argparse with subcommands, Typer and Click, input validation, reading stdin and files, exit codes and error output, structured and colourful output, running external commands safely with subprocess, configuration layering (defaults, files, environment, flags), logging and verbosity, dry runs, idempotent automation, scheduling, testing CLIs and distributing them as installable commands.Intermediate · 28 min🔒 Paid5Robust Python API Clients with httpx: Timeouts, Retries, Backoff, Pagination, Auth, Rate Limits and TestingBuild HTTP clients that behave well when networks and servers do not. Covers httpx clients and connection pooling, the four timeouts, error classification (retryable versus not), retries with exponential backoff and jitter, idempotency keys, honouring Retry-After and rate limits, pagination patterns, authentication including token refresh, streaming and large downloads, async clients with concurrency limits, structuring a reusable client class, circuit breakers, observability and testing with respx.Intermediate · 28 min🔒 Paid
🎯 Projects and Interview3 topics

Two end-to-end projects and Python interview scenarios.

1Python Project: Build a Streaming Log Analyzer with Tests, a CLI and PackagingPut the Python track into practice by building a log analysis tool end to end. Design the package layout, parse log lines with regular expressions and dataclasses, stream files with generators, aggregate results, add a command-line interface, write tests with pytest, add logging and error handling, and package it for installation.Intermediate · 40 min🔒 Paid2Project: Build a Polite Async Web Crawler with Rate Limiting, robots.txt, Graceful Shutdown and PersistenceBuild a concurrent crawler with asyncio and httpx. Covers requirements, architecture with a frontier queue and worker pool, URL normalisation and deduplication, robots.txt and per-host politeness, rate limiting and concurrency limits, retries and timeouts, HTML parsing and link extraction, persistence and resumability with SQLite, graceful shutdown on signals, metrics and logging, tests with a fake server, and ethical and legal considerations.Advanced · 50 min🔒 Paid3Python Interview Scenarios: Concept Questions, Coding Exercises, Debugging Cases and System Design with Model AnswersPrepare for Python interviews at backend, SRE and automation roles. Covers an answer framework, 35 concept questions with model answers (language, data model, functions, OOP, concurrency, performance, testing, packaging), ten coding exercises with solutions and complexity notes, five debugging cases, four design scenarios (rate limiter, log pipeline, job queue, plugin system), common traps, and a self-assessment checklist.Intermediate · 38 minFREE
Start here · no payment needed

Start free with Python

Learn how Python really works, set up a professional toolchain and write your first useful programs.

  1. 1How Python Really Runs: Interpreter, Bytecode and a Professional SetupSee what happens between typing a line of Python and getting a result. Learn how CPython compiles source to bytecode, why virtual environments exist, how to set up a modern toolchain with uv, ruff and pytest, and build your first useful script step by step. · 24 min
  2. 2Names, Objects and Mutability: The Python Object Model ExplainedUnderstand the single idea behind most Python surprises: names point to objects. Learn identity versus equality, mutable versus immutable types, aliasing bugs, shallow and deep copies, reference counting, and how numbers (int, float, Decimal) really behave, with practical debugging examples. · 26 min
  3. 3Python Control Flow and Structural Pattern Matching: if, for, while, match and Idiomatic LoopsWrite clear, idiomatic Python control flow. Master truthiness and conditional expressions, loops with enumerate, zip and for-else, the walrus operator, EAFP versus LBYL, and the match statement with literal, sequence, mapping, class and guarded patterns, with practical examples and the traps to avoid. · 26 min
  4. 4Python Interview Scenarios: Concept Questions, Coding Exercises, Debugging Cases and System Design with Model AnswersPrepare for Python interviews at backend, SRE and automation roles. Covers an answer framework, 35 concept questions with model answers (language, data model, functions, OOP, concurrency, performance, testing, packaging), ten coding exercises with solutions and complexity notes, five debugging cases, four design scenarios (rate limiter, log pipeline, job queue, plugin system), common traps, and a self-assessment checklist. · 38 min
Create a free account to track progress

Learn it. Practise it. Prove it.

Questions, answered

I am a complete beginner. Can I start?

Yes. The first lessons are free and start from zero, then the course goes deep.

Is this just syntax?

No. It explains why Python behaves as it does, so you can predict and debug behaviour.

Does it cover modern Python?

Yes: type hints, pattern matching, dataclasses, asyncio, uv and current tooling.

Also available