Step 1 • Setup
Python Setup and Virtual Environments beginner Install Python correctly — use pyenv (or mise) to manage multiple Python versions, understand why system Python is dangerous to modify, create virtual environments (venv, virtualenv) to isolate project dependencies, and use pip or uv to install packages. Know where Python looks for modules (sys.path) and how PYTHONPATH works.
3h Step 2 • Foundations
Syntax, Variables, and Control Flow beginner Learn Python's syntax — indentation as structure, variables and assignment, basic data types (int, float, str, bool, None), arithmetic and comparison operators, if/elif/else, while and for loops, range(), break/continue, and the ternary (inline if) expression. Understand Python's dynamic typing and why isinstance() beats type().
8h Step 3 • Foundations
Built-in Data Structures beginner Master Python's core data structures — lists (mutable ordered sequences, slicing, list comprehensions), tuples (immutable, unpacking, named tuples), dictionaries (hash maps, dict comprehensions, defaultdict, Counter), sets (unique collections, set operations), and strings (immutable, string methods, f-strings, format specifiers). Know time complexity of common operations.
8h Step 4 • Foundations
Functions, Arguments, and Scope beginner Define and call functions with positional and keyword arguments, default values, *args, **kwargs, keyword-only arguments (after *), and positional-only arguments (before /). Understand LEGB scope (Local, Enclosing, Global, Built-in), closures, the global and nonlocal keywords, and lambda functions (when they're appropriate).
7h Step 5 • Foundations
Object-Oriented Programming and Classes beginner Model with classes — __init__, instance attributes, methods, class methods (@classmethod), static methods (@staticmethod), properties (@property), inheritance and super(), method resolution order (MRO), dunder methods (__str__, __repr__, __eq__, __len__, __iter__, __getitem__), and abstract base classes. Understand composition vs inheritance.
10h Step 6 • Foundations
Dataclasses and Pydantic Models intermediate Use @dataclass for simple value objects (auto-generated __init__, __repr__, __eq__, field() for defaults), frozen dataclasses for immutability, and Pydantic BaseModel for validated data with type coercion, custom validators, serialization (model_dump(), model_json_schema()), and settings management (pydantic-settings for env variables).
6h Step 7 • Foundations
Exceptions, Files, and Context Managers beginner Handle failures explicitly — try/except/else/finally, exception hierarchies (when to catch broadly vs narrowly), raising custom exceptions (class AppError(Exception)), context managers with the with statement, writing your own context managers with __enter__/__exit__ and @contextmanager, pathlib for filesystem operations, and safe file I/O patterns.
7h Step 8 • Advanced Syntax
Iterators, Generators, and Comprehensions intermediate Use Python's iteration protocol — implement __iter__ and __next__ for custom iterables, generator functions (yield, yield from), generator expressions for lazy evaluation, list/dict/set comprehensions, itertools (chain, islice, groupby, product, combinations, permutations), and functools (reduce, partial, lru_cache). Understand when lazy iteration saves memory.
8h Step 9 • Advanced Syntax
Decorators and Metaprogramming intermediate Write and use decorators — function decorators (wrapper pattern, functools.wraps to preserve metadata), class decorators, decorators with arguments (decorator factories), stacked decorators, and common use cases (logging, timing, retry, access control, memoization). Understand how Python decorates at definition time, not call time.
6h Step 10 • Tooling
Type Hints, mypy, and Static Analysis intermediate Add type hints to Python code — basic annotations (int, str, list[str], dict[str, int]), Optional (same as X | None), Union, Any (avoid it), TypeVar, Generic classes, Protocol for structural subtyping, Literal types, TypedDict for dict shapes, and type aliases. Run mypy (or Pyright) in strict mode to catch real bugs at development time.
8h Step 11 • Tooling
Modules, Packages, and Imports intermediate Organize Python code at scale — __init__.py and its role in packages, relative vs absolute imports, __all__ for explicit public API, namespace packages, import resolution order, and avoiding circular imports. Use pyproject.toml (the modern standard — replaces setup.py) with hatchling/setuptools as build backend, and understand src layout vs flat layout.
6h Step 12 • Tooling
Ruff, Black, and pre-commit Hooks intermediate Keep Python codebases clean and consistent — Ruff (extremely fast linter + formatter, replaces flake8/isort/pyupgrade), Black for opinionated formatting (or use Ruff format), pre-commit hooks to enforce standards before commit, editorconfig for cross-editor consistency, and pyproject.toml for centralizing all tool configuration.
4h Step 13 • Quality
Testing with pytest intermediate Write reliable tests with pytest — test functions and classes, fixtures (@pytest.fixture, conftest.py, parametrize, scope), mocking with unittest.mock (Mock, patch, MagicMock), testing exceptions (pytest.raises), temporary files (tmp_path), code coverage (pytest-cov), and property-based testing with Hypothesis for edge case discovery.
8h Step 14 • Async
Async I/O, Threading, and Concurrency intermediate Handle concurrent workloads in Python — asyncio (async def, await, asyncio.gather, asyncio.create_task, async context managers, async generators), httpx for async HTTP clients, aiofiles for async file I/O, threading (for I/O-bound work that isn't async-native), multiprocessing (for CPU-bound work to bypass the GIL), and ProcessPoolExecutor/ThreadPoolExecutor with concurrent.futures.
10h Step 15 • Async
Standard Library Deep Dive intermediate Python's standard library covers most needs — learn json (loads/dumps, custom encoders/decoders), re (regex: compile, match, search, findall, groups, named groups), datetime (datetime, date, timedelta, timezone-aware datetimes), logging (loggers, handlers, formatters, structured logging), argparse (CLI argument parsing), os/sys for system interaction, and subprocess for running shell commands.
8h Step 16 • Networking
HTTP Clients and REST API Consumption intermediate Make HTTP requests from Python — requests (sync: sessions, auth, retries, timeouts), httpx (async support, HTTP/2, type annotations), tenacity for retry with backoff, and how to handle API authentication (API keys, Bearer tokens, OAuth2 client credentials). Understand connection pooling, timeout categories (connect vs read), and how to test HTTP calls with responses or respx.
5h Step 17 • Web
Web Frameworks — FastAPI and Django intermediate Build web services with Python — FastAPI (async, auto OpenAPI docs, Pydantic validation, dependency injection, great for APIs), Django (full-featured: ORM, admin, auth, templates — great for content apps), and Flask (micro-framework for simple services). Know when to choose each. For new APIs in 2026, FastAPI is the default; for content/admin-heavy apps, Django.
12h Step 18 • Web
Databases with SQLAlchemy intermediate Interact with databases in Python — SQLAlchemy Core (SQL expression language) and ORM (mapped classes, relationships, lazy vs eager loading, Session lifecycle), Alembic for schema migrations (autogenerate, upgrade/downgrade), and asyncpg/asyncio-compatible engines for async database access. Understand connection pools (QueuePool), avoiding N+1 queries, and how to test with an in-memory SQLite database.
10h Step 19 • Advanced
Performance, Profiling, and Optimization advanced Diagnose and fix Python performance issues — profile with cProfile and line_profiler to find hot spots, memory profiling with memory_profiler, understand the GIL and its implications for multi-threaded CPU work, numpy for vectorized numerical operations, caching with functools.lru_cache, and when to use Cython/Rust extensions for truly hot paths.
8h Step 20 • Ship It
Packaging and Publishing to PyPI advanced Publish reusable Python packages — configure pyproject.toml (project metadata, dependencies, optional extras, entry points for CLI scripts), choose a build backend (hatchling, setuptools, flit), build source distributions (sdist) and wheels (bdist_wheel), upload to PyPI with twine or trusted publishing via GitHub Actions, and manage versions with bump-my-version or hatch versioning.
6h 