Unit 2: Conditional and Iterative Statements - Subjective Questions

The modulus operator % returns the remainder obtained when one number is divided by another.

If is divided by , then:

where is the quotient and is the remainder. In Python, a % b produces .

Examples:

• 17 % 5 evaluates to 2.
• 20 % 4 evaluates to 0.
• 7 % 10 evaluates to 7.

Applications:

• Checking even or odd numbers: A number n is even when n % 2 == 0.
• Testing divisibility: n % d == 0 means that n is divisible by d.
• Cyclic operations: The expression (index + 1) % size can wrap an index back to zero.

Python provides the random module for generating pseudo-random values. It is imported using import random.

• random.random() returns a floating-point value in the interval .
• random.randint(a, b) returns an integer in the inclusive interval .
• random.randrange(start, stop, step) selects a value from the same sequence represented by range(start, stop, step). The stop value is excluded.

Examples:

import random

x = random.random()       # 0.0 <= x < 1.0
y = random.randint(1, 6) # 1 through 6
z = random.randrange(2, 11, 2) # 2, 4, 6, 8, or 10

These functions are commonly used in games, simulations, testing, sampling, and randomized algorithms.

A Boolean expression is an expression whose result is either True or False.

Python comparison operators include:

• ==: equal to
• !=: not equal to
• <: less than
• >: greater than
• <=: less than or equal to
• >=: greater than or equal to

Examples:

• 8 > 3 evaluates to True.
• 5 == 7 evaluates to False.
• 10 != 4 evaluates to True.

Python also interprets values in Boolean contexts. Values such as 0, 0.0, None, and empty strings or collections are considered falsy. Most other values are truthy.

Boolean expressions control the execution of conditional statements and loops.

Logical operators combine or reverse Boolean expressions.

and operator: It is True only when both operands are true.

or operator: It is True when at least one operand is true.

not operator: It reverses a truth value: not True is False, and not False is True.

age = 20
has_id = True

can_enter = age >= 18 and has_id
is_special_case = age < 12 or age >= 60
invalid = not has_id

Python uses short-circuit evaluation: and stops when it finds a falsy operand, while or stops when it finds a truthy operand.

Conditional statements select code according to Boolean conditions.

Simple if: The block executes only when the condition is true.

if temperature > 30:
    print('Hot day')

if-else: Exactly one of two blocks executes.

if number % 2 == 0:
    print('Even')
else:
    print('Odd')

if-elif-else: Conditions are checked from top to bottom. The first true branch executes, and the remaining branches are skipped.

if score >= 90:
    grade = 'A'
elif score >= 75:
    grade = 'B'
elif score >= 50:
    grade = 'C'
else:
    grade = 'F'

A colon is required after each condition, and indentation defines each controlled block.

An if-elif-else ladder chooses one branch from several alternatives at the same logical level. A nested conditional places one conditional inside another and is useful when a second decision depends on the result of the first.

Ladder example:

if marks >= 80:
    result = 'Distinction'
elif marks >= 50:
    result = 'Pass'
else:
    result = 'Fail'

Nested example:

if marks >= 50:
    if marks >= 80:
        result = 'Pass with distinction'
    else:
        result = 'Pass'
else:
    result = 'Fail'

Comparison:

• A ladder is usually clearer for mutually exclusive alternatives.
• Nesting expresses dependent or hierarchical decisions.
• Excessive nesting reduces readability and may often be simplified using logical operators or early returns.
• Indentation is essential because it identifies which branch contains the inner condition.

A year is a leap year when it is divisible by , or when it is divisible by but not by .

The Boolean condition is:

year = int(input('Enter a year: '))

if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
    print('Leap year')
else:
    print('Not a leap year')

Explanation:

• Years divisible by 400, such as 2000, are leap years.
• Years divisible by 100 but not 400, such as 1900, are not leap years.
• Other years divisible by 4, such as 2024, are leap years.
• Parentheses make the intended grouping of logical expressions explicit.

A while statement repeatedly executes a block as long as its condition remains true. It is appropriate when the number of iterations is not known in advance.

A counter-controlled while loop usually contains:

• Initialization: Set the initial loop-control value.
• Condition: Decide whether another iteration should run.
• Update: Change the loop-control value.
• Termination: Stop when the condition becomes false.

count = 1
while count <= 5:
    print(count)
    count += 1

Here, count = 1 initializes the counter, count <= 5 is tested before every iteration, and count += 1 updates it. The loop terminates when count becomes 6.

If the update is omitted, the condition may remain true forever, producing an infinite loop.

In sentinel-controlled iteration, a special value called a sentinel indicates that input has ended. The number of repetitions does not need to be known beforehand.

total = 0
number = int(input('Enter a number (-1 to stop): '))

while number != -1:
    total += number
    number = int(input('Enter a number (-1 to stop): '))

print('Sum:', total)

Working:

• -1 is the sentinel value.
• The loop continues while the input is not -1.
• Valid inputs are added to total.
• The sentinel is checked before it can be included in the sum.

A sentinel should normally be a value that cannot be confused with valid input. If negative numbers are valid data, a different termination mechanism may be needed.

A for loop iterates over the items of an iterable, such as a string, list, tuple, or range.

for item in iterable:
    statement

The range() function generates an integer sequence:

• range(stop) produces values from 0 to stop - 1.
• range(start, stop) begins at start and excludes stop.
• range(start, stop, step) changes each value by step.

Examples:

for i in range(5):
    print(i)       # 0, 1, 2, 3, 4

for i in range(2, 8, 2):
    print(i)       # 2, 4, 6

for i in range(5, 0, -1):
    print(i)       # 5, 4, 3, 2, 1

The step cannot be zero. A negative step is used for descending sequences.

Both loops repeat statements, but they express repetition differently.

Use a for loop when:

• Processing every item in a list or string.
• Repeating a fixed number of times.
• Iterating over a range().

Use a while loop when:

• Waiting until valid input is received.
• Repeating until a sentinel occurs.
• Simulating a process whose stopping time is unknown.

The choice should communicate the intended form of iteration clearly.

Python provides statements that alter normal loop execution.

• break immediately terminates the nearest enclosing loop.
• continue skips the rest of the current iteration and begins the next iteration.
• A loop's else clause executes when the loop finishes normally, but it does not execute when the loop is terminated by break.

for number in range(2, 10):
    if number == 5:
        continue
    if number == 8:
        break
    print(number)
else:
    print('Loop completed normally')

This code skips 5 and terminates at 8; therefore, the else block is not executed.

A common use of loop else is searching: the else block reports failure only when no matching item caused a break.

A nested loop places one loop inside another. For every iteration of the outer loop, the inner loop completes all its iterations.

for row in range(1, 11):
    for column in range(1, 11):
        product = row * column
        print(f'{product:4}', end='')
    print()

Explanation:

• The outer loop selects each row from 1 through 10.
• For every row, the inner loop selects each column from 1 through 10.
• Each displayed value is .
• end='' keeps products on the same line.
• The final print() moves output to the next row.

Since both loops execute times, the multiplication operation is performed times. In general, loops of sizes and perform inner iterations.

A nested while loop contains one while loop inside another. The inner loop completes its iterations for each iteration of the outer loop.

row = 1
while row <= 5:
    column = 1
    while column <= row:
        print('*', end=' ')
        column += 1
    print()
    row += 1

Output:

*
* *
* * *
* * * *
* * * * *

The outer loop controls the number of rows. The inner loop prints as many symbols as the current row number. column must be reinitialized to 1 at the start of every outer iteration. Both loop-control variables must be updated to prevent infinite loops.

Both forms represent multidimensional or repeated iteration, but their control mechanisms differ.

Nested for loops:

• Best when iterating over known ranges or collections.
• Loop-variable progression is handled automatically.
• Usually shorter and easier to read for tables, matrices, and patterns.

Nested while loops:

• Best when repetition depends on conditions that may change unpredictably.
• Require explicit initialization and updating of each control variable.
• Provide more flexible control but have a greater risk of infinite loops.

Examples of applications:

• Nested for: processing every cell of a matrix or producing a multiplication table.
• Nested while: repeatedly validating grouped input or simulating condition-controlled processes.

For loops with outer size and inner size , the body may run times. If both sizes grow as , the time complexity is commonly .

The randint() function can simulate each die because a standard die has integer outcomes from through .

import random

rolls = 0
while True:
    die1 = random.randint(1, 6)
    die2 = random.randint(1, 6)
    rolls += 1

    print(die1, die2)
    if die1 + die2 == 12:
        break

print('Number of rolls:', rolls)

Explanation:

• Two new random integers are generated during every iteration.
• rolls records the number of attempts.
• while True creates an indefinite loop.
• The loop terminates through break when die1 + die2 == 12.

Only the outcome gives a sum of . Assuming fair independent dice, its probability on one roll is , although the actual number of iterations varies each time.

Repeated random trials can approximate an event's probability. The ratio of successful outcomes to total trials approaches the theoretical probability as the number of trials becomes large.

import random

trials = 10000
heads = 0

for _ in range(trials):
    toss = random.randint(0, 1)
    if toss == 1:
        heads += 1

estimated_probability = heads / trials
print(estimated_probability)

Explanation:

• 0 may represent tails and 1 may represent heads.
• The for loop conducts exactly 10000 trials.
• heads counts successful outcomes.
• The estimate is calculated as:

For a fair coin, the result should usually be near , but it will not necessarily be exactly because of random variation.

Encapsulation means grouping related logic into a self-contained unit and exposing a clear interface for using it. In Python, functions encapsulate calculations, conditions, and loops behind a meaningful name.

def count_even(numbers):
    count = 0
    for number in numbers:
        if number % 2 == 0:
            count += 1
    return count

result = count_even([3, 4, 8, 11, 14])

The function encapsulates both the loop and the even-number condition.

Benefits:

• Reusability: The same operation can be called with different lists.
• Readability: count_even() communicates intent clearly.
• Maintainability: Changes are made in one location.
• Testing: The function can be tested independently.
• Information hiding: Callers need to know the inputs and result, not every implementation detail.

Generalization is the process of replacing fixed values or special-case logic with parameters so that one solution works for a broader class of problems.

A specific loop might print the numbers from 1 to 5:

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

It can be generalized as follows:

def display_sequence(start, stop, step=1):
    for number in range(start, stop, step):
        print(number)

display_sequence(1, 6)
display_sequence(10, 0, -2)

How it is generalized:

• start replaces a fixed starting value.
• stop replaces a fixed boundary.
• step controls the direction and interval.
• A default value keeps common calls concise.

Generalization improves reuse and reduces duplicated code, but parameters should represent meaningful variations rather than making a function unnecessarily complex.

The game can be encapsulated in a function and generalized through parameters that define the number range and attempt limit.

import random

def play_guessing_game(low, high, max_attempts):
    target = random.randint(low, high)

    for attempt in range(1, max_attempts + 1):
        guess = int(input(f'Guess a number from {low} to {high}: '))

        if guess == target:
            print(f'Correct in {attempt} attempts')
            return True
        elif guess < target:
            print('Too low')
        else:
            print('Too high')

    print(f'No attempts left. The number was {target}.')
    return False

play_guessing_game(1, 100, 7)

Concepts demonstrated:

• random.randint(low, high) generates the target.
• The for loop enforces the attempt limit.
• if-elif-else provides feedback.
• return ends the function immediately after a correct guess.
• Encapsulation keeps the complete game logic in one function.
• Parameters generalize the game for different ranges and difficulty levels.