Python
Zero to production Python — 46 modules, no prerequisites
46 Modules. Foundations to Advanced.
Follow in order. Each module builds on the last. Every concept is introduced exactly when you need it, not before.
What is Python? Setup & Your First Program
Why Python is the most in-demand language in the US job market, how it actually runs, and getting a real environment set up — no confusion, no skipped steps.
Variables, Data Types & Type Conversion
Every value in Python is an object. Variables, the core data types, mutability, object identity, dynamic typing, and how to convert safely between them without silent bugs.
Operators — Arithmetic, Comparison, Logical
Every operator Python has — including bitwise and membership operators — what each actually does under the hood, and the precedence rules that cause real bugs when ignored.
Strings — Creation, Indexing, Slicing, Methods
Strings are the data type you will touch the most. Indexing, slicing, the methods that matter, Unicode and encoding, and f-strings done right.
Control Flow — if / elif / else
How Python actually evaluates truthiness, every form of conditional logic, structural pattern matching, and the readability patterns senior engineers actually use.
Loops — for / while, break / continue
for vs while, iterating over every kind of collection, and the loop control keywords that trip up beginners.
Functions — Defining, Parameters, Return Values
Functions are how you stop repeating yourself. Parameters, defaults, return values, and scope, explained from first principles.
Lists — Creation, Indexing, Methods
The workhorse data structure of Python. Every list method, when to use each, and how lists actually behave in memory.
Tuples and Sets
Immutable sequences and unordered unique collections — what they are for and why choosing the right structure matters.
Input/Output & f-string Formatting
Reading user input, printing output the right way, and every f-string formatting trick you will actually use.
Dictionaries
Key-value storage, the most-used data structure in real Python code — methods, iteration patterns, and performance characteristics.
List, Dict and Set Comprehensions
The Pythonic way to build collections — when comprehensions make code clearer, and when they make it worse.
Nested Data Structures
Lists of dicts, dicts of lists, and the real-world JSON-shaped data you will actually work with.
String Manipulation Deep Dive
Parsing, cleaning, and transforming text at a level beyond the basics — the patterns every data-facing script needs.
Reading & Writing Files
File handles, context managers, text vs binary mode, and the mistakes that cause data loss.
Working with CSV and JSON
The two formats every Python script touches. The csv and json modules, and the gotchas that break real pipelines.
Exception Handling
try/except/finally, catching the right exceptions, and writing your own — so your programs fail safely, not silently.
Modules, Packages & Virtual Environments
import, pip, requirements.txt, and virtual environments — how real Python projects are actually structured.
Classes and Objects — The Basics
The core idea of OOP in Python — classes as blueprints, objects as instances, from first principles.
Constructors, Instance vs Class Attributes
The difference between data that belongs to an instance and data shared across a whole class — and the bugs that come from confusing them.
Inheritance and Polymorphism
Building class hierarchies, overriding methods, and writing code that works across related types.
Encapsulation and Magic/Dunder Methods
Python's convention-based privacy, and the dunder methods that make your objects behave like built-in types.
Class Methods, Static Methods and Properties
@classmethod, @staticmethod, and @property — what each is actually for, with real examples of when to reach for each.
Abstract Base Classes and Interfaces
Enforcing a contract across subclasses with the abc module — how larger Python codebases stay consistent.
*args, **kwargs and Function Arguments Deep Dive
Every way Python lets you pass arguments — positional, keyword, variadic — and how to design flexible function signatures.
Lambda Functions and Functional Tools
Anonymous functions and the functional-programming toolkit — map, filter, reduce — and when they help vs hurt readability.
Iterators and Iterables — Building Your Own
What actually happens when you write a for loop, and how to build objects that support iteration.
Generators and yield
Lazy evaluation that saves memory at scale — how generators work internally and when to use them over lists.
Decorators — Writing and Using Them
Functions that wrap functions. How decorators actually work, and writing your own from scratch.
Context Managers and the with Statement
What with is actually doing, and building your own context managers for resource management.
Closures and Scope — The LEGB Rule
How Python resolves variable names, what a closure actually captures, and the scoping bugs that confuse everyone once.
Regular Expressions with re
Pattern matching for text — the syntax that looks intimidating but follows a small set of real rules.
Working with Dates and Times
datetime, timezones, and formatting — the module every real application needs and everyone gets wrong at least once.
Multithreading and Multiprocessing Basics
The GIL, when threads actually help, and when you need real parallelism with processes instead.
Async Python — asyncio, async/await
Asynchronous programming for I/O-bound work — coroutines, the event loop, and where async actually pays off.
Type Hints and Static Typing with mypy
Adding types to Python without losing what makes it Python — annotations, generics, and catching bugs before runtime.
Working with APIs in Python
The requests library, REST calls, authentication, and error handling for talking to real-world APIs.
Unit Testing with pytest
Writing tests that actually catch bugs — fixtures, assertions, mocking, and testing as a habit, not an afterthought.
Debugging Techniques and Tools
Systematic debugging beyond print statements — pdb, tracebacks, and reading errors like a senior engineer.
Logging Best Practices
Why print() is not logging — the logging module, levels, and structuring logs for production systems.
Packaging and Distributing Python Projects
Turning a script into a real installable package — project structure, pyproject.toml, and publishing to PyPI.
Python Performance — Profiling and Optimisation
Finding real bottlenecks before optimising anything — profiling tools and the optimisations that actually matter.
Intro to NumPy and pandas
The bridge from core Python into data work — arrays, DataFrames, and why these libraries exist at all.
Building a CLI Tool
A complete, real command-line tool built from scratch using argparse — start to finish, project-style.
Python Best Practices — PEP 8, Clean Code
The conventions that separate readable, maintainable Python from code that works but nobody wants to touch.
Python Interview Prep — Common Questions and Patterns
The Python questions that come up in real technical interviews, answered at senior-engineer depth.
More modules dropping soon.
Start with Module 01 today. Each module is self-contained enough to read on its own — but follow the order. Every concept earns the next one.
Discussion
0Have a better approach? Found something outdated? Share it — your knowledge helps everyone learning here.