Adjust materials for range, zip, enumerate

Author: encukou

lessons/beginners/range/index.md

@@ -46,13 +46,27 @@ range(0, 10000)
 [0, 1, 2, 3, ..., 9999]
 ```
 
-Kdybys zkusil{{a}} třeba `list(range(1000000000000000000))`, počítači
+Kdybys zkusil{{a}} třeba `list(range(1000000000000000))`, počítači
 dojde paměť.
-Miliarda čísel se tam prostě nevejde.
+Biliarda čí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*.
+
+
+> [warning]
+> Pokud máš na počítači v jiném okně neuloženou práci, radši `list(range(...))`
+> s hodně vysokými čísly nezkoušej.
+>
+> U absurdně vysokého čísla jako `1000000000000000` Python předem ví,
+> že mu paměť dojde, a tak ohlásí chybu ještě než se bude snažit seznam vytvořit.
+> U trochu menšího čísla (např. `1000000000`, ale na každém počítači je to
+> jinak) se může stát, že se Python pokusí seznam začít tvořit, zaplní přitom
+> většinu dostupné paměti a počítač „zamrzne“.
+> V závislosti na systému se pak třeba může stát že reakce na
+> <kbd>Ctrl</kbd>+<kbd>C</kbd> bude trvat hodně dlouho.
+
+Se samotným `range(1000000000000000)` ale není problém.
+S konceptem *všech čísel od 0 do biliardy* 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.
@@ -93,6 +107,25 @@ True
 23
 ```
 
-Objekt `range` ale nejde měnit – metody jako `zajimava_cisla.sort()`,
-`zajimava_cisla.pop()` fungovat nebudou.
+Objekt `range` ale nejde měnit – mazání prvků nebo metody jako
+`zajimava_cisla.sort()`, `zajimava_cisla.pop()` fungovat nebudou.
+
+> [note] Proč ne?
+> Když máš objekt jako `range(8, 10000, 3)`, osmdesátý prvek je jen trocha
+> matematiky: spočítáš `8 + 3 * 80` a zkontroluješ že to nepřesáhlo `10000`.
+> Podobně je to s ostatními sekvencemi „všech <var>X</var>-tých čísel od
+> <var>A</var> do <var>B</var>“, tedy s ostatními `range`.
+>
+> Kdyby ale šlo udělat něco jako:
+>
+> ```python
+> sekvence = range(8, 10000, 3)
+> del sekvence[10]
+> sekvence.insert(103, 'ježek')
+> ```
+>
+> … jde najednou o mnohem složitější koncept, kde se N-tý prvek hledá mnohem
+> hůř. Už to není jednoduchá sekvence čísel – už to není `range`, ale spíš
+> seznam jakýchkoli hodnot.
 
+Pokud budeš něco co `range` neumí potřebovat, převeď `range` na seznam.

lessons/beginners/zip-enumerate/index.md

@@ -18,6 +18,7 @@ Spousta těchto typů umí něco navíc: zjistit jestli obsahují nějaký prvek
 Nic z toho ale není potřeba, aby byl objekt iterovatelný.
 
 Podívejme se na dva další iterovatelné objekty: `enumerate` a `zip`.
+Oba jsou sekvence vytvořené z jiných, jednodušších sekvencí.
 
 
 ## Enumerate: očíslování sekvence
@@ -59,9 +60,23 @@ for dvojice in enumerate(trpaslici):
 Objekt, který funkce `enumerate` vrací, je *iterátor dvojic* – sekvence,
 jejíž prvky jsou dvojice.
 
+Sekvence `enumerate` toho „umí“ ještě míň než seznam nebo `range`.
+Nejde z ní ani vybírat prvky, o metodách jako `append` ani nemluvě:
+
+```pycon
+>>> enumerate(trpaslici)[3]
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'enumerate' object is not subscriptable
+```
+
+Když budeš od sekvence `enumerate` chtít něco víc než iterování,
+převeď ji na seznam.
+
+
 ## Rozbalování v cyklu for
 
-Cyklus `for` umíme rozepsat: opakuje se v něm nastavení proměnné (které dělá
+Cyklus `for` umíš rozepsat: opakuje se v něm nastavení proměnné (které dělá
 `for` za tebe), pak tělo cyklu, a znovu nastavení proměnné, tělo cyklu, atd.
 Pro „trpasličí“ cyklus to je:
 
@@ -155,11 +170,11 @@ for index, den in enumerate(dny, start=1):
 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:
+Řekněme že máš seznam věcí a druhý seznam, ve kterém jsou barvy těch věcí:
 
 ``` python
-veci = ['tráva', 'slunce', 'mrkev', 'řeka']
-barvy = ['zelená', 'žluté', 'oranžová', 'modrá']
+veci = ['tráva', 'slunce', 'mrkev', 'list']
+barvy = ['zelená', 'žluté', 'oranžová', 'zelený']
 ```
 
 Když na ně zavoláš `zip`, dostaneš iterátor, který (podobně jako `enumerate`
@@ -179,7 +194,7 @@ Po převedení na seznam se ale ukáže seznam odpovídajících si dvojic:
 
 ```pycon
 >>> list(zip(veci, barvy))
-[('tráva', 'zelená'), ('slunce', 'žluté'), ('mrkev', 'oranžová'), ('řeka', 'modrá')]
+[('tráva', 'zelená'), ('slunce', 'žluté'), ('mrkev', 'oranžová'), ('list', 'zelený')]
 ```
 
 Takové dvojice jsou připravené na to, že je rozbalíš v cyklu `for`:
@@ -194,9 +209,9 @@ V následujícím případě vznikne 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']
+veci = ['tráva', 'slunce', 'mrkev', 'list']
+barvy = ['zelená', 'žluté', 'oranžová', 'zelený']
+mista = ['na zemi', 'nahoře', 'na talíři', 'na stromě']
 cisla = range(4)
 
 for vec, barva, misto, cislo in zip(veci, barvy, mista, cisla):
@@ -209,8 +224,8 @@ for vec, barva, misto, cislo in zip(veci, barvy, mista, cisla):
 Jak se `zip` chová, když dostane seznamy různých délek?
 
 ```python
-veci = ['tráva', 'slunce', 'mrkev', 'řeka', 'myšlenka', 'spravedlnost']
-barvy = ['zelená', 'žluté', 'oranžová', 'modrá']
+veci = ['tráva', 'slunce', 'mrkev', 'list', 'myšlenka', 'spravedlnost']
+barvy = ['zelená', 'žluté', 'oranžová', 'zelený']
 for vec, barva in zip(veci, barvy):
     print(f"{vec} je {barva}")
 ```