else子句只在while条件变为false时执行。如果跳出循环，或者引发异常，则不会执行该循环。

一种考虑它的方法是作为一个关于条件的if/else结构:

if condition:
    handle_true()
else:
    handle_false()

类似于循环结构:

while condition:
    handle_true()
else:
    # condition is false now, handle and go on with the rest of the program
    handle_false()

一个例子可能是:

while value < threshold:
    if not process_acceptable_value(value):
        # something went wrong, exit the loop; don't pass go, don't collect 200
        break
    value = update(value)
else:
    # value >= threshold; pass go, collect 200
    handle_threshold_reached()

当while-condition的值为false时，else子句将被执行。

从文档中可以看到:

The while statement is used for repeated execution as long as an expression is true: while_stmt ::= "while" expression ":" suite ["else" ":" suite] This repeatedly tests the expression and, if it is true, executes the first suite; if the expression is false (which may be the first time it is tested) the suite of the else clause, if present, is executed and the loop terminates. A break statement executed in the first suite terminates the loop without executing the else clause’s suite. A continue statement executed in the first suite skips the rest of the suite and goes back to testing the expression.

else:语句当且仅当while循环不再满足它的条件时执行(在您的示例中，当n != 0为假时)。

所以输出是这样的:

5
4
3
2
1
what the...

else子句在正常退出一个块时执行，比如击中循环条件或从try块底部掉下去。如果您中断或返回一个块，或引发异常，则不会执行。它不仅适用于while和for循环，还适用于try块。

您通常会在通常会提前退出循环的地方发现它，并且在意想不到/不寻常的情况下运行到循环的末尾。例如，如果你在一个列表中循环寻找一个值:

for value in values:
    if value == 5:
        print "Found it!"
        break
else:
    print "Nowhere to be found. :-("

在Python中，'while: else:'结构的更好用法应该是，如果'while'中没有执行循环，则执行'else'语句。今天它的工作方式没有意义，因为您可以使用下面的代码获得相同的结果……

n = 5
while n != 0:
    print n
    n -= 1
print "what the..."

请允许我举例说明为什么要使用else子句。但是:

我的观点在Leo的回答中得到了更好的解释 我使用for-而不是while-循环，但else工作类似(除非遇到break，否则执行) 有更好的方法可以做到这一点(例如，将其包装到函数中或引发异常)

打破多级循环

它是这样工作的:外部循环在结尾有一个break，所以它只会执行一次。但是，如果内部循环完成(没有找到除数)，那么它将到达else语句，并且永远不会到达外部断点。这样，内部循环中的中断将跳出两个循环，而不仅仅是一个循环。

for k in [2, 3, 5, 7, 11, 13, 17, 25]:
    for m in range(2, 10):
        if k == m:
            continue
        print 'trying %s %% %s' % (k, m)
        if k % m == 0:
            print 'found a divisor: %d %% %d; breaking out of loop' % (k, m)
            break
    else:
        continue
    print 'breaking another level of loop'
    break
else:
    print 'no divisor could be found!'

我的回答将集中在我们什么时候可以使用while/for-else。

乍一看，使用时似乎没有什么不同

while CONDITION:
    EXPRESSIONS
print 'ELSE'
print 'The next statement'

and

while CONDITION:
    EXPRESSIONS
else:
    print 'ELSE'
print 'The next statement'

因为打印'ELSE'语句似乎总是在这两种情况下执行(当while循环结束或不运行时)。

然后，只有当打印'ELSE'语句不被执行时，情况才有所不同。 它是在while下面的代码块中有一个突破

In [17]: i = 0

In [18]: while i < 5:
    print i
    if i == 2:
        break
    i = i +1
else:
    print 'ELSE'
print 'The next statement'
   ....:
0
1
2
The next statement

如与:

In [19]: i = 0

In [20]: while i < 5:
    print i
    if i == 2:
        break
    i = i +1
print 'ELSE'
print 'The next statement'
   ....:
0
1
2
ELSE
The next statement

Return不在此类别中，因为它对上述两种情况具有相同的效果。

异常引发也不会造成差异，因为当它引发时，下一个代码将在异常处理程序中执行(block除外)，else子句或while子句后面的代码将不会被执行。

如果while循环没有中断，则执行Else。

我有点喜欢用“跑步者”来比喻。

“else”就像越过终点线，与你是从赛道的起点还是终点出发无关。"else"只有当你在两者之间的某个地方中断时才不会执行。

runner_at = 0 # or 10 makes no difference, if unlucky_sector is not 0-10
unlucky_sector = 6
while runner_at < 10:
    print("Runner at: ", runner_at)
    if runner_at == unlucky_sector:
        print("Runner fell and broke his foot. Will not reach finish.")
        break
    runner_at += 1
else:
    print("Runner has finished the race!") # Not executed if runner broke his foot.

主要的用例是使用这种打破嵌套循环，或者如果你想只在循环没有在某处中断时运行某些语句(认为中断是一种不寻常的情况)。

例如，下面是一个关于如何在不使用变量或try/catch的情况下跳出内部循环的机制:

for i in [1,2,3]:
    for j in ['a', 'unlucky', 'c']:
        print(i, j)
        if j == 'unlucky':
            break
    else: 
        continue  # Only executed if inner loop didn't break.
    break         # This is only reached if inner loop 'breaked' out since continue didn't run. 

print("Finished")
# 1 a
# 1 b
# Finished

我知道这是个老问题，但是…

正如Raymond Hettinger所说，应该调用while/no_break而不是while/else。 如果你看一下这个片段，我发现它很容易理解。

n = 5
while n > 0:
    print n
    n -= 1
    if n == 2:
        break
if n == 0:
    print n

现在，我们不用在while循环后检查condition，而是用else替换它，然后去掉那个检查。

n = 5
while n > 0:
    print n
    n -= 1
    if n == 2:
        break
else:  # read it as "no_break"
    print n

我总是把它读成while/no_break来理解代码，这种语法对我来说更有意义。

else子句只在while条件为false时执行。

下面是一些例子:

例1:初始条件为false，因此执行else-clause。

i = 99999999

while i < 5:
    print(i)
    i += 1
else:
    print('this')

输出:

this

例2:while-condition i < 5永远不会变成false，因为i == 3打破了循环，所以else-clause没有执行。

i = 0

while i < 5:
    print(i)
    if i == 3:
        break
    i += 1
else:
    print('this')

输出:

0
1
2
3

例3:while-condition i < 5在i为5时变为false，因此执行else-clause。

i = 0

while i < 5:
    print(i)
    i += 1
else:
    print('this')

输出:

0
1
2
3
4
this

As far as I know the main reason for adding else to loops in any language is in cases when the iterator is not on in your control. Imagine the iterator is on a server and you just give it a signal to fetch the next 100 records of data. You want the loop to go on as long as the length of the data received is 100. If it is less, you need it to go one more times and then end it. There are many other situations where you have no control over the last iteration. Having the option to add an else in these cases makes everything much easier.

假设要在单链表中搜索元素x

    def search(self, x):
        position = 1
        p =self.start
        while p is not None:
            if p.info == x:
                print(x, " is at position ", position)
                return True
            position += 1
            p = p.link
        else:
            print(x, "not found in list") 
            return False

因此，如果条件失败，其他将执行，希望它有助于!

thing = 'hay'
while thing:
  if thing == 'needle':
    print('I found it!!')  # wrap up for break
    break
  thing = haystack.next()
else:
  print('I did not find it.')  # wrap up for no-break

可能不幸命名为else-子句的地方是您从循环耗尽中不间断地结束的地方。

你可以没有它，如果

你中断与return或raise→调用或尝试后的整个代码是你的不可中断的地方 你在while之前设置了默认值(例如found = False) 但它可能会隐藏else子句知道要避免的错误

如果您使用带有非平凡结束符的multi-break，那么您应该在break之前使用一个简单的赋值，对no-break使用一个else子句赋值，并使用If -elif-else或match-case来避免重复非平凡的break处理代码。

注:同样适用于thing in haystack: