What is the common pitfall with Tuples Containing Mutable Objects (Shallow Immutability)?

A tuple only guarantees that its pointers cannot be reassigned. If an element points to a mutable list, that list can still be mutated. Exam trap note: Exams love testing if `(1, [2])` can be a dictionary key. It raises TypeError because it contains an unhashable list.

What are the core concepts of Python Tuples?

Tuples represent heterogeneous records of fixed length (e.g., coordinates (x, y, z), database rows). CPython optimizes tuples: because they cannot grow, there is no over-allocation buffer, reducing memory overhead. Single-element tuples require a trailing comma: `single = (42,)`. Without the comma, `(42)` is just parenthesized integer 42.

← Previous: Python Lists (Arrays) All Modules Next: Python Sets →

MOD-10 · Sequence #10 · Python Collections

Python Tuples

Tuples are ordered, immutable sequences. Because they cannot be modified after creation, tuples have a smaller memory footprint than lists, can be hashed as dictionary keys, and support structural packing and unpacking.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

thistuple = ("apple", "banana", "cherry")
a, *rest = thistuple
print(a, rest)  # 'apple', ['banana', 'cherry']

Core Principles & Mental Models

1. Tuples as Immutable Records

Fixed Structure and Memory Efficiency

Tuples represent heterogeneous records of fixed length (e.g., coordinates (x, y, z), database rows).
CPython optimizes tuples: because they cannot grow, there is no over-allocation buffer, reducing memory overhead.
Single-element tuples require a trailing comma: `single = (42,)`. Without the comma, `(42)` is just parenthesized integer 42.

point = (10, 20, 30)
# point[0] = 15 -> TypeError: 'tuple' object does not support item assignment
print("Tuple:", point)

💡 Key Takeaway: Use tuples for data that should remain constant throughout execution.

2. Extended Unpacking (*rest)

Capturing Variable-Length Slices

Python allows capturing remaining elements into a list using the star operator: `head, *tail = iterable`.
Can be used anywhere in the pattern: `first, *middle, last = numbers`.

scores = [100, 95, 88, 72, 60]
highest, *other_scores, lowest = scores
print(f"Highest: {highest}, Lowest: {lowest}, Middle count: {len(other_scores)}")

💡 Key Takeaway: Extended unpacking simplifies extracting subsets of ordered data cleanly.

Interactive Walkthrough Examples

Tuples as Dictionary Keys (Hashability) (Basic)

Using coordinates as dictionary keys (which fails for mutable lists).

grid_lookup = {
    (0, 0): "Origin",
    (1, 0): "East",
    (0, 1): "North"
}
target = (1, 0)
print(f"Location at {target}: {grid_lookup[target]}")

Explanation: Because tuples of hashable items are immutable, they implement __hash__ and can serve as dictionary keys.

Common Misconceptions & Exam Traps

Common Pitfall: Tuples Containing Mutable Objects (Shallow Immutability)

A tuple only guarantees that its pointers cannot be reassigned. If an element points to a mutable list, that list can still be mutated.

Buggy Code

t = (1, 2, [10, 20])
t[2].append(30)  # Mutates the inner list successfully!
print("t:", t)  # (1, 2, [10, 20, 30])
# hash(t) -> TypeError: unhashable type: 'list'

Correct Solution

t = (1, 2, (10, 20))  # Use nested tuples for complete immutability
print("Hashable tuple:", hash(t))

Exam Trap Note: Exams love testing if `(1, [2])` can be a dictionary key. It raises TypeError because it contains an unhashable list.

Conceptual Knowledge Self-Check Quiz

Q1: What is the type of the expression `x = (5)` in Python?

tuple
int
generator
set

Without a trailing comma, parentheses are treated as an arithmetic grouping operator. `(5,)` is a tuple; `(5)` is an integer.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Always include the trailing comma for single-element tuples: `(val,)`.
✅ Use typing.NamedTuple or dataclasses for structured records with named fields.

← Python Lists (Arrays) Take Assessed Test → Python Sets →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.