Python Tuple
Holding Fixed Groups: Understanding Tuples in Python
In the previous article, we learned about Lists, which are great for storing ordered collections of items that can change. But sometimes, you need an ordered collection where the items should not be changed after you create it.
Think about situations where you need to store a fixed pair of coordinates (like X, Y), a color code (Red, Green, Blue values), or the details of a record that should stay constant once set. While you could use a list, Python offers another type specifically for ordered, unchangeable collections: the Tuple.
What is a Tuple?
A Tuple is a type of object in Python that holds an ordered collection of items, similar to a list. However, the key difference is that tuples are immutable.
Here are the main characteristics of tuples:
- Ordered: Items have a specific position (index), just like lists.
- Unchangeable (Immutable): You cannot add, remove, or change items after the tuple is created.
- Allows duplicate members.
- Can hold items of different data types.
Tuples are written using parentheses () instead of square brackets [].
# A tuple storing coordinates (X, Y) - these should ideally not change
coordinates = (10, 20)
# A tuple storing RGB color values
rgb_color = (255, 0, 100)
# A tuple can hold mixed types
player_info = ("Alice", 500, True)
# An empty tuple
empty_tuple = ()
When you create a tuple, Python creates a tuple object in memory, and your variable name points to that immutable object.
Creating Tuples
Tuples are usually created using parentheses ().
Creating an Empty Tuple
my_settings = ()
another_empty_tuple = tuple() # Using the tuple() function
Creating a Tuple with Initial Items
Put the items inside the parentheses, separated by commas.
game_over_coords = (100, 200)
level_bounds = (0, 1000)
Creating a Single-Item Tuple (Important!)
This is a common point of confusion. To create a tuple with only one item, you must include a comma after the item, even if there are no parentheses around it. If you don't add the comma, Python sees it just as the item itself, not a tuple.
# This is NOT a tuple, it's just the number 5
not_a_tuple = (5)
print(type(not_a_tuple)) # Output: <class 'int'>
# This IS a tuple with one item because of the comma
single_item_tuple = (5,)
print(type(single_item_tuple)) # Output: <class 'tuple'>
# Parentheses are optional if you use the comma
another_single_tuple = 10,
print(type(another_single_tuple)) # Output: <class 'tuple'>
For clarity, it's generally best to always use parentheses () when creating tuples, especially for single-item ones (item,).
Accessing Tuple Items (Indexing)
Tuples are ordered, so you can access individual items using their position number, called an index. Just like lists and strings, indexing starts from 0.
You access an item using square brackets [] with the index number after the tuple variable name.
player_record = ("Bob", 750, False)
# Indices: 0 1 2
name = player_record[0]
print(name) # Output: Bob
score = player_record[1]
print(score) # Output: 750
You can also use negative indexing to count from the end. The last item is at index -1.
my_tuple = (10, 20, 30, 40)
last_item = my_tuple[-1]
print(last_item) # Output: 40
Trying to access an index that doesn't exist will give an IndexError.
Slicing Tuples (Getting Parts of a Tuple)
You can get a portion (a slice) of a tuple using slicing, just like with lists and strings. Slicing a tuple always creates a new tuple object; it does not change the original tuple.
The syntax is tuple_name[start:stop:step].
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# Get items from index 2 up to (not including) index 5
slice1 = numbers[2:5]
print(slice1) # Output: (2, 3, 4) (This is a new tuple)
# Get every second item from the beginning
slice_with_step = numbers[::2]
print(slice_with_step) # Output: (0, 2, 4, 6, 8) (This is a new tuple)
# Using a step of -1 gets a reversed copy (as a new tuple)
reversed_tuple = numbers[::-1]
print(reversed_tuple) # Output: (9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
Slicing creates a new tuple object, even if it contains the same values or is a slice of the whole tuple (my_tuple[:]).
Tuple Operations (Creating New Tuples)
You can use some operators like + and * with tuples, but remember these operations create new tuples; they don't change the original tuple.
-
Concatenation (
+): Joins two or more tuples together to create a new tuple.tuple1 = (1, 2) tuple2 = (3, 4) combined_tuple = tuple1 + tuple2 # Creates a new tuple (1, 2, 3, 4) print(combined_tuple) # Output: (1, 2, 3, 4) print(tuple1) # Output: (1, 2) (Original tuple is unchanged) -
Repetition (
*): Repeats the items in a tuple a certain number of times to create a new tuple.my_tuple = (0,) repeated_tuple = my_tuple * 5 # Creates a new tuple (0, 0, 0, 0, 0) print(repeated_tuple) # Output: (0, 0, 0, 0, 0)
Tuple Methods
Tuples have a small number of built-in methods. Because tuples are immutable, their methods do not change the tuple; they only provide information about it.
-
.count(value): Returns the number of times a specificvalueappears in the tuple.my_tuple = (1, 2, 2, 3, 1, 2) print(my_tuple.count(2)) # Output: 3 (the value 2 appears 3 times) print(my_tuple.count(5)) # Output: 0 (the value 5 does not appear) -
.index(value): Returns the index of the first time a specificvalueappears in the tuple.my_tuple = (1, 2, 2, 3, 1, 2) print(my_tuple.index(2)) # Output: 1 (the first 2 is at index 1) print(my_tuple.index(3)) # Output: 3 (the first 3 is at index 3) # print(my_tuple.index(5)) # This would cause a ValueError
Getting the Number of Items (len())
Use the built-in len() function to find out how many items are in a tuple.
my_tuple = (10, 20, 30)
print(len(my_tuple)) # Output: 3
empty_tuple = ()
print(len(empty_tuple)) # Output: 0
Checking if an Item Exists (in Operator)
Use the in operator to check if a specific value is present in a tuple. Returns True or False.
settings = ("easy", "medium", "hard")
print("medium" in settings) # Output: True
print("expert" in settings) # Output: False
Iterating Through a Tuple (for Loop)
Like other ordered collections (lists, strings), you can easily go through each item in a tuple using a for loop.
rgb_color = (255, 128, 0)
print("RGB components:")
for color_value in rgb_color:
print(color_value)
# Output:
# RGB components:
# 255
# 128
# 0
You can use enumerate() with tuples too, just like with lists, if you need both the index and the item.
Why Tuples Are Immutable (And What You Cannot Do)
The defining feature of tuples is their immutability. Once a tuple object is created, you cannot change its contents. This means:
- You cannot change an item at a specific index using assignment.
my_tuple = (1, 2, 3) # my_tuple[0] = 5 # This would cause a TypeError! # TypeError: 'tuple' object does not support item assignment - You cannot add items (tuples have no
.append()or.insert()methods). - You cannot remove items (tuples have no
.remove()or.pop()methods, anddelcan delete the whole tuple variable, but not just an item inside it usingdel my_tuple[0]). - You cannot reorder items in place (tuples have no
.sort()or.reverse()methods).
If you need a collection that can change, you should use a List instead. If you need to "change" a tuple, you actually have to create a new tuple based on the old one's contents, perhaps with some modifications.
my_tuple = (1, 2, 3)
# To "add" an item, you create a new tuple
new_tuple = my_tuple + (4,) # Creates a new tuple (1, 2, 3, 4)
print(new_tuple) # Output: (1, 2, 3, 4)
When to Use Tuples
Use tuples when:
- You have a collection of items that logically belong together but should not be changed during the program's execution (like coordinates, configuration settings, database records).
- You want to return multiple values from a function. Python functions often return multiple values bundled as a tuple.
- You need to use the collection as a key in a dictionary or an item in a set. Because tuples are immutable, they can be used in these situations (lists, being mutable, cannot be dictionary keys or set items).
Tuple Packing and Unpacking
A very common and useful feature of tuples is packing and unpacking.
-
Packing: This happens automatically when you group values together, often using commas.
# This automatically creates a tuple (3, 4) and the name 'coords' points to it coords = 3, 4 print(type(coords)) # Output: <class 'tuple'> -
Unpacking: This is when you assign items from a tuple (or any sequence) to multiple variable names on the left side of the assignment operator (
=). The number of variable names must match the number of items in the tuple.player_data = ("Bob", 750, True) # A tuple # Unpack the tuple into three separate variables name, score, is_online = player_data print(name) # Output: Bob print(score) # Output: 750 print(is_online) # Output: TrueUnpacking is great for easily assigning multiple values returned by a function. We saw a simple form of unpacking when swapping variables on one line:
a, b = b, ais really unpacking the tuple(b, a)into the namesaandb.
Type Annotations for Tuples
For type hinting, you use the Tuple type from the typing module.
-
For tuples with items of the same type but of variable length, use
Tuple[ItemType, ...]. The...means "zero or more items of this type".from typing import Tuple rgb_values: Tuple[int, ...] = (255, 128, 0) # Tuple of integers, any length -
For tuples with a fixed number of items of potentially different types, list the types inside the
[].from typing import Tuple player_record: Tuple[str, int, bool] = ("Bob", 750, True) # Fixed length, specific types coordinate: Tuple[float, float] = (10.5, 20.1)
This fixed-length tuple hint is useful for clearly defining the structure of simple records.
Going Deeper: Tuples and Abstract Base Classes
Like lists, tuples implement standard interfaces defined by Abstract Base Classes (ABCs) in collections.abc. This defines what operations tuples support.
-
Tuples are
Sequences: They implement theSequenceABC. This means they support operations common to all ordered collections (like lists, strings, ranges):- Indexing (
my_tuple[index]). - Slicing (
my_tuple[start:stop]). - Checking length (
len(my_tuple)). - Checking membership (
item in my_tuple). - Iteration (
for item in my_tuple:).
- Indexing (
-
Tuples are NOT
MutableSequences: They do not implement theMutableSequenceABC. This confirms that they do not support operations that change the collection in place (like.append(),.remove(), assigning to an index, etc.).
You can verify this using isinstance():
import collections.abc
my_tuple = (1, 2, 3)
print(isinstance(my_tuple, collections.abc.Sequence)) # Output: True (It's an ordered collection)
print(isinstance(my_tuple, collections.abc.MutableSequence)) # Output: False (It cannot be changed in place)
Understanding these ABCs helps solidify why tuples have the behaviors they do – they fulfill the "contract" of an ordered sequence but not the contract of a sequence that can be modified.
Conclusion
Tuples are another essential collection type in Python, used for ordered groups of items. Their key difference from lists is that they are immutable – they cannot be changed after creation.
Key things you learned about tuples:
- They are ordered and immutable collections.
- You create them using parentheses
()(remember the comma,for single-item tuples!). - You access individual items using indices (
[]) and parts using slicing ([:]). - Operations like
+and*, and slicing, create new tuple objects. - They have methods like
.count()and.index(). - You check length with
len()and membership within. - They are easily processed using a
forloop. - You cannot change items in place, add, or remove items after creation.
- Tuple packing and unpacking are common and useful features.
- You can use generic type hints (
Tuple[...]) for clarity. - Tuples implement the
SequenceABC but not theMutableSequenceABC.
Use tuples when you need ordered data that should remain constant. They provide a guarantee that the collection won't be accidentally changed.