Variables & Types

Variables: familiar concept, different rules

In TypeScript you declare a variable with let or const and optionally annotate its type. The TypeScript compiler enforces that type throughout the variable’s life. In Python you just write the name and assign — no keyword, no compiler. The variable simply exists from that line forward, and its type is whatever you assigned.

The key difference: TypeScript’s type system lives at compile time (and disappears at runtime). Python’s optional type hints are just annotations — the interpreter does not enforce them, and third-party tools like mypy do the checking separately.

Declaring variables

// TypeScript
let age: number = 30;
let name: string = "Alice";
const PI: number = 3.14159;
let isActive: boolean = true;

// Inferred type — TS figures it out
let score = 100;  // inferred as number

# Python
age: int = 30
name: str = "Alice"
PI: float = 3.14159
is_active: bool = True

# No annotation needed — works the same
score = 100  # Python infers nothing; it is just an int

Notice the style differences:

No let or const keyword — the assignment IS the declaration.
snake_case for variable names (not camelCase).
True / False are capitalized (not lowercase like JS/TS).

Constants by convention: UPPER_CASE

Python has no const keyword. The community convention is to name constants in UPPER_SNAKE_CASE. Nothing stops you from reassigning them — it is purely a signal to other developers.

// TypeScript — enforced at compile time
const MAX_RETRIES: number = 3;
const API_BASE = "https://api.example.com";

// MAX_RETRIES = 5;  // TS error: cannot assign to const

# Python — convention only, NOT enforced
MAX_RETRIES: int = 3
API_BASE: str = "https://api.example.com"

# Technically legal (but don't do this):
# MAX_RETRIES = 5  # no error, just bad style

Dynamic typing in action

Python variables are not locked to their initial type. A variable is just a name pointing to an object — you can rebind it to any type at any time. TypeScript will refuse this at compile time; Python will not.

// TypeScript
let value: string | number = "hello";
value = 42;   // OK — union type
// value = true; // Error — not in the union

# Python
value = "hello"
print(type(value))   # <class 'str'>

value = 42
print(type(value))   # <class 'int'>

value = [1, 2, 3]
print(type(value))   # <class 'list'>

Multiple assignment

Python lets you unpack multiple values in a single line — a pattern TypeScript developers recognise from array destructuring.

// TypeScript destructuring
const [x, y, z] = [1, 2, 3];
const { name, age } = { name: "Alice", age: 30 };

# Python tuple unpacking
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# Works with any iterable
first, *rest = [10, 20, 30, 40]
print(first, rest)  # 10 [20, 30, 40]

Try it

Open in an online REPL

# Experiment with Python variables
age: int = 30
name: str = "Alice"
PI: float = 3.14159
is_active: bool = True

print(f"name={name}, age={age}, PI={PI}, is_active={is_active}")

# Dynamic reassignment — Python allows this
age = "thirty"
print(f"age is now: {age} (type: {type(age).__name__})")

# Multiple assignment
x, y, z = 1, 2, 3
print(f"x={x}, y={y}, z={z}")

# Star unpacking
first, *rest = [10, 20, 30, 40]
print(f"first={first}, rest={rest}")

🟦 Type hints are optional and not enforced at runtime

In TypeScript, types are a compile-time guarantee — the compiler rejects type mismatches before your code ever runs.

In Python, type hints like name: str = "Alice" are documentation for humans and tools — the Python interpreter itself ignores them completely at runtime. You can pass an int to a function annotated as str and Python will not complain.

For static analysis (the equivalent of TypeScript’s compiler), run mypy or pyright separately:

pip install mypy
mypy your_script.py

Modern editors (VS Code with Pylance, PyCharm) run this analysis automatically as you type.