Day 9 | Loops in Python (For Loop & While Loop) with DevOps Use Cases

Loops are a fundamental programming construct available across almost all languages, including C, C++, Java, Python, and Node.js. In DevOps and automation, loops allow us to perform repetitive tasks—such as checking the status of multiple servers, waiting for cloud resources to provision, or processing log files—without writing redundant code. This chapter covers the mechanics of for and while loops, loop control statements (break and continue), and practical DevOps use cases.

1. The Core Problem: Why Do We Need Loops?

In software development and systems automation, we frequently need to execute a block of code multiple times. Without loops, executing repetitive tasks requires manually duplicating code.

The Naive Approach (Manual Duplication)

If you want to print a string five times, you might copy-paste the print statement:

print("Abhishek")
print("Abhishek")
print("Abhishek")
print("Abhishek")
print("Abhishek")

While copy-pasting works for 5 iterations, it becomes completely unmanageable if you need to execute the code 10,000 times, 1 million times, or dynamically based on user input.

The Loop Approach

Using a loop, we can compress those repetitive lines of code into a clean, highly scalable block:

for i in range(10):
    print("Abhishek")

Real-Life Analogy

Think of the loading dots (...) you see on a terminal interface while waiting for a program to install or execute. Behind the scenes, the program runs a loop that repeatedly prints a dot at set intervals until the main installation process completes.

2. The Mental Model: For Loop vs. While Loop

Python provides two primary types of loops: the for loop and the while loop. Choosing between them depends on whether the number of iterations is definite (known beforehand) or indefinite (dependent on a dynamic condition).

3. Deep Dive into the Python For Loop Syntax

The for loop in Python is designed to iterate over a sequence (such as a list, a tuple, or a range of numbers).

Syntax Structure

for variable in sequence:
    # Block of code to execute

Keyword Breakdown

1. for: The keyword that initiates the loop.
2. variable: A placeholder variable (e.g., i, x, fruit) that stores the current element of the sequence during the current iteration.
3. in: The membership operator that retrieves the next element from the sequence and assigns it to the loop variable.
4. sequence: An iterable object (like a list, tuple, or range) that the loop traverses.

4. Working with Sequences: Lists, Tuples, and the range() Function

To understand how the for loop tracks its execution state, let's look at how it interacts with different sequence types.

A. Iterating Over a List

When iterating over a list, the in keyword sequentially assigns each element to the loop variable.

colors = ["yellow", "green", "blue"]

for x in colors:
    print(x)

Execution Flow:

1. First iteration: x is assigned "yellow". The loop prints "yellow".
2. Second iteration: x is assigned "green". The loop prints "green".
3. Third iteration: x is assigned "blue". The loop prints "blue".
4. The sequence is exhausted; the loop terminates.

B. Iterating Using the range() Function

The range() function is a built-in Python utility that generates a sequence of numbers. By default, range(n) generates integers starting from 0 up to (but not including) n.

for i in range(10):
    print(i, "Abhishek")

Note: Conceptually, range(10) behaves similarly to a list containing [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

Output:

0 Abhishek
1 Abhishek
2 Abhishek
...
9 Abhishek

The variable i acts as an indicator or tracker for the loop, incrementing automatically on each iteration.

5. Deep Dive into the Python While Loop Syntax

The while loop is used when you do not know the exact number of iterations beforehand. It evaluates a boolean condition before each iteration. If the condition is True, the code block executes. If it evaluates to False, the loop terminates.

Syntax Structure

while condition:
    # Block of code to execute

The Danger of Infinite Loops

Because while loops run as long as their condition is True, you must ensure that the code block eventually modifies the state so that the condition becomes False. Otherwise, you will create an infinite loop that consumes system resources indefinitely.

# WARNING: Infinite Loop Example
count = 1
while count <= 5:
    print("This will run forever because count never changes!")

To fix this, increment the control variable:

count = 1
while count <= 5:
    print(count)
    count += 1  # Increments count by 1 each iteration

6. Loop Control Statements: break vs. continue

Sometimes, you need to alter the standard flow of a loop based on an external condition. Python provides two statements for loop manipulation: break and continue.

A. The break Statement

The break statement terminates the loop immediately. Any remaining iterations are skipped, and control passes to the next statement outside the loop.

for number in range(1, 6):
    if number == 3:
        break
    print(number)

Output:

1
2

Explanation: When number equals 3, the break statement executes, immediately terminating the loop.

B. The continue Statement

The continue statement skips the rest of the code inside the loop for the current iteration only and jumps directly to the next iteration.

for number in range(1, 6):
    if number == 3:
        continue
    print(number)

Output:

1
2
4
5

Explanation: When number equals 3, the continue statement skips the print(number) line and moves to the next iteration where number is 4.

7. DevOps Use Cases: When to Use For Loops

DevOps engineers use for loops when performing operations on a pre-defined, static list of resources.

Use Case 1: Multi-Environment Application Deployment

When deploying an application to a known set of environments, a for loop ensures consistent execution across all targets.

environments = ["dev", "staging", "prod"]

for env in environments:
    print(f"Deploying application artifacts to the [{env}] environment...")
    # Code to trigger deployment APIs or scripts

Use Case 2: Database Backup Operations

If you manage a static list of databases that require sequential backups:

databases = ["users_db", "orders_db", "inventory_db"]

for db in databases:
    print(f"Starting backup process for: {db}")
    # Code to execute pg_dump or mysqldump

Use Case 3: Iterating Over Target Servers

Performing configuration updates or health checks across a static inventory of servers:

servers = ["192.168.1.10", "192.168.1.11", "192.168.1.12"]

for server in servers:
    print(f"SSHing into {server} to run security patches...")
    # Code to execute remote commands

8. DevOps Use Cases: When to Use While Loops

DevOps engineers use while loops when dealing with dynamic states, external APIs, or asynchronous operations where the duration of the task is unknown.

Use Case 1: Waiting for Kubernetes Pod Readiness

When deploying to Kubernetes, pods do not spin up instantly. You must query the API repeatedly until the deployment status is healthy.

# Conceptual representation of waiting for a deployment
deployment_ready = False

while not deployment_ready:
    print("Checking deployment status via kubectl...")
    # In a real script, you would query the Kubernetes API here
    # status = get_kubernetes_deployment_status()
    # if status == "Ready": deployment_ready = True
    
    # Temporary simulation to avoid infinite loop in testing
    deployment_ready = True 
    print("Deployment is ready!")

Use Case 2: Deleting Temporary Files Until a Directory is Empty

If a cleanup script needs to purge files from a temporary directory, the number of files can vary wildly. A while loop is ideal here:

# Conceptual cleanup loop
import os

# Assume temp_dir is a list of files in a folder
temp_files = ["log1.txt", "log2.txt", "cache.db"]

while len(temp_files) > 0:
    file_to_delete = temp_files.pop()
    print(f"Deleting file: {file_to_delete}")

print("Temporary directory is clean.")

Use Case 3: Monitoring AWS EC2 Instance State

When spinning up an EC2 instance using an automation script, the instance transitions from pending to running. You must poll the AWS API until the state changes.

instance_state = "pending"
attempts = 0

while instance_state != "running":
    print(f"Instance is pending... checking again (Attempt {attempts})")
    attempts += 1
    if attempts >= 3:
        instance_state = "running"  # Simulating state change

print("EC2 Instance is fully operational!")

Note: In production Python scripts, DevOps engineers use libraries like boto3 (for AWS) or the official kubernetes Python client to query these states. Because raw shell commands cannot be executed directly as native Python code without wrapper modules (like subprocess), we use these conceptual structures to build our automation logic.

9. Real-World Workflow: Checking Kubernetes Pod Readiness

The following vertical workflow illustrates how a Python automation script uses a while loop to poll a Kubernetes cluster, waiting for a microservice deployment to become healthy before proceeding with an integration test suite.

10. Summary and Key Takeaways

• Loops Eliminate Redundancy: Loops allow the repetitive execution of a block of code without manual code duplication, making automation scripts clean and maintainable.
• For Loops are for Definite Iteration: Use a for loop when you know the exact number of iterations beforehand (e.g., iterating over a list of 3 target servers or a range of 10 numbers).
• While Loops are for Indefinite Iteration: Use a while loop when the number of iterations depends on a dynamic condition (e.g., waiting for a cloud resource to provision or a service to become healthy).
• The in Keyword Assigns State: In a for loop, the in keyword automatically fetches the next item from the sequence and assigns it to the loop variable.
• range() Generates Sequences: The range(n) function generates a sequence of integers from 0 to n-1, which is highly useful for executing a loop a specific number of times.
• break Terminates Immediately: The break statement stops the loop entirely and transfers control to the code outside the loop.
• continue Skips the Current Iteration: The continue statement skips the remaining code in the current iteration and immediately moves to the next iteration.
• DevOps Automation Relies on Loops: Whether you are iterating over environments (dev, stage, prod), backing up databases, or polling cloud APIs, mastering loops is essential for writing robust infrastructure-as-code and configuration management scripts.