Repeating Tasks with Loops

In programming, many operations must be repeated multiple times—whether it’s processing items in a list, handling user input, or performing calculations. Python provides two main types of loops: while and for. Both allow you to repeat a block of code, but they serve slightly different purposes.

1. The while Loop

A while loop continues to execute a block of code as long as a given condition is true. Its structure is straightforward:

count = 1

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

Explanation:

• The loop checks the condition count <= 5.
• Since it is initially True, the block executes.
• After printing, count is incremented by 1.
• Once count exceeds 5, the condition becomes False, and the loop stops.

while loops are ideal when you don’t know in advance how many times the loop should run. For example, reading input until a user decides to quit:

command = ""

while command.lower() != "quit":
    command = input("Enter a command: ")
    print(f"You entered: {command}")

• This loop keeps prompting the user until they type "quit".
• Notice the importance of updating command inside the loop; otherwise, the condition would never become False, causing an infinite loop.

Tip: Always ensure the loop’s condition will eventually be False, otherwise your program will run indefinitely.

2. The for Loop

When the number of iterations is known in advance or when iterating over a sequence, the for loop is more convenient. Unlike some languages, Python’s for loop iterates directly over items of an iterable, such as lists, strings, or dictionaries.

Example with a list:

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

• The variable fruit takes the value of each element in the list sequentially.
• Python automatically ends the loop after the last element.

Using range() with for loops

The range() function generates sequences of numbers. It is commonly used for looping a specific number of times:

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

• Prints numbers 1 through 5.
• range(start, stop, step) allows you to customize the iteration pattern:

for i in range(10, 0, -2):
    print(i)

• Prints 10, 8, 6, 4, 2.
• start is the initial value, stop is exclusive, and step determines the increment or decrement.

Iterating over other iterables

Python’s for loop can work with any iterable, including strings, tuples, sets, and dictionaries:

# Iterating through a string
for char in "Python":
    print(char)

# Iterating through a dictionary
scores = {"Alice": 90, "Bob": 85}

for name, score in scores.items():
    print(f"{name} scored {score}")

• Using .items() allows accessing both keys and values in a dictionary.
• Python’s iterable-based for loop is cleaner and more Pythonic than manually using counters.

3. Nested Loops

A loop inside another loop is called a nested loop. Nested loops are useful when dealing with multi-dimensional data structures, such as matrices, grids, or tables:

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

Explanation:

• The outer loop runs 3 times.
• For each iteration of the outer loop, the inner loop runs 2 times.
• This produces all combinations of i and j:

i=0, j=0
i=0, j=1
i=1, j=0
i=1, j=1
i=2, j=0
i=2, j=1

Note: Nested loops can be computationally expensive. If you have large datasets, consider using list comprehensions, vectorized operations with NumPy, or other optimization techniques.

4. Best Practices for Loops

1. Avoid infinite loops: Always ensure the loop’s condition will eventually evaluate to False.
2. Prefer for loops for sequences: They are more readable and less error-prone than manually managing counters.
3. Use descriptive variable names: Instead of i or j, use row, column, item, etc., for clarity.
4. Break complex loops into functions: This improves readability and reusability.
5. Use enumerate() for indices: When you need both index and value, enumerate() avoids manually managing counters.

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits, start=1):
    print(f"{index}: {fruit}")

• Output:

1: apple
2: banana
3: cherry

5. Integrating Loops with Conditionals

Loops are often combined with if-elif-else statements to perform conditional repetition:

numbers = [10, 15, 20, 25]

for num in numbers:
    if num % 2 == 0:
        print(f"{num} is even")
    else:
        print(f"{num} is odd")

• Each number is checked for a condition inside the loop.
• Combines iteration with decision-making, a common pattern in real-world programs.

This approach of combining loops and conditionals forms the foundation for processing data, automating tasks, and building complex applications in Python.

Controlling Loops: break, continue, and pass

Python provides statements to control the execution flow within loops.

• break: Exits the nearest enclosing loop immediately.
• continue: Skips the rest of the current iteration and proceeds to the next.
• pass: Does nothing; used as a placeholder.

for num in range(5):
    if num == 2:
        continue  # skip 2
    if num == 4:
        break     # stop the loop at 4
    print(num)

Output:

0
1
3

pass is often used when defining a function or loop where the code block will be implemented later:

def future_function():
    pass

The else Clause with Loops

Python has a unique feature: loops can have an else block that executes only if the loop was not terminated by a break. This is particularly useful in search or validation logic.

for i in range(3):
    print(i)
else:
    print("Loop completed normally.")

If a break occurs, the else block is skipped:

for i in range(3):
    if i == 1:
        break
else:
    print("This will not print")

This allows handling success and failure cases clearly without additional flags or variables.

Advanced Loop Techniques

Python loops also support idiomatic constructs like:

• enumerate(): Provides index along with the element.
• zip(): Iterates over multiple iterables in parallel.
• reversed(): Iterates in reverse order.
• range(start, stop, step): Custom step sizes for counting.

names = ["Alice", "Bob", "Charlie"]

for index, name in enumerate(names, start=1):
    print(f"{index}: {name}")

This prints a numbered list of names, combining iteration with index tracking.

Next Blog- Python Data Structures