Write a program to read email IDs of n number of students and store them in a tuple. Create two new tuples, on

Programming Problems · Q1

Q. Write a program to read email IDs of n number of students and store them in a tuple. Create two new tuples, one to store only the usernames from the email IDs and second to store domain names from the email IDs. Print all three tuples at the end of the program. [Hint: You may use the function split()]

Yanam BieapTextbookSubjective· 3mImportance★★★★★est

47% · 14/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.

Read n email IDs into a tuple (tuples are immutable, so each addition concatenates a new one-element tuple), then split every ID at the @ sign: split("@") returns [username, domain], which we unpack into the two new tuples.

n = int(input("How many email IDs? "))
emails = ()
for i in range(n):
    emails = emails + (input("Enter email ID: "),)

usernames = ()
domains = ()
for email in emails:
    (username, domain) = email.split("@")
    usernames = usernames + (username,)
    domains = domains + (domain,)
print(emails, usernames, domains, sep="\n")

For pooja@gmail.com, arif@yahoo.com, mary@outlook.com this prints the three tuples: the full IDs, ('pooja', 'arif', 'mary') and ('gmail.com', 'yahoo.com', 'outlook.com').

✓Final answer

Split each email ID on "@" with split() and build three tuples by concatenation — full IDs, usernames and domains — and print all three.

Build the email tuple by concatenating one-element tuples in a loop, then use split("@") to break each ID into its username and domain and collect those into two more tuples.

The idea. Tuples are immutable — you cannot append to one. The standard workaround is concatenation: emails = emails + (email,) builds a new, longer tuple each time (note the one-element tuple (email,) with its comma). The parsing itself is one call: every email ID has the shape username@domain, so email.split("@") gives a two-element list we can unpack directly into (username, domain).

Program:

n = int(input("How many email IDs? "))
emails = ()
for i in range(n):
    email = input("Enter email ID: ")
    emails = emails + (email,)

usernames = ()
domains = ()
for email in emails:
    (username, domain) = email.split("@")
    usernames = usernames + (username,)
    domains = domains + (domain,)

print("Email IDs :", emails)
print("Usernames :", usernames)
print("Domains   :", domains)

Sample run:

How many email IDs? 3
Enter email ID: pooja@gmail.com
Enter email ID: arif@yahoo.com
Enter email ID: mary@outlook.com
Email IDs : ('pooja@gmail.com', 'arif@yahoo.com', 'mary@outlook.com')
Usernames : ('pooja', 'arif', 'mary')
Domains   : ('gmail.com', 'yahoo.com', 'outlook.com')

Key lines:

emails + (email,) — tuple concatenation; (email,) must carry the trailing comma or it is just a string in brackets.
(username, domain) = email.split("@") — split returns ['pooja', 'gmail.com'] for the first ID, and tuple-style unpacking assigns both parts in one statement.

Tip

If an address might contain more than one @ (rare but possible in test data), email.split("@", 1) splits only at the first one, keeping the rest intact in the domain part.

✓Final answer

The program stores all email IDs in one tuple, then uses split("@") to derive a usernames tuple ('pooja', 'arif', 'mary') and a domains tuple ('gmail.com', 'yahoo.com', 'outlook.com'), printing all three.

←Previous questionQ8 — TypeError occurs while statement 2 is running. Give reason. How can it…→Next questionQ2 — Write a program to input names of n students and store them in a tuple…

🎓Unlock everything free for 14 days

Unlock everything free for 14 days