Variables and Types in Python

How Python's type system works

Python is dynamically typed — types are checked at runtime, not compile time. Python is also strongly typed — it will not silently coerce incompatible types. "5" + 3 raises a TypeError in Python (unlike JavaScript where it gives "53"). Every object in Python carries its type at runtime — you can always check with type() or isinstance().

Type hints (PEP 484, Python 3.5+)

Python 3.5 added optional type annotations. They are not enforced at runtime but are used by static analysis tools (mypy, pyright, Pyrefly) and IDEs. The Python interpreter completely ignores them at runtime — x: int = "hello" runs without error.

from typing import Optional, Union

# Function with type hints
def greet(name: str, times: int = 1) -> str:
    return (f"Hello, {name}! " * times).strip()

# Variable annotations
score: int = 95
label: str

# Optional — the value may be None
def find_user(id: int) -> Optional[str]:
    if id == 1: return "Priya"
    return None

# Union — one of several types (Python 3.10+ shorthand: str | int)
def process(value: Union[str, int]) -> str:
    return str(value)

# Modern syntax (3.10+)
def divide(a: float, b: float) -> float | None:
    return a / b if b != 0 else None

# Type annotations don't change runtime behaviour
x: int = "hello"    # No error at runtime!
print(type(x))      # <class 'str'>

Mutability in depth

Mutability is one of Python's most important concepts. Immutable objects (int, str, tuple, frozenset) cannot be changed after creation — what looks like "changing a string" always creates a new string. Mutable objects (list, dict, set) can be modified in-place. This matters enormously when passing objects to functions and when using objects as dictionary keys (only immutable objects are hashable and can be keys).

# Immutable — "changing" creates a new object
s = "hello"
id_before = id(s)
s = s + " world"    # new string object
print(id(s) == id_before)   # False — different object

# Mutable — modified in place
lst = [1, 2, 3]
id_before = id(lst)
lst.append(4)
print(id(lst) == id_before)  # True — same object

# Tuple vs list — same data, different mutability
point_list  = [10, 20]   # mutable
point_tuple = (10, 20)   # immutable

# Only immutable objects can be dict keys / set members
d = {(1, 2): "a point"}        # tuple key — OK
# d = {[1, 2]: "a point"}      # TypeError: list is unhashable

# Gotcha: mutable default argument
def add_item(item, lst=[]):     # DON'T do this
    lst.append(item)
    return lst
print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] — shared list!

def add_item_safe(item, lst=None):  # correct pattern
    if lst is None: lst = []
    lst.append(item)
    return lst

Names, objects, and identity

In Python, variables are names bound to objects — not boxes containing values. When you write a = b, you bind the name a to the same object that b points to. For mutable objects, this means both a and b can see mutations. is checks identity (same object), == checks equality (same value).

a = [1, 2, 3]
b = a           # b and a point to the SAME list
b.append(4)
print(a)        # [1, 2, 3, 4] — a sees the change!

c = a.copy()    # c is a new list with the same values
c.append(5)
print(a)        # [1, 2, 3, 4] — a unchanged

# Identity vs equality
x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)   # True  — same values
print(x is y)   # False — different objects

# Small int caching: CPython caches -5 to 256
a = 256; b = 256
print(a is b)   # True — same cached object
a = 257; b = 257
print(a is b)   # False — not cached (implementation detail)

Python's data model: everything is an object

In Python, every value is an instance of some class — integers, strings, functions, classes themselves, and even None. The Python data model (Python Language Reference §3) defines the abstract base for all objects: every object has an identity (id() returns the memory address in CPython), a type (type()), and a value. The id() of an object is unique and constant for its lifetime. CPython's implementation uses reference counting: each object stores how many names point to it. When the count reaches zero, the object is freed.

The type hierarchy

Python's type hierarchy (Python Language Reference §3.2): None · NotImplemented · Ellipsis → numbers (int → bool, complex, float) → sequences (immutable: str, bytes, tuple; mutable: list, bytearray) → set types (frozenset, set) → mappings (dict) → callables (functions, methods, classes) → modules → types. All types are instances of type; type itself is an instance of type (the metaclass of everything).

Integer interning and string interning

CPython interns (caches) small integers from -5 to 256 — all accesses to these integers reuse the same object. CPython also interns string literals that look like identifiers (alphanumeric, starting with letter or underscore) at compile time. This is an implementation detail of CPython, not guaranteed by the Python language specification. Code that relies on is for integers or strings is implementation-specific and may break in PyPy or other implementations.