5. Python Control Structures and Data Handling: Questions and Answers

b) Only one

Only one else is allowed and it must come last. Multiple elif branches are allowed.

b) Indentation

Indentation (spaces or tabs at the start of a line) is mandatory and affects how the code executes.

c) 3.10

It is part of structural pattern matching and is an alternative to the switch statement of other languages.

c) _ (underscore)

b) 0

range(start, stop, step): start defaults to 0 and step defaults to 1.

c) 1 to 5

The stop value is not inclusive.

b) break

c) continue

b) after the loop finishes normally

b) infinite loop

It happens when the loop control variable is not updated.

b) 0

c) clear()

b) append()

d) Tuple

b) ("apple",)

The trailing comma is required.

c) Set

b) Intersection

a | b is union, a - b is difference, a ^ b is symmetric difference.

b) discard()

a) get()

Square brackets raise a KeyError for a missing key.

c) dictionary

Use set() to create an empty set.

if.

_ (underscore): case _.

Indentation.

for.

stop.

Nesting (nested loops).

break; continue.

while.

Square [ ]; parentheses ( ); curly braces { }.

Slicing.

count(); index().

len().

Comprehension. Example: [x*x for x in range(1, 6)].

Immutable.

add(); update().

Key-value; unique (and of an immutable type).

clear().

3.7.

Control structures are methods that dictate the flow of execution in a program. They answer the question 'What should happen next in a program?'. They allow decision-making, looping and branching based on conditions. The two main kinds are conditional statements and looping statements.

A code block is a group of statements executed together. In Python, indentation (spaces or tabs at the beginning of a line) is the only way to define code blocks such as conditional and looping statements. It is mandatory and directly affects how the code executes.

• Decision making
• Flow control
• Iterations
• Improved efficiency and flexibility
• Real-world applications

if condition:
    code block/ statement
elif condition:
    code block/ statement
else:
    code block/ statement

• The if statement checks the first condition.
• If it is false, the elif (else if) checks another condition.
• If neither is true, the else block is executed.
• Multiple elif branches are allowed; only one else is allowed and it must come last.
• elif and else are not compulsory.
• Only one block is executed, even if multiple conditions are true.

marks = int(input("Enter marks: "))
if marks >= 90:
    print("Grade A+")
elif marks >= 80:
    print("Grade A")
elif marks >= 70:
    print("Grade B+")
elif marks >= 60:
    print("Grade B")
elif marks >= 50:
    print("Grade C+")
elif marks >= 40:
    print("Grade C")
elif marks >= 30:
    print("Grade D+")
else:
    print("Grade D")

Output

Enter marks: 91
Grade A+

match-case was introduced in Python 3.10 as part of structural pattern matching. It is an alternative to the switch statement of languages like C++, Java and JavaScript. It compares a value against several patterns and executes the code of the first matching case; _ is the default case.

• Cleaner and more readable than long if-elif-else chains.
• Supports advanced pattern matching (tuples, lists, conditions within patterns).
• Enhances code maintainability.

match variable:
    case pattern1:
        # code block
    case pattern2:
        # code block
    case _:
        # default block

day = "Monday"
match day:
    case "Monday":
        print("Start of the week")
    case "Friday":
        print("Weekend is near")
    case _:
        print("Regular day")

Output

Start of the week

Looping allows a set of instructions to be executed repeatedly until a certain condition is met. It reduces the need to write the same code many times and makes programs shorter, faster and easier to maintain. It is used for processing collections of data, repeating calculations and controlling program flow, and is widely used in data processing, simulations and algorithm development.

A for loop iterates over a sequence (like a list or string) and performs actions on each item.

for loop_variable in sequence:
    # do required operation with loop_variable

• loop_variable takes the value of each element, one at a time.
• sequence is the collection being iterated over.
• The code block runs once for each item.

1. Python looks at the first item in the sequence.
2. It assigns that item to the loop variable.
3. It runs the code inside the loop.
4. It moves to the next item and repeats.
5. When all items are processed, the loop ends.

word = "hello"
for letter in word:
    print(letter)

Output

h
e
l
l
o

range() is a built-in function that generates a sequence of numbers, often used with for loops to repeat something a specific number of times.

range(start, stop, step)

• start: where the sequence begins (default 0)
• stop: where the sequence ends (not inclusive)
• step: how much to increase each time (default 1)

for i in range(1, 6):
    print(i)

Output

1
2
3
4
5

Placing one loop inside another is called nesting. Like a clock, the outer loop (hour hand) moves slowly while the inner loop (minute hand) completes a full cycle for each step of the outer loop.

for i in range(1, 4):
    for j in range(1, 4):
        print(i, "*", j, "=", i * j)

Output

1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9

for num in range(1, 10):
    if num == 5:
        break
    print(num)

Output

1
2
3
4

The loop stops when num becomes 5, so 5 is not printed.

for num in range(1, 6):
    if num == 3:
        continue
    print(num)

Output

1
2
4
5

When num is 3, continue skips print(num).

sentence = "Python is fun"
vowels = "aeiou"
count = 0
for char in sentence:
    if char.lower() in vowels:
        count += 1
print("Number of vowels:", count)

Output

Number of vowels: 3

An else clause can be used with a for loop. It runs after the loop finishes normally (that is, when the sequence is exhausted).

for i in range(3):
    print("Loop:", i)
else:
    print("Loop finished")

Output

Loop: 0
Loop: 1
Loop: 2
Loop finished

A while loop repeatedly executes a block of code based on a condition. The condition is evaluated before each iteration; if it is True the body runs, and once it becomes False the loop terminates.

while condition:
    block of code

count = 1
while count <= 5:
    print("Count is :", count)
    count += 1

Output

Count is : 1
Count is : 2
Count is : 3
Count is : 4
Count is : 5

An infinite loop occurs when the loop condition never becomes False. This can happen if the loop control variable is not updated.

i = 1
while i < 5:
    print("i =", i)   # missing increment: i never changes, so i < 5 is always True

break exits the while loop prematurely, even if the condition is still True.

i = 1
while i <= 10:
    print(i)
    if i == 5:
        break
    i += 1

Output

1
2
3
4
5

continue skips the current iteration and moves to the next one.

i = 0
while i < 6:
    i += 1
    if i == 3:
        continue
    print(i)

Output

1
2
4
5
6

The else block of a while loop executes when the loop condition becomes False.

i = 0
while i < 4:
    print("i =", i)
    i += 1
else:
    print("Loop finished")

Output

i = 0
i = 1
i = 2
i = 3
Loop finished

A while loop placed inside another while loop.

i = 1
while i <= 3:
    j = 1
    while j <= 2:
        print(f"i = {i}, j = {j}")
        j += 1
    i += 1

Output

i = 1, j = 1
i = 1, j = 2
i = 2, j = 1
i = 2, j = 2
i = 3, j = 1
i = 3, j = 2

• User input validation: repeatedly ask for input until valid data is entered.
• Menu-driven programs: keep displaying options until the user chooses to exit.
• Game loops: keep running the game logic until the player quits.

• Always ensure the loop condition will eventually become False.
• Use break and continue carefully to control the flow.
• Avoid infinite loops unless intentionally required (e.g. servers, games).
• Use comments to clarify the loop logic.

A list is a data structure that stores multiple items in a single variable. It is created with square brackets [ ] and can hold different data types (integers, strings, floats, even other lists). Characteristics: ordered (items keep a defined order), mutable (can add, remove or modify elements), allows duplicates, and indexed from 0.

List elements are accessed by index, starting from 0. A negative index counts from the end.

fruits = ["apple", "banana", "cherry"]
print(fruits[0])
print(fruits[2])
print(fruits[-1])

Output

apple
cherry
cherry

Slicing accesses a range of elements. Syntax: list[start:stop:step]. The stop index is not included.

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

Output

[20, 30, 40]

Lists are mutable, so an element can be changed by assigning a new value to its index.

fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"
print(fruits)

Output

['apple', 'blueberry', 'cherry']

• append(): adds an item to the end. fruits.append("orange")
• insert(): adds an item at a specific index. fruits.insert(1, "grape")
• extend(): adds the elements of another list. fruits.extend(["kiwi", "melon"])

• remove(): removes the first occurrence of a value. fruits.remove("banana")
• pop(): removes the item at a given index. fruits.pop(2)
• clear(): removes all items. fruits.clear()

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)
fruits.remove("banana")
print(fruits)
fruits.pop(1)
print(fruits)
print(len(fruits))

Output

['apple', 'banana', 'cherry', 'orange']
['apple', 'cherry', 'orange']
['apple', 'orange']
2

len() gives the number of items. A list can be traversed with a for loop or a while loop.

fruits = ["apple", "banana", "cherry"]
print(len(fruits))
for fruit in fruits:
    print(fruit)
i = 0
while i < len(fruits):
    print(fruits[i])
    i += 1

Output

3
apple
banana
cherry
apple
banana
cherry

Use the membership operators in and not in.

fruits = ["apple", "banana", "cherry"]
if "apple" in fruits:
    print("Apple is in the list")

Output

Apple is in the list

List comprehension is a concise way to create lists.

squares = [x * x for x in range(1, 6)]
print(squares)

Output

[1, 4, 9, 16, 25]

A list can contain other lists. An element is accessed using two indices: first the inner list, then the element in it.

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

Output

3

A tuple is a built-in data type that stores multiple items in a single variable, like a list, but its contents cannot be changed once created; this is why it is called immutable. Tuples suit fixed data such as coordinates, configuration settings or constants.

fruits = ("apple", "banana", "cherry")   # with parentheses
colors = "red", "green", "blue"           # without parentheses
empty = ()                                # empty tuple
single = ("apple",)                       # single element needs a trailing comma

Although tuples are immutable, these operations are possible: concatenation, repetition, membership testing, slicing, indexing, len() and looping.

a = (1, 2)
b = (3, 4)
c = a + b
print(c)
repeat = ("Hi",) * 3
print(repeat)
numbers = (10, 20, 30, 40, 50)
print(numbers[1:4])
print(numbers[::2])
print(30 in numbers)
print(len(numbers))

Output

(1, 2, 3, 4)
('Hi', 'Hi', 'Hi')
(20, 30, 40)
(10, 30, 50)
True
5

Tuples have only two methods because they are immutable: count() returns how many times a value appears, and index() returns the index of the first occurrence.

numbers = (1, 2, 3, 2, 2)
print(numbers.count(2))
print(numbers.index(3))

Output

3
2

A set is a built-in data type that stores multiple items in a single variable. Sets are unordered, unindexed and do not allow duplicate values. They are useful for removing duplicates, checking membership and performing union, intersection and difference.

• Unordered: no guaranteed order of items.
• Unindexed: elements cannot be accessed by index.
• No duplicates: duplicate values are removed automatically.
• Immutable elements: elements must be immutable (numbers, strings, tuples); lists and dictionaries cannot be elements.
• Mutable container: the set itself can be changed by adding or removing items.

fruits = {"apple", "banana", "cherry"}
colors = set(["red", "green", "blue"])   # set() constructor
empty = set()                            # NOT {} which creates a dictionary

• add(): adds a single element.
• update(): adds multiple elements.
• remove(): removes a specific item; raises an error if not found.
• discard(): removes an item without error if not found.
• pop(): removes a random item.
• clear(): removes all items.

Sets support mathematical operations: union, intersection, difference and symmetric difference.

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)    # union
print(a & b)    # intersection
print(a - b)    # difference
print(a ^ b)    # symmetric difference

Output

{1, 2, 3, 4, 5}
{3}
{1, 2}
{1, 2, 4, 5}

Union combines the elements of both sets (no duplicates). Intersection gives the elements common to both sets.

a = {"apple", "banana", "cherry"}
b = {"banana", "kiwi", "melon"}
print("Union:", sorted(a.union(b)))
print("Intersection:", a.intersection(b))
print("Difference:", sorted(a.difference(b)))

Output

Union: ['apple', 'banana', 'cherry', 'kiwi', 'melon']
Intersection: {'banana'}
Difference: ['apple', 'cherry']

(The order of elements in a set may vary each time; the output above is sorted for display.)

Use issubset().

x = {1, 2}
y = {1, 2, 3, 4}
print(x.issubset(y))

Output

True

names = ["Alice", "Bob", "Alice", "Charlie"]
unique_names = set(names)
print(sorted(unique_names))

Output

['Alice', 'Bob', 'Charlie']

A dictionary stores data as key-value pairs. Instead of numeric indices, unique keys are used to access the values. It suits structured data like student records.

student = {
    "name": "Aryananda",
    "age": 17,
    "class": "12A"
}
print(student)

Output

{'name': 'Aryananda', 'age': 17, 'class': '12A'}

• Key-value pairs: each item has a key and a value.
• Ordered: unordered before Python 3.7; from 3.7 onwards insertion order is preserved.
• Mutable: items can be added, updated or removed.
• Unique keys: a repeated key overwrites the previous value.
• Immutable keys: keys must be strings, numbers or tuples (not lists or dictionaries).
• Values can be any type: strings, numbers, lists, other dictionaries.

Using curly braces or the dict() constructor. With dict(), keys must be valid identifiers (no spaces or special characters).

student1 = {"name": "Aryananda", "age": 17}
student2 = dict(name="Sreerag", age=17, class_="CSE")
print(student1)
print(student2)

Output

{'name': 'Aryananda', 'age': 17}
{'name': 'Sreerag', 'age': 17, 'class_': 'CSE'}

Values are accessed with their keys, using square brackets or the get() method. get() is safer because it returns None if the key does not exist, whereas square brackets raise a KeyError.

student = dict(name="Sreenanda", age=17, class_="E1")
print(student["name"])
print(student.get("age"))
print(student.get("mark"))

Output

Sreenanda
17
None

Assign a new value to an existing key to update it, or assign to a new key to add a pair.

student = dict(name="Sreelakshmi", age=17, class_="XI")
student["age"] = 18          # update
student["school"] = "SNHSS"  # add
print(student)

Output

{'name': 'Sreelakshmi', 'age': 18, 'class_': 'XI', 'school': 'SNHSS'}

• pop(key): removes the item with the given key.
• popitem(): removes the last inserted item (Python 3.7+).
• del: deletes a key-value pair, e.g. del student["age"].
• clear(): removes all items.

student = dict(name="Devarag", age=17, class_="XI")
student.pop("class_")
del student["age"]
print(student)
student.clear()
print(student)

Output

{'name': 'Devarag'}
{}

i = 1
while i <= 10:
    print(i)
    i += 1

Output

1
2
3
4
5
6
7
8
9
10

i = 10
while i >= 1:
    print(i)
    i -= 1

Output

10
9
8
7
6
5
4
3
2
1

password = ""
while password != "python123":
    password = input("Enter password: ")
print("Access granted")

Output

Enter password: abc
Enter password: hello
Enter password: python123
Access granted

balance = 5000
choice = "yes"
while choice == "yes":
    amount = int(input("Enter amount to withdraw: "))
    if amount <= balance:
        balance = balance - amount
        print("Collect cash. Balance:", balance)
    else:
        print("Insufficient balance")
    choice = input("Another withdrawal? (yes/no): ")
print("Thank you")

Output

Enter amount to withdraw: 2000
Collect cash. Balance: 3000
Another withdrawal? (yes/no): yes
Enter amount to withdraw: 4000
Insufficient balance
Another withdrawal? (yes/no): yes
Enter amount to withdraw: 1000
Collect cash. Balance: 2000
Another withdrawal? (yes/no): no
Thank you

n = int(input("Enter a number: "))
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

Output

Enter a number: 5
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

for i in range(1, 4):
    for j in range(1, 4):
        print(i, "*", j, "=", i * j)

Output

1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9

text = input("Enter a string: ")
count = 0
for ch in text:
    if ch.lower() in "aeiou":
        count += 1
print("Number of vowels:", count)

Output

Enter a string: Computer Applications
Number of vowels: 8

total = 0
for i in range(1, 11):
    total += i
print("Sum =", total)

Output

Sum = 55

fruits = ["apple", "banana", "cherry", "orange", "grape"]
for fruit in fruits:
    print(fruit)

Output

apple
banana
cherry
orange
grape

numbers = [12, 45, 7, 89, 23]
largest = numbers[0]
for n in numbers:
    if n > largest:
        largest = n
print("Largest:", largest)

Output

Largest: 89

(The built-in max(numbers) gives the same result.)

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
odd_numbers = []
for n in numbers:
    if n % 2 != 0:
        odd_numbers.append(n)
print(odd_numbers)

Output

[1, 3, 5, 7]

cubes = [x ** 3 for x in range(1, 11)]
print(cubes)

Output

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

students = [["Anu", 85], ["Biju", 90], ["Diya", 78]]
print(students[1])
print(students[2][0])
print(students[0][1])

Output

['Biju', 90]
Diya
85

marks = [85, 90, 78, 92]
average = sum(marks) / len(marks)
print("Average marks:", average)

Output

Average marks: 86.25

shopping = []
shopping.append("milk")
shopping.append("bread")
shopping.append("eggs")
print(shopping)

Output

['milk', 'bread', 'eggs']

items = ["apple", "banana", "apple", "orange"]
unique_items = []
for item in items:
    if item not in unique_items:
        unique_items.append(item)
print(unique_items)

Output

['apple', 'banana', 'orange']

fruits = {"apple", "banana", "cherry", "orange", "grape"}
fruits.add("kiwi")
print(sorted(fruits))
print(len(fruits))

Output

['apple', 'banana', 'cherry', 'grape', 'kiwi', 'orange']
6

names = ["Alice", "Bob", "Alice", "Charlie"]
unique_names = list(set(names))
print(sorted(unique_names))

Output

['Alice', 'Bob', 'Charlie']

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print("Union:", a | b)
print("Intersection:", a & b)

Output

Union: {1, 2, 3, 4, 5, 6}
Intersection: {3, 4}

x = {1, 2}
y = {1, 2, 3, 4}
print(x.issubset(y))
print(y.issubset(x))

Output

True
False

numbers = {1, 2, 3, 4}
numbers.discard(3)
numbers.discard(10)   # no error even though 10 is not in the set
print(numbers)

Output

{1, 2, 4}

student = {"name": "Anu", "age": 17}
student["age"] = 18
student["class"] = "XI"
print(student)
del student["age"]
print(student)

Output

{'name': 'Anu', 'age': 18, 'class': 'XI'}
{'name': 'Anu', 'class': 'XI'}

name = input("Enter name: ")
mark = int(input("Enter mark: "))
result = {name: mark}
print(result)

Output

Enter name: Diya
Enter mark: 70
{'Diya': 70}

student = {"name": "Anu", "age": 17, "class": "XI"}
for key in student:
    print(key, ":", student[key])

Output

name : Anu
age : 17
class : XI

Conditional statements let a program make decisions based on conditions. The main ones in Python are if-elif-else and match-case.

• if-elif-else: if checks the first condition, elif checks further conditions, and else runs when none is true. Only one block runs.
• match-case: compares a value with several patterns and runs the first matching case; case _ is the default.

marks = 72
if marks >= 90:
    print("Grade A+")
elif marks >= 70:
    print("Grade B+")
else:
    print("Grade C")

day = "Friday"
match day:
    case "Monday":
        print("Start of the week")
    case "Friday":
        print("Weekend is near")
    case _:
        print("Regular day")

Output

Grade B+
Weekend is near

A for loop iterates over a sequence. range(start, stop, step) produces numbers (stop is not included). Loops can be nested. break stops the loop, continue skips an iteration, and an else clause runs when the loop ends normally.

for i in range(1, 4):
    for j in range(1, 3):
        print(i, j)

for n in range(1, 6):
    if n == 3:
        continue
    if n == 5:
        break
    print(n)
else:
    print("not printed because of break")

Output

1 1
1 2
2 1
2 2
3 1
3 2
1
2
4

A while loop repeats while its condition is True. Make sure the loop variable is updated, otherwise the loop becomes infinite. break exits early, continue skips the current iteration, and else runs when the condition becomes False.

i = 0
while i < 6:
    i += 1
    if i == 3:
        continue
    if i == 5:
        break
    print(i)
else:
    print("else part")

Output

1
2
4

A list is an ordered, mutable, indexed collection that allows duplicates, created with [ ].

fruits = ["apple", "banana", "cherry"]
print(fruits[0], fruits[-1])
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])
fruits.append("orange")
fruits.insert(1, "grape")
fruits.extend(["kiwi", "melon"])
print(fruits)
fruits.remove("banana")
fruits.pop(2)
print(fruits)
print(len(fruits))

Output

apple cherry
[20, 30, 40]
['apple', 'grape', 'banana', 'cherry', 'orange', 'kiwi', 'melon']
['apple', 'grape', 'orange', 'kiwi', 'melon']
5

A tuple is an ordered, immutable collection created with ( ). Its contents cannot be changed after creation, which makes it ideal for fixed data. Tuples support indexing, slicing, concatenation, repetition, membership testing, len() and looping, and have only count() and index() as methods.

A set is an unordered, unindexed collection of unique elements; elements must be immutable but the set itself is mutable. Methods: add, update, remove, discard, pop, clear. Operations: union (|), intersection (&), difference (-), symmetric difference (^), issubset, issuperset, isdisjoint.

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

Output

{1, 2, 3, 4, 5}
{3}
{1, 2}
{1, 2, 4, 5}

A dictionary stores key-value pairs; keys are unique and immutable, values can be of any type, and the dictionary is mutable (and keeps insertion order from Python 3.7).

student = dict(name="Sreelakshmi", age=17, class_="XI")
print(student["name"])
print(student.get("age"))
student["age"] = 18
student["school"] = "SNHSS"
print(student)
student.pop("class_")
print(student)
print(list(student.keys()))
print(list(student.values()))

Output

Sreelakshmi
17
{'name': 'Sreelakshmi', 'age': 18, 'class_': 'XI', 'school': 'SNHSS'}
{'name': 'Sreelakshmi', 'age': 18, 'school': 'SNHSS'}
['name', 'age', 'school']
['Sreelakshmi', 18, 'SNHSS']

for i in range(1, 4):
    print("for:", i)
i = 1
while i <= 3:
    print("while:", i)
    i += 1

Output

for: 1
for: 2
for: 3
while: 1
while: 2
while: 3