Ejemplo de uso de la declaración "continuar" en Python?

La definición de la continuedeclaración es:

La continuedeclaración continúa con la próxima iteración del bucle.

No puedo encontrar ningún buen ejemplo de código.

¿Podría alguien sugerir algunos casos simples donde continuesea ​​necesario?

Aquí hay un ejemplo simple:

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

La salida será:

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

Continúa a la siguiente iteración del bucle.

Me gusta usar continuar en bucles donde hay muchas condiciones que deben cumplirse antes de "ponerse manos a la obra". Entonces, en lugar de un código como este:

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

Me sale un código como este:

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

Al hacerlo de esta manera evito el código muy anidado. Además, es fácil optimizar el ciclo eliminando primero los casos más frecuentes, de modo que solo tengo que tratar los casos poco frecuentes pero importantes (por ejemplo, el divisor es 0) cuando no hay otro showtopper.

Por lo general, la situación en la que continuar es necesario / útil es cuando desea omitir el código restante en el ciclo y continuar la iteración.

Realmente no creo que sea necesario, ya que siempre puedes usar sentencias if para proporcionar la misma lógica, pero podría ser útil para aumentar la legibilidad del código.

import random  

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

continuar es una declaración de control extremadamente importante. El código anterior indica una aplicación típica, donde se puede evitar el resultado de una división por cero. Lo uso a menudo cuando necesito almacenar la salida de los programas, pero no quiero almacenar la salida si el programa se ha bloqueado. Tenga en cuenta que para probar el ejemplo anterior, reemplace la última instrucción con print 1 / float (x), o obtendrá ceros cada vez que haya una fracción, ya que randint devuelve un entero. Lo omití por claridad.

Algunas personas han comentado sobre la legibilidad, diciendo: "Oh, no ayuda tanto la legibilidad, ¿a quién le importa?"

Suponga que necesita una verificación antes del código principal:

if precondition_fails(message): continue

''' main code here '''

Tenga en cuenta que puede hacer esto después se haya escrito el código principal sin cambiar ese código de ninguna manera. Si difunde el código, solo se resaltará la línea agregada con "continuar", ya que no hay cambios de espacio en el código principal.

Imagínese si tiene que hacer un desayuno de código de producción, que resulta simplemente agregar una línea con continuar. Es fácil ver que ese es el único cambio cuando revisas el código. Si comienza a ajustar el código principal en if / else, diff resaltará el código recién sangrado, a menos que ignore los cambios de espacio, lo cual es peligroso particularmente en Python. Creo que a menos que haya estado en la situación en la que tiene que implementar el código a corto plazo, es posible que no lo aprecie completamente.

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']

Digamos que queremos imprimir todos los números que no son múltiplos de 3 y 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

No es absolutamente necesario, ya que se puede hacer con IF, pero es más legible y también menos costoso en tiempo de ejecución.

Lo uso para omitir una iteración en un bucle si los datos no cumplen algunos requisitos:

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

Salida:

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

Como puede ver, el valor incorrecto no apareció después de la continuedeclaración.

Por ejemplo, si desea hacer diferentes cosas según el valor de una variable:

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

En el ejemplo anterior, si uso breakel intérprete se saltará el bucle. Pero con continueesto solo se saltan las declaraciones if-elif e ir directamente al siguiente elemento del ciclo.

continue simplemente omite el resto del código en el ciclo hasta la próxima iteración