What Does for-else Do in Python?

The else clause on a for loop is not the same else as the one in an if statement. It does not run when the loop finds nothing. It runs when the loop finishes normally, which means that it was never interrupted by a break.

def find_index(items, target):
    for index, item in enumerate(items):
        if item == target:
            return index
    else:
        return -1


print(find_index(['a', 'b', 'c'], 'b'))   # 1
print(find_index(['a', 'b', 'c'], 'z'))   # -1

For the first call the loop finds b at index 1 and returns straight away, so the else clause is never reached. For the second call the loop runs through every item without matching anything, no break happens, and the else clause runs and returns -1.

The way it works is that a break statement suppresses the else clause. If you write a loop with a break for any reason other than finding the thing that you are looking for, then the else clause will quietly not run, and that is the one trap to be aware of.

The pattern is worth knowing because it removes the flag variable. The conventional version of this function needs a found = -1 line before the loop, an if inside it, and a return after it. Here the two ways out sit next to each other, and each one is a single return statement, so the function reads from the top to the bottom without an extra variable to keep track of.

The flag-variable version is the one that most people write first. It needs a variable that is set before the loop and checked after it.

def find_index_flag(items, target):
    found = -1
    for index, item in enumerate(items):
        if item == target:
            found = index
            break
    return found


def find_index_else(items, target):
    for index, item in enumerate(items):
        if item == target:
            return index
    else:
        return -1


data = ['a', 'b', 'c']
print(find_index_flag(data, 'b'))   # 1
print(find_index_else(data, 'b'))   # 1
print(find_index_flag(data, 'z'))   # -1
print(find_index_else(data, 'z'))   # -1

Both versions give the same results. The differences are about readability and about how easy the code is to break by accident. The flag version has three places to think about, which are the initial value, the assignment inside the loop, and the return after it. If you forget the break, then the loop keeps scanning even after it has found a match. The for-else version has two exits, and each one is a single return, and the not-found case is written out explicitly instead of being implied by the starting value of a variable.

The for-else version also generalises better. Once you are used to it, a loop with any number of early exits and one final else reads like a complete story, because every way out of the function is visible in one place.

The honest caveat is that for-else is uncommon in real code, and many reviewers find it surprising the first time they see it. If a team does not already use the idiom, then a flag variable or an explicit helper is the more maintainable choice. Whichever one you pick, the skill that actually matters is being able to read both of them.

The two else clauses look alike but they mean different things. In a try statement, the else clause runs when the try block finishes without raising an exception. In a for loop, the else clause runs when the loop finishes without a break. One of them is about errors, and the other one is about leaving early.

It is easy to blur that difference, because a break and an exception are both ways of leaving a block early, but the rules are really quite separate. A try, except, and else block still runs its else when the exception is caught by an earlier except clause. A for-else block runs its else only if nothing in the loop raised a break, and an exception that travels out of the loop skips the else completely.

So is for-else worth using? The case for it is the search-loop pattern, where the else clause replaces a flag variable and puts the not-found case in one visible place. It also states the intent precisely, because the else block really does mean that no match was found. The case against it is that the construct is rare, so a reader has to stop and work out which kind of else they are looking at, and a future edit that adds a break for some unrelated reason would quietly disable the else.

The practical advice for an interview is to know the construct, to use it where it removes a flag variable and the intent is obvious, and to fall back to an explicit result variable when the loop body is likely to grow or when a break may be added later. Both choices are defensible. What matters is that you can explain the difference between the two else clauses without hesitating.