Python

Python from absolute zero to confident, idiomatic code. You start with what a program is and how the Python interpreter turns your source into bytecode and runs it, learn the object model early (names are labels bound to objects), and build up through text, control flow, functions, data structures, files and errors, modules, testing, object-oriented design, generators and decorators, type hints, and a look under the hood at dictionaries, memory and concurrency. The track ends with practical projects: a command-line tool and data processing with CSV and JSON. Every lesson explains what actually happens, shows runnable code, and checks your understanding with exercises run in a sandbox.

• Foundations
  What a program is, how the Python interpreter runs source code via bytecode, the REPL versus scripts, and your first programs that print and read input.
  1. What a program is · 25 min · 4 exercises
  2. How Python runs your code · 30 min · 4 exercises
  3. The REPL, scripts, print and comments · 30 min · 4 exercises
  4. Reading input: your first interactive program · 35 min · 4 exercises
• Values, types and names
  Everything is an object with a type; names are labels bound to objects. Integers, floats, booleans, None, and converting between types.
  1. Everything is an object: values and types · 30 min · 4 exercises
  2. Names bind to objects · 40 min · 5 exercises
  3. Integers and floats · 40 min · 4 exercises
  4. Booleans and None · 30 min · 5 exercises
  5. Converting between types · 35 min · 5 exercises
• Expressions and operators
  Arithmetic, precedence, integer division and modulo, comparisons, boolean logic with short-circuiting and truthiness, and assignment forms.
  1. Arithmetic operators and precedence · 35 min · 4 exercises
  2. Comparisons, boolean logic and truthiness · 40 min · 5 exercises
  3. Assignment forms · 35 min · 5 exercises
  4. Bitwise operators and number bases · 40 min · 5 exercises
• Strings and text
  Strings as immutable sequences: indexing and slicing, the essential methods, f-string formatting, and how Unicode text relates to bytes.
  1. Strings are sequences: indexing, slicing and immutability · 35 min · 5 exercises
  2. Essential string methods · 40 min · 5 exercises
  3. Formatting with f-strings · 40 min · 5 exercises
  4. Unicode, code points and bytes · 40 min · 5 exercises
• Control flow
  Making decisions with if/elif/else, repeating with while and for, break/continue/else on loops, and structural pattern matching with match.
  1. Making decisions: if, elif and else · 40 min · 5 exercises
  2. Repeating with while · 40 min · 5 exercises
  3. for loops and range · 40 min · 5 exercises
  4. break, continue and loop else · 35 min · 4 exercises
  5. Structural pattern matching with match · 40 min · 4 exercises
• Functions
  Defining and calling functions, return values, parameters and arguments of every kind, scope and the LEGB rule, docstrings, and recursion.
  1. Defining and calling functions · 35 min · 4 exercises
  2. Parameters and arguments · 45 min · 5 exercises
  3. Scope: local, global and the LEGB rule · 40 min · 5 exercises
  4. Docstrings and designing good functions · 40 min · 3 exercises
  5. Recursion · 45 min · 5 exercises
• Lists, tuples, dicts and sets
  Python's core containers, what each is good at and what it costs, and the crucial ideas of mutability, aliasing and copying.
  1. Lists · 45 min · 5 exercises
  2. Tuples and unpacking · 40 min · 5 exercises
  3. Dictionaries · 45 min · 5 exercises
  4. Sets · 40 min · 5 exercises
  5. Mutability, aliasing and copying · 45 min · 6 exercises
• Iteration
  How for really works, enumerate, zip, sorted and key functions, comprehensions, and the built-ins that consume iterables.
  1. How for really works: iterables and iterators · 35 min · 4 exercises
  2. enumerate, zip and reversed · 35 min · 4 exercises
  3. Sorting with sorted and key functions · 40 min · 5 exercises
  4. Comprehensions · 40 min · 5 exercises
  5. Built-ins that consume iterables · 40 min · 5 exercises
• Errors, exceptions and files
  Reading tracebacks, handling and raising exceptions, defining your own, working with files safely using with and pathlib, and talking to the outside world through stdin, stdout, stderr and exit codes.
  1. Reading tracebacks and the exception hierarchy · 35 min · 4 exercises
  2. Handling exceptions: try, except, else and finally · 40 min · 5 exercises
  3. Raising exceptions and defining your own · 40 min · 4 exercises
  4. Files: open, read, write and with · 45 min · 5 exercises
  5. Paths and the file system with pathlib · 40 min · 4 exercises
  6. stdin, stdout, stderr and exit codes · 45 min · 4 exercises
• Modules, packages and the standard library
  How import works, writing your own modules and packages, the __name__ == '__main__' idiom, and a guided tour of the most useful standard library modules.
  1. Modules and how import works · 40 min · 4 exercises
  2. Writing your own modules and the __main__ idiom · 40 min · 4 exercises
  3. Packages · 40 min · 4 exercises
  4. Standard library tour I: collections, itertools and functools · 50 min · 5 exercises
  5. Standard library tour II: math, random, datetime and os · 50 min · 5 exercises
• Testing and debugging
  Thinking in tests, assert, the unittest framework, and finding bugs systematically with tracebacks, print, logging and pdb.
  1. Thinking in tests and assert · 45 min · 4 exercises
  2. Testing with unittest · 50 min · 4 exercises
  3. Debugging: tracebacks, print and logging · 50 min · 4 exercises
  4. Debugging with pdb and breakpoint() · 45 min · 4 exercises
• Object-oriented Python
  Classes and instances, methods and attributes, special (dunder) methods, inheritance versus composition, properties, and dataclasses.
  1. Classes and instances · 40 min · 4 exercises
  2. Special (dunder) methods · 45 min · 4 exercises
  3. Class attributes, properties and encapsulation · 45 min · 4 exercises
  4. Inheritance, super() and composition · 50 min · 4 exercises
  5. Dataclasses and enums · 45 min · 4 exercises
• Iterators, generators, closures and decorators
  The iterator protocol, generator functions and expressions, closures, decorators, context managers, and type hints for documenting and checking your code.
  1. The iterator protocol · 40 min · 4 exercises
  2. Generators · 45 min · 4 exercises
  3. Functions as objects, lambdas and closures · 45 min · 4 exercises
  4. Decorators · 50 min · 4 exercises
  5. Context managers · 45 min · 4 exercises
  6. Type hints · 45 min · 4 exercises
• Under the hood: internals and concurrency
  How dicts and hashing work, memory management with reference counting and the garbage collector, the GIL, threads, processes, and asyncio.
  1. How dicts and sets work: hashing · 45 min · 4 exercises
  2. Memory: references, reference counting and the garbage collector · 45 min · 4 exercises
  3. Threads and the GIL · 50 min · 3 exercises
  4. Processes and concurrent.futures · 45 min · 4 exercises
  5. asyncio basics · 50 min · 4 exercises
• Practical projects
  Putting it together: a real command-line tool with argparse, processing CSV and JSON data, and a text-analysis program built and tested end to end.
  1. Building a command-line tool with argparse · 50 min · 4 exercises
  2. Processing CSV data · 50 min · 4 exercises
  3. Working with JSON · 45 min · 4 exercises
  4. Project: a log analyzer from start to finish · 75 min · 4 exercises
  5. Project: a to-do manager with subcommands and JSON storage · 75 min · 4 exercises