Start from zero and become an expert. 60 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.
Run your first program, then variables, decisions, loops and functions. Everything else is built on these.
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.
Lists, dictionaries and text — the containers you will reach for in almost every program you write.
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.
Handling errors, reading and writing files, and using code other people wrote. This is where scripts become tools.
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.
Tables, charts and databases. Take this part if you are heading towards data analysis; it is not needed for the ones after it.
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.
Classes, then a look under the bonnet at what Python is actually doing. The step from writing code to understanding it.
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.
Sorting, searching, recursion, linked lists and trees. The classic computer-science material, and what technical interviews ask about.
Big O, all sorting algorithms, binary search, two pointers, sliding window.
The call stack, base and recursive cases, why naive recursion goes exponential, memoization and tabulation, and the 5-question DP framework.
Coin change, 0/1 knapsack, longest common subsequence and edit distance worked with the framework, space optimisation, plus two-pointer and sliding window.
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.
The array layout, heapq, the max-heap trick, a MinHeap from scratch, priority queues with tiebreakers, and the classic top-K problems.
Adjacency lists, BFS and DFS, Dijkstra's shortest path built on Part 1's heap, topological sort with cycle detection, and Union-Find.
Testing, building a web service, reading somebody else's codebase, and a capstone that ties it together.
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.