False. Lists are mutable — their elements can be changed, added, or removed after creation. Tuples are immutable.

True. Tuples can contain elements of any type: (1, "hello", 3.14, True). They are heterogeneous collections.

False. Dictionary keys must be unique. If you assign a value to an existing key, it overwrites the previous value.

d = {'a': 1, 'a': 2}
print(d)  # {'a': 2} — the second value overwrites the first

False. sort() sorts the list in place and returns None. To get a new sorted list without modifying the original, use the sorted() function.

a = [3, 1, 2]
b = a.sort()   # b is None, a is [1, 2, 3]
c = sorted(a)  # c is [1, 2, 3], a is unchanged

True. len() returns the number of elements in a list or tuple, and the number of key-value pairs in a dictionary.

False. (5) is just an integer in parentheses (Python treats it as 5). (5,) is a single-element tuple. Always include the trailing comma for a single-element tuple.

True. Lists can contain any data type, including other lists (nested lists). Example: [[1, 2], [3, 4], [5, 6]].

a = [1, 2]
a.append([3, 4])
print(a)    # [1, 2, [3, 4]] — nested list

b = [1, 2]
b.extend([3, 4])
print(b)    # [1, 2, 3, 4] — flat list

a = [10, 20, 30, 20, 40]
a.remove(20)   # [10, 30, 20, 40] — removes first 20
val = a.pop(1)  # val = 30, a = [10, 20, 40] — removes and returns index 1
del a[0]       # [20, 40] — deletes element at index 0

List Creation:

# Different ways to create lists
numbers = [10, 20, 30, 40, 50]          # List of integers
names = ["Ravi", "Priya", "Kumar"]        # List of strings
mixed = [1, "hello", 3.14, True]          # List of mixed types
nested = [[1, 2], [3, 4], [5, 6]]         # Nested list (list of lists)
empty = []                                # Empty list
from_range = list(range(1, 6))           # [1, 2, 3, 4, 5]

List Indexing and Slicing:

fruits = ["apple", "banana", "cherry", "date", "elderberry"]

# Indexing
print(fruits[0])    # "apple" — first element
print(fruits[-1])   # "elderberry" — last element
print(fruits[2])    # "cherry" — third element

# Slicing
print(fruits[1:4])   # ["banana", "cherry", "date"]
print(fruits[:3])    # ["apple", "banana", "cherry"]
print(fruits[2:])    # ["cherry", "date", "elderberry"]
print(fruits[::-1])  # Reverse: ["elderberry", "date", "cherry", "banana", "apple"]

List Methods:

# Adding elements
a = [10, 20, 30]
a.append(40)         # [10, 20, 30, 40] — add at end
a.insert(1, 15)      # [10, 15, 20, 30, 40] — add at index 1
a.extend([50, 60])   # [10, 15, 20, 30, 40, 50, 60] — add multiple

# Removing elements
a.remove(15)          # [10, 20, 30, 40, 50, 60] — remove value 15
val = a.pop()         # val = 60, a = [10, 20, 30, 40, 50] — remove last
val = a.pop(1)        # val = 20, a = [10, 30, 40, 50] — remove at index

# Other methods
a.sort()              # [10, 30, 40, 50] — sort in ascending order
a.reverse()           # [50, 40, 30, 10] — reverse the list
print(a.count(10))   # 1 — count occurrences
print(a.index(40))   # 1 — first index of value
print(len(a))        # 4 — number of elements

Program: Find largest and smallest element in a list

# Program to find largest and smallest in a list
numbers = []
n = int(input("Enter number of elements: "))

for i in range(n):
    num = int(input(f"Enter element {i+1}: "))
    numbers.append(num)

print("List:", numbers)
print("Largest element:", max(numbers))
print("Smallest element:", min(numbers))

# Without using max() and min():
largest = numbers[0]
smallest = numbers[0]

for num in numbers:
    if num > largest:
        largest = num
    if num < smallest:
        smallest = num

print("Largest (manual):", largest)
print("Smallest (manual):", smallest)

Output:

Dictionary Creation:

# Different ways to create dictionaries
student = {'name': 'Ravi', 'age': 16, 'marks': 95}
empty = {}                                     # Empty dictionary
from_pairs = dict([('a', 1), ('b', 2)])        # From list of tuples
from_kwargs = dict(name='Priya', age=17)       # From keyword arguments

# Accessing values
print(student['name'])        # Ravi — using key
print(student.get('age'))     # 16 — using get()
print(student.get('grade', 'N/A'))  # N/A — default value

# Modifying dictionary
student['grade'] = 'A'        # Add new key-value pair
student['marks'] = 98         # Update existing value
student['age'] += 1           # Modify value
print(student)
# {'name': 'Ravi', 'age': 17, 'marks': 98, 'grade': 'A'}

Dictionary Methods:

student = {'name': 'Ravi', 'age': 16, 'marks': 95}

# keys(), values(), items()
print(student.keys())    # dict_keys(['name', 'age', 'marks'])
print(student.values())  # dict_values(['Ravi', 16, 95])
print(student.items())   # dict_items([('name', 'Ravi'), ('age', 16), ('marks', 95)])

# Iterating through dictionary
for key in student:
    print(key, ":", student[key])

# Using items() for key-value pairs
for key, value in student.items():
    print(f"{key} = {value}")

# pop() — remove and return value
marks = student.pop('marks')   # marks = 95, 'marks' key removed

# update() — merge dictionaries
student.update({'school': 'ABC', 'city': 'Chennai'})

# Checking if key exists
if 'name' in student:
    print("Name exists:", student['name'])

# delete a key
del student['age']

Dictionary Operations:

# Length
d = {'a': 1, 'b': 2, 'c': 3}
print(len(d))          # 3

# Membership (checks keys, not values)
print('a' in d)        # True
print(1 in d)          # False (1 is a value, not a key)
print(1 in d.values()) # True (check values)

# Copy a dictionary
d2 = d.copy()

# Clear all entries
d.clear()              # d becomes {}

Program: Count character frequency using a dictionary

# Program to count frequency of each character in a string
def char_frequency(text):
    freq = {}
    for char in text:
        if char in freq:
            freq[char] += 1
        else:
            freq[char] = 1
    return freq

# Main program
string = input("Enter a string: ")
result = char_frequency(string)

print("\nCharacter Frequency:")
print("-" * 25)
for char, count in sorted(result.items()):
    print(f"'{char}' : {count}")

# Total characters
print(f"\nTotal characters: {len(string)}")
print(f"Unique characters: {len(result)}")

Output:

Trace for "programming": p→1, r→1, o→1, g→1, r→2, a→1, m→1, m→2, i→1, n→1, g→2

Tuple Creation:

# Different ways to create tuples
t1 = (1, 2, 3, 4, 5)          # Tuple of integers
t2 = ("apple", "banana")       # Tuple of strings
t3 = (1, "hello", 3.14, True)  # Mixed types
t4 = ()                         # Empty tuple
t5 = (5,)                       # Single element (comma required!)
t6 = tuple([1, 2, 3])          # From a list
t7 = tuple("abc")               # From a string: ('a', 'b', 'c')

# Important: (5) is an integer, NOT a tuple
print(type((5)))    # <class 'int'>
print(type((5,)))   # <class 'tuple'>

Tuple Indexing and Slicing:

t = (10, 20, 30, 40, 50)

# Indexing
print(t[0])    # 10 — first element
print(t[-1])   # 50 — last element

# Slicing
print(t[1:4])   # (20, 30, 40)
print(t[:3])    # (10, 20, 30)
print(t[::-1])  # (50, 40, 30, 20, 10) — reversed

Tuple Operations:

# Concatenation
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(t1 + t2)    # (1, 2, 3, 4, 5, 6)

# Repetition
print(t1 * 3)     # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Membership
print(2 in t1)     # True

# Length
print(len(t1))    # 3

# Min, Max
print(min(t1))    # 1
print(max(t1))    # 3

Tuple Methods:

t = (1, 2, 3, 2, 4, 2)

# count() — number of occurrences
print(t.count(2))    # 3

# index() — first index of value
print(t.index(2))    # 1

# Sorted (returns a list, not tuple)
print(sorted(t))     # [1, 2, 2, 2, 3, 4]
print(tuple(sorted(t)))  # (1, 2, 2, 2, 3, 4)

Why use tuples?

• Immutable — data cannot be accidentally changed
• Faster than lists (no modification overhead)
• Can be used as dictionary keys (lists cannot)
• Used for fixed data like days of week, coordinates, constants

(a) Program: Swap two numbers using tuples

# Program to swap two numbers using tuple packing/unpacking
a = int(input("Enter first number (a): "))
b = int(input("Enter second number (b): "))

print(f"Before swapping: a = {a}, b = {b}")

# Swap using tuple packing and unpacking
a, b = b, a

print(f"After swapping: a = {a}, b = {b}")

Output:

How it works: b, a creates a tuple (20, 10). Then a, b = (20, 10) unpacks the tuple, assigning 20 to a and 10 to b.

(b) Program: Student record using a dictionary

# Program to create and display a student record using a dictionary

# Create student dictionary
student = {}

# Input student details
student['roll_no'] = int(input("Enter roll number: "))
student['name'] = input("Enter name: ")
student['class'] = input("Enter class: ")
student['marks'] = {}

# Input marks for 3 subjects
subjects = ['Tamil', 'English', 'Maths']
for subject in subjects:
    mark = int(input(f"Enter {subject} marks: "))
    student['marks'][subject] = mark

# Calculate total and average
total = sum(student['marks'].values())
average = total / len(student['marks'])
student['total'] = total
student['average'] = average

# Determine grade
if average >= 90:
    student['grade'] = 'A'
elif average >= 80:
    student['grade'] = 'B'
elif average >= 70:
    student['grade'] = 'C'
elif average >= 60:
    student['grade'] = 'D'
else:
    student['grade'] = 'E'

# Display student record
print("\n" + "=" * 40)
print("       STUDENT RECORD")
print("=" * 40)
print(f"Roll Number  : {student['roll_no']}")
print(f"Name         : {student['name']}")
print(f"Class        : {student['class']}")
print("-" * 40)
print("Subject-wise Marks:")
for subject, mark in student['marks'].items():
    print(f"  {subject:10s} : {mark}")
print("-" * 40)
print(f"Total        : {student['total']}")
print(f"Average      : {student['average']:.2f}")
print(f"Grade        : {student['grade']}")
print("=" * 40)

Output: