Tuples

In Python, tuples are an 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) # Output: (1, 2, 36, 3, 15)
print(tuple2) # Output: ('Red', 'Yellow', 'Blue')
print(tuple3) # Output: (1, 'John', 12, 5.3)

You can also create a tuple using tuple().

For example:

numbers = tuple([1, 2, 3])
 
print(numbers)  # Output: (1, 2, 3)

This is useful when converting from lists or iterables.

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, not a tuple.

For example:

tuple1 = (1) # This is an integer.
print(type(tuple1)) # Output: <class 'int'>
 
tuple2 = (1,) # This is a tuple.
print(type(tuple2)) # Output: <class 'tuple'>

Length of Tuple

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

For example:

tuple1 = (1,2,36,3,15)
lengthOfTuple = len(tuple1)
 
print(lengthOfTuple) # Output: 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]) # Output: Orange
print(fruits[1]) # Output: Apple
print(fruits[2]) # Output: 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]) # Output: Banana
print(fruits[-2]) # Output: Apple
print(fruits[-3]) # Output: 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.

The slice includes elements from the start index up to, but not including, the end index.

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 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

👉 Next tutorial: Python Sets