Learn to program in Python from zero: values, decisions, loops, functions, data structures, files, modules and a small data project.

Python Fundamentals

## Why it matters

Real data comes in collections: a week of temperatures, the students in a class, the rows of a file. A **list** holds many values in order under one name, so you can loop over them, pick out parts and sort them. A **tuple** is its fixed-size cousin, ideal for a group of values that belong together, such as a coordinate.

## Creating and indexing lists

```python
temps = [18, 21, 19, 25, 23, 17, 20]
names = ["Ada", "Grace", "Katherine"]
empty = []
mixed = ["sample-01", 23.4, True]   # allowed, but usually one type per list is clearer
```

Each item has a position, its **index**, starting at 0. Negative indexes count from the end:

```python
print(temps[0])     # 18   first item
print(temps[3])     # 25
print(temps[-1])    # 20   last item
print(temps[-2])    # 17
print(len(temps))   # 7
```

Asking for a position that does not exist, such as `temps[7]`, raises `IndexError: list index out of range`. The last valid index is always `len(temps) - 1`.

## Slicing

A **slice** `list[start:stop]` gives a new list from `start` up to, but not including, `stop`, the same rule as `range`:

```python
temps = [18, 21, 19, 25, 23, 17, 20]

print(temps[0:3])   # [18, 21, 19]   first three
print(temps[:3])    # [18, 21, 19]   start defaults to 0
print(temps[4:])    # [23, 17, 20]   stop defaults to the end
print(temps[-2:])   # [17, 20]       last two
print(temps[::2])   # [18, 19, 23, 20]  every second item (step 2)
print(temps[::-1])  # [20, 17, 23, 25, 19, 21, 18]  reversed
```

Slicing never raises an `IndexError`; out-of-range bounds are simply trimmed. Strings slice the same way: `"Python"[:3]` is `"Pyt"`.

## Changing a list

Lists are **mutable**: you can change them after they are created.

```python
queue = ["Ada", "Grace"]
queue.append("Katherine")       # add to the end
queue.insert(0, "Alan")         # insert at position 0
queue[1] = "Ada L."             # replace an item
removed = queue.pop()           # remove and return the last item
queue.remove("Grace")           # remove the first matching value
print(queue)                    # ['Alan', 'Ada L.']
print("Alan" in queue)          # True
```

Other useful tools: `max(temps)`, `min(temps)`, `sum(temps)`, `temps.count(19)` and `temps.index(25)` (position of the first 25).

## Sorting: sorted() versus .sort()

```python
temps = [18, 21, 19, 25]

ordered = sorted(temps)      # returns a NEW sorted list
print(ordered)               # [18, 19, 21, 25]
print(temps)                 # [18, 21, 19, 25]  unchanged

temps.sort(reverse=True)     # sorts IN PLACE, returns None
print(temps)                 # [25, 21, 19, 18]
```

A classic bug is `temps = temps.sort()`, which replaces your list with `None`. Use `sorted()` when you want to keep the original.

## Copying and aliasing

Assigning a list to another name does **not** copy it. Both names point to the same list:

```python
a = [1, 2, 3]
b = a
b.append(4)
print(a)        # [1, 2, 3, 4]  a changed too
c = a.copy()    # or a[:] or list(a): a real copy
```

## Tuples

A tuple looks like a list with parentheses, but it cannot be changed:

```python
location = (51.5072, -0.1276)    # latitude, longitude
print(location[0])               # 51.5072
location[0] = 0                  # TypeError: 'tuple' object does not support item assignment
```

Use a tuple when the number and meaning of the items is fixed: a coordinate, an RGB colour, a `(name, score)` pair. **Unpacking** assigns each item to its own name:

```python
lat, lon = location
print(f"{lat:.2f}, {lon:.2f}")   # 51.51, -0.13
```

Functions that return several values (`return low, high`) are returning a tuple.

## Lists of tuples: a small table

Lists and tuples combine into simple tables of records:

```python
results = [("Ada", 91), ("Grace", 78), ("Katherine", 85)]

for name, score in results:
    print(f"{name:10} {score}")

best = max(results, key=lambda pair: pair[1])
print("Top:", best[0])   # Top: Ada
```

`key=` tells `max` (and `sorted`) what to compare: here, the score in position 1. `lambda pair: pair[1]` is a tiny unnamed function. You will see this pattern often.

## Common mistakes

- **Off by one at the end.** The last index is `len(x) - 1`, or simply `x[-1]`.
- **`x = x.sort()`.** `.sort()` returns `None`. Use `x.sort()` alone or `x = sorted(x)`.
- **Accidental aliasing.** `b = a` shares the list; use `a.copy()` for an independent copy.
- **Forgetting the comma in a one-item tuple.** `(5)` is just the number 5; `(5,)` is a tuple.
- **Confusing `append` and `extend`.** `a.append([4, 5])` adds one item (a list); `a.extend([4, 5])` adds two.

## Quick recap

- Lists are ordered and mutable; index from 0, or from the end with negatives.
- Slices `[start:stop:step]` return new lists and exclude `stop`.
- `append`, `insert`, `pop`, `remove` change a list in place.
- `sorted()` returns a new list; `.sort()` changes the list and returns `None`.
- Tuples are fixed groups of values; unpack them with `a, b = pair`.

## Try it

In the Do tab you will slice a week of temperatures, sort a copy without changing the original, and unpack a coordinate tuple.


Store ordered data in lists, index and slice it, sort it, and use tuples for fixed groups of values.

Lists and tuples

Lists | Intro to CS - Python | Khan Academy

Python Tutorial: Slicing Lists and Strings

## Why it matters

Lists are great when position matters. Often, though, you want to find something by a **name**: the price of an item, the email for a user ID, the number of times each word appears. A **dictionary** (`dict`) stores key-value pairs and finds any value by its key almost instantly, however large it gets. A **set** stores unique values, which makes removing duplicates and comparing groups easy.

## Creating and using a dictionary

```python
prices = {"apple": 0.5, "bread": 2.25, "milk": 1.1}

print(prices["bread"])      # 2.25
prices["eggs"] = 3.0        # add a new key
prices["milk"] = 1.2        # update an existing key
del prices["apple"]         # remove a key
print(len(prices))          # 3
print("milk" in prices)     # True   (checks keys, not values)
```

Keys are usually strings or numbers, and each key appears only once. Values can be anything, including lists or other dictionaries.

## Missing keys: KeyError and .get()

Looking up a key that does not exist raises an error:

```python
print(prices["cheese"])          # KeyError: 'cheese'
```

`.get()` returns a default instead:

```python
print(prices.get("cheese"))      # None
print(prices.get("cheese", 0))   # 0
```

Use `[]` when a missing key would be a bug you want to hear about, and `.get()` when missing is normal.

## Looping over a dictionary

```python
stock = {"bolts": 120, "nuts": 80, "washers": 0}

for name in stock:                 # loops over keys
    print(name)

for name, qty in stock.items():    # keys and values together
    if qty == 0:
        print(f"Reorder {name}")

print(list(stock.values()))        # [120, 80, 0]
print(sum(stock.values()))         # 200
```

Dictionaries remember the order in which keys were inserted.

## Counting with a dictionary

Counting things is one of the most common jobs in data work. The pattern:

```python
words = "the cat and the hat and the bat".split()

counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1

print(counts)
# {'the': 3, 'cat': 1, 'and': 2, 'hat': 1, 'bat': 1}
```

`counts.get(word, 0)` is the current count, or 0 the first time a word is seen. The standard library also has `collections.Counter`, which does this in one line and adds handy methods:

```python
from collections import Counter
counts = Counter(words)
print(counts.most_common(2))   # [('the', 3), ('and', 2)]
```

Learn the manual pattern first; it adapts to anything, such as summing amounts per category instead of counting.

## Grouping with a dictionary of lists

```python
readings = [("tank-a", 20.5), ("tank-b", 18.0), ("tank-a", 21.5)]

by_tank = {}
for tank, value in readings:
    if tank not in by_tank:
        by_tank[tank] = []
    by_tank[tank].append(value)

print(by_tank)   # {'tank-a': [20.5, 21.5], 'tank-b': [18.0]}
```

## Sets: unique values

A set holds each value at most once, in no particular order:

```python
tags = ["python", "data", "python", "beginner", "data"]
unique = set(tags)
print(unique)              # {'data', 'beginner', 'python'} (order may vary)
print(len(unique))         # 3
print(sorted(unique))      # ['beginner', 'data', 'python']

seen = set()
seen.add("sample-01")
print("sample-01" in seen) # True, and very fast even for millions of items
```

Sets support maths-style operations:

```python
course_a = {"ada", "grace", "alan"}
course_b = {"grace", "katherine"}

print(course_a & course_b)   # {'grace'}                  in both (intersection)
print(course_a | course_b)   # all four names              in either (union)
print(course_a - course_b)   # {'ada', 'alan'}            in a but not b
```

Note that `{}` creates an empty **dictionary**. An empty set is `set()`.

## Choosing a structure

| You need to... | Use |
|---|---|
| keep items in order, allow duplicates | list |
| hold a fixed group of values | tuple |
| look things up by a key | dict |
| keep unique values or test membership quickly | set |

## Common mistakes

- **KeyError on a first count.** `counts[word] += 1` fails the first time. Use `counts.get(word, 0) + 1`.
- **Checking values with `in`.** `"1.2" in prices` checks keys. Use `in prices.values()` for values.
- **Using a list as a key.** Keys must be unchangeable (strings, numbers, tuples). A list raises `TypeError: unhashable type`.
- **Expecting order from a set.** Use `sorted(my_set)` when order matters.
- **`{}` for an empty set.** That is an empty dict.

## Quick recap

- A dict maps keys to values: `d[key]`, `d[key] = value`, `del d[key]`.
- `.get(key, default)` avoids `KeyError` when missing is normal.
- Loop with `.items()` to get keys and values together.
- Count with `counts[k] = counts.get(k, 0) + 1` or `collections.Counter`.
- Sets hold unique values and support `&`, `|` and `-`.

## Try it

In the Do tab you will count words in a sentence, look up prices with a default, and find the unique tags in a list.


Look up and count values by key with dictionaries, and remove duplicates with sets.

Dictionaries and sets

Dictionaries | Intro to CS - Python | Khan Academy

Python Tutorial for Beginners 5: Dictionaries - Working with Key-Value Pairs

## Why it matters

A huge share of everyday code follows one shape: start with an empty collection, loop over some data, maybe skip some items, and add a transformed value for each one. Python has a compact, readable syntax for exactly this, called a **comprehension**. You will see comprehensions everywhere in real Python code, especially in data work, so you need to be able to read and write them.

## From loop to list comprehension

Here is the familiar loop version, squaring the numbers 1 to 5:

```python
squares = []
for n in range(1, 6):
    squares.append(n * n)
print(squares)    # [1, 4, 9, 16, 25]
```

The same thing as a list comprehension:

```python
squares = [n * n for n in range(1, 6)]
```

Read it left to right as "a list of `n * n`, for each `n` in `range(1, 6)`". The pieces map directly onto the loop: the expression that was inside `append(...)` comes first, then the `for` clause.

More examples:

```python
names = ["ada", "grace", "katherine"]
capitalised = [name.title() for name in names]    # ['Ada', 'Grace', 'Katherine']
lengths = [len(name) for name in names]           # [3, 5, 9]

celsius = [0, 21.5, 100]
fahrenheit = [c * 9 / 5 + 32 for c in celsius]    # [32.0, 70.7, 212.0]

texts = ["12.5", "13.0", "11.75"]
values = [float(t) for t in texts]                # [12.5, 13.0, 11.75]
```

That last one replaces a four-line loop you may have written in the debugging lesson.

## Filtering with if

Add an `if` at the end to keep only some items:

```python
readings = [21.5, -999, 22.0, 23.25, -999, 22.75]

valid = [r for r in readings if r != -999]
print(valid)              # [21.5, 22.0, 23.25, 22.75]

evens = [n for n in range(10) if n % 2 == 0]
print(evens)              # [0, 2, 4, 6, 8]
```

The loop equivalent puts the `if` inside the `for`:

```python
valid = []
for r in readings:
    if r != -999:
        valid.append(r)
```

If you want to **transform** values conditionally rather than filter them, put an `if ... else` expression at the front instead:

```python
labels = ["high" if r > 22 else "normal" for r in valid]
# ['normal', 'normal', 'high', 'high']
```

Rule of thumb: `if` at the end filters (fewer items out); `if ... else` at the front chooses a value (same number of items out).

## Dictionary comprehensions

Use braces and a `key: value` pair:

```python
names = ["ada", "grace", "katherine"]
name_lengths = {name: len(name) for name in names}
# {'ada': 3, 'grace': 5, 'katherine': 9}

scores = {"Ada": 91, "Grace": 48, "Katherine": 85, "Alan": 55}
passed = {name: s for name, s in scores.items() if s >= 50}
# {'Ada': 91, 'Katherine': 85, 'Alan': 55}

prices_usd = {"bolt": 0.10, "nut": 0.05}
prices_cents = {item: round(p * 100) for item, p in prices_usd.items()}
# {'bolt': 10, 'nut': 5}
```

## Set comprehensions

Braces without a colon build a set, which removes duplicates:

```python
emails = ["ada@lab.org", "grace@navy.mil", "alan@lab.org"]
domains = {e.split("@")[1] for e in emails}
# {'lab.org', 'navy.mil'}
```

## Nested loops in a comprehension

You can have more than one `for`, in the same order as nested loops:

```python
grid = [(row, col) for row in range(2) for col in range(3)]
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]

matrix = [[1, 2], [3, 4], [5, 6]]
flat = [x for row in matrix for x in row]    # [1, 2, 3, 4, 5, 6]
```

These get hard to read quickly. If a comprehension needs two `for` clauses and an `if`, a regular loop is often kinder to the next reader.

## Generator expressions

Swap the square brackets for parentheses inside a function call and you get a **generator expression**, which produces values one at a time without building a list in memory:

```python
total = sum(r for r in readings if r != -999)
count_high = sum(1 for r in readings if r > 22)
```

This is the usual way to sum or count over a filter.

## When not to use a comprehension

- When the loop body does more than build one value (printing, updating several variables, handling errors).
- When the line gets long enough that you have to scroll or squint.
- When you do not need the resulting list at all. Do not write `[print(x) for x in items]`; a plain `for` loop is clearer.

## Common mistakes

- **Putting a filtering `if` at the front.** `[x if x > 0 for x in xs]` is a `SyntaxError`. Filters go at the end: `[x for x in xs if x > 0]`.
- **Forgetting the `else` in a front `if`.** `[a if cond else b for ...]` needs both parts.
- **Reusing a name.** `[x for x in x]` works but is confusing; use a different loop variable.
- **Writing a set by accident.** `{n for n in nums}` is a set, not a dict; a dict needs `key: value`.

## Quick recap

- `[expr for item in iterable]` builds a list; add `if cond` at the end to filter.
- `{key: value for item in iterable}` builds a dict; `{expr for ...}` builds a set.
- `expr_a if cond else expr_b` at the front chooses a value for every item.
- `sum(... for ...)` sums or counts without building a list.
- Prefer a normal loop when a comprehension stops being easy to read.

## Try it

In the Do tab you will rewrite three small loops as comprehensions: squares, a filter of passing scores, and a dictionary of word lengths.


Build lists, dictionaries and sets in one readable line, with optional filtering.

Comprehensions

Python Tutorial: Comprehensions - How they work and why you should be using them

Store ordered data in lists and tuples, look values up by key with dictionaries and sets, and build new collections with comprehensions.