Variables and Types

Dynamic Typing

Python is dynamically typed: variables don't have types — values do. A variable is just a name bound to an object. The same name can be re-bound to a different type at any time. Compare this to Go, where each variable has a fixed type known at compile time.

x = 42            # x is bound to an int
x = "hello"       # now bound to a str — perfectly legal
x = [1, 2, 3]      # now a list

print(type(x))   # <class 'list'>

Variables and Naming

Assignment in Python is just binding a name to an object. Multiple names can refer to the same object, and a name has no inherent type.

age = 30
name = "Alice"
is_admin = True

# Multiple assignment
a, b, c = 1, 2, 3
x = y = z = 0          # all three point to the same int 0

# Swap without a temp
a, b = b, a

Naming Rules & Conventions

The Built-in Types

Numbers

# int — arbitrary precision, no overflow
big = 2 ** 100            # 1267650600228229401496703205376

# float — 64-bit IEEE 754 double
pi = 3.14159
scientific = 1.5e-3     # 0.0015

# complex — built into the language
z = 2 + 3j
print(z.real, z.imag)  # 2.0 3.0

# Integer literals: bin / oct / hex / underscores
b = 0b1010              # 10
o = 0o17                # 15
h = 0xff                # 255
big = 1_000_000_000     # underscores allowed for readability

Strings

greeting = "hello"
multi = """Multi-line
string with newlines."""

# f-strings (Python 3.6+) — the modern way to format
name = "Alice"
age = 30
msg = f"{name} is {age} years old"

# Expressions and format specs inside f-strings
pi = 3.14159
print(f"{pi:.2f}")        # '3.14'
print(f"{2**10:_}")        # '1_024'
print(f"{name=}")          # name='Alice' (3.8+ debug syntax)

# Raw strings — no escape processing
path = r"C:\Users\Alice"

# Bytes — raw binary data, distinct from str
data = b"\x89PNG\r\n"

Booleans and None

# bool is a subclass of int. True == 1, False == 0.
flag = True
print(True + True)       # 2

# None — the singleton sentinel value (like null)
result = None

# Always test for None with `is`, never with `==`
if result is None:
    ...

Collections (preview)

numbers = [1, 2, 3]              # list — mutable ordered
coords = (10, 20)              # tuple — immutable ordered
unique = {1, 2, 3}              # set — unordered, no dupes
user = {"name": "Alice"}        # dict — key/value mapping

Each gets its own dedicated tutorial later in the curriculum.

Type Conversion

Convert between types explicitly with built-in constructors. Python won't auto-convert: "5" + 5 raises TypeError.

int("42")         # 42
int(3.7)          # 3 — truncates toward zero
int("ff", 16)     # 255 — second arg is the base

float("3.14")     # 3.14
float("inf")      # inf

str(42)           # '42'
str([1, 2])       # '[1, 2]'

bool(0)           # False — falsy values: 0, '', [], {}, None
bool("hi")        # True

list("abc")       # ['a', 'b', 'c']
tuple([1, 2])     # (1, 2)
set("hello")     # {'h', 'e', 'l', 'o'}

Falsy Values

Python has well-defined truthiness rules. These all evaluate to False in a boolean context:

Everything else is truthy. Prefer if items: over if len(items) > 0:.

Identity vs Equality

Two different comparisons confuse beginners coming from other languages. Use == for value equality, is for object identity (same memory location).

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b      # True — same contents
a is b      # False — different list objects
a is c      # True — c is just another name for a

id(a), id(b)  # different addresses

Type Hints (PEP 484)

Since Python 3.5, you can annotate variables, parameters, and return types. These are hints — Python ignores them at runtime, but tools like mypy, pyright, and editors like VS Code use them to catch bugs before you run your code.

Function Signatures

def greet(name: str, age: int = 0) -> str:
    return f"Hello, {name} (age {age})"

def save(user_id: int, data: dict) -> None:
    ...

Variable Annotations

count: int = 0
name: str
name = "Alice"          # annotation alone is allowed

Built-in Generics (3.9+)

You can use the built-in collection types as generic types directly — no need to from typing import List.

def total(prices: list[float]) -> float:
    return sum(prices)

def lookup(users: dict[int, str], uid: int) -> str | None:
    return users.get(uid)

The typing Module

from typing import Optional, Any, Callable, Final

MAX_RETRIES: Final[int] = 3      # cannot be reassigned (checked by mypy)

def parse(raw: str) -> Optional[int]:   # equivalent to: int | None
    ...

def run(fn: Callable[[int], str], n: int) -> str:
    return fn(n)

Running mypy

(.venv) $ pip install mypy
(.venv) $ mypy main.py
Success: no issues found in 1 source file

Common Operations and Built-ins