From ba9a7303c886499856b130a21298d2d82b9f1626 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Tue, 8 Sep 2015 18:24:00 +0200
Subject: Created cs-cz folder, translated first part of Python3

---
 cs-cz/python3.html.markdown | 666 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 666 insertions(+)
 create mode 100644 cs-cz/python3.html.markdown

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
new file mode 100644
index 00000000..79f064c6
--- /dev/null
+++ b/cs-cz/python3.html.markdown
@@ -0,0 +1,666 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Tomáš Bedřich", "http://tbedrich.cz"]
+filename: learnpython3.py
+---
+
+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).
+
+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í 3x"
+    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žiteje 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
+0 == False  # => True
+2 == True   # => False
+1 == 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 UTF8 znaky
+"Toto je řetězec."
+'Toto je také řetězec.'
+
+# Řetězce se také dají sčítat, ale nepoužívejte to
+"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/slovník se vyhodnotí jako False
+# Vše ostatní se vyhodnotí jako True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+
+
+####################################################
+## 2. Variables and Collections
+####################################################
+
+# Python has a print function
+print("I'm Python. Nice to meet you!")
+
+# No need to declare variables before assigning to them.
+# Convention is to use lower_case_with_underscores
+some_var = 5
+some_var  # => 5
+
+# Accessing a previously unassigned variable is an exception.
+# See Control Flow to learn more about exception handling.
+some_unknown_var  # Raises a NameError
+
+# Lists store sequences
+li = []
+# You can start with a prefilled list
+other_li = [4, 5, 6]
+
+# Add stuff to the end of a list with append
+li.append(1)    # li is now [1]
+li.append(2)    # li is now [1, 2]
+li.append(4)    # li is now [1, 2, 4]
+li.append(3)    # li is now [1, 2, 4, 3]
+# Remove from the end with pop
+li.pop()        # => 3 and li is now [1, 2, 4]
+# Let's put it back
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# Access a list like you would any array
+li[0]  # => 1
+# Look at the last element
+li[-1]  # => 3
+
+# Looking out of bounds is an IndexError
+li[4]  # Raises an IndexError
+
+# You can look at ranges with slice syntax.
+# (It's a closed/open range for you mathy types.)
+li[1:3]  # => [2, 4]
+# Omit the beginning
+li[2:]  # => [4, 3]
+# Omit the end
+li[:3]  # => [1, 2, 4]
+# Select every second entry
+li[::2]   # =>[1, 4]
+# Return a reversed copy of the list
+li[::-1]   # => [3, 4, 2, 1]
+# Use any combination of these to make advanced slices
+# li[start:end:step]
+
+# Remove arbitrary elements from a list with "del"
+del li[2]   # li is now [1, 2, 3]
+
+# You can add lists
+# Note: values for li and for other_li are not modified.
+li + other_li   # => [1, 2, 3, 4, 5, 6]
+
+# Concatenate lists with "extend()"
+li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+
+# Check for existence in a list with "in"
+1 in li   # => True
+
+# Examine the length with "len()"
+len(li)   # => 6
+
+
+# Tuples are like lists but are immutable.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Raises a TypeError
+
+# You can do most of the list operations on tuples too
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# You can unpack tuples (or lists) into variables
+a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
+# Tuples are created by default if you leave out the parentheses
+d, e, f = 4, 5, 6
+# Now look how easy it is to swap two values
+e, d = d, e     # d is now 5 and e is now 4
+
+
+# Dictionaries store mappings
+empty_dict = {}
+# Here is a prefilled dictionary
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Look up values with []
+filled_dict["one"]   # => 1
+
+# Get all keys as an iterable with "keys()". We need to wrap the call in list()
+# to turn it into a list. We'll talk about those later.  Note - Dictionary key
+# ordering is not guaranteed. Your results might not match this exactly.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+
+
+# Get all values as an iterable with "values()". Once again we need to wrap it
+# in list() to get it out of the iterable. Note - Same as above regarding key
+# ordering.
+list(filled_dict.values())   # => [3, 2, 1]
+
+
+# Check for existence of keys in a dictionary with "in"
+"one" in filled_dict   # => True
+1 in filled_dict   # => False
+
+# Looking up a non-existing key is a KeyError
+filled_dict["four"]   # KeyError
+
+# Use "get()" method to avoid the KeyError
+filled_dict.get("one")   # => 1
+filled_dict.get("four")   # => None
+# The get method supports a default argument when the value is missing
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)   # => 4
+
+# "setdefault()" inserts into a dictionary only if the given key isn't present
+filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+
+# Adding to a dictionary
+filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  #another way to add to dict
+
+# Remove keys from a dictionary with del
+del filled_dict["one"]  # Removes the key "one" from filled dict
+
+
+# Sets store ... well sets
+empty_set = set()
+# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
+some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+
+# Can set new variables to a set
+filled_set = some_set
+
+# Add one more item to the set
+filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+
+# Do set intersection with &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# Do set union with |
+filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# Do set difference with -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# Check for existence in a set with in
+2 in filled_set   # => True
+10 in filled_set   # => False
+
+
+####################################################
+## 3. Control Flow and Iterables
+####################################################
+
+# Let's just make a variable
+some_var = 5
+
+# Here is an if statement. Indentation is significant in python!
+# prints "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # This elif clause is optional.
+    print("some_var is smaller than 10.")
+else:                  # This is optional too.
+    print("some_var is indeed 10.")
+
+
+"""
+For loops iterate over lists
+prints:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # You can use format() to interpolate formatted strings
+    print("{} is a mammal".format(animal))
+
+"""
+"range(number)" returns an iterable of numbers
+from zero to the given number
+prints:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(lower, upper)" returns an iterable of numbers
+from the lower number to the upper number
+prints:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+While loops go until a condition is no longer met.
+prints:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Shorthand for x = x + 1
+
+# Handle exceptions with a try/except block
+try:
+    # Use "raise" to raise an error
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+except (TypeError, NameError):
+    pass    # Multiple exceptions can be handled together, if required.
+else:   # Optional clause to the try/except block. Must follow all except blocks
+    print("All good!")   # Runs only if the code in try raises no exceptions
+finally:  #   Execute under all circumstances
+    print("We can clean up resources here")
+ 		 
+# Instead of try/finally to cleanup resources you can use a with statement
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python offers a fundamental abstraction called the Iterable.
+# An iterable is an object that can be treated as a sequence.
+# The object returned the range function, is an iterable.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => range(1,10). This is an object that implements our Iterable interface
+
+# We can loop over it.
+for i in our_iterable:
+    print(i)    # Prints one, two, three
+
+# However we cannot address elements by index.
+our_iterable[1]  # Raises a TypeError
+
+# An iterable is an object that knows how to create an iterator.
+our_iterator = iter(our_iterable)
+
+# Our iterator is an object that can remember the state as we traverse through it.
+# We get the next object with "next()".
+next(our_iterator)  # => "one"
+
+# It maintains state as we iterate.
+next(our_iterator)  # => "two"
+next(our_iterator)  # => "three"
+
+# After the iterator has returned all of its data, it gives you a StopIterator Exception
+next(our_iterator)  #  Raises StopIteration
+
+# You can grab all the elements of an iterator by calling list() on it.
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Functions
+####################################################
+
+# Use "def" to create new functions
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y    # Return values with a return statement
+
+# Calling functions with parameters
+add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+
+# Another way to call functions is with keyword arguments
+add(y=6, x=5)   # Keyword arguments can arrive in any order.
+
+# You can define functions that take a variable number of
+# positional arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+# You can define functions that take a variable number of
+# keyword arguments, as well
+def keyword_args(**kwargs):
+    return kwargs
+
+# Let's call it to see what happens
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# You can do both at once, if you like
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# When calling functions, you can do the opposite of args/kwargs!
+# Use * to expand tuples and use ** to expand kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Function Scope
+x = 5
+
+def setX(num):
+    # Local var x not the same as global variable x
+    x = num  # => 43
+    print (x)  # => 43
+
+def setGlobalX(num):
+    global x
+    print (x)  # => 5
+    x = num  #  global var x is now set to 6
+    print (x)  # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python has first class functions
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# There are also anonymous functions
+(lambda x: x > 2)(3)   # => True
+
+# TODO - Fix for iterables
+# There are built-in higher order functions
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# We can use list comprehensions for nice maps and filters
+# List comprehension stores the output as a list which can itself be a nested list
+[add_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]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# We subclass from object to get a class.
+class Human(object):
+
+    # A class attribute. It is shared by all instances of this class
+    species = "H. sapiens"
+
+    # Basic initializer, this is called when this class is instantiated.
+    # Note that the double leading and trailing underscores denote objects
+    # or attributes that are used by python but that live in user-controlled
+    # namespaces. Methods(or objects or attributes) like: __init__, __str__,
+    # __repr__ etc. are called magic methods (or sometimes called dunder methods)
+    # You should not invent such names on your own.
+    def __init__(self, name):
+        # Assign the argument to the instance's name attribute
+        self.name = name
+
+    # An instance method. All methods take "self" as the first argument
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # A class method is shared among all instances
+    # They are called with the calling class as the first argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # A static method is called without a class or instance reference
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantiate a class
+i = Human(name="Ian")
+print(i.say("hi"))     # prints out "Ian: hi"
+
+j = Human("Joel")
+print(j.say("hello"))  # prints out "Joel: hello"
+
+# Call our class method
+i.get_species()   # => "H. sapiens"
+
+# Change the shared attribute
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Call the static method
+Human.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# You can import modules
+import math
+print(math.sqrt(16))  # => 4
+
+# You can get specific functions from a module
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# You can import all functions from a module.
+# Warning: this is not recommended
+from math import *
+
+# You can shorten module names
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+
+# Python modules are just ordinary python files. You
+# can write your own, and import them. The name of the
+# module is the same as the name of the file.
+
+# You can find out which functions and attributes
+# defines a module.
+import math
+dir(math)
+
+
+####################################################
+## 7. Advanced
+####################################################
+
+# Generators help you make lazy code
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# A generator creates values on the fly.
+# Instead of generating and returning all values at once it creates one in each
+# iteration.  This means values bigger than 15 wont be processed in
+# double_numbers.
+# Note range is a generator too. Creating a list 1-900000000 would take lot of
+# time to be made
+# We use a trailing underscore in variable names when we want to use a name that
+# would normally collide with a python keyword
+range_ = range(1, 900000000)
+# will double all numbers until a result >=30 found
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decorators
+# in this example beg wraps say
+# Beg will call say. If say_please is True then it will change the returned
+# message
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+```
+
+## Ready For More?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From a074b33d29e7968a168c387a51c9a0c7f2748091 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Wed, 9 Sep 2015 13:53:03 +0200
Subject: Collections

---
 cs-cz/python3.html.markdown | 278 ++++++++++++++++++++++----------------------
 1 file changed, 137 insertions(+), 141 deletions(-)

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 79f064c6..68f9f597 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -9,7 +9,7 @@ translators:
 filename: learnpython3.py
 ---
 
-Python byl vytvořen Guidem Van Rossum v raných 90 letech. Nyní je jedním z nejpopulárnějších jazyků.
+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).
@@ -139,168 +139,164 @@ bool({})  # => False
 
 
 ####################################################
-## 2. Variables and Collections
+## 2. Proměnné a kolekce
 ####################################################
 
-# Python has a print function
-print("I'm Python. Nice to meet you!")
-
-# No need to declare variables before assigning to them.
-# Convention is to use lower_case_with_underscores
-some_var = 5
-some_var  # => 5
-
-# Accessing a previously unassigned variable is an exception.
-# See Control Flow to learn more about exception handling.
-some_unknown_var  # Raises a NameError
-
-# Lists store sequences
-li = []
-# You can start with a prefilled list
-other_li = [4, 5, 6]
-
-# Add stuff to the end of a list with append
-li.append(1)    # li is now [1]
-li.append(2)    # li is now [1, 2]
-li.append(4)    # li is now [1, 2, 4]
-li.append(3)    # li is now [1, 2, 4, 3]
-# Remove from the end with pop
-li.pop()        # => 3 and li is now [1, 2, 4]
-# Let's put it back
-li.append(3)    # li is now [1, 2, 4, 3] again.
-
-# Access a list like you would any array
-li[0]  # => 1
-# Look at the last element
-li[-1]  # => 3
-
-# Looking out of bounds is an IndexError
-li[4]  # Raises an IndexError
-
-# You can look at ranges with slice syntax.
-# (It's a closed/open range for you mathy types.)
-li[1:3]  # => [2, 4]
-# Omit the beginning
-li[2:]  # => [4, 3]
-# Omit the end
-li[:3]  # => [1, 2, 4]
-# Select every second entry
-li[::2]   # =>[1, 4]
-# Return a reversed copy of the list
-li[::-1]   # => [3, 4, 2, 1]
-# Use any combination of these to make advanced slices
-# li[start:end:step]
-
-# Remove arbitrary elements from a list with "del"
-del li[2]   # li is now [1, 2, 3]
-
-# You can add lists
-# Note: values for li and for other_li are not modified.
-li + other_li   # => [1, 2, 3, 4, 5, 6]
-
-# Concatenate lists with "extend()"
-li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
-
-# Check for existence in a list with "in"
-1 in li   # => True
-
-# Examine the length with "len()"
-len(li)   # => 6
-
-
-# Tuples are like lists but are immutable.
-tup = (1, 2, 3)
-tup[0]   # => 1
-tup[0] = 3  # Raises a TypeError
-
-# You can do most of the list operations on tuples too
-len(tup)   # => 3
-tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
-tup[:2]   # => (1, 2)
-2 in tup   # => True
-
-# You can unpack tuples (or lists) into variables
-a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
-# Tuples are created by default if you leave out the parentheses
+# 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
+
+# Přístup k předtím nepoužité 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 sčítat
+# 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
-# Now look how easy it is to swap two values
-e, d = d, e     # d is now 5 and e is now 4
-
-
-# Dictionaries store mappings
-empty_dict = {}
-# Here is a prefilled dictionary
-filled_dict = {"one": 1, "two": 2, "three": 3}
-
-# Look up values with []
-filled_dict["one"]   # => 1
+# Prohození proměnných je tak velmi snadné
+e, d = d, e     # d je nyní 5, e je nyní 4
 
-# Get all keys as an iterable with "keys()". We need to wrap the call in list()
-# to turn it into a list. We'll talk about those later.  Note - Dictionary key
-# ordering is not guaranteed. Your results might not match this exactly.
-list(filled_dict.keys())   # => ["three", "two", "one"]
 
+# Slovníky ukládají klíče a hodnoty
+prazdny_slovnik = {}
+# Lze je také rovnou naplnit
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
 
-# Get all values as an iterable with "values()". Once again we need to wrap it
-# in list() to get it out of the iterable. Note - Same as above regarding key
-# ordering.
-list(filled_dict.values())   # => [3, 2, 1]
+# Přistupovat k hodnotám lze pomocí []
+slovnik["jedna"] # => 1
 
+# Všechny klíče dostaneme pomocí keys() jako iterátor. Nyní ještě potřebujeme
+# obalit volání v list(), abychom dostali seznam. To rozebereme později.
+# Pozor, že jakékoliv pořadí klíčů není garantováno - může být různé.
+list(slovnik.keys())  # => ["dva", "jedna", "tři"]
 
-# Check for existence of keys in a dictionary with "in"
-"one" in filled_dict   # => True
-1 in filled_dict   # => False
+# Všechny hodnoty opět jako iterátor 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]
 
-# Looking up a non-existing key is a KeyError
-filled_dict["four"]   # KeyError
+# Operátorem in se lze dotázat na přítomnost klíče
+"jedna" in slovnik  # => True
+1 in slovnik        # => False
 
-# Use "get()" method to avoid the KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
-# The get method supports a default argument when the value is missing
-filled_dict.get("one", 4)   # => 1
-filled_dict.get("four", 4)   # => 4
+# Přístup k neexistujícímu klíči vyhodí KeyError
+slovnik["four"]  # Vyhodí KeyError
 
-# "setdefault()" inserts into a dictionary only if the given key isn't present
-filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
-filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+# 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
 
-# Adding to a dictionary
-filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4  #another way to add to dict
+# 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
 
-# Remove keys from a dictionary with del
-del filled_dict["one"]  # Removes the key "one" from filled dict
+# 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
 
-# Sets store ... well sets
-empty_set = set()
-# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
-some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
 
-# Can set new variables to a set
-filled_set = some_set
+# 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}
 
-# Add one more item to the set
-filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+# Přidání položky do množiny
+mnozina.add(5)   # mnozina je nyní {1, 2, 3, 4, 5}
 
-# Do set intersection with &
-other_set = {3, 4, 5, 6}
-filled_set & other_set   # => {3, 4, 5}
+# Průnik lze udělat pomocí operátoru &
+jina_mnozina = {3, 4, 5, 6}
+mnozina & jina_mnozina   # => {3, 4, 5}
 
-# Do set union with |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+# Sjednocení pomocí operátoru |
+mnozina | jina_mnozina   # => {1, 2, 3, 4, 5, 6}
 
-# Do set difference with -
+# Rozdíl pomocí operátoru -
 {1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
 
-# Check for existence in a set with in
-2 in filled_set   # => True
-10 in filled_set   # => False
+# Operátorem in se lze dotázat na přítomnost prvku v množině
+2 in mnozina   # => True
+10 in mnozina   # => False
 
 
 ####################################################
-## 3. Control Flow and Iterables
+## 3. Řízení toku a iterace
 ####################################################
 
 # Let's just make a variable
@@ -386,8 +382,8 @@ with open("myfile.txt") as f:
 # An iterable is an object that can be treated as a sequence.
 # The object returned the range function, is an iterable.
 
-filled_dict = {"one": 1, "two": 2, "three": 3}
-our_iterable = filled_dict.keys()
+slovnik = {"one": 1, "two": 2, "three": 3}
+our_iterable = slovnik.keys()
 print(our_iterable)  # => range(1,10). This is an object that implements our Iterable interface
 
 # We can loop over it.
@@ -412,7 +408,7 @@ next(our_iterator)  # => "three"
 next(our_iterator)  #  Raises StopIteration
 
 # You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+list(slovnik.keys())  # => Returns ["one", "two", "three"]
 
 
 ####################################################
-- 
cgit v1.2.3


From 49c579f350b200d3e6f170eb207c6bc081b4b0e2 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Wed, 9 Sep 2015 16:14:12 +0200
Subject: If, for, while, iterators

---
 cs-cz/python3.html.markdown | 166 ++++++++++++++++++++++----------------------
 1 file changed, 84 insertions(+), 82 deletions(-)

(limited to 'cs-cz/python3.html.markdown')

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


From f31f35a32e5774330d6f1989d74f97e3c18cd24f Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Wed, 9 Sep 2015 17:09:18 +0200
Subject: Functions

---
 cs-cz/python3.html.markdown | 130 ++++++++++++++++++++++----------------------
 1 file changed, 65 insertions(+), 65 deletions(-)

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 03fa2682..dc7ad34b 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -4,6 +4,7 @@ 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.py
@@ -20,7 +21,7 @@ Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit sta
 
 # Jednořádkový komentář začíná křížkem
 
-""" Víceřádkové komentáře používají 3x"
+""" 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
 """
 
@@ -417,97 +418,96 @@ next(iterator)  # Vyhodí StopIteration
 ## 4. Funkce
 ####################################################
 
-# Use "def" to create new functions
-def add(x, y):
-    print("x is {} and y is {}".format(x, y))
-    return x + y    # Return values with a return statement
+# Pro vytvoření nové funkce použijte def
+def secist(x, y):
+    print("x je {} a y je {}".format(x, y))
+    return x + y  # Hodnoty se vrací pomocí return
 
-# Calling functions with parameters
-add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+# Volání funkce s parametry
+secist(5, 6)  # => Vypíše "x je 5 a y je 6" a vrátí 11
 
-# Another way to call functions is with keyword arguments
-add(y=6, x=5)   # Keyword arguments can arrive in any order.
+# 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í
 
-# You can define functions that take a variable number of
-# positional arguments
-def varargs(*args):
-    return args
+# Lze definovat funkce s proměnným počtem (pozičních) argumentů
+def vrat_argumenty(*argumenty):
+    return argumenty
 
-varargs(1, 2, 3)   # => (1, 2, 3)
+vrat_argumenty(1, 2, 3)  # => (1, 2, 3)
 
-# You can define functions that take a variable number of
-# keyword arguments, as well
-def keyword_args(**kwargs):
-    return kwargs
+# Lze definovat také funkce s proměnným počtem pojmenovaných argumentů
+def vrat_pojmenovane_argumenty(**pojmenovane_argumenty):
+    return pojmenovane_argumenty
 
-# Let's call it to see what happens
-keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+vrat_pojmenovane_argumenty(kdo="se bojí", nesmi="do lesa")
+# => {"kdo": "se bojí", "nesmi": "do lesa"}
 
 
-# You can do both at once, if you like
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
-"""
-all_the_args(1, 2, a=3, b=4) prints:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
+# 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
 
-# When calling functions, you can do the opposite of args/kwargs!
-# Use * to expand tuples and use ** to expand kwargs.
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+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)
 
-# Function Scope
+
+# Viditelnost proměnných - vytvořme si globální proměnnou x
 x = 5
 
-def setX(num):
-    # Local var x not the same as global variable x
-    x = num  # => 43
-    print (x)  # => 43
+def nastavX(cislo):
+    # Lokální proměnná x překryje globální x
+    x = cislo  # => 43
+    print(x)  # => 43
 
-def setGlobalX(num):
+def nastavGlobalniX(cislo):
     global x
-    print (x)  # => 5
-    x = num  #  global var x is now set to 6
-    print (x)  # => 6
+    print(x)  # => 5
+    x = cislo  # Nastaví globální proměnnou x na 6
+    print(x)  # => 6
 
-setX(43)
-setGlobalX(6)
+nastavX(43)
+nastavGlobalX(6)
 
 
-# Python has first class functions
-def create_adder(x):
-    def adder(y):
-        return x + y
-    return adder
+# Funkce jsou first-class objekty
+def vyrobit_scitacku(pricitane_cislo):
+    def scitacka(x):
+        return x + pricitane_cislo
+    return scitacka
 
-add_10 = create_adder(10)
-add_10(3)   # => 13
+pricist_10 = vyrobit_scitacku(10)
+pricist_10(3)  # => 13
 
-# There are also anonymous functions
-(lambda x: x > 2)(3)   # => True
+# Klíčové slovo lambda vytvoří anonymní funkci
+(lambda parametr: parametr > 2)(3)  # => True
 
-# TODO - Fix for iterables
-# There are built-in higher order functions
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+# 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]
 
-# We can use list comprehensions for nice maps and filters
-# List comprehension stores the output as a list which can itself be a nested list
-[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+# 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. Classes
+## 5. Třídy
 ####################################################
 
-
 # We subclass from object to get a class.
 class Human(object):
 
-- 
cgit v1.2.3


From 7036c4a89c613c0dcd2a56a44c5f631e49c25ed4 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Wed, 9 Sep 2015 17:21:48 +0200
Subject: Fixed wrong info about iterators

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index dc7ad34b..9733215c 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -238,13 +238,13 @@ 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 iterátor. 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é.
+# 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 iterátor získáme pomocí values(). Opět tedy
-# potřebujeme použít list(), abychom dostali seznam. Stejně jako
+# 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]
 
@@ -327,7 +327,7 @@ for zvire in ["pes", "kočka", "myš"]:
     print("{} je savec".format(zvire))
 
 """
-range(cislo) vrací itarátor čísel od 0 do cislo
+range(cislo) vrací iterovatelný objekt čísel od 0 do cislo
 vypíše:
     0
     1
@@ -338,7 +338,7 @@ for i in range(4):
     print(i)
 
 """
-range(spodni_limit, horni_limit) vrací itarátor čísel mezi limity
+range(spodni_limit, horni_limit) vrací iterovatelný objekt čísel mezi limity
 vypíše:
     4
     5
-- 
cgit v1.2.3


From 61634fc32a4b9962062e890de98250aea8db3c24 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Wed, 9 Sep 2015 17:30:00 +0200
Subject: Added contact to myself and fixed contact to author

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 9733215c..e842321b 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -13,7 +13,8 @@ filename: learnpython3.py
 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).
+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/).
 
-- 
cgit v1.2.3


From 003db4af9b6d10d9737c28103a66c61887eb1c19 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Thu, 10 Sep 2015 18:14:25 +0200
Subject: Classes

---
 cs-cz/python3.html.markdown | 83 ++++++++++++++++++++++-----------------------
 1 file changed, 41 insertions(+), 42 deletions(-)

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index e842321b..0364b43d 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -509,59 +509,58 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])
 ## 5. Třídy
 ####################################################
 
-# We subclass from object to get a class.
-class Human(object):
-
-    # A class attribute. It is shared by all instances of this class
-    species = "H. sapiens"
-
-    # Basic initializer, this is called when this class is instantiated.
-    # Note that the double leading and trailing underscores denote objects
-    # or attributes that are used by python but that live in user-controlled
-    # namespaces. Methods(or objects or attributes) like: __init__, __str__,
-    # __repr__ etc. are called magic methods (or sometimes called dunder methods)
-    # You should not invent such names on your own.
-    def __init__(self, name):
-        # Assign the argument to the instance's name attribute
-        self.name = name
-
-    # An instance method. All methods take "self" as the first argument
-    def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
-
-    # A class method is shared among all instances
-    # They are called with the calling class as the first argument
+# 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 get_species(cls):
-        return cls.species
+    def vrat_druh(cls):
+        return cls.druh
 
-    # A static method is called without a class or instance reference
+    # Statická metoda je volána bez reference na třídu nebo instanci
     @staticmethod
-    def grunt():
-        return "*grunt*"
+    def odkaslej_si():
+        return "*ehm*"
 
 
-# Instantiate a class
-i = Human(name="Ian")
-print(i.say("hi"))     # prints out "Ian: hi"
+# 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"
 
-j = Human("Joel")
-print(j.say("hello"))  # prints out "Joel: hello"
+# Volání třídní metody
+d.vrat_druh()  # => "H. sapiens"
 
-# Call our class method
-i.get_species()   # => "H. sapiens"
+# Změna atributu třídy
+Clovek.druh = "H. neanderthalensis"
+d.vrat_druh()  # => "H. neanderthalensis"
+a.vrat_druh()  # => "H. neanderthalensis"
 
-# Change the shared attribute
-Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
-
-# Call the static method
-Human.grunt()   # => "*grunt*"
+# Volání statické metody
+Clovek.odkaslej_si()  # => "*ehm*"
 
 
 ####################################################
-## 6. Modules
+## 6. Moduly
 ####################################################
 
 # You can import modules
-- 
cgit v1.2.3


From 5335df886183da20e65c383ad54f3f755ff33f58 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Thu, 10 Sep 2015 18:21:27 +0200
Subject: Modules

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 0364b43d..a82ec146 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -563,29 +563,27 @@ Clovek.odkaslej_si()  # => "*ehm*"
 ## 6. Moduly
 ####################################################
 
-# You can import modules
+# Lze importovat moduly
 import math
 print(math.sqrt(16))  # => 4
 
-# You can get specific functions from a module
+# 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
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
 
-# You can import all functions from a module.
-# Warning: this is not recommended
+# Můžete také importovat všechny funkce z modulu, ale radši to nedělejte
 from math import *
 
-# You can shorten module names
+# Můžete si přejmenovat modul při jeho importu
 import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
+math.sqrt(16) == m.sqrt(16)  # => True
 
-# Python modules are just ordinary python files. You
-# can write your own, and import them. The name of the
-# module is the same as the name of the file.
+# 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
 
-# You can find out which functions and attributes
-# defines a module.
+# Funkcí dir() lze zjistit, co modul obsahuje
 import math
 dir(math)
 
-- 
cgit v1.2.3


From ea5866afc2a48fb4f047a120d1ebab160e74d40b Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Thu, 10 Sep 2015 18:53:10 +0200
Subject: Advanced

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index a82ec146..6d3a7f20 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -589,56 +589,44 @@ dir(math)
 
 
 ####################################################
-## 7. Advanced
+## 7. Pokročilé
 ####################################################
 
-# Generators help you make lazy code
-def double_numbers(iterable):
-    for i in iterable:
-        yield i + i
-
-# A generator creates values on the fly.
-# Instead of generating and returning all values at once it creates one in each
-# iteration.  This means values bigger than 15 wont be processed in
-# double_numbers.
-# Note range is a generator too. Creating a list 1-900000000 would take lot of
-# time to be made
-# We use a trailing underscore in variable names when we want to use a name that
-# would normally collide with a python keyword
-range_ = range(1, 900000000)
-# will double all numbers until a result >=30 found
-for i in double_numbers(range_):
-    print(i)
-    if i >= 30:
-        break
+# Generátory jsou funkce, které místo return obsahují yield
+def nasobicka_2(sekvence):
+    for i in sekvence:
+        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í.
 
-# Decorators
-# in this example beg wraps say
-# Beg will call say. If say_please is True then it will change the returned
-# message
-from functools import wraps
+# 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:
+        break
 
 
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Please! I am poor :(")
-        return msg
+# 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í.
 
-    return wrapper
+def nekolikrat(puvodni_funkce):
+    def opakovaci_funkce(*args, **kwargs):
+        for i in range(3):
+            puvodni_funkce(*args, **kwargs)
 
+    return opakovaci_funkce
 
-@beg
-def say(say_please=False):
-    msg = "Can you buy me a beer?"
-    return msg, say_please
 
+@nekolikrat
+def pozdrav(jmeno):
+    print("Měj se {}!".format(jmeno))
 
-print(say())  # Can you buy me a beer?
-print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+pozdrav("Pepo")  # Vypíše 3x: Měj se Pepo!
 ```
 
 ## Ready For More?
-- 
cgit v1.2.3


From babd2b59ffb007aa8f6e6a3254506401acf90bf4 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Thu, 10 Sep 2015 18:59:15 +0200
Subject: Footer

---
 cs-cz/python3.html.markdown | 21 +++------------------
 1 file changed, 3 insertions(+), 18 deletions(-)

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 6d3a7f20..cf9b03b6 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -629,22 +629,7 @@ def pozdrav(jmeno):
 pozdrav("Pepo")  # Vypíše 3x: Měj se Pepo!
 ```
 
-## Ready For More?
+## Co dál?
 
-### Free Online
-
-* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [The Official Docs](http://docs.python.org/3/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-* [Python Course](http://www.python-course.eu/index.php)
-* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
-
-### Dead Tree
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+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 f1a3493a6e60ad1a476e512337833a7849f99e70 Mon Sep 17 00:00:00 2001
From: Tomas Bedrich <ja@tbedrich.cz>
Date: Fri, 11 Sep 2015 14:47:32 +0200
Subject: Fixed minor errors

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index cf9b03b6..1f380f36 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -254,7 +254,7 @@ list(slovnik.values())  # => [3, 2, 1]
 1 in slovnik        # => False
 
 # Přístup k neexistujícímu klíči vyhodí KeyError
-slovnik["four"]  # Vyhodí KeyError
+slovnik["čtyři"]  # Vyhodí KeyError
 
 # Metoda get() funguje podobně jako [], ale vrátí None místo vyhození KeyError
 slovnik.get("jedna")   # => 1
@@ -475,7 +475,7 @@ def nastavGlobalniX(cislo):
     print(x)  # => 6
 
 nastavX(43)
-nastavGlobalX(6)
+nastavGlobalniX(6)
 
 
 # Funkce jsou first-class objekty
-- 
cgit v1.2.3


From 5254c21bbed437e1f91c9c78209da2b48d22ec8b Mon Sep 17 00:00:00 2001
From: Levi Bostian <levi.bostian@gmail.com>
Date: Thu, 1 Oct 2015 09:39:00 -0500
Subject: Add lang: to header of Python3 cs-cz file.

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

(limited to 'cs-cz/python3.html.markdown')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 1f380f36..11c8a654 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -8,6 +8,7 @@ contributors:
 translators:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
 filename: learnpython3.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ů.
-- 
cgit v1.2.3