Exemplo de uso da instrução "continue" em Python?

A definição da continuedeclaração é:

A continueinstrução continua com a próxima iteração do loop.

Não consigo encontrar bons exemplos de código.

Alguém poderia sugerir alguns casos simples, quando continuenecessário?

Aqui está um exemplo simples:

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

A saída será:

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

Ele continua na próxima iteração do loop.

Eu gosto de usar continue em loops, onde há muitas competições a serem cumpridas antes de você começar a trabalhar. Então, em vez de 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()

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

Ao fazer isso dessa maneira, evito código profundamente aninhado. Além disso, é fácil otimizar o loop eliminando os casos que ocorrem com mais frequência primeiro, para que eu tenha que lidar apenas com os casos pouco frequentes, mas importantes (por exemplo, o divisor é 0) quando não há nenhum outro limitador de exibição.

Geralmente, a situação em que continuar é necessária / útil é quando você deseja pular o código restante no loop e continuar a iteração.

Realmente não acredito que seja necessário, pois você sempre pode usar as instruções if para fornecer a mesma lógica, mas pode ser útil aumentar a legibilidade do código.

import random  

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

continue é uma declaração de controle extremamente importante. O código acima indica uma aplicação típica, onde o resultado de uma divisão por zero pode ser evitado. Eu o uso frequentemente quando preciso armazenar a saída de programas, mas não quero armazenar a saída se o programa falhar. Observe que, para testar o exemplo acima, substitua a última instrução por print 1 / float (x), ou você obterá zeros sempre que houver uma fração, pois randint retorna um número inteiro. Eu o omiti por clareza.

Algumas pessoas comentaram sobre legibilidade, dizendo: "Oh, isso não ajuda muito a legibilidade, quem se importa?"

Suponha que você precise de uma verificação antes do código principal:

if precondition_fails(message): continue

''' main code here '''

Observe que você pode fazer isso depois que o código principal foi gravado sem alterá-lo. Se você difere o código, somente a linha adicionada com "continuar" será destacada, pois não há alterações de espaçamento no código principal.

Imagine se você tiver que fazer um pequeno código de produção, que acaba adicionando uma linha com continue. É fácil ver que essa é a única alteração quando você revisa o código. Se você começar a agrupar o código principal em if / else, o diff destacará o código recuado, a menos que você ignore as alterações de espaçamento, o que é perigoso principalmente no Python. Acho que, a menos que você esteja na situação em que precisa implantar código em pouco tempo, talvez não aprecie isso 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 os números que não sejam múltiplos de 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

Não é absolutamente necessário, pois pode ser feito com IFs, mas é mais legível e também mais barato em tempo de execução.

Eu o uso para pular uma iteração em um loop se os dados não atenderem a alguns 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))

Resultado:

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 você pode ver, o valor errado não chegou depois da continuedeclaração.

Por exemplo, se você deseja fazer coisas diferentes, dependendo do valor de uma variável:

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

No exemplo acima, se eu usar breako intérprete, pulará o loop. Mas com continueele apenas pula as instruções if-elif e vai diretamente para o próximo item do loop.

continue simplesmente pula o restante do código no loop até a próxima iteração