Collections

Collections: the Python data structures you will use every day

Python ships four built-in collection types: list, tuple, dict, and set. As a TypeScript developer you already have mental models for all of them — the mapping is close, but each Python type has a distinct flavour.

Python	TypeScript	Key difference
`list`	`Array`	Mutable, ordered
`tuple`	Readonly array / `[T, U]`	Immutable, fixed-length
`dict`	`Record<K,V>` / `object` / `Map`	Mutable key-value
`set`	`Set`	Unique unordered values

list — Python’s Array

// TypeScript Array
const nums: number[] = [1, 2, 3, 4, 5];

nums.push(6);
nums.splice(0, 1);         // remove first element

console.log(nums[0]);      // 2
console.log(nums.length);  // 5

const doubled = nums.map((n) => n * 2);
const evens = nums.filter((n) => n % 2 === 0);

# Python list
nums: list[int] = [1, 2, 3, 4, 5]

nums.append(6)       # push
nums.pop(0)          # remove first element

print(nums[0])       # 2
print(len(nums))     # 5

doubled = [n * 2 for n in nums]     # list comprehension
evens = [n for n in nums if n % 2 == 0]

List comprehensions ([expr for x in iterable if condition]) are idiomatic Python — prefer them over map/filter for simple transformations.

dict — Python’s Record / Map

// TypeScript object / Record
const user: Record<string, unknown> = {
  name: "Alice",
  age: 30,
};

user["role"] = "admin";               // add key
delete user["age"];                   // remove key

console.log(user["name"]);            // Alice
console.log(user["missing"] ?? "n/a"); // n/a (nullish coalescing)

for (const [k, v] of Object.entries(user)) {
  console.log(k, v);
}

# Python dict
user: dict[str, object] = {
    "name": "Alice",
    "age": 30,
}

user["role"] = "admin"    # add key
del user["age"]           # remove key

print(user["name"])                      # Alice
print(user.get("missing", "n/a"))        # n/a (safe lookup)

for key, value in user.items():
    print(key, value)

Use .get(key, default) instead of dict[key] when the key might be absent — it returns the default instead of raising a KeyError.

set — unique values

// TypeScript Set
const tags = new Set<string>(["python", "web", "python"]);
tags.add("api");

console.log(tags.has("python"));    // true
console.log(tags.size);             // 3
tags.delete("web");

# Python set — literal syntax with {}
tags: set[str] = {"python", "web", "python"}  # duplicate removed
tags.add("api")

print("python" in tags)   # True
print(len(tags))           # 3
tags.discard("web")        # remove without error if absent

Slicing — Python’s killer feature for sequences

Python slicing lets you extract sub-sequences with [start:stop:step]. There is no direct TypeScript equivalent — .slice() exists on arrays but lacks the step parameter and negative indexing is not supported natively.

// TypeScript
const nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

console.log(nums.slice(2, 5));       // [2, 3, 4]
console.log(nums.slice(-3));         // [7, 8, 9]
// No step parameter in .slice()

# Python slicing — works on list, tuple, and str
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]   — indices 2,3,4
print(nums[-3:])      # [7, 8, 9]   — last 3
print(nums[::-1])     # reversed    — step of -1
print(nums[::2])      # [0,2,4,6,8] — every other
print(nums[1:8:2])    # [1,3,5,7]   — start:stop:step

# Strings too!
s = "Hello, World!"
print(s[:5])          # Hello
print(s[-6:])         # World!

Try it

Open in an online REPL

# list
nums = [1, 2, 3, 4, 5]
print(nums[1:4])       # [2, 3, 4]
print(nums[::-1])      # reversed
nums.append(6)
print(nums)

# list comprehension
doubled = [n * 2 for n in nums]
print(doubled)

# tuple (immutable)
point = (10, 20)
x, y = point
print(f"x={x}, y={y}")

# dict
user = {"name": "Alice", "age": 30}
user["role"] = "admin"
print(user.get("name"))
print(user.get("missing", "default"))
for k, v in user.items():
    print(f"  {k}: {v}")

# set
tags = {"python", "web", "python"}
tags.add("api")
print(tags)
print("python" in tags)

🟦 Tuples: immutable sequences with unpacking

Python tuples look like fixed-size arrays but carry a different semantic: they are immutable — you cannot append, remove, or reassign elements. TypeScript has readonly arrays and [T, U] tuple types, but they are a compiler concept. Python tuples are a runtime type with identity.

point = (10, 20)
# point[0] = 99  # TypeError: tuple object does not support item assignment

# Tuples are great for multi-value returns and dictionary keys
location = (37.7749, -122.4194)
city_map = {location: "San Francisco"}

Tuples are also the mechanism behind multiple return values and unpacking:

def divmod_custom(a: int, b: int) -> tuple[int, int]:
    return a // b, a % b   # returns a tuple

quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder)  # 3 2