Course · 34 lessons

Python Developer Roadmap.

A Python course from variables and control flow to concurrency, decorators, testing, memory, performance and security, across all 34 Python lessons in order.

This curriculum covers all of Python: the core language, the standard library patterns you’ll actually reach for, and the production concerns — memory, performance, security, concurrency — that separate scripts from software.

Suggested learning order

Getting started — what Python is, then installing it, virtual environments and running your first script.
Core language — variables, data types, operators, strings, control flow and functions.
Data and the standard library — lists, dicts, sets and tuples, the collections module, and how imports, packages and modules actually work.
Object-oriented Python — classes, encapsulation, polymorphism, abstraction, multiple inheritance and the MRO, composition vs. inheritance, and dataclasses.
Robust programs — handling errors and custom exceptions, file I/O with pathlib and JSON, then shipping a first CLI tool that pulls the basics together.
Functions and iteration in depth — decorators and closures, generators, and context managers (which build on both).
Concurrency — threads and processes, then asyncio straight after, while the comparison is fresh.
Quality and safety — testing with pytest (including async tests), then input validation and secrets handling.
Advanced — static typing with type hints, memory management and garbage collection, profiling and performance, classic design patterns, and metaclasses.
Interview prep — last, as a review of everything above.

The roadmap, step by step

python Step 1 of 34

Introduction to Python

Learn what Python is, its history, and real-world use cases — a practical Python tutorial for beginners starting from scratch.

python Step 2 of 34

Setting Up Python

Install Python, create and activate a virtual environment, install and freeze packages with pip, and run a first script, with real command output.

python Step 3 of 34

Python Variables and Type System

See how Python variables work by running them: names as references, mutable vs immutable objects, dynamic typing, PEP 8 names and LEGB scope.

python Step 4 of 34

Python Data Types

Master Python's built-in data types — int, float, str, bool, None — and how to inspect and convert between them with real type conversion.

python Step 5 of 34

Python Operators

Run Python's arithmetic, comparison, identity, logical, membership, bitwise and walrus operators, plus operator overloading, and see each real result.

python Step 6 of 34

Python Strings

Slice, search, split, join and format Python strings with f-strings and format specs, plus escapes and raw strings, each example with real output.

python Step 7 of 34

Control Flow in Python

Run if/elif/else, match-case, for and while loops, for/else, break/continue and comprehensions in Python, each example shown with its real output.

python Step 8 of 34

Python Functions and Parameters

Define Python functions with positional, keyword, default, *args and **kwargs parameters, see the mutable-default trap, lambdas and return values run.

python Step 9 of 34

Python Data Structures

Use Python lists, tuples, dicts, sets and comprehensions through small runnable programs, plus a real timing of list vs set membership tests.

python Step 10 of 34

Python Collections

Work through list, dict, set and tuple, then deque, defaultdict, Counter and namedtuple from the collections module, each with its real printed output.

python Step 11 of 34

Python Modules and Packages

Build a real package step by step: import styles, the __name__ guard, __init__.py and __all__, relative imports, sys.path, venv and pyproject.toml.

python Step 12 of 34

Object-Oriented Programming in Python

Learn Python OOP — classes, objects, instances, inheritance, dunder methods, and encapsulation — with real-world examples.

python Step 13 of 34

Encapsulation and Name Mangling in Python

Learn how Python encapsulates state with the underscore convention and name mangling, and why neither one is real access control.

python Step 14 of 34

Polymorphism and Duck Typing in Python

See how Python's polymorphism works through duck typing, letting unrelated objects share behavior without a common base class or interface.

python Step 15 of 34

Abstraction with Abstract Base Classes in Python

Use Python's abc module to define abstract base classes that force subclasses to implement required methods before they can be instantiated.

python Step 16 of 34

Multiple Inheritance and MRO in Python

See how Python resolves the diamond problem with C3 linearization (MRO), and use mixins to combine behavior from unrelated classes safely.

python Step 17 of 34

Composition vs Inheritance in Python

Compare Python's has-a composition against is-a inheritance, and see how composition avoids the fragile base class problem.

python Step 18 of 34

Python Dataclasses

Use the @dataclass decorator to generate __init__, __repr__, and __eq__ automatically, plus frozen instances and post-init validation.

python Step 19 of 34

Error Handling in Python

Handle exceptions with try/except/else/finally, chain and re-raise them, define custom exceptions, use except* and logging, all with real tracebacks.

python Step 20 of 34

File I/O, pathlib, and JSON in Python

Read and write text files with open() and with, choose the right file mode, navigate paths with pathlib, and round-trip JSON and CSV, all with real output.

python Step 21 of 34

Building a Python CLI Tool

Build a weather command-line tool with argparse, split CLI and API code, package it with pyproject.toml, and test it offline with unittest.mock.

python Step 22 of 34

Python Decorators and Closures

Build closures, then decorators: functools.wraps, decorator factories, stacking order, stateful class decorators and lru_cache, each with real output.

python Step 23 of 34

Python Generators

Write generators with yield, see their lazy execution step by step, then build pipelines with yield from, send(), generator expressions and itertools.

python Step 24 of 34

Python Context Managers

See exactly when __enter__ and __exit__ run, then build context managers with classes, @contextmanager, suppress and ExitStack, with real output.

python Step 25 of 34

Python Concurrency

Run threads, processes and concurrent.futures side by side: see the GIL in real timings, a race condition and its Lock fix, queues and executors.

python Step 26 of 34

Async Python with asyncio

Learn asyncio by running it: coroutines, gather, create_task, TaskGroup, async with, timeouts and aiohttp against a local server, with real output shown.

python Step 27 of 34

Testing Python Code

Write and run pytest tests: assertions, exceptions, fixtures, parametrize, mocks, coverage, async tests and unittest, with real pytest output for each.

python Step 28 of 34

Python Security

Run real attacks against local Python code and fix them: SQL injection, shell injection, path traversal, weak tokens and password hashes.

python Step 29 of 34

Python Type Hints and Static Typing

Annotate Python code and run mypy on it: unions, narrowing, generics, Protocol, TypedDict and --strict, with the real errors each one catches.

python Step 30 of 34

Python Memory Management

Watch CPython free objects: reference counts, cycles and gc.collect, weakref caches, __slots__ savings and tracemalloc profiling, with measured output.

python Step 31 of 34

Python Performance

Measure before optimising: timeit, cProfile and line_profiler on real code, then lru_cache, set lookups, str.join, NumPy and __slots__, timed.

python Step 32 of 34

Python Design Patterns

Run singleton, factory, observer, strategy, decorator and command patterns in idiomatic Python, and see where functions and modules replace classes.

python Step 33 of 34

Python Metaclasses

Understand Python's type system, metaclasses, __new__ vs __init__, custom metaclasses, __init_subclass__, and class decorators with real executed output.

python Step 34 of 34

Python Interview Prep

30 Python interview questions with concise answers and runnable code: the GIL, mutable defaults, decorators, MRO, closures, copying and more.