Reusable steps, and Python's built-in containers

You define one with def, a name, and brackets listing what it needs: def add(a, b): followed by an indented block. The names in brackets are called parameters — they refer to whatever gets passed in when the function runs.

The word return sends a value back to whoever called the function, and immediately stops the function. Anything written after a return never runs.

Here is the confusion that trips up nearly everyone, and it is worth reading twice. print shows a value to a human looking at the screen. return hands a value back to the rest of your program. A function that prints instead of returning looks like it works, because you see the right answer appear — but the value has gone nowhere, and total = add(2, 3) leaves total holding nothing at all. If you feel stupid when you hit this, you should not: everybody hits it.

Functions are how you stop repeating yourself, but more importantly they are how you make a problem smaller. A problem you cannot solve in one go often becomes obvious once you split it into three functions that each do one thing.

This is a feature, not a limitation. It means two different functions can both use the name count without interfering with each other. Each function gets its own private space.

A function can read variables defined outside it, but if it assigns to a name, that name becomes local to the function. This asymmetry surprises people once and then makes sense.

The practical rule while you are learning: pass what a function needs in through its parameters, and hand results back with return. Reaching outside a function for values produces code that is very hard to reason about later.

You write one as names = ["ana", "bo", "cy"]. You reach into it with square brackets and a position: names[0] is "ana". Counting starts at zero, so the last of three items sits at position 2. names[-1] is a shortcut for the last one.

Slicing takes a range: names[0:2] gives you the first two. The end number is not included, which matches how range() behaves — Python is consistent about this once you notice the pattern.

append adds to the end. Lists can hold anything, including other lists, which is how you make a grid: a list of rows, where each row is itself a list.

Underneath, a Python list is a dynamic array: a block of memory with the items laid out one after another. That layout is why reaching any position is instant, and it is also why inserting at the front is slow — everything after it has to shuffle along. You will build one of these from scratch in week 15, and this is the fact that will make sense of it.

You write one as ages = {"ana": 30, "bo": 25}. The labels are called keys and the things stored are called values. You fetch with ages["ana"].

The remarkable property is that looking something up takes the same time whether the dictionary holds ten items or ten million. It does not search. It calculates where the item must be from the key itself and goes straight there. That calculation is called hashing, and building it yourself is one of the main events of week 17.

Keys must be things that cannot change — text and numbers are fine, lists are not. This is one of the reasons tuples exist.

In practice, dictionaries are probably the structure you will reach for most often in your working life. Counting how many times each word appears, grouping records by category, remembering answers you have already worked out — all dictionaries.

Tuples are written with round brackets: point = (3, 4). Because they cannot change, they can be used as dictionary keys where lists cannot. They are also a clear signal to whoever reads your code that this group of values belongs together and is not meant to be edited.

Sets are written with curly brackets: seen = {1, 2, 3}. Adding something already there does nothing. Checking whether something is in a set is instant, in the same way as a dictionary lookup — a set is essentially a dictionary with keys and no values.

The practical use of a set is removing duplicates and testing membership. Removing duplicates from a list of a million items with a loop takes ages; doing it with a set is one line and near-instant. That gap between the obvious approach and the right structure is, in miniature, what this entire roadmap is about.

Instead of creating an empty list and appending in a loop, you write doubled = [x * 2 for x in numbers]. Read it left to right as: make a list, of x times two, for each x in numbers.

You can filter at the same time: evens = [x for x in numbers if x % 2 == 0].

This is genuinely idiomatic Python rather than showing off, and you will see it constantly in other people's code, so it is worth being comfortable reading. But do not force it — if a comprehension gets long enough that you have to squint at it, an ordinary loop is the better choice.