Add lessons on some special iterables: range, zip, enumerate

Author: encukou

courses/pyladies/info.yml

@@ -104,6 +104,12 @@ plan:
     url: https://pyvec.github.io/cheatsheets/lists/lists-cs.pdf
     type: cheatsheet
 
+- title: Iterujeme
+  slug: iteration
+  materials:
+  - lesson: beginners/range
+  - lesson: beginners/zip-enumerate
+
 - title: Grafika
   slug: pyglet
   materials:

lessons/beginners/range/index.md

@@ -0,0 +1,98 @@
+# Range – sekvence čísel
+
+Funkce `range(10)` vrátí speciální hodnotu,
+která v sobě obsahuje čísla od 0 do 9:
+
+```pycon
+>>> sekvence = range(10)
+>>> sekvence
+range(0, 10)
+```
+
+Je to hodnota typu `range`, podobně jako čísla jsou typu `int`, řetězce typu
+`str`, nebo seznamy typu `list`.
+
+Chceš-li se podívat, co v tomhle `range(0, 10)` vlastně je, máš dvě základní
+možnosti – projít ho cyklem `for` nebo převést na seznam konkrétních čísel:
+
+```pycon
+>>> sekvence
+range(0, 10)
+>>> for i in sekvence:
+...     print(i)
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+>>> list(sekvence)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+Možná se ptáš – proč tak složitě?
+Proč se místo `range(0, 10)` prostě ta čísla neukážou rovnou?
+
+Je to proto, že `range` se dá použít na opravdu dlouhé řady čísel:
+
+```pycon
+>>> range(10000)
+range(0, 10000)
+>>> list(range(10000))
+[0, 1, 2, 3, ..., 9999]
+```
+
+Kdybys zkusil{{a}} třeba `list(range(1000000000000000000))`, počítači
+dojde paměť.
+Miliarda čísel se tam prostě nevejde.
+Python vyhodí výjimku  `MemoryError`.
+Se samotným `range(1000000000000000000)` ale není problém.
+S konceptem čísel od 0 do miliardy se počítač vypořádá, i když si je neumí
+„zapamatovat“ všechny *najednou*.
+
+Je spousta věcí, které Python umí s `range` udělat, aniž by potřeboval
+„spočítat“ každé z čísel.
+Spousta operací, které znáš od seznamů, bude fungovat i s `range`:
+
+```pycon
+>>> zajimava_cisla = range(8, 10000, 3)  # Každé třetí číslo od 8 do 9999
+>>> zajimava_cisla[80]          # Osmdesáté "zajímavé číslo"
+248
+>>> zajimava_cisla[:5]          # Prvních 5 "zajímavých čísel"
+range(8, 23, 3)
+>>> list(zajimava_cisla[:5])    # Vypsání prvních 5 "zajímavých čísel"
+[8, 11, 14, 17, 20]
+>>> len(zajimava_cisla)         # Kolik tam je čísel?
+3331
+>>> 1337 in zajimava_cisla      # Je v této sekvenci moje konkrétní číslo ?
+True
+>>> zajimava_cisla.index(1337)  # Kolikáté je?
+443
+```
+
+```pycon
+>>> import random
+>>> random.choice(zajimava_cisla)
+1229
+```
+
+```pycon
+>>> for i in zajimava_cisla:
+...     print(i)
+...     if i > 20:
+...         break  # Stačilo!
+8
+11
+14
+17
+20
+23
+```
+
+Objekt `range` ale nejde měnit – metody jako `zajimava_cisla.sort()`,
+`zajimava_cisla.pop()` fungovat nebudou.
+

lessons/beginners/range/info.yml

@@ -0,0 +1,4 @@
+title: Range - sekvence čísel
+style: md
+attribution: Pro PyLadies Brno napsal Petr Viktorin, 2019.
+license: cc-by-sa-40

lessons/beginners/tuple/index.md

@@ -94,48 +94,6 @@ podil, zbytek = podil_a_zbytek(12, 5)
 > ```
 
 
-## Funkce, které vracejí <var>n</var>-tice
-
-`zip` je zajímavá funkce.
-Používá se ve `for` cyklech, podobně jako funkce `range`, která „dává” čísla.
-
-Když funkce `zip` dostane dva seznamy
-(či jiné věci použitelné ve `for`),
-„dává” dvojice, a to tak, že nejdřív spáruje
-první prvek jednoho seznamu s prvním prvkem
-druhého seznamu,
-pak druhý s druhým, třetí s třetím a tak dál.
-
-Hodí se to, když máš dva seznamy se stejnou
-strukturou – příslušné prvky k sobě „patří”
-a chceš je zpracovávat společně:
-
-```python
-osoby = 'máma', 'teta', 'babička', 'vrah'
-vlastnosti = 'hodná', 'milá', 'laskavá', 'zákeřný'
-for osoba, vlastnost in zip(osoby, vlastnosti):
-    print('{} je {}'.format(osoba, vlastnost))
-```
-
-Když `zip` dostane tři seznamy,
-bude tvořit trojice, ze čtyř seznamů nadělá čtveřice a tak dále.
-
-Další funkce, která vrací dvojice, je `enumerate`.
-Jako argument bere seznam (či jinou věc použitelnou
-ve `for`) a vždy spáruje index (pořadí v seznamu) s příslušným prvkem.
-Jako první tedy dá
-(0, *první prvek seznamu*), potom
-(1, *druhý prvek seznamu*),
-(2, *třetí prvek seznamu*)
-a tak dále.
-
-```python
-prvocisla = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
-
-for i, prvocislo in enumerate(prvocisla):
-    print('Prvočíslo č.{} je {}'.format(i, prvocislo))
-```
-
 ## Malé <var>n</var>-tice
 
 Jak vytvořit <var>n</var>-tici s žádným nebo jedním prvkem? Takhle:

lessons/beginners/zip-enumerate/index.md

@@ -0,0 +1,195 @@
+# Iterátory n-tic
+
+Některé hodnoty v Pythonu jsou *iterovatelné* (angl. *iterable*):
+obsahují sekvenci jiných hodnot a lze je „projít“ (iterovat) cyklem `for` nebo
+je převést na seznam.
+Už jich známe několik:
+
+```pycon
+>>> list(range(10))                 # sekvence čísel
+>>> list('ahoj')                    # řetězec
+>>> list(['Ahoj', 'Hello', 'Hei'])  # seznam
+>>> list((12, 'Sr', True))          # n-tice
+```
+
+Spousta těchto typů umí něco navíc: zjistit jestli obsahují nějaký prvek
+(`4 in range(10)`), zjistit délku (`len([1, 2, 3])`), převést na velká písmena
+(`'abc'.upper()`).
+Nic z toho ale není potřeba, aby byl objekt iterovatelný.
+
+Podívejme se na dva dalších iterovatelné objekty: `enumerate` a `zip`.
+
+
+## Enumerate: očíslování sekvence
+
+Funkce `enumerate` vezme nějakou existující sekvenci a *očísluje ji*:
+ve vrácené sekvenci budou dvojice (index, původní hodnota).
+
+Řekněme že máš tento seznam:
+
+```python
+trpaslici = ['Prófa', 'Stydlín', 'Dřímal', 'Kejchal', 'Štístko',
+             'Šmudla', 'Rejpal']
+```
+
+Když na něj použiješ `enumerate`, dostaneš objekt `enumerate`,
+který podobně jako `range()` neukáže svůj obsah „rovnou“,
+ale můžeš se „do něj“ podívat převedením na seznam.
+Uvidíš tak seznam dvojic (číslo, trpaslík):
+
+```pycon
+>>> enumerate(trpaslici)
+<enumerate object at 0x7f0db61b29d8>
+>>> list(enumerate(trpaslici))
+[(0, 'Prófa'), (1, 'Stydlín'), (2, 'Dřímal'), (3, 'Kejchal'), (4, 'Štístko'), (5, 'Šmudla'), (6, 'Rejpal')]
+```
+
+Místo převedení na seznam můžeš přes objekt `enumerate` iterovat cyklem `for`
+a pro každou dvojici něco udělat.
+Třeba ji hezky vypsat:
+
+```python
+for dvojice in enumerate(trpaslici):
+    # Rozbalení dvojice
+    index, trpaslik = dvojice
+    # Vypsání
+    print(f'Na pozici {index} je {trpaslik}!')
+```
+
+Objekt, který funkce `enumerate` vrací, je *iterátor dvojic* – sekvence,
+jejíž prvky jsou dvojice.
+
+## Rozbalování v cyklu for
+
+„Trpasličí“ cyklus se dá rozepsat takto:
+
+```python
+dvojice = 0, 'Prófa'    # toto dělá `for`
+index, trpaslik = dvojice
+print(f'Na pozici {index} je {trpaslik}!')
+
+dvojice = 1, 'Stydlín'  # toto dělá `for`
+index, trpaslik = dvojice
+print(f'Na pozici {index} je {trpaslik}!')
+
+dvojice = 2, 'Dřímal'  # toto dělá `for`
+index, trpaslik = dvojice
+print(f'Na pozici {index} je {trpaslik}!')
+
+# A tak dále
+```
+
+Kdybys to psal{{a}} ručně, lze to zjednodušit – přiřadit do dvou proměnných
+najedno, bez pomocné `dvojice`:
+
+```python
+index, trpaslik = 0, 'Prófa'    # toto by mohl dělat `for`
+print(f'Na pozici {index} je {trpaslik}!')
+
+index, trpaslik = 1, 'Stydlín'  # toto by mohl dělat `for`
+print(f'Na pozici {index} je {trpaslik}!')
+
+index, trpaslik = 2, 'Dřímal'  # toto by mohl dělat `for`
+print(f'Na pozici {index} je {trpaslik}!')
+
+# A tak dále
+```
+
+A `for` tohle ve skutečnosti umí: místo do proměnné `dvojice` může přiřadit
+rovnou do dvou proměnných `index, trpaslik`:
+
+```python
+for index, trpaslik in enumerate(trpaslici):
+    print(f'Na pozici {index} je {trpaslik}!')
+```
+
+Tohle je docela častẙ způsob práce s *iterátorem n-tic* – máš-li sekvenci,
+jejíž prvky jsou <var>n</var>-tice, můžeš jednotlivé součásti <var>n</var>-tice
+rozbalit přímo v hlavičce `for` cyklu.
+
+Zkus si to! Zkopíruj si tento seznam:
+
+```python
+dny = ['Po', 'Út', 'St', 'Čt', 'Pá', 'So', 'Ne']
+```
+
+… a zkus vypsat:
+
+```plain
+1. Po
+2. Út
+3. St
+4. Čt
+5. Pá
+6. So
+7. Ne
+```
+
+{% filter solution %}
+
+```python
+dny = ['Po', 'Út', 'St', 'Čt', 'Pá', 'So', 'Ne']
+for index, den in enumerate(dny):
+    cislo = index + 1
+    print(f'{cislo}. {den}')
+```
+
+To je trošku kostrbaté, ale dá se to zjednodušit: funkce `enumerate` zná
+pojmenovaný argument `start`, pomocí kterého umí sama
+počítat od jiného začátku než od nuly:
+
+```python
+dny = ['Po', 'Út', 'St', 'Čt', 'Pá', 'So', 'Ne']
+for index, den in enumerate(dny, start=1):
+    print(f'{index}. {den}')
+```
+
+{% endfilter %}
+
+
+## Zip: Víc iterací najednou
+
+Další iterátor <var>n</var>-tic je funkce `zip`, která umí projít dvě sekvence
+naráz.
+Řekněme že máš seznam věcí a k nim příslušných barev:
+
+``` python
+veci = ['tráva', 'slunce', 'mrkev', 'řeka']
+barvy = ['zelená', 'žluté', 'oranžová', 'modrá']
+```
+
+Kdtyž tyto dva seznamy dáš funkci `zip`, dostaneš iterátor který příslušné
+hodnoty spáruje.
+Bude tedy obsahovat:
+
+* Dvojici prvních prvků obou seznamů
+* Dvojici druhých prvků obou seznamů
+* Dvojici třetích prvků obou seznamů
+* ...
+
+``` python
+for vec, barva in zip(veci, barvy):
+    print(f"{vec} je {barva}")
+```
+
+Funguje to i pro více sekvencí.
+V následujícím případě je výsledný `zip` iterátor čtveřic (věc, barva,
+místo, číslo):
+
+``` python
+veci = ['tráva', 'slunce', 'mrkev', 'řeka']
+barvy = ['zelená', 'žluté', 'oranžová', 'modrá']
+mista = ['na zemi', 'nahoře', 'na talíři', 'za zídkou']
+cisla = range(4)
+
+for vec, barva, misto, cislo in zip(veci, barvy, mista, cisla):
+    print(f"{cislo}. {barva} {vec} je {misto}")
+```
+
+Když si ale vypíšeš samotný objekt `zip`, zjistíš že o sobě nic moc neřekne
+– podobně jako `enumerate`:
+
+```pycon
+>>> zip(veci, barvy, mista, cisla)
+<zip object at 0x7f0db61b1f48>
+```

lessons/beginners/zip-enumerate/info.yml

@@ -0,0 +1,4 @@
+title: Iterátory n-tic
+style: md
+attribution: Pro PyLadies Brno napsal Petr Viktorin, 2014-2019.
+license: cc-by-sa-40