Shefali

Posted on Nov 26 • Originally published at shefali.dev

Mastering Tuples in Python: A Comprehensive Guide

#webdev #python #programming #beginners

Tuples are an essential data structure in Python, offering a convenient way to store ordered and immutable data collections.

In this blog, you’ll learn everything about tuples in Python, including creation, slicing, methods, and more.

Let’s jump right into it!🚀

Tuples in Python

Tuples are ordered collection of data items. In tuples, you can store multiple items in a single variable.

Tuples are immutable i.e. you can not change them after creation.

Creating Tuples

Tuples are defined using round brackets () and items are separated by commas.

A tuple can contain items of different data types.

For example:

tuple1 = (1,2,36,3,15)
tuple2 = ("Red", "Yellow", "Blue")
tuple3 = (1, "John",12, 5.3)

print(tuple1) # (1, 2, 36, 3, 15)
print(tuple2) # ('Red', 'Yellow', 'Blue')
print(tuple3) # (1, 'John', 12, 5.3)

Single-Item Tuples

To create a tuple with one item, add a comma after the item. Without a comma, Python will treat it as an integer type.

For example:

tuple1 = (1) # This is an integer.
print(type(tuple1)) # <class 'int'>

tuple2 = (1,) # This is a tuple.
print(type(tuple2)) # <class 'tuple'>

Length of Tuple

You can find the length of a tuple (number of items in a tuple) using len() function.

For example:

tuple1 = (1,2,36,3,15)
lengthOfTuple = len(tuple1)

print(lengthOfTuple) # 5

Accessing Tuple Items

You can access tuple items/elements using indexing. Each element has its unique index.

Indexing starts from 0 for the first element, 1 for the second element, and so on.

For example:

fruits = ("Orange", "Apple", "Banana")

print(fruits[0]) # Orange
print(fruits[1]) # Apple
print(fruits[2]) # Banana

You can also access elements from the end of the tuple (-1 for the last element, -2 for the second-to-last element, and so on), this is called negative indexing.

For example:

fruits = ("Orange", "Apple", "Banana")

print(fruits[-1]) # Banana 
print(fruits[-2]) # Apple
print(fruits[-3]) # Orange
# for understanding, you can consider this as fruits[len(fruits)-3]

Check if an item is present in the tuple

You can check whether an element is present in the tuple or not, using the in keyword.

Example 1:

fruits = ("Orange", "Apple", "Banana")
if "Orange" in fruits:
    print("Orange is in the tuple.")
else:
    print("Orange is not in the tuple.")

#Output: Orange is in the tuple.

Example 2:

numbers = (1, 57, 13)
if 7 in numbers:
    print("7 is in the tuple.")
else:
    print("7 is not in the tuple.")

# Output: 7 is not in the tuple.

Slicing Tuples

You can get a range of tuple items by giving start, end and jump(skip) parameters.

Syntax:

tupleName[start : end : jumpIndex]

Note: jump Index is optional.

Example 1:

# Printing elements within a particular range
numbers = (1, 57, 13, 6, 18, 54)

# using positive indexes(this will print the items starting from index 2 and ending at index 4 i.e. (5-1))
print(numbers[2:5]) 

# using negative indexes(this will print the items starting from index -5 and ending at index -3 i.e. (-2-1))
print(numbers[-5:-2])

Output:

(13, 6, 18)
(57, 13, 6)

Example 2:

When no end index is provided, the interpreter prints all the values till the end.

# Printing all elements from a given index to till the end
numbers = (1, 57, 13, 6, 18, 54)

# using positive indexes
print(numbers[2:])  

# using negative indexes
print(numbers[-5:])

Output:

(13, 6, 18, 54)
(57, 13, 6, 18, 54)

Example 3:

When no start index is provided, the interpreter prints all the values from start up to the end index provided.

# Printing all elements from start to a given index
numbers = (1, 57, 13, 6, 18, 54)

#using positive indexes
print(numbers[:4])  

#using negative indexes
print(numbers[:-2])

Output:

(1, 57, 13, 6)
(1, 57, 13, 6)

Example 4:

You can print alternate values by giving jump index.

# Printing alternate values
numbers = (1, 57, 13, 6, 18, 54)

# using positive indexes(here start and end indexes are not given and 2 is jump index.)
print(numbers[::2]) 

# using negative indexes(here start index is -2, end index is not given and 2 is jump index.)
print(numbers[-2::2])

Output:

(1, 13, 18)
(18)

Manipulating Tuples

Tuples are immutable, so items cannot be added, removed, or changed. However, you can convert a tuple to a list, modify the list, and convert it back to a tuple.

For example:

fruits = ("Apple", "Orange", "Plum", "Banana")
fruits_list = list(fruits)   # Convert to list
fruits_list.append("Guava")  # Modify the list
fruits = tuple(fruits_list)  # Convert back to tuple

print(fruits)
# Output: ('Apple', 'Orange', 'Plum', 'Banana', 'Guava')

Concatenating Tuples

You can join two tuples using the + operator.

For example:

fruits1 = ("Apple", "Orange", "Plum")
fruits2 = ("Banana", "Grapes")
fruits = fruits1+ fruits2
print(fruits)

Output:

('Apple', 'Orange', 'Plum', 'Banana', 'Grapes')

Tuple Methods

Tuple has the following built-in methods:

count()

This method returns the number of times an element appears in a tuple.

Syntax:

tuple.count(element)

For example:

tuple1 = (1, 57, 3, 6, 18, 3, 3)
count_3 = tuple1.count(3)
print(count_3)  # Output: 3

index()

This method returns the first occurrence of the given element from the tuple.

Note: This method raises a ValueError if the element is not found in the tuple.

For example:

tuple1 = (1, 57, 3, 6, 18, 54, 3)
numberIndex = tuple1.index(3)
print('Index of 3 in tuple1 is:', numberIndex)
# Output: Index of 3 in tuple1 is: 2

You can specify a start index for the search. For example:

tuple1 = (1, 57, 13, 6, 18, 54, 13)
numberIndex = tuple1.index(13, 3) # Start search at index 3
print(numberIndex)
# Output: 6

That’s all for today.

I hope it was helpful.

Thanks for reading.

I created detailed Python notes while learning the language, and they’re available for only $1! Grab them here: Download Now

For more content like this click here.

Follow me on X(Twitter) for daily web development tips.

Keep Coding!!

Top comments (8)

Bradston Henry • Nov 26 • Edited

When I used to program heavily in Swift, I LOVED tuples. I'm just really getting into Python and learning, so I'm happy my passion with tuples can be re-ignited! Thanks for sharing how they work in Python. I will be referring back to this as I work.

Side Note: It would be cool if you added why tuples can be so helpful and why devs should consider using them. I think that would add a lot of value to this guide for those unfamiliar with tuples.