Python Essentials

Learn how to store and name data in Python.

Integers, floats, and all the math you need.

Working with text data in Python.

True, False, and the concept of nothing in Python.

Make your programs interactive with input() — and learn the friendliest way to build messages: f-strings.

Converting between int, float, string, and bool.

Comparing values to produce True or False.

Combining conditions with and, or, and not.

Making decisions in your code with conditional statements.

Put decisions inside decisions — and learn which values Python treats as True.

Your first complete program — combine input, conversion, and if/elif/else into something real.

Make Python repeat work for you — one item at a time.

Repeat something N times, count from A to B, or count down — range() generates the numbers.

Repeat as long as a condition holds — when you don't know how many times.

Exit a loop early, skip one round, or hold a spot — precision control for any loop.

The handful of loop recipes — accumulate, count, find the best — that solve most loop problems ever written.

A loop inside a loop — rows and columns, grids and combinations.

One variable, many values — Python's workhorse container.

append, insert, remove, pop — lists are built to change.

Take sub-lists, put things in order — and dodge the bug where two names share one list.

The unchangeable list — for data that belongs together and should stay put.

Look values up by name, not position — key → value pairs.

Add, update, delete, loop — and the counting pattern used everywhere.

No duplicates, instant membership checks — the specialist collection.

The build-a-list loop, folded into one elegant line.

List, tuple, dict, or set? A decision guide — plus the module's ideas working together.

Name a block of code once, run it anywhere — your biggest leap yet.

print shows a value to humans — return hands it back to the program.

Optional parameters, named arguments — flexible function signatures.

Where a variable lives, who can see it, and when it disappears.

Functions that accept any number of arguments — like print() does.

One-expression functions without a name — and the sorted(key=...) superpower.

Docstrings, one-job functions, and a refactoring workout — the habits of readable code.

Master the [start:stop:step] triple — reversal, every-other, and the patterns pros reach for.

The built-in toolbox: clean, search, test, split, and join text.

Beyond {name}: decimals, percentages, padding, and alignment — output that looks professional.

Slices, methods, f-strings, and functions — one real text-processing build.

Tracebacks are roadmaps, not accusations — learn to read them bottom-up.

Catch errors instead of crashing — the seatbelt of every real program.

The full exception toolkit: success-only code, always-run cleanup, and raising your own errors.

Combine every error tool into a program that survives anything a user types.

Design your own data types — blueprints and the things built from them.

Functions that live on objects and work with their data through self.

Child classes that reuse, extend, and override a parent — families of types.

__str__, __eq__, __len__ — plug your classes into Python's built-in machinery.

Design a complete class — attributes, guarded methods, dunders, and a subclass.

Unlock Python's batteries-included standard library with import.

datetime, collections.Counter, pathlib — the modules working Pythonistas reach for weekly.

Split a growing program into files — and understand the __name__ == '__main__' idiom.

Install the world's Python (PyPI) — and keep each project's dependencies in its own sandbox.

Make data outlive the program — open, read, write, and the with statement.

Save whole dictionaries and lists — the data format the internet runs on.

A complete persistent app — menu loop, dictionaries, JSON storage, and every module before this one.

Peek under the for loop's hood — iter(), next(), and StopIteration.

Functions that pause — produce millions of values using almost no memory.

@wrap a function with extra behavior — timing, logging, auth — without touching its code.

Label parameters and returns — self-documenting code that editors can check for you.

How with really works, writing your own — and the road from here.