Python Tuple

Python Tuple is used to store the sequence of immutable Python objects. The tuple is similar
to lists since the value of the items stored in the list can be changed, whereas the tuple is
immutable, and the value of the items stored in the tuple cannot be changed.

Creating a tuple
A tuple can be written as the collection of comma-separated (,) values enclosed with the
small () brackets. The parentheses are optional but it is good practice to use. A tuple can be
defined as follows.

T1 = (101, "Peter", 22)

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

T3 = 10,20,30,40,50

print(type(T1))

print(type(T2))

print(type(T3))

Output:

<class 'tuple'>

<class 'tuple'>

<class 'tuple'>

Note: The tuple which is created without using parentheses is also known as tuple packing.

An empty tuple can be created as follows.

T4 = ()

Creating a tuple with single element is slightly different. We will need to put comma after the element to
declare the tuple.

tup1 = ("Python")

print(type(tup1))

#Creating a tuple with single element

tup2 = ("Python ",)

print(type(tup2))
Output:

<class 'str'>

<class 'tuple'>

A tuple is indexed in the same way as the lists. The items in the tuple can be accessed by using their
specific index value.

Consider the following example of tuple:

Example - 1

tuple1 = (10, 20, 30, 40, 50, 60)

print(tuple1)

count = 0

for i in tuple1:

print("tuple1[%d] = %d"%(count, i))

count = count+1

Output:

(10, 20, 30, 40, 50, 60)

tuple1[0] = 10

tuple1[1] = 20

tuple1[2] = 30

tuple1[3] = 40

tuple1[4] = 50

tuple1[5] = 60

Example – 2

tuple1 = tuple(input("Enter the tuple elements ..."))

print(tuple1)

count = 0

for i in tuple1:

print("tuple1[%d] = %s"%(count, i))

 count = count+1

Output:

Enter the tuple elements ...123456

('1', '2', '3', '4', '5', '6')

tuple1[0] = 1

tuple1[1] = 2

tuple1[2] = 3

tuple1[3] = 4

tuple1[4] = 5

tuple1[5] = 6

A tuple is indexed in the same way as the lists. The items in the tuple can be accessed by
using their specific index value.

We will see all these aspects of tuple in this section of the tutorial.

Tuple indexing and slicing

The indexing and slicing in the tuple are similar to lists. The indexing in the tuple starts from
0 and goes to length(tuple) - 1.

The items in the tuple can be accessed by using the index [] operator. Python also allows us
to use the colon operator to access multiple items in the tuple.

Consider the following image to understand the indexing and slicing in detail.
Consider the following example:

tup = (1,2,3,4,5,6,7)

print(tup[0])

print(tup[1])

print(tup[2])

# It will give the IndexError

print(tup[8])

Output:

tuple index out of range

In the above code, the tuple has 7 elements which denote 0 to 6. We tried to access an
element outside of tuple that raised an IndexError.

tuple = (1,2,3,4,5,6,7)

#element 1 to end

print(tuple[1:])

#element 0 to 3 element

print(tuple[:4])

#element 1 to 4 element

print(tuple[1:5])

# element 0 to 6 and take step of 2

print(tuple[0:6:2])
Output:

(2, 3, 4, 5, 6, 7)

(1, 2, 3, 4)

(1, 2, 3, 4)

(1, 3, 5)

Negative Indexing
The tuple element can also access by using negative indexing. The index of -1 denotes the
rightmost element and -2 to the second last item and so on.

The elements from left to right are traversed using the negative indexing. Consider the
following example:

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

print(tuple1[-1])

print(tuple1[-4])

print(tuple1[-3:-1])

print(tuple1[:-1])

print(tuple1[-2:])

Output:

(3, 4)

(1, 2, 3, 4)

(4, 5)

Deleting Tuple
Unlike lists, the tuple items cannot be deleted by using the del keyword as tuples are
immutable. To delete an entire tuple, we can use the del keyword with the tuple name.

Consider the following example.

 tuple1 = (1, 2, 3, 4, 5, 6)

print(tuple1)

del tuple1[0]

print(tuple1)

del tuple1

print(tuple1)

Output:

(1, 2, 3, 4, 5, 6)

Traceback (most recent call last):

File "tuple.py", line 4, in <module>

print(tuple1)

NameError: name 'tuple1' is not defined

Basic Tuple operations

The operators like concatenation (+), repetition (*), Membership (in) works in the same
way as they work with the list. Consider the following table for more detail.

Let's say Tuple t = (1, 2, 3, 4, 5) and Tuple t1 = (6, 7, 8, 9) are declared.

Operator Description Example

Repetition The repetition operator enables the tuple T1*2 = (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

elements to be repeated multiple times.

Concatenation It concatenates the tuple mentioned on T1+T2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)

either side of the operator.

Membership It returns true if a particular item exists in print (2 in T1) prints True.
the tuple otherwise false
 Iteration The for loop is used to iterate over the tuple for i in T1:
elements. print(i)
Output

1
2
3
4
5

Length It is used to get the length of the tuple. len(T1) = 5

Python Tuple inbuilt functions

SN Function Description

1 cmp(tuple1, tuple2) It compares two tuples and returns true if tuple1 is greater than tuple2

otherwise false.

2 len(tuple) It calculates the length of the tuple.

3 max(tuple) It returns the maximum element of the tuple

4 min(tuple) It returns the minimum element of the tuple.

5 tuple(seq) It converts the specified sequence to the tuple.

Example
Create a Tuple:
thistuple = ("apple", "banana", "cherry")

print(thistuple)

Output

('apple', 'banana', 'cherry')

Access Tuple Items

You can access tuple items by referring to the index number, inside square brackets:

Example
Print the second item in the tuple:

thistuple = ("apple", "banana", "cherry")

print(thistuple[1])

Output

Banana

Negative Indexing
Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second last
item etc.

Example
Print the last item of the tuple:

thistuple = ("apple", "banana", "cherry")

print(thistuple[-1])

Output

Cherry
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
Return the third, fourth, and fifth item:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[2:5])

#This will return the items from position 2 to 5.

#Remember that the first item is position 0,

#and note that the item in position 5 is NOT included

Output

('cherry', 'orange', 'kiwi')

Note: The search will start at index 2 (included) and end at index 5 (not included).

Remember that the first item has index 0.

Range of Negative Indexes

Specify negative indexes if you want to start the search from the end of the tuple:

Example
This example returns the items from index -4 (included) to index -1 (excluded)

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[-4:-1])

#Negative indexing means starting from the end of the tuple.

#This example returns the items from index -4 (included) to index -1 (excluded)

#Remember that the last item has the index -1,

Output

('orange', 'kiwi', 'melon')

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
Convert the tuple into a list to be able to change it:

x = ("apple", "banana", "cherry")

y = list(x)

y[1] = "kiwi"

x = tuple(y)

print(x)

Output

("apple", "kiwi", "cherry")

Loop Through a Tuple

You can loop through the tuple items by using a for loop.

Example
Iterate through the items and print the values:

thistuple = ("apple", "banana", "cherry")

for x in thistuple:

print(x)

Output

apple

banana

cherry
Check if Item Exists
To determine if a specified item is present in a tuple use the in keyword:

Example
Check if "apple" is present in the tuple:

thistuple = ("apple", "banana", "cherry")

if "apple" in thistuple:

print("Yes, 'apple' is in the fruits tuple")

Output

Yes, 'apple' is in the fruits tuple

Add Items
Once a tuple is created, you cannot add items to it. Tuples are unchangeable.

Example
You cannot add items to a tuple:

thistuple = ("apple", "banana", "cherry")

thistuple[3] = "orange" # This will raise an error

print(thistuple)

Output

Traceback (most recent call last):

File "demo_tuple_add.py", line 2, in <module>

thistuple[3] = "orange" # This will raise an error

TypeError: 'tuple' object does not support item assignment

Join Two Tuples
To join two or more tuples you can use the + operator:

Example
Join two tuples:

tuple1 = ("a", "b" , "c")

tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2

print(tuple3)

Output

('a', 'b', 'c', 1, 2, 3)

The tuple() Constructor

It is also possible to use the tuple() constructor to make a tuple.

Example
Using the tuple() method to make a tuple:

thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets

print(thistuple)

Output

('apple', 'banana', 'cherry')

Tuple Methods
Python has two built-in methods 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
 Where use tuple?
Using tuple instead of list is used in the following scenario.

1. Using tuple instead of list gives us a clear idea that tuple data is constant and must not
be changed.

2. Tuple can simulate a dictionary without keys. Consider the following nested structure,
which can be used as a dictionary

[(101, "John", 22), (102, "Mike", 28), (103, "Dustin", 30)]

List vs. Tuple

SN List Tuple

1 The literal syntax of list is shown by the []. The literal syntax of the tuple is shown by the ().

2 The List is mutable. The tuple is immutable.

3 The List has the a variable length. The tuple has the fixed length.

4 The list provides more functionality than a The tuple provides less functionality than the list.
tuple.

5 The list is used in the scenario in which we The tuple is used in the cases where we need to store
need to store the simple collections with no
the read-only collections i.e., the value of the items
constraints where the value of the items can
be changed. cannot be changed. It can be used as the key inside

the dictionary.

6 The lists are less memory efficient than a The tuples are more memory efficient because
tuple.
of its immutability.