Pythonic ways to use 'else' in a for loop

If you have a for loop you don’t really have any condition statement. So break is your choice if you like to abort and then else can serve perfectly to handle the case where you were not happy.

for fruit in basket:
   if fruit.kind in ['Orange', 'Apple']:
       fruit.eat()
       break
else:
   print 'The basket contains no desirable fruit'

Without using break, else blocks have no benefit for for and while statements. The following two examples are equivalent:

for x in range(10):
  pass
else:
  print "else"

for x in range(10):
  pass
print "else"

The only reason for using else with for or while is to do something after the loop if it terminated normally, meaning without an explicit break.

After a lot of thinking, I can finally come up with a case where this might be useful:

def commit_changes(directory):
    for file in directory:
        if file_is_modified(file):
            break
    else:
        # No changes
        return False

    # Something has been changed
    send_directory_to_server()
    return True

Here you go:

a = ('y','a','y')
for x in a:
  print x,
else:
  print '!'

It’s for the caboose.

edit:

# What happens if we add the ! to a list?

def side_effect(your_list):
  your_list.extend('!')
  for x in your_list:
    print x,

claimant = ['A',' ','g','u','r','u']
side_effect(claimant)
print claimant[-1]

# oh no, claimant now ends with a '!'

edit:

a = (("this","is"),("a","contrived","example"),("of","the","caboose","idiom"))
for b in a:
  for c in b:
    print c,
    if "is" == c:
      break
  else:
    print

Perhaps the best answer comes from the official Python tutorial:

break and continue Statements, and else Clauses on Loops:

Loop statements may have an else
clause; it is executed when the loop
terminates through exhaustion of the
list (with for) or when the condition
becomes false (with while), but not
when the loop is terminated by a break
statement

Basically, it simplifies any loop that uses a boolean flag like this:

found = False                # <-- initialize boolean
for divisor in range(2, n):
    if n % divisor == 0:
        found = True         # <-- update boolean
        break  # optional, but continuing would be a waste of time

if found:                    # <-- check boolean
    print(n, "is divisible by", divisor)
else:
    print(n, "is prime")

and allows you to skip the management of the flag:

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

Note that there is already a natural place for code to execute when you do find a divisor – right before the break. The only new feature here is a place for code to execute when you tried all divisors and did not find any.

This helps only in conjuction with break. You still need booleans if you can’t break (e.g. because you looking for the last match, or have to track several conditions in parallel).

Oh, and BTW, this works for while loops just as well.

any/all

If the only purpose of the loop is a yes-or-no answer, any()/all() functions with a generator or generator expression can be utilized:

if any(n % divisor == 0 
       for divisor in range(2, n)):
    print(n, "is composite")
else:
    print(n, "is prime")

Note the elegancy! The code is 1:1 what you want to say!

[This has similar efficiency to a loop with a break, because the any() function is short-circuiting, only running the generator expression until it yeilds True.]

But that won’t give you the actual divisor, as any() always returns exactly True or False. A loop with else: is hard to beat when you need both (A) access to current value that was "found" (B) separate code paths for "found" vs. "not found" cases.

I was introduced to a wonderful idiom in which you can use a for/break/else scheme with an iterator to save both time and LOC. The example at hand was searching for the candidate for an incompletely qualified path. If you care to see the original context, please see the original question.

def match(path, actual):
    path = path.strip('/').split('/')
    actual = iter(actual.strip('/').split('/'))
    for pathitem in path:
        for item in actual:
            if pathitem == item:
                break
        else:
            return False
    return True

What makes the use of for/else so great here is the elegance of avoiding juggling a confusing boolean around. Without else, but hoping to achieve the same amount of short-circuiting, it might be written like so:

def match(path, actual):
    path = path.strip('/').split('/')
    actual = iter(actual.strip('/').split('/'))
    failed = True
    for pathitem in path:
        failed = True
        for item in actual:
            if pathitem == item:
                failed = False
                break
        if failed:
            break
    return not failed

I think the use of else makes it more elegant and more obvious.

A use case of the else clause of loops is breaking out of nested loops:

while True:
    for item in iterable:
        if condition:
            break
        suite
    else:
        continue
    break

It avoids repeating conditions:

while not condition:
    for item in iterable:
        if condition:
            break
        suite