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

Python is one of the most widely used programming languages in the world. Data analysts use it to clean spreadsheets, engineers use it to process sensor readings, scientists use it to run simulations, and web developers use it to build servers. It is popular with beginners because the code reads almost like English, and popular with professionals because a huge library of ready-made tools sits behind it.

In this lesson you will run your first program, see what Python prints back, and learn the habits that make every later lesson easier.

## Where Python code runs

A Python program is a plain text file, usually ending in `.py`, that the **Python interpreter** reads from top to bottom and executes one line at a time. There are three common ways to run it:

- **In the browser.** The Do tab of this course runs Python for you, with nothing to install. It uses Pyodide, a version of Python that runs inside your web browser.
- **In a terminal.** After installing Python from [python.org](https://www.python.org/downloads/), you save a file such as `hello.py` and run `python3 hello.py` (on Windows, often `py hello.py`).
- **In the interactive shell (REPL).** Typing `python3` on its own opens a prompt (`>>>`) where each line runs as soon as you press Enter. It is handy for quick experiments.

All three run the same language. What you learn here works everywhere.

## Your first program

```python
print("Hello, world!")
```

`print` is a **function**: a named piece of code that does a job. You call it by writing its name followed by parentheses, and you put the thing you want it to work on, the **argument**, inside. Here the argument is the text `"Hello, world!"`. Text in quotes is called a **string**. Single quotes (`'Hello'`) and double quotes (`"Hello"`) both work; just use the same kind at both ends.

`print` can take several arguments separated by commas. It puts a space between them:

```python
print("Lessons in this course:", 15)
print("Modules:", 5, "Lessons per module:", 3)
```

Output:

```text
Lessons in this course: 15
Modules: 5 Lessons per module: 3
```

## Python as a calculator

Python understands arithmetic. Each line below is an **expression**, which Python works out to a single value:

```python
print(7 + 3)      # 10
print(7 - 3)      # 4
print(7 * 3)      # 21
print(7 / 2)      # 3.5   (true division always gives a decimal)
print(7 // 2)     # 3     (floor division drops the remainder)
print(7 % 2)      # 1     (remainder, called "modulo")
print(2 ** 10)    # 1024  (power)
```

Python follows the usual order of operations, so `2 + 3 * 4` is `14`, and `(2 + 3) * 4` is `20`. When in doubt, add parentheses: they make your intent clear to the next reader too.

Everything after a `#` on a line is a **comment**. Python ignores it. Comments are notes for humans, and they are a good place to explain *why* a line exists.

## Giving a value a name

You will often want to keep a result and use it again. The `=` sign stores a value under a name:

```python
seconds_per_day = 24 * 60 * 60
print("Seconds in a day:", seconds_per_day)
print("Seconds in a week:", seconds_per_day * 7)
```

The name on the left is a **variable**. The next lesson covers variables in detail; for now, read `=` as "store the value on the right under the name on the left".

## Order matters

Python runs your file top to bottom. A line can only use names that were created on an earlier line:

```python
print(total)   # NameError: name 'total' is not defined
total = 10
```

Swap the two lines and it works. When something goes wrong, Python stops and prints an **error message** that names the problem and the line number. Lesson 6 of this course is all about reading these messages; for now, look at the last line of the error first, because that is where Python says what went wrong.

## Common mistakes

- **Missing quotes.** `print(Hello)` makes Python look for a variable called `Hello`. Text needs quotes: `print("Hello")`.
- **Mismatched quotes or brackets.** `print("Hello')` or `print("Hello"` is a `SyntaxError`. Every opening quote and bracket needs a matching closing one.
- **Capital letters.** Python is case-sensitive. `Print` and `print` are different names, and only `print` exists.
- **Expecting `/` to give a whole number.** `10 / 2` is `5.0`, not `5`. Use `//` when you want whole-number division.
- **Stray indentation.** A line that starts with spaces for no reason is an `IndentationError`. Start top-level lines at the left edge.

## Quick recap

- A Python program is text that the interpreter runs from top to bottom.
- `print(...)` shows values; separate several values with commas.
- Strings are text in quotes; numbers are written without quotes.
- Python does arithmetic with `+ - * / // % **` and follows the order of operations.
- `name = value` stores a value so you can use it later.
- When an error appears, read its last line first.

## Try it

Open the Do tab. You will store a greeting, work out how many minutes are in a week, and print both.


Run your first Python program, print output and use Python as a calculator.

Running Python

Print statements and expressions | Intro to CS - Python | Khan Academy

Scripts and sequences | Intro to CS - Python | Khan Academy

## Why it matters

Almost every program takes in some values, transforms them and reports a result: a price and a quantity become a total, a list of readings becomes an average, a name becomes a personalised message. Variables hold those values, and knowing the difference between numbers and text saves you from the most common beginner bugs.

## Variables are names for values

```python
course = "Python Fundamentals"
lessons = 15
hours = 12.5
```

Each line stores a value under a name. You can change what a name points to later, and the old value is simply replaced:

```python
lessons = 15
lessons = lessons + 1   # take the current value, add 1, store it back
print(lessons)          # 16
```

That pattern is so common that Python has a shortcut: `lessons += 1`.

**Naming rules:** names can contain letters, digits and underscores, cannot start with a digit, and are case-sensitive (`Total` and `total` are different). The Python convention is `snake_case`: lowercase words joined by underscores, such as `max_temperature`. Pick names that say what the value means; `price_per_item` is far easier to read later than `p` or `x2`.

## The basic types

Every value has a **type**. You can ask Python with `type(...)`:

```python
print(type(15))        # <class 'int'>    whole number
print(type(12.5))      # <class 'float'>  decimal number
print(type("15"))      # <class 'str'>    text (a string)
print(type(True))      # <class 'bool'>   True or False
```

The type decides what operations make sense. `15 + 1` is `16`, but `"15" + "1"` is `"151"`, because `+` joins strings together. And `"15" + 1` is an error: Python refuses to guess whether you meant maths or joining.

## Converting between types

Text that arrives from a file, a web form or a sensor is a string, even when it looks like a number. Convert it before doing maths:

```python
quantity_text = "4"
quantity = int(quantity_text)      # 4 (an int)
price = float("3.50")              # 3.5 (a float)
label = str(quantity)              # "4" (back to text)
```

`int("3.5")` fails, because `"3.5"` is not a whole number. Use `float` for decimals, then `round` or `int` if you need a whole number.

A note on decimals: computers store floats in binary, so some values are tiny approximations. `0.1 + 0.2` prints `0.30000000000000004`. This is normal in every language. Round when you display results, and compare floats with a small tolerance rather than `==`.

## Working with strings

Strings come with many built-in **methods**, which you call with a dot:

```python
name = "  ada lovelace  "
print(name.strip())          # "ada lovelace"  (remove surrounding spaces)
print(name.strip().title())  # "Ada Lovelace"
print(name.upper())          # "  ADA LOVELACE  "
print(len("Python"))         # 6  (number of characters)
print("ace" in "Lovelace")   # True
print("a,b,c".split(","))    # ['a', 'b', 'c']
print("data.csv".replace(".csv", ".txt"))  # "data.txt"
```

Methods return a **new** string; the original is unchanged. `name.upper()` on its own does nothing useful unless you store or print the result.

You can pick out characters by position, counting from 0:

```python
word = "Python"
print(word[0])    # "P"
print(word[-1])   # "n"  (negative numbers count from the end)
```

## Formatting output with f-strings

To build a message from values, put an `f` before the opening quote and write expressions inside `{}`:

```python
item = "notebook"
price = 3.5
quantity = 4
total = price * quantity

print(f"{quantity} x {item} = ${total:.2f}")
# 4 x notebook = $14.00
```

The part after the colon is a **format spec**. A few useful ones:

```python
value = 1234.5678
print(f"{value:.2f}")    # 1234.57    two decimal places
print(f"{value:,.1f}")   # 1,234.6    thousands separator
print(f"{0.256:.1%}")    # 25.6%      as a percentage
print(f"{7:03d}")        # 007        pad with zeros to width 3
```

f-strings are the modern, readable way to format text. You will still see older styles such as `"Total: " + str(total)` or `"{}".format(total)` in existing code; they do the same job.

## A worked example

A lab records a sample as text: `"sample-07,23.456"`. Report it nicely:

```python
record = "sample-07,23.456"
parts = record.split(",")          # ['sample-07', '23.456']
sample_id = parts[0].upper()       # 'SAMPLE-07'
mass_g = float(parts[1])           # 23.456
print(f"{sample_id}: {mass_g:.1f} g")
# SAMPLE-07: 23.5 g
```

Split, convert, format: you will use this pattern constantly.

## Common mistakes

- **Doing maths on text.** `"4" * 2` is `"44"`. Convert with `int()` or `float()` first.
- **Forgetting the `f`.** `"{total}"` prints the braces literally. It must be `f"{total}"`.
- **Expecting methods to change the original.** Strings are immutable; store the result: `name = name.strip()`.
- **Using `=` when you mean "equals".** `=` stores; `==` compares (next lesson).
- **Comparing floats exactly.** Prefer `abs(a - b) < 1e-9` or `round(a, 2) == b`.

## Quick recap

- `name = value` stores a value; `snake_case` names that describe the value.
- Main types: `int`, `float`, `str`, `bool`. `type()` tells you which.
- Convert with `int()`, `float()`, `str()`; input text is always a string.
- String methods (`strip`, `upper`, `split`, `replace`) return new strings.
- f-strings (`f"{value:.2f}"`) format numbers and text in one readable line.

## Try it

In the Do tab you will turn a quantity stored as text into a number, calculate a total and format a receipt line.


Store values in variables, convert between numbers and text, and format output with f-strings.

Variables, numbers, and strings

Python Variables - Python Tutorial for Beginners with Examples | Mosh

Python Tutorial for Beginners 2: Strings - Working with Textual Data

## Why it matters

Programs become useful when they make decisions: flag a temperature that is too high, give a discount over a certain spend, reject a password that is too short, assign a letter grade. Every one of those is a **condition**: a question with a yes-or-no answer, followed by different code for each answer.

## Booleans: True and False

A comparison produces a **boolean**, a value that is either `True` or `False`:

```python
print(5 > 3)      # True
print(5 == 3)     # False   (== asks "are these equal?")
print(5 != 3)     # True    (!= means "not equal")
print(4 <= 4)     # True
print("cat" == "Cat")   # False: comparisons are case-sensitive
```

The six comparison operators are `==`, `!=`, `<`, `<=`, `>` and `>=`. Remember: a single `=` stores a value, a double `==` compares.

## Combining conditions

Use `and`, `or` and `not` to build bigger questions:

```python
temp = 22
humidity = 70

print(temp > 18 and temp < 26)    # True: both parts are True
print(temp > 30 or humidity > 60) # True: at least one part is True
print(not temp > 30)              # True: flips False to True
```

Python also lets you chain comparisons the way you would in maths: `18 < temp < 26` means the same as `temp > 18 and temp < 26`.

## if, elif and else

```python
temp = 31

if temp > 30:
    print("Too hot: open the vents")
elif temp < 10:
    print("Too cold: turn on the heater")
else:
    print("Temperature OK")
```

How it works:

1. Python checks the `if` condition. If it is `True`, it runs that indented block and **skips the rest**.
2. Otherwise it checks each `elif` ("else if") in order and runs the first one that is `True`.
3. If none matched, the `else` block runs. `elif` and `else` are both optional.

**Indentation is part of the syntax.** The lines that belong to a branch are indented (four spaces is the standard). The colon at the end of the `if` line is required. When the indentation ends, so does the branch.

## Order matters in elif chains

Because Python stops at the first true branch, put the most specific tests first:

```python
score = 95

# Wrong order: 95 is >= 60, so this prints "D"
if score >= 60:
    grade = "D"
elif score >= 90:
    grade = "A"

# Right order: highest threshold first
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(grade)   # A
```

## Truthiness

`if` does not need a comparison. Python treats some values as "falsy": `0`, `0.0`, the empty string `""`, empty lists and `None`. Everything else is "truthy":

```python
name = ""
if name:
    print(f"Hello, {name}")
else:
    print("Please enter your name")
```

This is a neat shortcut for "is it empty?", but use explicit comparisons when they are clearer, such as `if count == 0:`.

## What about input()?

In a terminal, `input("Your age: ")` pauses the program and returns what the user typed, always as a string, so you would write `age = int(input("Your age: "))`. The in-browser runner on this site cannot pause for typing, so in the Do tab we set values directly or pass them to a function. The decision logic is exactly the same.

## A worked example

A theme park ride needs riders to be at least 120 cm tall, or at least 100 cm when riding with an adult:

```python
def can_ride(height_cm, with_adult):
    if height_cm >= 120:
        return True
    elif height_cm >= 100 and with_adult:
        return True
    else:
        return False

print(can_ride(130, False))  # True
print(can_ride(110, True))   # True
print(can_ride(110, False))  # False
```

`def` creates a **function**, a named, reusable block that takes inputs and `return`s a result. Module 2 covers functions properly; here it just lets us test one rule with several inputs. The whole rule also fits on one line: `return height_cm >= 120 or (height_cm >= 100 and with_adult)`.

## Common mistakes

- **`=` instead of `==`.** `if temp = 30:` is a `SyntaxError`.
- **Missing colon or indentation.** Every `if`, `elif` and `else` line ends with `:` and its block is indented.
- **Testing in the wrong order.** In an `elif` chain, the first true branch wins.
- **`if x == 1 or 2:`** This is always true, because `2` on its own is truthy. Write `if x == 1 or x == 2:` or `if x in (1, 2):`.
- **Comparing text with numbers.** `"10" > 9` is an error. Convert first.

## Quick recap

- Comparisons (`== != < <= > >=`) give `True` or `False`.
- `and`, `or` and `not` combine conditions.
- `if` / `elif` / `else` runs the first branch whose condition is true.
- Indentation and the colon define each branch.
- Empty and zero values are falsy; most other values are truthy.

## Try it

In the Do tab you will finish two functions: one turns a score into a letter grade, the other decides whether a reading is in a safe range.


Compare values, combine conditions with and, or and not, and branch with if, elif and else.

Conditions and booleans

if-elif-else | Intro to CS - Python | Khan Academy

Python Tutorial for Beginners 6: Conditionals and Booleans - If, Else, and Elif Statements

Run your first Python code, store values in variables, format text and numbers, and make decisions with if, elif and else.