Tuples in Python

Tuple representation

Reason — According to the image shown above, the elements are enclosed within parentheses () and separated by commas, which represents a tuple in Python.

An empty tuple

Reason — The tuple() function without any argument returns an empty tuple, meaning a tuple that contains no elements.

T[:3]

Reason — In tuple slicing, the elements are extracted from the starting index up to (final index − 1). Since indexing starts from 0, T[:3] means elements from index 0 to 2, which are (1, 2, 3).

(1, 2, 3)

Reason — A tuple is represented by elements enclosed within parentheses ( ) and separated by commas. Therefore, (1, 2, 3) represents a tuple.

True

Reason — In tuple comparison, corresponding elements are compared starting from index 0. Since 1 = 1 and 2 = 2, the comparison moves to the next element where 3 < 8, which is True. Therefore, the entire relation evaluates to True.

+

Reason — The + operator is used to concatenate two or more tuples to form a single tuple.

1. True
2. False
   Corrected Statement: An empty tuple is a tuple which contains no element.
3. False
   Corrected Statement: The tuple() function is used to convert iterable objects into a tuple, not a complex number.
4. True
5. False
   Corrected Statement: The purpose of index( ) function in tuple is to return the position of the first occurrence of a specified value.
6. True

1. sum( )
2. Concatenation
3. Replication
4. Index
5. sorted( )

Both A and R are true and R is the correct explanation of A.

Reason — A tuple can be created from non-tuple structures such as lists and strings using the tuple( ) function. When a string is converted to a tuple, each character of the string becomes a separate element of the tuple.

The given code will result in a syntax error.

SyntaxError: invalid syntax

The del keyword is used to delete a tuple, but it is a statement and cannot be used inside the print( ) function.

(i)

False

In tuple comparison, corresponding elements are compared from the 0th index. Since 12 is greater than 5, the condition (12, 4, 6, 8) < (5, 9) evaluates to False.

(ii)

True

The corresponding elements of both tuples are compared. Since 'a' and 'A' are different, the two tuples are not equal. Therefore, the condition using != evaluates to True.

(iii)

False

In tuple comparison, corresponding elements are compared starting from index 0. First, 1 = 1 and 2 = 2, so comparison proceeds to the next elements. At index 2, 8 is less than 13, therefore, (1, 2, 8, 5) is not greater than (1, 2, 13, 5), and the result is False.

T1 = eval(input("Enter integers in a tuple within ( ): "))
s = 0

for x in T1:
    if x % 10 == 5:
        s = s + x

print("Sum of the numbers ending with digit 5:", s)

Enter integers in a tuple within ( ): (15, 23, 45, 60, 75, 82, 95)
Sum of the numbers ending with digit 5: 230

T1 = eval(input("Enter integers in a tuple within ( ): "))
pos = 0
neg = 0

for x in T1:
    if x > 0:
        pos = pos + x
    elif x < 0:
        neg = neg + x

print("Sum of positive numbers:", pos)
print("Sum of negative numbers:", neg)

Enter integers in a tuple within ( ): (12, -5, 8, -3, 15, -10, 6)
Sum of positive numbers: 41
Sum of negative numbers: -18

T1 = eval(input("Enter 10 integers in a tuple within ( ): "))
found = False
mn = 0

for x in T1:
    if x % 2 != 0:
        if found == False:
            mn = x
            found = True
        elif x < mn:
            mn = x

if found == True:
    print("Minimum of odd numbers:", mn)
else:
    print("No odd number found")

Enter 10 integers in a tuple within ( ): (12, 7, 15, 8, 21, 10, 5, 18, 9, 14)
Minimum of odd numbers: 5

T1 = eval(input("Enter a set of numbers in a tuple within ( ): "))
s = sorted(T1, reverse = True)
print("Sorted numbers in descending order:", s)

Enter a set of numbers in a tuple within ( ): (16, 13, 12, 17, 14)
Sorted numbers in descending order: [17, 16, 14, 13, 12]

T1 = eval(input("Enter integers in a tuple within ( ): "))
print("Prime numbers are:")

for a in T1:
    c = 0
    for b in range(1, a+1):
        if(a % b == 0):
            c = c + 1
    if(c == 2):
        print(a)

Enter integers in a tuple within ( ): (12, 7, 15, 11, 9, 5, 8)
Prime numbers are:
7
11
5

T1 = eval(input("Enter integers in a tuple within ( ): "))
print("Perfect numbers are:")

for a in T1:
    s = 0
    if a > 1:
        for b in range(1, a):
            if(a % b == 0):
                s = s + b
        if(s == a):
            print(a)

Enter integers in a tuple within ( ): (6, 10, 28, 12, 15)
Perfect numbers are:
6
28

Tuple is an ordered sequence of data. The elements of a tuple are immutable. It means, any change made in the elements of a tuple cannot be updated in its place.

Example: T = (1, 2, 3, 4)

A tuple that does not contain any element as its member, is known as an empty tuple. An empty tuple is represented by empty braces ( ).

No, a tuple element cannot be changed because the elements of a tuple are immutable. It means that any change made in the elements of a tuple cannot be updated in its place.

Tuple slicing is a technique to create a tuple after ignoring some elements of the existing tuple. It can be done by slicing a tuple from consecutive indexes.

Traversing a tuple means accessing the elements of a tuple consecutively one after the other to perform any operation. It can be done with the help of a for loop.

Example:

T1 = (2, 4, 6, 8)
for x in T1:
    print(x)

Replicating a tuple means duplicating the elements within a tuple, i.e., appending the tuple with the elements of the same tuple. It is done with the help of * operator.

Example:

T1 = (1, 3, 5)
print(T1 * 2)

Output:

(1, 3, 5, 1, 3, 5)

The two operators that resolve searching an element in a tuple are in and not in. These operators are used to check whether an element is present or not present in a tuple.

Differences between a list and a tuple are:

The count( ) function is responsible to find the frequency of an element in a tuple.

The len( ) function is used to find the length of a tuple, i.e., the number of elements available in the tuple.

Syntax: p = len(<tuple>)

Example:

T1 = (8, 3, 2, 9, 4)
p = len(T1)
print("Number of elements in the tuple:", p)

Output:

Number of elements in the tuple: 5

The index( ) function returns the index of the first occurrence of an element in the tuple.

Syntax: <tuple variable>.index(<tuple element>)

Example:

T1 = (12, 14, 16, 18, 20)
print(T1.index(18))

Output:

3

The sum( ) function is used to find the arithmetic sum of all integer values stored in a tuple.

Syntax: sum(Tuple)

Example:

T1 = (13, 14, 12, 15)
s = sum(T1)
print(s)

Output:

54

The sorted( ) function is used to arrange a set of elements stored in a tuple either in ascending or descending order and returns the elements as a list.

Syntax:

sorted(tuple)
sorted(tuple, reverse = True)

• sorted(tuple) : It will sort the elements of given tuple in ascending order.
• sorted(tuple, reverse = True) : It will sort a set of tuple data into descending order.

Example:

T1 = (16, 13, 12, 17, 14)
print(sorted(T1))
print(sorted(T1, reverse = True))

Output:

[12, 13, 14, 16, 17]
[17, 16, 14, 13, 12]