Esempio di utilizzo dell'istruzione "continue" in Python?

La definizione della continuedichiarazione è il seguente:

L' continueistruzione continua con la successiva iterazione del ciclo.

Non riesco a trovare buoni esempi di codice.

Qualcuno potrebbe suggerire alcuni casi semplici dove continueè necessario?

Ecco un semplice esempio:

for letter in 'Django':    
    if letter == 'D':
        continue
    print("Current Letter: " + letter)

L'output sarà:

Current Letter: j
Current Letter: a
Current Letter: n
Current Letter: g
Current Letter: o

Continua alla successiva iterazione del ciclo.

Mi piace usare continue in loop in cui ci sono molte contese da soddisfare prima di "dedicarti al lavoro". Quindi, invece di un codice come questo:

for x, y in zip(a, b):
    if x > y:
        z = calculate_z(x, y)
        if y - z < x:
            y = min(y, z)
            if x ** 2 - y ** 2 > 0:
                lots()
                of()
                code()
                here()

Ricevo un codice come questo:

for x, y in zip(a, b):
    if x <= y:
        continue
    z = calculate_z(x, y)
    if y - z >= x:
        continue
    y = min(y, z)
    if x ** 2 - y ** 2 <= 0:
        continue
    lots()
    of()
    code()
    here()

In questo modo evito codice nidificato molto profondamente. Inoltre, è facile ottimizzare il loop eliminando prima i casi che si verificano più frequentemente, quindi devo solo occuparmi dei casi rari ma importanti (ad esempio il divisore è 0) quando non ci sono altri showtopper.

Di solito la situazione in cui continue è necessario / utile è quando si desidera saltare il codice rimanente nel loop e continuare l'iterazione.

Non credo davvero che sia necessario, dal momento che puoi sempre usare if istruzioni per fornire la stessa logica, ma potrebbe essere utile per aumentare la leggibilità del codice.

import random  

for i in range(20):  
    x = random.randint(-5,5)  
    if x == 0: continue  
    print 1/x  

continue è una dichiarazione di controllo estremamente importante. Il codice sopra indica un'applicazione tipica, in cui è possibile evitare il risultato di una divisione per zero. Lo uso spesso quando devo memorizzare l'output dai programmi, ma non voglio archiviare l'output se il programma si è bloccato. Nota, per testare l'esempio sopra, sostituisci l'ultima istruzione con print 1 / float (x), o otterrai degli zeri ogni volta che c'è una frazione, poiché randint restituisce un numero intero. L'ho omesso per chiarezza.

Alcune persone hanno commentato la leggibilità, dicendo "Oh, non aiuta molto la leggibilità, a chi importa?"

Supponiamo di aver bisogno di un controllo prima del codice principale:

if precondition_fails(message): continue

''' main code here '''

Nota che puoi farlo dopo che il codice principale è stato scritto senza modificarlo comunque. Se si differenzia il codice, verrà evidenziata solo la riga aggiunta con "continua" poiché non vi sono modifiche di spaziatura al codice principale.

Immagina se devi fare una colazione del codice di produzione, che risulta semplicemente aggiungere una riga con continue. È facile vedere che è l'unica modifica quando si esamina il codice. Se inizi a racchiudere il codice principale in if / else, diff evidenzierà il codice appena rientrato, a meno che non ignori le modifiche alla spaziatura, il che è particolarmente pericoloso in Python. Penso che a meno che tu non sia stato nella situazione in cui devi implementare il codice con breve preavviso, potresti non apprezzarlo appieno.

def filter_out_colors(elements):
  colors = ['red', 'green']
  result = []
  for element in elements:
    if element in colors:
       continue # skip the element
    # You can do whatever here
    result.append(element)
  return result

  >>> filter_out_colors(['lemon', 'orange', 'red', 'pear'])
  ['lemon', 'orange', 'pear']

Supponiamo di voler stampare tutti i numeri che non sono multipli di 3 e 5

for x in range(0, 101):
    if x % 3 ==0 or x % 5 == 0:
        continue
        #no more code is executed, we go to the next number 
    print x

Non è assolutamente necessario poiché può essere eseguito con gli IF ma è più leggibile e anche meno costoso in fase di esecuzione.

Lo uso per saltare un'iterazione in un ciclo se i dati non soddisfano alcuni requisiti:

# List of times at which git commits were done.
# Formatted in hour, minutes in tuples.
# Note the last one has some fantasy.
commit_times = [(8,20), (9,30), (11, 45), (15, 50), (17, 45), (27, 132)]

for time in commit_times:
    hour = time[0]
    minutes = time[1]

    # If the hour is not between 0 and 24
    # and the minutes not between 0 and 59 then we know something is wrong.
    # Then we don't want to use this value,
    # we skip directly to the next iteration in the loop.
    if not (0 <= hour <= 24 and 0 <= minutes <= 59):
        continue

    # From here you know the time format in the tuples is reliable.
    # Apply some logic based on time.
    print("Someone commited at {h}:{m}".format(h=hour, m=minutes))

Produzione:

Someone commited at 8:20
Someone commited at 9:30
Someone commited at 11:45
Someone commited at 15:50
Someone commited at 17:45

Come puoi vedere, il valore errato non è riuscito dopo l' continueistruzione.

Ad esempio, se vuoi fare cose diverse a seconda del valore di una variabile:

my_var = 1
for items in range(0,100):
    if my_var < 10:
        continue
    elif my_var == 10:
        print("hit")
    elif my_var > 10:
        print("passed")
    my_var = my_var + 1

Nell'esempio sopra, se uso breakl'interprete salterà il ciclo. Ma con continueesso salta solo le istruzioni if-elif e passa direttamente all'elemento successivo del ciclo.

continue salta semplicemente il resto del codice nel ciclo fino alla successiva iterazione