Learn Python

Start the interactive interpreter, run a script file, and know which Python you are using.

Names point at objects; every object has a type you can inspect with type().

int, float and the arithmetic operators, including floor division, modulo and powers.

Create, combine and format text with str methods and f-strings.

Make decisions with if/elif/else, comparison operators, and Python's truthiness rules.

Repeat work with for over any iterable, while for conditions, plus break, continue, range and enumerate.

The ordered, mutable sequence you'll use most: create, index, change, sort.

Assignment never copies: names share objects, and mutable objects change for everyone holding them.

Fixed-size immutable sequences for records, multiple return values and dictionary keys.

Map keys to values for fast lookup; iterate, update and safely read with get().

Unordered collections of unique items with fast membership and set algebra.

Extract, copy, reverse and replace ranges of lists and strings with start:stop:step.

Build lists, dicts and sets from iterables in one readable expression.

Destructure data by shape with match/case: literals, sequences, mappings, classes and guards.

Package logic with def, parameters, return values, default arguments and docstrings.

Split code into files and use the standard library with import and from ... import.

Variadic arguments, keyword-only and positional-only parameters, and unpacking at call sites.

Pass functions around, use lambda and key functions, and capture variables in closures.

How for loops really work, and writing lazy sequences with yield.

Wrap functions to add behaviour, preserve metadata with functools.wraps, and take decorator arguments.

yield from delegation, generator return values, send/close, and lazy pipelines with itertools.

Read a traceback, catch the exceptions you expect, and raise your own.

Open text files with with open(...), read them line by line, and write results back.

else/finally, custom exception hierarchies, chaining with raise ... from, and exception groups.

Guarantee setup and cleanup with the with statement, and write your own with contextlib.

Define your own types with class, __init__, methods, attributes and a useful __repr__.

Extend classes with subclasses, call parent logic with super(), and know when to compose instead.

Generate __init__, __repr__ and __eq__ for data-holding classes with @dataclass.

Make your objects work with ==, hashing, len(), iteration, operators and calls via dunder methods.

Computed and validated attributes with @property, and the descriptor protocol behind it.

Build, inspect and walk file paths portably with pathlib.Path.

Counter, defaultdict, deque and namedtuple, plus when to reach for them.

Isolate each project's dependencies in a venv and install packages with pip.

Annotate functions and variables, use built-in generics and unions, and check with a type checker.

Write automated tests with plain asserts, fixtures and parametrisation, and know unittest.

Type-parameter syntax, type aliases, structural Protocols, TypedDict, Literal, overloads and TypeIs.

Lay out a project, declare metadata and dependencies in pyproject.toml, build wheels and publish.

Run many I/O-bound tasks concurrently on one thread with coroutines, tasks and TaskGroup.

Choose threads for I/O-bound work and processes for CPU-bound work, via executor pools.

Exactly how obj.attr is resolved: __getattribute__, descriptors, instance dicts, __getattr__ and __slots__.

How CPython frees objects: reference counts, the cyclic garbage collector, weak references and immortal objects.

Why the GIL exists, what it does and doesn't protect, and the experimental free-threaded 3.13 build.

sys.modules, finders and loaders, sys.path, bytecode caches, circular imports and lazy module attributes.

How a class statement builds a class via type, and when __init_subclass__ or a metaclass is the right tool.

Read bytecode with dis, understand the specialising interpreter and JIT, and profile before optimising.