Curriculum

All Courses

Work through them in order or jump straight to what you need. Every lesson runs in your browser.

🐍

Python Basics

Beginner

Start from scratch. Variables, types, input, output. Run code right in your browser.

Hello, World!

Write and run your very first Python program.

Variables & Types

Store values with names. Numbers, strings, booleans.

Arithmetic

Math operators: +, -, *, /, //, %, **

Working with Strings

Slice, format, and transform text.

🔀

Control Flow

Beginner

If statements, loops, and the logic that makes programs think.

if / elif / else

Make decisions in your code.

for loops

Repeat actions over sequences.

while loops

Loop until a condition becomes false.

📦

Data Structures

Intermediate

Lists, tuples, dicts, sets — the containers that hold your data.

Lists

Ordered, mutable collections.

Dictionaries

Key-value pairs for fast lookup.

List Comprehensions

Build lists with one expressive line.

⚙️

Functions & Modules

Intermediate

Package logic into reusable pieces. Import the standard library.

Defining Functions

Reusable blocks of code with inputs and outputs.

Default & Keyword Arguments

Make functions flexible.

🧱

Object-Oriented Python

Advanced

Classes, objects, inheritance, dunder methods, and properties.

Classes & Objects

Define your own types with state and behavior.

Inheritance

Build new classes by extending existing ones.

Dunder Methods

__str__, __eq__, __len__ — make your objects feel native.

⚠️

Errors & Files

Advanced

Handle exceptions gracefully and work with files.

try / except

Catch errors instead of crashing.

Raising Exceptions

Throw your own errors with clear messages.

Reading & Writing Files

Use 'with open' for safe file I/O.

✨

Iterators, Generators & Decorators

Advanced

Python's most powerful expressive tools.

Iterators

How for loops actually work under the hood.

Generators

Lazy sequences with the yield keyword.

Decorators

Wrap functions to add behavior.

Lambdas & Higher-Order Functions

map, filter, sorted with key=…

🚀

Modern Python

Advanced

Type hints, dataclasses, pattern matching, and async.

Type Hints

Annotate function signatures for clarity and tooling.

Dataclasses

Boilerplate-free classes for holding data.

Pattern Matching (match/case)

Structural matching, new in Python 3.10.

async / await

Concurrent code without threads.

Custom Context Managers

The 'with' statement, your way.

Functional Python

Advanced

itertools, functools, partial application, and pure-function patterns.

itertools Essentials

count, cycle, chain, islice, groupby — composable iterator tools.

functools: reduce, cache, partial

Fold sequences, memoize results, pre-fill arguments.

Pure Functions & Immutability

Write code that's easy to test and reason about.

⚡

Concurrency & Parallelism

Advanced

Threads, processes, asyncio gather, and the GIL explained.

Threads for I/O

Use threading when you wait on the network or disk.

ThreadPoolExecutor

High-level thread pool from concurrent.futures.

ProcessPoolExecutor

Parallel CPU-bound work across cores.

Locks, RLock & Semaphore

Protect shared state from data races.

asyncio timeouts & cancellation

Bound how long a coroutine may run; clean up on cancel.

Async iterators & context managers

async for and async with for streaming I/O.

Concurrent asyncio

asyncio.gather runs coroutines side by side.

Producer / Consumer with Queue

Thread-safe coordination with queue.Queue.

🧪

Testing & Debugging

Advanced

unittest, assertions, doctest, and disciplined debugging.

Assertions

Sanity-check assumptions while developing.

unittest Basics

Group tests into a TestCase and run them.

doctest

Tests live inside your docstrings.

🔍

Regex & Text Processing

Advanced

Pattern matching, capture groups, and parsing structured text.

re.search & re.match

Find a pattern anywhere in a string.

Capture Groups

Extract pieces with parentheses and named groups.

findall & sub

Extract every match or rewrite the string.

🌐

Data Formats & Networking

Advanced

JSON, CSV, datetime, and talking to web APIs.

JSON Encoding & Decoding

json.dumps and json.loads bridge Python and the web.

CSV Files

Read and write tabular data with the csv module.

Dates & Times

datetime, timedelta, and ISO formatting.

HTTP with urllib

Fetch URLs from the standard library.

🧙

Metaprogramming

Advanced

Descriptors, metaclasses, and bending Python to your will.

Dynamic Attribute Access

getattr, setattr, hasattr at runtime.

Descriptors

Custom attribute behavior via __get__ and __set__.

Metaclasses

Classes that create classes.

🧰

Collections & Stdlib Toolbox

Advanced

Counter, defaultdict, deque, namedtuple, heapq, bisect, enum.

Sets & Set Algebra

Unique members, fast membership, union / intersection.

Tuples & Unpacking

Fixed-size records and star-unpacking.

namedtuple

Lightweight immutable records with attribute access.

Counter

Count anything with one line.

defaultdict

Auto-create missing keys with a default value.

deque

O(1) appends and pops at both ends.

heapq — priority queues

Min-heap on a plain list.

bisect — sorted insertion

Binary search and insert into a sorted list.

Enums

Named constants with type safety.

🔤

Advanced Typing

Advanced

Generics, TypedDict, Literal, Protocol — write code your IDE understands.

f-string Format Spec

Padding, precision, binary, hex — all inline.

Slicing Deep Dive

start:stop:step on any sequence.

enumerate & zip

Index-and-value, and parallel iteration.

Generics with TypeVar

Reusable container types.

TypedDict & Literal

Type-checked dicts and string enums.

pathlib

Object-oriented file paths.

🏛️

Advanced OOP

Advanced

Properties, classmethods, slots, MRO, abstract base classes, walrus.

@property — computed attributes

Getters and setters without boilerplate.

classmethod & staticmethod

Alternate constructors and utility helpers.

__slots__ — tighter memory

Fixed attributes, smaller objects, no __dict__.

Abstract Base Classes

Force subclasses to implement methods.

MRO & super()

How Python resolves multiple inheritance.

Walrus := operator

Assign inside an expression.

🪄

Functional Extras & Context Managers

Advanced

partial, contextmanager decorator, string translation, walrus.

functools.partial

Bake in arguments to build new functions.

@contextmanager

Build context managers from a generator.

str.translate (ROT13)

Fast character-by-character mapping.

⚙️

Stdlib Power Tools

Advanced

logging, argparse, pickle, hashlib, secrets, statistics.

logging

Levels, formats, and where output goes.

argparse

Parse command-line arguments with one import.

pickle

Serialize Python objects to bytes.

hashlib

Cryptographic hashes (SHA-256, MD5, ...).

secrets — secure tokens

Cryptographically strong random for tokens & passwords.

statistics

Mean, median, mode, stdev — built-in.

🧠

Systems Concepts (read-only)

Advanced

Topics the in-browser sandbox can't run: multiprocessing, subprocess, sockets.

multiprocessing — true parallelism

Bypass the GIL by spawning OS processes.

subprocess — shell out safely

Run external commands and capture output.

sockets — raw TCP / UDP

The low-level networking primitive under everything.

multiprocessing Queue & Pipe

Send data safely between processes.

shared_memory — zero-copy buffers

Skip pickling for huge arrays.

subprocess — streaming & pipes

Read output line by line; pipe commands together.

Tiny TCP echo server

Accept connections and echo back.

asyncio TCP server

Same echo server, scalable to thousands of connections.

🔬

Advanced Deep Dives

Advanced

Real-world advanced Python: LRU caches, retries, observers, descriptors, DI, toposort, safe eval, async queues.

Build an LRU Cache

OrderedDict + move_to_end is all you need.

Retry with Backoff

A production-grade retry decorator.

Observer Pattern (weakref)

Pub/sub without leaking subscribers.

Generator Pipelines

Stream data through stages, lazily.

Async Producer/Consumer

asyncio.Queue coordinates concurrent tasks.

Typed Attributes with Descriptors

Enforce a type on every assignment.

Dependency Injection Container

100 lines of magic in 8.

Topological Sort (Kahn)

Schedule tasks with dependencies.

Safe Expression Evaluator

Parse with ast — never use eval() on user input.