Backend & APIs

Node and API design

Create route handlers, validation, authorization, and jobs.

intermediate

Database and persistence

Design schemas, queries, migrations, and connection pooling.

intermediate

The Python Data Model

How special methods and the built-in types define Python's consistent object API, building a card-deck example and emulating numeric types, string representations, and collection behavior.

intermediate

An Array of Sequences

Built-in sequence types, list comprehensions and generator expressions, tuple unpacking, sequence pattern matching, slicing, and when a list is not the right answer (arrays, memory views, NumPy, deques).

intermediate

Dictionaries and Sets

Modern dict syntax and comprehensions, mapping pattern matching, the standard mapping API with missing-key handling, variants of dict, and set theory operations on sets and dict views.

intermediate

Unicode Text Versus Bytes

Bytes, encoders and decoders, encoding errors, handling text files, Unicode normalization for reliable comparisons and sorting, and the dual-mode str and bytes APIs.

intermediate

Data Class Builders

The standard library's class builders — classic and typed named tuples, type hints 101, and the @dataclass decorator with field options, post-init processing, and pattern matching on class instances.

intermediate

Object References, Mutability, and Recycling

Variables as references, identity versus equality, shallow and deep copies, mutable arguments and defensive copying, and how del triggers garbage collection.

advanced

Functions as First-Class Objects

Higher-order functions, modern replacements for map/filter/reduce, the nine flavors of callable objects, parameter kinds, the operator module, and functools.partial.

intermediate

Type Hints in Functions

Gradual typing with Mypy: supported operations, usable annotation types, Optional/Union, generic collections and mappings, ABCs, parameterized generics with TypeVar, and static protocols.

intermediate

Decorators and Closures

Decorator mechanics and execution timing, registration decorators, variable scope rules, closures with the nonlocal declaration, memoization with functools.cache/lru_cache, and single-dispatch generic functions.

advanced

Design Patterns with First-Class Functions

Refactors a Strategy pattern case study from classes to function-oriented strategies, adds decorator enhancement and module introspection, and implements the Command pattern with callables.

advanced

A Pythonic Object

Builds a Pythonic Vector class supporting representations, alternative constructors, classmethod versus staticmethod, formatted displays, hashing, positional pattern matching, and __slots__.

intermediate

Special Methods for Sequences

Evolves a user-defined sequence type across five versions covering duck typing, slice-aware __getitem__, dynamic attribute access, hashing and fast equality, and formatting.

intermediate

Interfaces, Protocols, and ABCs

Contrasts duck typing, monkey patching, and structural typing: programming ducks, subclassing and defining ABCs, virtual subclasses, static and runtime-checkable protocols, and the numbers ABCs.

advanced

Inheritance: For Better or for Worse

Covers super(), subclassing built-in types, multiple inheritance and method resolution order, real-world mixins (ThreadingMixIn, Django, Tkinter), and coping strategies that favor composition.

advanced

More About Type Hints

Deepens typing with @overload, TypedDict, type casting, reading hints at runtime and their problems, implementing generic classes with variance, and generic static protocols.

advanced

Operator Overloading

When operator overloading makes sense: unary operators, adding and multiplying, the @ infix operator, rich comparison operators, and augmented assignment.

intermediate

Iterators, Generators, and Classic Coroutines

The iteration protocol, iterables versus iterators, generator functions and expressions, itertools, lazy evaluation, subgenerators with yield from, and classic (generator-based) coroutines.

advanced

with, match, and else Blocks

Context managers and with blocks with contextlib utilities and @contextmanager, a pattern matching case study building a Scheme interpreter, and else blocks beyond if.

advanced

Concurrency Models in Python

Surveys processes, threads, coroutines and the GIL, building spinner and prime-checker experiments and reviewing what concurrency means for system administration, data science, and server-side web development.

advanced

Concurrent Executors

Uses concurrent.futures for concurrent web downloads and multicore work: Executor.map, process pools, progress display, error handling, and futures.as_completed.

advanced

Asynchronous Programming

Covers asyncio end to end: awaitables, native coroutines as humble generators, the all-or-nothing problem, async context managers, semaphores, executors, async servers with FastAPI, async iteration, and avoiding blocking or CPU-bound traps.

advanced

Dynamic Attributes and Properties

Wrangles semi-structured data with __getattr__ and computed @property values, including data-driven attribute creation, linked-record properties, caching, validation, property factories, and attribute deletion.

advanced

Attribute Descriptors

Builds attribute-validation descriptors step by step, covering overriding versus nonoverriding descriptors, overwriting descriptors in a class, and why methods are themselves descriptors.

advanced

Class Metaprogramming

Covers type as a class factory, __init_subclass__, class decorators, import time versus runtime, and metaclasses — including how modern features simplify or replace them and when to avoid them.

advanced