From b57b771dd3aba673c73cddf02b94c454f17b6b07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robin=20Pokorn=C3=BD?= <me@robinpokorny.com>
Date: Thu, 12 Jan 2017 16:00:48 +0100
Subject: [elm/cs] Fixes #2584 for Czech (#2629)

---
 cs-cz/elm.html.markdown | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
index babd46a2..f19f9e8b 100644
--- a/cs-cz/elm.html.markdown
+++ b/cs-cz/elm.html.markdown
@@ -54,19 +54,19 @@ not False -- True
 ["příliš", "žluťoučký", "kůň", "úpěl"]
 [1, 2, 3, 4, 5]
 -- Druhý příklad lze zapsat také pomocí dvou teček.
-[1..5]
+List.range 1 5
 
 -- Spojovat seznamy lze stejně jako řetězce.
-[1..5] ++ [6..10] == [1..10] -- True
+List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True
 
 -- K přidání položky do seznamu použijte funkci "cons".
-0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
+0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5]
 
 -- Funkce "head" pro získání první položky seznamu i funkce "tail" pro získání následujích položek
 -- vrací typ Maybe. Místo zjišťování, jestli nějaká položka není null,
 -- se s chybějcími hodnotami vypořádáme explicitně.
-List.head [1..5] -- Just 1
-List.tail [1..5] -- Just [2, 3, 4, 5]
+List.head (List.range 1 5) -- Just 1
+List.tail (List.range 1 5) -- Just [2, 3, 4, 5]
 List.head [] -- Nothing
 -- List.nazevFunkce odkazuje na funkci, která žije v modulu List.
 
@@ -82,7 +82,7 @@ snd ("elm", 42) -- 42
 -- Je to jediná hodnota svého typu, který se také nazývá "Unit".
 ()
 
--- Záznamy jsou podobné n-ticím, ale prvky jsou pojmenovány. Na pořadí nezáleží. 
+-- Záznamy jsou podobné n-ticím, ale prvky jsou pojmenovány. Na pořadí nezáleží.
 -- Povšimněte si, že hodnoty vlastností se přiřazují rovnítky, ne dvojtečkami.
 { x = 3, y = 7 }
 
@@ -153,10 +153,10 @@ odpoved =
   42
 
 -- Předejte funkci jako parametr jiným funkcím.
-List.map zdvoj [1..4] -- [2, 4, 6, 8]
+List.map zdvoj (List.range 1 4) -- [2, 4, 6, 8]
 
 -- Nebo použijte anonymní funkci.
-List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
+List.map (\a -> a * 2) (List.range 1 4) -- [2, 4, 6, 8]
 
 -- V definici funkce lze zapsat vzor, může-li nastat pouze jeden případ.
 -- Tato funkce přijímá jednu dvojici místo dvou parametrů.
@@ -182,7 +182,7 @@ fib n =
   else
     fib (n - 1) + fib (n - 2)
 
-List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+List.map fib (List.range 0 8) -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
 
 -- Jiná rekurzivní funkce (v praxi použijte List.length).
 delkaSeznamu seznam =
@@ -339,11 +339,11 @@ $ elm repl
 
 -- Balíčky jsou určeny uživatelským jménem na GitHubu a názvem repozitáře.
 -- Nainstalujte nový balíček a uložte jej v souboru elm-package.json.
-$ elm package install evancz/elm-html
+$ elm package install evancz/elm-lang/html
 
 -- Porovnejte změny mezi verzemi jednoho balíčku.
-$ elm package diff evancz/elm-html 3.0.0 4.0.2
--- Správce balíčků v Elmu vyžaduje sémantické verzování, 
+$ elm package diff elm-lang/html 1.1.0 2.0.0
+-- Správce balíčků v Elmu vyžaduje sémantické verzování,
 -- takže minor verze nikdy nerozbije váš build.
 ```
 
-- 
cgit v1.2.3


From c52ae61127b9b50f39e45876c672ed73ce4e2125 Mon Sep 17 00:00:00 2001
From: andys8 <andys8@users.noreply.github.com>
Date: Sat, 23 Dec 2017 11:57:45 +0100
Subject: [elm] Update code to access tuples

---
 cs-cz/elm.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
index f19f9e8b..42ec89e5 100644
--- a/cs-cz/elm.html.markdown
+++ b/cs-cz/elm.html.markdown
@@ -75,8 +75,8 @@ List.head [] -- Nothing
 
 -- K získání hodnot z dvojice použijte funkce first a second.
 -- (Toto je pouze zkratka. Brzy si ukážeme, jak na to "správně".)
-fst ("elm", 42) -- "elm"
-snd ("elm", 42) -- 42
+Tuple.first ("elm", 42) -- "elm"
+Tuple.second ("elm", 42) -- 42
 
 -- Prázná n-tice, neboli "unit", se občas používá jako zástupný symbol.
 -- Je to jediná hodnota svého typu, který se také nazývá "Unit".
-- 
cgit v1.2.3


From f5a53518ee16bf9f2c7e268c3407303f9fe033de Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Wed, 15 Aug 2018 17:34:52 +0530
Subject: Fix build error in 'build/docs/cs-cz/markdown/index.html'

---
 cs-cz/markdown.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 568e4343..35becf94 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -13,7 +13,7 @@ Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce či
 a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
 dalších formátů)
 
-```markdown
+```md
 <!-- Markdown je nadstavba nad HTML, takže jakýkoliv kód HTML je validní
 Markdown, to znamená, že můžeme používat HTML elementy, třeba jako komentář, a
 nebudou ovlivněny parserem Markdownu. Avšak, pokud vytvoříte HTML element v
-- 
cgit v1.2.3


From e0efb66f069b6ac4fe3632d9036d057ab1ff424a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kuba?= <tomas.kuba@simplity.eu>
Date: Sun, 14 Oct 2018 23:31:33 +0200
Subject: improve wording, fix typos, add missing text from english original

---
 cs-cz/javascript.html.markdown | 360 +++++++++++++++++++++++------------------
 1 file changed, 207 insertions(+), 153 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index cbf7687e..8d4ac278 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -9,32 +9,27 @@ lang: cs-cz
 filename: javascript-cz.js
 ---
 
-JavaScript byl vytvořen Brendan Eichem v roce 1995 pro Netscape. Byl původně
-zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk Javy,
-která byla zamýšlena pro více komplexní webové aplikace, ale jeho úzké propojení
-s webovými stránkami a vestavěná podpora v prohlížečích způsobila, že se stala
-více běžná ve webovém frontendu než Java.
+JavaScript byl vytvořen Brendanem Eichem v roce 1995 pro Netscape. Původně byl
+zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk
+Javy, která byla zamýšlena pro komplexnější webové aplikace. Úzké propojení
+JavaScriptu s webovými stránkami a vestavěná podpora v prohlížečích způsobila,
+že se stal ve webovém frontendu běžnějším než Java.
 
-
-JavaScript není omezen pouze na webové prohlížeče, např. projekt Node.js,
+JavaScript není omezen pouze na webové prohlížeče. Např. projekt Node.js,
 který zprostředkovává samostatně běžící prostředí V8 JavaScriptového enginu z
-Google Chrome se stává více a více oblíbený pro serverovou část webových aplikací.
-
-Zpětná vazba je velmi ceněná. Autora článku můžete kontaktovat (anglicky) na
-[@adambrenecki](https://twitter.com/adambrenecki), nebo
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au), nebo mě, jakožto překladatele,
-na [martinek@ludis.me](mailto:martinek@ludis.me).
+Google Chrome se stává stále oblíbenější i pro serverovou část webových 
+aplikací.
 
 ```js
-// Komentáře jsou jako v zayku C. Jednořádkové komentáře začínájí dvojitým lomítkem,
+// Jednořádkové komentáře začínájí dvojitým lomítkem,
 /* a víceřádkové komentáře začínají lomítkem s hvězdičkou
    a končí hvězdičkou s lomítkem */
 
-// Vyrazu můžou být spuštěny pomocí ;
+// Příkazy mohou být ukončeny středníkem ;
 delejNeco();
 
-// ... ale nemusí, středníky jsou automaticky vloženy kdekoliv,
-// kde končí řádka, kromě pár speciálních případů
+// ... ale nemusí, protože středníky jsou automaticky vloženy kdekoliv,
+// kde končí řádka, kromě pár speciálních případů.
 delejNeco()
 
 // Protože tyto případy můžou způsobit neočekávané výsledky, budeme
@@ -44,12 +39,12 @@ delejNeco()
 // 1. Čísla, řetězce a operátory
 
 // JavaScript má jeden číselný typ (čímž je 64-bitový IEEE 754 double).
-// Double má 52-bit přesnost, což je dostatečně přesné pro ukládání celých čísel
-// do 9✕10¹⁵.
+// Double má 52-bitovou přesnost, což je dostatečně přesné pro ukládání celých
+// čísel až do 9✕10¹⁵.
 3; // = 3
 1.5; // = 1.5
 
-// Základní matematické operace fungují, jak byste očekávali
+// Základní matematické operace fungují tak, jak byste očekávali
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
@@ -65,30 +60,30 @@ delejNeco()
 18.5 % 7; // = 4.5
 
 // Bitové operace také fungují; když provádíte bitové operace, desetinné číslo  
-// (float) se převede na celé číslo (int) se znaménkem *do* 32 bitů
+// (float) se převede na celé číslo (int) se znaménkem *až do* 32 bitů
 1 << 2; // = 4
 
 // Přednost se vynucuje závorkami.
 (1 + 3) * 2; // = 8
 
-// Existují 3 hodnoty mimo obor reálných čísel
+// Existují 3 hodnoty mimo obor reálných čísel:
 Infinity; // + nekonečno; výsledek např. 1/0
 -Infinity; // - nekonečno; výsledek např. -1/0
 NaN; // výsledek např. 0/0, znamená, že výsledek není číslo ('Not a Number')
 
-// Také existují hodnoty typu bool
+// Také existují hodnoty typu boolean.
 true; // pravda
 false; // nepravda
 
-// Řetězce znaků jsou obaleny  ' nebo ".
+// Řetězce znaků jsou obaleny ' nebo ".
 'abc';
-"Ahoj světe!";
+"Hello, world";
 
-// Negace se tvoří pomocí !
+// Negace se tvoří pomocí znaku !
 !true; // = false
 !false; // = true
 
-// Rovnost se porovnává ===
+// Rovnost se porovnává pomocí ===
 1 === 1; // = true
 2 === 1; // = false
 
@@ -103,16 +98,16 @@ false; // nepravda
 2 >= 2; // = true
 
 // Řetězce znaků se spojují pomocí +
-"Ahoj " + "světe!"; // = "Ahoj světe!"
+"Hello " + "world!"; // = "Hello world!"
 
-// ... což funguje nejenom s řetězci
+// ... což funguje nejen s řetězci
 "1, 2, " + 3; // = "1, 2, 3"
-"Ahoj " + ["světe", "!"] // = "Ahoj světe,!"
+"Hello " + ["world", "!"]; // = "Hello world,!"
 
 // a porovnávají se pomocí < nebo >
 "a" < "b"; // = true
 
-// Rovnost s převodem typů se dělá pomocí == ...
+// Rovnost s převodem typů se dělá za pomoci dvojitého rovnítka...
 "5" == 5; // = true
 null == undefined; // = true
 
@@ -124,24 +119,24 @@ null === undefined; // = false
 13 + !0; // 14
 "13" + !0; // '13true'
 
-// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí charAt`
+// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí `charAt`
 "Toto je řetězec".charAt(0);  // = 'T'
 
-// ...nebo použít `substring` k získání podřetězce
-"Ahoj světe".substring(0, 4); // = "Ahoj"
+// ...nebo použít `substring` k získání podřetězce.
+"Hello world".substring(0, 5); // = "Hello"
 
-// `length` znamená délka a je to vlastnost, takže nepoužívejte ()
-"Ahoj".length; // = 4
+// `length` znamená délka a je to vlastnost, takže nepoužívejte ().
+"Hello".length; // = 5
 
 // Existují také typy `null` a `undefined`.
-null;      // značí, že žádnou hodnotu
-undefined; // značí, že hodnota nebyla definovaná (ikdyž
+null;      // obvykle označuje něco záměrně bez hodnoty
+undefined; // obvykle označuje, že hodnota není momentálně definovaná (ačkoli
            // `undefined` je hodnota sama o sobě)
 
 // false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
-// vrací pravdu (true)..
-// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, ikdyž 0 == "0"
-// vrací pravdu
+// vrací pravdu (true).
+// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, i když 0 == "0"
+// vrací pravdu.
 
 ///////////////////////////////////
 // 2. Proměnné, pole a objekty
@@ -151,11 +146,11 @@ undefined; // značí, že hodnota nebyla definovaná (ikdyž
 // znak `=`.
 var promenna = 5;
 
-// když vynecháte slůvko 'var' nedostanete chybovou hlášku...
+// Když vynecháte slůvko 'var', nedostanete chybovou hlášku...
 jinaPromenna = 10;
 
-// ...ale vaše proměnná bude vytvořena globálně, bude vytvořena  v globálním
-// oblasti působnosti, ne jenom v lokálním tam, kde jste ji vytvořili
+// ...ale vaše proměnná bude vytvořena globálně. Bude vytvořena v globální
+// oblasti působnosti, tedy nejenom v lokální tam, kde jste ji vytvořili.
 
 // Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
 var dalsiPromenna; // = undefined
@@ -163,56 +158,72 @@ var dalsiPromenna; // = undefined
 // Pokud chcete vytvořit několik proměnných najednou, můžete je oddělit čárkou
 var someFourthVar = 2, someFifthVar = 4;
 
-// Existuje kratší forma pro matematické operace na proměnné
+// Existuje kratší forma pro matematické operace nad proměnnými
 promenna += 5; // se provede stejně jako promenna = promenna + 5;
-// promenna je ted 10
+// promenna je teď 10
 promenna *= 10; // teď je promenna rovna 100
 
 // a tohle je způsob, jak přičítat a odečítat 1
 promenna++; // teď je promenna 101
 promenna--; // zpět na 100
 
-// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu
-var mojePole = ["Ahoj", 45, true];
+// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu.
+var myArray = ["Ahoj", 45, true];
 
 // Jednotlivé hodnoty jsou přístupné přes hranaté závorky.
 // Členové pole se začínají počítat na nule.
 myArray[1]; // = 45
 
-// Pole je proměnlivé délky a členové se můžou měnit
-myArray.push("Světe");
+// Pole je proměnlivé délky a členové se můžou měnit.
+myArray.push("World");
 myArray.length; // = 4
 
 // Přidání/změna na specifickém indexu
 myArray[3] = "Hello";
 
-// JavaScriptové objekty jsou stejné jako asociativní pole v jinných programovacích
+// Přidání nebo odebrání člena ze začátku nebo konce pole
+myArray.unshift(3); // Přidej jako první člen
+someVar = myArray.shift(); // Odstraň prvního člena a vrať jeho hodnotu
+myArray.push(3); // Přidej jako poslední člen
+someVar = myArray.pop(); // Odstraň posledního člena a vrať jeho hodnotu
+
+// Spoj všechny členy pole středníkem
+var myArray0 = [32,false,"js",12,56,90];
+myArray0.join(";") // = "32;false;js;12;56;90"
+
+// Vrať část pole s elementy od pozice 1 (včetně) do pozice 4 (nepočítaje)
+myArray0.slice(1,4); // = [false,"js",12]
+
+// Odstraň čtyři členy od pozice 2, vlož následující
+// "hi","wr" and "ld"; vrať odstraněné členy
+myArray0.splice(2,4,"hi","wr","ld"); // = ["js",12,56,90]
+// myArray0 === [32,false,"hi","wr","ld"]
+
+// JavaScriptové objekty jsou stejné jako asociativní pole v jiných programovacích
 // jazycích: je to neuspořádaná množina páru hodnot - klíč:hodnota.
-var mujObjekt = {klic1: "Ahoj", klic2: "světe"};
+var mujObjekt = {klic1: "Hello", klic2: "World"};
 
-// Klíče jsou řetězce, ale nejsou povinné uvozovky, pokud jsou validní
-// JavaScriptové identifikátory. Hodnoty můžou být jakéhokoliv typu-
+// Klíče jsou řetězce, ale nemusí mít povinné uvozovky, pokud jsou validními
+// JavaScriptovými identifikátory. Hodnoty můžou být jakéhokoliv typu.
 var mujObjekt = {klic: "mojeHodnota", "muj jiny klic": 4};
 
 // K hodnotám můžeme přistupovat opět pomocí hranatých závorek
-myObj["muj jiny klic"]; // = 4
+mujObjekt["muj jiny klic"]; // = 4
 
 // ... nebo pokud je klíč platným identifikátorem, můžeme přistupovat k
 // hodnotám i přes tečku
 mujObjekt.klic; // = "mojeHodnota"
 
 // Objekty jsou měnitelné, můžeme upravit hodnoty, nebo přidat nové klíče.
-myObj.mujDalsiKlic = true;
+mujObjekt.mujDalsiKlic = true;
 
-// Pokud se snažíte přistoupit ke klíči, který není nastaven, dostanete undefined
-myObj.dalsiKlic; // = undefined
+// Pokud se snažíte přistoupit ke klíči, který neexistuje, dostanete undefined.
+mujObjekt.dalsiKlic; // = undefined
 
 ///////////////////////////////////
 // 3. Řízení toku programu
 
-// Syntaxe pro tuto sekci je prakticky stejná jako pro Javu
-
-// `if` (když) funguje, jak byste čekali.
+// Funkce `if` funguje, jak byste čekali.
 var pocet = 1;
 if (pocet == 3){
     // provede, když se pocet rovná 3
@@ -222,42 +233,49 @@ if (pocet == 3){
     // provede, když je pocet cokoliv jinného
 }
 
-// Stejně tak cyklus while
+// Stejně tak cyklus `while`.
 while (true){
-    // nekonečný cyklus
+    // nekonečný cyklus!
 }
 
-// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou
+// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou.
 var vstup;
 do {
     vstup = nactiVstup();
 } while (!jeValidni(vstup))
 
-// Cyklus for je stejný jako v Javě nebo jazyku C
+// Cyklus `for` je stejný jako v Javě nebo jazyku C:
 // inicializace; podmínka pro pokračování; iterace.
-for (var i = 0; i < 3; i++){
-    // provede třikrát
+for (var i = 0; i < 5; i++){
+    // provede se pětkrát
 }
 
-// Cyklus For-in iteruje přes každo vlastnost prototypu
-var popis = "";
-var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
-for (var x in osoba){
-    popis += osoba[x] + " ";
+// Opuštění cyklu s návěštím je podobné jako v Javě
+outer:
+for (var i = 0; i < 10; i++) {
+    for (var j = 0; j < 10; j++) {
+        if (i == 5 && j ==5) {
+            break outer;
+            // opustí vnější (outer) cyklus místo pouze vnitřního (inner) cyklu
+        }
+    }
 }
 
-//Když chcete iterovat přes vlastnosti, které jsou přímo na objektu a nejsou
-//zděněné z prototypů, kontrolujte vlastnosti přes hasOwnProperty()
+// Cyklus For-in iteruje přes každou vlastnost prototypu
 var popis = "";
-var osoba = {prijmeni:"Jan", jmeno:"Novák", vek:18};
+var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
 for (var x in osoba){
-    if (osoba.hasOwnProperty(x)){
-        popis += osoba[x] + " ";
-    }
-}
+    popis += osoba[x] + " ";
+} // popis = 'Paul Ken 18 '
 
-// for-in by neměl být použit pro pole, pokud záleží na pořadí indexů.
-// Neexistuje jistota, že for-in je vrátí ve správném pořadí.
+// Příkaz for/of umožňuje iterovat iterovatelné objekty (včetně vestavěných typů
+// String, Array, například polím podobným argumentům nebo NodeList objektům,
+// TypeArray, Map a Set, či uživatelsky definované iterovatelné objekty).
+var myPets = "";
+var pets = ["cat", "dog", "hamster", "hedgehog"];
+for (var pet of pets){
+    myPets += pet + " ";
+} // myPets = 'cat dog hamster hedgehog '
 
 // && je logické a, || je logické nebo
 if (dum.velikost == "velký" && dum.barva == "modrá"){
@@ -270,7 +288,6 @@ if (barva == "červená" || barva == "modrá"){
 // && a || jsou praktické i pro nastavení základních hodnot
 var jmeno = nejakeJmeno || "default";
 
-
 // `switch` zkoumá přesnou rovnost (===)
 // Používejte 'break;' po každé možnosti, jinak se provede i možnost za ní.
 znamka = 'B';
@@ -289,8 +306,9 @@ switch (znamka) {
     break;
 }
 
+
 ////////////////////////////////////////////////////////
-// 4. Funckce, Oblast platnosti (scope) a Vnitřní funkce
+// 4. Funkce, Oblast platnosti (scope) a Vnitřní funkce
 
 // JavaScriptové funkce jsou definovány slůvkem `function`.
 function funkce(text){
@@ -302,12 +320,9 @@ funkce("něco"); // = "NĚCO"
 // jako slůvko return, jinak se vrátí 'undefined', kvůli automatickému vkládání
 // středníků. Platí to zejména pro Allmanův styl zápisu.
 
-function funkce()
-{
+function funkce(){
     return // <- zde je automaticky vložen středník
-    {
-        tohleJe: "vlastnost objektu"
-    }
+    { tohleJe: "vlastnost objektu"};
 }
 funkce(); // = undefined
 
@@ -327,9 +342,9 @@ function myFunction(){
 setInterval(myFunction, 5000);
 
 // Objekty funkcí nemusíme ani deklarovat pomocí jména, můžeme je napsat jako
-// ananymní funkci přímo vloženou jako argument
+// anonymní funkci přímo vloženou jako argument
 setTimeout(function(){
-  // tento kód bude zavolán za 5 vteřin    
+  // tento kód bude zavolán za 5 vteřin
 }, 5000);
 
 // JavaScript má oblast platnosti funkce, funkce ho mají, ale jiné bloky ne
@@ -339,21 +354,21 @@ if (true){
 i; // = 5 - ne undefined, jak byste očekávali v jazyku, kde mají bloky svůj
 // rámec působnosti
 
-// Toto je běžný model,který chrání před únikem dočasných proměnných do
+// Toto je běžný model, který chrání před únikem dočasných proměnných do
 //globální oblasti
 (function(){
     var docasna = 5;
-    // Můžeme přistupovat k globálního oblasti přes přiřazování globalním
+    // Můžeme přistupovat ke globálního oblasti přes přiřazování globalním
     // objektům. Ve webovém prohlížeči je to vždy 'window`. Globální objekt
-    // může mít v jiných prostředích jako Node.js jinné jméno.
+    // může mít v jiných prostředích jako Node.js jiné jméno.
     window.trvala = 10;
 })();
 docasna; // způsobí ReferenceError
 trvala; // = 10
 
-// Jedna z nejvice mocných vlastnosti JavaScriptu je vnitřní funkce. Je to funkce
-// definovaná v jinné funkci, vnitřní funkce má přístup ke všem proměnným ve
-// vnější funkci, dokonce i poté, co funkce skončí
+// Jedna z nejmocnějších vlastností JavaScriptu je vnitřní funkce. Je to funkce
+// definovaná v jiné funkci. Vnitřní funkce má přístup ke všem proměnným ve
+// vnější funkci, dokonce i poté, co vnější funkce skončí.
 function ahojPoPetiVterinach(jmeno){
     var prompt = "Ahoj, " + jmeno + "!";
     // Vnitřní funkce je dána do lokální oblasti platnosti, jako kdyby byla
@@ -362,9 +377,9 @@ function ahojPoPetiVterinach(jmeno){
         alert(prompt);
     }
     setTimeout(vnitrni, 5000);
-    // setTimeout je asynchronní, takže funkce ahojPoPetiVterinach se ukončí
-    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak protože
-    // vnitrni je definována přes ahojPoPetiVterinach, má pořád přístup k
+    // setTimeout je asynchronní, takže se funkce ahojPoPetiVterinach ukončí
+    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak
+    // vnitrni je definována přes ahojPoPetiVterinach a má pořád přístup k
     // proměnné prompt, když je konečně zavolána.
 }
 ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
@@ -372,23 +387,23 @@ ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
 ///////////////////////////////////////////////////
 // 5. Více o objektech, konstuktorech a prototypech
 
-// Objekty můžou obsahovat funkce
+// Objekty můžou obsahovat funkce.
 var mujObjekt = {
     mojeFunkce: function(){
-        return "Ahoj světe!";
+        return "Hello world!";
     }
 };
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Když jsou funkce z objektu zavolány, můžou přistupovat k objektu přes slůvko
 // 'this''
 var mujObjekt = {
-    text: "Ahoj světe!",
+    text: "Hello world!",
     mojeFunkce: function(){
         return this.text;
     }
 };
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Slůvko this je nastaveno k tomu, kde je voláno, ne k tomu, kde je definováno
 // Takže naše funkce nebude fungovat, když nebude v kontextu objektu.
@@ -396,23 +411,23 @@ var mojeFunkce = mujObjekt.mojeFunkce;
 mojeFunkce(); // = undefined
 
 // Opačně, funkce může být přiřazena objektu a může přistupovat k objektu přes
-// this, i když nebyla přímo v definici-
+// this, i když nebyla přímo v definici.
 var mojeDalsiFunkce = function(){
     return this.text.toUpperCase();
 }
 mujObjekt.mojeDalsiFunkce = mojeDalsiFunkce;
-mujObjekt.mojeDalsiFunkce(); // = "AHOJ SVĚTE!"
+mujObjekt.mojeDalsiFunkce(); // = "HELLO WORLD!"
 
 // Můžeme také specifikovat, v jakém kontextu má být funkce volána pomocí
 // `call` nebo `apply`.
 
 var dalsiFunkce = function(s){
     return this.text + s;
-}
-dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Ahoj světe! A ahoj měsíci!"
+};
+dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Hello world! A ahoj měsíci!"
 
-// Funkce `apply`je velmi podobná, akorát bere jako druhý argument pole argumentů
-dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Ahoj světe! A ahoj slunce!"
+// Funkce `apply`je velmi podobná, pouze bere jako druhý argument pole argumentů
+dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Hello world! A ahoj slunce!"
 
 // To je praktické, když pracujete s funkcí, která bere sekvenci argumentů a
 // chcete předat pole.
@@ -425,38 +440,42 @@ Math.min.apply(Math, [42, 6, 27]); // = 6
 // použijte `bind`.
 
 var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
-pripojenaFunkce(" A ahoj Saturne!"); // = "Ahoj světe! A ahoj Saturne!"
+pripojenaFunkce(" A ahoj Saturne!"); // = "Hello world! A ahoj Saturne!"
 
-// `bind` může být použito čatečně částečně i k používání
+// `bind` může být použito částečně k přepoužití funkce
 
-var nasobeni = function(a, b){ return a * b; }
+var nasobeni = function(a, b){ return a * b; };
 var zdvojeni = nasobeni.bind(this, 2);
 zdvojeni(8); // = 16
 
 // Když zavoláte funkci se slůvkem 'new', vytvoří se nový objekt a
 // a udělá se dostupný funkcím skrz slůvko 'this'. Funkcím volaným takto se říká
-// konstruktory
+// konstruktory.
 
 var MujKonstruktor = function(){
     this.mojeCislo = 5;
-}
+};
 mujObjekt = new MujKonstruktor(); // = {mojeCislo: 5}
 mujObjekt.mojeCislo; // = 5
 
-// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlasnosti
-// objektu, který neexistuje na objektu, tak se JS koukne do prototypu.
+// Narozdíl od nejznámějších objektově orientovaných jazyků, JavaScript nezná
+// koncept instancí vyvořených z tříd. Místo toho Javascript kombinuje
+//  instanciování a dědění do konceptu zvaného 'prototyp'.
+
+// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlastnosti
+// objektu, který neexistuje na objektu, tak se JS podívá do prototypu.
 
 // Některé JS implementace vám umožní přistupovat k prototypu přes magickou
 // vlastnost '__proto__'. I když je toto užitečné k vysvětlování prototypů, není
-// to součást standardu, ke standartní způsobu k používání prototypu se dostaneme
-// později.
+// to součást standardu. Ke standardnímu způsobu používání prototypu se
+// dostaneme později.
 var mujObjekt = {
     mujText: "Ahoj svete!"
 };
 var mujPrototyp = {
     smyslZivota: 42,
     mojeFunkce: function(){
-        return this.mujText.toLowerCase()
+        return this.mujText.toLowerCase();
     }
 };
 
@@ -464,7 +483,7 @@ mujObjekt.__proto__ = mujPrototyp;
 mujObjekt.smyslZivota; // = 42
 
 // Toto funguje i pro funkce
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Samozřejmě, pokud není vlastnost na vašem prototypu, tak se hledá na
 // prototypu od prototypu atd.
@@ -474,21 +493,41 @@ mujPrototyp.__proto__ = {
 mujObjekt.mujBoolean; // = true
 
 
-// Zde neni žádné kopírování; každý objekt ukládá referenci na svůj prototyp
-// Toto znamená, že můžeme měnit prototyp a změny se projeví všude
+// Zde není žádné kopírování; každý objekt ukládá referenci na svůj prototyp
+// Toto znamená, že můžeme měnit prototyp a změny se projeví všude.
 mujPrototyp.smyslZivota = 43;
-mujObjekt.smyslZivota // = 43
+mujObjekt.smyslZivota; // = 43
+
+// Příkaz for/in umožňuje iterovat vlastnosti objetku až do úrovně null
+// prototypu.
+for (var x in myObj){
+    console.log(myObj[x]);
+}
+///Vypíše:
+// Hello world!
+// 43
+// [Function: myFunc]
+
+// Pro výpis pouze vlastností patřících danému objektu a nikoli jeho prototypu,
+// použijte kontrolu pomocí `hasOwnProperty()`.
+for (var x in myObj){
+    if (myObj.hasOwnProperty(x)){
+        console.log(myObj[x]);
+    }
+}
+///Vypíše:
+// Hello world!
 
 // Zmínili jsme již předtím, že '__proto__' není ve standardu a není cesta, jak
 // měnit prototyp existujícího objektu. Avšak existují možnosti, jak vytvořit
-// nový objekt s daným prototypem
+// nový objekt s daným prototypem.
 
 // První je Object.create, což je nedávný přídavek do JS a není dostupný zatím
 // ve všech implementacích.
 var mujObjekt = Object.create(mujPrototyp);
-mujObjekt.smyslZivota // = 43
+mujObjekt.smyslZivota; // = 43
 
-// Druhý způsob, který funguje všude je pomocí konstuktoru. Konstruktor má
+// Druhý způsob, který funguje všude, je pomocí konstuktoru. Konstruktor má
 // vlastnost jménem prototype. Toto *není* prototyp samotného konstruktoru, ale
 // prototyp nového objektu.
 MujKonstruktor.prototype = {
@@ -499,10 +538,10 @@ MujKonstruktor.prototype = {
 };
 var mujObjekt2 = new MujKonstruktor();
 mujObjekt2.ziskejMojeCislo(); // = 5
-mujObjekt2.mojeCislo = 6
+mujObjekt2.mojeCislo = 6;
 mujObjekt2.ziskejMojeCislo(); // = 6
 
-// Vestavěnné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
+// Vestavěné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
 // ekvivalentní obalovací objekty (wrappery).
 var mojeCislo = 12;
 var mojeCisloObj = new Number(12);
@@ -530,45 +569,60 @@ String.prototype.prvniZnak = function(){
 
 // Tento fakt je často používán v polyfillech, což je implementace novějších
 // vlastností JavaScriptu do starších variant, takže je můžete používat třeba
-// ve starých prohlížečích
+// ve starých prohlížečích.
 
-// Pro příkklad, zmínili jsme, že Object.create není dostupný ve všech
-// implementacích, můžeme si avšak přidat pomocí polyfillu
+// Na příklad jsme zmínili, že Object.create není dostupný ve všech
+// implementacích, ale můžeme si ho přidat pomocí polyfillu:
 if (Object.create === undefined){ // nebudeme ho přepisovat, když existuje
     Object.create = function(proto){
         // vytvoříme dočasný konstruktor
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // ten použijeme k vytvoření nového s prototypem
+        // ten použijeme k vytvoření nového objektu s prototypem
         return new Constructor();
-    }
+    };
 }
 ```
 
 ## Kam dál
 
-[Mozilla Developer
-Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) obsahuje
-perfektní dokumentaci pro JavaScript, který je používaný v prohlížečích. Navíc
-je to i wiki, takže jakmile se naučíte více, můžete pomoci ostatním, tím, že
-přispějete svými znalostmi.
+[Mozilla Developer Network][1] obsahuje perfektní dokumentaci pro JavaScript,
+který je používaný v prohlížečích. Navíc je to i wiki, takže jakmile se naučíte
+více, můžete pomoci ostatním tím, že přispějete svými znalostmi.
 
-MDN's [A re-introduction to
-JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+MDN's [A re-introduction to JavaScript][2]
 pojednává o konceptech vysvětlených zde v mnohem větší hloubce. Tento návod
-pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit více, jak se používá
-na webových stránkách, začněte tím, že se kouknete na [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit, jak se používá
+na webových stránkách, začněte tím, že se podíváte na [DOM][3]
+
+[Learn Javascript by Example and with Challenges][4]
+je varianta tohoto návodu i s úkoly.
+
+[JavaScript Garden][5] je sbírka příkladů těch nejnepředvídatelnějších částí
+tohoto jazyka.
+
+[JavaScript: The Definitive Guide][6] je klasická výuková kniha.
+
+[Eloquent Javascript][8] od Marijn Haverbeke je výbornou JS knihou/e-knihou.
 
-[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) je varianta tohoto
-návodu i s úkoly-
+[Javascript: The Right Way][10] je průvodcem Javascriptem pro začínající
+vývojáře i pomocníkem pro zkušené vývojáře, kteří si chtějí prohloubit své
+znalosti.
 
-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) je sbírka
-příkladů těch nejvíce nepředvídatelných částí tohoto jazyka.
+[Javascript:Info][11] je moderním Javascriptovým průvodcem, který pokrývá
+základní i pokročilé témata velice výstižným výkladem.
 
-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/)
-je klasická výuková kniha.
+Jako dodatek k přímým autorům tohoto článku byly na těchto stránkách části
+obsahu převzaty z Pythoního tutoriálu Louiho Dinha, a tak0 z [JS Tutorial][7]
+na stránkách Mozilla Developer Network.
 
-Jako dodatek k přímým autorům tohoto článku, některý obsah byl přizpůsoben z
-Pythoního tutoriálu od Louie Dinh na této stráce, a z [JS
-Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
-z Mozilla Developer Network.
+[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+[4]: http://www.learneroo.com/modules/64/nodes/350
+[5]: http://bonsaiden.github.io/JavaScript-Garden/
+[6]: http://www.amazon.com/gp/product/0596805527/
+[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[8]: http://eloquentjavascript.net/
+[10]: http://jstherightway.org/
+[11]: https://javascript.info/
-- 
cgit v1.2.3


From 8d463993ebe459a0ef8d1ade1814ba34abc34a05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kuba?= <tomas.kuba@simplity.eu>
Date: Mon, 15 Oct 2018 10:42:55 +0200
Subject: fix spell check errors

---
 cs-cz/javascript.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index 8d4ac278..c2723725 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -16,12 +16,12 @@ JavaScriptu s webovými stránkami a vestavěná podpora v prohlížečích způ
 že se stal ve webovém frontendu běžnějším než Java.
 
 JavaScript není omezen pouze na webové prohlížeče. Např. projekt Node.js,
-který zprostředkovává samostatně běžící prostředí V8 JavaScriptového enginu z
-Google Chrome se stává stále oblíbenější i pro serverovou část webových 
+který zprostředkovává samostatně běžící prostředí V8 JavaScriptového jádra z
+Google Chrome se stává stále oblíbenější i pro serverovou část webových
 aplikací.
 
 ```js
-// Jednořádkové komentáře začínájí dvojitým lomítkem,
+// Jednořádkové komentáře začínají dvojitým lomítkem,
 /* a víceřádkové komentáře začínají lomítkem s hvězdičkou
    a končí hvězdičkou s lomítkem */
 
@@ -30,7 +30,7 @@ delejNeco();
 
 // ... ale nemusí, protože středníky jsou automaticky vloženy kdekoliv,
 // kde končí řádka, kromě pár speciálních případů.
-delejNeco()
+delejNeco();
 
 // Protože tyto případy můžou způsobit neočekávané výsledky, budeme
 // středníky v našem návodu používat.
@@ -230,7 +230,7 @@ if (pocet == 3){
 } else if (pocet == 4){
     // provede, když se pocet rovná 4
 } else {
-    // provede, když je pocet cokoliv jinného
+    // provede, když je pocet cokoliv jiného
 }
 
 // Stejně tak cyklus `while`.
@@ -282,7 +282,7 @@ if (dum.velikost == "velký" && dum.barva == "modrá"){
     dum.obsahuje = "medvěd";
 }
 if (barva == "červená" || barva == "modrá"){
-    // barva je červená nebo modtrá
+    // barva je červená nebo modrá
 }
 
 // && a || jsou praktické i pro nastavení základních hodnot
@@ -358,7 +358,7 @@ i; // = 5 - ne undefined, jak byste očekávali v jazyku, kde mají bloky svůj
 //globální oblasti
 (function(){
     var docasna = 5;
-    // Můžeme přistupovat ke globálního oblasti přes přiřazování globalním
+    // Můžeme přistupovat ke globálního oblasti přes přiřazování globálním
     // objektům. Ve webovém prohlížeči je to vždy 'window`. Globální objekt
     // může mít v jiných prostředích jako Node.js jiné jméno.
     window.trvala = 10;
@@ -382,10 +382,10 @@ function ahojPoPetiVterinach(jmeno){
     // vnitrni je definována přes ahojPoPetiVterinach a má pořád přístup k
     // proměnné prompt, když je konečně zavolána.
 }
-ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
+ahojPoPetiVterinach("Adam"); // otevře pop-up s textem  "Ahoj, Adam!" za 5s
 
 ///////////////////////////////////////////////////
-// 5. Více o objektech, konstuktorech a prototypech
+// 5. Více o objektech, konstruktorech a prototypech
 
 // Objekty můžou obsahovat funkce.
 var mujObjekt = {
-- 
cgit v1.2.3


From 5022b4544b0857bc11f40c26ca5fef651f88bb76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kuba?= <tomas.kuba@simplity.eu>
Date: Mon, 15 Oct 2018 11:01:42 +0200
Subject: fix spell typos and improve some more sentences

---
 cs-cz/javascript.html.markdown | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index c2723725..c05a9138 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -133,7 +133,7 @@ null;      // obvykle označuje něco záměrně bez hodnoty
 undefined; // obvykle označuje, že hodnota není momentálně definovaná (ačkoli
            // `undefined` je hodnota sama o sobě)
 
-// false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
+// false, null, undefined, NaN, 0 a "" vrací nepravdu (false). Všechno ostatní
 // vrací pravdu (true).
 // Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, i když 0 == "0"
 // vrací pravdu.
@@ -382,7 +382,7 @@ function ahojPoPetiVterinach(jmeno){
     // vnitrni je definována přes ahojPoPetiVterinach a má pořád přístup k
     // proměnné prompt, když je konečně zavolána.
 }
-ahojPoPetiVterinach("Adam"); // otevře pop-up s textem  "Ahoj, Adam!" za 5s
+ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
 
 ///////////////////////////////////////////////////
 // 5. Více o objektech, konstruktorech a prototypech
@@ -442,7 +442,7 @@ Math.min.apply(Math, [42, 6, 27]); // = 6
 var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
 pripojenaFunkce(" A ahoj Saturne!"); // = "Hello world! A ahoj Saturne!"
 
-// `bind` může být použito částečně k přepoužití funkce
+// `bind` může být použito částečně k provázání funkcí
 
 var nasobeni = function(a, b){ return a * b; };
 var zdvojeni = nasobeni.bind(this, 2);
@@ -458,11 +458,11 @@ var MujKonstruktor = function(){
 mujObjekt = new MujKonstruktor(); // = {mojeCislo: 5}
 mujObjekt.mojeCislo; // = 5
 
-// Narozdíl od nejznámějších objektově orientovaných jazyků, JavaScript nezná
-// koncept instancí vyvořených z tříd. Místo toho Javascript kombinuje
-//  instanciování a dědění do konceptu zvaného 'prototyp'.
+// Na rozdíl od nejznámějších objektově orientovaných jazyků, JavaScript nezná
+// koncept instancí vytvořených z tříd. Místo toho Javascript kombinuje
+// vytváření instancí a dědění do konceptu zvaného 'prototyp'.
 
-// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlastnosti
+// Každý JavaScriptový objekt má prototyp. Když budete přistupovat k vlastnosti
 // objektu, který neexistuje na objektu, tak se JS podívá do prototypu.
 
 // Některé JS implementace vám umožní přistupovat k prototypu přes magickou
@@ -470,7 +470,7 @@ mujObjekt.mojeCislo; // = 5
 // to součást standardu. Ke standardnímu způsobu používání prototypu se
 // dostaneme později.
 var mujObjekt = {
-    mujText: "Ahoj svete!"
+    mujText: "Hello world!"
 };
 var mujPrototyp = {
     smyslZivota: 42,
@@ -498,7 +498,7 @@ mujObjekt.mujBoolean; // = true
 mujPrototyp.smyslZivota = 43;
 mujObjekt.smyslZivota; // = 43
 
-// Příkaz for/in umožňuje iterovat vlastnosti objetku až do úrovně null
+// Příkaz for/in umožňuje iterovat vlastnosti objektu až do úrovně null
 // prototypu.
 for (var x in myObj){
     console.log(myObj[x]);
@@ -527,7 +527,7 @@ for (var x in myObj){
 var mujObjekt = Object.create(mujPrototyp);
 mujObjekt.smyslZivota; // = 43
 
-// Druhý způsob, který funguje všude, je pomocí konstuktoru. Konstruktor má
+// Druhý způsob, který funguje všude, je pomocí konstruktoru. Konstruktor má
 // vlastnost jménem prototype. Toto *není* prototyp samotného konstruktoru, ale
 // prototyp nového objektu.
 MujKonstruktor.prototype = {
@@ -560,7 +560,7 @@ if (new Number(0)){
    // a objekty jsou vždy pravdivé
 }
 
-// Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
+// Avšak, obalovací objekty a normální vestavěné typy sdílejí prototyp, takže
 // můžete přidat funkcionalitu k řetězci
 String.prototype.prvniZnak = function(){
     return this.charAt(0);
@@ -605,15 +605,15 @@ tohoto jazyka.
 
 [Eloquent Javascript][8] od Marijn Haverbeke je výbornou JS knihou/e-knihou.
 
-[Javascript: The Right Way][10] je průvodcem Javascriptem pro začínající
+[Javascript: The Right Way][10] je průvodcem JavaScriptem pro začínající
 vývojáře i pomocníkem pro zkušené vývojáře, kteří si chtějí prohloubit své
 znalosti.
 
-[Javascript:Info][11] je moderním Javascriptovým průvodcem, který pokrývá
+[Javascript:Info][11] je moderním JavaScriptovým průvodcem, který pokrývá
 základní i pokročilé témata velice výstižným výkladem.
 
 Jako dodatek k přímým autorům tohoto článku byly na těchto stránkách části
-obsahu převzaty z Pythoního tutoriálu Louiho Dinha, a tak0 z [JS Tutorial][7]
+obsahu převzaty z Pythonního tutoriálu Louiho Dinha, a tak0 z [JS Tutorial][7]
 na stránkách Mozilla Developer Network.
 
 [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
-- 
cgit v1.2.3


From 3268606f95730da96fcb61dffc9fc5a6fc971fff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zden=C4=9Bk=20B=C3=B6hm?= <zdenek.bohm@nic.cz>
Date: Sat, 27 Oct 2018 17:19:02 +0530
Subject: Fix text

---
 cs-cz/python3.html.markdown | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 581ed3a3..dbaae88b 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -76,9 +76,13 @@ False or True   # => True
 # Používání logických operátorů s čísly
 0 and 2     # => 0
 -5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
+
+# Při porovnání s boolean hodnotou nepoužívejte operátor rovnosti "==". 
+# Stejně jako u hodnoty None.
+# Viz PEP8: https://www.python.org/dev/peps/pep-0008/ 
+0 is False  # => True
+2 is True   # => False
+1 is True   # => True
 
 # Rovnost je ==
 1 == 1  # => True
@@ -99,11 +103,11 @@ False or True   # => True
 2 < 3 < 2  # => False
 
 
-# Řetězce používají " nebo ' a mohou obsahovat UTF8 znaky
+# Řetězce používají " nebo ' a mohou obsahovat unicode znaky
 "Toto je řetězec."
 'Toto je také řetězec.'
 
-# Řetězce se také dají sčítat, ale nepoužívejte to
+# Řetězce se také dají slučovat
 "Hello " + "world!"  # => "Hello world!"
 # Dají se spojovat i bez '+'
 "Hello " "world!"  # => "Hello world!"
@@ -152,10 +156,12 @@ 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ázvy proměnných mohou obsahovat i unicode znaky, ale nedělejte to.
+# Viz PEP 3131 -- Supporting Non-ASCII Identifiers: 
+# https://www.python.org/dev/peps/pep-3131/
 název_proměnné = 5
 
-# Přístup k předtím nepoužité proměnné vyvolá výjimku
+# Přístup k předtím nedefinované proměnné vyvolá výjimku
 # Odchytávání vyjímek - viz další kapitola
 neznama_promenna  # Vyhodí NameError
 
@@ -199,7 +205,7 @@ sez[::-1]  # => [3, 4, 2, 1]
 # Odebírat prvky ze seznamu lze pomocí del
 del sez[2]   # sez je nyní [1, 2, 3]
 
-# Seznamy můžete sčítat
+# Seznamy můžete slučovat
 # Hodnoty sez a jiny_seznam přitom nejsou změněny
 sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
 
-- 
cgit v1.2.3


From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001
From: Anindya Srivastava <pro.anindya@gmail.com>
Date: Wed, 6 Feb 2019 07:26:25 +0530
Subject: Type correction for the output of math.sqrt() propagated across
 versions and languages

---
 cs-cz/python3.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index dbaae88b..2cbf52e6 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -572,7 +572,7 @@ Clovek.odkaslej_si()  # => "*ehm*"
 
 # Lze importovat moduly
 import math
-print(math.sqrt(16.0))  # => 4
+print(math.sqrt(16.0))  # => 4.0
 
 # Lze také importovat pouze vybrané funkce z modulu
 from math import ceil, floor
-- 
cgit v1.2.3


From f1a7e8f8b2553bfa4ecfcf67a16e4a5e37859194 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Bed=C5=99ich?= <ja@tbedrich.cz>
Date: Fri, 20 Sep 2019 16:27:27 +0200
Subject: [python/cs-cz] Update examples: bool + generators

---
 cs-cz/python3.html.markdown | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 2cbf52e6..bd3690a8 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -137,12 +137,14 @@ None  # => None
 "něco" is None  # => False
 None is None    # => True
 
-# None, 0, a prázdný řetězec/seznam/slovník se vyhodnotí jako False
+# None, 0, a prázdný řetězec/seznam/N-tice/slovník/množina se vyhodnotí jako False
 # Vše ostatní se vyhodnotí jako True
-bool(0)   # => False
-bool("")  # => False
-bool([])  # => False
-bool({})  # => False
+bool(0)        # => False
+bool("")       # => False
+bool([])       # => False
+bool(tuple())  # => False
+bool({})       # => False
+bool(set())    # => False
 
 
 ####################################################
@@ -602,18 +604,21 @@ dir(math)
 # Generátory jsou funkce, které místo return obsahují yield
 def nasobicka_2(sekvence):
     for i in sekvence:
+        print("Zpracovávám číslo {}".format(i))
         yield 2 * i
 
 # Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil
 # celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci.
-# To znamená, že čísla větší než 15 se v metodě nasobicka_2 vůbec nezpracují.
+for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
+        break
 
 # Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
 # hodně času i paměti, proto se místo toho čísla generují postupně.
-
-for i in nasobicka_2(range(900000000)):
-    print(i)  # Vypíše čísla 0, 2, 4, 6, 8, ... 30
-    if i >= 30:
+for nasobek in nasobicka_2(range(900000000)):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
         break
 
 
@@ -633,7 +638,7 @@ def nekolikrat(puvodni_funkce):
 def pozdrav(jmeno):
     print("Měj se {}!".format(jmeno))
 
-pozdrav("Pepo")  # Vypíše 3x: Měj se Pepo!
+pozdrav("Pepo")  # Vypíše 3x: "Měj se Pepo!"
 ```
 
 ## Co dál?
-- 
cgit v1.2.3


From a3b0585374d69e392fdb724bde30bc4048358d31 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 04:54:36 +0100
Subject: Rename Python 3 markdown files into 'python'

```
for f in $(find . -iname "*python3*" | grep -vE 'git'); do
  fnew=$(echo "$f" | sed 's/python3/python/')
  git mv "$f" "$fnew"
done
---
 cs-cz/python.html.markdown  | 647 ++++++++++++++++++++++++++++++++++++++++++++
 cs-cz/python3.html.markdown | 647 --------------------------------------------
 2 files changed, 647 insertions(+), 647 deletions(-)
 create mode 100644 cs-cz/python.html.markdown
 delete mode 100644 cs-cz/python3.html.markdown

(limited to 'cs-cz')

diff --git a/cs-cz/python.html.markdown b/cs-cz/python.html.markdown
new file mode 100644
index 00000000..bd3690a8
--- /dev/null
+++ b/cs-cz/python.html.markdown
@@ -0,0 +1,647 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Tomáš Bedřich", "http://tbedrich.cz"]
+translators:
+    - ["Tomáš Bedřich", "http://tbedrich.cz"]
+filename: learnpython3-cz.py
+lang: cs-cz
+---
+
+Python byl vytvořen Guidem Van Rossum v raných 90. letech. Nyní je jedním z nejpopulárnějších jazyků.
+Zamiloval jsem si Python pro jeho syntaktickou čistotu - je to vlastně spustitelný pseudokód.
+
+Vaše zpětná vazba je vítána! Můžete mě zastihnout na [@louiedinh](http://twitter.com/louiedinh) nebo louiedinh [at] [email od googlu] anglicky,
+autora českého překladu pak na [@tbedrich](http://twitter.com/tbedrich) nebo ja [at] tbedrich.cz
+
+Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/python/).
+
+```python
+
+# Jednořádkový komentář začíná křížkem
+
+""" Víceřádkové komentáře používají tři uvozovky nebo apostrofy
+    a jsou často využívány jako dokumentační komentáře k metodám
+"""
+
+####################################################
+## 1. Primitivní datové typy a operátory
+####################################################
+
+# Čísla
+3  # => 3
+
+# Aritmetické operace se chovají běžným způsobem
+1 + 1   # =>  2
+8 - 1   # =>  7
+10 * 2  # => 20
+
+# Až na dělení, které vrací desetinné číslo
+35 / 5  # => 7.0
+
+# Při celočíselném dělení je desetinná část oříznuta (pro kladná i záporná čísla)
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0  #  celočíselně dělit lze i desetinným číslem
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Pokud použijete desetinné číslo, výsledek je jím také
+3 * 2.0  # => 6.0
+
+# Modulo
+7 % 3  # => 1
+
+# Mocnění (x na y-tou)
+2**4  # => 16
+
+# Pro vynucení priority použijte závorky
+(1 + 3) * 2  # => 8
+
+# Logické hodnoty
+True
+False
+
+# Negace se provádí pomocí not
+not True   # => False
+not False  # => True
+
+# Logické operátory
+# U operátorů záleží na velikosti písmen
+True and False  # => False
+False or True   # => True
+
+# Používání logických operátorů s čísly
+0 and 2     # => 0
+-5 or 0     # => -5
+
+# Při porovnání s boolean hodnotou nepoužívejte operátor rovnosti "==". 
+# Stejně jako u hodnoty None.
+# Viz PEP8: https://www.python.org/dev/peps/pep-0008/ 
+0 is False  # => True
+2 is True   # => False
+1 is True   # => True
+
+# Rovnost je ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Nerovnost je !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Další porovnání
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Porovnání se dají řetězit!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+
+# Řetězce používají " nebo ' a mohou obsahovat unicode znaky
+"Toto je řetězec."
+'Toto je také řetězec.'
+
+# Řetězce se také dají slučovat
+"Hello " + "world!"  # => "Hello world!"
+# Dají se spojovat i bez '+'
+"Hello " "world!"  # => "Hello world!"
+
+# Řetězec lze považovat za seznam znaků
+"Toto je řetězec"[0]  # => 'T'
+
+# .format lze použít ke skládání řetězců
+"{} mohou být {}".format("řetězce", "skládány")
+
+# Formátovací argumenty můžete opakovat
+"{0} {1} stříkaček stříkalo přes {0} {1} střech".format("tři sta třicet tři", "stříbrných")
+# => "tři sta třicet tři stříbrných stříkaček stříkalo přes tři sta třicet tři stříbrných střech"
+
+# Pokud nechcete počítat, můžete použít pojmenované argumenty
+"{jmeno} si dal {jidlo}".format(jmeno="Franta", jidlo="guláš")  # => "Franta si dal guláš"
+
+# Pokud zároveň potřebujete podporovat Python 2.5 a nižší, můžete použít starší způsob formátování
+"%s se dají %s jako v %s" % ("řetězce", "skládat", "jazyce C")
+
+
+# None je objekt (jinde NULL, nil, ...)
+None  # => None
+
+# Pokud porovnáváte něco s None, nepoužívejte operátor rovnosti "==",
+# použijte raději operátor "is", který testuje identitu.
+"něco" is None  # => False
+None is None    # => True
+
+# None, 0, a prázdný řetězec/seznam/N-tice/slovník/množina se vyhodnotí jako False
+# Vše ostatní se vyhodnotí jako True
+bool(0)        # => False
+bool("")       # => False
+bool([])       # => False
+bool(tuple())  # => False
+bool({})       # => False
+bool(set())    # => False
+
+
+####################################################
+## 2. Proměnné a kolekce
+####################################################
+
+# Python má funkci print
+print("Jsem 3. Python 3.")
+
+# Proměnné není třeba deklarovat před přiřazením
+# Konvence je používat male_pismo_s_podtrzitky
+nazev_promenne = 5
+nazev_promenne  # => 5
+# Názvy proměnných mohou obsahovat i unicode znaky, ale nedělejte to.
+# Viz PEP 3131 -- Supporting Non-ASCII Identifiers: 
+# https://www.python.org/dev/peps/pep-3131/
+název_proměnné = 5
+
+# Přístup k předtím nedefinované proměnné vyvolá výjimku
+# Odchytávání vyjímek - viz další kapitola
+neznama_promenna  # Vyhodí NameError
+
+# Seznam se používá pro ukládání sekvencí
+sez = []
+# Lze ho rovnou naplnit
+jiny_seznam = [4, 5, 6]
+
+# Na konec seznamu se přidává pomocí append
+sez.append(1)    # sez je nyní [1]
+sez.append(2)    # sez je nyní [1, 2]
+sez.append(4)    # sez je nyní [1, 2, 4]
+sez.append(3)    # sez je nyní [1, 2, 4, 3]
+# Z konce se odebírá se pomocí pop
+sez.pop()        # => 3 a sez je nyní [1, 2, 4]
+# Vložme trojku zpátky
+sez.append(3)    # sez je nyní znovu [1, 2, 4, 3]
+
+# Přístup k prvkům funguje jako v poli
+sez[0]  # => 1
+# Mínus počítá odzadu (-1 je poslední prvek)
+sez[-1]  # => 3
+
+# Přístup mimo seznam vyhodí IndexError
+sez[4]  # Vyhodí IndexError
+
+# Pomocí řezů lze ze seznamu vybírat různé intervaly
+# (pro matematiky: jedná se o uzavřený/otevřený interval)
+sez[1:3]  # => [2, 4]
+# Odříznutí začátku
+sez[2:]  # => [4, 3]
+# Odříznutí konce
+sez[:3]  # => [1, 2, 4]
+# Vybrání každého druhého prvku
+sez[::2]  # =>[1, 4]
+# Vrácení seznamu v opačném pořadí
+sez[::-1]  # => [3, 4, 2, 1]
+# Lze použít jakoukoliv kombinaci parametrů pro vytvoření složitějšího řezu
+# sez[zacatek:konec:krok]
+
+# Odebírat prvky ze seznamu lze pomocí del
+del sez[2]   # sez je nyní [1, 2, 3]
+
+# Seznamy můžete slučovat
+# Hodnoty sez a jiny_seznam přitom nejsou změněny
+sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
+
+# Spojit seznamy lze pomocí extend
+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
+
+# Délku seznamu lze zjistit pomocí len
+len(sez)  # => 6
+
+
+# N-tice je jako seznam, ale je neměnná
+ntice = (1, 2, 3)
+ntice[0]      # => 1
+ntice[0] = 3  # Vyhodí TypeError
+
+# S n-ticemi lze dělat většinu operací, jako se seznamy
+len(ntice)         # => 3
+ntice + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+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
+# 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
+
+
+# Slovníky ukládají klíče a hodnoty
+prazdny_slovnik = {}
+# Lze je také rovnou naplnit
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
+
+# Přistupovat k hodnotám lze pomocí []
+slovnik["jedna"]  # => 1
+
+# Všechny klíče dostaneme pomocí keys() jako iterovatelný objekt. Nyní ještě
+# potřebujeme obalit volání v list(), abychom dostali seznam. To rozebereme
+# později. Pozor, že jakékoliv pořadí klíčů není garantováno - může být různé.
+list(slovnik.keys())  # => ["dva", "jedna", "tři"]
+
+# Všechny hodnoty opět jako iterovatelný objekt získáme pomocí values(). Opět
+# tedy potřebujeme použít list(), abychom dostali seznam. Stejně jako
+# v předchozím případě, pořadí není garantováno a může být různé
+list(slovnik.values())  # => [3, 2, 1]
+
+# Operátorem in se lze dotázat na přítomnost klíče
+"jedna" in slovnik  # => True
+1 in slovnik        # => False
+
+# Přístup k neexistujícímu klíči vyhodí KeyError
+slovnik["čtyři"]  # Vyhodí KeyError
+
+# Metoda get() funguje podobně jako [], ale vrátí None místo vyhození KeyError
+slovnik.get("jedna")   # => 1
+slovnik.get("čtyři")   # => None
+# Metodě get() lze předat i výchozí hodnotu místo None
+slovnik.get("jedna", 4)   # => 1
+slovnik.get("čtyři", 4)   # => 4
+
+# metoda setdefault() vloží prvek do slovníku pouze pokud tam takový klíč není
+slovnik.setdefault("pět", 5)  # slovnik["pět"] je nastaven na 5
+slovnik.setdefault("pět", 6)  # slovnik["pět"] je pořád 5
+
+# Přidání nové hodnoty do slovníku
+slovnik["čtyři"] = 4
+# Hromadně aktualizovat nebo přidat data lze pomocí update(), parametrem je opět slovník
+slovnik.update({"čtyři": 4})  # slovnik je nyní {"jedna": 1, "dva": 2, "tři": 3, "čtyři": 4, "pět": 5}
+
+# Odebírat ze slovníku dle klíče lze pomocí del
+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}
+
+# Přidání položky do množiny
+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}
+
+# Sjednocení pomocí operátoru |
+mnozina | jina_mnozina  # => {1, 2, 3, 4, 5, 6}
+
+# Rozdíl pomocí operátoru -
+{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
+9 in mnozina  # => False
+
+
+####################################################
+## 3. Řízení toku programu, cykly
+####################################################
+
+# Vytvořme si proměnnou
+promenna = 5
+
+# Takto vypadá podmínka. Na odsazení v Pythonu záleží!
+# Vypíše "proměnná je menší než 10".
+if promenna > 10:
+    print("proměnná je velká jak Rusko")
+elif promenna < 10:  # Část elif je nepovinná
+    print("proměnná je menší než 10")
+else:                # Část else je také nepovinná
+    print("proměnná je právě 10")
+
+
+"""
+Smyčka for umí iterovat (nejen) přes seznamy
+vypíše:
+    pes je savec
+    kočka je savec
+    myš je savec
+"""
+for zvire in ["pes", "kočka", "myš"]:
+    # Můžete použít formát pro složení řetězce
+    print("{} je savec".format(zvire))
+
+"""
+range(cislo) vrací iterovatelný objekt čísel od 0 do cislo
+vypíše:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+range(spodni_limit, horni_limit) vrací iterovatelný objekt čísel mezi limity
+vypíše:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+Smyčka while se opakuje, dokud je podmínka splněna.
+vypíše:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Zkrácený zápis x = x + 1. Pozor, žádné x++ neexisuje.
+
+
+# Výjimky lze ošetřit pomocí bloku try/except(/else/finally)
+try:
+    # Pro vyhození výjimky použijte raise
+    raise IndexError("Přistoupil jste k neexistujícímu prvku v seznamu.")
+except IndexError as e:
+    print("Nastala chyba: {}".format(e))
+    # Vypíše: Nastala chyba: Přistoupil jste k neexistujícímu prvku v seznamu.
+except (TypeError, NameError):  # Více výjimek lze zachytit najednou
+    pass  # Pass znamená nedělej nic - nepříliš vhodný způsob ošetření chyb
+else:  # Volitelný blok else musí být až za bloky except
+    print("OK!")  # Vypíše OK! v případě, že nenastala žádná výjimka
+finally:  # Blok finally se spustí nakonec za všech okolností
+    print("Uvolníme zdroje, uzavřeme soubory...")
+
+# Místo try/finally lze použít with pro automatické uvolnění zdrojů
+with open("soubor.txt") as soubor:
+    for radka in soubor:
+        print(radka)
+
+# Python běžně používá iterovatelné objekty, což je prakticky cokoliv,
+# co lze považovat za sekvenci. Například to, co vrací metoda range(),
+# nebo otevřený soubor, jsou iterovatelné objekty.
+
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
+iterovatelny_objekt = slovnik.keys()
+print(iterovatelny_objekt)  # => dict_keys(["jedna", "dva", "tři"]). Toto je iterovatelný objekt.
+
+# Můžeme použít cyklus for na jeho projití
+for klic in iterovatelny_objekt:
+    print(klic)    # vypíše postupně: jedna, dva, tři
+
+# Ale nelze přistupovat k prvkům pod jejich indexem
+iterovatelny_objekt[1]  # Vyhodí TypeError
+
+# Všechny položky iterovatelného objektu lze získat jako seznam pomocí list()
+list(slovnik.keys())  # => ["jedna", "dva", "tři"]
+
+# Z iterovatelného objektu lze vytvořit iterátor
+iterator = iter(iterovatelny_objekt)
+
+# Iterátor je objekt, který si pamatuje stav v rámci svého iterovatelného objektu
+# Další hodnotu dostaneme voláním next()
+next(iterator)  # => "jedna"
+
+# Iterátor si udržuje svůj stav v mezi jednotlivými voláními next()
+next(iterator)  # => "dva"
+next(iterator)  # => "tři"
+
+# Jakmile interátor vrátí všechna svá data, vyhodí výjimku StopIteration
+next(iterator)  # Vyhodí StopIteration
+
+
+####################################################
+## 4. Funkce
+####################################################
+
+# Pro vytvoření nové funkce použijte klíčové slovo def
+def secist(x, y):
+    print("x je {} a y je {}".format(x, y))
+    return x + y  # Hodnoty se vrací pomocí return
+
+# Volání funkce s parametry
+secist(5, 6)  # => Vypíše "x je 5 a y je 6" a vrátí 11
+
+# Jiný způsob, jak volat funkci, je použít pojmenované argumenty
+secist(y=6, x=5)  # Pojmenované argumenty můžete předat v libovolném pořadí
+
+# Lze definovat funkce s proměnným počtem (pozičních) argumentů
+def vrat_argumenty(*argumenty):
+    return argumenty
+
+vrat_argumenty(1, 2, 3)  # => (1, 2, 3)
+
+# Lze definovat také funkce s proměnným počtem pojmenovaných argumentů
+def vrat_pojmenovane_argumenty(**pojmenovane_argumenty):
+    return pojmenovane_argumenty
+
+vrat_pojmenovane_argumenty(kdo="se bojí", nesmi="do lesa")
+# => {"kdo": "se bojí", "nesmi": "do lesa"}
+
+
+# Pokud chcete, lze použít obojí najednou
+# Konvence je používat pro tyto účely názvy *args a **kwargs
+def vypis_vse(*args, **kwargs):
+    print(args, kwargs)  # print() vypíše všechny své parametry oddělené mezerou
+
+vypis_vse(1, 2, a=3, b=4)  # Vypíše: (1, 2) {"a": 3, "b": 4}
+
+# * nebo ** lze použít k rozbalení N-tic nebo slovníků!
+ntice = (1, 2, 3, 4)
+slovnik = {"a": 3, "b": 4}
+vypis_vse(ntice)  # Vyhodnotí se jako vypis_vse((1, 2, 3, 4)) – jeden parametr, N-tice
+vypis_vse(*ntice)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4)
+vypis_vse(**slovnik)  # Vyhodnotí se jako vypis_vse(a=3, b=4)
+vypis_vse(*ntice, **slovnik)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4, a=3, b=4)
+
+
+# Viditelnost proměnných - vytvořme si globální proměnnou x
+x = 5
+
+def nastavX(cislo):
+    # Lokální proměnná x překryje globální x
+    x = cislo  # => 43
+    print(x)  # => 43
+
+def nastavGlobalniX(cislo):
+    global x
+    print(x)  # => 5
+    x = cislo  # Nastaví globální proměnnou x na 6
+    print(x)  # => 6
+
+nastavX(43)
+nastavGlobalniX(6)
+
+
+# Funkce jsou first-class objekty
+def vyrobit_scitacku(pricitane_cislo):
+    def scitacka(x):
+        return x + pricitane_cislo
+    return scitacka
+
+pricist_10 = vyrobit_scitacku(10)
+pricist_10(3)  # => 13
+
+# Klíčové slovo lambda vytvoří anonymní funkci
+(lambda parametr: parametr > 2)(3)  # => True
+
+# Lze použít funkce map() a filter() z funkcionálního programování
+map(pricist_10, [1, 2, 3])
+# => <map object at 0x0123467> - iterovatelný objekt s obsahem: [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])
+# => <filter object at 0x0123467> - iterovatelný objekt s obsahem: [6, 7]
+
+# S generátorovou notací lze dosáhnout podobných výsledků, ale vrací seznam
+[pricist_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+# Generátorová notace funguje i pro slovníky
+{x: x**2 for x in range(1, 5)}  # => {1: 1, 2: 4, 3: 9, 4: 16}
+# A také pro množiny
+{pismeno for pismeno in "abeceda"}  # => {"d", "a", "c", "e", "b"}
+
+
+####################################################
+## 5. Třídy
+####################################################
+
+# Třída Clovek je potomkem (dědí od) třídy object
+class Clovek(object):
+
+    # Atribut třídy - je sdílený všemi instancemi
+    druh = "H. sapiens"
+
+    # Toto je kostruktor. Je volán, když vytváříme instanci třídy. Dvě
+    # podtržítka na začátku a na konci značí, že se jedná o atribut nebo
+    # objekt využívaný Pythonem ke speciálním účelům, ale můžete sami
+    # definovat jeho chování. Metody jako __init__, __str__, __repr__
+    # a další se nazývají "magické metody". Nikdy nepoužívejte toto
+    # speciální pojmenování pro běžné metody.
+    def __init__(self, jmeno):
+        # Přiřazení parametru do atributu instance jmeno
+        self.jmeno = jmeno
+
+    # Metoda instance - všechny metody instance mají "self" jako první parametr
+    def rekni(self, hlaska):
+        return "{jmeno}: {hlaska}".format(jmeno=self.jmeno, hlaska=hlaska)
+
+    # Metoda třídy - sdílená všemi instancemi
+    # Dostává jako první parametr třídu, na které je volána
+    @classmethod
+    def vrat_druh(cls):
+        return cls.druh
+
+    # Statická metoda je volána bez reference na třídu nebo instanci
+    @staticmethod
+    def odkaslej_si():
+        return "*ehm*"
+
+
+# Vytvoření instance
+d = Clovek(jmeno="David")
+a = Clovek("Adéla")
+print(d.rekni("ahoj"))    # Vypíše: "David: ahoj"
+print(a.rekni("nazdar"))  # Vypíše: "Adéla: nazdar"
+
+# Volání třídní metody
+d.vrat_druh()  # => "H. sapiens"
+
+# Změna atributu třídy
+Clovek.druh = "H. neanderthalensis"
+d.vrat_druh()  # => "H. neanderthalensis"
+a.vrat_druh()  # => "H. neanderthalensis"
+
+# Volání statické metody
+Clovek.odkaslej_si()  # => "*ehm*"
+
+
+####################################################
+## 6. Moduly
+####################################################
+
+# Lze importovat moduly
+import math
+print(math.sqrt(16.0))  # => 4.0
+
+# Lze také importovat pouze vybrané funkce z modulu
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Můžete také importovat všechny funkce z modulu, ale radši to nedělejte
+from math import *
+
+# Můžete si přejmenovat modul při jeho importu
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Modul v Pythonu není nic jiného, než obyčejný soubor .py
+# Můžete si napsat vlastní a prostě ho importovat podle jména
+from muj_modul import moje_funkce  # Nyní vyhodí ImportError - muj_modul neexistuje
+
+# Funkcí dir() lze zjistit, co modul obsahuje
+import math
+dir(math)
+
+
+####################################################
+## 7. Pokročilé
+####################################################
+
+# Generátory jsou funkce, které místo return obsahují yield
+def nasobicka_2(sekvence):
+    for i in sekvence:
+        print("Zpracovávám číslo {}".format(i))
+        yield 2 * i
+
+# Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil
+# celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci.
+for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
+        break
+
+# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
+# hodně času i paměti, proto se místo toho čísla generují postupně.
+for nasobek in nasobicka_2(range(900000000)):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
+        break
+
+
+# Dekorátory jsou funkce, které se používají pro obalení jiné funkce, čímž mohou
+# přidávat nebo měnit její stávající chování. Funkci dostávají jako parametr
+# a typicky místo ní vrací jinou, která uvnitř volá tu původní.
+
+def nekolikrat(puvodni_funkce):
+    def opakovaci_funkce(*args, **kwargs):
+        for i in range(3):
+            puvodni_funkce(*args, **kwargs)
+
+    return opakovaci_funkce
+
+
+@nekolikrat
+def pozdrav(jmeno):
+    print("Měj se {}!".format(jmeno))
+
+pozdrav("Pepo")  # Vypíše 3x: "Měj se Pepo!"
+```
+
+## Co dál?
+
+Spoustu odkazů na české i anglické materiály najdete na [webu české Python komunity]
+(http://python.cz/). Můžete také přijít na Pyvo, kde to společně probereme.
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
deleted file mode 100644
index bd3690a8..00000000
--- a/cs-cz/python3.html.markdown
+++ /dev/null
@@ -1,647 +0,0 @@
----
-language: python3
-contributors:
-    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
-    - ["Steven Basart", "http://github.com/xksteven"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Tomáš Bedřich", "http://tbedrich.cz"]
-translators:
-    - ["Tomáš Bedřich", "http://tbedrich.cz"]
-filename: learnpython3-cz.py
-lang: cs-cz
----
-
-Python byl vytvořen Guidem Van Rossum v raných 90. letech. Nyní je jedním z nejpopulárnějších jazyků.
-Zamiloval jsem si Python pro jeho syntaktickou čistotu - je to vlastně spustitelný pseudokód.
-
-Vaše zpětná vazba je vítána! Můžete mě zastihnout na [@louiedinh](http://twitter.com/louiedinh) nebo louiedinh [at] [email od googlu] anglicky,
-autora českého překladu pak na [@tbedrich](http://twitter.com/tbedrich) nebo ja [at] tbedrich.cz
-
-Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/python/).
-
-```python
-
-# Jednořádkový komentář začíná křížkem
-
-""" Víceřádkové komentáře používají tři uvozovky nebo apostrofy
-    a jsou často využívány jako dokumentační komentáře k metodám
-"""
-
-####################################################
-## 1. Primitivní datové typy a operátory
-####################################################
-
-# Čísla
-3  # => 3
-
-# Aritmetické operace se chovají běžným způsobem
-1 + 1   # =>  2
-8 - 1   # =>  7
-10 * 2  # => 20
-
-# Až na dělení, které vrací desetinné číslo
-35 / 5  # => 7.0
-
-# Při celočíselném dělení je desetinná část oříznuta (pro kladná i záporná čísla)
-5 // 3       # => 1
-5.0 // 3.0   # => 1.0  #  celočíselně dělit lze i desetinným číslem
--5 // 3      # => -2
--5.0 // 3.0  # => -2.0
-
-# Pokud použijete desetinné číslo, výsledek je jím také
-3 * 2.0  # => 6.0
-
-# Modulo
-7 % 3  # => 1
-
-# Mocnění (x na y-tou)
-2**4  # => 16
-
-# Pro vynucení priority použijte závorky
-(1 + 3) * 2  # => 8
-
-# Logické hodnoty
-True
-False
-
-# Negace se provádí pomocí not
-not True   # => False
-not False  # => True
-
-# Logické operátory
-# U operátorů záleží na velikosti písmen
-True and False  # => False
-False or True   # => True
-
-# Používání logických operátorů s čísly
-0 and 2     # => 0
--5 or 0     # => -5
-
-# Při porovnání s boolean hodnotou nepoužívejte operátor rovnosti "==". 
-# Stejně jako u hodnoty None.
-# Viz PEP8: https://www.python.org/dev/peps/pep-0008/ 
-0 is False  # => True
-2 is True   # => False
-1 is True   # => True
-
-# Rovnost je ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Nerovnost je !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Další porovnání
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Porovnání se dají řetězit!
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-
-# Řetězce používají " nebo ' a mohou obsahovat unicode znaky
-"Toto je řetězec."
-'Toto je také řetězec.'
-
-# Řetězce se také dají slučovat
-"Hello " + "world!"  # => "Hello world!"
-# Dají se spojovat i bez '+'
-"Hello " "world!"  # => "Hello world!"
-
-# Řetězec lze považovat za seznam znaků
-"Toto je řetězec"[0]  # => 'T'
-
-# .format lze použít ke skládání řetězců
-"{} mohou být {}".format("řetězce", "skládány")
-
-# Formátovací argumenty můžete opakovat
-"{0} {1} stříkaček stříkalo přes {0} {1} střech".format("tři sta třicet tři", "stříbrných")
-# => "tři sta třicet tři stříbrných stříkaček stříkalo přes tři sta třicet tři stříbrných střech"
-
-# Pokud nechcete počítat, můžete použít pojmenované argumenty
-"{jmeno} si dal {jidlo}".format(jmeno="Franta", jidlo="guláš")  # => "Franta si dal guláš"
-
-# Pokud zároveň potřebujete podporovat Python 2.5 a nižší, můžete použít starší způsob formátování
-"%s se dají %s jako v %s" % ("řetězce", "skládat", "jazyce C")
-
-
-# None je objekt (jinde NULL, nil, ...)
-None  # => None
-
-# Pokud porovnáváte něco s None, nepoužívejte operátor rovnosti "==",
-# použijte raději operátor "is", který testuje identitu.
-"něco" is None  # => False
-None is None    # => True
-
-# None, 0, a prázdný řetězec/seznam/N-tice/slovník/množina se vyhodnotí jako False
-# Vše ostatní se vyhodnotí jako True
-bool(0)        # => False
-bool("")       # => False
-bool([])       # => False
-bool(tuple())  # => False
-bool({})       # => False
-bool(set())    # => False
-
-
-####################################################
-## 2. Proměnné a kolekce
-####################################################
-
-# Python má funkci print
-print("Jsem 3. Python 3.")
-
-# Proměnné není třeba deklarovat před přiřazením
-# Konvence je používat male_pismo_s_podtrzitky
-nazev_promenne = 5
-nazev_promenne  # => 5
-# Názvy proměnných mohou obsahovat i unicode znaky, ale nedělejte to.
-# Viz PEP 3131 -- Supporting Non-ASCII Identifiers: 
-# https://www.python.org/dev/peps/pep-3131/
-název_proměnné = 5
-
-# Přístup k předtím nedefinované proměnné vyvolá výjimku
-# Odchytávání vyjímek - viz další kapitola
-neznama_promenna  # Vyhodí NameError
-
-# Seznam se používá pro ukládání sekvencí
-sez = []
-# Lze ho rovnou naplnit
-jiny_seznam = [4, 5, 6]
-
-# Na konec seznamu se přidává pomocí append
-sez.append(1)    # sez je nyní [1]
-sez.append(2)    # sez je nyní [1, 2]
-sez.append(4)    # sez je nyní [1, 2, 4]
-sez.append(3)    # sez je nyní [1, 2, 4, 3]
-# Z konce se odebírá se pomocí pop
-sez.pop()        # => 3 a sez je nyní [1, 2, 4]
-# Vložme trojku zpátky
-sez.append(3)    # sez je nyní znovu [1, 2, 4, 3]
-
-# Přístup k prvkům funguje jako v poli
-sez[0]  # => 1
-# Mínus počítá odzadu (-1 je poslední prvek)
-sez[-1]  # => 3
-
-# Přístup mimo seznam vyhodí IndexError
-sez[4]  # Vyhodí IndexError
-
-# Pomocí řezů lze ze seznamu vybírat různé intervaly
-# (pro matematiky: jedná se o uzavřený/otevřený interval)
-sez[1:3]  # => [2, 4]
-# Odříznutí začátku
-sez[2:]  # => [4, 3]
-# Odříznutí konce
-sez[:3]  # => [1, 2, 4]
-# Vybrání každého druhého prvku
-sez[::2]  # =>[1, 4]
-# Vrácení seznamu v opačném pořadí
-sez[::-1]  # => [3, 4, 2, 1]
-# Lze použít jakoukoliv kombinaci parametrů pro vytvoření složitějšího řezu
-# sez[zacatek:konec:krok]
-
-# Odebírat prvky ze seznamu lze pomocí del
-del sez[2]   # sez je nyní [1, 2, 3]
-
-# Seznamy můžete slučovat
-# Hodnoty sez a jiny_seznam přitom nejsou změněny
-sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
-
-# Spojit seznamy lze pomocí extend
-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
-
-# Délku seznamu lze zjistit pomocí len
-len(sez)  # => 6
-
-
-# N-tice je jako seznam, ale je neměnná
-ntice = (1, 2, 3)
-ntice[0]      # => 1
-ntice[0] = 3  # Vyhodí TypeError
-
-# S n-ticemi lze dělat většinu operací, jako se seznamy
-len(ntice)         # => 3
-ntice + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
-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
-# 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
-
-
-# Slovníky ukládají klíče a hodnoty
-prazdny_slovnik = {}
-# Lze je také rovnou naplnit
-slovnik = {"jedna": 1, "dva": 2, "tři": 3}
-
-# Přistupovat k hodnotám lze pomocí []
-slovnik["jedna"]  # => 1
-
-# Všechny klíče dostaneme pomocí keys() jako iterovatelný objekt. Nyní ještě
-# potřebujeme obalit volání v list(), abychom dostali seznam. To rozebereme
-# později. Pozor, že jakékoliv pořadí klíčů není garantováno - může být různé.
-list(slovnik.keys())  # => ["dva", "jedna", "tři"]
-
-# Všechny hodnoty opět jako iterovatelný objekt získáme pomocí values(). Opět
-# tedy potřebujeme použít list(), abychom dostali seznam. Stejně jako
-# v předchozím případě, pořadí není garantováno a může být různé
-list(slovnik.values())  # => [3, 2, 1]
-
-# Operátorem in se lze dotázat na přítomnost klíče
-"jedna" in slovnik  # => True
-1 in slovnik        # => False
-
-# Přístup k neexistujícímu klíči vyhodí KeyError
-slovnik["čtyři"]  # Vyhodí KeyError
-
-# Metoda get() funguje podobně jako [], ale vrátí None místo vyhození KeyError
-slovnik.get("jedna")   # => 1
-slovnik.get("čtyři")   # => None
-# Metodě get() lze předat i výchozí hodnotu místo None
-slovnik.get("jedna", 4)   # => 1
-slovnik.get("čtyři", 4)   # => 4
-
-# metoda setdefault() vloží prvek do slovníku pouze pokud tam takový klíč není
-slovnik.setdefault("pět", 5)  # slovnik["pět"] je nastaven na 5
-slovnik.setdefault("pět", 6)  # slovnik["pět"] je pořád 5
-
-# Přidání nové hodnoty do slovníku
-slovnik["čtyři"] = 4
-# Hromadně aktualizovat nebo přidat data lze pomocí update(), parametrem je opět slovník
-slovnik.update({"čtyři": 4})  # slovnik je nyní {"jedna": 1, "dva": 2, "tři": 3, "čtyři": 4, "pět": 5}
-
-# Odebírat ze slovníku dle klíče lze pomocí del
-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}
-
-# Přidání položky do množiny
-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}
-
-# Sjednocení pomocí operátoru |
-mnozina | jina_mnozina  # => {1, 2, 3, 4, 5, 6}
-
-# Rozdíl pomocí operátoru -
-{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
-9 in mnozina  # => False
-
-
-####################################################
-## 3. Řízení toku programu, cykly
-####################################################
-
-# Vytvořme si proměnnou
-promenna = 5
-
-# Takto vypadá podmínka. Na odsazení v Pythonu záleží!
-# Vypíše "proměnná je menší než 10".
-if promenna > 10:
-    print("proměnná je velká jak Rusko")
-elif promenna < 10:  # Část elif je nepovinná
-    print("proměnná je menší než 10")
-else:                # Část else je také nepovinná
-    print("proměnná je právě 10")
-
-
-"""
-Smyčka for umí iterovat (nejen) přes seznamy
-vypíše:
-    pes je savec
-    kočka je savec
-    myš je savec
-"""
-for zvire in ["pes", "kočka", "myš"]:
-    # Můžete použít formát pro složení řetězce
-    print("{} je savec".format(zvire))
-
-"""
-range(cislo) vrací iterovatelný objekt čísel od 0 do cislo
-vypíše:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-
-"""
-range(spodni_limit, horni_limit) vrací iterovatelný objekt čísel mezi limity
-vypíše:
-    4
-    5
-    6
-    7
-"""
-for i in range(4, 8):
-    print(i)
-
-"""
-Smyčka while se opakuje, dokud je podmínka splněna.
-vypíše:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Zkrácený zápis x = x + 1. Pozor, žádné x++ neexisuje.
-
-
-# Výjimky lze ošetřit pomocí bloku try/except(/else/finally)
-try:
-    # Pro vyhození výjimky použijte raise
-    raise IndexError("Přistoupil jste k neexistujícímu prvku v seznamu.")
-except IndexError as e:
-    print("Nastala chyba: {}".format(e))
-    # Vypíše: Nastala chyba: Přistoupil jste k neexistujícímu prvku v seznamu.
-except (TypeError, NameError):  # Více výjimek lze zachytit najednou
-    pass  # Pass znamená nedělej nic - nepříliš vhodný způsob ošetření chyb
-else:  # Volitelný blok else musí být až za bloky except
-    print("OK!")  # Vypíše OK! v případě, že nenastala žádná výjimka
-finally:  # Blok finally se spustí nakonec za všech okolností
-    print("Uvolníme zdroje, uzavřeme soubory...")
-
-# Místo try/finally lze použít with pro automatické uvolnění zdrojů
-with open("soubor.txt") as soubor:
-    for radka in soubor:
-        print(radka)
-
-# Python běžně používá iterovatelné objekty, což je prakticky cokoliv,
-# co lze považovat za sekvenci. Například to, co vrací metoda range(),
-# nebo otevřený soubor, jsou iterovatelné objekty.
-
-slovnik = {"jedna": 1, "dva": 2, "tři": 3}
-iterovatelny_objekt = slovnik.keys()
-print(iterovatelny_objekt)  # => dict_keys(["jedna", "dva", "tři"]). Toto je iterovatelný objekt.
-
-# Můžeme použít cyklus for na jeho projití
-for klic in iterovatelny_objekt:
-    print(klic)    # vypíše postupně: jedna, dva, tři
-
-# Ale nelze přistupovat k prvkům pod jejich indexem
-iterovatelny_objekt[1]  # Vyhodí TypeError
-
-# Všechny položky iterovatelného objektu lze získat jako seznam pomocí list()
-list(slovnik.keys())  # => ["jedna", "dva", "tři"]
-
-# Z iterovatelného objektu lze vytvořit iterátor
-iterator = iter(iterovatelny_objekt)
-
-# Iterátor je objekt, který si pamatuje stav v rámci svého iterovatelného objektu
-# Další hodnotu dostaneme voláním next()
-next(iterator)  # => "jedna"
-
-# Iterátor si udržuje svůj stav v mezi jednotlivými voláními next()
-next(iterator)  # => "dva"
-next(iterator)  # => "tři"
-
-# Jakmile interátor vrátí všechna svá data, vyhodí výjimku StopIteration
-next(iterator)  # Vyhodí StopIteration
-
-
-####################################################
-## 4. Funkce
-####################################################
-
-# Pro vytvoření nové funkce použijte klíčové slovo def
-def secist(x, y):
-    print("x je {} a y je {}".format(x, y))
-    return x + y  # Hodnoty se vrací pomocí return
-
-# Volání funkce s parametry
-secist(5, 6)  # => Vypíše "x je 5 a y je 6" a vrátí 11
-
-# Jiný způsob, jak volat funkci, je použít pojmenované argumenty
-secist(y=6, x=5)  # Pojmenované argumenty můžete předat v libovolném pořadí
-
-# Lze definovat funkce s proměnným počtem (pozičních) argumentů
-def vrat_argumenty(*argumenty):
-    return argumenty
-
-vrat_argumenty(1, 2, 3)  # => (1, 2, 3)
-
-# Lze definovat také funkce s proměnným počtem pojmenovaných argumentů
-def vrat_pojmenovane_argumenty(**pojmenovane_argumenty):
-    return pojmenovane_argumenty
-
-vrat_pojmenovane_argumenty(kdo="se bojí", nesmi="do lesa")
-# => {"kdo": "se bojí", "nesmi": "do lesa"}
-
-
-# Pokud chcete, lze použít obojí najednou
-# Konvence je používat pro tyto účely názvy *args a **kwargs
-def vypis_vse(*args, **kwargs):
-    print(args, kwargs)  # print() vypíše všechny své parametry oddělené mezerou
-
-vypis_vse(1, 2, a=3, b=4)  # Vypíše: (1, 2) {"a": 3, "b": 4}
-
-# * nebo ** lze použít k rozbalení N-tic nebo slovníků!
-ntice = (1, 2, 3, 4)
-slovnik = {"a": 3, "b": 4}
-vypis_vse(ntice)  # Vyhodnotí se jako vypis_vse((1, 2, 3, 4)) – jeden parametr, N-tice
-vypis_vse(*ntice)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4)
-vypis_vse(**slovnik)  # Vyhodnotí se jako vypis_vse(a=3, b=4)
-vypis_vse(*ntice, **slovnik)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4, a=3, b=4)
-
-
-# Viditelnost proměnných - vytvořme si globální proměnnou x
-x = 5
-
-def nastavX(cislo):
-    # Lokální proměnná x překryje globální x
-    x = cislo  # => 43
-    print(x)  # => 43
-
-def nastavGlobalniX(cislo):
-    global x
-    print(x)  # => 5
-    x = cislo  # Nastaví globální proměnnou x na 6
-    print(x)  # => 6
-
-nastavX(43)
-nastavGlobalniX(6)
-
-
-# Funkce jsou first-class objekty
-def vyrobit_scitacku(pricitane_cislo):
-    def scitacka(x):
-        return x + pricitane_cislo
-    return scitacka
-
-pricist_10 = vyrobit_scitacku(10)
-pricist_10(3)  # => 13
-
-# Klíčové slovo lambda vytvoří anonymní funkci
-(lambda parametr: parametr > 2)(3)  # => True
-
-# Lze použít funkce map() a filter() z funkcionálního programování
-map(pricist_10, [1, 2, 3])
-# => <map object at 0x0123467> - iterovatelný objekt s obsahem: [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])
-# => <filter object at 0x0123467> - iterovatelný objekt s obsahem: [6, 7]
-
-# S generátorovou notací lze dosáhnout podobných výsledků, ale vrací seznam
-[pricist_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
-# Generátorová notace funguje i pro slovníky
-{x: x**2 for x in range(1, 5)}  # => {1: 1, 2: 4, 3: 9, 4: 16}
-# A také pro množiny
-{pismeno for pismeno in "abeceda"}  # => {"d", "a", "c", "e", "b"}
-
-
-####################################################
-## 5. Třídy
-####################################################
-
-# Třída Clovek je potomkem (dědí od) třídy object
-class Clovek(object):
-
-    # Atribut třídy - je sdílený všemi instancemi
-    druh = "H. sapiens"
-
-    # Toto je kostruktor. Je volán, když vytváříme instanci třídy. Dvě
-    # podtržítka na začátku a na konci značí, že se jedná o atribut nebo
-    # objekt využívaný Pythonem ke speciálním účelům, ale můžete sami
-    # definovat jeho chování. Metody jako __init__, __str__, __repr__
-    # a další se nazývají "magické metody". Nikdy nepoužívejte toto
-    # speciální pojmenování pro běžné metody.
-    def __init__(self, jmeno):
-        # Přiřazení parametru do atributu instance jmeno
-        self.jmeno = jmeno
-
-    # Metoda instance - všechny metody instance mají "self" jako první parametr
-    def rekni(self, hlaska):
-        return "{jmeno}: {hlaska}".format(jmeno=self.jmeno, hlaska=hlaska)
-
-    # Metoda třídy - sdílená všemi instancemi
-    # Dostává jako první parametr třídu, na které je volána
-    @classmethod
-    def vrat_druh(cls):
-        return cls.druh
-
-    # Statická metoda je volána bez reference na třídu nebo instanci
-    @staticmethod
-    def odkaslej_si():
-        return "*ehm*"
-
-
-# Vytvoření instance
-d = Clovek(jmeno="David")
-a = Clovek("Adéla")
-print(d.rekni("ahoj"))    # Vypíše: "David: ahoj"
-print(a.rekni("nazdar"))  # Vypíše: "Adéla: nazdar"
-
-# Volání třídní metody
-d.vrat_druh()  # => "H. sapiens"
-
-# Změna atributu třídy
-Clovek.druh = "H. neanderthalensis"
-d.vrat_druh()  # => "H. neanderthalensis"
-a.vrat_druh()  # => "H. neanderthalensis"
-
-# Volání statické metody
-Clovek.odkaslej_si()  # => "*ehm*"
-
-
-####################################################
-## 6. Moduly
-####################################################
-
-# Lze importovat moduly
-import math
-print(math.sqrt(16.0))  # => 4.0
-
-# Lze také importovat pouze vybrané funkce z modulu
-from math import ceil, floor
-print(ceil(3.7))   # => 4.0
-print(floor(3.7))  # => 3.0
-
-# Můžete také importovat všechny funkce z modulu, ale radši to nedělejte
-from math import *
-
-# Můžete si přejmenovat modul při jeho importu
-import math as m
-math.sqrt(16) == m.sqrt(16)  # => True
-
-# Modul v Pythonu není nic jiného, než obyčejný soubor .py
-# Můžete si napsat vlastní a prostě ho importovat podle jména
-from muj_modul import moje_funkce  # Nyní vyhodí ImportError - muj_modul neexistuje
-
-# Funkcí dir() lze zjistit, co modul obsahuje
-import math
-dir(math)
-
-
-####################################################
-## 7. Pokročilé
-####################################################
-
-# Generátory jsou funkce, které místo return obsahují yield
-def nasobicka_2(sekvence):
-    for i in sekvence:
-        print("Zpracovávám číslo {}".format(i))
-        yield 2 * i
-
-# Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil
-# celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci.
-for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
-    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
-    if nasobek >= 10:
-        break
-
-# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
-# hodně času i paměti, proto se místo toho čísla generují postupně.
-for nasobek in nasobicka_2(range(900000000)):
-    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
-    if nasobek >= 10:
-        break
-
-
-# Dekorátory jsou funkce, které se používají pro obalení jiné funkce, čímž mohou
-# přidávat nebo měnit její stávající chování. Funkci dostávají jako parametr
-# a typicky místo ní vrací jinou, která uvnitř volá tu původní.
-
-def nekolikrat(puvodni_funkce):
-    def opakovaci_funkce(*args, **kwargs):
-        for i in range(3):
-            puvodni_funkce(*args, **kwargs)
-
-    return opakovaci_funkce
-
-
-@nekolikrat
-def pozdrav(jmeno):
-    print("Měj se {}!".format(jmeno))
-
-pozdrav("Pepo")  # Vypíše 3x: "Měj se Pepo!"
-```
-
-## Co dál?
-
-Spoustu odkazů na české i anglické materiály najdete na [webu české Python komunity]
-(http://python.cz/). Můžete také přijít na Pyvo, kde to společně probereme.
-- 
cgit v1.2.3


From efe00fd06e2908f547ed8d47bd818301f96c4620 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:03:08 +0100
Subject: Switch links: 'python3 <-> python' and 'python <-> pythonlegacy'

The list of references is exhausted by running 'ack docs/python'.
---
 cs-cz/python.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python.html.markdown b/cs-cz/python.html.markdown
index bd3690a8..7086ec5f 100644
--- a/cs-cz/python.html.markdown
+++ b/cs-cz/python.html.markdown
@@ -17,7 +17,7 @@ Zamiloval jsem si Python pro jeho syntaktickou čistotu - je to vlastně spustit
 Vaše zpětná vazba je vítána! Můžete mě zastihnout na [@louiedinh](http://twitter.com/louiedinh) nebo louiedinh [at] [email od googlu] anglicky,
 autora českého překladu pak na [@tbedrich](http://twitter.com/tbedrich) nebo ja [at] tbedrich.cz
 
-Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/python/).
+Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/pythonlegacy/).
 
 ```python
 
-- 
cgit v1.2.3


From 5864aba42d2cf57dfe96049568b3a9689ea6a813 Mon Sep 17 00:00:00 2001
From: Leigh Brenecki <l@leigh.net.au>
Date: Thu, 13 Feb 2020 10:38:29 +1030
Subject: Purge my deadname

---
 cs-cz/javascript.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index c05a9138..408ddde0 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: javascript
 contributors:
-    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Leigh Brenecki", "https://leigh.net.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
-- 
cgit v1.2.3


From cb55323819fa8ea937550051c2d41cb28b727630 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Thu, 13 Feb 2020 22:07:05 -0800
Subject: fix cs-cz python3

---
 cs-cz/python.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python.html.markdown b/cs-cz/python.html.markdown
index 7086ec5f..b684bd7d 100644
--- a/cs-cz/python.html.markdown
+++ b/cs-cz/python.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: python3
+language: python
 contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
@@ -7,7 +7,7 @@ contributors:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
 translators:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
-filename: learnpython3-cz.py
+filename: learnpython-cz.py
 lang: cs-cz
 ---
 
-- 
cgit v1.2.3


From ae75b35f5f2e75396984f79c081746e6f408a072 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Thu, 13 Feb 2020 22:13:20 -0800
Subject: fix cs-cz python3 again

---
 cs-cz/python.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python.html.markdown b/cs-cz/python.html.markdown
index b684bd7d..0e2416d1 100644
--- a/cs-cz/python.html.markdown
+++ b/cs-cz/python.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: python
+language: Python
 contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
-- 
cgit v1.2.3


From 7b7464e17824850047289e666fbeedd0c7b24fdc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Bed=C5=99ich?= <ja@tbedrich.cz>
Date: Wed, 19 Feb 2020 10:04:30 +0100
Subject: Fix bad description of floor division

---
 cs-cz/python.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/python.html.markdown b/cs-cz/python.html.markdown
index 0e2416d1..71509460 100644
--- a/cs-cz/python.html.markdown
+++ b/cs-cz/python.html.markdown
@@ -42,7 +42,8 @@ Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit sta
 # Až na dělení, které vrací desetinné číslo
 35 / 5  # => 7.0
 
-# Při celočíselném dělení je desetinná část oříznuta (pro kladná i záporná čísla)
+# Při celočíselném dělení je na výsledek aplikována funkce floor(),
+# což znamená zaokrouhlení směrem k mínus nekonečnu (pro kladná i záporná čísla).
 5 // 3       # => 1
 5.0 // 3.0   # => 1.0  #  celočíselně dělit lze i desetinným číslem
 -5 // 3      # => -2
-- 
cgit v1.2.3