Python Tuples
Learn about tuples in Python - ordered, unchangeable collections of data.
Tuples
Tuples are used to store multiple items in a single variable.
Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.
A tuple is a collection which is ordered and unchangeable.
Tuples are written with round brackets.
Example
thistuple = ("apple", "banana", "cherry")
print(thistuple)Tuple Items
Tuple items are ordered, unchangeable, and allow duplicate values.
Tuple items are indexed, the first item has index [0], the second item has index [1] etc.
Ordered
When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.
Unchangeable
Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.
Allow Duplicates
Since tuples are indexed, they can have items with the same value:
Example
thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple)Tuple Length
To determine how many items a tuple has, use the len() function:
Example
thistuple = ("apple", "banana", "cherry")
print(len(thistuple))Create Tuple With One Item
To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.
Example
thistuple = ("apple",)
print(type(thistuple))
# NOT a tuple
thistuple = ("apple")
print(type(thistuple))Tuple Items - Data Types
Tuple items can be of any data type:
Example
tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)A tuple can contain different data types:
Example
tuple1 = ("abc", 34, True, 40, "male")type()
From Python's perspective, tuples are defined as objects with the data type 'tuple':
Example
mytuple = ("apple", "banana", "cherry")
print(type(mytuple))The tuple() Constructor
It is also possible to use the tuple() constructor to make a tuple.
Example
thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)Access Tuple Items
You can access tuple items by referring to the index number, inside square brackets:
Example
thistuple = ("apple", "banana", "cherry")
print(thistuple[1])Negative Indexing
Negative indexing means start from the end.
-1 refers to the last item, -2 refers to the second last item etc.
Example
thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])Range of Indexes
You can specify a range of indexes by specifying where to start and where to end the range.
When specifying a range, the return value will be a new tuple with the specified items.
Example
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])Update Tuples
Tuples are unchangeable, meaning that you cannot change, add, or remove items once the tuple is created.
But there are some workarounds.
Change Tuple Values
Once a tuple is created, you cannot change its values. Tuples are unchangeable, or immutable as it also is called.
But there is a workaround. You can convert the tuple into a list, change the list, and convert the list back into a tuple.
Example
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)Add Items
Since tuples are immutable, they do not have a built-in append() method, but there are other ways to add items to a tuple.
1. Convert into a list: Just like the workaround for changing a tuple, you can convert it into a list, add your item(s), and convert it back into a tuple.
Example
thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.append("orange")
thistuple = tuple(y)2. Add tuple to a tuple. You are allowed to add tuples to tuples, so if you want to add one item, (or many), create a new tuple with the item(s), and add it to the existing tuple:
Example
thistuple = ("apple", "banana", "cherry")
y = ("orange",)
thistuple += y
print(thistuple)Unpack Tuples
When we create a tuple, we normally assign values to it. This is called "packing" a tuple:
Example
fruits = ("apple", "banana", "cherry")But, in Python, we are also allowed to extract the values back into variables. This is called "unpacking":
Example
fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits
print(green)
print(yellow)
print(red)Note: The number of variables must match the number of values in the tuple, if not, you must use an asterisk to collect the remaining values as a list.
Using Asterisk*
If the number of variables is less than the number of values, you can add an * to the variable name and the values will be assigned to the variable as a list:
Example
fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")
(green, yellow, *red) = fruits
print(green)
print(yellow)
print(red)Why Use a Tuple Instead of a List?
- Immutable — safe to pass around; cannot be changed by accident.
- Hashable — a tuple of immutables can be a dict key or set member; a list cannot.
- Slightly faster and smaller than a list.
- Signals intent: "this group of values belongs together and won't change" (like coordinates).
point = (10, 20)
locations = {(0, 0): "origin", (10, 20): "target"} # tuple keys - OK
# {[0, 0]: "x"} # TypeError: list is unhashablePacking and Unpacking
coords = 3, 4 # packing (parentheses optional)
x, y = coords # unpacking
print(x, y) # 3 4
first, *middle, last = (1, 2, 3, 4, 5)
print(first, middle, last) # 1 [2, 3, 4] 5
# functions return multiple values as a tuple
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([4, 1, 9])
print(lo, hi) # 1 9A single-item tuple needs a trailing comma: (5,) is a tuple, (5) is just the number 5.
Try It Yourself
Exercise 1: Unpack (1, 2, 3) into a, b, c and print their sum.
Show solution
a, b, c = (1, 2, 3)
print(a + b + c) # 6Exercise 2: Create a one-element tuple containing just "solo".
Show solution
t = ("solo",)
print(type(t)) # <class 'tuple'>Key Takeaways
- Tuples are ordered and immutable.
- They can be dict keys and set members (if their contents are immutable).
- Unpack with
a, b = tup; capture the rest with*. - One-item tuple needs a trailing comma.
📘 Real-World Deep Dive
Tuples are immutable, hashable, and slightly faster than lists. They communicate "this collection is a value, not a container" — every time you see one, ask whether a <code>NamedTuple</code> or <code>dataclass</code> would clarify the code.
Real-Life Scenario
A function that returns multiple values at once: the next point, the slope between the previous point and the current one, and whether we crossed a threshold.
Real-Life Example
from typing import NamedTuple
class Segment(NamedTuple):
x0: float
y0: float
x1: float
y1: float
crossed: bool
def next_segment(prev, curr, threshold: float = 100) -> Segment:
x0, y0 = prev
x1, y1 = curr
slope = (y1 - y0) / (x1 - x0) if x1 != x0 else float("inf")
crossed = (y0 < threshold <= y1) or (y1 < threshold <= y0)
return Segment(x0, y0, x1, y1, crossed)
walk = [(0, 10), (1, 40), (2, 95), (3, 110), (4, 130)]
results = [
next_segment(walk[i - 1], walk[i])
for i in range(1, len(walk))
if next_segment(walk[i - 1], walk[i]).crossed
]
for r in results:
print(r)Expected Output
Segment(x0=2, y0=95, x1=3, y1=110, crossed=True)Common mistakes
- Tuple of one element must include a trailing comma:
x = (1,). - Tuple elements are still mutable if they are themselves mutable (lists, dicts).
- A
(a, b) = (b, a)swap works only because tuple-pack / unpack is atomic.
🚀 Performance & Best Practices
tuple(xs)is faster thantuple([...])for a known iterable.- Tuple unpacking is faster than indexing for small fixed-size records — prefer
a, b, c = xsoverxs[0], xs[1], xs[2]. - Use
NamedTuple(or@dataclass(frozen=True)) to get record-style access with low memory cost.
🧪 Try It Yourself
- Replace
Segmentwith a frozen dataclass and benchmark the difference. - Write
as_dict(s: Segment) -> dictand a reversefrom_dict(d) -> Segment. - Add a generator that yields only the crossing segments from a long walk.