TUPLE- DATA Type :
Tuple is used to represent a set of homogeneous or heterogeneous elements
into a single entity.
Tuple objects are immutable that means once if we create a tuple object
later we cannot modify those tuple elements.
All elements are separated by commas (,) and enclosed by parentheses.
Parentheses are optional. ()
Tuple allows duplicate elements.
Every element in the tuple has its own index number
Tuple supports both forward indexing and also backward indexing, forward
indexing starts from 0 and backward indexing starts from -1.
If we take only one element in the tuple then we should use comma (,) after
that single element.
t = (10,) --->> tuple type
t1 = (10) --->> int type
Tuples can be used as keys to the dictionary.
We can create a tuple in different ways, like with tuple(), with () or without ()
also.
The main difference between lists and tuples is- Lists are enclosed in square
brackets like [] and their elements and size can be changed, while tuples are
enclosed in parentheses like () and their elements and size cannot be
updated.
Creating a tuple with tuple() :
>>> tup = tuple([10,20,30,True,'Python'])
>>> print(tup) (10, 20, 30, True, 'Python')
>>> type(tup) <class 'tuple'>
>>> id(tup) 52059760
Creating an empty tuple:
Example:
>>> tup = () #creating empty tuple
>>> print(tup) ()
>>> type(tup) <class 'tuple'>
>>> id(tup) 23134256
Creating a tuple with ()
Example:
>>> tup2 = (10,20,30,40,50) #creating homogeneous tuple
>>> print(tup2) (10, 20, 30, 40, 50)
>>> type(tup2) <class 'tuple'>
>>> id(tup2) 63484864
Creating a tuple without ()
Example:
>>> tup = 10,20,True,'Py' #creating tuple without parenthesis
>>> print(tup) (10, 20, True, 'Py')
>>> type(tup) <class 'tuple'>
>>> id(tup) 67086688
Creating a tuple with heterogeneous elements
Example:
>>> tup1 = (10,20,30,True,"Python",10.5,3+5j) #creating heterogeneous tuple
>>> print(tup1)
(10, 20, 30, True, 'Python', 10.5, (3+5j))
Creating a tuple with homogeneous elements
Example:
>>> t = (10,20,30,40) # creating homogeneous tuple
>>> print(t) # (10,20,30,40)
NOTE : tuple with Single value
Creating a tuple with a single element is tricky, if we take only one element
then the type of that tuple will be based on specified element type.
>>> t2 = (1)
>>> t2 1
>>> type(t2) <type 'int'>
>>> t2 = (True)
>>> print(t2) True
>>> type(t2) <type 'bool'>
>>> t2 = ('a')
>>> print(t2) 'a'
>>> type(t2) <type 'str'>
Solution :
So to solve the above problem we should use comma (,) after the element in the
tuple if tuple contains single element.
For example:
>>> t2=(1,)
>>> print(t2) (1,)
>>> type(t2) <type 'tuple'>
>>> t2=(False,)
>>> print(t2) (False,)
>>> type(t2) <type 'tuple'>
>>> t2 = ('a')
>>> print(t2) ('a',)
>>> type(t2) <type 'tuple'>
Tuple Indexing:
Tuple indexing is nothing but fetching a specific element from the existing tuple by
using its index value.
Tuple Slicing:
Tuple slicing is nothing but fetching a sequence of elements from the existing tuple
by using their index values.
Example:
>>>tup = (10,20,30,True,"Python",10.5,3+5j,10)
>>> print(tup) # (10, 20, 30, True, 'Python', 10.5, (3+5j), 10)
>>> type(tup) # <class 'tuple'>
0 1 2 3 4 5 6 7
tup = ( 10, 20, 30, True, "Python", 10.5, 3+5j, 10 )
-8 -7 -6 -5 -4 -3 -2 -1
>>> tup[0:4] (10, 20, 30, True)
>>> tup[0:0] ()
>>> tup[0:1] (10,)
>>> tup[0:5] (10, 20, 30, True, 'Python')
>>> tup[3:5] (True, 'Python')
>>> tup[2:-2] (30, True, 'Python', 10.5)
>>> tup[-5:-2] (True, 'Python', 10.5)
>>> tup[-5:] (True, 'Python', 10.5, (3+5j), 10)
>>> tup[6:] ((3+5j), 10)
Tuple concatenation :
We can concatenate two or more tuples in python.
Example:
>>> tup1=(1,2,3,'a',True) #creating first tuple tup1
>>> print(tup1) (1, 2, 3, 'a', True)
>>> type(tup) <class 'tuple'>
>>> tup2=(10,20,False,'b') #creating second tuple tup2
>> print(tup2) (10, 20, False, 'b')
>>> type(tup2) <class 'tuple'>
>>> tup3 = tup1+tup2 #concatenating tup1 and tup2 as tup3
>>> print(tup3) (1, 2, 3, 'a', True, 10, 20, False, 'b')
>>> type(tup3) <class 'tuple'>
Tuple multiplication or repetition :
We can multiply or repeat a tuple n number of times.
>>> tup1=(1,2,3,'a',True)
>>> print(tup1) (1, 2, 3, 'a', True)
>>> type(tup1) <class 'tuple'>
>>> tup1*3
(1, 2, 3, 'a', True, 1, 2, 3, 'a', True, 1, 2, 3, 'a', True)
Tuple Data type Methods :
1. len():
This function returns no.of elements in the tuple.
>>> tup = (1,2,3,4,'a',5.5)
>>> len(tup) 6
2. count():
This function counts the number of occurences of a specific elements.
This function takes exactly one argument like element.
Example:
>>> tup = (1,10,20,True,0)
>>> tup.count(1) 2
>>> tup.count(0) 1
3. index(object, index_value,end_index):
This function is used to find the index value of specific|given element.
This function returns by default first occurence of given element index_value.
It is also accepts the second parameter as index value, it is used for from
where you want search the given index. By default index_value starts from
zero.
Example:
>>> tup=(1,10,20,True,0)
>>> tup.index(0) 4
>>> tup.index(10) 1
>>> tup.index(20) 2
4. max():
This function returns maximum value from the tuple elements.
Example:
>>> tup=(1,3,2,55,3,5,23)
>>> max(tup) 55
5. min():
This function returns minimum value from the tuple elements.
Example:
>>> tup=(1,3,2,55,3,5,23)
>>> min(tup) 1
6. sum():
this function returns sum of all the elements.
Example:
>>> tup=[1,9,5,11,2]
>>> sum(tup) 28
7. sorted(object):
sorted() is going to take the elements from given object and arranging all the
elements by default in a assending order.
after arranging all the elements in assending order then resoult store in a
new variable.
sorted() method is not doing any changes in a original object and the result
store in a new object.
sorted() method returns result in a list format by defalt.
if you want to get in tuple format then use tuple() method
Example:
>>> tup = (1,3,2,55,3,5,23)
>>> sorted(tup) [1, 2, 3, 3, 5, 23, 55]
Note: by default this function sorts the data in ascending order. We can also get in
descending order by setting True for reverse.
Example:
>>> tup=(1,3,2,55,3,5,23)
>>> sorted(tup,reverse=True) [55, 23, 5, 3, 3, 2, 1]
Or
>>> t1 = tuple([1,2,3,7,4])
>>> t1 (1, 2, 3, 7, 4)
>>> t2 = reversed(t1)
>>> tuple(t2) (4, 7, 3, 2, 1)
8. reversed():
reversed() is going to take the elements from given object and arranging all
the elements by default in a reversing order.
after arranging all the elements in reversing order then resoult store in a
new variable.
reversed() method is not doing any changes in a original object and the result
store in a new object.
reversed() method returns result in a <reversed object at 0x03EFFC30>
format by defalt. Internally elements are reversed.
if you want to get in tuple format then use tuple() method
>>> t = (10, 40, 60, 20)
>>> t2 = reversed(t)
>>> t2
<reversed object at 0x03EFFC30>
>>> tuple(t2) # (20, 60, 40, 10)
Note:
tuple object is not supporting both sort() and reverse() and copy() and clear()
also.
>>> t = (10, 40, 60, 20)
>>> t2 = sort(t)
NameError: name 'sort' is not defined
>>> t3 = reverse(t)
NameError: name 'reverse' is not defined
>>> t = (10, 40, 60, 20)
>>> id(t) # 65890704
>>> t2 = t
>>> print(t2) # (10, 40, 60, 20)
>>> id(t8) # 65890704
>>> t2 = t.copy()
AttributeError: 'tuple' object has no attribute 'copy'
DEL Command :
We cannot delete the elements of existing tuple but we can delete the entire tuple
object by using del command.
Example:
>>> tup = (10,20,"Python",1.3)
>>> print(tup) # (10, 20, 'Python', 1.3)
>>> type(tup) # <class 'tuple'>
>>> del tup # deleting tuple by using del command.
>>> print(tup) # after deleting
NameError: name 'tup' is not defined
We can replace the elements of list but not tuple, like
>>> lst=[10,20,30,'Py',True]
>>> lst[4]=False # it is possible in list
>>> print(lst) [10, 20, 30, 'Py', False]
>>> tup = (10,20,30,'Py',True)
>>> tup[4]=False # it is not possible in tuple
TypeError: 'tuple' object does not support item assignment
Tuple packing:
We can create a tuple by using existing variables, so its called tuple packing.
>>> a=10
>>> b=20
>>> c='Python'
>>> d=2+5j
>>> tup=(a,b,c,d)
>>> print(tup) (10, 20, 'Python', (2+5j))
>>> type(tup) <class 'tuple'>
>>> id(tup) 62673808
Tuple Unpacking
Tuple unpacking allows to extract tuple elements automatically.
Tuple unpacking is the list of variables on the left has the same number of
elements as the length of the tuple
>>> tup=(1,2,3,4)
>>> a,b,c,d=tup # tuple unpacking
>>> print(a) 1
>>> print(b) 2
>>> print(c) 3
>>> print(d) 4
Nested tuple:
Python supports nested tuple, means a tuple in another tuple.
Tuple allows list as its element.
Example:
>>> t1=(1,'a',True)
>>> print(t1) (1, 'a', True)
>>> type(t1) <class 'tuple'>
>>> t2=(10,'b',False)
>>> print(t2) (10, 'b', False)
>>> type(t2) <class 'tuple'>
>>> t3=(t1,100,'Python',t2) # creating a tuple with existing tuples t1 and t2
>>> print(t3) ((1, 'a', True), 100, 'Python', (10, 'b', False))
>>> type(t3) <class 'tuple'>
>>> print(t3[0]) (1, 'a', True)
>>> print(t3[1]) 100
>>> print(t3[2]) Python
>>> print(t3[3]) (10, 'b', False)
>>> print(t3[3][0]) 10
>>> print(t3[3][1]) b
>>> print(t3[3][2]) False
>>> print(t3[0][0]) 1
>>> print(t3[0][1]) a
>>> print(t3[0][2]) True
>>> t3[0:2] ((1, 'a', True), 100)
>>> t3[2:4] ('Python', (10, 'b', False))
>>> t3[-2:4] ('Python', (10, 'b', False))
Note:
We can’t modify any element of the above tuples because tuples are
immutable.
If the tuple contains a list as a element then we can modify the elements of
the list as it a mutable object.
Example:
>>> tup = (1,2,[10,12,'a'],(100,200,300),3,'Srinivas')
>>> print(tup) # (1, 2, [10, 12, 'a'], (100, 200, 300), 3, 'Srinivas')
>>> tup[0] 1
>>> tup[1] 2
>>> tup[2] [10, 12, 'a']
>>> tup[3] (100, 200, 300)
>>> tup[4] 3
>>> tup[5] 'Srinivas'
>>> tup[0]=50
# trying to replace element 1 with 50, interpreter throws error.
TypeError: 'tuple' object does not support item assignment
>>> tup[2][0]=50
# trying to replace element of list 10 with 50, interpreter accepts.
>>> print(tup) (1, 2, [50, 12, 'a'], (100, 200, 300), 3, 'Srinivas')
Converting tuple to list :
>>> tup=(1,2,4,9,8) #creating a tuple
>>> print(tup) (1, 2, 4, 9, 8)
>>> type(tup) <class 'tuple'>
>>> lst = list(tup) # converting tuple to list by using list()
>>> print(lst) [1, 2, 4, 9, 8]
>>> type(lst) <class 'list'>
Converting list to tuple:
>>> lst=[10,20,30,40,'a'] #creating a list
>>> print(lst) [10, 20, 30, 40, 'a']
>>> type(lst) <class 'list'>
>>> tup=tuple(lst) #converting list to tuple by using tuple()
>>> print(tup) (10, 20, 30, 40, 'a')
>>> type(tup) <class 'tuple'>
Converting tuple to string:
>>> tup=('a','b','c') #creating tuple
>>> print(tup) ('a', 'b', 'c')
>>> type(tup) <class 'tuple'>
>>> str1=''.join(tup) #converting tuple to string by using join method
>>> print(str1) abc
>>> type(str1) <class 'str'>
Converting string to tuple:
>>> str1="Python Srinivas" #creating a string
>>> print(str1) Python Srinivas
>>> type(str1) <class 'str'>
>>> tup=tuple(str1) #converting a string by using tuple function.
>>> print(tup)
('P', 'y', 't', 'h', 'o', 'n', ' ', 'S', 'r', 'i', 'n', 'i', 'v', 'a', 's')
>>> type(tup) <class 'tuple'>
Note:
>>> t = ("a","b","c",10)
>>> ''.join(t)
TypeError: sequence item 3: expected str instance, int found
Advantages of Tuple over List:
• Generally we use tuple for heterogeneous elements and list for homogeneous
elements.
• Iterating through tuple is faster than list because tuples are immutable, So there
might be a slight performance boost.
• Tuples can be used as key for a dictionary. With list, this is not possible because
list is a mutable object.
• If you have data that doesn't change, implementing it as tuple will guarantee
that it remains write-protected.
