Python Code Example: nested for-loop

This code snippet initializes four variables (`a`, `b`, `c1`, `c2`) and uses nested loops to count iterations and compare values.

• `a` is set to 5, `b` to 7, `c1` and `c2` are initialized to 0.
• The outer loop runs from 20 down to (but not including) 5, decrementing by 1 each time. For each iteration, `c1` is incremented by 1.
• The inner loop runs from 0 to 6 (7 times) for each iteration of the outer loop. For each iteration of the inner loop, `c2` is incremented by 1.
• Inside the inner loop, a conditional statement checks if the values of `i` and `j` are equal. If they are, it prints how many times each loop has run. However, given the ranges, this condition is never met, so the print statement is never executed.

Code Example

``````a, b, c1, c2 = 5, 7, 0, 0

for i in range(20, a, -1):
c1 = c1 + 1
for j in range(0, b):
c2 = c2 + 1
if i == j:
print("How many times the loops are run?")
print(
"first loop: "
+ str(c1)
+ "\nsecond loop: "
+ str(c2)
+ " ("
+ str(c1)
+ " * "
+ str(b)
+ ")"
)``````

Output

``````How many times the loops are run?
first loop: 15
second loop: 105 (15 * 7)``````

Variable Initialization

``a, b, c1, c2 = 5, 7, 0, 0``
• `a = 5`: This sets the variable `a` to 5.
• `b = 7`: This sets the variable `b` to 7.
• `c1 = 0`: This initializes the counter `c1` to 0.
• `c2 = 0`: This initializes the counter `c2` to 0.

Outer Loop

``````for i in range(20, a, -1):
c1 = c1 + 1``````
• `range(20, a, -1)` generates a sequence of numbers starting from 20 down to (but not including) `a` (which is 5), decrementing by 1 each time. So, the values of `i` will be 20, 19, 18, …, 6.
• `c1 = c1 + 1` increments `c1` by 1 each time the outer loop runs. This counts how many times the outer loop executes.

Inner Loop

``````    for j in range(0, b):
c2 = c2 + 1``````
• `range(0, b)` generates a sequence of numbers from 0 to `b-1` (which is 6). So, the values of `j` will be 0, 1, 2, 3, 4, 5, 6.
• `c2 = c2 + 1` increments `c2` by 1 each time the inner loop runs. This counts how many times the inner loop executes.

Conditional Statement

``````        if i == j:
print("How many times the loops are run?")
print(
"first loop: "
+ str(c1)
+ "\nsecond loop: "
+ str(c2)
+ " ("
+ str(c1)
+ " * "
+ str(b)
+ ")"
)``````
• `if i == j` checks if the current values of `i` and `j` are equal. If they are, it executes the print statement.
• The `print` statement outputs the number of times the outer loop has run (`c1`) and the number of times the inner loop has run (`c2`). It also shows that `c2` is equal to `c1` multiplied by `b` (since `c2` is incremented `b` times for each outer loop iteration).

Detailed Walkthrough

1. Initialization: `a = 5`, `b = 7`, `c1 = 0`, `c2 = 0`.
2. Outer Loop Execution:
• The outer loop starts with `i = 20` and decrements until `i > 5`.
• `c1` increments with each iteration of the outer loop.
3. Inner Loop Execution:
• The inner loop runs from `j = 0` to `j = 6` for each value of `i` in the outer loop.
• `c2` increments with each iteration of the inner loop.
4. Conditional Check:
• For each combination of `i` and `j`, the condition `if i == j` is checked.
• Given the ranges (`i` from 20 to 6 and `j` from 0 to 6), the condition `i == j` will never be true because the ranges do not overlap. Therefore, the print statement will never be executed.

Conclusion

Since the conditional statement `if i == j` will never be true given the ranges of `i` and `j`, the print statement inside the conditional block will not be executed.

However, if we are to determine how many times the loops would run in total:

• The outer loop runs from 20 to 6 (inclusive), which means it iterates 15 times (`20 - 6 + 1`).
• For each iteration of the outer loop, the inner loop runs 7 times.

Therefore:

• `c1` will be 15 after the outer loop finishes.
• `c2` will be `15 * 7 = 105` after all iterations of the inner loop.

Even though the print statement is never executed due to the ranges of `i` and `j`, this demonstrates how to count the number of loop executions using counters.