Split local variables from functions; add Recursion

Author: encukou

courses/pyladies/info.yml

@@ -59,6 +59,8 @@ plan:
   slug: def-str
   materials:
   - lesson: beginners/def
+  - lesson: beginners/local-variables
+  - lesson: beginners/recursion
   - lesson: beginners/nested-traceback
   - lesson: beginners/str
   - lesson: beginners/str-index-slice

lessons/beginners/def/index.md

@@ -204,95 +204,3 @@ def nic():
 
 print(nic())
 ```
-
-
-## Lokální proměnné
-
-Gratuluji, umíš definovat vlastní funkce!
-Zbývá ještě vysvětlit jednu věc: lokální a globální proměnné.
-
-Funkce může používat proměnné „zvnějšku“:
-
-```python
-pi = 3.1415926
-
-def obsah_kruhu(polomer):
-    return pi * polomer ** 2
-
-print(obsah_kruhu(100))
-```
-
-Ale všechny argumenty a všechny proměnné, do kterých funkce přiřazuje,
-jsou *úplně nové* proměnné, které nemají nic
-společného s tím, co je „venku“ kolem funkce.
-
-Těm úplně novým proměnným se říká
-*lokální proměnné* (angl. *local variables*), protože existují
-jen místně, v rámci volání jedné jediné funkce.
-Takže tohle nebude fungovat tak, jak se zdá:
-
-```python
-x = 0
-
-def nastav_x(hodnota):
-    x = hodnota  # Přiřazení do lokální proměnné!
-
-nastav_x(40)
-print(x)
-```
-
-
-Proměnné, které nejsou lokální, jsou *globální* – ty
-existují v celém programu.
-(Jen ve funkcích, které mají náhodou
-lokální proměnnou stejného jména, „nejsou vidět“ –
-to jméno označuje lokální proměnnou.)
-
-Pojďme si to ukázat.
-Než spustíš tenhle program,
-zkus předpovědět, co bude dělat.
-Pak ho pusť, a pokud dělal něco jiného,
-zkus vysvětlit proč.
-Pozor, je tam chyták!
-
-```python
-from math import pi
-obsah = 0
-a = 30
-
-def obsah_elipsy(a, b):
-    obsah = pi * a * b  # Přiřazení do `obsah`
-    a = a + 3  # Přiřazení do `a`
-    return obsah
-
-print(obsah_elipsy(a, 20))
-print(obsah)
-print(a)
-```
-
-Zkus odpovědět na tyto otázky:
-
-* Je proměnná `pi` lokální, nebo globální?
-* Je proměnná `obsah` lokální, nebo globální?
-* Je proměnná `a` lokální, nebo globální?
-* Je proměnná `b` lokální, nebo globální?
-
-{% filter solution %}
-* `pi` je globální – nepřiřazuje se do ní ve funkci;
-  je „vidět“ v celém programu.
-* Proměnné `obsah` jsou v programu dvě – jedna globální,
-  a jedna je lokální pro funkci `obsah_elipsy`,
-  protože do ní tahle funkce přiřazuje.
-* Proměnné `a` jsou taky dvě, podobně jako `obsah`.
-  Tady byl chyták: příkaz `a = a + 3` nemá žádný smysl;
-  do `a` se sice uloží větší číslo, ale vzápětí funkce `obsah_elipsy` skončí
-  a její lokální proměnná `a` přestane existovat.
-* Proměnná `b` je jenom lokální – jako argument funkce `obsah_elipsy`.
-
-{% endfilter %}
-
-
-Jestli ti to celé připadá zmatené a složité, dá se tomu zatím vyhnout
-dodržováním jednoho pravidla:
-*nepřiřazuj ve funkcích do proměnných, které existují i vně funkce.*
-(Parametr funkce se počítá jako přiřazení.)

lessons/beginners/local-variables/index.md

@@ -0,0 +1,156 @@
+# Lokální proměnné
+
+Už umíš definovat vlastní funkce.
+Zbývá ale ještě dovysvětlit, jak v nich fungují proměnné.
+
+Funkce může používat proměnné „zvnějšku“.
+Následující program přiřadí do proměnné `pi` a všechny další funkce
+mají k `pi` přístup:
+
+```python
+pi = 3.1415926
+
+def obsah_kruhu(polomer):
+    return pi * polomer ** 2
+
+print(obsah_kruhu(100))
+```
+
+Jinak je tomu ale v případě, kdy proměnnou nastavíš *uvnitř* funkce.
+
+Všechny argumenty a všechny proměnné, do kterých funkce přiřazuje,
+jsou *úplně nové* proměnné, které nemají nic
+společného s tím, co je „venku“ kolem funkce.
+
+Těmto proměnným se říká *lokální proměnné* (angl. *local variables*),
+protože existují jen místně, v rámci volání jedné jediné funkce.
+
+Proměnné, které nejsou lokální, jsou *globální* – ty existují v celém programu.
+
+Pro příklad:
+
+```python
+def nastav_x(hodnota):
+    x = hodnota  # Přiřazení do lokální proměnné!
+
+nastav_x(40)
+print('x =', x)
+```
+
+Program skončí s chybou!
+Funkce `nastav_x` si hraje na vlastním písečku; proměnná `x` je jen
+pro ni.
+Když funkce `nastav_x` skončí, proměnná `x` přestane existovat.
+
+
+## Přiřazení
+
+To, co dělá lokální proměnnou, je *přiřazení*.
+Porovnej `nastav_x` s příkladem na `obsah_kruhu` výše: rozdíl mezi `pi` a `x`
+je v tom, že do `x` funkce přiřazuje.
+
+Co je to přiřazení? Všechno, co *nastavuje* nějakou proměnnou. Například:
+* Klasika je přiřazovat pomocí `=`, např. `a = 3`.
+* Argumenty funkce: funkce `def nastav_x(hodnota)` přiřadí do `hodnota`,
+* Cyklus `for x in ...:` přiřazuje do proměnné `x`.
+* Pro úplnost, příkazy `def x(...):`, `import x` a `from ... import x` taky
+  přiřazují do `x` – ale ve funkcích se moc nepoužívají.
+
+> [note] A další
+> K těmto materiálům se možná budeš vracet, tak pro úplnost přidám další
+> způsoby, které postupně poznáš. Není jich mnoho:
+> * Příkazy `with ... as x`, `del x`, `except ... as x` přiřazují do `x`.
+> * Přiřazují i speciální přiřazovací operátory jako `+=`, `*=`, `:=`.
+
+
+## Zakrývání jména
+
+Jak to funguje, když ve funkci přiřadíš do proměnné, která existuje i globálně?
+Pak tu máme problém.
+
+Vytvoří se *úplně nová* lokální proměnná, která má stejné jméno jako
+ta globální.
+Jméno označuje lokální proměnnou, a ta globální pak „není vidět“.
+
+Tento příklad tedy nebude fungovat tak, jak se zdá:
+
+```python
+x = 0
+
+def nastav_x(hodnota):
+    x = hodnota  # Přiřazení do lokální proměnné!
+    print('Ve funkci nastav_x: x =', x)
+
+nastav_x(40)
+print('Venku: x =', x)
+```
+
+V tomto programu existují *dvě* proměnné jménem `x`.
+Jedna je globální. Jedna je lokální pro funkci `nastav_x`.
+Jmenují se stejně, ale jsou to dvě různé proměnné.
+
+
+## Lokální nebo globální?
+
+Pojďme si to ukázat.
+Než spustíš tenhle program, zkus předpovědět, co bude dělat.
+Pak ho pusť, a pokud dělal něco jiného, zkus vysvětlit proč.
+Pozor na chytáky!
+
+```python
+from math import pi
+obsah = 0
+a = 30
+
+def obsah_elipsy(a, b):
+    obsah = pi * a * b  # Přiřazení do `obsah`
+    a = a + 3  # Přiřazení do `a`
+    return obsah
+
+print(obsah_elipsy(a, 20))
+print(obsah)
+print(a)
+```
+
+Zkus odpovědět na tyto otázky:
+
+* Je proměnná `pi` lokální, nebo globální?
+* Je proměnná `obsah` lokální, nebo globální?
+* Je proměnná `a` lokální, nebo globální?
+* Je proměnná `b` lokální, nebo globální?
+* Je proměnná `obsah_elipsy` lokální, nebo globální?
+
+{% filter solution %}
+* `pi` je globální – nepřiřazuje se do ní ve funkci;
+  je „vidět“ v celém programu.
+* Proměnné `obsah` jsou v programu dvě – jedna globální,
+  a jedna je lokální pro funkci `obsah_elipsy`,
+  protože do ní tahle funkce přiřazuje.
+* Proměnné `a` jsou taky dvě, podobně jako `obsah`.
+  Tady byl chyták: příkaz `a = a + 3` nemá žádný smysl;
+  do `a` se sice uloží větší číslo, ale vzápětí funkce `obsah_elipsy` skončí
+  a její lokální proměnná `a` přestane existovat.
+* Proměnná `b` je jenom lokální – jako argument funkce `obsah_elipsy`.
+* Proměnná `obsah_elipsy` je globální (a je v ní funkce).
+
+> [note] A pro úplnost
+>
+> * Klíčová slova `from`, `import`, `def`, `return` nejsou proměnné.
+> * Jméno modulu `math` není proměnná.
+> * Proměnná `print` se dá považovat za globální.
+>   (Ve skutečnosti existuje zvláštní kategorie *zabudovaných* (angl. *builtin*)
+>   proměnných.)
+
+{% endfilter %}
+
+
+## Rada na závěr
+
+Pravidla pro lokální proměnné jsou pro začátečníky jednou z nejzvláštnějších
+věcí v Pythonu.
+Jsou ale užitečná – umožňují některé užitečné techniky, např. rekurzi.
+
+Jestli ti to celé připadá složité, dá se tomu zatím vyhnout dodržováním jednoho
+pravidla:
+*nepřiřazuj ve funkcích do proměnných, které existují i vně funkce.*
+(Parametr funkce se počítá jako přiřazení.)

lessons/beginners/local-variables/info.yml

@@ -0,0 +1,4 @@
+title: Lokální proměnné
+style: md
+attribution: Pro PyLadies Brno napsal Petr Viktorin, 2014-2017.
+license: cc-by-sa-40