Start from zero and become an expert. 55 lessons including 10 hands-on mini-projects (Mad Libs, FizzBuzz, Number Guess, Tip Calculator, Word Counter, Todo App, Bank Account, more). Variables, loops, functions, data structures, OOP, decorators, async, algorithms, FastAPI, and a capstone where you call your first LLM API.
A guided tour of every Python concept this track covers, in the order you'll learn them.
Install Python, write your first print() statement, and use the REPL to experiment with code interactively.
Create variables, master Python's core types, type conversion, and f-strings.
Ship your first interactive Python program in 20 minutes — collect input, weave a story with f-strings.
if/elif/else, for/while loops, break/continue, walrus operator, and match/case pattern matching.
Build a 1-100 guessing game with hot/cold feedback — your first program combining randomness, loops, and conditionals.
Solve software's most famous interview problem — 1 to 100 with Fizz, Buzz, and FizzBuzz.
Define functions, master LEGB scope, *args/**kwargs, default arguments, lambdas, and closures.
Build a tip + tax + split calculator with default parameters and tuple returns — your first reusable mini-library.
Python's core sequences — lists, tuples, sets, frozensets — with time complexity of every operation.
Write concise, fast list/dict/set transformations in one readable line.
Compute a class report (mean, min, max, pass rate, top scorers) using list comprehensions.
Python dicts: hash mechanics, collision resolution, all dict methods, and comprehensions.
Build a word-frequency counter — the foundation of every NLP pipeline.
All string methods, f-string format specs, Unicode/UTF-8, bytes vs str, and regex basics.
Build a strength meter that scores a password against five rules.
Read Python errors confidently, handle failures with try/except, and debug systematically.
Build a calculator that survives any bad input using try/except and validation loops.
Open files with `with`, handle errors gracefully, and work with pathlib, json, and csv.
Build a CLI todo app with file persistence — your first program that remembers state between runs.
Import modules, install packages, create virtual environments, and structure projects.
Keep API keys out of code using os.environ, .env files, and python-dotenv.
Master the requests library — GET/POST, JSON parsing, API auth, error handling.
Counter, defaultdict, OrderedDict, namedtuple, deque, plus heapq and bisect.
Regex patterns, groups, lookahead/lookbehind, and real-world text processing.
NumPy arrays, vectorization, broadcasting, and Pandas DataFrames.
Join DataFrames, apply functions, reshape with pivot_table, and build time series features.
Line plots, scatter plots, bar charts, histograms, and multi-panel figures.
The sklearn workflow: load, split, train, predict, evaluate. Pipelines and model comparison.
Connect to databases, write SQL, use SQLAlchemy ORM, integrate Pandas with SQL.
Type hints, mypy, pytest basics, unittest.mock, PEP 8, and good docstrings.
Create classes with __init__, methods, @property, __slots__, and inheritance basics.
Build a BankAccount class with deposit, withdraw, history, and transfers.
Multiple inheritance, MRO with C3 linearization, cooperative super(), the mixin pattern, and Abstract Base Classes.
@dataclass (frozen, order, slots, __post_init__), Enum / IntEnum / Flag, Protocol for structural subtyping, and __slots__ for memory optimization.
Implement __repr__, __eq__, __hash__, __len__, __getitem__, __iter__, __enter__/__exit__, __call__.
Decorators for timing/logging/caching, generators with yield, and context managers.
Everything is an object: references, id(), integer caching, mutable vs immutable.
AST, bytecode, refcounting, cyclic GC, the GIL, integer caching, and cProfile.
Threading, multiprocessing, asyncio, and concurrent.futures.
Big O, all sorting algorithms, binary search, two pointers, sliding window.
Recursion with memoization (@lru_cache) and tabulation. Fibonacci, coin change, LCS.
Node class, singly linked list operations (insert, delete, search, in-place reversal), and Floyd's two-pointer technique for cycle detection.
Doubly linked lists with prev/next pointers, merging two sorted lists, recursive reversal, and a complete LRU cache implementation.
LIFO and FIFO using lists and deque. MinStack, circular queue, monotonic stack.
Tree terminology, the TreeNode class, BST insert/search, and all four traversals (BFS, inorder, preorder, postorder) recursively and iteratively.
BST deletion (all three cases), validation with min/max bounds, self-balancing AVL/Red-Black trees, Tries for autocomplete, and expression-tree evaluation.
Min/max heaps, heapq, Dijkstra, topological sort, Union-Find.
Parametrize, fixtures, pytest.raises, and pytest-cov.
REST APIs with FastAPI, Pydantic validation, serving ML models, testing endpoints.
Read a complete 180-line FastAPI service line-by-line. Bridge from 'I know Python syntax' to 'I can read a codebase.'
Production-grade logging, config management, CLI tools (argparse/click/typer), packaging.
Three hands-on projects: calculator with history, persistent contact book, and a word frequency analyzer — the foundation of NLP preprocessing.
Two larger projects: a pandas-driven student-performance dashboard and an OOP-driven CLI quiz game with decorators, random shuffling, and a JSON-persisted leaderboard.
Build a text analyser that calls an LLM API, processes the response, and saves results.
22 interactive labs — hands-on exercises for this track
You're a factory robot repeating the same task on an assembly line — watch how loops automate repetitive work
You have a playlist of 50 songs — grab just tracks 10 through 20 with a single slice expression
You're organizing a library of 10,000 books — which sorting method is fastest?
Searching 1,000 users is fast — but what happens when you hit 1 million? See how algorithms scale
Type a key, watch the hash compute, see the bucket fill. Feel collisions and load factor in real time.
Visualize the call tree of naive Fibonacci. Duplicate subproblems glow red — toggle memoization and watch exponential collapse to linear.
Watch a Longest Common Subsequence DP table fill cell by cell with dependency arrows, then a green traceback reveals the hidden subsequence.
Click through a Python class inheritance tree and watch the MRO (C3 linearization) animate as methods resolve up the chain.
Step through a Python generator one yield at a time, see the frozen frame, and compare memory against its eager-list twin.
Watch a value flow through stacked Python decorators — peel in on the way down, wrap out on the way back — and see why decorator order matters.
Watch Python list operations animate — append, insert, delete, access — and see how Big-O emerges from your own clicks.
Race three HTTP requests sync vs async. Watch the event loop schedule, yield, and resume — three 1-second requests finish in 1 second, on a single thread.
Step through a `with` statement for file I/O, DB transactions, and locks. Watch __enter__ acquire, the body run, and __exit__ clean up — even when the body raises.
Step through nested try/except as an error bubbles up. Watch the call stack unwind, the new exception chain via __cause__, and Python's 'During handling...' traceback form.
Toggle type annotations and watch a mypy-like checker catch bugs before runtime — the kind you'd otherwise hit in production.
Compare hand-written class vs @dataclass. Toggle frozen/slots/default_factory to see generated boilerplate update live.
Compare ABC vs Protocol typing side-by-side. See why Protocol = duck typing + static verification.
Visualize chain, cycle, islice, takewhile, combinations, groupby — one lazy pull at a time.
Traverse a mock filesystem with pathlib — glob, parent, path joining, read_text, exists.
Parametrize tests, inject bugs, add fixtures, watch coverage light up.
Compare %-old / .format / f-strings side-by-side. Drive format specs to see padding, precision, thousands separators live.
Set root level, swap handlers, toggle JSON formatter, walk through pdb.set_trace() with live locals.
1375 questions across 55 modules — check how well you understood this track.