Tuples

A tuple is a sequence with fixed positions

Python documents tuples as immutable sequences. A tuple holds zero or more object references in an order, so its elements have positions beginning at index 0. That makes familiar sequence operations meaningful: point[0] reads the first value, and a for loop can visit values in order. Immutability means the tuple does not support replacing, inserting, or deleting one of those positions after it is made. Thus point[0] = 7 raises TypeError when point is a tuple. This is a property of the tuple container, not a promise that every object reachable through it is immutable. A tuple can contain an object whose own state can change; the tuple still keeps the same reference at that position. For a foundations lesson, the useful rule is precise: you cannot assign to a tuple slot.

That rule also helps interpret error messages. Python is not saying that the expression 7 is forbidden or that the first position cannot be read. It is rejecting an operation that would replace the object reference stored at position 0. Reading point[0] remains valid, and constructing a separate tuple with another first value remains valid. Keeping read, construction, mutation, and assignment as distinct actions is a practical way to reason about code.

Immutability is not the same as making a name permanent. Python names can be rebound. After point = (4, 9), writing point = (7, 9) makes point refer to a different tuple; it does not edit the earlier tuple. This distinction matters when reading code. One operation tries to mutate an existing object's position and fails; the other changes what a name refers to and is ordinary assignment.

Commas make tuples; parentheses clarify grouping

A comma is the essential syntactic feature for a tuple display. These two statements make equivalent two-item tuples: point = 4, 9 and point = (4, 9). Parentheses are common because they make a display readable and remove ambiguity inside a larger expression, but parentheses alone are only grouping: (4) evaluates to the integer 4, not a tuple. The empty tuple is the special display ().

The one-item case exposes the rule most clearly. ('north') is a parenthesized string expression. ('north',) is a tuple containing one string. The trailing comma is therefore required for a singleton tuple, whether or not parentheses are written: single = 'north', also works. The official tutorial calls out both the empty and one-item cases because their syntax differs from the usual multi-item pattern. Knowing this rule is more dependable than guessing from whether parentheses appear in printed output.

Packing and unpacking connect values and names

Tuple packing is the act of placing comma-separated expressions together. In coordinates = 4, 9, the right-hand side evaluates to a two-item tuple and is bound to coordinates. Sequence unpacking goes in the other direction: x, y = coordinates assigns the first item to x and the second to y. The pattern on the left has to match the number of values supplied in this basic form. A two-name target cannot unpack a three-item tuple, and Python raises ValueError rather than silently discarding a value.

The order is part of the meaning: in x, y = coordinates, the first target receives the first sequence item. Swapping the target names changes which name receives which value, even though the tuple itself stays unchanged. This makes unpacking concise, but programmers should choose target names that reflect each position's intended meaning.

Unpacking is useful because it gives meaningful names to a tuple's positions at the point where those names are needed. For example, row, column = (2, 5) makes later calculations easier to read than repeatedly using indexes. This lesson keeps unpacking focused on direct assignment. Function parameter collection and returned values are related language features, but they belong in their own lessons. Likewise, tuples can be compared with other collection types, but this lesson concentrates on tuple construction, fixed positions, and direct unpacking.