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

Data rarely lives inside your program. It arrives as files: instrument exports, spreadsheets saved as CSV, log files, configuration. And results usually need to be saved somewhere for someone else. Reading a file, processing it and writing a summary is one of the most practical things you can do with Python, and it takes only a few lines.

## Opening a file with `with`

```python
with open("notes.txt", "w") as f:
    f.write("first line\n")
    f.write("second line\n")

with open("notes.txt") as f:
    text = f.read()

print(text)
```

- `open(path, mode)` returns a **file object**. Mode `"r"` (the default) reads, `"w"` writes (creating the file, or **erasing** it if it already exists), and `"a"` appends to the end.
- The `with` block closes the file automatically when the block ends, even if an error happens inside it. Always use `with`; forgetting to close files can lose data that has not been written yet.
- `write` does not add a newline for you. Put `"\n"` at the end of each line.

A **path** like `"notes.txt"` is relative to the folder the program runs in, its *working directory*. A path such as `"data/readings.csv"` means "the `readings.csv` file inside the `data` folder". If Python says `FileNotFoundError`, the path or the working directory is usually the problem.

For text that may contain accented letters or symbols, say which encoding to use: `open("notes.txt", encoding="utf-8")`. UTF-8 is the safe default.

## Reading line by line

`f.read()` gives the whole file as one string. For large files, or when each line is a record, loop over the file object instead:

```python
with open("notes.txt") as f:
    for line in f:
        line = line.strip()      # remove the trailing "\n" and spaces
        if not line:
            continue             # skip blank lines
        print("Line:", line)
```

`f.readlines()` returns a list of lines if you need them all at once.

## CSV files and the csv module

CSV (comma-separated values) is the most common format for tabular data:

```text
sample,mass_g,temp_c
S-01,12.40,21.5
S-02,11.85,22.0
S-03,12.10,21.0
```

You could split each line on commas yourself, but real CSV files contain quoted fields with commas inside them, like `"Smith, Ada"`. The standard library's `csv` module handles all of that:

```python
import csv

with open("samples.csv", newline="") as f:
    reader = csv.DictReader(f)
    rows = list(reader)

print(rows[0])
# {'sample': 'S-01', 'mass_g': '12.40', 'temp_c': '21.5'}
```

`csv.DictReader` uses the header row as keys, so each row becomes a dictionary. Notice that **every value is a string**. Convert before doing maths:

```python
masses = [float(row["mass_g"]) for row in rows]
print(f"Mean mass: {sum(masses) / len(masses):.2f} g")   # Mean mass: 12.12 g
```

(Opening CSV files with `newline=""` is what the csv documentation recommends; it stops blank lines appearing on some systems.)

## Writing CSV and summary files

`csv.writer` writes lists as rows, and `csv.DictWriter` writes dictionaries:

```python
import csv

results = [
    {"sample": "S-01", "status": "ok"},
    {"sample": "S-02", "status": "check"},
]

with open("status.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["sample", "status"])
    writer.writeheader()
    writer.writerows(results)
```

A plain text summary is just `write` calls:

```python
with open("summary.txt", "w") as f:
    f.write(f"samples: {len(masses)}\n")
    f.write(f"mean_mass_g: {sum(masses) / len(masses):.2f}\n")
```

## A worked example: read, summarise, write

```python
import csv

def summarise_csv(in_path, out_path, column):
    with open(in_path, newline="") as f:
        values = [float(row[column]) for row in csv.DictReader(f)]
    with open(out_path, "w") as f:
        f.write(f"count: {len(values)}\n")
        f.write(f"min: {min(values):.2f}\n")
        f.write(f"max: {max(values):.2f}\n")
    return len(values)

summarise_csv("samples.csv", "mass_summary.txt", "mass_g")
```

Two `with` blocks, one for reading and one for writing, and a function so you can reuse it on any file and column.

## Files in the browser runner

The Do tab runs Python in your browser with its own temporary, in-memory file system. `open`, `csv` and `with` work exactly as on your computer, but the files disappear when you reload the page, and your program cannot see files on your own disk. That is why the exercise first writes a sample CSV file and then reads it back.

## Other formats

The same pattern works for other formats in the standard library: the `json` module reads and writes JSON (`json.load(f)`, `json.dump(data, f)`), which is common for configuration and web data. For large spreadsheets and analysis, the pandas library (covered in later courses) reads CSV in one line, but it is built on the same ideas.

## Common mistakes

- **Opening with `"w"` when you meant `"a"`.** `"w"` erases the existing file first.
- **Forgetting that CSV values are strings.** `"12.40" + "11.85"` joins text. Convert with `float()`.
- **Missing newlines.** `f.write("a")` then `f.write("b")` produces `ab` on one line.
- **Wrong path or working directory.** `FileNotFoundError` usually means the program is running from a different folder than you think.
- **Not using `with`.** Files you forget to close may not be fully written.

## Quick recap

- `with open(path, mode) as f:` opens a file and closes it for you.
- Modes: `"r"` read, `"w"` write (erases), `"a"` append.
- Loop over a file to read it line by line; `.strip()` each line.
- `csv.DictReader` turns rows into dictionaries of strings; convert numbers yourself.
- `f.write(...)` writes text; add `"\n"` yourself.

## Try it

In the Do tab you will read a small CSV of sample masses, calculate the count and mean, and write a two-line summary file.


Open text files safely with `with`, read CSV data with the csv module and write a summary file.

Reading and writing files

Python Tutorial: CSV Module - How to Read, Parse, and Write CSV Files

Python Tutorial: File Objects - Reading and Writing to Files

## Why it matters

Python comes with a large **standard library**: hundreds of modules for maths, statistics, dates, text, files, data formats and more, already installed wherever Python is. Before you write something yourself, it is worth checking whether the standard library already does it, tested and documented. Knowing how `import` works also prepares you for third-party packages such as pandas or requests, and for splitting your own programs into several files.

## Importing a module

A **module** is a file of Python code with functions and values you can use. Bring one in with `import`:

```python
import math

print(math.pi)            # 3.141592653589793
print(math.sqrt(16))      # 4.0
print(math.ceil(4.2))     # 5
print(math.floor(4.8))    # 4
print(math.hypot(3, 4))   # 5.0  (length of the hypotenuse)
```

You use the module's contents with a dot: `math.sqrt`. This keeps names organised: `math.sqrt` cannot clash with a `sqrt` of your own.

Other import forms:

```python
from math import sqrt, pi     # bring specific names in directly
print(sqrt(2) * pi)

import statistics as st       # give a module a shorter alias
print(st.mean([1, 2, 3]))
```

Avoid `from math import *`. It dumps every name into your program, so readers cannot tell where a name came from and your own variables can be silently overwritten.

Put imports at the top of the file, one per line. That way anyone reading the file sees immediately what it depends on.

## math: numbers and geometry

```python
import math

radius = 2.5
area = math.pi * radius ** 2
print(f"{area:.2f}")                  # 19.63

angle = math.radians(30)              # trig functions use radians
print(round(math.sin(angle), 3))      # 0.5
print(math.isclose(0.1 + 0.2, 0.3))   # True: safe float comparison
print(math.log10(1000))               # 3.0
```

`math.isclose` is the right way to compare floats, avoiding the `0.30000000000000004` surprise.

## statistics: quick summaries

```python
import statistics

readings = [21.5, 22.0, 23.25, 22.75, 21.0]

print(statistics.mean(readings))             # 22.1
print(statistics.median(readings))           # 22.0
print(round(statistics.stdev(readings), 3))  # 0.912 (sample standard deviation)
print(statistics.mode([3, 1, 3, 2]))         # 3
```

For small and medium data sets, `statistics` covers most of what you need without installing anything. (The Statistics Fundamentals course explains what these numbers mean.)

## datetime: dates and times

Dates are deceptively tricky: months have different lengths, years have leap days. The `datetime` module handles that for you:

```python
from datetime import date, datetime, timedelta

start = date(2026, 10, 1)
due = date.fromisoformat("2026-12-25")        # parse "YYYY-MM-DD"
print((due - start).days)                     # 85   (a timedelta, in days)
print(start + timedelta(days=30))             # 2026-10-31
print(start.strftime("%d %b %Y"))             # 01 Oct 2026
print(start.weekday())                        # 3 (Monday is 0, so Thursday)

stamp = datetime.fromisoformat("2026-10-01T14:30:00")
print(stamp.hour, stamp.minute)               # 14 30
```

Subtracting two dates gives a `timedelta`; its `.days` attribute is the gap in whole days. ISO format (`2026-10-01`) is unambiguous and sorts correctly as text, so it is the best choice for files and logs.

## A tour of other useful modules

| Module | Use it for |
|---|---|
| `random` | random numbers, shuffling, sampling (`random.choice`, `random.randint`) |
| `collections` | `Counter`, `defaultdict`, `namedtuple` |
| `itertools` | combinations, permutations, grouping |
| `json` | reading and writing JSON |
| `csv` | reading and writing CSV |
| `re` | regular expressions for text patterns |
| `pathlib` | working with file paths |
| `fractions`, `decimal` | exact fractions and exact decimal money maths |

The official documentation at [docs.python.org](https://docs.python.org/3/library/) lists them all. Typing `help(math)` or `dir(math)` in the interactive shell also shows what a module contains.

## Your own modules

Any `.py` file is a module. If you save functions in `units.py`, another file in the same folder can use them:

```python
# units.py
def c_to_f(c):
    return c * 9 / 5 + 32
```

```python
# main.py
import units
print(units.c_to_f(100))    # 212.0
```

Code at the top level of `units.py` runs when it is imported. To include test or demo code that runs only when you run the file directly, guard it:

```python
if __name__ == "__main__":
    print(c_to_f(100))
```

## Packages from outside the standard library

Third-party **packages** (pandas, numpy, requests and thousands more) are published on the Python Package Index (PyPI) and installed with `pip install package-name`, ideally inside a *virtual environment* (`python3 -m venv .venv`) so each project has its own set. Once installed, you import them in exactly the same way. Install only well-known, maintained packages, and check the spelling: look-alike malicious packages do exist. The exercises in this course use only the standard library.

## Common mistakes

- **Naming your file after a module.** A file called `math.py` or `statistics.py` in your folder hides the real module and causes baffling errors.
- **Forgetting the module prefix.** After `import math`, it is `math.sqrt`, not `sqrt`.
- **Degrees instead of radians.** `math.sin(30)` is not 0.5. Convert with `math.radians`.
- **Comparing dates as text in the wrong format.** `"1/10/2026"` style strings do not sort correctly; parse them into `date` objects.

## Quick recap

- `import module` then `module.name`; or `from module import name`; or `import module as alias`.
- `math` for maths, `statistics` for summaries, `datetime` for dates and durations.
- Check the standard library before writing your own version.
- Any `.py` file can be imported; guard demo code with `if __name__ == "__main__":`.
- Third-party packages come from PyPI via `pip`, inside a virtual environment.

## Try it

In the Do tab you will use `math`, `statistics` and `datetime` to finish three small helper functions.


Import modules, use math, statistics and datetime from the standard library, and know when to reach for a package.

Modules and the standard library

Importing modules | Intro to CS - Python | Khan Academy

Python Tutorial for Beginners 9: Import Modules and Exploring The Standard Library

## Why it matters

So far you have kept data (lists, dictionaries) and the functions that work on it separately. As programs grow, it helps to bundle them together: a sensor *has* a name, a unit and readings, and you can *ask it* for its average. A **class** describes that bundle, and each **object** made from it carries its own data. Everything in Python is already an object (a string has `.upper()`, a list has `.append()`), so learning classes also explains how the tools you already use work.

## Defining a class

```python
class Sensor:
    def __init__(self, name, unit):
        self.name = name
        self.unit = unit
        self.readings = []

    def add(self, value):
        self.readings.append(value)

    def average(self):
        if not self.readings:
            return 0.0
        return sum(self.readings) / len(self.readings)
```

- `class Sensor:` starts the definition. Class names use `CapWords` style.
- Functions defined inside a class are **methods**.
- `__init__` (two underscores on each side) is the **initialiser**. Python calls it automatically when you create a new object, to set up the object's starting data.
- `self` is the object the method is working on. Every method takes it as its first parameter. `self.name = name` stores the argument as an **attribute** of this particular object.

## Creating and using objects

```python
tank = Sensor("tank-a", "C")
pump = Sensor("pump-1", "bar")

tank.add(20.5)
tank.add(21.5)
pump.add(3.2)

print(tank.name, tank.readings)     # tank-a [20.5, 21.5]
print(tank.average())               # 21.0
print(pump.average())               # 3.2
```

Calling the class like a function, `Sensor("tank-a", "C")`, creates a new object (an **instance**) and runs `__init__` with `self` set to it. When you call `tank.add(20.5)`, Python passes `tank` as `self` for you; you never pass `self` yourself.

Each instance has its own attributes. Adding a reading to `tank` does not touch `pump`.

## Methods that use other methods

Methods can call each other through `self`:

```python
class Sensor:
    def __init__(self, name, unit):
        self.name = name
        self.unit = unit
        self.readings = []

    def add(self, value):
        self.readings.append(value)

    def average(self):
        if not self.readings:
            return 0.0
        return sum(self.readings) / len(self.readings)

    def summary(self):
        return f"{self.name}: {len(self.readings)} readings, mean {self.average():.1f} {self.unit}"

tank = Sensor("tank-a", "C")
for v in [20.5, 21.5, 22.0]:
    tank.add(v)
print(tank.summary())     # tank-a: 3 readings, mean 21.3 C
```

## A readable printout with `__str__`

By default, `print(tank)` shows something unhelpful like `<__main__.Sensor object at 0x10a...>`. Define `__str__` to choose what `print` and `str()` show:

```python
    def __str__(self):
        return f"Sensor({self.name}, {len(self.readings)} readings)"
```

Methods with double underscores are called **special methods** (or "dunder" methods). Python calls them for you in particular situations: `__init__` on creation, `__str__` when printing, `__len__` for `len(obj)`, and so on.

## Validating data

A class is a good place to enforce rules, so bad data is rejected at the door:

```python
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

acct = BankAccount("Ada", 100)
acct.deposit(50)
acct.withdraw(30)
print(acct.balance)     # 120
acct.withdraw(500)      # ValueError: Insufficient funds
```

`raise` signals an error deliberately. The calling code can catch it with `try` / `except ValueError` (see the debugging lesson) or let the program stop with a clear message.

## When to write a class

Classes are a tool, not a requirement. Plain functions and dictionaries are fine for small scripts. Consider a class when:

- several functions all take the same group of data as their first argument;
- you have many similar things (sensors, accounts, students), each with its own state;
- you want to enforce rules about how that data may change.

There is more to object-oriented programming, such as **inheritance** (a class that extends another) and the `@dataclass` shortcut from the `dataclasses` module that writes `__init__` for you. Those build on exactly what you have seen here.

## Common mistakes

- **Forgetting `self` in the method definition.** `def add(value):` fails with `TypeError: add() takes 1 positional argument but 2 were given`, because Python passes the object automatically.
- **Forgetting `self.` when using an attribute.** Inside a method, `readings` is a local name; the attribute is `self.readings`.
- **Misspelling `__init__`.** `_init_` or `__int__` will not be called when the object is created.
- **Creating mutable data at class level.** `readings = []` written directly under `class Sensor:` (outside `__init__`) is shared by all sensors. Create it in `__init__` with `self.readings = []`.
- **Calling the method without parentheses.** `tank.average` is the method itself; `tank.average()` runs it.

## Quick recap

- `class Name:` defines a class; calling `Name(...)` creates an instance.
- `__init__(self, ...)` sets each new object's starting attributes.
- Methods take `self` first and use `self.attribute` to reach the object's data.
- `__str__` controls what `print(obj)` shows.
- Use classes to bundle related data with the behaviour that belongs to it.

## Try it

In the Do tab you will finish a `Sensor` class: store readings, report the latest and the average, and print a readable summary.


Define a small class with an __init__ method, attributes and methods that work on the object's own data.

Objects and classes (intro)

Classes and objects | Intro to CS - Python | Khan Academy

Python OOP Tutorial 1: Classes and Instances

Read and write text and CSV files, use the standard library (math, statistics, datetime), and organise code with a first class.