Lekce 10 - Cyklus for v Pythonu

V předešlém cvičení, Řešené úlohy k 8.-9. lekci Pythonu, jsme si procvičili nabyté zkušenosti z předchozích lekcí.

Nyní přejdeme k cyklům. Po dnešním Python tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni v Pythonu programovat rozumné aplikace.

Cykly

Jak již slovo cyklus napovídá, něco se bude opakovat. Když chceme v programu něco udělat stokrát, jistě nebudeme stokrát psát pod sebe tentýž kód. Místo toho jej vložíme do cyklu. Cyklů máme více druhů. Samozřejmě si vysvětlíme, kdy který použít, a ukážeme si praktické příklady.

Cyklus for

Chceme-li pracovat se všemi prvky v sekvenci, použijeme cyklus for. Tento cyklus vždy obsahuje pevný počet opakování, který se rovná počtu prvků v sekvenci. Syntaxe (zápis) cyklu for je následující:

for prvek in sekvence:
    # blok příkazů

Sekvence v Pythonu jsou kontejnerové datové struktury, tj. jsou to proměnné, které mohou obsahovat více položek. S kontejnerovou strukturou (řetězci) jsme se již setkali.

Funkce range()

Pro cyklus for máme k dispozici funkci range(). Funkce nám vrací vygenerovaná čísla, například ve formě rozsahu (intervalu).

Funkce má tři parametry, její syntaxe je range(začátek, konec, krok):

• Začátek určuje, na kterém indexu se začíná. Výchozí hodnota je 0. Jedná se o nepovinný parametr.
• Konec určuje, na kterém indexu se končí. Pozor, tento index už však zahrnutý není. V dokumentaci se popisuje jako n-1 a jedná se o povinný parametr.
• Krok specifikuje způsob inkrementace (můžeme zvyšovat libovolně: po dvou, po deseti…). Výchozí hodnota je 1 a jedná se o nepovinný parametr.

Funkci range() tedy můžeme mít s jedním až třemi parametry:

• range(n) – Vrátí čísla od nuly do n-1 (do n, které už zahrnuto není).
• range(m, n) – Vrátí čísla od m do n-1.
• range(m, n, i) – Vrátí čísla od m a každé další i-té číslo do n-1.

Příklady použití cyklu for

Pojďme si udělat několik jednoduchých příkladů na procvičení for cyklu.

Klepání na dveře

Většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty, kteří ho neznají, budeme simulovat situaci, kdy Sheldon klepe na dveře své sousedky. Vždy třikrát zaklepe a poté zavolá: "Penny!". Náš kód by bez cyklů vypadal takto:

print("Knock")
print("Knock")
print("Knock")
print("Penny!")

My už ale nic otrocky opisovat nemusíme:

for i in range(3):
    print("Knock")
print("Penny!")

Výstup programu:

Výstup cyklu for:
Knock
Knock
Knock
Penny!

Cyklus proběhne třikrát díky parametru 3 ve funkci range(). Nyní můžeme zkusit napsat do parametru funkce range() v cyklu místo trojky jedenáctku.

Řada

Příkaz se spustí jedenáctkrát, aniž napíšeme něco navíc. Vidíme, že cykly jsou mocným nástrojem. Vypišme si nyní čísla od jedné do deseti a za každým mezeru:

for i in range(1, 11):
    print(i, end = ' ')

Vidíme, že proměnná má opravdu v každé iteraci (průběhu) jinou hodnotu:

Výstup cyklu:
1 2 3 4 5 6 7 8 9 10

Parametr end=' ' zajistí, že program po vypsání každého čísla nevloží nový řádek, ale místo toho mezeru.

Lichá čísla

Pomocí funkce range() můžeme také určit hranice intervalu, který chceme iterovat, a to včetně kroku:

for i in range(1, 11, 2):
    print(i, end = ' ')

Kód iteruje přes čísla v rozmezí od 1 do 10 (včetně 1 a vyloučeně 11) s krokem 2. Bude tedy vypisovat lichá čísla:

Výstup cyklu:
1 3 5 7 9

Sekvence znaků

Už jsme si řekli, že cyklus for projde všechny prvky v sekvenci. Iterovatelná sekvence je také řetězec a prvek je pak jednotlivý znak v řetězci. V každé iteraci se aktuální prvek sekvence zkopíruje do proměnné prvek a provedou se příkazy v cyklu. Vyzkoušejme si to na řetězcové sekvenci, kdy si každý znak vypíšeme na jednotlivý řádek:

slovo = "ahoj"
for znak in slovo:
   print(znak)

Výstupem je:

Výstup cyklu:
a
h
o
j

Malá násobilka

Nyní si vypíšeme malou násobilku (násobky čísel 1 až 10, vždy do deseti). Abychom zadání splnili, napíšeme si cyklus, který projde čísla od 1 do 10 a proměnnou vždy vynásobí daným číslem. Kód by mohl vypadat asi takto:

for i in range(1, 11):
    print(i, end = " ")
print()
for i in range(1, 11):
    print(i * 2, end = " ")
print()
for i in range(1, 11):
    print(i * 3, end = " ")
print()
for i in range(1, 11):
    print(i * 4, end = " ")
print()
for i in range(1, 11):
    print(i * 5, end = " ")
print()
for i in range(1, 11):
    print(i * 6, end = " ")
print()
for i in range(1, 11):
    print(i * 7, end = " ")
print()
for i in range(1, 11):
    print(i * 8, end = " ")
print()
for i in range(1, 11):
    print(i * 9, end = " ")
print()
for i in range(1, 11):
    print(i * 10, end = " ")

Výstup v konzoli:

Výstup cyklů:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Za pozornost stojí prázdná funkce print(), která zde plní funkci odřádkování na konci každého řádku. Program funguje hezky, ale stále jsme toho museli dost napsat. Pokud vás napadlo, že v podstatě děláme desetkrát totéž a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání v tom, abychom vložili dva cykly do sebe:

print("Malá násobilka pomocí dvou cyklů:")
for j in range(1, 11):
    for i in range(1, 11):
        print(i * j, end = " ")
    print()

Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme použít u obou cyklů proměnnou i, protože jsou vložené do sebe. Proměnná j nabývá ve vnějším cyklu hodnoty 1 až 10. V každé iteraci (rozumějme průběhu) cyklu je poté spuštěn další cyklus s proměnnou i. Tento cyklus je nám již známý, vypíše násobky, v tomto případě násobíme proměnnou j. Po každém běhu vnitřního cyklu pak dojde ještě k odřádkování zavoláním prázdné funkce print().

Mocnina čísla

Udělejme si ještě jeden program, na kterém si ukážeme práci s vnější proměnnou. Aplikace bude umět spočítat libovolnou mocninu libovolného čísla:

print("Mocninátor")
print("==========")
a = int(input("Zadejte základ mocniny: "))
n = int(input("Zadejte exponent: "))
result = a
for i in range(n - 1):
    result = result * a

print(f"Výsledek: {result}")
print("Děkuji za použití mocninátoru")

Výstup programu:

Konzolová aplikace
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru

Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomeneme, že například 2³ = 2 * 2 * 2. Mocninu aⁿ tedy spočítáme tak, že n-1krát vynásobíme číslo a číslem a. Výsledek si samozřejmě musíme ukládat do proměnné. Zpočátku bude mít hodnotu proměnné a a postupně se bude v cyklu pronásobovat. Pokud k mocninám potřebujete více informací, máme tu samozřejmě lekci s algoritmem výpočtu libovolné mocniny.

Nyní už tedy víme, k čemu se for cyklus využívá. Zapamatujme si, že počet opakování je pevně daný.

V příští lekci, Cyklus while v Pythonu, se ještě budeme věnovat cyklům. Naučíme se používat while cyklus a vylepšíme naši kalkulačku.

 

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.