After this lesson, you will be able to:

• Create tuples, including a single-item tuple, and read their values by index.
• Unpack a fixed-size record into separate variables.
• Use tuple packing and unpacking to swap values clearly.
• Explain tuple immutability and build a replacement tuple when an item needs to change.

Tuples group ordered values, like lists, but cannot be changed in place. Parentheses make tuple literals readable; it is the comma that creates a tuple, which is why a one-item tuple needs a trailing comma: ("eu",).

Indexes work as in lists: the first value is at index 0, and -1 reads the last. When you know how many fields a record contains, unpacking assigns them all at once: name, region = record. Python raises ValueError when the number of targets does not match the number of values.

Unpacking can also swap two variables without a separate temporary variable. Unlike a list, record[0] = value raises TypeError: construct a new tuple if you need a changed record.

1. Index a fixed record

Tuple indexing uses the same positive and negative positions as list indexing.

endpoint = ("billing", "eu", 443)
print(endpoint[0])
print(endpoint[-1])

Output:

billing
443

2. The single-item comma

Parentheses alone only group an expression; a comma marks a one-item tuple.

region = ("apac",)
print(type(region).__name__)
print(len(region))

Output:

tuple
1

3. Unpack a record

Unpacking makes the fields clear without repeated index expressions.

host = ("gateway", 8080, True)
service, port, online = host
print(f"{service}:{port} online={online}")

Output:

gateway:8080 online=True

4. Swap two values through unpacking

Python packs the right-hand values and assigns them to the targets on the left.

primary = "east"
backup = "west"
primary, backup = backup, primary
print(f"Primary: {primary}")
print(f"Backup: {backup}")

Output:

Primary: west
Backup: east

1. ("eu") is a string, not a one-item tuple.
2. Unpacking three values into two variables raises ValueError.
3. Trying record[1] = "us" raises TypeError.
4. Immutability prevents reassignment of tuple elements, but not changes inside a mutable object held by a tuple. That deeper case comes later.