Python: continuando para a próxima iteração no loop externo

Eu queria saber se existem maneiras internas de continuar a próxima iteração no loop externo em python. Por exemplo, considere o código:

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

Eu quero que essa instrução continue saia do loop jj e vá para o próximo item no loop ii. Eu posso implementar essa lógica de alguma outra maneira (definindo uma variável flag), mas existe uma maneira fácil de fazer isso ou é como pedir demais?

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

Em geral, quando você tem vários níveis de loop e breaknão funciona para você (porque deseja continuar com um dos loops superiores, não aquele logo acima do atual), você pode executar um dos seguintes procedimentos

Refatorar os loops dos quais você deseja escapar para uma função

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


for i in ...:
    inner()

A desvantagem é que você pode precisar passar para essa nova função algumas variáveis, que estavam anteriormente no escopo. Você pode apenas passá-los como parâmetros, transformá-los em variáveis ​​de instância em um objeto (crie um novo objeto apenas para esta função, se isso fizer sentido) ou variáveis ​​globais, singletons, o que for (ehm, ehm).

Ou você pode definir innercomo uma função aninhada e permitir apenas capturar o que precisa (pode ser mais lento?)

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

Use exceções

Filosoficamente, é para isso que servem as exceções, interrompendo o fluxo do programa através dos blocos de construção da programação estruturada (se, por, enquanto) quando necessário.

A vantagem é que você não precisa dividir o único pedaço de código em várias partes. Isso é bom se for algum tipo de cálculo que você está projetando enquanto o escreve em Python. A introdução de abstrações nesse ponto inicial pode atrasá-lo.

O lado ruim dessa abordagem é que os autores de intérpretes / compiladores geralmente assumem que as exceções são excepcionais e as otimizam de acordo.

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

Crie uma classe de exceção especial para isso, para não correr o risco de silenciar acidentalmente alguma outra exceção.

Algo completamente diferente

Estou certo de que ainda existem outras soluções.

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

Break interromperá o loop interno e o bloco1 não será executado (ele será executado apenas se o loop interno for encerrado normalmente).

Em outros idiomas, você pode rotular o loop e interromper o loop rotulado. A Proposta de Aprimoramento do Python (PEP) 3136 sugeriu adicioná-los ao Python, mas Guido o rejeitou :

No entanto, estou rejeitando com base em que códigos tão complicados para exigir esse recurso são muito raros. Na maioria dos casos, existem soluções alternativas existentes que produzem código limpo, por exemplo, usando 'return'. Embora eu tenha certeza de que existem alguns casos reais (raros) em que a clareza do código sofreria uma refatoração que possibilita o uso de retorno, isso é compensado por dois problemas:

1. A complexidade adicionada ao idioma, permanentemente. Isso afeta não apenas todas as implementações do Python, mas também todas as ferramentas de análise de código-fonte, além de toda a documentação da linguagem.

2. Minha expectativa de que o recurso seja abusado mais do que será usado corretamente, levando a uma diminuição líquida na clareza do código (medida em todo o código Python escrito a partir de agora). Programadores preguiçosos estão por toda parte e, antes que você perceba, você tem uma bagunça incrível nas mãos, com código ininteligível.

Portanto, se é isso que você estava esperando, você está sem sorte, mas olhe para uma das outras respostas, pois há boas opções lá.

Eu acho que você poderia fazer algo assim:

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

Eu acho que uma das maneiras mais fáceis de conseguir isso é substituir a declaração "continue" por "break", ou seja,

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

Por exemplo, aqui está o código fácil para ver exatamente como isso acontece:

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")

Outra maneira de lidar com esse tipo de problema é usar Exception ().

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

Por exemplo:

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

resultado:

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

Supondo que queremos pular para o loop n externo a partir do loop m se m = 3:

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

resultado:

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

Link de referência: http://www.programming-idioms.org/idiom/42/continue-outer-loop/1264/python

Queremos encontrar algo e parar a iteração interna. Eu uso um sistema de bandeira.

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

Eu apenas fiz algo assim. Minha solução para isso foi substituir o interior do loop por uma compreensão da lista.

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

onde op é algum operador booleano que atua em uma combinação de ii e jj. No meu caso, se alguma das operações retornou verdadeira, eu terminei.

Isso realmente não é tão diferente de quebrar o código em uma função, mas pensei que era interessante usar o operador "any" para fazer um OR lógico em uma lista de booleanos e fazer a lógica em uma única linha. Também evita a chamada de função.