Question 1

Question 8Can you change an element of a sequence? What if a sequence is a dictionary? What if a sequence is a tuple?

Accepted Answer

Yes, we can change any element of a sequence in python only if the type of the sequence is mutable.Dictionary — We can change the elements of a dictionary as dictionary is a mutable sequence. For example:d = {'k1':1, 'k2':4}d['k1'] = 2Here, we are changing the value of first key-value pair of dictionary d. Now dictionary d will be : {'k1':2, 'k2':4}Tuple — We cannot change the elements of a tuple as tuple is an immutable sequence.For example:tup = (1, 2, 3, 4)tup[0] = 5The above expression will give an error.TypeError: 'tuple' object does not support item assignment

Question 2

Question 9How can you add an extra element to a tuple ?

Accepted Answer

We can use the concatenation operator to add an extra element to a tuple as shown below. As tuples are immutable so they cannot be modified in place.For example:t=(1,2,3)
t_append = t + (4,)
print(t)
print(t_append)Output:(1,2,3)
(1,2,3,4)

Question 3

Question 10When would you prefer tuples over lists ?

Accepted Answer

Tuples are preferred over lists in the following cases:When we want to ensure that data is not changed accidentally. Tuples being immutable do not allow any changes in its data.When we want faster access to data that will not change as tuples are faster than lists.When we want to use the data as a key in a dictionary. Tuples can be used as keys in a dictionary, but lists cannot.When we want to use the data as an element of a set. Tuples can be used as elements of a set, but lists cannot.

Question 4

Question 12When would sum( ) not work for tuples ?

Accepted Answer

Sum would not work for the following cases:When tuple does not have numeric value.For example:-tup = ("a", "b")tup_sum = sum(tup)TypeError: unsupported operand type(s) for +: 'int' and 'str'here, "a" and "b" are string not integers therefore they can not be added together.Nested tuples having tuple as element.For example:-a = (1,2,(3,4))  
print(sum(a))  
Output:TypeError: unsupported operand type(s) for +: 'int' and 'tuple'Here, tuple 'a' is a nested tuple and since it consist of another tuple i.e. (3,4) it's elements can not be added to another tuple. Hence it will throw an error.Tuple containing elements of different data type.For example:-a = (1,2.5,(3,4),"hello")  
print(sum(a))  
Output:TypeError: unsupported operand type(s) for +: 'float' and 'tuple'Tuple a contains elements of integer, float, string and tuple type which can not be added together.

Question 5

Question 14Is the working of in operator and tuple.index( ) same ?

Accepted Answer

Both in operator and tuple.index( ) can be used to search for an element in the tuple but their working it is not exactly the same.The "in" operator returns true or false whereas tuple.index() searches for a element for the first occurrence and returns its position. If the element is not found in tuple or the index function is called without passing any element as a parameter then tuple.index( ) raises an error:For Example:-tuple = (1, 3, 5, 7, 9)print(3 in tuple) ⇒ Trueprint(4 in tuple) ⇒ Falseprint(tuple.index(3)) ⇒ 1print(tuple.index(2)) ⇒ ErrorValueError: tuple.index(x): x not in tuple 
print(tuple.index()) ⇒ ErrorTypeError: index expected at least 1 argument, got 0

Question 6

Question 1(a)Find the output generated by following code fragments :plane = ("Passengers", "Luggage")     
plane[1] = "Snakes"

Accepted Answer

OutputTypeError: 'tuple' object does not support item assignment
ExplanationSince tuples are immutable, tuple object does not support item assignment.

Question 7

Question 1(b)Find the output generated by following code fragments :(a, b, c) = (1, 2, 3)

Accepted Answer

Outputa = 1
b = 2
c = 3
ExplanationWhen we put tuples on both sides of an assignment operator, a tuple unpacking operation takes place. The values on the right are assigned to the variables on the left according to their relative position in each tuple. As you can see in the above example, a will be 1, b will be 2, and c will be 3.

Question 8

Question 1(d)Find the output generated by following code fragments :a, b, c, d = (1, 2, 3)

Accepted Answer

OutputValueError: not enough values to unpack (expected 4, got 3)
ExplanationTuple unpacking requires that the list of variables on the left has the same number of elements as the length of the tuple. In this case, the list of variables has one more element than the length of the tuple so this statement results in an error.

Question 9

Question 1(k)Find the output generated by following code fragments :tuple = ( 'a' , 'b',  'c' , 'd' , 'e')
tuple = ( 'A', ) + tuple[1: ]  
print(tuple)

Accepted Answer

Output('A', 'b', 'c', 'd', 'e') 
Explanationtuple[1:] creates a tuple slice of elements from index 1 (indexes always start from zero) to the last element i.e. ('b', 'c', 'd', 'e').+ operator concatenates tuple ( 'A', ) and tuple slice tuple[1: ] to form a new tuple.

Question 10

Question 1(m)Find the output generated by following code fragments :t3 = (6, 7)  
t4 = t3 * 3  
t5 = t3 * (3)  
print(t4)  
print(t5)

Accepted Answer

Output(6, 7, 6, 7, 6, 7)  
(6, 7, 6, 7, 6, 7)  
ExplanationThe repetition operator * replicates the tuple specified number of times. The statements t3 * 3 and t3 * (3) are equivalent as (3) is an integer not a tuple because of lack of comma inside parenthesis. Both the statements repeat t3 three times to form tuples t4 and t5.

Question 11

Question 1(o)What will be stored in variables a, b, c, d, e, f, g, h, after following statements ?perc = (88,85,80,88,83,86)  
a = perc[2:2]  
b = perc[2:]  
c = perc[:2]  
d = perc[:-2]  
e = perc[-2:]  
f = perc[2:-2]  
g = perc[-2:2]  
h = perc[:]

Accepted Answer

The values of variables a, b, c, d, e, f, g, h after the statements will be:a ⇒ ( )b ⇒ (80, 88, 83, 86)c ⇒ (88, 85)d ⇒ (88, 85, 80, 88)e ⇒ (83, 86)f ⇒ (80, 88)g ⇒ ( )h ⇒ (88, 85, 80, 88, 83, 86)Explanationperc[2:2] specifies an invalid range as start and stop indexes are the same. Hence, an empty slice is stored in a.Since stop index is not specified, perc[2:] will return a tuple slice containing elements from index 2 to the last element.Since start index is not specified, perc[:2] will return a tuple slice containing elements from start to the element at index 1.Length of Tuple is 6 and perc[:-2] implies to return a tuple slice containing elements from start till perc[ : (6-2)] = perc[ : 4] i.e., the element at index 3.Length of Tuple is 6 and perc[-2: ] implies to return a tuple slice containing elements from perc[(6-2): ] = perc[4 : ] i.e., from the element at index 4 to the last element.Length of Tuple is 6 and perc[2:-2] implies to return a tuple slice containing elements from index 2 to perc[2:(6-2)] = perc[2 : 4] i.e., to the element at index 3.Length of Tuple is 6 and perc[-2: 2] implies to return a tuple slice containing elements from perc[(6-2) : 2] = perc[4 : 2] i.e., index at 4 to index at 2 but that will yield empty tuple as starting index has to be lower than stopping index which is not true here.It will return all the elements since start and stop index is not specified.

Question 12

Question 2What does each of the following expressions evaluate to? Suppose that T is the tuple containing :("These", ["are" , "a", "few", "words"] , "that", "we", "will" , "use")T[1][0: :2]"a" in T[1][0]T[:1] + [1]T[2::2]T[2][2] in T[1]

Accepted Answer

The given expressions evaluate to the following:['are', 'few']TrueTypeError: can only concatenate tuple (not "list") to tuple('that', 'will')TrueExplanationT[1] represents first element of tuple i.e., the list ["are" , "a", "few", "words"]. [0 : : 2] creates a list slice starting from element at index zero of the list to the last element including every 2nd element (i.e., skipping one element in between)."in" operator is used to check elements presence in a sequence. T[1] represents the list ["are" , "a", "few", "words"]. T[1][0] represents the string "are". Since "a" is present in "are", it returns true.T[:1] is a tuple where as [1] is a list. They both can not be concatenated with each other.T[2::2] creates a tuple slice starting from element at index two of the tuple to the last element including every 2nd element (i.e., skipping one element in between).T[2] represents the string "that". T[2][2] represents third letter of "that" i.e., "a". T[1] represents the list ["are" , "a", "few", "words"]. Since "a" is present in the list, the in operator returns True.

Question 13

Question 3(b)Carefully read the given code fragments and figure out the errors that the code may produce.t = ('a', 'b', 'c', 'd', 'e')   
t[0] = 'A'

Accepted Answer

OutputTypeError: 'tuple' object does not support item assignment  
ExplanationTuple is a collection of ordered and unchangeable items as they are immutable. So once a tuple is created we can neither change nor add new values to it.

Question 14

Question 3(c)Carefully read the given code fragments and figure out the errors that the code may produce.t1 = (3)  
t2 = (4, 5, 6)  
t3 = t1 + t2  
print (t3)

Accepted Answer

OutputTypeError: unsupported operand type(s) for +: 'int' and 'tuple'
Explanationt1 holds an integer value not a tuple since comma is not added after the element where as t2 is a tuple. So here, we are trying to use + operator with an int and tuple operand which results in this error.

Question 15

Question 3(d)Carefully read the given code fragments and figure out the errors that the code may produce.t1 = (3,)  
t2 = (4, 5, 6)  
t3 = t1 + t2  
print (t3)

Accepted Answer

Output(3, 4, 5, 6) 
Explanationt1 is a single element tuple since comma is added after the element 3, so it can be easily concatenated with other tuple. Hence, the code executes successfully without giving any errors.

Question 16

Question 3(e)Carefully read the given code fragments and figure out the errors that the code may produce.t2	= (4, 5, 6)
t3	= (6, 7)
print(t3 - t2)

Accepted Answer

OutputTypeError: unsupported operand type(s) for -: 'tuple' and 'tuple'   
ExplanationArithmetic operations are not defined in tuples. Hence we can't remove items in a tuple.

Question 17

Question 3(f)Carefully read the given code fragments and figure out the errors that the code may produce.t3 = (6, 7)
t4 = t3 * 3 
t5= t3 * (3)
t6 = t3 * (3,)
print(t4)
print(t5) 
print(t6)

Accepted Answer

OutputTypeError: can't multiply sequence by non-int of type 'tuple'
ExplanationThe repetition operator * replicates the tuple specified number of times. The statements t3 * 3 and t3 * (3) are equivalent as (3) is an integer not a tuple because of lack of comma inside parenthesis. Both the statements repeat t3 three times to form tuples t4 and t5.In the statement, t6 = t3 * (3,), (3,) is a single element tuple and we can not multiply two tuples. Hence it will throw an error.

Question 18

Question 3(g)Carefully read the given code fragments and figure out the errors that the code may produce.odd= 1,3,5
print(odd + [2, 4, 6])[4]

Accepted Answer

OutputTypeError: can only concatenate tuple (not "list") to tuple 
ExplanationHere [2,4,6] is a list and odd is a tuple so because of different data types, they can not be concatenated with each other.

Question 19

Question 3(h)Carefully read the given code fragments and figure out the errors that the code may produce.t = ( 'a', 'b', 'c', 'd', 'e') 
1, 2, 3, 4, 5, = t

Accepted Answer

OutputSyntaxError: cannot assign to literal 
ExplanationWhen unpacking a tuple, the LHS (left hand side) should contain a list of variables. In the statement, 1, 2, 3, 4, 5, = t, LHS is a list of literals not variables. Hence, we get this error.

Question 20

Question 3(i)Carefully read the given code fragments and figure out the errors that the code may produce.t = ( 'a', 'b', 'c', 'd', 'e') 
1n, 2n, 3n, 4n, 5n = t

Accepted Answer

OutputSyntaxError: invalid decimal literal 
ExplanationThis error occurs when we declare a variable with a name that starts with a digit. Here, t is a tuple containing 5 values and then we are performing unpacking operation of tuples by assigning tuple values to 1n,2n,3n,4n,5n which is not possible since variable names cannot start with numbers.

Tuples

Checkpoint 12.1

Type A : Short Answer Questions/Conceptual Questions

Type B: Application Based Questions

Type C: Programming Practice/Knowledge based Questions