Tuple Data Structure
1. Tuple is exactly same as List except that it is immutable. i.e once we creates Tuple object,we cannot perform any
changes in that object.
Hence Tuple is Read Only version of List.
2. If our data is fixed and never changes then we should go for Tuple.
3. Insertion Order is preserved
4. Duplicates are allowed
5. Heterogeneous objects are allowed.
6. We can preserve insertion order and we can differentiate duplicate objects by using index. Hence index will play
very important role in Tuple also.
Tuple support both +ve and -ve index. +ve index means forward direction(from left to right) and -ve index means
backward direction(from right to left)
7. We can represent Tuple elements within Parenthesis and with comma seperator. Parenethesis are optional but
recommended to use.
Eg: 1. t=10,20,30,40
2. print(t)
3. print(type(t))
4.
5. Output
6. (10, 20, 30, 40)
7. <class 'tuple'>
8.
9. t=()
10. print(type(t)) # tuple
Tuple creation:
1. t=()
creation of empty tuple
2. t=(10,)
t=10,
creation of single valued tuple ,parenthesis are optional,should ends with comma
3. t=10,20,30
t=(10,20,30)
creation of multi values tuples & parenthesis are optional
4. By using tuple()
function:
1. list=[10,20,30]
2. t=tuple(list)
3. print(t)
4.
5. t=tuple(range(10,20,2))
6. print(t)
Accessing elements of tuple:
We can access either by index or by slice operator
1. By using index:
1. t=(10,20,30,40,50,60)
2. print(t[0]) #10
3. print(t[-1]) #60
4. print(t[100]) IndexError: tuple index out of range
2. By using slice operator:
1. t=(10,20,30,40,50,60)
3. print(t[2:100])
5.
7. (30, 40, 50)
9. (10, 30, 50)
Tuple vs immutability:
Once we creates tuple,we cannot change its content. Hence tuple objects are immutable.
Eg:
t=(10,20,30,40)
t[1]=70 TypeError: 'tuple' object does not support item assignment
Mathematical operators for tuple:
We can apply + and * operators for tuple
1. Concatenation Operator(+):
1. t1=(10,20,30)
2. t2=(40,50,60)
3. t3=t1+t2
4. print(t3) # (10,20,30,40,50,60)
2. Multiplication operator or repetition operator(*)
1. t1=(10,20,30)
2. t2=t1*3
3. print(t2) #(10,20,30,10,20,30,10,20,30)
Important functions of Tuple:
1. len()
To return number of elements present in the tuple
Eg:
t=(10,20,30,40)
print(len(t)) #4
2. count()
To return number of occurrences of given element in the tuple
Eg:
t=(10,20,10,10,20)
print([Link](10)) #3
3. index()
returns index of first occurrence of the given element.
If the specified element is not available then we will get ValueError.
Eg:
t=(10,20,10,10,20)
print([Link](10)) #0
print([Link](30)) ValueError: [Link](x): x not in tuple
4. min() and max() functions:
These functions return min and max values according to default natural sorting order. Eg:
1. t=(40,10,30,20)
3. print(max(t)) #40
Tuple Packing and Unpacking:
We can create a tuple by packing a group of variables. Eg:
a=10 b=20 c=30 d=40
t=a,b,c,d
print(t) #(10, 20, 30, 40)
Here a,b,c,d are packed into a tuple t. This is nothing but tuple packing.
Tuple Comprehension:
Tuple Comprehension is not supported by Python.
t= ( x**2 for x in range(1,6))
Here we are not getting tuple object and we are getting generator object.
Differences between List and Tuple:
List and Tuple are exactly same except small difference: List objects are mutable where as Tuple objects are
immutable.
In both cases insertion order is preserved, duplicate objects are allowed, heterogenous objects are allowed, index and
slicing are supported.
List Tuple
1) List is a Group of Comma separeated Values 1) Tuple is a Group of Comma separeated Values
within Square Brackets and Square Brackets are within Parenthesis and Parenthesis are optional.
mandatory. Eg: t = (10, 20, 30, 40)
Eg: i = [10, 20, 30, 40] t = 10, 20, 30, 40
2) List Objects are Mutable i.e. once we creates 2) Tuple Objeccts are Immutable i.e. once we
List Object we can perform any changes in that creates Tuple Object we cannot change its
Object. content.
Eg: i[1] = 70 t[1] = 70 ValueError: tuple object does not
support item assignment.
3) If the Content is not fixed and keep on 3) If the content is fixed and never changes
changing then we should go for List. then we should go for Tuple.
4) List Objects can not used as Keys for 4) Tuple Objects can be used as Keys for
Dictionries because Keys should be Dictionries because Keys should be
Hashable and Immutable. Hashable and Immutable.