Python：在外循环中继续下一次迭代

Question

我想知道是否有任何内置方法可以在 python 的外循环中继续下一次迭代。例如，考虑以下代码：

for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            continue
    ...block1...

我希望这个 continue 语句退出 jj 循环并转到 ii 循环中的下一项。我可以通过其他方式实现这个逻辑（通过设置标志变量），但是有没有简单的方法可以做到这一点，或者这就像要求太多？

Answer 1

for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            break
    else:
        ...block1...

Break会打断内循环，block1不会被执行（只有内循环正常退出才会运行）。

Answer 2

在其他语言中，您可以标记循环并从标记的循环中中断。 Python Enhancement Proposal (PEP) 3136 suggested adding these to Python 但Guido rejected it：

但是，我拒绝了它，因为代码太复杂了 需要这个功能是非常少见的。在大多数情况下，存在 产生干净代码的变通方法，例如使用'return'。 虽然我确信有一些（罕见的）真实案例可以清楚地说明 代码将遭受重构，使其可以使用 返回，这被两个问题所抵消：

1. 永久性地增加了语言的复杂性。这影响不 只有所有的 Python 实现，还有所有的源代码分析工具， 当然还有该语言的所有文档。

2. 我预计该功能将被滥用 使用正确，导致代码清晰度净下降（在 此后编写的所有 Python 代码）。懒惰的程序员无处不在， 在不知不觉中，你的手上已经出现了令人难以置信的混乱 难以理解的代码。

因此，如果这就是您所希望的，那么您就不走运了，但请查看其他答案之一，因为那里有不错的选择。

Answer 3

我认为你可以这样做：

for ii in range(200):
    restart = False
    for jj in range(200, 400):
        ...block0...
        if something:
            restart = True
            break
    if restart:
        continue
    ...block1...

Answer 4

for i in ...:
    for j in ...:
        for k in ...:
            if something:
                # continue loop i

在一般情况下，当您有多个循环级别并且break 不适合您时（因为您想继续上面的循环之一，而不是当前循环正上方的循环），您可以做一个以下的

将要转义的循环重构为函数

def inner():
    for j in ...:
        for k in ...:
            if something:
                return


for i in ...:
    inner()

缺点是您可能需要向该新函数传递一些以前在作用域内的变量。您可以将它们作为参数传递，将它们作为对象的实例变量（如果有意义的话，仅为该函数创建一个新对象），或者全局变量、单例等（ehm，ehm）。

或者你可以将inner定义为一个嵌套函数，让它只捕获它需要的东西（可能更慢？）

for i in ...:
    def inner():
        for j in ...:
            for k in ...:
                if something:
                    return
    inner()

使用例外

从哲学上讲，这就是例外的用途，在必要时通过结构化编程构建块（if、for、while）打破程序流程。

优点是您不必将单段代码分成多个部分。如果它是您在用 Python 编写时设计的某种计算，这很好。在早期引入抽象可能会减慢您的速度。

这种方法的坏处是解释器/编译器作者通常认为异常是异常的，并相应地对其进行优化。

class ContinueI(Exception):
    pass


continue_i = ContinueI()

for i in ...:
    try:
        for j in ...:
            for k in ...:
                if something:
                    raise continue_i
    except ContinueI:
        continue

为此创建一个特殊的异常类，这样您就不会冒险意外地消除其他异常。

完全不同的东西

我相信还有其他解决方案。

Answer 5

处理此类问题的另一种方法是使用Exception()。

for ii in range(200):
    try:
        for jj in range(200, 400):
            ...block0...
            if something:
                raise Exception()
    except Exception:
        continue
    ...block1...

例如：

for n in range(1,4):
    for m in range(1,4):
        print n,'-',m

结果：

    1-1
    1-2
    1-3
    2-1
    2-2
    2-3
    3-1
    3-2
    3-3

假设如果m =3，我们要从m循环跳到外n循环：

for n in range(1,4):
    try:
        for m in range(1,4):
            if m == 3:
                raise Exception()            
            print n,'-',m
    except Exception:
        continue

结果：

    1-1
    1-2
    2-1
    2-2
    3-1
    3-2

参考链接：http://www.programming-idioms.org/idiom/42/continue-outer-loop/1264/python

Answer 6

我们想找到一些东西，然后停止内部迭代。我使用标志系统。

for l in f:
    flag = True
    for e in r:
        if flag==False:continue
        if somecondition:
            do_something()
            flag=False

Answer 7

我刚刚做了这样的事情。我的解决方案是用列表理解替换内部 for 循环。

for ii in range(200):
    done = any([op(ii, jj) for jj in range(200, 400)])
    ...block0...
    if done:
        continue
    ...block1...

其中 op 是一些布尔运算符，作用于 ii 和 jj 的组合。就我而言，如果任何操作返回 true，我就完成了。

这实际上与将代码分解为一个函数并没有什么不同，但我认为使用“any”运算符对一个布尔值列表执行逻辑 OR 并在一行中执行所有逻辑很有趣。它也避免了函数调用。

Answer 8

我认为实现这一目标的最简单方法之一是将“继续”替换为“中断”语句，即

for ii in range(200):
 for jj in range(200, 400):
    ...block0...
    if something:
        break
 ...block1...       

例如，这里有一个简单的代码来看看它是如何进行的：

for i in range(10):
    print("doing outer loop")
    print("i=",i)
    for p in range(10):
        print("doing inner loop")
        print("p=",p)
        if p==3:
            print("breaking from inner loop")
            break
    print("doing some code in outer loop")

Answer 9

我知道继续外循环的最佳方法是使用范围在外循环下的布尔值并打破内循环。虽然，根据用例，您可能不会中断内循环，但在其内循环内继续外循环隐含地暗示您希望立即跳转到外循环的第一行并避免在内循环中进一步执行。这就是我添加break 声明的原因。

for i in range(0, 6):
    should_continue = False

    for f in range(1, i * 2):
        print(f"f = {f}")
        if (not (f % 1337) or not (f % 7)):
            print(f"{f} can be divided, continue outer loop")
            should_continue = True
            # leaves inner loop
            break

    if(should_continue): continue
    # Outer loop's code goes here
    print(f'Reached outer loop\ni = {i}')

这种方法避免调用任何函数并处理可能的缺点。众所周知，调用函数是一项相当昂贵的操作，特别是对于游戏。现在想象一个深度嵌套的 for 循环将运行数百万次，将其包装在函数中不会带来流畅的体验。

将循环包装在异常块中也是一个坏主意，并且会比函数慢得多。这是因为 Python 需要大量开销来触发异常机制并在稍后恢复运行时状态，异常被设计为异常使用。考虑到这一点，即使是一些 CPU 优化（例如 speculative execution）也不应该应用于异常块，而且可能不会。

我在这种方法中发现的唯一“问题”是break 将跳出内部循环一次，然后落在continue 上，而continue 又会再跳一次。与 C 或 JavaScript 中的 goto 语句相比，这有点笨拙，但对性能没有任何明显的影响，因为它只会生成一条额外的指令，该指令的运行速度与您的 CPU 时钟或解释器一样快实施。