If, for, while, iterators

cs-cz/python3.html.markdown

@@ -149,6 +149,8 @@ print("Jsem 3. Python 3.")
 # Konvence je používat male_pismo_s_podtrzitky
 nazev_promenne = 5
 nazev_promenne  # => 5
+# Názvy proměnných mohou obsahovat i UTF8 znaky
+název_proměnné = 5
 
 # Přístup k předtím nepoužité proměnné vyvolá výjimku
 # Odchytávání vyjímek - viz další kapitola
@@ -185,9 +187,9 @@ sez[2:]  # => [4, 3]
 # Odříznutí konce
 sez[:3]  # => [1, 2, 4]
 # Vybrání každého druhého prvku
-sez[::2]   # =>[1, 4]
+sez[::2]  # =>[1, 4]
 # Vrácení seznamu v opačném pořadí
-sez[::-1]   # => [3, 4, 2, 1]
+sez[::-1]  # => [3, 4, 2, 1]
 # Lze použít jakoukoliv kombinaci parametrů pro vytvoření složitějšího řezu
 # sez[zacatek:konec:krok]
 
@@ -202,10 +204,10 @@ sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
 sez.extend(jiny_seznam)   # sez je nyní [1, 2, 3, 4, 5, 6]
 
 # Kontrola, jestli prvek v seznamu existuje, se provádí pomocí in
-1 in sez   # => True
+1 in sez  # => True
 
 # Délku seznamu lze zjistit pomocí len
-len(sez)   # => 6
+len(sez)  # => 6
 
 
 # N-tice je jako seznam, ale je neměnná
@@ -220,11 +222,11 @@ ntice[:2]          # => (1, 2)
 2 in ntice         # => True
 
 # N-tice (nebo seznamy) lze rozbalit do proměnných jedním přiřazením
-a, b, c = (1, 2, 3)     # a je nyní 1, b je nyní 2 a c je nyní 3
+a, b, c = (1, 2, 3)  # a je nyní 1, b je nyní 2 a c je nyní 3
 # N-tice jsou vytvářeny automaticky, když vynecháte závorky
 d, e, f = 4, 5, 6
 # Prohození proměnných je tak velmi snadné
-e, d = d, e     # d je nyní 5, e je nyní 4
+e, d = d, e  # d je nyní 5, e je nyní 4
 
 
 # Slovníky ukládají klíče a hodnoty
@@ -233,7 +235,7 @@ prazdny_slovnik = {}
 slovnik = {"jedna": 1, "dva": 2, "tři": 3}
 
 # Přistupovat k hodnotám lze pomocí []
-slovnik["jedna"] # => 1
+slovnik["jedna"]  # => 1
 
 # Všechny klíče dostaneme pomocí keys() jako iterátor. Nyní ještě potřebujeme
 # obalit volání v list(), abychom dostali seznam. To rozebereme později.
@@ -275,58 +277,57 @@ del slovnik["jedna"]  # odebere klíč "jedna" ze slovnik
 # Množiny ukládají ... překvapivě množiny
 prazdna_mnozina = set()
 # Také je lze rovnou naplnit. A ano, budou se vám plést se slovníky. Bohužel.
-mnozina = {1, 1, 2, 2, 3, 4}   # mnozina je nyní {1, 2, 3, 4}
+mnozina = {1, 1, 2, 2, 3, 4}  # mnozina je nyní {1, 2, 3, 4}
 
 # Přidání položky do množiny
-mnozina.add(5)   # mnozina je nyní {1, 2, 3, 4, 5}
+mnozina.add(5)  # mnozina je nyní {1, 2, 3, 4, 5}
 
 # Průnik lze udělat pomocí operátoru &
 jina_mnozina = {3, 4, 5, 6}
-mnozina & jina_mnozina   # => {3, 4, 5}
+mnozina & jina_mnozina  # => {3, 4, 5}
 
 # Sjednocení pomocí operátoru |
-mnozina | jina_mnozina   # => {1, 2, 3, 4, 5, 6}
+mnozina | jina_mnozina  # => {1, 2, 3, 4, 5, 6}
 
 # Rozdíl pomocí operátoru -
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
 
 # Operátorem in se lze dotázat na přítomnost prvku v množině
-2 in mnozina   # => True
+2 in mnozina  # => True
-10 in mnozina   # => False
+9 in mnozina  # => False
 
 
 ####################################################
-## 3. Řízení toku a iterace
+## 3. Řízení toku programu, cykly
 ####################################################
 
-# Let's just make a variable
+# Vytvořme si proměnnou
-some_var = 5
+promenna = 5
 
-# Here is an if statement. Indentation is significant in python!
+# Takto vypadá podmínka. Na odsazení v Pythonu záleží!
-# prints "some_var is smaller than 10"
+# Vypíše "proměnná je menší než 10".
-if some_var > 10:
+if promenna > 10:
-    print("some_var is totally bigger than 10.")
+    print("proměnná je velká jak Rusko")
-elif some_var < 10:    # This elif clause is optional.
+elif promenna < 10:  # Část elif je nepovinná
-    print("some_var is smaller than 10.")
+    print("proměnná je menší než 10")
-else:                  # This is optional too.
+else:                # Část else je také nepovinná
-    print("some_var is indeed 10.")
+    print("proměnná je právě 10")
 
 
 """
-For loops iterate over lists
+Smyčka for umí iterovat (nejen) přes seznamy
-prints:
+vypíše:
-    dog is a mammal
+    pes je savec
-    cat is a mammal
+    kočka je savec
-    mouse is a mammal
+    myš je savec
 """
-for animal in ["dog", "cat", "mouse"]:
+for zvire in ["pes", "kočka", "myš"]:
-    # You can use format() to interpolate formatted strings
+    # Můžete použít formát pro složení řetězce
-    print("{} is a mammal".format(animal))
+    print("{} je savec".format(zvire))
 
 """
-"range(number)" returns an iterable of numbers
+range(cislo) vrací itarátor čísel od 0 do cislo
-from zero to the given number
+vypíše:
-prints:
     0
     1
     2
@@ -336,9 +337,8 @@ for i in range(4):
     print(i)
 
 """
-"range(lower, upper)" returns an iterable of numbers
+range(spodni_limit, horni_limit) vrací itarátor čísel mezi limity
-from the lower number to the upper number
+vypíše:
-prints:
     4
     5
     6
@@ -348,8 +348,8 @@ for i in range(4, 8):
     print(i)
 
 """
-While loops go until a condition is no longer met.
+Smyčka while se opakuje, dokud je podmínka splněna.
-prints:
+vypíše:
     0
     1
     2
@@ -358,61 +358,63 @@ prints:
 x = 0
 while x < 4:
     print(x)
-    x += 1  # Shorthand for x = x + 1
+    x += 1  # Zkrácený zápis x = x + 1. Pozor, žádné x++ neexisuje.
 
-# Handle exceptions with a try/except block
+
+# Výjimky lze ošetřit pomocí bloku try/except(/else/finally)
 try:
-    # Use "raise" to raise an error
+    # Pro vyhození výjimky použijte raise
-    raise IndexError("This is an index error")
+    raise IndexError("Přistoupil jste k neexistujícímu prvku v seznamu.")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    print("Nastala chyba: {}".format(e))
-except (TypeError, NameError):
+    # Vypíše: Nastala chyba: Přistoupil jste k neexistujícímu prvku v seznamu.
-    pass    # Multiple exceptions can be handled together, if required.
+except (TypeError, NameError):  # Více výjimek lze zachytit najednou
-else:   # Optional clause to the try/except block. Must follow all except blocks
+    pass  # Pass znamená nedělej nic - nepříliš vhodný způsob ošetření chyb
-    print("All good!")   # Runs only if the code in try raises no exceptions
+else:  # Volitelný blok else musí být až za bloky except
-finally:  #   Execute under all circumstances
+    print("OK!")  # Vypíše OK! v případě, že nenastala žádná výjimka
-    print("We can clean up resources here")
+finally:  # Blok finally se spustí nakonec za všech okolností
+    print("Uvolníme zdroje, uzavřeme soubory...")
 
-# Instead of try/finally to cleanup resources you can use a with statement
+# Místo try/finally lze použít with pro automatické uvolnění zdrojů
-with open("myfile.txt") as f:
+with open("soubor.txt") as soubor:
-    for line in f:
+    for radka in soubor:
-        print(line)
+        print(radka)
 
-# Python offers a fundamental abstraction called the Iterable.
+# Python běžně používá iterovatelné objekty, což je prakticky cokoliv,
-# An iterable is an object that can be treated as a sequence.
+# co lze považovat za sekvenci. Například to, co vrací metoda range(),
-# The object returned the range function, is an iterable.
+# nebo otevřený soubor, jsou iterovatelné objekty.
 
-slovnik = {"one": 1, "two": 2, "three": 3}
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
-our_iterable = slovnik.keys()
+iterovatelny_objekt = slovnik.keys()
-print(our_iterable)  # => range(1,10). This is an object that implements our Iterable interface
+print(iterovatelny_objekt)  # => dict_keys(["jedna", "dva", "tři"]). Toto je iterovatelný objekt.
 
-# We can loop over it.
+# Můžeme použít cyklus for na jeho projití
-for i in our_iterable:
+for klic in iterovatelny_objekt:
-    print(i)    # Prints one, two, three
+    print(klic)    # vypíše postupně: jedna, dva, tři
 
-# However we cannot address elements by index.
+# Ale nelze přistupovat k prvkům pod jejich indexem
-our_iterable[1]  # Raises a TypeError
+iterovatelny_objekt[1]  # Vyhodí TypeError
 
-# An iterable is an object that knows how to create an iterator.
+# Všechny položky iterovatelného objektu lze získat jako seznam pomocí list()
-our_iterator = iter(our_iterable)
+list(slovnik.keys())  # => ["jedna", "dva", "tři"]
 
-# Our iterator is an object that can remember the state as we traverse through it.
+# Z iterovatelného objektu lze vytvořit iterátor
-# We get the next object with "next()".
+iterator = iter(iterovatelny_objekt)
-next(our_iterator)  # => "one"
 
-# It maintains state as we iterate.
+# Iterátor je objekt, který si pamatuje stav v rámci svého iterovatelného objektu
-next(our_iterator)  # => "two"
+# Další hodnotu dostaneme voláním next()
-next(our_iterator)  # => "three"
+next(iterator)  # => "jedna"
 
-# After the iterator has returned all of its data, it gives you a StopIterator Exception
+# Iterátor si udržuje svůj stav v mezi jednotlivými voláními next()
-next(our_iterator)  #  Raises StopIteration
+next(iterator)  # => "dva"
+next(iterator)  # => "tři"
 
-# You can grab all the elements of an iterator by calling list() on it.
+# Jakmile interátor vrátí všechna svá data, vyhodí výjimku StopIteration
-list(slovnik.keys())  # => Returns ["one", "two", "three"]
+next(iterator)  # Vyhodí StopIteration
 
 
 ####################################################
-## 4. Functions
+## 4. Funkce
 ####################################################
 
 # Use "def" to create new functions