1. Algorytmy i programowanie

W Pythonie funkcja:

range(początek, koniec)

zawsze działa według zasady:

zaczynam od pierwszej liczby, ale nie dochodzę do ostatniej

Czyli:

range(1, 4)

oznacza:

zacznij od 1
idź w górę o 1
zatrzymaj się przed 4

W efekcie otrzymujemy:

1, 2, 3

Możesz to sobie wyobrazić jak schody:

1   2   3   4
↑           ↑
start     stop

Python staje na:

1
2
3

ale nie wchodzi na schodek numer 4.

Kilka przykładów

range(1, 5)

daje:

1, 2, 3, 4

range(3, 8)

daje:

3, 4, 5, 6, 7

range(0, 10)

daje:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Dlatego w Twoim programie jest napisane:

range(1, n + 1)

a nie:

range(1, n)

Gdyby użytkownik podał:

n = 3

to:

range(1, n)

oznaczałoby:

range(1, 3)

czyli:

1, 2

Liczba 3 nie zostałaby uwzględniona.

Natomiast:

range(1, n + 1)

staje się:

range(1, 4)

czyli:

1, 2, 3

i dzięki temu suma jest liczona poprawnie:

1 + 2 + 3 = 6

To bardzo częsty motyw na maturze. Uczniowie często popełniają tzw. błąd o jeden (off-by-one error), np. piszą:

for i in range(1, n):

i nie zauważają, że ostatnia liczba została pominięta. Dlatego warto zapamiętać prostą regułę:

range(start, stop)
start → wchodzi
stop  → nie wchodzi

czyli:

[ start , stop )

Nawias kwadratowy oznacza „włącznie”, a okrągły „bez ostatniego elementu”. To zapis często spotykany w informatyce i matematyce.

Zmienna x pamięta tylko ostatnio wpisaną liczbę. Wszystkie wcześniejsze liczby są „dopisywane” do zmiennej suma.

Czyli pamięć programu wygląda tak:

x     → ostatnia wpisana liczba
suma  → łączna suma wszystkich wcześniejszych liczb

Przykład działania, gdy wpisujemy: 5, 7, 2, 0.

suma = 0

Program tworzy zmienną suma. Na początku wynosi 0, bo jeszcze nic nie dodaliśmy.

while True:

To pętla nieskończona. Program będzie pytał o kolejne liczby, dopóki nie trafi na break.

Pierwszy obieg pętli

Użytkownik wpisuje:

5

Program zapisuje:

x = 5
suma = 0

Sprawdza:

if x == 0:

Czy 5 == 0? Nie.

Więc wykonuje:

suma = suma + x

czyli:

suma = 0 + 5
suma = 5

Drugi obieg pętli

Użytkownik wpisuje:

7

Teraz:

x = 7
suma = 5

Uwaga: x nie przechowuje już 5. Liczba 5 została wcześniej dodana do suma.

Program sprawdza:

7 == 0? Nie

Dodaje:

suma = 5 + 7
suma = 12

Trzeci obieg pętli

Użytkownik wpisuje:

2

Teraz:

x = 2
suma = 12

Program sprawdza:

2 == 0? Nie

Dodaje:

suma = 12 + 2
suma = 14

Czwarty obieg pętli

Użytkownik wpisuje:

0

Teraz:

x = 0
suma = 14

Program sprawdza:

if x == 0:    break

Czy 0 == 0? Tak.

Dlatego wykonuje:

break

czyli wychodzi z pętli.

Bardzo ważne: liczba 0 nie zostaje dodana do sumy, bo break jest przed instrukcją:

suma = suma + x

Po wyjściu z pętli program wykonuje:

print("Suma podanych liczb:", suma)

Wypisze:

Suma podanych liczb: 14

Podsumowanie w tabeli

Najprostsze wyjaśnienie dla ucznia:

Program nie trzyma wszystkich liczb w x.
x to tylko bieżąca liczba.
suma to skarbonka, do której program wrzuca każdą kolejną liczbę.
Gdy wpiszesz 0, program zamyka skarbonkę i pokazuje, ile jest w środku.

Wielu uczniów mechanicznie przepisuje:

for liczba in liczby:

nie rozumiejąc, co się właściwie dzieje.

Program ma wypisać wszystkie elementy listy:

4
7
2
9

Najpierw tworzona jest lista:

liczby = [4, 7, 2, 9]

Można ją sobie wyobrazić jako pudełko z czterema przegródkami:

Program napotyka:

for liczba in liczby:

Czytamy to po polsku jako:

Dla każdej liczby znajdującej się na liście liczby wykonaj instrukcje poniżej.

Python będzie kolejno wyciągał elementy z listy.

Pierwszy obieg pętli. Python bierze pierwszy element listy:

4

i przypisuje go do zmiennej:

liczba

Czyli chwilowo:

liczba = 4

Następnie wykonuje:

print(liczba)

Wynik:

4

Drugi obieg pętli. Python bierze kolejny element:

7

i zapisuje:

liczba = 7

Następnie wykonuje:

print(liczba)

Wynik:

7

Trzeci obieg

liczba = 2

Program wypisuje:

2

Czwarty obieg

liczba = 9

Program wypisuje:

9

Python sprawdza:

Czy na liście są jeszcze jakieś elementy?

Nie.

Pętla kończy działanie.

Co dzieje się „w głowie” programu? Można to rozpisać tak:

liczba = 4
print(liczba)
liczba = 7
print(liczba)
liczba = 2
print(liczba)
liczba = 9
print(liczba)

Pętla robi to automatycznie.

Skąd nazwa „liczba”? To tylko nazwa zmiennej.

Można napisać:

for x in liczby:    
print(x)

albo:

for element in liczby:    
print(element)

albo nawet:

for kot in liczby:    
print(kot)

Program zadziała identycznie.

Dlaczego zwykle piszemy „liczba”?

Bo nazwa pomaga zrozumieć kod.

To:

for liczba in liczby:

od razu sugeruje:

na liście znajdują się liczby

Natomiast:

for x in liczby:

też jest poprawne, ale mniej opisowe.

Jak zapamiętać działanie pętli for?

Najprostsza reguła:

for zmienna in lista:

oznacza:

Weź kolejno każdy element listy i włóż go do zmiennej.

Przykład:

owoce = ["jabłko", "gruszka", "śliwka"]
for owoc in owoce:    
print(owoc)

Python wykonuje:

owoc = "jabłko"
owoc = "gruszka"
owoc = "śliwka"

Tak samo w przykładzie:

for liczba in liczby:

oznacza:

liczba = 4
liczba = 7
liczba = 2
liczba = 9

kolejno, jeden element po drugim. To właśnie jest najważniejsza idea pętli for.

Program szuka największej liczby na liście.

Krok 1 — tworzymy listę

liczby = [4, 7, 2, 9, 3]

Program ma listę pięciu liczb:

Krok 2 — zakładamy, że największa jest pierwsza liczba

maksimum = liczby[0]

liczby[0] oznacza pierwszy element listy, czyli 4.

Na początku program zapisuje więc:

maksimum = 4

To jest tylko założenie startowe. Program jeszcze nie wie, czy 4 naprawdę jest największe.

Krok 3 — pętla sprawdza kolejne liczby

for liczba in liczby:

To znaczy:

Weź po kolei każdą liczbę z listy liczby i na chwilę nazwij ją liczba.

Program będzie więc sprawdzał kolejno:

4, 7, 2, 9, 3

Krok 4 — porównujemy bieżącą liczbę z maksimum

if liczba > maksimum:

Program pyta:

Czy aktualnie sprawdzana liczba jest większa od największej zapamiętanej do tej pory?

Jeśli tak, aktualizuje maksimum:

maksimum = liczba

Jeśli nie, nic nie zmienia.

Przebieg programu w tabeli

Krok 5 — wypisujemy wynik

Po zakończeniu pętli program ma już sprawdzone wszystkie liczby. W zmiennej maksimum została największa znaleziona wartość:

maksimum = 9

Dlatego:

print("Największa liczba:", maksimum)

wypisze:

Największa liczba: 9

Ważne:

Zmienna maksimum działa jak notatka z najlepszym wynikiem do tej pory.

Na początku zapisujemy pierwszą liczbę. Potem idziemy przez listę i za każdym razem pytamy:

Czy znalazłam coś większego niż to, co mam zapisane?

Jeśli tak — poprawiamy notatkę.
Jeśli nie — zostawiamy starą wartość.

Krok 1 — tworzymy listę

Program tworzy listę:

liczby = [4, 7, 2, 9, 3, 10, 12]

Można ją przedstawić tak:

Program ma sprawdzić każdą z tych liczb.

Krok 2 — tworzymy licznik

ile = 0

Program jeszcze nie znalazł żadnej liczby parzystej, więc licznik wynosi:

ile = 0

Można go traktować jak licznik osób wchodzących do sali.

Na początku sala jest pusta.

Krok 3 — rozpoczynamy pętlę

for liczba in liczby:

Python mówi:

Weź kolejno każdą liczbę z listy i włóż ją do zmiennej liczba.

Będzie więc kolejno:

liczba = 4
liczba = 7
liczba = 2
liczba = 9
liczba = 3
liczba = 10
liczba = 12

Krok 4 — sprawdzamy pierwszą liczbę

Pierwsza liczba to:

liczba = 4

Program wykonuje:

liczba % 2 == 0

Najpierw oblicza:

4 % 2

Reszta z dzielenia wynosi:

0

Ponieważ:

4 = 2 × 2 + 0

Warunek:

4 % 2 == 0

jest prawdziwy.

Program zwiększa licznik:

ile = ile + 1

czyli:

ile = 0 + 1
ile = 1

Krok 5 — sprawdzamy drugą liczbę

liczba = 7

Program liczy:

7 % 2 = 1

Ponieważ:

7 = 3 × 2 + 1

Warunek:

7 % 2 == 0

jest fałszywy.

Program nic nie robi.

Licznik pozostaje:

ile = 1

Krok 6 — sprawdzamy trzecią liczbę

liczba = 2

Program liczy:

2 % 2 = 0

Warunek jest prawdziwy.

Program zwiększa licznik:

ile = 1 + 1
ile = 2

Krok 7 — kolejne liczby

Dla 9

9 % 2 = 1

Nieparzysta. Program nic nie robi.

Licznik pozostaje:

ile = 2

Dla 3

3 % 2 = 1

Nieparzysta. Program nie robi nic.

Licznik pozostaje:

ile = 2

Dla 10

10 % 2 = 0

Parzysta.

Program zwiększa licznik:

ile = 2 + 1
ile = 3

Dla 12

12 % 2 = 0

Parzysta.

Program zwiększa licznik:

ile = 3 + 1
ile = 4

Przebieg programu w tabeli

Krok 8 — wypisujemy wynik

Po zakończeniu pętli Python sprawdził już wszystkie liczby z listy.

W zmiennej:

ile = 4

znajduje się liczba znalezionych liczb parzystych.

Program wykonuje:

print("Liczb parzystych jest:", ile)

i wypisuje:

Liczb parzystych jest: 4

Jak „myśli” program?

Można wyobrazić sobie, że Python przechodzi wzdłuż listy z notatnikiem.

Przy każdej liczbie zadaje sobie pytanie:

Czy ta liczba dzieli się przez 2 bez reszty?

Jeżeli tak:

Znalazłem kolejną liczbę parzystą — zwiększam licznik o 1.

Jeżeli nie:

To nie jest liczba parzysta — idę dalej.

Na końcu licznik pokazuje, ile takich liczb zostało znalezionych.

To jest klasyczny schemat maturalny zwany zliczaniem elementów spełniających warunek. Bardzo podobnie liczy się na maturze:

• liczbę liczb dodatnich,
• liczbę liczb pierwszych,
• liczbę słów o określonej długości,
• liczbę rekordów spełniających podany warunek.

Czy to zadanie można zrobić bez return?

Tak, można, ale wtedy funkcja będzie działała trochę inaczej.

Oryginalny program:

def suma(a, b):    
    return a + b
wynik = suma(5, 7)
print(wynik)

Najpierw funkcja oblicza:

5 + 7 = 12

Następnie:

return a + b

oddaje wynik do miejsca wywołania.

Czyli:

wynik = suma(5, 7)

staje się dla Pythona:

wynik = 12

Potem:

print(wynik)

wypisuje:

12

Wersja bez return

Możesz napisać:

def suma(a, b):
    print(a + b)
suma(5, 7)

Wynik:

12

Program zadziała, ale jest pewna różnica.

Funkcja tylko wyświetla wynik, ale go nie zwraca.

Skąd wiadomo, że jest problem?

Spróbujmy:

def suma(a, b):
    print(a + b)
wynik = suma(5, 7)
print(wynik)

Python wykona:

12
None

Dlaczego?

Bo funkcja nic nie zwróciła.

W takiej sytuacji Python automatycznie zwraca:

None

czyli:

brak wyniku

*Można też użyć zmiennej globalnej

Teoretycznie:

wynik = 0
def suma(a, b):    
    global wynik    
    wynik = a + b
suma(5, 7)
print(wynik)

Wynik:

12

Ale tego sposobu raczej nie uczy się na początku, bo prowadzi do wielu błędów.

Dlaczego na maturze używa się return?

Bo funkcja ma być jak kalkulator:

def suma(a, b):
    return a + b

Możemy wtedy zrobić:

x = suma(5, 7)
y = suma(10, 20)
print(x)
print(y)

albo nawet:

print(suma(5, 7) * 2)

Program najpierw obliczy:

suma(5, 7) = 12

a potem:

12 * 2 = 24

Jak to wyjaśnić jeszcze łatwiej?

Można użyć takiej analogii:

• print() = funkcja mówi wynik na głos.
• return = funkcja podaje wynik na kartce.

Jeżeli ktoś tylko powie:

12

to usłyszysz wynik, ale nie możesz go później wykorzystać.

Jeżeli poda Ci kartkę z napisem:

12

to możesz ją schować, skopiować, pomnożyć przez 2 albo wykorzystać później.

Właśnie dlatego w większości zadań maturalnych funkcje zwracają wynik przez return, a nie tylko go wyświetlają.

Co program ma sprawdzić?

Program sprawdza, czy podana liczba jest liczbą pierwszą.

Liczba pierwsza to liczba naturalna większa od 1, która ma dokładnie dwa dzielniki:

1 i samą siebie

Przykłady liczb pierwszych:

2, 3, 5, 7, 11, 13, 17

Przykłady liczb złożonych:

4, 6, 8, 9, 10, 12, 15

Krok 1 — definiujemy funkcję

def czy_pierwsza(n):

Słowo def oznacza, że tworzymy funkcję.

Nazwa funkcji to:

czy_pierwsza

W nawiasie znajduje się parametr:

n

Parametr n oznacza liczbę, którą funkcja będzie sprawdzać.

Na przykład jeśli później napiszemy:

czy_pierwsza(7)

to wewnątrz funkcji:

n = 7

Krok 2 — sprawdzamy liczby mniejsze od 2

if n < 2:    
    return False

Operator < oznacza „mniejsze niż”.

Program pyta:

Czy n jest mniejsze od 2?

Jeżeli tak, funkcja od razu zwraca:

False

czyli „fałsz”.

Dlaczego?

Bo liczby:

..., -3, -2, -1, 0, 1

nie są liczbami pierwszymi.

Przykład:

czy_pierwsza(1)

Wtedy:

n = 1

Program sprawdza:

1 < 2

To prawda, więc wykonuje:

return False

Funkcja kończy działanie.

Krok 3 — zaczynamy sprawdzać dzielniki

for i in range(2, int(n ** 0.5) + 1):

To najtrudniejsza linia w programie.

Rozbijmy ją na części.

Co oznacza for i in range(...)?

for i in range(...):

oznacza:

Weź kolejno liczby z podanego zakresu i zapisuj je tymczasowo do zmiennej i.

Zmienna i będzie kandydatem na dzielnik liczby n.

Czyli program będzie sprawdzał:

Czy n dzieli się przez i?

Dlaczego zaczynamy od 2?

range(2, ...)

Nie sprawdzamy dzielnika 1, bo każda liczba dzieli się przez 1.

W liczbach pierwszych chodzi o to, czy liczba ma dodatkowy dzielnik oprócz 1 i samej siebie.

Dlatego zaczynamy od:

2

Co oznacza n ** 0.5?

Operator ** oznacza potęgowanie.

Przykład:

3 ** 2

oznacza:

3 do potęgi 2 = 9

Zapis:

n ** 0.5

oznacza:

pierwiastek kwadratowy z n

Dlaczego?

Bo potęga 0.5 to inaczej pierwiastek kwadratowy.

Przykład:

25 ** 0.5

daje:

5.0

Dlaczego sprawdzamy tylko do pierwiastka?

Jeżeli liczba n ma dzielnik większy od pierwiastka z n, to musi mieć też drugi dzielnik mniejszy od pierwiastka.

Przykład dla liczby 36:

36 = 2 × 18
36 = 3 × 12
36 = 4 × 9
36 = 6 × 6
36 = 9 × 4
36 = 12 × 3
36 = 18 × 2

Po liczbie 6 pary zaczynają się powtarzać w odwrotnej kolejności.

Pierwiastek z 36 to:

6

Wystarczy więc sprawdzić dzielniki do 6.

Co oznacza int(...)?

int(n ** 0.5)

Funkcja int() zamienia wynik na liczbę całkowitą, odcinając część po przecinku.

Przykład:

int(4.79)

daje:

4

Dla liczby 20:

20 ** 0.5

to około:

4.47

Po zastosowaniu int():

4

Dlaczego dodajemy + 1?

int(n ** 0.5) + 1

Ponieważ range() nie uwzględnia ostatniej wartości.

Przykład:

range(2, 5)

daje:

2, 3, 4

Nie daje liczby 5.

Jeśli chcemy sprawdzić dzielniki do 4 włącznie, musimy napisać:

range(2, 5)

Dlatego dodajemy + 1.

Przykład dla liczby 29

Jeśli:

n = 29

to:

n ** 0.5

daje około:

5.38

int(n ** 0.5)

daje:

5

int(n ** 0.5) + 1

daje:

6

Czyli pętla:

for i in range(2, 6):

sprawdzi:

2, 3, 4, 5

Krok 4 — sprawdzamy, czy i jest dzielnikiem liczby n

if n % i == 0:

Operator % oznacza resztę z dzielenia.

Przykład:

10 % 2

daje:

0

bo 10 dzieli się przez 2 bez reszty.

Przykład:

10 % 3

daje:

1

bo:

10 = 3 × 3 + 1

Operator == oznacza „czy jest równe”.

Uwaga:

=

to przypisanie wartości.

==

to porównanie.

Warunek:

n % i == 0

oznacza:

Czy liczba n dzieli się przez i bez reszty?

Jeżeli tak, znaleźliśmy dzielnik, więc liczba nie jest pierwsza.

Krok 5 — jeśli znajdziemy dzielnik, kończymy funkcję

return False

Jeśli program znajdzie choć jeden dzielnik, nie musi sprawdzać dalej.

Przykład:

n = 21

Program sprawdza:

21 % 2 = 1
21 % 3 = 0

Skoro 21 dzieli się przez 3, to już wiadomo, że nie jest pierwsza.

Funkcja zwraca:

False

i kończy działanie.

Krok 6 — jeśli nie znaleziono dzielnika

return True

Jeżeli pętla zakończyła się i nie znaleziono żadnego dzielnika, oznacza to, że liczba jest pierwsza.

Funkcja zwraca:

True

czyli „prawda”.

Krok 7 — pobieramy liczbę od użytkownika

liczba = int(input("Podaj liczbę: "))

Tu dzieją się dwie rzeczy.

Najpierw:

input("Podaj liczbę: ")

pobiera dane od użytkownika jako tekst.

Na przykład użytkownik wpisuje:

29

Dla Pythona to na początku jest tekst:

"29"

Potem:

int(...)

zamienia tekst na liczbę całkowitą:

29

I zapisuje ją do zmiennej:

liczba = 29

Krok 8 — wywołujemy funkcję w instrukcji warunkowej

if czy_pierwsza(liczba):

To oznacza:

Uruchom funkcję czy_pierwsza dla wartości zapisanej w zmiennej liczba.

Jeśli:

liczba = 29

to Python wykonuje:

czy_pierwsza(29)

Wewnątrz funkcji:

n = 29

Funkcja zwróci True albo False.

Krok 9 — decyzja na podstawie wyniku funkcji

Jeżeli funkcja zwróci:

True

wykona się:

print("Liczba pierwsza")

Jeżeli funkcja zwróci:

False

wykona się:

print("Liczba złożona albo mniejsza od 2")

Przykład działania dla liczby 29

Użytkownik wpisuje:

29

Program wywołuje:

czy_pierwsza(29)

Funkcja sprawdza:

29 < 2? Nie

Następnie przygotowuje zakres:

pierwiastek z 29 ≈ 5.38
int(5.38) = 5
5 + 1 = 6
range(2, 6) daje: 2, 3, 4, 5

Sprawdza:

29 % 2 = 1
29 % 3 = 2
29 % 4 = 1
29 % 5 = 4

Nie znalazła dzielnika.

Zwraca:

True

Program wypisuje:

Liczba pierwsza

Przykład działania dla liczby 21

Użytkownik wpisuje:

21

Program wywołuje:

czy_pierwsza(21)

Funkcja sprawdza:

21 < 2? Nie

Zakres:

pierwiastek z 21 ≈ 4.58
int(4.58) = 4
4 + 1 = 5
range(2, 5) daje: 2, 3, 4

Sprawdza:

21 % 2 = 1
21 % 3 = 0

Znalazła dzielnik 3.

Funkcja natychmiast zwraca:

False

Program wypisuje:

Liczba złożona albo mniejsza od 2

Nie sprawdza już liczby 4, bo nie ma takiej potrzeby.

Przebieg dla 21 w tabeli

Wszystkie ważne operatory z kodu

Jak program „myśli”?

Najprościej:

Jeśli liczba jest mniejsza od 2, nie jest pierwsza.
W przeciwnym razie sprawdzam, czy ma jakiś dzielnik od 2 do pierwiastka z tej liczby.
Jeśli znajdę dzielnik, zwracam False.
Jeśli nie znajdę żadnego dzielnika, zwracam True.

Funkcja działa jak kontroler:

czy_pierwsza(29) → True
czy_pierwsza(21) → False
czy_pierwsza(1)  → False

Dzięki return wynik funkcji można potem wykorzystać w instrukcji:

if czy_pierwsza(liczba):

czyli program może podjąć decyzję na podstawie tego, co funkcja zwróciła.

Wyjaśnienie krok po kroku

Krok 1 — użytkownik wpisuje tekst

tekst = input("Podaj tekst: ")

Program prosi użytkownika o podanie tekstu.

Załóżmy, że użytkownik wpisze:

kot

Wtedy w pamięci programu powstaje zmienna:

tekst = "kot"

Zmienna tekst przechowuje cały napis.

Krok 2 — napis jest ciągiem znaków

W Pythonie napis, czyli tekst, można traktować jak ciąg pojedynczych znaków.

Czyli:

"kot"

Python widzi jako:

To oznacza, że napis składa się z osobnych liter.

Krok 3 — pętla for przechodzi po tekście

for znak in tekst:

Ten zapis czytamy tak:

Dla każdego znaku znajdującego się w zmiennej tekst, wykonaj instrukcje poniżej.

Najważniejsze jest to:

in tekst

To właśnie mówi programowi, że ma przechodzić po zawartości zmiennej tekst.

Słowo znak jest tylko nazwą pomocniczej zmiennej. Można ją nazwać inaczej, np.:

for litera in tekst:    
    print(litera)

albo:

for x in tekst:    
    print(x)

Program zadziała tak samo.

Krok 4 — pierwszy obieg pętli

Tekst to:

kot

Program bierze pierwszy znak:

k

i na chwilę zapisuje:

znak = "k"

Potem wykonuje:

print(znak)

Wypisuje:

k

Krok 5 — drugi obieg pętli

Program bierze kolejny znak:

o

Teraz:

znak = "o"

Wypisuje:

o

Krok 6 — trzeci obieg pętli

Program bierze ostatni znak:

t

Teraz:

znak = "t"

Wypisuje:

t

Wynik programu

Dla tekstu kot wynik będzie taki:

k
o
t

Każda litera pojawia się w osobnym wierszu, ponieważ print() domyślnie przechodzi do nowej linii po każdym wypisaniu.

Dlaczego program wie, że znak dotyczy zmiennej tekst?

Bo tak mówi ta linia:

for znak in tekst:

Jej sens jest taki:

weź kolejny element z tekstu i nazwij go chwilowo znak

Czyli:

znak = "k"
znak = "o"
znak = "t"

po kolei.

Zmienna znak nie pojawia się „nagle” bez powodu. Ona zostaje utworzona przez pętlę for.

Najkrócej

for znak in tekst:

oznacza:

Przejdź po wszystkich znakach zmiennej tekst, a każdy kolejny znak nazwij tymczasowo znak.

Dlatego kod:

tekst = "kot"
for znak in tekst:    
    print(znak)

działa tak, jakby Python wykonał:

znak = "k"
print(znak)
znak = "o"
print(znak)
znak = "t"
print(znak)

Wyjaśnienie krok po kroku

Co program ma zrobić?

Program ma policzyć:

Ile razy litera a występuje w podanym tekście.

Przykład:

Jeżeli użytkownik wpisze:

ananas

to program powinien odpowiedzieć:

Liczba liter a: 3

ponieważ w słowie:

a n a n a s

litera a występuje trzy razy.

Krok 1 — pobieramy tekst

tekst = input("Podaj tekst: ")

Załóżmy, że użytkownik wpisuje:

ananas

W pamięci programu powstaje:

tekst = "ananas"

Możemy wyobrazić sobie ten napis jako listę znaków:

Krok 2 — tworzymy licznik

ile = 0

Program jeszcze nie znalazł żadnej litery a.

Dlatego:

ile = 0

Można to porównać do licznika osób przy wejściu do kina.

Na początku licznik pokazuje:

0

Krok 3 — rozpoczynamy pętlę

for znak in tekst:

To oznacza:

Weź kolejno każdy znak znajdujący się w napisie tekst.

Python będzie wykonywał:

znak = "a"
znak = "n"
znak = "a"
znak = "n"
znak = "a"
znak = "s"

po kolei.

Krok 4 — pierwszy obieg pętli

Python bierze pierwszy znak:

znak = "a"

Następnie sprawdza:

if znak == "a":

Operator:

==

oznacza:

Czy lewa strona jest równa prawej stronie?

Program pyta:

Czy "a" jest równe "a"?

Odpowiedź:

Tak

Dlatego wykonuje:

ile = ile + 1

czyli:

ile = 0 + 1
ile = 1

Krok 5 — drugi obieg pętli

Python bierze kolejny znak:

znak = "n"

Sprawdza:

Czy "n" jest równe "a"?

Odpowiedź:

Nie

Nic nie robi.

Licznik pozostaje:

ile = 1

Krok 6 — trzeci obieg pętli

Python bierze:

znak = "a"

Sprawdza:

Czy "a" jest równe "a"?

Tak.

Zwiększa licznik:

ile = 1 + 1
ile = 2

Krok 7 — czwarty obieg

znak = "n"

Warunek jest fałszywy.

Licznik:

ile = 2

Krok 8 — piąty obieg

znak = "a"

Warunek jest prawdziwy.

Program wykonuje:

ile = 2 + 1
ile = 3

Krok 9 — szósty obieg

znak = "s"

Warunek jest fałszywy.

Licznik pozostaje:

ile = 3

Przebieg programu w tabeli

Krok 10 — wypisujemy wynik

Po zakończeniu pętli program wykona:

print("Liczba liter a:", ile)

Ponieważ:

ile = 3

na ekranie pojawi się:

Liczba liter a: 3

Skąd program wie, że ma sprawdzać kolejne litery?

Dzięki tej linii:

for znak in tekst:

Słowo:

tekst

oznacza napis:

"ananas"

Python wie, że napis jest ciągiem pojedynczych znaków.

Dlatego wykonuje:

znak = "a"
znak = "n"
znak = "a"
znak = "n"
znak = "a"
znak = "s"

jeden po drugim.

Jak „myśli” program?

Można wyobrazić sobie, że program przesuwa palec po kolejnych literach słowa:

a n a n a s↑

i za każdym razem pyta:

Czy to jest litera „a”?

Jeżeli tak:

Znalazłem kolejne „a”, zwiększam licznik.

Jeżeli nie:

To nie jest „a”, idę dalej.

Po przejrzeniu całego napisu licznik pokazuje, ile liter a zostało znalezionych.

To jest bardzo ważny schemat maturalny zwany:

zliczaniem elementów spełniających warunek

Tak samo można później liczyć:

• liczbę spacji w tekście,
• liczbę samogłosek,
• liczbę cyfr,
• liczbę wielkich liter,
• liczbę słów spełniających określony warunek.

Co program ma zrobić?

Program sprawdza, czy podany tekst jest palindromem.

Palindrom to wyraz lub zdanie, które czytane od lewej do prawej i od prawej do lewej wygląda tak samo.

Przykłady palindromów:

kajak
oko
radar
abba

Przykłady, które nie są palindromami:

kot
python
informatyka

Krok 1 — pobieramy tekst od użytkownika

tekst = input("Podaj tekst: ")

Załóżmy, że użytkownik wpisuje:

kajak

W pamięci programu powstaje zmienna:

tekst = "kajak"

Możemy rozpisać ją jako ciąg znaków:

Krok 2 — przechodzimy do instrukcji warunkowej

Program wykonuje:

if tekst == tekst[::-1]:

To jest najważniejsza linia programu.

Rozbijmy ją na części.

Co oznacza ==?

Operator:

==

oznacza:

Czy lewa strona jest równa prawej stronie?

Przykład:

5 == 5

daje:

True

natomiast:

5 == 3

daje:

False

Co oznacza tekst[::-1]?

To specjalny zapis Pythona służący do odwracania napisu.

Jeżeli:

tekst = "kajak"

to:

tekst[::-1]

oznacza:

odwrócony napis

Program tworzy:

kajak

ponieważ słowo „kajak” po odwróceniu wygląda identycznie.

Jak działa [::-1]?

Można to rozłożyć na części:

[start:stop:krok]

W naszym przypadku:

[::-1]

oznacza:

Python czyta więc napis od końca do początku.

Przykład dla słowa „kot”

Jeżeli:

tekst = "kot"

to:

tekst[::-1]

tworzy:

tok

Bo Python bierze litery od końca:

t
o
k

i składa z nich nowy napis.

Krok 3 — porównujemy oba napisy

Załóżmy, że użytkownik wpisał:

kajak

Program porównuje:

tekst       = "kajak"
tekst[::-1] = "kajak"

Czy:

"kajak" == "kajak"

?

Odpowiedź:

Tak

Python otrzymuje:

True

Krok 4 — wykonujemy odpowiedni blok kodu

Ponieważ warunek jest prawdziwy:

if tekst == tekst[::-1]:

program wykonuje:

print("To palindrom")

Na ekranie pojawia się:

To palindrom

Drugi przykład — słowo „kot”

Użytkownik wpisuje:

kot

Program zapisuje:

tekst = "kot"

Odwracamy napis

tekst[::-1]

daje:

tok

Porównujemy

Program sprawdza:

"kot" == "tok"

Odpowiedź:

Nie

czyli:

False

Wykonuje się część else

else:    
    print("To nie jest palindrom")

Na ekranie pojawia się:

To nie jest palindrom

Przebieg programu dla słowa „kajak”

Przebieg programu dla słowa „kot”

Jak „myśli” program?

Można wyobrazić sobie, że program bierze kartkę z napisem:

kajak

Następnie tworzy drugą kartkę:

kajak

czytaną od końca.

Potem pyta:

Czy obie kartki wyglądają identycznie?

Jeżeli tak:

To palindrom

Jeżeli nie:

To nie jest palindrom

Ważna uwaga dla maturzystów

Ten zapis:

tekst[::-1]

jest bardzo wygodny i często spotykany w Pythonie.

Jednak na maturze warto również rozumieć, że można odwrócić napis samodzielnie za pomocą pętli. Dzięki temu łatwiej rozwiązywać bardziej zaawansowane zadania związane z analizą tekstu.