Python Control Flow (if-else, switch) Exercises

• An if statement is a conditional statement.
• It evaluates the given condition:
  • If True, the indented block of code runs.
  • If False, the code block is skipped.

Example:

x = 10
if x > 5:
    print("x is greater than 5")

Output:

x is greater than 5

• Option 2: Incorrect, ignores the condition.
• Option 3: False — that would be handled by else.
• Option 4: Incorrect — repeating code is done using loops (for, while).

• The else block executes when the if condition evaluates to False.

Example:
 

x = 3
if x > 5:
    print("Greater than 5")
else:
    print("5 or less")

Output:

5 or less

• Option 1: elif is used for additional conditional checks after if.
• Option 2: then is not a Python keyword.
• Option 3: switch is not a Python keyword; Python uses match-case in 3.10+ or if-elif chains.

• x = 7 and the condition x < 5 is False.
• The else block runs when the if condition is False.
• Output: 5 or more
• Option 1: Wrong — condition is not met.
• Option 2: Wrong — print(x) is not used.
• This illustrates basic if-else branching.
• Option 4: No error occurs; syntax is correct. 

• Python uses logical operators and, or, not to combine multiple conditions.
• Option 1 correctly checks that both x > 5 and y < 10 are True.
• Option 2: then is not a valid keyword in Python.
• Option 3: Syntax is incorrect (or needs another condition).
• Option 4: Comma cannot combine conditions in if statements.

• x = 10, x % 2 == 0 evaluates to True because 10 is divisible by 2.
• The if block executes and prints "Even".
• Option 1: Wrong — condition is True, not False.
• Option 2: Wrong — code does not print x.
• Option 4: Wrong — no syntax error occurs.

• x = 15 → outer condition x > 10 is True → enter first if block.
• Inner if x % 2 == 0: 15 % 2 = 1 → False → execute else → prints "Odd and greater than 10".
• Option 1: False — 15 is not even.
• Option 3: False — x is greater than 10.
• Option 4: No error occurs; syntax is correct.

• x = 7 → x > 5 is True
• y = 12 → y < 10 is False
• if x > 5 and y < 10 → True and False = False → skip first block
• elif x > 5 or y < 10 → True or False = True → execute second block → prints "Condition B"
• Option 1: False — first condition not satisfied.
• Option 3: False — second condition satisfied.
• Option 4: No syntax error occurs.

• day = 3, so Python checks each case in order:

  1. case 1: False → skip

  2. case 2: False → skip

  3. case 3: True → execute print("Wednesday")

• The _ case acts as a default (like else or default in other languages).

• Output: Wednesday

• Option 1 & 2: Incorrect → day doesn’t match 1 or 2

• Option 4: Incorrect → _ case only executes if no other match

The code uses Python’s match-case to assign grades:

• score // 10 = 85 // 10 = 8
• Python checks each case in order:
  • case 10 | 9: False → skip
  • case 8: True → executes print("Grade B")

• _ acts as a default case for all unmatched values.

Summary:

• Output: Grade B
• Other options:
  • Option 1: False → 10 or 9 only
  • Option 3: False → 7 only
  • Option 4: False → default only executes if no match

Explanation detail
The code uses if-else combined with match-case to decide the output:

• First, the if score >= 90 condition is checked.

  • score = 92, so this is True.
  • Python executes print("Excellent") and skips the else block entirely.
• The match-case inside else is ignored because the if condition already ran.
• Output: Excellent

Quick notes:

• Option 1 & 2: Wrong → else block is not executed.
• Option 4: Wrong → default case in match-case is skipped.
• This shows that if-else takes priority, and match-case runs only if the else block is reached.

• First, age = 25 → age < 18 is False → skip first if.

• Enter the else block:

  • income < 30000 → 50000 < 30000? False → skip

  • income <= 70000 → 50000 <= 70000? True → execute print("Adult with Medium income") ✅

• The last else is ignored because one condition matched.

Key points:

• Nested if-else allows decision making on multiple variables.
• The code first checks age, then income for adults.
• Output: Adult with Medium income.

The code uses Python’s match-case (switch-style) to classify days:

• Step 1: day = 5

• Step 2: Python checks each case in order:

  • case 1 | 2 | 3 | 4 | 5 → True (5 matches) → execute print("Weekday") ✅

  • Remaining cases are skipped.

• Key points:

  • | allows multiple values in a single case.

  • _ acts as a default for unmatched values.

  • Output: Weekday

• Option 1: Incorrect → 5 is not 6 or 7

• Option 3: Incorrect → default only triggers if no match

• Option 4: Incorrect → no syntax error

The code uses if with nested logical operators to decide the output:

• Step 1: Evaluate x > 10 → 12 > 10 → True
• Step 2: Evaluate the expression inside parentheses: y < 10 or z > 10
  • y < 10 → 7 < 10 → True
  • z > 10 → 5 > 10 → False
  • Result of y < 10 or z > 10 → True or False → True
• Step 3: Combine with and: True and True → True
• Step 4: The if block executes → prints "Condition Met"

Summary:

• Nested logical operators allow complex decision-making.
• Option 1: Incorrect → condition is actually True.
• Option 2 & 4: Incorrect → syntax is valid and code prints output.

This code demonstrates nested if-else statements to determine weather conditions:

• Step 1: Check temperature > 30 → 35 > 30 → True
• Step 2: Enter the first if block and check humidity > 70 → 80 > 70 → True
• Step 3: Since both conditions are True, the code executes print("Hot and Humid")
• Step 4: The elif and else blocks are skipped because the first if ran.

Key Points:

• Nested if-else allows checking multiple related conditions in sequence.
• Outer if determines the main category (temperature).
• Inner if handles secondary factors (humidity).
• Output: Hot and Humid

This question demonstrates a tricky conditional expression to check eligibility based on age and ID:

• Step 1: The condition 18 <= age <= 60 ensures the age is between 18 and 60, inclusive.
• Step 2: The and has_id part ensures the person must have a valid ID.
• Step 3: Option 3 correctly combines both conditions using and and Python’s chained comparison for readability.

Why other options are incorrect:

• Option 1: Uses or incorrectly → a person without ID could still pass if age condition is met.
• Option 2: Excludes 18 and 60 due to strict > and < operators.
• Option 4: Misuses operator precedence → or makes the condition always True for many cases.

Key takeaway: Use parentheses or chained comparisons to combine multiple conditions correctly and avoid logical errors.

This code demonstrates Python’s match-case to differentiate weekdays and weekends:

• Step 1: day = 7, so Python checks each case in order.
• Step 2: case 1 | 2 | 3 | 4 | 5 → False → skip
• Step 3: case 6 | 7 → True → execute print("Weekend")

Why other options are incorrect:

• Option 1: 6 & 7 is invalid syntax for matching multiple values.
• Option 3: 6 or 7 does not work as expected in match-case; evaluates incorrectly.
• Option 4: Uses default _, which would incorrectly classify all days not 1-5 as "Weekend".

Key takeaway: Use | in match-case for multiple specific matches; do not confuse with or or &.

This code demonstrates complex logical conditions to control access:

• Step 1: is_admin = False, so the first part of or is False.
• Step 2: Evaluate the parentheses: has_key and has_password → True and True → True
• Step 3: Combine with or: False or True → True
• Step 4: print("Access Granted") executes ✅

Why other options are incorrect:

• Option 2: has_password = False → condition evaluates to False → no access.
• Option 3: Logical operators do not match the requirement; would give wrong results for some users.
• Option 4: Condition misuses parentheses → gives True for some invalid cases.

Key takeaway: Use parentheses to group logical conditions correctly; this ensures the intended precedence of and and or.

This example demonstrates a match-case structure with a default case for invalid input:

• Step 1: score = 105
• Step 2: Python checks each case in order:
  • Cases 90–100 → False
  • Cases 80–89 → False
  • Default case _ → True → execute print("Invalid")
• Step 3: Output is Invalid

Why other options are incorrect:

• Option 2: No default case → code would do nothing for score = 105
• Option 3: Python match-case does not allow relational expressions like 90 <= score <= 100 directly
• Option 4: Order matters → using score > 100 first is tricky, could be confusing; Option 1 is cleaner and explicit

Key takeaway: Use explicit matches for discrete values and a default _ case to handle invalid inputs clearly in match-case.

This code demonstrates a tricky combination of logical operators with nested conditions to determine discount eligibility:

• Step 1: loyal = False, so first part of or is False.
• Step 2: Evaluate parentheses: purchase > 1000 and membership → 1200 > 1000 and True → True
• Step 3: Combine with or: False or True → True
• Step 4: print("Special Discount") executes

Why other options are incorrect:

• Option 2: Uses and and or without parentheses → condition fails for some valid scenarios.
• Option 3: Membership is False → inner and evaluates to False → no discount.
• Option 1: Parentheses misplace precedence → some loyal customers without active membership would fail incorrectly.

Key takeaway: Always use parentheses to clearly define precedence in complex logical conditions combining and and or.

This question tests understanding of logical operator precedence in combined conditions:

• Step 1: is_admin = False → first part of or is False
• Step 2: Evaluate parentheses: is_manager and clearance > 5 → True and 6 > 5 → True
• Step 3: Combine with or: False or True → True
• Step 4: print("Valid Access") executes 

Why other options are incorrect:

• Option 2: Logical expression incorrectly combines and and or → fails in some valid scenarios.
• Option 3: Clearance = 4 → inner and evaluates to False → no access.
• Option 4: Parentheses change precedence → would incorrectly require clearance > 5 for admins too.

Key takeaway: Parentheses are crucial to ensure correct evaluation order when combining and and or in access control logic.