Przykładowe użycie polecenia "continue" w Pythonie?

Lubię używać continue w pętlach, w których istnieje wiele warunków do spełnienia, zanim przejdziesz do "sprawy". 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()

Dostaję 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 najczęściej występujące przypadki, tak że mam do czynienia tylko z rzadkimi, ale ważnymi przypadkami (np. dzielnik jest 0), gdy nie ma innego showstoppera.

Zazwyczaj sytuacja, w której continue jest konieczne / użyteczne, jest wtedy, 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ć poleceń if, aby zapewnić tę samą logikę, ale może być przydatne zwiększenie czytelności kodu.

import random  

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

Continue jest niezwykle ważną instrukcją kontrolną. Powyższy kod wskazuje typową aplikację, w której 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ę rozbił. Uwaga, aby przetestować powyższy przykład, zastąp ostatnią instrukcję print 1 / float(X), w przeciwnym razie otrzymasz zera za każdym razem, gdy jest ułamek, ponieważ randint Zwraca liczbę całkowitą. Pominąłem to dla jasności.

Niektórzy ludzie skomentowali czytelność, mówiąc: "Oh to nie pomaga czytelności tak bardzo, kogo to obchodzi?"

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

if precondition_fails(message): continue

''' main code here '''

Uwaga możesz to zrobić po główny kod został napisany bez zmiany tego kodu w każdym razie. Jeśli zmienisz Kod, tylko dodany wiersz z "continue" zostanie podświetlony, ponieważ nie ma zmian odstępów w kodzie głównym.

Wyobraź sobie, że musisz zrobić breakfix kodu produkcyjnego, co okazuje się być po prostu dodawaniem linii z continue. Łatwo zauważyć, że jest to jedyna zmiana podczas przeglądania kodu. Jeśli zaczniesz owijać 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 docenić tego w pełni.

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 wydrukować 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

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

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ę break interpreter pominie pętlę. Ale z continue pomija tylko polecenia if-elif i przechodzi bezpośrednio do następnego elementu pętli.

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

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

Wyjście:

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ć, Błędna wartość nie pojawiła się po instrukcji continue.