Pętle: for i while

Witaj z powrotem.

W poprzedniej lekcji nauczyłeś się warunków.

Twoje programy nauczyły się podejmować decyzje za pomocą:

if
else
elif

Bardzo dobrze.

Teraz twój program potrafi wybierać różne ścieżki.

Ale jest jeszcze jeden duży problem.

Co jeśli musimy coś powtórzyć?

Na przykład:

Wyświetlić coś 10 razy.
Pytać użytkownika, aż wpisze poprawne hasło.
Obliczyć sumy dla kilku produktów.
Pokazać liczby od 1 do 100.
Przetworzyć wiele elementów jeden po drugim.

Bez pętli musiałbyś pisać tak:

print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")

To działa.

Ale wygląda okropnie.

Bardzo okropnie.

Jak kopiowanie tej samej wiadomości pięć razy, bo komputer odmówił bycia użytecznym.

Pętle rozwiązują ten problem.

Pętle pozwalają programowi powtarzać działania.

Python robi nudne powtarzanie.

Ty zachowujesz zdrowie psychiczne.

Przynajmniej częściowo.

Czego się nauczysz

W tej lekcji nauczysz się:

czym są pętle;
dlaczego pętle są użyteczne;
jak używać for;
jak używać range();
jak działa zmienna pętli;
jak powtarzać kod określoną liczbę razy;
jak przechodzić przez tekst;
jak używać while;
jak zatrzymać pętlę warunkiem;
jak używać liczników;
jak unikać pętli nieskończonych;
jak używać break;
jak używać continue;
typowych błędów początkujących;
jak budować proste programy oparte na pętlach.

Pod koniec tej lekcji twoje programy będą mogły automatycznie powtarzać pracę.

To ogromny krok.

Bo komputery są bardzo dobre w powtarzaniu.

Nie nudzą się.

Nie narzekają.

Nie wzdychają dramatycznie po trzecim zadaniu.

W przeciwieństwie do ludzi.

Zwłaszcza w poniedziałek.

Czym jest pętla?

Pętla to sposób na powtarzanie kodu.

Zamiast pisać:

print("Hello")
print("Hello")
print("Hello")

możesz napisać:

for number in range(3):
    print("Hello")

Output:

Hello
Hello
Hello

Kod wewnątrz pętli wykonuje się kilka razy.

To bardzo użyteczne.

Pętla mówi:

Wykonaj tę akcję znowu i znowu.

Nie na zawsze.

Chyba że popełnisz błąd.

Wtedy tak, możliwe, że na zawsze.

Porozmawiamy o tym.

Bardzo ważne.

Bardzo lekko przerażające.

Twoja pierwsza pętla for

Utwórz plik:

loops.py

Napisz:

for number in range(5):
    print("Hello from Python!")

Uruchom:

python loops.py

albo:

python3 loops.py

Output:

Hello from Python!
Hello from Python!
Hello from Python!
Hello from Python!
Hello from Python!

Linia:

for number in range(5):

oznacza:

Powtórz wcięty kod 5 razy.

Wcięta linia:

    print("Hello from Python!")

należy do pętli.

Więc Python wykonuje ją 5 razy.

Bardzo użyteczne.

Bardzo czyste.

Bardzo “wreszcie komputer robi komputerowe rzeczy”.

Wcięcie znowu ma znaczenie

Tak jak przy if, wcięcie ma znaczenie w pętlach.

Poprawnie:

for number in range(3):
    print("Hello")

Źle:

for number in range(3):
print("Hello")

Python pokaże:

IndentationError

Kod wewnątrz pętli musi być wcięty.

Python używa wcięcia, żeby zrozumieć, co należy do pętli.

Twoje spacje nie są dekoracją.

Są strukturą.

Małą architekturą.

Znowu.

Python naprawdę kocha uporządkowane meble.

Dwukropek jest obowiązkowy

Pętla for też potrzebuje dwukropka:

for number in range(3):

Źle:

for number in range(3)
    print("Hello")

Poprawnie:

for number in range(3):
    print("Hello")

Dwukropek mówi Pythonowi:

Tutaj zaczyna się blok powtarzanego kodu.

Mały symbol.

Duża odpowiedzialność.

Dwukropek jest jak małe drzwi do pętli.

Zapomnisz drzwi, nikt nie wejdzie.

Zrozumienie range()

range() tworzy sekwencję liczb.

Przykład:

for number in range(5):
    print(number)

Output:

Ważny szczegół:

range(5)

zaczyna od 0 i zatrzymuje się przed 5.

Czyli daje:

0, 1, 2, 3, 4

Nie:

1, 2, 3, 4, 5

To zaskakuje wielu początkujących.

Python zaczyna liczyć od zera.

Komputery kochają zero.

Nikt nie wie, dlaczego są tak emocjonalnie do niego przywiązane.

Właściwie programiści wiedzą.

Ale dzisiaj nie otwieramy tej jaskini.

Liczenie od 1

Jeśli chcesz liczyć od 1 do 5, napisz:

for number in range(1, 6):
    print(number)

Output:

Tutaj:

range(1, 6)

oznacza:

Zacznij od 1.
Zatrzymaj się przed 6.

Więc ostatnią liczbą jest 5.

Bardzo ważne.

Druga wartość nie jest wliczana.

To w Pythonie bardzo częste.

Na początku wydaje się dziwne.

Potem staje się normalne.

Potem zaczynasz tłumaczyć to początkującym i brzmisz podejrzanie spokojnie.

range(start, stop, step)

range() może też używać kroku.

Przykład:

for number in range(0, 10, 2):
    print(number)

Output:

To oznacza:

Zacznij od 0.
Zatrzymaj się przed 10.
Idź co 2.

Inny przykład:

for number in range(10, 0, -1):
    print(number)

Output:

To liczy w dół.

Bardzo dramatycznie.

Jak start rakiety.

Ale z mniejszą ilością ognia.

Miejmy nadzieję.

Zmienna pętli

Spójrz na to:

for number in range(5):
    print(number)

Zmienna number zmienia się przy każdym wykonaniu pętli.

Pierwszy obrót:

number = 0

Drugi obrót:

number = 1

Trzeci obrót:

number = 2

I tak dalej.

Zmienna pętli przechowuje aktualną wartość.

Możesz nazwać ją inaczej:

for i in range(5):
    print(i)

To też działa.

Wielu programistów używa i dla prostych liczników.

Ale jasne nazwy często są lepsze:

for product_number in range(5):
    print(product_number)

Używaj nazw, które mają sens.

Twój przyszły ty nadal patrzy.

I ocenia.

Trochę.

Powtarzanie wiadomości z numerami

Spróbuj:

for number in range(1, 6):
    print(f"Message number {number}")

Output:

Message number 1
Message number 2
Message number 3
Message number 4
Message number 5

Teraz pętla nie tylko powtarza.

Używa też aktualnego numeru.

To bardzo użyteczne.

Pętle nie są tylko kopiarkami.

Mogą zmieniać coś za każdym razem.

Trochę.

Jak ludzie uczący się na błędach.

Ale szybciej.

Prosta suma z pętlą

Możesz użyć pętli do obliczenia sumy.

Przykład:

total = 0

for number in range(1, 6):
    total = total + number

print(f"Total: {total}")

Output:

Total: 15

Co się dzieje?

Zacznij z total równym 0.
Dodaj 1.
Dodaj 2.
Dodaj 3.
Dodaj 4.
Dodaj 5.
Wyświetl końcową sumę.

To bardzo popularny schemat.

Zacznij z pustym wynikiem.

Przejdź przez wartości.

Aktualizuj wynik.

Wyświetl albo użyj wyniku.

Bardzo użyteczne.

Bardzo programistyczne.

Bardzo “małe kroki tworzą coś większego”.

Krótsze aktualizowanie sumy

To:

total = total + number

można zapisać tak:

total += number

Więc program staje się:

total = 0

for number in range(1, 6):
    total += number

print(f"Total: {total}")

Output:

Total: 15

Obie wersje są poprawne.

Krótsza wersja jest częsta.

Używaj jej, kiedy rozumiesz, co oznacza.

Nie pisz krótkiego kodu tylko po to, żeby wyglądać profesjonalnie.

Profesjonalny kod to nie kod tajemniczy.

Profesjonalny kod to kod, który działa i da się go zrozumieć później.

Bardzo nudne.

Bardzo prawdziwe.

Przechodzenie przez tekst

Możesz przechodzić przez string pętlą.

Przykład:

word = "Python"

for letter in word:
    print(letter)

Output:

P
y
t
h
o
n

String składa się ze znaków.

Pętla może przechodzić przez nie jeden po drugim.

Tutaj:

letter

przechowuje aktualny znak.

Najpierw:

Potem:

I tak dalej.

Python rozbiera słowo jak mała uprzejma maszyna.

Bez przemocy.

Tylko znaki.

Liczenie liter

Spróbuj:

word = input("Enter a word: ")

letter_count = 0

for letter in word:
    letter_count += 1

print(f"The word has {letter_count} letters.")

Przykład:

Enter a word: Python

Output:

The word has 6 letters.

To ręcznie liczy litery.

Później poznasz łatwiejsze sposoby.

Ale zrobienie tego pętlą pomaga zrozumieć, jak działają pętle.

Czasem robimy rzeczy dłuższą drogą, żeby się nauczyć.

Nie dlatego, że Python lubi patrzeć, jak cierpimy.

Prawdopodobnie.

Pętla z warunkami

Możesz używać if wewnątrz pętli.

Przykład:

for number in range(1, 11):
    if number % 2 == 0:
        print(f"{number} is even")

Output:

2 is even
4 is even
6 is even
8 is even
10 is even

Ta linia:

number % 2 == 0

sprawdza, czy liczba jest parzysta.

Operator % daje resztę z dzielenia.

Jeśli liczba podzielona przez 2 ma resztę 0, jest parzysta.

Przykład:

4 % 2 = 0
5 % 2 = 1

Bardzo użyteczne.

Bardzo klasyczne.

Bardzo matematyczne, ale jeszcze nie za straszne.

Smok matematyki nadal śpi.

Liczby parzyste i nieparzyste

Utwórz plik:

even_odd.py

Napisz:

for number in range(1, 11):
    if number % 2 == 0:
        print(f"{number} is even")
    else:
        print(f"{number} is odd")

Output:

1 is odd
2 is even
3 is odd
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is odd
10 is even

Teraz pętla powtarza.

Warunek decyduje.

Razem tworzą mocniejszy program.

Pętle i warunki są jak mały silnik programowania.

Nie glamour.

Ale bardzo mocny.

Jak stary diesel, który odmawia śmierci.

Czym jest pętla while?

Pętla while powtarza kod, dopóki warunek jest prawdziwy.

Przykład:

count = 1

while count <= 5:
    print(count)
    count += 1

Output:

To oznacza:

Dopóki count jest mniejsze lub równe 5, powtarzaj blok.

Za każdym razem zwiększamy count o 1.

W końcu count staje się 6.

Wtedy warunek staje się fałszywy.

Pętla się zatrzymuje.

Bardzo ważne.

Pętla while musi mieć sposób, żeby się zatrzymać.

Inaczej staje się pętlą nieskończoną.

A twój komputer zaczyna patrzeć na ciebie z rozczarowaniem.

for vs while

Używaj for, kiedy wiesz, ile razy chcesz powtarzać.

Przykład:

for number in range(5):
    print(number)

Używaj while, kiedy chcesz powtarzać, aż coś się zmieni.

Przykład:

password = ""

while password != "secret":
    password = input("Password: ")

print("Access granted.")

Prosta zasada:

for     powtarzaj po znanej sekwencji
while   powtarzaj, dopóki warunek jest prawdziwy

Ta zasada nie jest idealna dla każdej sytuacji.

Ale dla początkujących jest bardzo dobra.

Twoja pierwsza pętla while

Utwórz plik:

while_loop.py

Napisz:

count = 1

while count <= 5:
    print(f"Count: {count}")
    count += 1

Uruchom.

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

Co się dzieje?

count zaczyna od 1.
Python sprawdza, czy count <= 5.
Jeśli prawda, wyświetla.
Potem count zwiększa się o 1.
Python sprawdza ponownie.
W końcu count staje się 6.
Warunek jest fałszywy.
Pętla się zatrzymuje.

To podstawowy schemat while.

Start.

Sprawdzenie.

Powtórzenie.

Aktualizacja.

Stop.

Piękne.

Jak pralka z logiką.

Pętle nieskończone

Pętla nieskończona to pętla, która nigdy się nie kończy.

Przykład:

count = 1

while count <= 5:
    print(count)

To jest niebezpieczne.

Dlaczego?

Bo count nigdy się nie zmienia.

Zawsze jest 1.

Więc:

count <= 5

zawsze jest prawdziwe.

Pętla działa wiecznie.

Albo dopóki nie zatrzymasz programu.

To nazywa się pętla nieskończona.

Bardzo częsty błąd początkujących.

Bardzo irytujący.

Świetny sposób, żeby terminal wyglądał jak opętany.

Jak zatrzymać pętlę nieskończoną

Jeśli program utknie w pętli nieskończonej, naciśnij:

Ctrl + C

To przerywa program.

Terminal może pokazać coś takiego:

KeyboardInterrupt

To normalne.

Oznacza, że zatrzymałeś program.

Niezbyt eleganckie.

Ale skuteczne.

Jak wyciągnięcie wtyczki z zagubionego robota.

Unikaj pętli nieskończonych, upewniając się, że warunek może stać się fałszywy.

Bardzo ważne.

Pętla z hasłem

Dobrym użyciem while jest pytanie, aż użytkownik poda poprawną odpowiedź.

Utwórz plik:

password_loop.py

Napisz:

password = ""

while password != "python123":
    password = input("Enter password: ")

print("Access granted.")

Przykład:

Enter password: banana
Enter password: hello
Enter password: python123
Access granted.

Pętla działa, dopóki hasło nie jest poprawne.

Kiedy użytkownik wpisze:

python123

warunek staje się fałszywy.

Pętla się zatrzymuje.

Potem program wyświetla:

Access granted.

Bardzo użyteczne.

Bardzo proste.

Bardzo słabe jako prawdziwe bezpieczeństwo.

Ponownie: nie chroń banku lekcją 5.

Używanie break

break natychmiast zatrzymuje pętlę.

Przykład:

while True:
    answer = input("Type q to quit: ")

    if answer == "q":
        break

    print(f"You typed: {answer}")

print("Program ended.")

Ta pętla zaczyna się od:

while True:

To oznacza:

Powtarzaj wiecznie.

Ale wewnątrz pętli używamy:

break

żeby zatrzymać się, kiedy użytkownik wpisze "q".

Przykład:

Type q to quit: hello
You typed: hello
Type q to quit: test
You typed: test
Type q to quit: q
Program ended.

break jest użyteczne.

Ale używaj go jasno.

Pętla z wieloma tajnymi wyjściami staje się labiryntem.

A nikt nie lubi debugować labiryntu.

No może bardzo dziwni ludzie.

Używanie continue

continue pomija resztę aktualnego obrotu pętli i przechodzi do następnej iteracji.

Przykład:

for number in range(1, 6):
    if number == 3:
        continue

    print(number)

Output:

Kiedy number wynosi 3, Python wykonuje:

continue

Więc pomija:

print(number)

dla tej iteracji.

Potem pętla kontynuuje od 4.

continue jest użyteczne, kiedy chcesz pominąć pewne przypadki.

Jak powiedzenie:

Nie ten. Następny.

Bardzo praktyczne.

Bardzo lekko niegrzeczne.

break vs continue

Prosta różnica:

break      całkowicie zatrzymuje pętlę
continue   pomija ten obrót i przechodzi do następnego

Przykład z break:

for number in range(1, 6):
    if number == 3:
        break

    print(number)

Output:

1
2

Pętla zatrzymuje się na 3.

Przykład z continue:

for number in range(1, 6):
    if number == 3:
        continue

    print(number)

Output:

Pętla pomija 3, ale kontynuuje.

Małe słowa.

Różne zachowanie.

Nie myl ich, chyba że lubisz niespodzianki.

Typowy błąd: brak aktualizacji zmiennej while

Źle:

count = 1

while count <= 5:
    print(count)

To nigdy się nie kończy.

Poprawnie:

count = 1

while count <= 5:
    print(count)
    count += 1

Zawsze pytaj:

Jak ta pętla while się zatrzyma?

Jeśli nie potrafisz odpowiedzieć, twoja pętla może stać się nieśmiertelna.

Nieśmiertelny kod brzmi fajnie.

Nie jest fajny.

Zwykle to bug w pelerynie.

Typowy błąd: złe range()

Oczekiwanie początkującego:

for number in range(5):
    print(number)

Oczekiwany output:

Prawdziwy output:

Zapamiętaj:

range(5)

zaczyna od 0 i zatrzymuje się przed 5.

Jeśli chcesz od 1 do 5:

for number in range(1, 6):
    print(number)

To daje:

Python się nie myli.

To po prostu Python.

To zdanie przyda się jeszcze wiele razy.

Typowy błąd: złe wcięcie

Źle:

for number in range(3):
print(number)

Poprawnie:

for number in range(3):
    print(number)

Kod wewnątrz pętli musi być wcięty.

Jeśli kilka linii należy do pętli, wcięte muszą być wszystkie:

for number in range(3):
    print("Current number:")
    print(number)

Obie linie print() wykonują się wewnątrz pętli.

Jeśli linia nie jest wcięta, jest poza pętlą.

Przykład:

for number in range(3):
    print(number)

print("Done")

Output:

0
1
2
Done

Done wyświetla się tylko raz po zakończeniu pętli.

Bardzo ważne.

Wcięcie decyduje o przynależności.

Jak dokumenty dla bloków kodu.

Typowy błąd: używanie while, gdy for jest prostsze

To działa:

count = 0

while count < 5:
    print(count)
    count += 1

Ale to jest prostsze:

for count in range(5):
    print(count)

Używaj for, kiedy znasz liczbę powtórzeń.

Używaj while, kiedy pętla zależy od warunku.

Nie używaj śrubokręta jako łyżki.

Może zadziałać.

Ale ludzie będą zadawać pytania.

Mini program: tabliczka mnożenia

Utwórz plik:

multiplication_table.py

Napisz:

number = int(input("Enter a number: "))

for i in range(1, 11):
    result = number * i
    print(f"{number} x {i} = {result}")

Przykład:

Enter a number: 5

Output:

5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

To klasyczny program z pętlą.

Bardzo użyteczny.

Bardzo prosty.

Bardzo szkolny, ale w dobrym sensie.

Przeważnie.

Mini program: suma liczb

Utwórz plik:

sum_numbers.py

Napisz:

limit = int(input("Add numbers from 1 to: "))

total = 0

for number in range(1, limit + 1):
    total += number

print(f"Total: {total}")

Przykład:

Add numbers from 1 to: 5

Output:

Total: 15

Bo:

1 + 2 + 3 + 4 + 5 = 15

Zauważ:

range(1, limit + 1)

Dlaczego limit + 1?

Bo range() zatrzymuje się przed drugą wartością.

Jeśli użytkownik wpisze 5, potrzebujemy:

range(1, 6)

Mały szczegół.

Duże znaczenie.

Python kocha te małe pułapki.

Edukacyjne pułapki.

Ale nadal pułapki.

Mini program: zgadnij liczbę

Utwórz plik:

guess_number.py

Napisz:

secret_number = 7
guess = 0

while guess != secret_number:
    guess = int(input("Guess the number: "))

    if guess < secret_number:
        print("Too low.")
    elif guess > secret_number:
        print("Too high.")
    else:
        print("Correct!")

Przykład:

Guess the number: 3
Too low.
Guess the number: 10
Too high.
Guess the number: 7
Correct!

Ten program używa:

zmiennych;
inputu;
konwersji typów;
while;
warunków;
operatorów porównania.

Wiele lekcji razem.

Tak rośnie programowanie.

Jedna idea łączy się z drugą.

Jak kable.

Miejmy nadzieję, że podpisane.

Mini program: menu z pętlą

Utwórz plik:

menu.py

Napisz:

choice = ""

while choice != "q":
    print("----- Menu -----")
    print("1. Say hello")
    print("2. Say goodbye")
    print("q. Quit")

    choice = input("Choose an option: ").lower()

    if choice == "1":
        print("Hello!")
    elif choice == "2":
        print("Goodbye!")
    elif choice == "q":
        print("Exiting...")
    else:
        print("Unknown option.")

Ten program pokazuje menu, dopóki użytkownik nie wpisze:

Pętle menu są bardzo częste.

Wiele programów terminalowych działa właśnie tak.

Program pyta.

Użytkownik wybiera.

Program reaguje.

Potem pyta ponownie.

Narodziła się mała aplikacja command-line.

Bardzo urocza.

Bardzo użyteczna.

Nie karm jej po północy.

Praktyka

Utwórz plik:

practice_loops.py

Napisz program, który:

pyta użytkownika o liczbę;
wyświetla wszystkie liczby od 1 do tej liczby;
pokazuje, czy każda liczba jest parzysta czy nieparzysta;
oblicza sumę całkowitą.

Przykład:

limit = int(input("Enter a number: "))

total = 0

for number in range(1, limit + 1):
    total += number

    if number % 2 == 0:
        print(f"{number} is even")
    else:
        print(f"{number} is odd")

print(f"Total sum: {total}")

Przykładowy output:

Enter a number: 5
1 is odd
2 is even
3 is odd
4 is even
5 is odd
Total sum: 15

To bardzo dobra praktyka.

Łączy:

input;
pętle;
warunki;
arytmetykę;
zmienne;
formatowany output.

Bardzo mocne ćwiczenie dla początkujących.

Niełatwe.

Ale bardzo użyteczne.

Mini wyzwanie

Utwórz plik:

shopping_total.py

Twój program powinien:

zapytać, ile produktów klient chce wprowadzić;
powtórzyć tyle razy;
zapytać o nazwę produktu;
zapytać o cenę produktu;
dodać cenę do sumy;
wyświetlić końcową sumę.

Przykładowe rozwiązanie:

product_count = int(input("How many products? "))

total = 0

for number in range(1, product_count + 1):
    print(f"Product {number}")

    product_name = input("Name: ")
    price = float(input("Price: "))

    total += price

    print(f"Added {product_name}: {price:.2f}")

print("----- Total -----")
print(f"Total price: {total:.2f}")

Przykładowa interakcja:

How many products? 3
Product 1
Name: Keyboard
Price: 70
Added Keyboard: 70.00
Product 2
Name: Mouse
Price: 25
Added Mouse: 25.00
Product 3
Name: Notebook
Price: 5.5
Added Notebook: 5.50
----- Total -----
Total price: 100.50

To jest blisko prawdziwej logiki.

Sklep.

Lista produktów.

Suma.

Jeszcze bez bazy danych.

Jeszcze bez web app.

Ale idea jest prawdziwa.

Mały program terminalowy.

Duży fundament.

Bardzo Python.

Extra challenge: hasło z próbami

Utwórz plik:

password_attempts.py

Twój program powinien:

przechowywać sekretne hasło;
pozwolić tylko na 3 próby;
wyświetlić "Access granted.", jeśli hasło jest poprawne;
wyświetlić "Access denied." po 3 błędnych próbach.

Przykładowe rozwiązanie:

secret_password = "python123"
attempts = 0
max_attempts = 3
access_granted = False

while attempts < max_attempts:
    password = input("Password: ")
    attempts += 1

    if password == secret_password:
        access_granted = True
        break
    else:
        print("Wrong password.")

if access_granted:
    print("Access granted.")
else:
    print("Access denied.")

Ten program używa:

while;
licznika;
break;
flagi boolean;
warunku po pętli.

Bardzo dobra praktyka.

To poważniejsza logika.

Nadal nie jest to prawdziwe bezpieczeństwo.

Ale to bardzo dobra nauka.

Bank nadal nie jest bezpieczny.

Proszę, trzymaj bank z dala od tej lekcji.

Checklist dla początkujących

Kiedy twoja pętla nie działa, sprawdź:

Czy zapisałem plik?
Czy użyłem dwukropka po for albo while?
Czy ciało pętli jest wcięte?
Czy moja pętla while ma sposób, żeby się zatrzymać?
Czy zaktualizowałem licznik?
Czy używam range() poprawnie?
Czy potrzebuję range(1, limit + 1)?
Czy przypadkiem nie umieściłem kodu poza pętlą?
Czy użyłem break, kiedy chciałem zatrzymać pętlę?
Czy użyłem continue, kiedy chciałem pominąć tylko jeden obrót?

Pętle są potężne.

Ale mogą tworzyć mylące błędy.

Zwłaszcza pętle while.

Zawsze pytaj:

Co zmienia się przy każdym obrocie?
Kiedy pętla się zatrzyma?

Jeśli potrafisz odpowiedzieć na te dwa pytania, jesteś dużo bezpieczniejszy.

Jeśli nie, przygotuj się na chaos.

Edukacyjny chaos.

Ale nadal chaos.

Podsumowanie

Dzisiaj nauczyłeś się:

pętle powtarzają kod;
pętle for są użyteczne, kiedy znasz sekwencję do przejścia;
range() tworzy sekwencję liczb;
range(5) daje liczby od 0 do 4;
range(1, 6) daje liczby od 1 do 5;
zmienna pętli zmienia się przy każdej iteracji;
stringi można przechodzić znak po znaku;
pętle mogą zawierać warunki;
while powtarza, dopóki warunek jest prawdziwy;
pętle while potrzebują sposobu zatrzymania;
pętle nieskończone pojawiają się, gdy warunek nigdy nie staje się fałszywy;
Ctrl + C może zatrzymać zablokowany program;
break natychmiast zatrzymuje pętlę;
continue pomija aktualną iterację;
pętle są użyteczne do sum, liczników, menu, haseł i powtarzanego inputu.

To ogromny krok.

Twoje programy teraz mogą powtarzać pracę.

Mogą liczyć.

Mogą pytać ponownie.

Mogą obliczać sumy.

Mogą pokazywać menu.

Mogą przetwarzać wiele wartości.

Tutaj programowanie staje się dużo potężniejsze.

Bo komputery kochają powtarzanie.

A ludzie kochają nie robić nudnego powtarzania ręcznie.

Piękna współpraca.

Przeważnie.

Następna lekcja

W następnej lekcji nauczymy się list.

Listy pozwalają przechowywać wiele wartości w jednej zmiennej.

Zamiast pisać:

product1 = "Keyboard"
product2 = "Mouse"
product3 = "Notebook"

napiszesz:

products = ["Keyboard", "Mouse", "Notebook"]

Potem pętle i listy będą pracować razem.

I właśnie wtedy Python zaczyna robić się dużo bardziej użyteczny.

Bardzo mocny postęp.

Bardzo Python.