Loops in Python

A loop repeats a block of code. Each pass through the block is an iteration. A while loop checks a condition before every pass and runs its body while that condition is true. This suits a task such as “keep adding until the total reaches 100.”

Start, test, and update

A counting loop needs a starting value, a condition, and an update. The header ends with a colon. Indent the body by four spaces:

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

The output is:

3
2
1
Liftoff!

At the first check, n > 0 is true because n is 3. Python prints 3, subtracts 1, and returns to the header. It repeats with 2 and then 1. The update makes n equal to 0, so the next check is false. Python skips the body and runs the final print.

Indentation determines what repeats. Both indented lines belong to the body. The last line lines up with while, so it runs once after the loop. An if checks its condition once; while returns to check again after each completed body.

The check happens at the top

Changing a variable does not interrupt the rest of the current body:

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

This prints Still in this pass and then 0, on separate lines. The update makes the condition false, but Python checks it only when it returns to the header. Starting with n = 0 instead would skip the whole body: a while loop can run zero times.

Short updates and changing values

n -= 1 means n = n - 1. Similarly, count += 1 adds 1, balance *= 1.07 multiplies by 1.07, and n //= 10 replaces n with its integer quotient by 10. Python has no increment operator: count++ is a syntax error. Writing ++count applies unary plus twice and leaves the integer unchanged.

Here a loop removes one digit on each pass:

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

The remainder n % 10 is the last digit. First, 2 is added and n becomes 47. Next, 7 is added and n becomes 4. Finally, 4 is added and n becomes 0. The output is 13. The update both prepares the next pass and moves toward the exit.

A target loop need not have a count known in advance. Starting with a balance of 1000, multiplying it by 1.07 and increasing a year counter until it reaches 2000 takes 11 passes. After 10 passes the balance is about 1967.15; after 11 it is about 2104.85.

Conditions can combine comparisons with and, or, and not. Truthiness also works: for an integer, while n: repeats while n is nonzero. Use a condition whose meaning is easy to follow. Keep indentation consistent with spaces; mismatched levels can raise IndentationError, and mixed tabs and spaces can raise TabError.

An infinite loop keeps repeating without reaching an exit. You might see the same output scrolling or a program appearing to do nothing. To find the cause, follow the values used in the condition and look for a reachable way out.

Find the update

This loop keeps printing 3:

n = 3
while n > 0:
    print(n)

The test stays true because nothing changes n. Add n -= 1 inside the body to make the values 3, 2, and 1 print before the loop stops. Putting that update after the loop does not help: the program cannot reach it while the loop is still running.

The direction matters too. With while n > 0:, an update of n += 1 makes a positive value grow. Python integers do not wrap around at a fixed maximum to provide an accidental exit. Name the change you expect, such as “one fewer attempt remaining,” and check that the code makes that change on each path through the body.

A target can be missed

An update can change the value on every pass and still never reach an equality target:

n = 1
while n != 10:
    print(n)
    n += 2

The values are 1, 3, 5, 7, 9, 11, and so on. They are always odd, so none equals 10. For the task “print odd values below 10,” use while n < 10:. Once n becomes 11, that condition is false. The choice of comparison must match whether the task ends at a value or when a boundary is crossed.

Decimal steps and exact equality

Many decimal fractions are stored approximately as floats. Repeatedly adding 0.1 to 0.0 ten times gives 0.9999999999999999. A loop waiting for exact equality with 1.0 therefore misses its intended stop.

When the task is to visit a fixed set of tenths, count with integers and compute each decimal:

for i in range(11):
    x = i / 10
    print(x)

This visits 11 values from 0.0 through 1.0. The integer count controls the repetitions; the stored decimal does not decide whether the loop should stop.

Check every route through the body

Before running a while loop, locate its starting values, its condition, and every statement that changes those values. Check that the change can make the condition false. If an if skips an update, trace that route too. A temporary line such as print("n =", n) inside the body can show a value that is stuck or moving away from the boundary.

To interrupt a running program, press Ctrl+C in a terminal, or use the editor's Stop or Interrupt button. In a terminal, Python normally reports KeyboardInterrupt with a traceback.

Deliberate repetition

while True: deliberately keeps its header condition true. Its body uses break to leave the loop when an event occurs, such as the user entering “quit.” The exit must be reachable. An input loop may keep waiting because the user has not requested an exit; a bug is a loop whose logic makes the intended exit impossible.

An input loop can collect an unknown amount of data or keep asking until an answer is acceptable. In both cases, the new input must affect the next decision to repeat.

Stop at a sentinel

A sentinel is a special input that means “no more data.” Choose a value that cannot be a genuine data item. For positive counts, 0 can work; if 0 is a valid measurement, choose a different stop signal.

The priming read gets the first value before the condition is checked:

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

For inputs 4, 7, and 0, the body first adds 4, then adds 7. Reading 0 makes the next condition false. The program prints Total: 11; it never processes the sentinel. If the first input is 0, the body runs zero times and the total stays 0.

The final read inside the body is essential. Without it, the same first value is processed forever. The test must also happen before processing a newly read value: otherwise a sentinel can be counted as data.

Keep types consistent

input() returns text. The string "0" does not equal the integer 0. Convert numeric input with int() before comparing it with a numeric sentinel, or keep the input as text and compare with a string such as "done". A numeric conversion expects a valid numeric string; a range check tests the resulting number.

For an average, keep a counter alongside the total. With sentinel -1 and inputs 8, 6, 10, and -1, the total is 24 and the count is 3. Divide after the loop to get 8.0. If the first input is -1, the count stays 0, so use if count > 0: before division. That handles an empty data set without ZeroDivisionError.

Ask again while an answer is invalid

A validation loop describes the unacceptable answers in its condition:

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

With 150, -2, and 34, the warning appears twice. The value 34 makes both comparisons false, so the loop ends. The endpoints 0 and 120 are accepted too.

The word or matters: an age is invalid if it is below the minimum or above the maximum. Writing age < 0 and age > 120 would reject nothing, because one number cannot be both.

For a yes/no answer, the invalid test is answer != "y" and answer != "n". An answer must differ from both accepted strings to be rejected. With or, even "y" would repeat because it differs from "n". Trace one acceptable and one unacceptable answer to check such a condition.

The same tasks can use while True with one read in the body, followed by an exit test and break. That puts the decision immediately after the input and avoids writing the read twice.

A for loop visits the items of a sequence in order. At each pass, Python assigns the next item to the loop variable and runs the indented body. A loop over a sequence is often called a definite loop because the items give it a defined set of work.

One item at a time

A string is a sequence of characters:

for ch in "cat":
    print(ch)

This prints c, a, and t on separate lines. Spaces and punctuation count as characters too. The string "hi there" has eight characters, including its space, so visiting every character takes eight passes.

A list holds a sequence of values. Its literal form uses square brackets and commas:

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

The output is 6, 82, and 24, each on its own line. score is one number at a time, not the whole list and not its position. No manual counter update is needed to move from 3 to 41 to 12.

Use a name that describes one item: name in names, or score in scores. If the body never needs the current value, _ is a common name for that unused loop variable.

Assignment does not replace an item

The loop variable is an ordinary variable. Assigning a different number to it does not replace the number in the list:

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

The body prints 10, 20, and 30. On each new iteration, the next original list item is assigned to n. The final output line is [1, 2, 3]: the list itself has not changed. After the loop, n retains 30, the last value assigned to it in the body.

An empty sequence gives the body no work. With for ch in "":, there are zero passes, and the loop makes no assignment to ch. Do not rely on a loop creating its variable when there might be no items.

Membership inside a loop

In a for header, in introduces the sequence to visit. In a condition, it tests membership and produces True or False. These uses can work together:

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Each character is visited, but the counter changes only for e, u, a, i, and o. The output is 5. The if is indented inside the loop, and the counter update is indented inside the if.

This loop also shows why a loop variable and a counter have different jobs. ch holds the current character; vowels records how many characters have met the condition so far. The counter starts before the loop so it keeps its result between passes.

A bare integer cannot supply items: for i in 5: raises TypeError. To repeat an action five times, write for _ in range(5):. The range supplies the steps, even when the body does not use their values.

A range describes evenly spaced integers. It is useful for repeating work a set number of times, counting up or down, and selecting regular steps. Its stop value is always excluded.

Three forms

With one argument, that argument is the stop. With two, they are the start and stop. With three, the last argument is the step added after each value. range(0, 10, 3) visits 0, 3, 6, and 9; the next step would reach 12, so it is not supplied.

The stop stays excluded even when a step could land exactly on it. range(0, 10, 5) supplies only 0 and 5. For the default positive step of 1 and a stop above the start, the number of supplied values is the stop minus the start.

Count down with a negative step

range(5, 0, -1) supplies 5, 4, 3, 2, and 1. To include 0, put the stop below it: range(5, -1, -1) supplies six values, ending at 0.

The direction must match the bounds. range(5, 0) is empty because its default step is positive. range(1, 5, -1) is also empty because it starts below the stop but steps downward. Empty ranges are valid and cause zero iterations; a zero step, in contrast, raises ValueError.

Put the last required value inside the boundary

To add the even integers from 2 through 20:

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

The stop of 21 allows 20 to be visited. The ten values total 110, so the program prints 110. Using stop 20 would leave out 20 and give 90.

For a multiplication table, let the range supply the factors:

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

The first output line is 7 x 1 = 7, and the tenth is 7 x 10 = 70. If the number itself is unused, for _ in range(3): can repeat a message three times.

Inspect a range and check its arguments

list(range(2, 6)) produces [2, 3, 4, 5], which is useful when checking the bounds. len(range(0, 10, 3)) is 4. A range stores its defining bounds and step instead of building a list containing every integer.

The arguments are integers, including zero and negative integers: range(-3, 3) visits -3 through 2. A float such as 3.0 is rejected with TypeError, even though it has no fractional part. A count entered as text can be converted first with n = int(input("How many? ")), then used in range(n).

Choose a loop by asking what controls repetition. If there is a sequence of items to visit, or a count of repetitions, for usually expresses the work directly. If the next repetition depends on a changing condition or a future input, while puts that decision in its header.

Defined items or a changing condition

A count need not be written as a literal in the program. After reading n from input, range(n) still gives a definite set of steps. An indefinite loop waits on a condition whose stopping point is not specified as a repetition count.

Guessing a large number of repetitions is a poor fit for “until done.” A loop over range(1000) can exhaust its attempts before the user finishes, and a version without an exit check will continue after the work is complete.

Rewrite a counting loop

These two loops print 1 through 5, each number on its own line:

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

i = 1
while i < 6:
    print(i)
    i += 1

In the while version, the range's start becomes the initialization, the excluded stop becomes the < comparison, and the step becomes the update. The body uses i before that update. Moving the update before print(i) would shift the printed values.

Counting down changes both the comparison and the update:

i = 10
while i > 0:
    print(i)
    i -= 2

This prints 10, 8, 6, 4, and 2, just as for i in range(10, 0, -2): would. The descending range excludes its stop, so the matching while condition is i > 0.

The two forms match the printed counting task; their final loop-variable values differ. The while version performs its last update to 0 before stopping. The for version ends after assigning its last supplied value, 2.

A range keeps the bounds it was given

n = 3
for i in range(n):
    n = 10
    print(i)

This still prints 0, 1, and 2. The range was created using 3; assigning 10 to n does not rebuild it. A break can end the loop early, but changing that separate variable does not change the range's supplied numbers.

A while header, in contrast, evaluates its expression again on each return. If that expression uses n, changing n in the body can change when the loop ends. When both forms express a counting task clearly, the for version handles stepping without a manual update to forget.

break ends the innermost loop containing it immediately. Python skips the rest of that body and all remaining iterations, then continues after the loop. A condition inside the body decides when this early exit should happen.

Stop when the first result is found

Search for the first multiple of 7 above 50:

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

The loop checks 51, 52, 53, 54, 55, and 56. The remainder is zero at 56, so Python prints 56 and leaves the loop. It takes six iterations, even though the range can supply 49 numbers. Without break, the loop would also print later multiples of 7.

break is indented inside the if, so it runs only for a match. If it lined up with if instead, it would run on the very first iteration regardless of the test. A break inside an if ends the loop containing that if; it does not merely end the conditional block.

Read once, then decide whether to process

A while True loop places the exit decision after reading input:

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

For inputs “hello,” “there,” and “done,” the response lines are:

hello
there
Done!

The sentinel is tested before the processing line. When it appears, break jumps over print(line). The final unindented print still runs after the loop. There is only one input statement, because every pass begins by reading a new line.

A numeric total uses the same order: initialize total = 0 before the loop; read and convert a number; break if it is 0; otherwise add it. For 4, 7, and 0, the total is 11. Processing before the exit test would let the sentinel reach the calculation, which matters when the stop value could alter a count, product, or average.

Validate at the point of input

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

The chained comparison accepts an age from 0 through 120. It means 0 <= age and age <= 120. An accepted number exits before the warning; a number outside that range reaches the warning and then another input. In this form the if describes a valid answer, whereas a header-controlled validation loop describes an invalid one.

Read the jump literally

A statement after break in the same block cannot run. Put a message or saved result before the break when it belongs to the successful case. Put code after the loop when it should run after either an early exit or normal completion.

break must be inside a loop; otherwise Python raises SyntaxError. Several separate exit points can make a loop harder to follow. When a single condition naturally describes the task's stopping rule, keeping it in the header can make the path easier to trace.

continue skips the rest of the current iteration. The loop remains active: a for loop takes its next item, and a while loop returns to its condition. It is useful when an item should receive none of the processing that follows a check.

Skip selected values

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

The range supplies all ten integers from 1 through 10. At 3, 6, and 9, continue skips the addition. The sum of all ten is 55; leaving out those three values removes 18, so the program prints 37.

Continue does not remove an iteration from the range. The body still starts with each value, including the skipped ones. It changes which later lines execute on that pass.

A positive filter can express the same work. In a loop over [5, -2, 8, -7, 3], if n < 0: continue followed by print(n) prints 5, 8, and 3. Putting the print inside if n >= 0: gives the same output. Continue is often helpful when several processing lines follow, because rejected items can leave that part of the body immediately.

Do not skip a while update

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

This prints 0 and 1, then gets stuck at 2. At 2, continue jumps to the condition without reaching the update. The condition stays true, and the same branch is taken again.

To skip printing 2 while still making progress, update on that branch too:

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

Now the output is 0, 1, 3, and 4 on separate lines. The skipped path advances from 2 to 3. Each route through this body performs exactly one update.

Break, continue, and pass

For a loop over [1, 2, 3, 4], suppose an if n == 2: contains one of these statements and print(n) follows the if. Break prints only 1. Continue prints 1, 3, and 4. Pass prints all four values because it does not skip the print.

pass can fill a body where Python requires a statement while the code is being developed. It does not provide an update or an exit: while True: pass keeps running. Break and continue must be inside a loop and affect only the innermost loop containing them.

An else block can belong to a for or while loop. It runs once when the loop finishes normally: a for loop runs out of items, or a while condition becomes false. It is skipped when that loop ends through break. Read it as the no-break case.

Report a search that found no match

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

The loop reaches 15, prints First multiple of 5: 15, and breaks. The else is skipped. With [4, 9, 22], the loop uses every item without breaking and prints No multiple of 5 once.

The alignment is decisive. The else lines up with for, so it belongs to the loop. An else lined up with the inner if would run for each nonmatching item, announcing failure before the search had finished.

An empty list also reaches the loop else. There are no items, so the body runs zero times and there is no break. Likewise, a while loop whose condition is false at its first check runs its else immediately.

Search for a divisor

A prime number is an integer at least 2 whose only positive divisors are 1 and itself. Search for a divisor between those endpoints:

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

For 29, every remainder is nonzero and the loop else prints 29 is prime. For 21, the first divisor is 3 and the break skips the loop else. The outer check handles numbers below 2. Without it, an empty range for 1 would reach the else and incorrectly call 1 prime. For 2 the range is also empty, but the “prime” conclusion is correct.

Limited attempts with while else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

A correct guess takes the break, even on the third attempt. Three wrong guesses raise the counter to 3; the condition becomes false and the else prints the failure message. An ordinary statement after the loop would run in both cases, so it would not distinguish them.

Record the result with a flag

A flag is a Boolean variable that records whether something happened. Start found = False, change it to True when a match appears, and break. After the loop, if not found: handles failure. That provides the same search outcome as loop else, using an explicit record of the event. Choose a form whose indentation and exit path you can explain clearly.

An accumulator keeps a result between iterations. A counter is a particular accumulator that increases by 1 each time an event occurs. Set the starting value before the loop, update inside it, and use the finished result afterward.

Count events or add values

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

The test succeeds for 15, 22, and 11, so the output is 3. The update adds 1 for a matching item; adding n would total the matching values instead.

To sum every item, initialize total = 0, remove the if test, add total += n directly in the body, and print total afterward. The five values total 60. Their average is 60 / 5, which gives 12.0; division with / returns a float for these integer operands.

For a filtered average, update both the total and the count under the same condition:

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Here the selected total is 48 and the count is 3, so the output is 16.0. Dividing by the length of the whole list would use the wrong group. The count check also handles an empty list or a list with no matches.

Choose a starting value that fits the operation

A product of the integers 1 through 5 starts at 1 and finishes at 120. Starting it at 0 would keep every product at 0.

Text accumulation also depends on order:

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Each new character goes in front of the saved text, producing desserts. Changing the update to rev = rev + ch adds characters at the end and rebuilds stressed.

Keep the result between iterations

Moving total = 0 inside a sum loop erases the previous work on every pass. With [4, 15, 22, 8, 11], resetting before every addition leaves only 11 at the end. Initialize outside the loop so the next addition uses the previous subtotal.

A print inside the body shows the running total after each update: 4, 19, 41, 49, and 60 in this example. A print after the loop shows only 60. Choose its placement to match the requested output.

For a simple stored list, sum(values) gives its total and len(values) gives its count. An explicit loop lets you filter values, track several results together, or process values as they arrive from input.

To find a maximum, keep the largest value seen so far. Compare each new item with that saved value and replace it only when the new item is larger. The minimum pattern works the same way with the comparison reversed.

Start without inventing a data value

None is Python's value for “nothing yet.” It gives the first item a clear way to become the current best:

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

The saved values after each item are 12, 12, 25, and 25. The program prints 25. At the first item, largest is None is true. Python's or stops there, so it does not try the invalid comparison of a number with None. On later passes, the saved value is a number and the second comparison is used.

For a minimum, start smallest = None and use smallest is None or n < smallest. The same list produces -3.

Starting a maximum at 0 can report a value that never appeared. For -5, -2, and -9, no value exceeds 0, so that version would wrongly keep 0. The maximum is -2. Starting a minimum at 0 has the corresponding problem when every item is positive.

If the data is known to contain an item, using that first value as the starting best also works. Built-ins cover simple stored lists: max([12, -3, 25, 7]) gives 25 and min([12, -3, 25, 7]) gives -3. A custom loop can keep related information, such as where the value occurred.

Save the position when the best changes

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

The day counter advances for every item. The best day changes only when a new maximum appears. The final output is 26 4, meaning a temperature of 26 on day 4. Saving the day after the loop would merely save the last day examined.

Decide what a tie should do

For [5, 8, 8, 3], the test n > largest keeps the first 8 and its position, 2 when counting from 1. Replacing > with >= also updates on an equal value, keeping the last 8 at position 3. The largest number is unchanged; the saved position differs.

An empty list leaves a None-initialized best unchanged. Check for that state before reporting a number or doing arithmetic with it. It means no item has supplied a best value.

The comparison can use a property of an item. To keep the longest word among “pear,” “banana,” and “fig,” compare len(word) with the length of the saved word. “Banana” has six characters, so it wins. Save the word itself when it becomes best so the result identifies the item, not just its length.

A linear search checks items in order until it finds a match or runs out of items. A match may be an exact value, the first item passing a condition, or evidence for an “any” or “all” question.

Remember success

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

The flag starts false because nothing has been found yet. The first check, Ana, leaves it unchanged. The second check finds Ben, sets the flag true, and exits. The output is Ben is on the list.

The flag records an event across the whole search. Do not reset it on each nonmatch. If a loop continues after finding Ben and sets found = False when it reaches Chen, the successful result is lost. Likewise, “not found” belongs after all checks have failed, not inside a per-item else that announces failure for Ana before Ben is examined.

First match or last match

For [7, 4, 9, 10], the first even number is 4 and the last is 10. This loop saves the first one:

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

The output is 4. Remove the break and each new match overwrites the previous one, leaving 10. If nothing matches, the saved value remains None. Choose whether the task wants existence, the first item, the last item, or a position before deciding what to store.

To report a position, maintain a counter that advances for every examined item and save it on a match. Say how positions are numbered: counting from 1 makes Chen position 3 in the names list; Python's usual position numbering begins at 0.

Any needs one success; all needs one failure

An “any” search starts false and becomes true at the first item that passes. It can stop there because one success answers the question.

An “all” search starts true and becomes false at the first failure:

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

The third value, -1, disproves “all values are positive,” so the output is False. There is no need to inspect 5. Zero would also fail because positive means greater than zero. If there are no items, the flag remains true: no counterexample has appeared.

Exact membership and custom conditions

For equality alone, "Ben" in names directly gives True or False. A loop makes the changing search state visible and lets the test express a custom condition, such as “the first word longer than five characters.”

String comparisons are exact. "ben" differs from "Ben", and "Ben " includes a trailing space. A search for one of those strings must not treat the others as equal.

A nested loop is a loop inside another loop's body. For each outer iteration, the inner loop starts and runs through its work. The outer variable stays fixed while the inner variable changes.

Build one row at a time

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

The output has these three rows, each with a trailing space after its last number:

1 2 3 4 
2 4 6 8 
3 6 9 12 

First row is 1, while col takes 1 through 4. Then row becomes 2 and the inner loop begins again at column 1. Finally row 3 gets the same four columns. The inner body executes twelve times.

end=" " replaces print's usual newline with a space. The empty print() ends the row. It is inside the outer body but outside the inner body, so it runs three times. Indenting it one level farther would put every number on its own line. Removing its indentation would end a line only once, after both loops.

Give the loop variables distinct names, such as row and col. Reusing the outer name inside the inner loop overwrites the value needed to identify the current row.

Count the work

When every outer pass gets the same number of inner passes, multiply the counts. Three rows and four columns give twelve inner executions. Two loops with 100 passes each give 10,000 inner executions; three levels give 1,000,000. A small increase in each bound can therefore create much more repeated work.

If the inner bound changes with the outer variable, add the separate counts:

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

This prints:

*
**
***
****

The row lengths are 1, 2, 3, and 4, for ten stars in total. For a pattern with n such rows, the total is $n(n+1)\mathrm{/}2$. Multiplying four by four would wrongly assume every row has four stars.

Reset a result for each group

To total each row of the multiplication grid, set row_total = 0 inside the outer loop, just before the inner loop. Add row * col inside the inner body and print row_total after the inner loop. The outputs are 10, 20, and 30.

Initializing only once, before both loops, keeps earlier rows' totals too. Printing after each row then gives 10, 30, and 60. Both placements preserve a result, but one preserves a row result and the other preserves a whole-grid running total.

Visit combinations

Two loops over range(1, 7) visit all 36 ordered outcomes for two dice. The first loop supplies the first die and the second supplies the second die. A condition inside the inner body can count pairs whose sum is 7. Six pass: (1, 6), (2, 5), (3, 4), (4, 3), (5, 2), and (6, 1). Reversing a pair describes a different ordered outcome.

Break and continue act on the innermost loop containing them. In nested code, locate that loop before predicting what happens next. A break in the inner body does not by itself stop the outer loop.

Follow an inner break

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

At a = 1, the pair 1 1 prints. When b becomes 2, the break ends that inner loop. The outer loop advances to a = 2 and starts a fresh inner loop at b equal to 1. It prints 2 1 and 2 2, then breaks at b equal to 3. For a equal to 3, every b passes. The six output lines are:

1 1
2 1
2 2
3 1
3 2
3 3

Stop both loops with a recorded result

A search for a combination can use a flag and one break at each level:

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

Rows a equal to 1 and 2 have no match. On row 3, b reaches 4 and the product is 12. The inner break ends the b loop; the flag then makes the outer break run. The final output is 3 4.

The flag is initialized before both loops, because it records a result for the entire search. The outer if found: belongs after the inner loop but within the outer body. Its indentation gives it one check per completed or interrupted row.

Preserve values when the search continues

Removing only the outer break makes the search continue to later rows. In this example, a later match is 4 3, but the loop eventually examines row 5 and finishes with a = 5 and b = 5. Printing the loop variables then gives 5 5, not a stored match.

If the task needs the last matching pair, save best_a = a and best_b = b whenever a match occurs. Those separate variables retain a match while the loop variables continue changing. Check the found flag before reporting them when a match might not exist.

Skip a pair, then keep the row

A continue inside the inner loop moves to its next inner value. For two loops visiting 1 through 4, if a == b: continue before the processing skips four equal pairs. Twelve ordered pairs remain from the original sixteen.

An if can also select pairs without jumping. Two dice have three ordered pairs with sum 10: (4, 6), (5, 5), and (6, 4). A condition inside the inner body identifies them.

Tracing means running a program by hand, one statement at a time, while recording its values and output. A trace table gives each relevant variable a column. Label whether a value is recorded before or after an update so the rows have a clear meaning.

Trace a while loop

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Start with total = 0 and i = 1. Check the condition before entering the body. For each true check, run the addition before the increment:

The next check is 5 <= 4, which is false. There is no fifth body row. The body runs four times, the condition is checked five times, and the print after the loop outputs 10 once. Final values are i = 5 and total = 10.

Keep the failed check distinct from an iteration: it ends the loop without executing its body. If the initial condition is already false, there are no body rows at all and the variables retain their starting values.

Statement order changes the result

If the increment moves above the addition, each pass uses the new i. The four additions become 2, 3, 4, and 5, giving 14. The condition still tests i at the top, before that increment. Tracing only the header values would miss which value the addition actually uses.

When a body contains a break or continue, stop following its remaining lines as soon as the jump occurs. With continue, return to the header or next item; with break, proceed after the loop. A trace must follow those routes, not simply copy all body statements into each row.

Trace characters and nested loops

A for loop assigns the next item at the start of its pass:

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

The saved text becomes "a", then "ba", then "cba". The output is cba. Record the actual text, including its order, instead of writing only that “a character was added.”

For nested loops, use one row for each inner iteration. Record both loop variables so the outer value repeats across the rows belonging to it. In a two-row, three-column loop, the row values are 1, 1, 1, 2, 2, 2 while the column values are 1, 2, 3, 1, 2, 3.

Produce a trace with print

A temporary print("i =", i, "total =", total) after both updates in the sum loop displays i and total at the end of each pass. Placing it before the updates displays a different moment. Compare the print's location with your table's column labels. Remove diagnostic prints after fixing the code so they do not become extra program output.

For a “what prints?” question, record only statements that actually print. A variable changing is not itself output; several updates can happen before a single final print.

An off-by-one error visits one value too many or too few, or shifts the visited values by one. It often comes from a range's excluded stop, a choice between < and <=, or the starting value of a counter.

State the intended endpoints

To add 1 through 10, range(1, 10) is too short. It supplies only 1 through 9, giving a total of 45. range(1, 11) includes 10 and gives 55. For an ascending integer range with step 1, use stop n + 1 to include the final value n.

For a default step of 1, range(a, b) supplies b - a values when b is greater than a. A break can still end the loop before all of them are used. With other step sizes, list the small case or use len(range(...)) to check the count.

A while loop's count depends on its start, comparison, and update together. For a nonnegative integer n, with i += 1 at the end of every pass and no early exit:

At n equal to 0, the first two skip the body. The third runs once with i equal to 0. This tiny case exposes the extra pass without tracing a long loop.

Countdown boundaries

Starting at 5 and printing before n -= 1, while n > 0: prints five values, ending at 1. Using n >= 0 prints six, ending at 0. The corresponding descending ranges are range(5, 0, -1) and range(5, -1, -1).

Check the order too. Updating a counter before using it can shift every value even when the loop has the expected number of passes. A trace should record the actual first and last values used by the calculation.

Items and the gaps between them

A fencepost error confuses item counts with gap counts. Five fence sections need six posts. Five printed numbers need only four separators between them.

for i in range(1, 6):
    print(i, end="-")

This prints 1-2-3-4-5-, including an unwanted final dash. Each print adds a dash after an item, even the last one.

One repair is to print the first item separately, then print a separator before each later item:

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

The output is 1-2-3-4-5. The loop prints four dash-and-number pieces, and the final empty print ends the line. This version has a known first item; a general empty-data case must skip that first-item print too.

Check the repair with small cases

Write down the intended first value, last value, and count before changing the code. Choose the bounds and comparison to match them, then trace a short run. Check zero and one item as well as an ordinary case. Zero reveals work that should be skipped; one reveals an unnecessary separator or an extra update. Change the boundary that causes the error so the code's repetition matches the task.