🔒 Tuples

Some data should NEVER change once it's created — the days of the week, the months of a year, the latitude and longitude of your school, or your date of birth. If you store such data in a list, a single wrong line of code could accidentally change it. Python gives us a safer container for this: the tuple. A tuple looks and behaves a lot like a list, but it is locked after creation. This chapter shows how to create a tuple (and why (5) is not one), which operations and functions work on tuples, what packing and unpacking mean, and when to choose a tuple instead of a list.

11.1 🏁 Introduction

A tuple is an ordered, immutable collection of values enclosed in round brackets ( ) and separated by commas. Like lists, tuples can hold values of different data types and allow duplicates.

days = ("Mon", "Tue", "Wed", "Thu", "Fri")   # tuple of strings
point = (10, 20)                              # a pair of numbers
student = (101, "Riya", 92.5, True)           # mixed types
empty = ()                                    # an empty tuple
nested = (1, 2, (3, 4), [5, 6])               # tuple containing a tuple and a list

Analogy: A list is like a whiteboard — you can write, erase and rewrite. A tuple is like a printed certificate 📜 — once printed, nobody can change the name or the marks on it. You can read it as many times as you like, but you can't edit it!

11.2 🛠️ Creating Tuples

11.2.1 Different Ways to Create a Tuple

T1 = (1, 2, 3)              # using round brackets
T2 = 4, 5, 6                # brackets are optional — commas make the tuple!
T3 = tuple([7, 8, 9])       # from a list
T4 = tuple("ABC")           # from a string → ('A', 'B', 'C')
T5 = tuple(range(1, 4))     # from a range → (1, 2, 3)
T6 = tuple()                # empty tuple → ()

print(T2, type(T2))         # (4, 5, 6) <class 'tuple'>
print(T4)                   # ('A', 'B', 'C')

11.2.2 The Single-Element Tuple Trap ⚠️

This is a classic tuple question.

a = (5)
b = (5,)
c = 5,
print(type(a))    # <class 'int'>     ← NOT a tuple!
print(type(b))    # <class 'tuple'>
print(type(c))    # <class 'tuple'>
print(b)          # (5,)

11.2.3 Taking a Tuple as Input

# Method 1: the user types the tuple itself, e.g. (10, 20, 30)
T = eval(input("Enter a tuple: "))

# Method 2: build a list first, then convert it
L = []
n = int(input("How many elements? "))
for i in range(n):
    L.append(int(input("Enter element: ")))
T = tuple(L)
print(T)

11.3 🔢 Accessing Tuple Elements

11.3.1 Indexing

Tuples use the same two-way indexing as strings and lists:

    T  = (  'a',  'e',  'i',  'o',  'u'  )
Forward:     0     1     2     3     4
Backward:   -5    -4    -3    -2    -1

T = ('a', 'e', 'i', 'o', 'u')
print(T[0], T[2], T[-1])    # a i u
print(len(T))               # 5
# print(T[5])               # ❌ IndexError: tuple index out of range

11.3.2 Traversing a Tuple

T = (12, 45, 7, 30)
for x in T:
    print(x, end=" ")
# Output: 12 45 7 30

for i in range(len(T)):
    print("Index", i, "→", T[i])

11.3.3 Tuples are Immutable 🔒

T = (10, 20, 30)
# T[0] = 100        # ❌ TypeError: 'tuple' object does not support item assignment
# T.append(40)      # ❌ AttributeError: 'tuple' object has no attribute 'append'
# del T[0]          # ❌ TypeError: 'tuple' object doesn't support item deletion

del T               # ✅ allowed — deletes the WHOLE tuple variable
# print(T)          # ❌ NameError: name 'T' is not defined

To "change" a tuple, you must create a new tuple:

T = (10, 20, 30)
T = T + (40,)       # a NEW tuple is created and assigned to T
print(T)            # (10, 20, 30, 40)

T = (10, 20, 30)
L = list(T)         # convert to a list
L[1] = 200          # change the list
T = tuple(L)        # convert back
print(T)            # (10, 200, 30)

T = (1, 2, [3, 4])
T[2][0] = 30      # ✅ allowed — we are changing the LIST, not the tuple
print(T)          # (1, 2, [30, 4])
# T[2] = [5, 6]   # ❌ TypeError — replacing the element itself is not allowed

11.4 ➕ Tuple Operations

T = (1, 2)
# T + 3            # ❌ TypeError: can only concatenate tuple (not "int") to tuple
print(T + (3,))    # ✅ (1, 2, 3)

11.4.1 Slicing ✂️

Slicing works exactly as for strings and lists — T[start : stop : step] — and it always returns a new tuple.

  T = ( 10,  20,  30,  40,  50,  60 )
         0    1    2    3    4    5
        -6   -5   -4   -3   -2   -1

11.5 📦 Tuple Assignment — Packing and Unpacking

11.5.1 Packing

Packing means putting several values together into a tuple.

student = 101, "Aman", 88      # the three values are PACKED into one tuple
print(student)                 # (101, 'Aman', 88)

11.5.2 Unpacking

Unpacking means extracting the values of a tuple into separate variables in one statement. The number of variables on the left must equal the number of elements.

student = (101, "Aman", 88)
roll, name, marks = student    # UNPACKING
print(name)                    # Aman
print(marks)                   # 88

      student  =  ( 101 ,  "Aman" ,  88 )
                     ↓        ↓       ↓
      roll, name, marks  =  101,  "Aman",  88

11.5.3 Swapping Using Tuple Assignment 🔄

The famous one-line swap you saw earlier is actually packing + unpacking!

a, b = 5, 10
a, b = b, a        # right side packs (10, 5); left side unpacks it
print(a, b)        # 10 5

11.6 🧰 Tuple Functions and Methods

Because tuples are immutable, they have only two methods: count() and index(). All other operations are done with built-in functions.

T = (40, 10, 30, 20)
S = sorted(T)
print(S, type(S))                  # [10, 20, 30, 40] <class 'list'>
print(tuple(sorted(T)))            # (10, 20, 30, 40)
print(sorted(T, reverse=True))     # [40, 30, 20, 10]
print(T)                           # (40, 10, 30, 20)  ← unchanged

11.7 🪆 Nested Tuples

A tuple can contain other tuples — useful for fixed, table-like data.

results = (("Riya", 92), ("Aman", 85), ("Zoya", 78))
print(results[1])          # ('Aman', 85)
print(results[1][0])       # Aman
for name, marks in results:     # unpacking inside the loop!
    print(name, "scored", marks)

Riya scored 92
Aman scored 85
Zoya scored 78

11.8 ⚖️ List vs Tuple

11.9 💻 Important Tuple Programs

Code Example: tuple_stats.py

# Find the maximum, minimum and mean of numbers in a tuple
T = (45, 12, 78, 34, 89, 23)
largest = smallest = T[0]
total = 0
for x in T:
    if x > largest:
        largest = x
    if x < smallest:
        smallest = x
    total += x
print("Maximum:", largest)
print("Minimum:", smallest)
print("Mean:", round(total / len(T), 2))

Maximum: 89
Minimum: 12
Mean: 46.83

Code Example: tuple_search.py

# Linear search in a tuple
T = (15, 8, 42, 23, 4, 16)
key = int(input("Enter the value to search: "))
found = False
for i in range(len(T)):
    if T[i] == key:
        print(key, "found at index", i)
        found = True
        break
if not found:
    print(key, "is not in the tuple")
# Input 23 → 23 found at index 3
# Input 99 → 99 is not in the tuple

Code Example: tuple_frequency.py

# Count the frequency of each element in a tuple
T = ("a", "b", "a", "c", "b", "a")
seen = ()
for x in T:
    if x not in seen:
        print(x, ":", T.count(x))
        seen = seen + (x,)

a : 3
b : 2
c : 1

Code Example: even_odd_tuple.py

# Create two new tuples of even and odd numbers from a given tuple
T = (11, 24, 35, 46, 57, 68)
even = odd = ()
for x in T:
    if x % 2 == 0:
        even += (x,)
    else:
        odd += (x,)
print("Even:", even)     # Even: (24, 46, 68)
print("Odd:", odd)       # Odd: (11, 35, 57)

Code Example: fibonacci_tuple.py

# Store the first n Fibonacci numbers in a tuple
n = int(input("How many terms? "))
fib = ()
a, b = 0, 1
for i in range(n):
    fib += (a,)
    a, b = b, a + b
print(fib)
# Input 7 → (0, 1, 1, 2, 3, 5, 8)

⚠️ Common Errors and Misconceptions

🎯 Sample Exam Questions

Q1: Very Short Answer [1 mark each]

a) What is the type of x in x = (7)? → int

b) Name the only two methods available for tuples. → count() and index()

c) What is the output of print((1, 2) * 2)? → (1, 2, 1, 2)

d) What does sorted((3, 1, 2)) return? → [1, 2, 3] (a list)

e) What is the output of print(len((1, (2, 3), [4, 5, 6])))? → 3

Q2: Output Based [2 marks]

Q: Write the output of the following code:

T = (10, 20, 30, 40, 50)
print(T[1:4], T[-2], T[::-2])
a, b, c = T[:3]
print(a + b + c, T.index(c))

Answer:

(20, 30, 40) 40 (50, 30, 10)
60 2

(T[:3] is (10, 20, 30), which is unpacked into a, b and c.)

Q3: Find the Errors [2 marks]

Q: Identify the errors (if any) in the following code and explain why:

T = (5, 10, 15)
T[1] = 12
T.append(20)
print(T + 25)

Answer:

• T[1] = 12 → TypeError: a tuple does not support item assignment (it is immutable).
• T.append(20) → AttributeError: tuples have no append() method.
• T + 25 → TypeError: a tuple can only be concatenated with another tuple; write T + (25,).

Q4: Output Based [3 marks]

Q: Write the output of the following code:

T1 = (1, 2, [3, 4])
T1[2].append(5)
print(T1)
T2 = T1[:2] + (6,)
print(T2, len(T2))
T3 = ("A",) * 2 + ("B",)
print(T3, T3.count("A"), T3.index("B"))

Answer:

(1, 2, [3, 4, 5])
(1, 2, 6) 3
('A', 'A', 'B') 2 2

Q5: Program [3 marks]

Q: Write a program to input a tuple of numbers and create a new tuple that contains only the elements greater than the mean of the tuple.

T = eval(input("Enter a tuple of numbers: "))
mean = sum(T) / len(T)
result = ()
for x in T:
    if x > mean:
        result += (x,)
print("Mean:", mean)
print("Elements above mean:", result)
# Input (10, 20, 30, 40, 50) → Mean: 30.0
#                              Elements above mean: (40, 50)

✏️ Practice Problems

1. Differentiate between a list and a tuple (any four points).

2. Write the output of: (a) type((1)) (b) type((1,)) (c) tuple("CS") (d) (1, 2) + (3,) * 2

3. If T = ('P', 'Y', 'T', 'H', 'O', 'N'), write the output of: (a) T[2:5] (b) T[-1:-4:-1] (c) T.index('H') (d) 'y' in T

4. Explain packing and unpacking with one example each.

5. Write a program to input a tuple of strings and print the longest string along with its length.

6. Write a program to input a tuple of integers and count how many are positive, negative and zero.

7. Write a program to input two tuples and create a third tuple containing the elements common to both (without duplicates).

8. "A tuple is immutable, yet the following code works." Explain why: T = ([1, 2], 3); T[0].append(9)

9. Write a program to store the names of the 7 days of the week in a tuple and print the days that have more than 6 letters.

10. Write a program to find the second largest element of a tuple without using sorted().