A Tuple is a numerically ordered sequence of elements that can store elements of heterogeneous types, is iterable, immutable and allows duplicate elements.
split()
and join()
)sorted()
functionhelp(tuple)
Help on class tuple in module builtins: class tuple(object) | tuple(iterable=(), /) | | Built-in immutable sequence. | | If no argument is given, the constructor returns an empty tuple. | If iterable is specified the tuple is initialized from iterable's items. | | If the argument is a tuple, the return value is the same object. | | Built-in subclasses: | asyncgen_hooks | UnraisableHookArgs | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __rmul__(self, value, /) | Return value*self. | | count(self, value, /) | Return number of occurrences of value. | | index(self, value, start=0, stop=9223372036854775807, /) | Return first index of value. | | Raises ValueError if the value is not present. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature.
t1 = (1, 2, 3, 4, 5) #tuple of integers
t1 = 1, 2, 3, 4, 5
print("t1: ", t1)
t2 = (2.3, 5.6, 1.8) #tuple of floats
print("t2: ", t2)
t3 = ('hello', 'this', 'F', 'good show') #tuple of strings
print("t3: ", t3)
t4 = (True, False, True) # tuple of boolean values
print("t4: ", t4)
print("Type of t4 is: ", type(t4))
t1: (1, 2, 3, 4, 5) t2: (2.3, 5.6, 1.8) t3: ('hello', 'this', 'F', 'good show') t4: (True, False, True) Type of t4 is: <class 'tuple'>
# creating empty tuple
t5 = ()
print("t5: ", t5)
t5: ()
# to create a tuple with only one element is a bit tricky
t6 = (25,) # note the comma, without it, Python will take it as int/float/string and not tuple
print("\nt6: ", t6)
print(type(t6))
t6: (25,) <class 'tuple'>
# Nested Tuple: a tuple can also have another tuple as an item
t1 = ("Arif", 30, 5.5, (10,'rauf'))
print(t1)
('Arif', 30, 5.5, (10, 'rauf'))
# Nested tuple: A tuple can also have another tuple, or list as an item
t1 = (1, "Hello", [8, 'OK', 6], (1, 2, 'BYE'), 5.5)
print("t1: ", t1)
print("Type of t1 is: ", type(t1))
t1: (1, 'Hello', [8, 'OK', 6], (1, 2, 'BYE'), 5.5) Type of t1 is: <class 'tuple'>
t1 = ("Arif", 30, 5.5)
print("t1: ", t1)
t1: ('Arif', 30, 5.5)
a = (1, 2, 3)
b = (2, 3, 1)
id(a), id(b), a is b, a == b
(140597048184448, 140597047356352, False, False)
# Tuples are immutable, i.e., tuple elements cannot be changed
numbers = (10, 20, 30)
numbers[2] = 15 # this will generate an error
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) /var/folders/1t/g3ylw8h50cjdqmk5d6jh1qmm0000gn/T/ipykernel_27657/769081338.py in <module> 1 # Tuples are immutable, i.e., tuple elements cannot be changed 2 numbers = (10, 20, 30) ----> 3 numbers[2] = 15 # this will generate an error TypeError: 'tuple' object does not support item assignment
# Tupple however can be reassigned
numbers = (10, 20, 30)
numbers = (1, 2, 3) # A tupple can be reassigned
numbers
Remember the tuple object (10,20,20)
in memory has become an orphan, since the numbers variable is now pointing to another tuple object (1,2,3)
in memory. The unreferenced tuple object will be garbage collected by Python garbage collector
# A List within a tuple is still mutable
t1 = (1, "Hello", [8, 'OK', 6], (1, 2, 'BYE'), 5.5)
t1[2][1] = 'Not OK' # will work fine
t1
(1, 'Hello', [8, 'Not OK', 6], (1, 2, 'BYE'), 5.5)
# Like Lists, Tuples allow duplicate elements
names = ('Arif', 'Rauf', 'Hadeed', 'Arif', 'Mujahid')
print(names)
('Arif', 'Rauf', 'Hadeed', 'Arif', 'Mujahid')
# A tuple having two sub-tuples within it
a = (1,2,3,(4,5),(6,7,8,9),10,11)
# A tuple having a sub-tuple, which is further having a sub-tuple and that again having a subtuple
b = (1,2,3,(4,5,(6,7,8,(9,10,11))))
a, b
((1, 2, 3, (4, 5), (6, 7, 8, 9), 10, 11), (1, 2, 3, (4, 5, (6, 7, 8, (9, 10, 11)))))
# you can unpack tuple elements
t1 = ('learning', 'is', 'fun', 'with', 'Arif')
a, b, c, d, e = t1 # the number of variables on the left must match the length of tuple
print (a, c, e)
print(type(a))
learning fun Arif <class 'str'>
# you can pack individual elements to a tuple
t1 = a,b,c,d,e
print(t1)
print(type(t1))
('learning', 'is', 'fun', 'with', 'Arif') <class 'tuple'>
index()
method of Tuple class#You can access elements of tuple using indexing which starts from zero
t1 = ("Arif", 30, 5.5, (10,'rauf'))
print(t1[2]) #accessing element of tuple at index2
print(t1[3]) #accessing element of tuple at index3, which is again a tuple
#accessing Nested tuple element
print(t1[0][2]) #accessing third character of a tuple element at index 0
print(t1[3][1]) #accessing second element of Nested tuple at index 3
5.5 (10, 'rauf') i rauf
#Negative indexing starts looking at the tuple from the right hand side
t1 = ("Arif", 30, 5.5, (10,'rauf'))
print(t1[-1]) #accessing last element
print(t1[-2]) #accessing second last element
(10, 'rauf') 5.5
help(t1.index)
# index(value) method is used when you know the tuple element and wants to get its index
# index(value) method returns the index of the first matched item with its only argument
mytuple = (27, 4.5, 'arif', 64, 'hadeed', 19, 'arif')
print("\nmytuple: ", mytuple)
print("mytuple.index(3): ", mytuple.index('arif'))
mytuple: (27, 4.5, 'arif', 64, 'hadeed', 19, 'arif') mytuple.index(3): 2
mytuple[start:end:step]
t1 = ('a','b','c','d','e','f','g','h','i')
t1
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i')
t1[::]
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i')
t1[3:]
('d', 'e', 'f', 'g', 'h', 'i')
t1[:4]
('a', 'b', 'c', 'd')
t1[2:5]
t1[:-2]
t1[-1]
# Slicing by using strides
print(t1[::]) # A default step of 1
print(t1[::1]) # A step of 1
print(t1[::2]) # A step of 2
print(t1[::3]) # A step of 3
# Reverse slicing
print(t1[::-1]) # Take 1 step back each time
print(t1[5:1:-1]) # Take 1 step back each time
#if start is less than end in case of a negative step, it will return empty string
print(t1[2:10:-1])
print(t1[::-2]) # Take 2 steps back
# You CANNOT use slice operator on the left side of assignment as tuple is immutable
t1 = (1, 2, 3, 4, 5, 6, 7)
#t1[2:4] = ['a', 'b', 'c'] # will generate an error as 'tuple' object does not support item assignment
+
operator is used to concatenate two or more tuples*
operator is used to repeat or replicate# Add some elements to the end of an existing tuple using concatenation operator
a = (1,2,3)
b = a + (4,5)
# Add some elements to the beginning of an existing tuple using concatenation operator
c = (0,) + b
a, b, c
((1, 2, 3), (1, 2, 3, 4, 5), (0, 1, 2, 3, 4, 5))
# use + operator to concatenate two tuples
food_items1 = ('fruits', 'bread', 'veggies')
food_items2 = ('meat', 'spices', 'burger')
food = food_items1 + food_items2
print(food)
('fruits', 'bread', 'veggies', 'meat', 'spices', 'burger')
# You can concatenate two heterogeneous tuples
t1 = (5, 3.4, 'hello')
t2 = (31, 9.7, 'bye')
t3 = t1 + t2
print(t3)
(5, 3.4, 'hello', 31, 9.7, 'bye')
num1 = (1,2,3)
num2 = num1 + (4, 5, 6, (7, 8))
print (num2)
(1, 2, 3, 4, 5, 6, (7, 8))
# use tuple * n syntax to create large tuples by repeating the tuple n times
name = ('Arif', 'Hadeed', 'Mujahid')
a = name * 3
print(a)
('Arif', 'Hadeed', 'Mujahid', 'Arif', 'Hadeed', 'Mujahid', 'Arif', 'Hadeed', 'Mujahid')
#tuple of 100 A's
buf = ('A',)
newbuf = buf * 100
print(newbuf)
type(newbuf)
('A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A')
tuple
append
, extend
, and insert
)¶myfamily = ("Farooq", 'Rauf', 'Hadeed')
print("\n myfamily tuple: ", myfamily)
myfamily.insert(2,'Arif') # will generate an error as tuple object has no attribute 'insert'
myfamily tuple: ('Farooq', 'Rauf', 'Hadeed')
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) /var/folders/1t/g3ylw8h50cjdqmk5d6jh1qmm0000gn/T/ipykernel_27657/1169247384.py in <module> 1 myfamily = ("Farooq", 'Rauf', 'Hadeed') 2 print("\n myfamily tuple: ", myfamily) ----> 3 myfamily.insert(2,'Arif') # will generate an error as tuple object has no attribute 'insert' AttributeError: 'tuple' object has no attribute 'insert'
pop
and remove
methods)¶tuple1 = ('learning', 'is', 'fun', 'with', 'arif', 'butt')
#You cannot delete items from a tuple using del keyword
#del tuple1[3] # will generate an error as tuple object doesn't support item deletion
# However, you can assign a new tuple object to the reference tuple1
tuple1 = (1, 2, 3, 'arif')
# However, you can delete an entire tuple object using del keyword
#del tuple1
#print(tuple1)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) /var/folders/1t/g3ylw8h50cjdqmk5d6jh1qmm0000gn/T/ipykernel_27657/527872821.py in <module> 8 # However, you can delete an entire tuple object using del keyword 9 del tuple1 ---> 10 print(tuple1) 11 NameError: name 'tuple1' is not defined
# convert a string into tuple using tuple()
str1 = 'Learning is fun' #this is a string
print("Original string: ", str1, "and its type is: ", type(str1))
t1 = tuple(str1)
print("t1: ", t1, "and its type is: ", type(t1))
Original string: Learning is fun and its type is: <class 'str'> t1: ('L', 'e', 'a', 'r', 'n', 'i', 'n', 'g', ' ', 'i', 's', ' ', 'f', 'u', 'n') and its type is: <class 'tuple'>
str.split()
to Split a Tuple into Strings¶str1 = ""
help(str1.split)
Help on built-in function split: split(sep=None, maxsplit=-1) method of builtins.str instance Return a list of the words in the string, using sep as the delimiter string. sep The delimiter according which to split the string. None (the default value) means split according to any whitespace, and discard empty strings from the result. maxsplit Maximum number of splits to do. -1 (the default value) means no limit.
str1 = 'Learning is fun' #this is a string
t1 = tuple(str1.split(' ')) # The split() method returns a list, which you can typecast to a tuple
print(t1)
print(type(t1))
('Learning', 'is', 'fun') <class 'tuple'>
str2 = "Data Science is GR8 Degree" #this is a string
t2 = tuple(str2.split('c'))
print(t2)
print(type(t2))
('Data S', 'ien', 'e is GR8 Degree') <class 'tuple'>
str.join()
to Join Strings into a Tuple¶str.join()
is the reverse of split() method, and is used to joing multiple strings by inserting the string in between on which this method is calledstr.join()
methodstr = ""
help(str.join)
Help on built-in function join: join(iterable, /) method of builtins.str instance Concatenate any number of strings. The string whose method is called is inserted in between each given string. The result is returned as a new string. Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
t1 = ('This', 'is', 'getting', 'more', 'and', 'more', 'interesting')
t1
('This', 'is', 'getting', 'more', 'and', 'more', 'interesting')
str2 = ' '.join(t1)
str2, type(str2)
('This is getting more and more interesting', str)
delimiter = " # "
str3 = delimiter.join(t1)
print(str3)
print(type(str3))
This # is # getting # more # and # more # interesting <class 'str'>
t1.index(val)
method takes the value and returns the first index where that value resides in the tuplet1.count(val)
method takes exactly one argument and returns the number of times a that value occurs in a tuplet1 = (3, 8, 1, 6, 0, 8, 4)
rv = t1.index(6)
print(rv)
3
t1 = (3, 8, 1, 6, 8, 0, 8, 4)
rv = t1.count(8)
print(rv)
3
Like Lists, you can apply max()
, min()
, and sum()
functions on tuples with numeric elements
t1 = (3, 8, 1, 6, 0, 8, 4)
print("length of list: ", len(t1))
print("max element in list: ", max(t1))
print("min element in list: ",min(t1))
print("Sum of element in list: ",sum(t1))
length of list: 7 max element in list: 8 min element in list: 0 Sum of element in list: 30
Like Lists, you can apply in
and not in
membership operators on Tuples
t1 = (3, 8, 1, 6, 0, 8, 4)
rv1 = 9 in t1
print(rv1)
rv2 = 9 not in t1
print(rv2)
t2 = ("XYZ", "ABC", "MNO", "ARIF")
rv3 = "ARIF" in t2
print(rv3)
False True True
Comparing Objects and Values
#In case of strings, both variables str1 and str2 refers to the same memory location containing string object 'hello'
str1 = 'hello'
str2 = 'hello'
print(id(str1), id(str2))
print (str1 is str2) # is operator is checking the memory address (ID) of two strings
print (str1 == str2) # == operator is checking the contents of two strings
140597046554096 140597046554096 True True
#In case of tuples, both t1 and t2 refers to two different objects in the memory having same values
t1 = (1, 2, 3)
t2 = (1, 2, 3)
print(id(t1), id(t2))
print (t1 is t2) # is operator is checking the memory address (ID) of two tuples
print (t1 == t2) # == operator is checking the contents of two tuples element by element
140597048251712 140597048247424 False True
sorted()
function can be used to sort iterable objects, such as lists, tuples, and dictionaries. - We have seen its usage in our Tuple session.sorted()
function sorts the items of the specified iterable object and creates a new object with the newly sorted values. sorted(object, key=None, reverse=False)
object
: the iterable object that you want to sort (required)key
: the function that allows you to perform custom sort operations (optional)reverse
: specifies whether the object should be sorted in descending order (optional)- default value is False# Sorting a Dictionary by it values with numeric values
t1 = (3, 8, 1, 6, 0, 8, 4)
print("Original Tuple = ", t1)
list1 = sorted(t1)
list2 = sorted(t1, reverse=True)
print("Ascending Sort: ", list1)
print("Descending Sort: ", list2)
Original Tuple = (3, 8, 1, 6, 0, 8, 4) Ascending Sort: [0, 1, 3, 4, 6, 8, 8] Descending Sort: [8, 8, 6, 4, 3, 1, 0]
# Sorting a tuple with string values
t1 = ("XYZ", "ABC", "MNO", "ARIF")
print("Original Tuple: ", t1)
list1 = sorted(t1)
list2 = sorted(t1, reverse=True)
print("Ascending Sort: ", list1)
print("Descending Sort: ", list2)
Original Tuple: ('XYZ', 'ABC', 'MNO', 'ARIF') Ascending Sort: ['ABC', 'ARIF', 'MNO', 'XYZ'] Descending Sort: ['XYZ', 'MNO', 'ARIF', 'ABC']
sorted()
Method¶
Example 1: Suppose given a tuple with elements ('ccc', 'aaaa', 'd', 'bb')
and we want to sort it by length of strings inside the tuple so that the output is like : ('d', 'bb', 'ccc', 'aaaa)
sorted(iterable, key=None, reverse=False)
key
parameter of sorted()
functionsorted()
function will run this one argument function on all the elements of the tuple and return a single value, and build up a shadow list of those new values.len()
, which when called on every element of tuple
will return a shadow list containing length of every string within the original tuple containing [3,4,1,2]
sorted()
function will then sort elements of the tuple based on the values of the shadow list and returns the required sorted list :)t1 = ('ccc', 'aaaa', 'd', 'bb')
sorted(t1)
['aaaa', 'bb', 'ccc', 'd']
#Example 1:
t1 = ('ccc', 'aaaa', 'd', 'bb')
sorted(t1, key=len)
['d', 'bb', 'ccc', 'aaaa']
Example 2: Suppose given a tuple with elements ('abcz', 'xyza', 'bas', 'arif')
and we want to sort it by last character of strings within the tuple so that the output is like : ('xyza', 'arif', 'bas', 'abcz')
sorted(iterable, key=None, reverse=False)
key
parameter of sorted()
functionsorted()
function will run this one argument function on all the elements of the tuple and return a single value, and build up a shadow list of those new values.tuple
will return a shadow list containing only the last character of every string within the original tuple containing ['z', 'a', 's', 'f']
sorted()
function will then sort elements of the tuple based on the values of the shadow list and returns the required sorted list :)def last(s):
return s[-1]
t1 = ('abcz', 'xyza', 'bas', 'arif')
rv = sorted(t1, key=last)
print(rv)
print(t1)
['xyza', 'arif', 'bas', 'abcz'] ('abcz', 'xyza', 'bas', 'arif')
Try answering the following questions to test your understanding of the topics covered in this notebook:
10.How to delete Tuple in Python ?