Tuples and Dictionaries — NCERT Solutions

Given Code:

>>> tuple1 = (5)   # statement 1
>>> len(tuple1)    # statement 2

Reason for TypeError:

In statement 1, tuple1 = (5) does not create a tuple. Python treats (5) as simply the integer 5 enclosed in parentheses (for grouping), not as a tuple. Therefore, tuple1 is of type int, not tuple.

We can verify:

>>> type(tuple1)
<class 'int'>

In statement 2, len(tuple1) is called on an integer object. The len() function works only on sequences (strings, lists, tuples, etc.) and not on scalar types like int. Hence Python raises:

TypeError: object of type 'int' has no len()

Correction:

To create a single-element tuple, a trailing comma must be placed inside the parentheses:

>>> tuple1 = (5,)   # correct way to create a single-element tuple
>>> type(tuple1)
<class 'tuple'>
>>> len(tuple1)
1

Rule: A single-element tuple must always have a trailing comma — (element,) — otherwise Python interprets it as a parenthesised expression, not a tuple.

Concept: We use split('@') to separate the username (part before '@') and domain name (part after '@') from each email ID. Tuples are built by converting lists using tuple().

# Program to split email IDs into usernames and domain names

n = int(input("Enter the number of students: "))

email_list = []
for i in range(n):
    email = input(f"Enter email ID of student {i+1}: ")
    email_list.append(email)

# Convert list to tuple
email_tuple = tuple(email_list)

# Create username and domain tuples
username_list = []
domain_list   = []

for email in email_tuple:
    parts = email.split('@')   # splits into [username, domain]
    username_list.append(parts[0])
    domain_list.append(parts[1])

username_tuple = tuple(username_list)
domain_tuple   = tuple(domain_list)

# Display all three tuples
print("\nAll Email IDs  :", email_tuple)
print("Usernames      :", username_tuple)
print("Domain Names   :", domain_tuple)

Sample Run:

Enter the number of students: 3
Enter email ID of student 1: alice@gmail.com
Enter email ID of student 2: bob@yahoo.com
Enter email ID of student 3: carol@cbse.nic.in

All Email IDs  : ('alice@gmail.com', 'bob@yahoo.com', 'carol@cbse.nic.in')
Usernames      : ('alice', 'bob', 'carol')
Domain Names   : ('gmail.com', 'yahoo.com', 'cbse.nic.in')

Concept: We store student names in a tuple and use the in membership operator to check presence.

# Program to search a student name in a tuple

n = int(input("Enter the number of students: "))

name_list = []
for i in range(n):
    name = input(f"Enter name of student {i+1}: ")
    name_list.append(name)

# Convert list to tuple
student_tuple = tuple(name_list)

print("\nStudent Tuple:", student_tuple)

# Search for a student
search_name = input("\nEnter the name to search: ")

if search_name in student_tuple:
    print(f"{search_name} is PRESENT in the tuple.")
else:
    print(f"{search_name} is NOT PRESENT in the tuple.")

Sample Run:

Enter the number of students: 4
Enter name of student 1: Aman
Enter name of student 2: Priya
Enter name of student 3: Rahul
Enter name of student 4: Sneha

Student Tuple: ('Aman', 'Priya', 'Rahul', 'Sneha')

Enter the name to search: Rahul
Rahul is PRESENT in the tuple.

Concept: We extract the dictionary values, sort them in descending order, and pick the top 2.

# Program to find the highest 2 values in a dictionary

# Sample dictionary
marks = {'Aman': 85, 'Priya': 92, 'Rahul': 78, 'Sneha': 95, 'Karan': 88}

print("Dictionary:", marks)

# Method: sort values in descending order and take first two
sorted_values = sorted(marks.values(), reverse=True)

top2 = sorted_values[:2]
print("\nTop 2 highest values:", top2)

# Also display which students have these top 2 values
print("\nStudents with top 2 values:")
for key, value in marks.items():
    if value in top2:
        print(f"  {key}: {value}")

Output:

Dictionary: {'Aman': 85, 'Priya': 92, 'Rahul': 78, 'Sneha': 95, 'Karan': 88}

Top 2 highest values: [95, 92]

Students with top 2 values:
  Priya: 92
  Sneha: 95

Concept: We iterate over each character of the string and use a dictionary to count the frequency of each character. The get() method is used to handle the case when a character is seen for the first time.

# Program to create a frequency dictionary from a string

string = input("Enter a string: ")

freq_dict = {}

for char in string:
    freq_dict[char] = freq_dict.get(char, 0) + 1

print("Frequency Dictionary:", freq_dict)

Sample Run:

Enter a string: w3resource
Frequency Dictionary: {'w': 1, '3': 1, 'r': 2, 'e': 2, 's': 1, 'o': 1, 'u': 1, 'c': 1}

Step-by-step trace for 'w3resource':

Final dictionary matches the expected output.

Concept: A dictionary with friend names as keys and phone numbers as values. We use standard dictionary operations: display, add, delete, modify, membership check, and sorted display.

# Program to manage a friends' phone book using a dictionary

# Step 1: Input friends' names and phone numbers
phonebook = {}
n = int(input("Enter number of friends: "))
for i in range(n):
    name  = input(f"Enter name of friend {i+1}: ")
    phone = input(f"Enter phone number of {name}: ")
    phonebook[name] = phone

# a) Display all friends and their phone numbers
print("\na) All Friends and Phone Numbers:")
for name, phone in phonebook.items():
    print(f"   {name}: {phone}")

# b) Add a new key-value pair
new_name  = input("\nb) Enter name of new friend to add: ")
new_phone = input(f"   Enter phone number of {new_name}: ")
phonebook[new_name] = new_phone
print("   Modified Dictionary:", phonebook)

# c) Delete a particular friend
del_name = input("\nc) Enter name of friend to delete: ")
if del_name in phonebook:
    del phonebook[del_name]
    print(f"   {del_name} deleted. Updated Dictionary:", phonebook)
else:
    print(f"   {del_name} not found in phonebook.")

# d) Modify the phone number of an existing friend
mod_name = input("\nd) Enter name of friend whose number is to be modified: ")
if mod_name in phonebook:
    new_num = input(f"   Enter new phone number for {mod_name}: ")
    phonebook[mod_name] = new_num
    print("   Updated Dictionary:", phonebook)
else:
    print(f"   {mod_name} not found in phonebook.")

# e) Check if a friend is present
check_name = input("\ne) Enter name to check: ")
if check_name in phonebook:
    print(f"   {check_name} IS present in the phonebook.")
else:
    print(f"   {check_name} is NOT present in the phonebook.")

# f) Display in sorted order of names
print("\nf) Phonebook in Sorted Order of Names:")
for name in sorted(phonebook.keys()):
    print(f"   {name}: {phonebook[name]}")

Sample Run:

Enter number of friends: 3
Enter name of friend 1: Priya
Enter phone number of Priya: 9876543210
Enter name of friend 2: Aman
Enter phone number of Aman: 9123456789
Enter name of friend 3: Sneha
Enter phone number of Sneha: 9988776655

a) All Friends and Phone Numbers:
   Priya: 9876543210
   Aman: 9123456789
   Sneha: 9988776655

b) Enter name of new friend to add: Rahul
   Enter phone number of Rahul: 9001122334
   Modified Dictionary: {'Priya': '9876543210', 'Aman': '9123456789', 'Sneha': '9988776655', 'Rahul': '9001122334'}

c) Enter name of friend to delete: Sneha
   Sneha deleted. Updated Dictionary: {'Priya': '9876543210', 'Aman': '9123456789', 'Rahul': '9001122334'}

d) Enter name of friend whose number is to be modified: Aman
   Enter new phone number for Aman: 9000000001
   Updated Dictionary: {'Priya': '9876543210', 'Aman': '9000000001', 'Rahul': '9001122334'}

e) Enter name to check: Priya
   Priya IS present in the phonebook.

f) Phonebook in Sorted Order of Names:
   Aman: 9000000001
   Priya: 9876543210
   Rahul: 9001122334

Concept: We use a dictionary where the key is the roll number (int) and the value is a tuple (name, percentage) — an immutable data type as hinted.

# SMIS - Student Management and Information System
# Dictionary: {roll_number: (name, percentage)}

students = {}   # global dictionary

# -------------------------------------------------------
# Function 1: Accept details of n students
# -------------------------------------------------------
def accept_details():
    n = int(input("Enter number of students: "))
    for i in range(n):
        roll = int(input(f"\nEnter Roll Number of student {i+1}: "))
        name = input("Enter Name: ")
        perc = float(input("Enter Percentage: "))
        students[roll] = (name, perc)   # value is a tuple (immutable)
    print("\nDetails accepted successfully.")

# -------------------------------------------------------
# Function 2: Search a student by roll number
# -------------------------------------------------------
def search_student():
    roll = int(input("Enter Roll Number to search: "))
    if roll in students:
        name, perc = students[roll]
        print(f"Roll No : {roll}")
        print(f"Name    : {name}")
        print(f"Percent : {perc}%")
        if perc >= 33:
            print("Result  : PASS")
        else:
            print("Result  : FAIL")
    else:
        print("Student with this roll number NOT FOUND.")

# -------------------------------------------------------
# Function 3: Display result of all students
# -------------------------------------------------------
def display_all():
    if not students:
        print("No student records found.")
        return
    print(f"\n{'Roll':<8}{'Name':<20}{'Percentage':<12}{'Result'}")
    print("-" * 50)
    for roll, (name, perc) in students.items():
        result = "PASS" if perc >= 33 else "FAIL"
        print(f"{roll:<8}{name:<20}{perc:<12}{result}")

# -------------------------------------------------------
# Function 4: Find the topper (highest percentage)
# -------------------------------------------------------
def find_topper():
    if not students:
        print("No student records found.")
        return
    topper_roll = max(students, key=lambda r: students[r][1])
    name, perc  = students[topper_roll]
    print(f"\nTopper Details:")
    print(f"Roll No    : {topper_roll}")
    print(f"Name       : {name}")
    print(f"Percentage : {perc}%")

# -------------------------------------------------------
# Function 5: Find subject toppers
# (Accepts subject-wise marks separately)
# -------------------------------------------------------
def find_subject_toppers():
    subjects = ['English', 'Hindi', 'Maths', 'Science', 'Social Science']
    # subject_marks: {roll: [marks list]}
    subject_marks = {}

    print("\nEnter subject-wise marks for each student:")
    for roll, (name, _) in students.items():
        print(f"\nStudent: {name} (Roll: {roll})")
        marks = []
        for sub in subjects:
            m = float(input(f"  {sub}: "))
            marks.append(m)
        subject_marks[roll] = marks

    print("\nSubject Toppers:")
    for idx, sub in enumerate(subjects):
        topper_roll = max(subject_marks, key=lambda r: subject_marks[r][idx])
        topper_name = students[topper_roll][0]
        top_marks   = subject_marks[topper_roll][idx]
        print(f"  {sub:<20}: {topper_name} (Roll {topper_roll}) with {top_marks} marks")

# -------------------------------------------------------
# Main Menu
# -------------------------------------------------------
def main():
    while True:
        print("\n===== SMIS - Student Management System =====")
        print("1. Accept Student Details")
        print("2. Search Student by Roll Number")
        print("3. Display All Students' Results")
        print("4. Find Topper")
        print("5. Find Subject Toppers")
        print("6. Exit")
        choice = int(input("Enter your choice: "))

        if   choice == 1: accept_details()
        elif choice == 2: search_student()
        elif choice == 3: display_all()
        elif choice == 4: find_topper()
        elif choice == 5: find_subject_toppers()
        elif choice == 6:
            print("Exiting SMIS. Goodbye!")
            break
        else:
            print("Invalid choice. Please try again.")

main()

Key Design Decisions:

• Dictionary key = roll number (unique identifier).
• Dictionary value = tuple (name, percentage) — immutable as required by the hint.
• Each functionality is encapsulated in a separate user-defined function.
• Pass mark is taken as 33%.
• The topper is found using max() with a lambda key on percentage.