Write a program to input names of n students and store them in a tuple. Also, input a name from the user and f

Programming Problems · Q2

Q. Write a program to input names of n students and store them in a tuple. Also, input a name from the user and find if this student is present in the tuple or not. We can accomplish these by:

(a) writing a user defined function

(b) using the built-in function

Uttarakhand UbseTextbookSubjective· 3mImportance★★★★★est

60% · 18/30 Questions

✓ Free question

Concept understanding — Tuple Manipulation

Tuple Manipulation

Think of a tuple as a sealed envelope. You can put things inside it — numbers, strings, even other envelopes — but once you seal it, you cannot change what's inside. You can, however, take the envelope, combine it with other envelopes, cut it open to peek at its contents, or make a copy with slight changes. That's tuple manipulation: everything you can do with a tuple without altering the original.

What Is a Tuple?

A tuple is an ordered, immutable collection of items. In Python, you write it with parentheses:

point = (3, 5)
colors = ("red", "green", "blue")
mixed = (1, "hello", 3.14)

The word immutable is the key. Once created, you cannot add, remove, or replace an element. This is not a limitation — it's a guarantee. When you pass a tuple to a function, you know it will not be changed behind your back.

What Can You Do?

Accessing Elements

You use square brackets with an index, just like with lists:

point = (3, 5)
print(point[0])   # 3
print(point[-1])  # 5 (last element)

Slicing

You can extract a portion of a tuple, which gives you a new tuple:

t = (10, 20, 30, 40, 50)
print(t[1:4])   # (20, 30, 40)

The original t remains untouched.

Concatenation and Repetition

You can join tuples with + and repeat them with *:

a = (1, 2)
b = (3, 4)
c = a + b        # (1, 2, 3, 4)
d = a * 3        # (1, 2, 1, 2, 1, 2)

Each operation creates a brand-new tuple.

Membership and Length

t = (5, 10, 15)
print(10 in t)   # True
print(len(t))    # 3

Counting and Indexing

t = (1, 2, 2, 3, 2)
print(t.count(2))   # 3
print(t.index(3))   # 3 (first occurrence)

Unpacking

This is where tuples shine. You can assign each element to a variable in one line:

point = (4, 7)
x, y = point
print(x)   # 4
print(y)   # 7

You can even swap two variables without a temporary variable:

a, b = b, a

Behind the scenes, Python packs b, a into a tuple and then unpacks it into a, b.

Nested Tuples

A tuple can contain other tuples. Access them with multiple indices:

matrix = ((1, 2), (3, 4))
print(matrix[0][1])   # 2

What You Cannot Do

These will raise an error:

t = (1, 2, 3)
t[0] = 10        # TypeError
t.append(4)      # AttributeError
t.remove(2)      # AttributeError

Watch out

A common mistake is thinking you can modify a tuple. You cannot. If you need to change the collection, use a list. If you need to "change" a tuple, you must create a new one.

Why Use Tuples?

Safety: Data that should not change (e.g., days of the week, coordinates, function return values) stays fixed.
Performance: Tuples are slightly faster than lists because of their immutability.
Dictionary keys: Only immutable types (tuples, strings, numbers) can be used as dictionary keys. Lists cannot.

The Precise Statement

Important

Tuple manipulation refers to all operations that can be performed on a tuple without modifying the original tuple itself. These include indexing, slicing, concatenation, repetition, membership testing, length, counting, indexing, unpacking, and nesting. Because tuples are immutable, any operation that appears to change a tuple actually creates a new tuple.

A Quick Example: Swapping Without a Temp

a = 5
b = 10
a, b = b, a
print(a, b)   # 10 5

This works because Python evaluates the right-hand side as a tuple (10, 5) and then unpacks it into a and b. No temporary variable needed, no mutation — just tuple magic.

Store the n names in a tuple by concatenation, then search two ways: (a) a user-defined function that walks the tuple comparing each element (linear search), and (b) Python's built-in membership test in (or the tuple method count()).

def search(names, target):          # (a)
    for name in names:
        if name == target:
            return True
    return False

# ... names read into a tuple ...
if search(names, target): print("found (a)")
if target in names:       print("found (b)")   # built-in way

For names Aman, Bina, Chetan, Divya and search Chetan, both report present, and names.count('Chetan') gives 1.

✓Final answer

A user-defined linear-search function returns True when a name matches; the built-in membership operator in (or count()) does the same check in one expression — both find Chetan in the tuple.

Read the names into a tuple, then check membership twice — with your own linear-search function, and with Python's built-in in operator / count() method.

The idea. The task contrasts writing a search with reusing one. The user-defined version is a plain linear search: visit each element, compare with the target, return True on the first match. Python already ships this logic as the membership operator in (and the tuple method count(), which returns how many times a value occurs — nonzero means present).

Program (both approaches on the same data):

def search(names, target):        # (a) user defined function
    for name in names:
        if name == target:
            return True
    return False

n = int(input("How many students? "))
names = ()
for i in range(n):
    names = names + (input("Enter name: "),)

target = input("Enter the name to search: ")

# (a) using the user defined function
if search(names, target):
    print("(a)", target, "is present in the tuple (user defined function)")
else:
    print("(a)", target, "is not present in the tuple (user defined function)")

# (b) using the built-in membership operator 'in' / built-in count()
if target in names:
    print("(b)", target, "is present in the tuple (built-in 'in')")
else:
    print("(b)", target, "is not present in the tuple (built-in 'in')")
print("(b) count() reports", names.count(target), "occurrence(s)")

Sample run:

How many students? 4
Enter name: Aman
Enter name: Bina
Enter name: Chetan
Enter name: Divya
Enter the name to search: Chetan
(a) Chetan is present in the tuple (user defined function)
(b) Chetan is present in the tuple (built-in 'in')
(b) count() reports 1 occurrence(s)

Key lines:

search() returns True the moment a match is found and False only after the whole tuple is scanned — the standard linear-search shape, O(n) time.
target in names performs exactly the same scan internally, in one readable expression.
names.count(target) additionally tells you how many occurrences there are.

Tip

In real code always prefer in — it is shorter, clearer and implemented in C. The user-defined version is for learning how the search actually works.

✓Final answer

Both methods confirm the searched name: (a) the user-defined function scans the tuple element by element and returns True/False; (b) the built-in membership operator in (backed up by count()) reports the same result directly — in the sample run, Chetan is present.

←Previous questionQ1 — Write a program to read email IDs of n number of students and store th…→Next questionQ3 — Write a Python program to find the highest 2 values in a dictionary.

Q.Write a program to input names of n students and store them in a tuple. Also, input a name from the user and find if this student is present in the tuple or not. We can accomplish these by:

🎓Unlock everything free for 14 days

Q.Write a program to input names of n students and store them in a tuple. Also, input a name from the user and find if this student is present in the tuple or not.
We can accomplish these by:

Unlock everything free for 14 days