Python Control Statements

Control Statements in Python¶

• Control statements determine the flow of execution in a program. They allow us to manage the order in which statements are executed, enabling decision-making, repetition, and sequential execution.

• There are three primary types of control flow:

  1. Sequential Execution – Executes statements in the order they are written.
  2. Selection Control (Decision Making) – Executes different statements based on conditions.
  3. Iteration (Looping) – Repeats a block of code multiple times.

1. Sequential Control¶

• Definition: Statements execute one after another in a linear fashion.
• Behavior: No branching or repetition occurs.

2. Selection Control (Decision Making)¶

• Definition: The program chooses a path based on conditions.
• Behavior: Executes different blocks of code depending on conditions (e.g., if-else, Match).

3. Iteration Control (Looping)¶

• Definition: Repeats a block of code until a condition is met.
• Behavior: Executes loops (for, while).

Python If...Else Statements¶

• Python provides conditional statements to control the flow of execution based on specific conditions.

• Python supports the following logical conditions for comparisons:

  • Equals: a == b
  • Not Equals: a != b
  • Less than: a < b
  • Less than or equal to: a <= b
  • Greater than: a > b
  • Greater than or equal to: a >= b

If Statements¶

• In Python, the if statement is the most basic form. It evaluates a given condition and checks whether it is True or False.
  • If the condition evaluates to True, the block of code under the if statement executes.
  • If the condition evaluates to False, that block is skipped, and the program continues with the next line of code following the if block.

Syntax:

if condition:
    statement_1
    statement_2
    ...
    statement_n

Indentation in If Statements¶

• Python uses indentation to define code blocks. Incorrect indentation leads to errors.

if views > threshold:
print("Intensity Coding has reached a milestone!")  # IndentationError

The elif Statement¶

• The elif keyword is used to check additional conditions when the previous if statement is false.

Syntax:

if condition:
    statement_1
elif another_condition:
    statement_2

The else Statement¶

• The else clause is used to define a block of code that executes only when all previous conditions evaluate to False. It acts as a fallback option when none of the specified conditions are satisfied.

Syntax:

if condition:
    statement_1
elif another_condition:
    statement_2
else:
    statement_3

Syntax of the if-else statement¶

• If there is no need for an elif, you can use only else:

if condition:
    statement 1
else:
    statement 2

Short-Hand If Statement¶

• When an if statement has only one line, it can be written in a single line.

Short-Hand If...Else (Ternary Operator)¶

• For concise conditional expressions, Python allows a short-hand format.

Logical Operators (and, or, not)¶

Using and Operator¶

• Both conditions must be True for the block to execute.

Using or Operator¶

• At least one condition must be True for execution.

Using not Operator¶

• Reverses the result of a condition.

Nested If Statements¶

• An if statement inside another if statement is called a nested if. It allows the program to check multiple levels of conditions sequentially.

Syntax:

if condition_outer:
    if condition_inner:
        # Executed when both outer and inner conditions are True
        statement_of_inner_if
    else:
        # Executed when outer condition is True but inner condition is False
        statement_of_inner_else
    # Executed when the outer condition is True (after inner block completes)
    statement_of_outer_if
else:
    # Executed when the outer condition is False
    statement_of_outer_else

# Statement outside all if-else blocks
statement_outside_if_block

The pass Statement¶

• Python does not allow empty if statements. However, you can use the pass keyword if an if block is required but should not execute any code.

Python match Statement¶

• Python introduced the powerful match statement in version 3.10, bringing pattern matching capabilities similar to switch-case in languages like C, Java, or JavaScript — but far more expressive and Pythonic.

• The match statement allows you to compare a value (called the subject) against various patterns, executing code based on the first successful match. This provides a more readable and scalable alternative to lengthy if...elif...else chains.

Syntax¶

 match subject:
     case pattern1:
         # Executes if subject matches pattern1
     case pattern2:
         # Executes if subject matches pattern2
     case _:
         # Default fallback if no other pattern matches

How match Works¶

• The subject is evaluated once.
• Patterns are checked top-down.
• The first matching case block is executed.
• The _ is a wildcard pattern, similar to else.

Pattern Matching Use Cases¶

Basic Matching Example¶

Using _ as a Default Fallback¶

Match Multiple Conditions Using |¶

Use Guards (if) to Add Conditions¶

Matching Tuples (Sequence Pattern)¶

Matching Class Instances¶

Sequence Matching with Extended Unpacking¶

Matching Dictionaries (Mapping Pattern)¶

Nested Patterns with as¶

Python Loops – while and for¶

• Loops in Python allow executing a block of code multiple times. Python provides two primary loop types:
  • while loop – Executes as long as a specified condition is True.
  • for loop – Iterates over a sequence such as a list, tuple, dictionary, or string.

Python While Loops¶

while Loop¶

• The while loop executes a block of code as long as a specified condition evaluates to True.

Syntax:

while condition:
   # Code block to execute

• In a while loop, the condition is evaluated before each iteration begins. If the condition evaluates to True, the block of code inside the loop executes. Once the condition becomes False, the loop terminates, and the program continues with the next statement following the loop.

Infinite Loop¶

• A while loop without a stopping condition runs indefinitely.

break Statement¶

• The break statement stops the loop even if the condition remains True.

continue Statement¶

• The continue statement skips the current iteration and moves to the next.

else Statement¶

• The else block runs after the while loop finishes execution.
• If the loop is terminated prematurely by either a break or return statement, the else clause won’t execute at all.

Nested while Loops¶

• A nested while loop is a loop inside another loop. The outer loop runs first, and for each iteration of the outer loop, the inner loop executes completely.

Key Points

• The outer loop controls the main iteration.
• The inner loop runs completely for each iteration of the outer loop.
• Both loops require proper exit conditions to avoid infinite loops.

Syntax

while condition_outer:
    # Outer loop body
    while condition_inner:
        # Inner loop body

Nested while Loops with break¶

• Break : Immediately exits the current loop (inner loop in nested cases).
• Using break in the inner loop does not affect the outer loop except in logic flow.

Syntax with break

while condition_outer:
    # Outer loop body
    while condition_inner:
        if some_condition:
            break  # Exit inner loop immediately

Nested while Loops with continue¶

• continue : Skips the rest of the current iteration and moves to the next iteration of the loop.
• Using continue in the inner loop does not affect the outer loop except in logic flow.

Syntax with continue

while condition_outer:
    # Outer loop body
    while condition_inner:
        if some_condition:
            continue  # Skip current iteration of inner loop

Python For Loops¶

• A for loop in Python is used to iterate over a sequence, such as a list, tuple, dictionary, set, or string. Unlike traditional loops in other languages that use indexing, Python's for loop works more like an iterator.
• Unlike a while loop, which continues execution as long as a certain condition remains true, a for loop is typically used when the number of iterations is predetermined—you already know how many times the loop should run.

Syntax:

for element in sequence:
    # Code block to be executed repeatedly
    body_of_for_loop

Looping Through a List¶

• A for loop allows us to iterate through each item in a list and perform actions on them.

Looping Through a String¶

• Strings in Python are sequences of characters, which means we can iterate through them like a list.

Using break in a For Loop¶

• The break statement stops the loop when a certain condition is met.

Using continue in a For Loop¶

• The continue statement skips the current iteration and moves to the next item.

The range() Function in For Loops¶

• The range() function generates a sequence of numbers, which can be useful for loops.

Else in a For Loop¶

• The else block in a for loop runs when the loop finishes normally (i.e., no break).
• If the loop is stopped with break, the else block does not execute.

The pass Statement in a For Loop¶

• The pass statement is used as a placeholder when a loop cannot be empty.

Nested for Loops¶

• A nested for loop is a loop inside another loop. The outer loop runs first, and for each iteration of the outer loop, the inner loop executes completely.

Syntax

for outer_variable in iterable_outer:
    # Outer loop body
    for inner_variable in iterable_inner:
        # Inner loop body

Nested for Loops with break¶

• Break : Immediately exits the current loop (inner loop in nested cases).
• Using break in the inner loop does not affect the outer loop except in logic flow.

Syntax with break

for outer_variable in iterable_outer:
    # Outer loop body
    for inner_variable in iterable_inner:
        # Inner loop body        
        if some_condition:
            break  # Exit inner loop immediately

Nested for Loops with continue¶

• continue : Skips the rest of the current iteration and moves to the next iteration of the loop.
• Using continue in the inner loop does not affect the outer loop except in logic flow.

Syntax with continue

for outer_variable in iterable_outer:
    # Outer loop body
    for inner_variable in iterable_inner:
        # Inner loop body   
        if some_condition:
            continue  # Skip current iteration of inner loop

Python range() Function¶

• The range() function in Python generates a sequence of numbers. It is commonly used in loops to iterate over a specified range without storing all values in memory, making it highly memory efficient.

Syntax¶

range(start, stop, step)

Parameter Details¶

Useful Information¶

Key Points About the range() Function¶

• The range() function operates only with integers — all its parameters (start, stop, and step) must be integer values. You cannot use floating-point numbers or other data types as arguments.
• Each of the three parameters can be either positive or negative.
• The step value cannot be zero; if you set step = 0, Python will raise a ValueError.

1. Using range(stop) – Default Start (0) and Step (1)¶

2. Using range(start, stop) – Specified Start and Default Step (1)¶

3. Using range(start, stop, step) – Specified Step Value¶

4. Using range() with a Negative Step (Counting Backwards)¶