Czym jest iteracja?

Program, który wysyła e-mail z przypomnieniem do 10 000 użytkowników, nie zawiera 10 000 kopii kodu wysyłającego. Zawiera ten kod raz, wewnątrz pętli, a pętla wykonuje go raz dla każdego użytkownika. Każde wykonanie to jedna iteracja, a cała pętla to sposób, w jaki program iteruje po użytkownikach.

Jak działa iteracja krok po kroku

Każda pętla przechodzi przez ten sam cykl:

1. Sprawdź. Przetestuj warunek pętli, który jest wartością typu boolean: czy jest kolejny element albo czy licznik jest nadal poniżej limitu?
2. Wykonaj. Jeśli odpowiedź to prawda, wykonaj ciało pętli raz.
3. Zaktualizuj. Przejdź do następnego elementu albo zmień licznik.
4. Powtórz. Wróć do kroku 1. Gdy sprawdzenie da fałsz, program kontynuuje od kodu za pętlą.

Tutaj ciało wykonuje się pięć razy, a każda iteracja dodaje kolejną liczbę do bieżącej sumy:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

Zmienna total istnieje poza pętlą, więc zachowuje wartość z jednej iteracji na następną. Ten wzorzec, czyli zmienna ustawiona przed pętlą i aktualizowana w jej wnętrzu, nazywa się akumulatorem i pojawia się w niemal każdej pętli, która coś oblicza.

Pętle liczące i pętle z warunkiem

Są dwa rodzaje iteracji. Iteracja określona wykonuje się znaną liczbę razy: raz na każdy element listy albo raz na każdą liczbę od 1 do 5. Pętla for w Pythonie jest stworzona właśnie do tego, często razem z range().

Iteracja nieokreślona powtarza się, dopóki coś się nie wydarzy, a liczba przejść nie jest znana z góry. Do tego pasuje pętla while:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Pieniądze, które rosną o 10% rocznie, podwajają się po 8 latach. Program ustalił to przez iterowanie, a nie przez rozwiązanie równania. Przewodniki po pętlach for i pętlach while omawiają oba rodzaje w Pythonie.

Iterowanie po kolekcji

Większość pętli przechodzi przez kolekcję: elementy tablicy, znaki napisu, linie pliku. Pętla for w Pythonie podaje ci każdy element bezpośrednio, a enumerate() dodaje jego pozycję:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Za kulisami for prosi kolekcję o iterator przez iter(), a potem wywołuje na nim next() raz na iterację. Te same wywołania możesz wykonać sam:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Bez wartości domyślnej czwarte next() zgłasza StopIteration. Ten wyjątek to sygnał, po którym pętla for wie, że kolekcja się skończyła.

Inne języki zapisują tę samą ideę inaczej. C liczy za pomocą indeksu, a Java i JavaScript mają też pętlę, która podaje każdy element:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iteracja a rekurencja

Rekurencja to drugi sposób powtarzania pracy: funkcja wywołuje samą siebie na mniejszej wersji problemu, aż dojdzie do przypadku, na który może odpowiedzieć bezpośrednio. Wszystko, co zapiszesz jednym sposobem, można zapisać drugim, ale zachowują się inaczej:

Wiersz o pamięci ma znaczenie w praktyce. Python domyślnie pozwala na około 1000 zagnieżdżonych wywołań, więc rekurencyjna suma 5000 liczb się nie udaje tam, gdzie pętla nie ma żadnego problemu:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

Wizualizacja rekurencji pokazuje krok po kroku, jak stos wywołań rośnie i maleje.

Częste błędy

Pętla nieskończona. Pętla while, której warunek nigdy nie staje się fałszywy, działa, dopóki nie zatrzymasz programu. Zwykłą przyczyną jest zapomniany krok aktualizacji, na przykład pominięcie count = count - 1.

Pomyłka o jeden. range(1, 5) daje 1, 2, 3 i 4, a nie 5, bo wartość końcowa jest wykluczona. Pętla, która wykona się raz za dużo albo raz za mało, nadal działa bez błędu i daje złą odpowiedź, a to jest błąd logiczny.

Zmienianie listy podczas przechodzenia po niej. Usuwanie elementów z listy, po której iterujesz, sprawia, że pętla pomija elementy:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Jedna dwójka przetrwała, bo usunięcie pierwszej 2 przesunęło drugą na pozycję, którą pętla już minęła. Zamiast tego zbuduj nową listę: numbers = [n for n in numbers if n != 2].

Co dalej

Pętle przechodzą przez kolekcje, więc naturalną stroną towarzyszącą jest czym jest tablica, a strona co to jest boolean wyjaśnia sprawdzenia prawda albo fałsz, które decydują, kiedy pętla się kończy. Gdy pętla daje zły wynik bez komunikatu o błędzie, przeczytaj, czym jest błąd logiczny. Żeby poćwiczyć pisanie pętli, zacznij kurs Python albo wypróbuj powyższe przykłady w edytorze online Pythona.