Python Tuples: Ordered, Immutable Sequences in Python
Python tuples are ordered collections that cannot be changed after they are created. Use them when you want to group values together and protect that group from accidental edits. This article explains how tuples work, how to write them, how unpacking works, and the mistakes people make with immutability and single-item tuples.
Difficulty: Beginner
Helpful to know first: basic Python variables, lists, and how functions return values.
How Python Tuples Store Multiple Values
A tuple is a sequence, just like a list, which means it keeps items in order and lets you read them by position. The difference is that a tuple is immutable: once you create it, you cannot change its size or replace one of its items.
You usually write a tuple with commas. Parentheses often make the tuple easier to read, but the commas are what really matter.
point = 3, 5
print(point)
print(type(point))
# Output:
# (3, 5)
# <class 'tuple'>Here, point stores two values in a fixed order. Python creates a tuple even without parentheses because the commas define the tuple.
A tuple is a sequence type, so you can index, slice, loop over it, and check its length with len().
Writing Tuples, One Item Tuples, and Empty Tuples
Tuples have a few syntax details that cause a lot of beginner mistakes. The most important one is the single-item tuple: one value by itself is not a tuple unless you include a trailing comma.
Empty tuples
An empty tuple uses empty parentheses.
empty = ()
print(empty)
print(len(empty))
# Output:
# ()
# 0Single-item tuples
If you forget the comma, Python sees just a parenthesized value, not a tuple.
one_value = (42,)
not_a_tuple = (42)
print(type(one_value))
print(type(not_a_tuple))
# Output:
# <class 'tuple'>
# <class 'int'>The comma is the part that turns one value into a one-item tuple. This is one of the most common tuple syntax mistakes in Python.
Accessing Tuple Items by Index and Slice
Because tuples are ordered, you can read items by position with indexing. The first item is at index 0, the second at index 1, and so on.
colors = ("red", "green", "blue", "yellow")
print(colors[0])
print(colors[-1])
print(colors[1:3])
# Output:
# red
# yellow
# ('green', 'blue')Negative indexes count from the end. Slicing returns a new tuple, not a view into the old one.
Like lists, tuples raise IndexError if you ask for an index that does not exist.
numbers = (10, 20)
print(numbers[2])
# IndexError: tuple index out of rangeTuple Packing and Unpacking Make Code Clearer
Tuple packing means Python groups values into one tuple automatically. Tuple unpacking means Python splits a tuple into separate variables.
This is useful when you want to return multiple related values from a function or assign several values at once.
def get_dimensions():
return 1920, 1080
width, height = get_dimensions()
print(width)
print(height)
# Output:
# 1920
# 1080If the number of variables does not match the number of items, Python raises an error. That is a helpful signal that your data shape is not what you expected.
name, age = ("Ada", 36, "extra")
# ValueError: too many values to unpack (expected 2)Swapping values with tuples
Tuple unpacking is the standard Python way to swap two variables without a temporary variable.
left = 10
right = 20
left, right = right, left
print(left)
print(right)
# Output:
# 20
# 10Why Tuples Are Immutable and Why That Matters
Tuple immutability means the tuple object itself cannot be changed after creation. You cannot replace an item, append a new item, or remove one. That makes tuples a good fit for fixed records such as coordinates, RGB colors, and database-like rows.
Immutability does not mean every object inside the tuple is immutable. A tuple can hold mutable objects such as lists, and those objects can still change.
data = ([1, 2], "done")
data[0].append(3)
print(data)
# Output:
# ([1, 2, 3], 'done')The tuple did not change structure, but the list inside it did. This surprises many beginners who assume tuple immutability protects everything inside the tuple.
Because tuples are immutable, they can sometimes be used as dictionary keys or set members, but only if all of their items are hashable. A tuple that contains a list cannot be used as a key.
valid_key = (1, "a")
lookup = {valid_key: "stored"}
print(lookup[valid_key])
# Output:
# storedA tuple is often a better choice than a list when the data represents a fixed record and should not be resized.
Common Tuple Patterns You Will See in Real Code
Returning several values from a function
Functions in Python can return a tuple of related results. This keeps the return value compact and easy to unpack at the call site.
def split_name(full_name):
parts = full_name.split()
return parts[0], parts[-1]
first, last = split_name("Grace Hopper")
print(first)
print(last)
# Output:
# Grace
# HopperLooping over pairs
Tuples often show up in loops, especially when a function produces pairs of related data.
pairs = [("A", 1), ("B", 2), ("C", 3)]
for label, value in pairs:
print(label, value)
# Output:
# A 1
# B 2
# C 3Returning coordinates or records
Tuples are a natural way to model a fixed collection of fields such as a coordinate, a date parts tuple, or a small result record.
def get_point():
return 10, 15
x, y = get_point()
print(f"x={x}, y={y}")
# Output:
# x=10, y=15How Tuple Behavior Differs From Lists in Practice
Tuples and lists are both ordered sequences, but they serve different jobs. Lists are for data that changes. Tuples are for data that should stay fixed.
| Feature | Tuple | List |
|---|---|---|
| Mutability | Immutable | Mutable |
| Syntax | (1, 2) | [1, 2] |
| Common use | Fixed record, coordinates, unpacking | Growing or changing collection |
| Methods | Few: count(), index() | Many: append(), sort(), and more |
A tuple is not automatically faster in a way you should obsess over as a beginner. The real design reason to choose a tuple is meaning: the data is meant to stay the same.
When the program needs to add, remove, or reorder items, use a list. When the program needs a fixed set of values, use a tuple.
Predict the Output
Does this create a tuple or a plain value?
a = (7)
b = (7,)
print(type(a))
print(type(b))
What does this print?
Show answer
a is an int, not a tuple, because the parentheses are only grouping. b is a one-item tuple because of the trailing comma.
# <class 'int'>
# <class 'tuple'>What happens when you unpack a tuple in a loop?
items = [("pen", 2), ("pencil", 5)]
for name, count in items:
print(name, count)
What happens?
Show answer
Each two-item tuple is unpacked into name and count on each loop iteration.
# pen 2
# pencil 5Find the Bug
Why does this code not protect the data?
This code is trying to keep a fixed record, but one part of it can still change. Find the bug before reading the solution.
record = ("Alice", [1, 2])
record[1].append(3)
print(record)
Show answer
The bug is that the tuple contains a list. The tuple itself is immutable, but the list inside it is still mutable, so the list can change.
Fixed code: use an immutable sequence inside the tuple if you need the whole record to stay fixed.
record = ("Alice", (1, 2))
# record[1].append(3) # not possible now
print(record)
# Output:
# ('Alice', (1, 2))The corrected version works because both the outer record and the inner data are immutable tuples.
Common Mistakes With Python Tuples
Forgetting the comma in a one-item tuple
A one-item tuple needs a trailing comma. Without it, Python treats the value as a normal expression inside parentheses.
Problem: The code looks like a tuple, but value is just an integer, so later tuple operations will fail or behave differently than expected.
value = (5)
print(type(value))
Fix: Add a trailing comma when you want a one-item tuple.
value = (5,)
print(type(value))
The corrected version works because the comma tells Python to build a tuple.
Trying to change an item in place
Tuples do not support item assignment. Beginners often use a tuple where a list would be more appropriate.
Problem: The code tries to replace an item in a tuple, which raises a TypeError.
point = (1, 2)
point[0] = 10
# TypeError: 'tuple' object does not support item assignmentFix: Create a new tuple instead of trying to edit the old one.
point = (1, 2)
point = (10, point[1])
print(point)
The corrected version works because tuples are replaced as a whole, not edited item by item.
Unpacking the wrong number of values
Tuple unpacking must match the number of items on the right side. If the counts do not line up, Python stops with a ValueError.
Problem: The code expects two values, but the tuple contains three, so Python cannot assign them cleanly.
name, age = ("Maya", 20, "extra")
# ValueError: too many values to unpack (expected 2)Fix: Make the left side match the data, or use * to collect the extras when that is your intention.
name, age, note = ("Maya", 20, "extra")
print(name, age, note)
The corrected version works because each tuple item has a matching destination variable.
Using a tuple when you need a changing collection
Sometimes the code runs, but the data structure is still the wrong choice. If the collection needs to grow, shrink, or be sorted in place, a tuple makes that awkward.
Problem: The code chooses a tuple for data that needs to change later, so the first update attempt fails.
tasks = ("read", "write")
tasks.append("test")
# AttributeError: 'tuple' object has no attribute 'append'Fix: Use a list when the collection must change over time.
tasks = ["read", "write"]
tasks.append("test")
print(tasks)
The corrected version works because lists are designed for changing collections.
When to Use a Tuple, and When to Use Something Else
Use a tuple when the data is a fixed group of related values and you want that shape to stay the same. Use a list when the collection will change.
| If you need... | Use a tuple | Use something else |
|---|---|---|
| Fixed record of values | Yes | List if fields change, dictionary if values have names |
| Ordered items to read by position | Yes | List if items must be edited |
| To add or remove items | No | List |
| Named fields and clearer code | Sometimes | dict or dataclass |
Many real programs start with tuples for small fixed results and later move to a dataclass or dictionary when the values need names. That is often a readability improvement, not a correction.
Tuple versus list versus dictionary
A tuple is best when the position of each item already tells you what it means. A list is best when you are managing a collection of similar items. A dictionary is best when each value needs a name.
# Tuple: fixed order
coordinate = (12, 34)
# List: changeable collection
names = ["Ana", "Ben"]
# Dictionary: named fields
person = {"name": "Ana", "age": 20}Interview Questions About Python Tuples
Why would you use a tuple instead of a list?
Use a tuple when the values belong together and should not change. That makes the code clearer and helps prevent accidental modification.
Why does a one-item tuple need a comma?
Because Python uses the comma, not the parentheses, to decide whether something is a tuple. The parentheses are just grouping unless a comma is present.
Can a tuple contain mutable objects?
Yes. A tuple can store lists, dictionaries, or other mutable objects. The tuple still cannot change size, but the mutable objects inside it can change.
Are tuples always faster than lists?
No simple rule applies everywhere. The important difference is not speed for most beginner code. The main reason to choose a tuple is that the data should not change.
Try It Yourself
Create a tuple that stores a student's name, grade, and favorite subject. Then unpack the tuple into three variables and print a sentence using those values.
- Use a tuple, not a list.
- Store exactly three values.
- Unpack the tuple into three variables.
- Print one readable sentence.
Expected output:
Leah got 91 in biology.Hint: Put the values in one tuple first, then assign them to three variables on the left side.
Show solution
student = ("Leah", 91, "biology")
name, grade, subject = student
print(f"{name} got {grade} in {subject}.")
# Output:
# Leah got 91 in biology.Summary
- A tuple is an ordered Python sequence.
- Tuples are immutable, so you cannot change their size or replace items.
- The comma makes a tuple; parentheses alone do not.
- Use tuple unpacking to split values into separate variables.
- A tuple can contain mutable objects, but those objects can still change.
- Use tuples for fixed data, lists for changing data, and dictionaries for named data.
Next, learn about Python lists so you can see when a mutable sequence is the better choice.