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

// 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

# 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

// 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

# 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

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

Python

# 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

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

Python

# 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]

f-strings and t-strings

An f-string interpolates immediately and hands you a finished str. Python 3.14 adds the t-string (PEP 750): same syntax with a t prefix, but it evaluates to a Template object that keeps the literal parts and the interpolated values apart. TypeScript has had exactly this split for years — a plain template literal versus a tagged template.

TypeScript

// TypeScript
const name = "O'Brien";

// Template literal — one finished string
const msg = `Hello, ${name}`;

// Tagged template — the tag sees the pieces
function sql(strings: TemplateStringsArray, ...values: unknown[]) {
  return { text: strings.join("?"), values };
}
const query = sql`SELECT * FROM users WHERE name = ${name}`;

Python

# Python 3.14
name = "O'Brien"

# f-string — one finished string
msg = f"Hello, {name}"

# t-string — a Template, not a str
query = t"SELECT * FROM users WHERE name = {name}"
print(type(query).__name__)   # Template
print(query.strings)          # ('SELECT * FROM users WHERE name = ', '')
print([i.value for i in query.interpolations])   # ["O'Brien"]

Why it matters is the same reason tagged templates matter in TypeScript: an f-string glues the value into the text, so a quote inside name becomes SQL injection. A t-string hands the library the static text and the values separately, so it can bind them as parameters. Rule of thumb: f-string for messages you print, t-string for anything a parser downstream will read — SQL, HTML, shell.

Try it

Run ▸ 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.

Which statement correctly declares a constant in Python by convention?

const MAX_SIZE = 100 final MAX_SIZE: int = 100 MAX_SIZE: int = 100 let MAX_SIZE = 100

What does Python use instead of the `let` keyword to declare a variable?

The `var` keyword The `def` keyword Nothing — assignment creates the variable The `new` keyword

What is the Python naming convention for regular variables?

camelCase PascalCase UPPER_SNAKE_CASE snake_case

After `x: int = 5`, you write `x = "hello"`. What happens at runtime?

Python raises a TypeError Python silently reassigns x to the string Python raises a SyntaxError The type hint prevents the reassignment

Submit

Mark as complete