Python Tuples: What They Are, How to Use Them, and Why They Matter

If you're relatively new to Python programming, you may have heard of tuples but aren't quite sure what they are or how to use them. Fortunately, tuples are relatively straightforward and can be a powerful tool for managing data in your Python programs. In this blog post, we'll explore what tuples are, how to access and update them, how to unpack them, and how to loop and join tuples.

What are Tuples?

In Python, a tuple is a collection of elements that is ordered and immutable. This means that you can't change the elements of a tuple once it's been created, and you can't add or remove elements from a tuple. Tuples are similar to lists in Python, but they have a few key differences. One of the main differences is that lists are mutable, while tuples are not. This makes tuples useful when you need to store a collection of values that should not be modified.

To create a tuple in Python, you simply enclose a comma-separated list of elements in parentheses. For example:

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

In this example, we've created a tuple called my_tuple that contains the elements 1, 2, 3, 4, and 5.

Tuple Items

Tuple Items are:

• Ordered: The items have a defined order, and the new items will be placed at the end of the list.
• Unchangeable: We cannot change, add or remove items after the tuple has been created.
• Allow duplicate values: Tuples are indexed, meaning it can have items that have the same value.

Tuple Length

To determine how many items a tuple contains, we can use Python's built-in function len(). The len function takes a tuple as an argument and returns an integer, indicating the number of items in that given tuple.

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple)) #outputs: 5

Creating a Tuple with Only One Item

Python does not recognize tuples with only one item, so to create a tuple with only one item you have to add a comma after that item. That way Python recognizes it as a tuple.

my_tuple = (1,)
print(type(my_tuple)) #outputs: <class 'tuple'>

my_tuple = (1)
print(type(my_tuple)) #outputs: <class 'int'>

Data Types

Tuple items can be of any data type, including strings, numbers, booleans, and even other collection types:

tuple_1 = (10, 8, 6, 7, 25)
tuple_2 = ("string 1", "string 2", "string 3")
tuple_3 = (True, False, True)
tuple_4 = (10, "String", True)
tuple_5 = (
    (10, 8, 6, 7, 25), 
    ("string 1", "string 2", "string 3")
)

How to Access Tuples

To access elements of a tuple in Python, you use square brackets and the index of the element you want to access. For example, to access the first element of my_tuple from the previous example, you would use:

print(my_tuple[0])

This would output 1. Note that, like lists, tuple indices start at 0.

This would output (2, 3, 4).

Negative Indexing

You can also access tuple items using negative indexing, which starts from the end of the tuple. The last item in the tuple has an index of -1, the second-to-last item has an index of -2, and so on.

Here's an example:

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

print(my_tuple[-1]) # Output: 5
print(my_tuple[-3]) # Output: 3

Range of Indexes

You can also access a range of elements in a tuple by using a colon (:) inside the square brackets. For example, to access the second through fourth elements of my_tuple, you would use:

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

print(my_tuple[1:4]) #output: (2, 3, 4)

note

The range of indexes is non-inclusive, meaning that the range will start at index 1 (included) and end at index 4 (not included).

You can leave out the start value, making the range start at the first item:

print(my_tuple[:4]) #output: (1, 2, 3, 4)

Also by leaving out the end value, the range will go on to the end of the tuple:

print(my_tuple[1:]) #output: (2, 3, 4, 5)

If you want the range to start from the end of the tuple, just specify negative indexes:

print(my_tuple[-4:-1]) #output: (2, 3, 4)

How to Update Tuples

As we mentioned earlier, tuples are immutable, which means you can't change their elements once they're created. However, you can create a new tuple with modified elements based on an existing tuple. For example:

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:2] + (6, 7, 8) + my_tuple[3:]
print(new_tuple)

In this example, we've created a new tuple called new_tuple that contains the first two elements of my_tuple, followed by the elements 6, 7, and 8, and finally the last two elements of my_tuple. The output of this code would be (1, 2, 6, 7, 8, 4, 5).

How to Unpack Tuples

Sometimes you may want to assign the elements of a tuple to individual variables. This is known as "tuple unpacking" in Python, and it can be done using a simple syntax. For example:

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a) # 1
print(b) # 2
print(c) # 3

In this example, we've assigned the elements of my_tuple to the variables a, b, and c.

note

Note that the number of variables you use to unpack the tuple must match the number of elements in the tuple.

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:

my_tuple = (1, 2, 3, 4, 5)
a, b, *c = my_tuple
print(a) # 1
print(b) # 2
print(c) # [3, 4, 5]

Loop Tuples

You can loop through the elements of a tuple in Python using a for loop. For example:

my_tuple = (1, 2, 3, 4, 5)
for element in my_tuple:
    print(element)

This would output each element of my_tuple on a separate line.

Loop through index numbers

We can also loop through the tuple items by referring to their index number. By using Python's range() and len() functions we can iterate through the tuple items by using their index numbers.

my_tuple = (1, 2, 3, 4, 5)
for i in range(len(my_tuple)):
    print(my_tuple[i]) #outputs all tuple items one by one

Using a while loop

We can also loop through the tuple items using a while loop, where we use the len() function to determine the length of the tuple, then start at index 0 and loop your way through the tuple items by referring to their indexes.

my_tuple = (1, 2, 3, 4, 5)
i = 0
while i < len(my_tuple):
    print(my_tuple[i]) #outputs all tuple items one by one
    i += 1

Warning

Remember to increase the index by 1, in this case the variable i, otherwise you will be stuck in an infinite loop.

Join Tuples

To join tuples, you can use the + operator:

tuple_1 = (1, 2, 3)
tuple_2 = ('string 1', 'string 2')

tuple_3 = tuple_1 + tuple_2
print(tuple_3) # (1, 2, 3, 'string 1', 'string 2')

Join Tuple Items

You can also join the elements of a tuple together into a single string using the join() method. For example:

my_tuple = ("apple", "banana", "cherry")
my_string = ", ".join(my_tuple)
print(my_string)

In this example, we've joined the elements of my_tuple together with commas and a space between them, and assigned the resulting string to my_string. The output of this code would be apple, banana, cherry.

Multiply Tuples

If you want to multiply the items of a tuple a given number of times, you can use the * operator:

my_tuple = (1, 2, 3, 4)
multiplied_tuple = my_tuple * 2

print(multiplied_tuple) # (1, 2, 3, 4, 1, 2, 3, 4)

Tuple Methods

Python has two built-in functions that you can use on tuples:

Method	Description
count()	Returns the number of times a specified value occurs in a tuple
index()	Searches the tuple for a specified value and returns the position of where it was found

Conclusion

Tuples may seem like a simple concept, but they can be a powerful tool in your Python programming arsenal. By understanding how to create, access, update, unpack, loop through, and join tuples, you'll be better equipped to manage and manipulate data in your Python programs. So the next time you're working on a Python project, don't forget to consider whether tuples might be the right tool for the job.