Python: continua con l'iterazione successiva nel ciclo esterno

Volevo sapere se ci sono modi incorporati per continuare alla prossima iterazione nel ciclo esterno in Python. Ad esempio, considera il codice:

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

Voglio che questa istruzione continue esca dal ciclo jj e vada all'elemento successivo nel ciclo ii. Posso implementare questa logica in qualche altro modo (impostando una variabile flag), ma c'è un modo semplice per farlo, o è come chiedere troppo?

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

In un caso generale, quando hai più livelli di loop e breaknon funziona per te (perché vuoi continuare uno dei loop superiori, non quello proprio sopra quello corrente), puoi fare una delle seguenti

Rifattorizza i loop da cui vuoi fuggire in una funzione

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


for i in ...:
    inner()

Lo svantaggio è che potrebbe essere necessario passare a quella nuova funzione alcune variabili, che erano in precedenza nell'ambito. Puoi semplicemente passarli come parametri, renderli variabili di istanza su un oggetto (creare un nuovo oggetto solo per questa funzione, se ha senso), oppure variabili globali, singoli punti, qualunque cosa (ehm, ehm).

Oppure puoi definire inneruna funzione nidificata e lasciare che catturi solo ciò di cui ha bisogno (potrebbe essere più lento?)

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

Usa le eccezioni

Filosoficamente, ecco a cosa servono le eccezioni, interrompendo il flusso del programma attraverso i blocchi di programmazione strutturati (se, per, mentre) quando necessario.

Il vantaggio è che non è necessario suddividere il singolo pezzo di codice in più parti. Questo è utile se è un tipo di calcolo che stai progettando mentre lo scrivi in ​​Python. L'introduzione di astrazioni a questo punto iniziale può rallentare.

La cosa negativa di questo approccio è che gli autori di interpreti / compilatori di solito assumono che le eccezioni siano eccezionali e ottimizzino di conseguenza per loro.

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

Crea una speciale classe di eccezione per questo, in modo da non rischiare di mettere a tacere accidentalmente un'altra eccezione.

Qualcos'altro del tutto

Sono sicuro che ci sono ancora altre soluzioni.

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

Break interromperà il ciclo interno e il blocco1 non verrà eseguito (verrà eseguito solo se il ciclo interno viene chiuso normalmente).

In altre lingue è possibile etichettare il loop e interrompere dal loop etichettato. La proposta di potenziamento di Python (PEP) 3136 ha suggerito di aggiungerli a Python ma Guido l'ha respinto :

Tuttavia, lo sto rifiutando sulla base del fatto che un codice così complicato da richiedere questa funzione è molto raro. Nella maggior parte dei casi esistono soluzioni alternative che producono codice pulito, ad esempio utilizzando 'return'. Mentre sono sicuro che ci sono alcuni casi (rari) reali in cui la chiarezza del codice risentirebbe di un refactoring che rende possibile l'uso del ritorno, questo è compensato da due problemi:

1. La complessità aggiunta alla lingua, in modo permanente. Ciò influisce non solo su tutte le implementazioni di Python, ma anche su tutti gli strumenti di analisi dei sorgenti, oltre ovviamente a tutta la documentazione per il linguaggio.

2. La mia aspettativa che la funzione venga abusata più di quanto verrà utilizzata correttamente, portando a una netta diminuzione della chiarezza del codice (misurata su tutto il codice Python scritto d'ora in poi). I programmatori pigri sono ovunque e prima che tu lo sappia hai un incredibile casino tra le mani di codice incomprensibile.

Quindi, se è quello che speravi, sei sfortunato, ma guarda una delle altre risposte in quanto ci sono buone opzioni lì.

Penso che potresti fare qualcosa del genere:

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

Penso che uno dei modi più semplici per raggiungere questo obiettivo sia quello di sostituire "continua" con la frase "break", cioè

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

Ad esempio, ecco il codice semplice per vedere come va esattamente:

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

Un altro modo per affrontare questo tipo di problema è utilizzare Exception ().

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

Per esempio:

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

risultato:

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

Supponendo di voler saltare al ciclo n esterno dal ciclo 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

risultato:

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

Link di riferimento: http://www.programming-idioms.org/idiom/42/continue-outer-loop/1264/python

Vogliamo trovare qualcosa e quindi interrompere l'iterazione interiore. Uso un sistema di bandiera.

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

Ho appena fatto qualcosa del genere. La mia soluzione per questo era sostituire l'interno per il ciclo con una comprensione dell'elenco.

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

dove op è un operatore booleano che agisce su una combinazione di ii e jj. Nel mio caso, se una delle operazioni è risultata vera, avevo finito.

Questo non è poi così diverso dal suddividere il codice in una funzione, ma ho pensato che usare l'operatore "any" per fare un OR logico su un elenco di booleani e fare la logica tutto in una riga fosse interessante. Evita anche la chiamata di funzione.