Creating a Tuple

A tuple can be created by enclosing items in parentheses (), separated by commas:

1
empty_tuple = ()
2
numbers = (1, 2, 3, 4)
3
mixed = (1, 1.2, True, None, "hello")
4
repetition = ("ABC", "ABC", "ABC")
5
nested = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

A tuple can also be created using the tuple() constructor which takes an iterable and converts it into a tuple. If the iterable is already a tuple, it will return the same tuple.

1
chars = tuple("hello")  # ('h', 'e', 'l', 'l', 'o')
2
numbers = tuple(range(5))  # (0, 1, 2, 3, 4)

Common Sequence Operations

Tuples are sequences, which means they support common sequence operations that work with other sequence types like strings and lists. These operations include:

• Membership: Check if an element exists
• Length: Get the number of elements
• Minimum and Maximum: Find the smallest and largest elements
• Counting: Count the number of occurrences of an element
• Searching: Find the index of an element
• Indexing: Access elements by their position
• Slicing: Extract portions of the tuple
• Concatenation: Combine tuples
• Repetition: Repeat tuples

Indexing, Slicing, and Immutability

Tuples support indexing and slicing just like lists. Elements can be accessed using positive indices (starting at 0) or negative indices (counting from the end), and tuples can be sliced using the same [start:stop:step] syntax. However, the key difference is that tuples are immutable: their contents cannot be changed after creation.

1
x = (1, 2, 3, 4, 5)
2

3
print(x[0])  # 1
4
print(x[-1])  # 5
5
print(x[1:4])  # (2, 3, 4)
6
print(x[::2])  # (1, 3, 5)
7

8
x[0] = 10  # TypeError: 'tuple' object does not support item assignment

Warning

Since tuples are immutable, you cannot modify, add, or delete elements. Slicing creates a new tuple, leaving the original unchanged.

The Comma Operator and Parentheses

The comma is what actually creates a tuple, not the parentheses. Parentheses are optional in most cases, but they help with readability and are required in some contexts to avoid ambiguity.

1
# All of these create tuples
2
x = (1, 2, 3, 4, 5)
3
y = (1, 2, 3)
4
z = (1, 2)
5

6
# Parentheses are optional
7
x = 1, 2, 3, 4, 5
8
y = 1, 2, 3
9
z = 1, 2

However, for a single-element tuple, the comma is required:

1
# This creates an integer, not a tuple
2
t = (1)
3
print(type(t))  # <class 'int'>
4

5
# This creates a tuple
6
t = (1,)
7
print(type(t))  # <class 'tuple'>
8

9
# Or without parentheses
10
t = 1,
11
print(type(t))  # <class 'tuple'>

Tuple Packing and Unpacking

Tuple packing is the process of creating a tuple from values:

1
colors = ("red", "green", "purple")

Tuple unpacking (also called destructuring) is the process of extracting values from a tuple into separate variables:

1
colors = ("red", "green", "purple")
2
(primary, secondary, accent) = colors
3

4
print(primary)  # red
5
print(secondary)  # green
6
print(accent)  # purple

The number of variables must match the number of elements in the tuple, otherwise Python will raise a ValueError:

1
colors = ("red", "green", "purple")
2
(primary, secondary) = colors  # ValueError: too many values to unpack (expected 2)

1
colors = ("red", "green", "blue", "purple", "orange")
2

3
# Collect remaining elements in the middle
4
(primary, *middle, secondary) = colors
5
print(primary)  # red
6
print(middle)  # ['green', 'blue', 'purple']
7
print(secondary)  # orange
8

9
# Collect remaining elements at the end
10
(primary, secondary, *the_rest) = colors
11
print(primary)  # red
12
print(secondary)  # green
13
print(the_rest)  # ['blue', 'purple', 'orange']
14

15
# Collect remaining elements at the beginning
16
(*first, last) = colors
17
print(first)  # ['red', 'green', 'blue', 'purple']
18
print(last)  # orange

1
a = 5
2
b = 10
3

4
a, b = b, a
5

6
print(a)  # 10
7
print(b)  # 5

1
a = 5
2
b = 6
3
c = 7
4
d = 8
5

6
a, b, c, d = d, c, b, a

Looping, Membership, and Operators

Tuples support the same iteration and operator behaviors as lists: you can loop through tuples using for or while loops, check membership with in and not in, and use identity operators is and is not. The assignment operator works the same way, but since tuples are immutable, assigning a tuple to multiple variables is safe—there’s no risk of accidentally modifying one variable and affecting another.

1
fruits = ("apple", "banana", "orange")
2

3
# Looping
4
for fruit in fruits:
5
    print(fruit)
6

7
for i in range(len(fruits)):
8
    print(i, ":", fruits[i])
9

10
i = 0
11
while i < len(fruits):
12
    print(fruits[i])
13
    i += 1
14

15
# Membership
16
print("apple" in fruits)  # True
17
print("grape" not in fruits)  # True
18

19
# Assignment and identity
20
x = (1, 2, 3)
21
y = x
22
print(x is y)  # True
23
print(x == y)  # True (same values)

Notable Tuple Methods

Notable tuple methods include:

• count(e): Returns the number of occurrences of e in the tuple.
• index(value): Returns the first index of value. Raises a ValueError if the value is not found.

1
numbers = (1, 2, 3, 2, 4, 2, 5)
2

3
print(numbers.count(2))  # 3
4
print(numbers.count(10))  # 0
5

6
print(numbers.index(2))  # 1
7
print(numbers.index(4))  # 4
8
print(numbers.index(10))  # ValueError: tuple.index(x): x not in tuple

Tuple as a Sequence

Tuples are sequences, so let’s see all the sequence operations in one example:

1
x = (1, 2, 3, 4, 5)
2

3
print(x)  # (1, 2, 3, 4, 5)
4
print(len(x))  # 5
5
print(min(x))  # 1
6
print(max(x))  # 5
7
print(sum(x))  # 15
8

9
print(3 in x)  # True
10
print(10 in x)  # False
11

12
print(x.count(3))  # 1
13
print(x.index(3))  # 2
14

15
print(x[1::2])  # (2, 4)
16
print(x * 2)  # (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
17
print(x + (6, 7))  # (1, 2, 3, 4, 5, 6, 7)

Why Tuples Exist

A common question for Python developers is: Why do we have tuples if we have lists? When should we use one over the other?

Although they are similar, they are used in fundamentally different ways:

• Tuples can be thought of as similar to C-structs, where we have a collection of elements and we are operating on all of them together (point coordinates, RGB color values, etc.). They are:

  • Immutable (cannot be changed after creation)
  • Can be used as dictionary keys
  • More memory-efficient for fixed collections
  • Indicate that the data structure is meant to be fixed

• Lists are similar to arrays/vectors, where we are free to add/remove elements, and operate on each one individually. They are:

  • Mutable (can be changed after creation)
  • Cannot be used as dictionary keys
  • Better for collections that need to grow or shrink
  • Indicate that the data structure is meant to be modified

Exercises

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
print(my_tuple)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
total = 0
7
for num in my_tuple:
8
    total += num
9
print(total)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
print(sum(my_tuple))

1
size = int(input())
2
x = []
3
for i in range(size):
4
    x.append(int(input()))
5
y = []
6
for i in range(size):
7
    y.append(int(input()))
8
points = []
9
for i in range(size):
10
    points.append((x[i], y[i]))
11
print(points)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
minimum = my_tuple[0]
7
for num in my_tuple:
8
    if num < minimum:
9
        minimum = num
10
print(minimum)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
target = int(input())
7
count = 0
8
for num in my_tuple:
9
    if num == target:
10
        count += 1
11
print(count)

1
a = int(input())
2
b = int(input())
3
c = int(input())
4
d = int(input())
5
e = int(input())
6
my_tuple = (a, b, c, d, e)
7
first, *middle, last = my_tuple
8
print(first)
9
print(middle)
10
print(last)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
reversed_list = []
7
for i in range(len(my_tuple) - 1, -1, -1):
8
    reversed_list.append(my_tuple[i])
9
reversed_tuple = tuple(reversed_list)
10
print(reversed_tuple)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
target = int(input())
7
index = -1
8
for i in range(len(my_tuple)):
9
    if my_tuple[i] == target:
10
        index = i
11
        break
12
print(index)

1
size = int(input())
2
numbers = []
3
for i in range(size):
4
    numbers.append(int(input()))
5
my_tuple = tuple(numbers)
6
my_list = list(my_tuple)
7
new_element = int(input())
8
my_list.append(new_element)
9
my_tuple = tuple(my_list)
10
print(my_tuple)