Python Control Flow Statements:- IF-Elif-Else, For & While Loop, Break, Continue, Pass

Looping in Python

Type of loops in Python

In Python, there are primarily two fundamental loop constructs for iterating over sequences of elements:

1. for loop:

• Used to iterate over a sequence of elements (like lists, tuples, strings, dictionaries).
• Executes a block of code for each element in the sequence.

Syntax:

for element in sequence:
    # Code to be executed for each element

Example:

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

Output:

apple
banana
cherry

2. while loop:

• Executes a block of code as long as a certain condition is true.
• More flexible than for loops, as the condition can be based on any logic and may change within the loop.

Syntax:

while condition:
    # Code to be executed while the condition is true

Example:

count = 0
while count < 5:
  print(count)
  count += 1  # Increment count

Output:

0
1
2
3
4

Additional Considerations:

• break statement: Used to exit a loop prematurely when a specific condition is met within the loop.
• continue statement: Used to skip the current iteration of the loop and move on to the next one.
• Nested Loops: Loops can be nested within each other to create more complex iterations.

Choosing the Right Loop:

• If you know the exact number of elements in a sequence, a for loop is typically more concise and readable.
• If you need to iterate until a specific condition is met, a while loop is more appropriate.

By effectively using these loop constructs, you can automate repetitive tasks and control the flow of your Python programs.

For Loops

The syntax for a for loop in Python is concise and easy to understand. Here’s a breakdown of its components:

Basic Structure:

for item in iterable:
  # code to be executed for each item

Explanation:

• for: This keyword initiates the loop.
• item(Variable): This is a placeholder variable that takes on the value of each item in the sequence during each iteration of the loop. You can choose any meaningful name for this variable.
• in: This keyword specifies that you’re looping through the elements in the sequence.
• iterable: This is the iterable object (like a list, string, tuple, etc.) that the loop will iterate over. The for loop will extract each item from the sequence one by one and assign it to the item variable.
• # code to be executed for each item: This is the indented code block that will be executed for each item in the sequence. The indentation level is crucial! It defines which lines of code are part of the loop body.

Example 1: Looping through a List

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

In this example, the loop iterates over the fruits list. In each iteration, the current fruit (e.g., “apple” in the first iteration) is assigned to the fruit variable, and the indented print statement is executed.

Example 2: Looping through a String

name = "Alice"
for letter in name:
  print(letter.upper())  # Print each letter in uppercase

Here, the loop iterates over each letter in the name string. The current letter is assigned to the letter variable in each iteration, and the print statement converts it to uppercase before printing.

Key Points:

• The for loop automatically handles the iteration and stops when it reaches the end of the sequence.
• You can use any iterable object (like a dictionary or a custom class with an iterator) in the sequence part.
• The loop variable (item in our examples) is temporary within the loop and cannot be accessed outside of the loop’s indented block.

By mastering the for loop in Python, you can efficiently iterate over sequences and perform operations on each item, making your code more concise and readable.

Range Function

The range() function is versatile and widely used in Python for generating sequences of numbers. It’s helpful for iterating over sequences, generating lists of numbers, and various other tasks where you need a series of numbers.

range(start, stop[, step])

• start: The starting value of the sequence (inclusive). If omitted, it defaults to 0.
• stop: The end value of the sequence (exclusive). This is the number up to which the sequence generates values.
• step: The step or increment between each number in the sequence. If omitted, it defaults to 1.

Syntax 1: range(start=0,end=len(sequence),step=1)

list(range(1,5))
[0,1,2,3,4]

list(range(1,10,2))
[1,3,5,7,9]

range(stop)

range(3) 

range(3+1) 

range(start, stop)

range(2, 6)     

range(5,10+1) 

range(start, stop, step)

range(4, 15+1, 2)         

range(2*2, 25, 3+2) 

range(10, 0, -2)  

Nested for loops

Nested for loops are a powerful tool in Python, allowing you to perform iterations over multi-dimensional data structures such as lists of lists, matrices, and more. Let’s explore some complex examples to understand nested for loops better.

1. Matrix Addition

Adding two matrices element-wise using nested for loops.

A = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

B = [
    [9, 8, 7],
    [6, 5, 4],
    [3, 2, 1]
]

# Initialize the result matrix with zeros
result = [[0 for _ in range(len(A[0]))] for _ in range(len(A))]

# Perform element-wise addition
for i in range(len(A)):
    for j in range(len(A[0])):
        result[i][j] = A[i][j] + B[i][j]

print("Result of matrix addition:")
for row in result:
    print(row)

2. Transpose of a Matrix

Finding the transpose of a matrix using nested for loops.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Initialize the transpose matrix with zeros
transpose = [[0 for _ in range(len(matrix))] for _ in range(len(matrix[0]))]

# Compute the transpose
for i in range(len(matrix)):
    for j in range(len(matrix[0])):
        transpose[j][i] = matrix[i][j]

print("Transpose of the matrix:")
for row in transpose:
    print(row)

3. Multiplication Table

Generating a multiplication table using nested for loops.

# Define the size of the multiplication table
size = 10

# Generate the multiplication table
multiplication_table = [[i * j for j in range(1, size + 1)] for i in range(1, size + 1)]

print("Multiplication table:")
for row in multiplication_table:
    print(row)

4. Generating Combinations

Generating all possible combinations of elements from two lists using nested for loops.

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]

combinations = []

for item1 in list1:
    for item2 in list2:
        combinations.append((item1, item2))

print("All combinations:")
for combination in combinations:
    print(combination)

5. Image Processing (Grayscale to Binary)

Converting a grayscale image to a binary image using nested for loops (assuming the image is represented as a 2D list of pixel values).

# Example grayscale image (2D list of pixel values)
grayscale_image = [
    [120, 200, 150],
    [30, 255, 75],
    [100, 180, 220]
]

# Threshold value for binary conversion
threshold = 128

# Initialize binary image
binary_image = [[0 for _ in range(len(grayscale_image[0]))] for _ in range(len(grayscale_image))]

# Convert grayscale to binary
for i in range(len(grayscale_image)):
    for j in range(len(grayscale_image[0])):
        binary_image[i][j] = 1 if grayscale_image[i][j] > threshold else 0

print("Binary image:")
for row in binary_image:
    print(row)

6. Word Search Puzzle

Searching for a word in a 2D grid of characters using nested for loops.

grid = [
    ['c', 'a', 't'],
    ['d', 'o', 'g'],
    ['r', 'a', 't']
]

word = "cat"
found = False

for i in range(len(grid)):
    for j in range(len(grid[0])):
        # Check if the first character matches and search horizontally
        if grid[i][j] == word[0]:
            if j + len(word) <= len(grid[0]) and all(grid[i][j + k] == word[k] for k in range(len(word))):
                found = True
                break
    if found:
        break

print(f"Word '{word}' found in grid: {found}")

7. Flattening a Nested List

Flattening a nested list using nested for loops.

nested_list = [[1, 2, [3, 4]], [5, 6], [7, 8, [9, 10]]]

def flatten_list(nested):
    flat_list = []
    for item in nested:
        if isinstance(item, list):
            flat_list.extend(flatten_list(item))
        else:
            flat_list.append(item)
    return flat_list

flattened_list = flatten_list(nested_list)
print("Flattened list:", flattened_list)

These examples demonstrate the use of nested for loops in various scenarios, including matrix operations, image processing, and working with nested lists. They show how powerful and versatile nested loops can be when dealing with complex data structures.

While Loop in Python

A while loop is a fundamental control flow construct in Python that allows you to execute a block of code repeatedly as long as a certain condition remains true. It’s particularly useful for situations where you don’t know beforehand how many times you need to iterate.

Syntax:

while condition:
    # Code to be executed as long as the condition is true

Explanation:

1. condition: This is a Boolean expression that determines whether the loop continues to execute. If the condition evaluates to True, the code block within the loop will run. If it evaluates to False, the loop terminates.
2. Code block: This is the indented block of code that gets executed repeatedly as long as the condition holds true.