Exemple d'utilisation de l'instruction «continue» en Python?

La définition de la continuedéclaration est:

L' continueinstruction continue avec l'itération suivante de la boucle.

Je ne trouve pas de bons exemples de code.

Quelqu'un pourrait-il suggérer des cas simples où cela continueest nécessaire?

Voici un exemple simple:

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

La sortie sera:

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

Il continue à l'itération suivante de la boucle.

J'aime utiliser continuer dans des boucles où il y a beaucoup de choses à remplir avant de passer aux choses sérieuses. Donc, au lieu d'un code comme celui-ci:

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

Je reçois un code comme celui-ci:

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

En faisant cela, j'évite le code très profondément imbriqué. En outre, il est facile d'optimiser la boucle en éliminant d'abord les cas les plus fréquents, de sorte que je n'ai à traiter que les cas rares mais importants (par exemple, le diviseur est 0) lorsqu'il n'y a pas d'autre showstopper.

Habituellement, la situation où continuer est nécessaire / utile est lorsque vous souhaitez ignorer le code restant dans la boucle et continuer l'itération.

Je ne pense pas vraiment que ce soit nécessaire, car vous pouvez toujours utiliser des instructions if pour fournir la même logique, mais cela peut être utile pour augmenter la lisibilité du code.

import random  

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

continue est une déclaration de contrôle extrêmement importante. Le code ci-dessus indique une application typique, où le résultat d'une division par zéro peut être évité. Je l'utilise souvent lorsque j'ai besoin de stocker la sortie de programmes, mais je ne veux pas stocker la sortie si le programme est tombé en panne. Notez que pour tester l'exemple ci-dessus, remplacez la dernière instruction par print 1 / float (x), ou vous obtiendrez des zéros chaque fois qu'il y a une fraction, car randint renvoie un entier. Je l'ai omis pour plus de clarté.

Certaines personnes ont fait des commentaires sur la lisibilité, en disant: "Oh, cela n'aide pas beaucoup la lisibilité, qui s'en soucie?"

Supposons que vous ayez besoin d'une vérification avant le code principal:

if precondition_fails(message): continue

''' main code here '''

Notez que vous pouvez le faire après que le code principal a été écrit sans changer ce code de toute façon. Si vous différez le code, seule la ligne ajoutée avec «continuer» sera mise en surbrillance car il n'y a pas de modifications d'espacement dans le code principal.

Imaginez que vous deviez faire un breakix de code de production, qui se révèle être simplement en ajoutant une ligne avec continue. Il est facile de voir que c'est le seul changement lorsque vous examinez le code. Si vous commencez à envelopper le code principal dans if / else, diff mettra en évidence le code nouvellement mis en retrait, à moins que vous n'ignoriez les changements d'espacement, ce qui est particulièrement dangereux en Python. Je pense qu'à moins que vous n'ayez été dans une situation où vous devez déployer du code à court préavis, vous ne l'apprécierez peut-être pas pleinement.

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

Disons que nous voulons imprimer tous les nombres qui ne sont pas des multiples de 3 et 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

Ce n'est pas absolument nécessaire car cela peut être fait avec des IF mais c'est plus lisible et aussi moins coûteux en temps d'exécution.

Je l'utilise afin de sauter une itération dans une boucle si les données ne répondent pas à certaines exigences:

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

Production:

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

Comme vous pouvez le voir, la mauvaise valeur ne l'a pas fait après l' continueinstruction.

Par exemple, si vous souhaitez faire différentes choses en fonction de la valeur d'une 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

Dans l'exemple ci-dessus, si j'utilise breakl'interpréteur sautera la boucle. Mais avec continueelle ignore uniquement les instructions if-elif et passe directement à l'élément suivant de la boucle.

continue saute simplement le reste du code dans la boucle jusqu'à la prochaine itération