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

Computers are good at doing the same thing many times without getting bored or making mistakes. Adding up a thousand readings, checking every row of a file, retrying a calculation until it converges: all of these are **loops**. Python has two kinds. A `for` loop goes through a collection item by item. A `while` loop keeps going as long as a condition is true.

## for loops over a list

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

for value in readings:
    print("Reading:", value)
```

Read it as "for each `value` in `readings`, run the indented block". On each pass, called an **iteration**, the loop variable `value` holds the next item. The loop ends by itself after the last item.

You can loop over any collection, including the characters of a string:

```python
for letter in "DNA":
    print(letter)     # D, then N, then A
```

## The accumulator pattern

The most common loop builds up a result. Start with an empty or zero value **before** the loop, update it **inside**, and use it **after**:

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

total = 0
count = 0
for value in readings:
    total += value
    count += 1

print(f"Average: {total / count:.2f}")   # Average: 22.38
```

The same pattern finds a maximum, counts matches or collects values into a new list:

```python
high = []
for value in readings:
    if value > 22:
        high.append(value)     # append adds an item to the end of a list
print(high)                    # [23.25, 22.75]
```

(Python also has built-ins such as `sum`, `max` and `len` for the simple cases. Knowing the pattern lets you handle the cases they do not cover.)

## Counting with range

`range` produces a sequence of whole numbers, which is how you repeat something a fixed number of times:

```python
for i in range(5):
    print(i)            # 0 1 2 3 4   (stops BEFORE 5)

for year in range(2020, 2025):
    print(year)         # 2020 to 2024

for n in range(10, 0, -2):
    print(n)            # 10 8 6 4 2   (a step of -2)
```

`range(start, stop, step)` includes `start` and excludes `stop`. That "up to but not including" rule is everywhere in Python, and it is the source of many off-by-one bugs. To add the numbers from 1 to 100 you need `range(1, 101)`.

If you need both the position and the item, use `enumerate`:

```python
for position, name in enumerate(["Ada", "Grace", "Katherine"], start=1):
    print(position, name)    # 1 Ada / 2 Grace / 3 Katherine
```

## while loops

Use `while` when you do not know in advance how many iterations you need, only when to stop:

```python
balance = 1000.0
years = 0
while balance < 2000:
    balance *= 1.05      # 5% growth each year
    years += 1
print(f"Doubles after {years} years")   # Doubles after 15 years
```

Python checks the condition before every iteration. When it becomes false, the loop ends. **Something inside the loop must eventually make the condition false**, or the loop runs forever. If your program seems frozen, an infinite `while` loop is the usual suspect (the browser runner stops it after a few seconds; in a terminal, press Ctrl+C).

## break and continue

- `break` leaves the loop immediately.
- `continue` skips the rest of this iteration and moves to the next one.

```python
values = [4, 8, -1, 15, 16]

for v in values:
    if v < 0:
        print("Found a negative value, stopping")
        break
    print("Processing", v)

for v in values:
    if v < 0:
        continue          # skip bad data, keep going
    print("Valid:", v)
```

## Nested loops

A loop inside a loop runs the inner loop completely for each pass of the outer one. A multiplication table is the classic example:

```python
for row in range(1, 4):
    line = ""
    for col in range(1, 4):
        line += f"{row * col:4}"
    print(line)
```

Output:

```text
   1   2   3
   2   4   6
   3   6   9
```

## Common mistakes

- **Off by one with range.** `range(1, 10)` stops at 9. Ask yourself whether the last value should be included.
- **Resetting the accumulator inside the loop.** If `total = 0` sits inside the loop, it is wiped on every pass. Put it before the loop.
- **Forgetting to update the while condition.** No `years += 1` or `balance *= ...` means an infinite loop.
- **Changing a list while looping over it.** Removing items from the list you are looping over skips elements. Build a new list instead.
- **Wrong indentation.** A line indented under the loop runs every time; a line at the outer level runs once, after the loop. Moving a `print` one level in or out changes the output completely.

## Quick recap

- `for item in collection:` visits each item once.
- Accumulator pattern: set up before, update inside, use after.
- `range(start, stop, step)` counts and excludes `stop`.
- `while condition:` repeats until the condition is false; make sure it can become false.
- `break` exits a loop; `continue` skips to the next iteration.

## Try it

In the Do tab you will write a `for` loop that sums a range of numbers, another that counts values above a threshold, and a `while` loop that finds how many years an investment takes to double.


Repeat work over ranges and lists with for loops, and loop until a condition changes with while.

for and while loops

while loops | Intro to CS - Python | Khan Academy

Python Tutorial for Beginners 7: Loops and Iterations - For/While Loops

## Why it matters

As programs grow, you find yourself writing the same few lines in several places: converting units, validating a value, formatting a report line. A **function** gives those lines a name so you can write them once and use them everywhere. Functions also make code easier to test, because you can check one small piece at a time, and easier to read, because a good name like `celsius_to_fahrenheit` explains itself.

## Defining and calling a function

```python
def celsius_to_fahrenheit(celsius):
    fahrenheit = celsius * 9 / 5 + 32
    return fahrenheit

print(celsius_to_fahrenheit(100))   # 212.0
print(celsius_to_fahrenheit(-40))   # -40.0
```

The parts:

- `def` starts the definition, followed by the function's name.
- Inside the parentheses are the **parameters**: names for the inputs. Here, `celsius`.
- The colon and the indented block form the **body**.
- `return` sends a value back to whoever called the function, and ends the function immediately.

Defining a function does not run it. It runs only when you **call** it, writing its name with **arguments** in parentheses: `celsius_to_fahrenheit(100)`. The value `100` is assigned to the parameter `celsius` for that call.

## return versus print

This difference trips up almost every beginner:

```python
def area_print(width, height):
    print(width * height)

def area_return(width, height):
    return width * height

a = area_print(3, 4)    # shows 12, but a is None
b = area_return(3, 4)   # shows nothing, but b is 12
print(b * 2)            # 24
```

`print` shows a value on the screen and then the value is gone. `return` hands the value back so the rest of your program can use it. A function with no `return` statement returns the special value `None`. As a rule, functions that calculate something should `return` it and let the caller decide whether to print it.

## Several parameters and default values

```python
def bmi(mass_kg, height_m):
    return mass_kg / height_m ** 2

print(round(bmi(70, 1.75), 1))    # 22.9
```

Arguments are matched to parameters by position. You can also pass them by name, which is clearer when there are several:

```python
print(round(bmi(height_m=1.75, mass_kg=70), 1))   # 22.9
```

A parameter can have a **default value**, used when the caller leaves it out:

```python
def format_temp(value, unit="C", decimals=1):
    return f"{value:.{decimals}f} °{unit}"

print(format_temp(21.456))               # 21.5 °C
print(format_temp(70.8, "F"))            # 70.8 °F
print(format_temp(21.456, decimals=2))   # 21.46 °C
```

Parameters with defaults must come after the ones without.

## Returning early and returning several values

`return` can appear more than once. The first one reached wins:

```python
def safe_divide(a, b):
    if b == 0:
        return None          # nothing sensible to return
    return a / b
```

To return several values, separate them with commas. Python packs them into a tuple, and the caller can unpack them:

```python
def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9, 4])
print(low, high)     # 2 9
```

## Scope: variables inside functions

Variables created inside a function are **local**: they exist only while the function runs and cannot be seen from outside.

```python
def add_tax(price):
    tax = price * 0.2
    return price + tax

print(add_tax(10))   # 12.0
print(tax)           # NameError: name 'tax' is not defined
```

This is a feature. It means a function cannot accidentally overwrite your other variables, and you can understand it on its own. Pass what a function needs in as arguments, and get results out with `return`, rather than relying on variables defined elsewhere.

## Documenting a function

A string on the first line of the body is a **docstring**. It describes what the function does, and tools such as `help()` and code editors show it:

```python
def average(values):
    """Return the mean of a list of numbers, or 0.0 for an empty list."""
    if not values:
        return 0.0
    return sum(values) / len(values)
```

## A worked example: building from small pieces

Small functions combine into bigger ones:

```python
def average(values):
    if not values:
        return 0.0
    return sum(values) / len(values)

def report(name, values):
    return f"{name}: mean {average(values):.1f} from {len(values)} readings"

print(report("Tank A", [20.5, 21.0, 22.5]))
# Tank A: mean 21.3 from 3 readings
```

Each function does one job and can be tested on its own. That is the habit that makes larger programs manageable.

## Common mistakes

- **Forgetting the parentheses.** `celsius_to_fahrenheit` without `()` refers to the function itself; it does not call it.
- **Printing instead of returning.** If the caller needs the value, `return` it.
- **Code after `return`.** Lines after a `return` in the same block never run.
- **Calling before defining.** Python runs top to bottom, so define a function above the line that first calls it.
- **Mutable default values.** `def add(item, items=[])` shares one list across every call. Use `items=None`, then `if items is None: items = []`.

## Quick recap

- `def name(parameters):` defines a function; calling `name(arguments)` runs it.
- `return` sends a value back; without it, a function returns `None`.
- Default values make parameters optional; keyword arguments make calls readable.
- Variables inside a function are local to it.
- Small, single-purpose functions are easier to test and reuse.

## Try it

In the Do tab you will write a unit converter, a safe average and a formatter that uses a default value.


Define reusable functions with parameters, default values and return values.

Writing functions

Functions | Intro to CS - Python | Khan Academy

Python Tutorial for Beginners 8: Functions

## Why it matters

Every programmer, at every level, writes code that breaks. The difference between a beginner and an experienced developer is not fewer errors, it is how quickly they find the cause. Python is very helpful here: when something goes wrong it prints a **traceback** that says what failed and exactly where. Learning to read it turns a scary wall of red text into a set of directions.

## Anatomy of a traceback

Here is a small script with a bug:

```python
def average(values):
    return sum(values) / len(values)

def report(readings):
    mean = average(readings)
    return f"Mean: {mean:.2f}"

print(report([]))
```

Running it prints:

```text
Traceback (most recent call last):
  File "sensors.py", line 8, in <module>
    print(report([]))
  File "sensors.py", line 5, in report
    mean = average(readings)
  File "sensors.py", line 2, in average
    return sum(values) / len(values)
ZeroDivisionError: division by zero
```

Read it **from the bottom up**:

1. **The last line** names the error type (`ZeroDivisionError`) and a message (`division by zero`). This is *what* went wrong.
2. **The frame just above it** shows *where*: file `sensors.py`, line 2, inside the function `average`, with the line of code itself.
3. **The frames higher up** show *how the program got there*: line 8 called `report`, which on line 5 called `average`. "Most recent call last" means the deepest call is at the bottom.

So the story is: `report([])` passed an empty list to `average`, and `len([])` is 0. The fix might be to handle the empty case in `average`, or to avoid calling it with no data. The traceback tells you where to look; you still decide what the correct behaviour is.

## Common error types

| Error | Usual cause | Example |
|---|---|---|
| `SyntaxError` | Code is not valid Python: missing colon, bracket or quote | `if x > 3` |
| `IndentationError` | Inconsistent or missing indentation | a block not indented under `if` |
| `NameError` | A name is misspelled or used before it is defined | `pirnt("hi")` |
| `TypeError` | An operation got the wrong type of value | `"5" + 3` |
| `ValueError` | Right type, unusable value | `int("3.5")` |
| `ZeroDivisionError` | Dividing by zero | `10 / 0` |
| `IndexError` | List position does not exist | `[1, 2][5]` |
| `KeyError` | Dictionary key does not exist | `{"a": 1}["b"]` |
| `AttributeError` | That type has no such method or attribute | `[1, 2].upper()` |

A `SyntaxError` is special: Python finds it before running anything, so no lines run at all. The caret (`^`) under the code points at where Python got confused, and the real mistake is often just before it, such as an unclosed bracket on the previous line.

## Bugs without errors

The hardest bugs raise no error at all: the program runs and gives the wrong answer. An off-by-one loop or a wrong formula looks perfectly fine to Python. For these you need to check results against values you know:

```python
def average(values):
    total = 0
    for i in range(1, len(values)):   # bug: skips the first item
        total += values[i]
    return total / len(values)

print(average([2, 4, 6]))   # 3.3333333333333335, but should be 4.0
```

Testing with a tiny input whose answer you can work out by hand exposes the bug immediately.

## A debugging method

1. **Reproduce it.** Find the smallest input that shows the problem.
2. **Read the last line, then the nearest frame in your own code.** Ignore frames inside libraries at first.
3. **Look at the values.** Add temporary `print` calls to see what variables actually hold: `print("DEBUG values =", repr(values))`. `repr` shows quotes around strings, so you can tell `"5"` from `5`.
4. **Form one hypothesis and test it.** Change one thing, run again. Changing several things at once hides which one mattered.
5. **Check with `assert`.** `assert average([2, 4, 6]) == 4` stops with an `AssertionError` if the result is wrong. The checks in this course's Do tab work exactly this way.
6. **Remove the debug prints** when you are done.

Explaining the code line by line to someone else (or to a rubber duck on your desk) is a surprisingly effective step 4. You often spot the bug mid-sentence.

## Handling errors you expect

Some errors are not bugs but expected situations, like a sensor sending `"n/a"` instead of a number. `try` / `except` lets you handle them:

```python
def parse_reading(text):
    try:
        return float(text)
    except ValueError:
        return None          # not a number: skip it

print(parse_reading("21.5"))   # 21.5
print(parse_reading("n/a"))    # None
```

Catch the **specific** error you expect. A bare `except:` hides every problem, including typos in your own code, and makes debugging much harder.

## Common mistakes

- **Reading only the top of the traceback.** The answer is at the bottom.
- **Guessing instead of looking.** Print the actual values before changing code.
- **Fixing the symptom.** Wrapping everything in `try` / `except` makes the error message go away, not the bug.
- **Assuming input types.** Text from files and forms is a string until you convert it.

## Quick recap

- Read tracebacks bottom up: error type and message, then the line, then the call chain.
- Learn the common error types; each points to a typical cause.
- Wrong-answer bugs need known test cases and `assert`.
- Debug one hypothesis at a time, with `print(repr(...))` to see real values.
- Use `try` / `except SpecificError` only for situations you expect.

## Try it

The Do tab gives you a small sensor script with three bugs. Run the checks, read each failure message, and fix the code until every check passes.


Read a Python traceback from the bottom up, recognise common error types and fix bugs methodically.

Reading errors and debugging

How Do You Read a Python Traceback?

Traceback (most recent call last): Python's tracebacks explained

Repeat work with for and while loops, package logic into reusable functions, and fix broken scripts by reading tracebacks.