Przykładowe użycie instrukcji „continue” w Pythonie?

Definicja tego continuejest stwierdzenie:

continueOświadczenie kontynuuje następnej iteracji pętli.

Nie mogę znaleźć żadnych dobrych przykładów kodu.

Czy ktoś mógłby zasugerować kilka prostych przypadków, w których continuejest to konieczne?

Oto prosty przykład:

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

Wynik będzie:

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

Kontynuuje do następnej iteracji pętli.

Lubię używać kontynuacji w pętlach, w których jest wiele wymagań, które należy spełnić, zanim przejdziesz do rzeczy. Więc zamiast takiego kodu:

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

Otrzymuję taki kod:

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

Robiąc to w ten sposób, unikam bardzo głęboko zagnieżdżonego kodu. Ponadto łatwo jest zoptymalizować pętlę, eliminując najpierw najczęściej występujące przypadki, tak że mam do czynienia tylko z rzadkimi, ale ważnymi przypadkami (np. Dzielnik wynosi 0), gdy nie ma innego showstoppera.

Zazwyczaj sytuacja, w której continue jest konieczne / przydatne, ma miejsce, gdy chcesz pominąć pozostały kod w pętli i kontynuować iterację.

Naprawdę nie uważam, że jest to konieczne, ponieważ zawsze można użyć instrukcji if, aby zapewnić tę samą logikę, ale może to być przydatne, aby zwiększyć czytelność kodu.

import random  

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

Kontynuuj to niezwykle ważne oświadczenie kontrolne. Powyższy kod wskazuje na typowe zastosowanie, w którym można uniknąć wyniku dzielenia przez zero. Używam go często, gdy muszę przechowywać dane wyjściowe z programów, ale nie chcę przechowywać danych wyjściowych, jeśli program się zawiesił. Uwaga, aby przetestować powyższy przykład, zamień ostatnią instrukcję na print 1 / float (x), w przeciwnym razie otrzymasz zera za każdym razem, gdy występuje ułamek, ponieważ randint zwraca liczbę całkowitą. Pominąłem to dla jasności.

Niektórzy ludzie komentowali czytelność, mówiąc: „Och, to wcale nie poprawia czytelności, kogo to obchodzi?”

Załóżmy, że potrzebujesz czeku przed głównym kodem:

if precondition_fails(message): continue

''' main code here '''

Pamiętaj, że możesz to zrobić później głównego kodu bez zmiany tego kodu w żaden sposób. Jeśli porównasz kod, tylko dodana linia z "kontynuuj" będzie podświetlona, ​​ponieważ nie ma zmian odstępów w głównym kodzie.

Wyobraź sobie, że musisz zrobić breakfix kodu produkcyjnego, który okazuje się po prostu dodaniem linii z kontynuacją. Łatwo zauważyć, że to jedyna zmiana podczas przeglądania kodu. Jeśli zaczniesz zawijać główny kod w if / else, diff podświetli nowo wcięty kod, chyba że zignorujesz zmiany odstępów, co jest niebezpieczne szczególnie w Pythonie. Myślę, że jeśli nie byłeś w sytuacji, w której musisz wdrożyć kod w krótkim czasie, możesz nie w pełni to docenić.

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

Powiedzmy, że chcemy wypisać wszystkie liczby, które nie są wielokrotnościami 3 i 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

Nie jest to absolutnie konieczne, ponieważ można to zrobić za pomocą IF, ale jest bardziej czytelne i tańsze w czasie wykonywania.

Używam go, aby pominąć iterację w pętli, jeśli dane nie spełniają pewnych wymagań:

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

Wynik:

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

Jak widać, zła wartość nie pojawiła się po continueinstrukcji.

Na przykład, jeśli chcesz robić różne rzeczy w zależności od wartości zmiennej:

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

W powyższym przykładzie, jeśli użyję breakinterpretera, pominie pętlę. Ale z continuenim tylko pomija instrukcje if-elif i przechodzi bezpośrednio do następnego elementu pętli.

continue po prostu pomija resztę kodu w pętli do następnej iteracji