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')

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')

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')

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')

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')

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')

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')

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')

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')

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')

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')

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')

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


From 6dabd9568d2a99e7bbc079d0466588bf68a42283 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Mon, 5 Oct 2015 10:15:07 +0200
Subject: Brainfuck cs_CZ translation

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

(limited to 'cs-cz')

diff --git a/cs-cz/brainfuck.html.markdown b/cs-cz/brainfuck.html.markdown
new file mode 100644
index 00000000..92424ecf
--- /dev/null
+++ b/cs-cz/brainfuck.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnbrainfuck.bf
+lang: cs-cz
+---
+
+Brainfuck (psaný bez kapitálek s vyjímkou začátku věty) je extrémně minimální 
+Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příkazů.
+
+Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
+
+Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule 
+a datovým ukazatelem na aktuální buňce.
+
+Můžeme využít těchto osm příkazů:
++ : Přičte k aktuální buňce jedničku.
+- : Odečte od aktuální buňky jedničku.
+> : Posune datový ukazatel na další buňku, která je napravo.
+< : Posune datový ukazatel na předchozí buňku, která je nalevo.
+. : Vytiskne ASCII hodnotu aktuální buňky (například 65 = 'A').
+, : Načte jeden znak do aktuální buňky.
+[ : Pokud je hodnota aktuální buňky nulová, přeskočí na buňku odpovídající ] .
+    Jinak skočí na další instrukci.
+] : Pokud je hodnota aktuální buňky nulova, přeskočí na další instrukci.
+    Jinak skočí zpět na instrukci odpovídající [ .
+
+[ a ] tak tvoří 'while' smyčku a tyto symboly musí tak být v páru.
+
+Pojďme se mrknout na některé brainfuck programy.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Tento program vypíše písmeno 'A' (v ASCII je to číslo 65). Nejdříve navýší 
+buňku #1 na hodnotu 6. Buňka #1 bude použita pro smyčku. Potom program vstoupí 
+do smyčky ([) a sníží hodnotu buňky #1 o jedničku. Ve smyčce zvýší hodnotu 
+buňky #2 desetkrát, vrátí ze zpět na buňku #1 a sníží její hodnotu o jedničku.
+Toto se stane šestkrát (je potřeba šestkrát snížit hodnotu buňky #1, aby byla 
+nulová a program přeskočil na konec cyklu označený znakem ].
+
+Na konci smyčky, kdy jsme na buňce #1 (která má hodnotu 0), tak má buňka #2 
+hodnotu 60. Přesuneme se na buňku #2 a pětkrát zvýšíme její hodnotu o jedničku 
+na hodnotu 65. Na konci vypíšeme hodnotu buňky #2 - 65, což je v ASCII znak 'A' 
+na terminálu.
+
+
+, [ > + < - ] > .
+
+Tento program přečte znak z uživatelského vstupu a zkopíruje ho do buňky #1.
+Poté začne smyčka - přesun na buňku #2, zvýšení hodnoty buňky #2 o jedničku,
+přesun zpět na buňku #1 a snížení její hodnoty o jedničku. Takto smyčka pokračuje
+do té doby, než je buňka #1 nulová a buňka #2 nabyde původní hodnotu buňky #1. 
+Protože jsme na buňce #1, přesuneme se na buňku #2 a vytiskneme její hodnotu 
+v ASCII.
+
+Je dobré vědět, že mezery jsou v programu uvedené pouze z důvodu čitelnosti. 
+Program je možné klidně zapsat i takto:
+
+,[>+<-]>.
+
+
+Nyní se podívejte na tento program a zkuste zjistit co dělá: 
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Tento program vezme dvě čísla ze vstupu a vynásobí je.
+
+Program nejdříve načte dvě vstupní hodnoty. Poté začíná smyčka řízená hodnotou
+v buňce #1 - přesun na buňku #2 a start druhé vnořené smyčky, která je řízená 
+hodnotou v buňce #2 a zvyšuje hodnotu v buňce #3. Nicméně je zde problém 
+kdy na konci vnitřní smyčky je v buňce #2 nula a smyčka by tak znovu 
+napokračovala. Vyřešíme to tak, že zvyšujeme o jedničku i buňku #4 a její 
+hodnotu poté překopírujeme do buňky #2. Na konci programu je v buňce #3 
+výsledek.
+```
+
+A to je brainbuck. Zase tak složitý není, co? Zkuste si nyní napsat nějaký
+vlastní brainfuck program a nebo interpretr v jiném jazyce, což není zase
+tak složité, ale pokud jste opravdový masochista, zkuste si naprogramovat
+interpretr jazyka brainfuck v jazyce... brainfuck :)
-- 
cgit v1.2.3


From 4d619e9b0fc4a061fa720b47b22068c8661e9be6 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Wed, 7 Oct 2015 10:22:08 +0200
Subject: [json/cs] JSON translation to cs_CZ

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

(limited to 'cs-cz')

diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
new file mode 100644
index 00000000..8a685524
--- /dev/null
+++ b/cs-cz/json.html.markdown
@@ -0,0 +1,63 @@
+---
+language: json
+filename: learnjson.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnjson.json
+lang: cs-cz
+---
+
+JSON je exterémně jednoduchý datově nezávislý formát a bude asi jeden z 
+nejjednodušších 'Learn X in Y Minutes' ze všech.
+
+JSON nemá ve své nejzákladnější podobě žádné komentáře, ale většina parserů 
+umí pracovat s komentáři ve stylu jazyka C (`//`, `/* */`). Pro tyto účely 
+však budeme používat 100% validní JSON bez komentářů. Pojďme se podívat na 
+syntaxi formátu JSON:
+
+```json
+{
+  "klic": "value",
+  
+  "hodnoty": "Musí být vždy uvozený v dvojitých uvozovkách",
+  "cisla": 0,
+  "retezce": "Hellø, wørld. Všechny unicode znaky jsou povolené, společně s \"escapováním\".",
+  "pravdivostni_hodnota": true,
+  "prazdna_hodnota": null,
+
+  "velke_cislo": 1.2e+100,
+
+  "objekt": {
+    "komentar": "Most of your structure will come from objects.",
+
+    "pole": [0, 1, 2, 3, "Pole nemusí být pouze homogenní.", 5],
+
+    "jiny_objekt": {
+      "comment": "Je povolené jakkoli hluboké zanoření."
+    }
+  },
+
+  "cokoli": [
+    {
+      "zdroje_drasliku": ["banány"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "alternativni_styl_zapisu": {
+    "komentar": "Mrkni se na toto!"
+  , "pozice_carky": "Na pozici čárky nezáleží - pokud je před hodnotou, ať už je kdekoli, tak je validní."
+  , "dalsi_komentar": "To je skvělé."
+  },
+
+  "to_bylo_rychle": "A tím jsme hotový. Nyní již víte vše, co může formát JSON nabídnout!"
+}
+```
-- 
cgit v1.2.3


From d2a8a7f161b70148c541326989d0c39f342217ad Mon Sep 17 00:00:00 2001
From: ScheRas <simon+github@scheras.eu>
Date: Wed, 14 Oct 2015 21:11:05 +0200
Subject: Fixed typo

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

(limited to 'cs-cz')

diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 11c8a654..6d2fd1eb 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -48,7 +48,7 @@ Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit sta
 -5 // 3      # => -2
 -5.0 // 3.0  # => -2.0
 
-# Pokud použiteje desetinné číslo, výsledek je jím také
+# Pokud použijete desetinné číslo, výsledek je jím také
 3 * 2.0  # => 6.0
 
 # Modulo
@@ -420,7 +420,7 @@ next(iterator)  # Vyhodí StopIteration
 ## 4. Funkce
 ####################################################
 
-# Pro vytvoření nové funkce použijte def
+# 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
@@ -520,7 +520,7 @@ class Clovek(object):
     # 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
+    # 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
-- 
cgit v1.2.3


From 0053fdbd2f479640e53282582f8393be44fba130 Mon Sep 17 00:00:00 2001
From: Michal Martinek <martinek8@gmail.com>
Date: Sat, 24 Oct 2015 19:42:34 +0200
Subject: Czech translation for Markdown

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

(limited to 'cs-cz')

diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
new file mode 100644
index 00000000..637f0ab6
--- /dev/null
+++ b/cs-cz/markdown.html.markdown
@@ -0,0 +1,258 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+filename: markdown.md
+---
+
+Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce čitelná
+a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
+dalších formátů)
+
+```markdown
+<!-- 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
+Markdownu, tak nemůžete používat syntaxi Markdownu uvnitř tohoto elementu. -->
+
+<!-- Markdown se také mírně liší v jednotlivých interpretacích parseru. Tento
+návod vás bude upozorňovat, které vlastnosti jsou obecné a které specifické pro
+konkrétní parser. -->
+
+<!-- Nadpisy -->
+<!-- Můžete vytvořit HTML elementy <h1> až <h6> jednoduše tak, že text předsadíte
+počtem křížků (#), podle toho jaké úrovně to má být nadpis -->
+# Toto je <h1>
+## Toto je <h2>
+### Toto je <h3>
+#### Toto je <h4>
+##### Toto je <h5>
+###### Toto je <h6>
+
+<!-- Markdown obsahuje taky dvě další cesty, jak udělat h1 a h2 -->
+Toto je h1
+==========
+
+Toto je h2
+----------
+
+<!-- Jednoduché stylování textu -->
+<!-- Pomocí markdownu můžete text jednoduše označit jako kurzívu či tučný -->
+
+*Tento text je kurzívou;*
+_Stejně jako tento._
+
+**Tento text je tučně**
+__Stejně jako tento.__
+
+***Tento text je obojí***
+**_Jako tento!_**
+*__A tento!__*
+
+<!-- Ve verzi Markdownu od Githubu, máme k dispozici taky prošktrnutí: -->
+
+~~Tento text je prošktrnutý.~~
+
+<!-- Odstavce jsou jedna nebo více řádek textu, oddělených jednou nebo více prázdnými řádky. -->
+
+Toto je odstavec. Píši odstavec, není to zábava?
+
+Teď jsem v odstavci 2.
+Jsem pořád v odstavci 2!
+
+
+Toto je odstavec 3.
+
+<!-- Chtěli jste někdy vložit znak <br /> tag? Můžete napsat na konec odstavce
+dvě nebo více mezer a potom začít nový odstavec. -->
+
+Tento odstavec končí dvěma mezerami.  
+
+Nad tímto odstavcem je  <br />!
+
+<!-- Blokové citace se dělají jednoduše pomocí znaku >. -->
+
+> Toto je bloková citace. Můžete dokonce
+> manuálně rozdělit řádky, a před každý vložit >, nebo nechat vaše řádky jakkoliv dlouhé, ať se zarovnají sami.
+> Nedělá to rozdíl, dokud začínáte vždy znakem >.
+
+> Můžu použít více než jednu
+>> odsazení?
+> Jak je to úhledné, že?
+
+<!-- Seznamy -->
+<!-- Nečíslovaný seznam můžete jednoduše udělat pomocí hvězdiček, plusů, nebo
+ pomlček -->
+
+* Položka
+* Položka
+* Jinná položka
+
+nebo
+
++ Položka
++ Položka
++ Další položka
+
+nebo
+
+- Položka
+- Položka
+- Další položka
+
+<!-- Číslovaný seznam se dělají pomocí čísla a . -->
+
+1. Položka jedna
+2. Položka dvě
+3. Položka tři
+
+<!-- Nemusíte dokonce psát čísla správně a markdown je zobrazi správně,
+     ale nemusí to být vždy dobrý nápad -->
+
+1. Položka jedna
+1. Položka dvě
+1. Položka tři
+<!-- (Toto zobrazí to samě, jako příklad nadtím.) -->
+
+<!-- Můžete také tvořit podseznamy -->
+
+1. Položka jedna
+2. Položka dvě
+3. Položka tři
+    * Podpoložka
+    * Podpoložka
+4. Položka čtyři
+
+<!-- Existují i zašktávací seznamy. Toto vytvoří HTML checkboxy. -->
+
+Boxy níže bez 'x' jsou nezašktrnuté checkboxy.
+- [ ] První úkol
+- [ ] Druhý úkol
+Tento box bude zašktrnutý
+- [x] Tento úkol byl dokončen
+
+<!-- Bloky ködu -->
+<!-- Můžete označit kód bloku (který používá <code> element) odsazením pomocí 4
+     mezer, nebo tabu -->
+
+    Toto je kód
+    Stejně jako toto
+
+<!-- Můžete dokonce přidat další 4 mezery nebo tab pro další odsazení -->
+
+    moje_pole.each do |i|
+        puts i
+    end
+
+<!-- Kód na řádku může být označen pomocí zpětných apostrofů ` -->
+
+Jan nevědel, jak se dělá `go_to()` funkce!
+
+<!-- V Markdownu od Githubu , můžete použít speciální syntaxi pro kód -->
+
+\`\`\`ruby <!-- vyjma zpětných lomítek, jenom ```ruby ! -->
+def neco
+    puts "Ahoj světe!"
+end
+\`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
+
+<!-- Text výše nepotřebuje odsazení a navíc Github použije zvýraznění označeného
+ jazyka. -->
+
+<!-- Horizontální čára (<hr />) -->
+<!-- Horizontální čára se jednoduše přidá pomocí 3 nebo více hvězdiček nebo pomlček
+s nebo bez mezer. -->
+
+***
+---
+- - -
+****************
+
+<!-- Odkazy -->
+<!-- Jedna z nejlepších věcí na Markdownu je, jak jednoduše se dělají odkazy.
+Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a je to. -->
+
+[Klikni na mě!](http://test.com/)
+
+<!-- Můžete také přidat jméno linku pomocí uvozovek -->
+
+[Klikni na mě!](http://test.com/ "Odkaz na Test.com")
+
+<!-- Relativní cesty fungují taky -->
+
+[Jdi na hudbu](/hudba/).
+
+<!-- Markdown taktéž podporuje reference odkazů. -->
+
+[Klikni na tento odkaz][link1] pro více informací!
+[Taky zkontrolujte tento odkaz][neco], když chcete.
+
+[link1]: http://test.com/ "Cool!"
+[neco]: http://neco.czz/ "Dobře!"
+
+<!-- Titulek může být v apostrofech nebo závorkách, nebo vyjmutý úplně. Reference
+ může být kdekoliv ve vašem dokumentu a identifikátor může být jakýkoliv, dokud
+ je unikátní.-->
+
+<!-- Také existuje "implicitní pojmenování", které použije text jako id -->
+
+[Toto][] je odkaz..
+
+[toto]: http://totojelink.cz/
+
+<!-- Ale toto není zrovna běžné užívané. -->
+
+<!-- Obrázky -->
+<!-- Obrázky se dělají stejně jako odkazy, ale s vykřičníkem na začátku -->
+
+![Toto je atribut alt pro obrázek](http://imgur.com/myimage.jpg "Nepovinný titulek")
+
+<!-- Reference fungují, jak bychom čekali-->
+
+![Toto je atribut alt][mujobrazek]
+
+[mujobrazek]: relativni/cesta/obrazek.jpg "a toto by byl titulek"
+
+<!-- Ostatní -->
+<!-- Automatické odkazy -->
+
+<http://stranka.cz/> je stejná jako
+[http://stranka.cz/](http://stranka.cz/)
+
+<!-- Automatické odkazy pro emaily-->
+
+<jmeno@prijmeni.cz>
+
+<!-- Escapování znaků -->
+
+Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
+
+<!-- Klávesové zkratky -->
+<!-- V Markdownu od Githubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
+
+Váš počítač přestal pracovat? Zkuste
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabulky -->
+<!-- Tabulky jsou povolené pouze v Markdownu od Githubu a jsou trochu podivně,
+     ale když je opravdu chcete: -->
+
+| Sloupec1     | Sloupec2 | Sloupec3      |
+| :----------- | :------: | ------------: |
+| Vlevo zarovn.| Na střed | Vpravo zarovn.|
+| blah         | blah     | blah          |
+
+<!-- nebo, to jde i taky: -->
+
+Sloupec 1 | Sloupec2 | Sloupec3
+:-- | :-: | --:
+Ohh toto je tak ošklivé | radši to | nedělejte
+
+<!-- Konec -->
+
+```
+
+Pro více informací, prozkoumejte oficiální článek o syntaxi od Johna Grubera
+ [zde](http://daringfireball.net/projects/markdown/syntax) a skvělý tahák od Adama Pritcharda [zde](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-- 
cgit v1.2.3


From d94d88cd2031b7322c2c2886fa54b26ef1c461be Mon Sep 17 00:00:00 2001
From: Michal Martinek <martinek8@gmail.com>
Date: Thu, 29 Oct 2015 19:21:48 +0100
Subject: Czech translation for Sass

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

(limited to 'cs-cz')

diff --git a/cs-cz/sass.html.markdown b/cs-cz/sass.html.markdown
new file mode 100644
index 00000000..e890debe
--- /dev/null
+++ b/cs-cz/sass.html.markdown
@@ -0,0 +1,439 @@
+---
+language: sass
+filename: learnsass.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+translators:
+  - ["Michal Martinek", "https://github.com/MichalMartinek"]
+
+---
+
+Sass je rozšíření jazyka CSS, který přidává nové vlastnosti jako proměnné, zanořování, mixiny a další.
+Sass (a další preprocesory, jako  [Less](http://lesscss.org/)) pomáhají vývojářům psát udržovatelný a neopakující (DRY) kód.
+
+Sass nabízí dvě možnosti syntaxe. SCSS, které je stejná jako CSS, akorát obsahuje nové vlastnosti Sassu. Nebo Sass, který používá odsazení místo složených závorek a středníků.
+Tento tutoriál bude používat syntaxi CSS.
+
+
+Pokud jste již obeznámeni s CSS3, budete schopni používat Sass relativně rychle. Nezprostředkovává nějaké úplně nové stylové možnosti, spíše nátroje, jak psát Vás CSS kód více efektivně, udržitelně a jednoduše.
+
+```scss
+
+
+//Jednořádkové komentáře jsou ze Sassu při kompilaci vymazány
+
+/*Víceřádkové komentáře jsou naopak zachovány */
+
+
+
+/*Proměnné
+==============================*/
+
+
+
+/* Můžete uložit CSS hodnotu (jako třeba barvu) do proměnné.
+Použijte symbol '$' k jejímu vytvoření. */
+
+$hlavni-barva: #A3A4FF;
+$sekundarni-barva: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Můžete používat proměnné napříč vaším souborem.
+Teď, když chcete změnit barvu, stačí ji změnit pouze jednou.*/
+
+body {
+	background-color: $hlavni-barva;
+	color: $sekundarni-barva;
+	font-family: $body-font;
+}
+
+/* Toto se zkompiluje do: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Toto je o hodně více praktické, než měnit každý výskyt barvy.  */
+
+
+
+/*Mixiny
+==============================*/
+
+
+
+/* Pokud zjistíte, že píšete kód pro více než jeden element, můžete jej uložit do mixinu.
+
+Použijte '@mixin' direktivu, plus jméno vašeho mixinu.*/
+
+@mixin na-stred {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Mixin vložíte pomocí '@include' a jména mixinu */
+
+div {
+	@include na-stred;
+	background-color: $hlavni-barva;
+}
+
+/*Což se zkompiluje do: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Můžete využít mixiny i třeba pro takovéto ušetření práce: */
+
+@mixin velikost($sirka, $vyska) {
+	width: $sirka;
+	height: $vyska;
+}
+
+/*Stačí vložit argumenty: */
+
+.obdelnik {
+	@include velikost(100px, 60px);
+}
+
+.ctverec {
+	@include velikost(40px, 40px);
+}
+
+/* Toto se zkompiluje do: */
+.obdelnik {
+  width: 100px;
+  height: 60px;
+}
+
+.ctverec {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/*Funkce
+==============================*/   
+
+
+
+/* Sass obsahuje funkce, které vám pomůžou splnit různé úkoly. */
+
+/* Funkce se spouštějí pomocí jejich jména, které následuje seznam argumentů uzavřený v kulatých závorkách. */
+body {
+  width: round(10.25px);    
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Se zkompiluje do: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}   
+
+/* Můžete také definovat vlastní funkce. Funkce jsou velmi podobné mixinům.
+   Když se snažíte vybrat mezi funkcí a mixinem, mějte na paměti, že mixiny
+   jsou lepší pro generování CSS kódu, zatímco funkce jsou lepší pro logiku.
+   Příklady ze sekce Matematické operátory jsou skvělí kandidáti na
+   znovupoužitelné funkce. */
+
+/* Tato funkce vrací poměr k velikosti rodiče v procentech.
+@function vypocitat-pomer($velikost, $velikost-rodice) {
+  @return $velikost / $velikost-rodice * 100%;
+}
+
+$hlavni obsah: vypocitat-pomer(600px, 960px);
+
+.hlavni-obsah {
+  width: $hlavni-obsah;
+}
+
+.sloupec {
+  width: vypocitat-pomer(300px, 960px);
+}
+
+/* Zkompiluje do: */
+
+.hlavni-obsah {
+  width: 62.5%;
+}
+
+.sloupec {
+  width: 31.25%;
+}
+
+
+
+/*Dědění
+==============================*/
+
+
+
+/*Dědění je způsob jak používat vlastnosti pro jeden selektor ve druhém. */
+
+.oznameni {
+	@include velikost(5em, 5em);
+	border: 5px solid $sekundarni-barva;
+}
+
+.oznameni-uspech {
+	@extend .oznameni;
+	border-color: #22df56;
+}
+
+/* Zkompiluje do: */
+.oznameni, .oznameni-uspech {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.oznameni-uspech {
+  border-color: #22df56;
+}
+
+
+/* Dědění CSS výrazů je preferováno před vytvořením mixinu kvůli způsobu,
+   jakým způsobem Sass dává dohromady třídy, které sdílejí stejný kód.
+   Kdyby to bylo udělané pomocí mixinu, tak výška, šířka, rámeček by byl v
+   každém výrazu, který by volal mixin. I když tohle neovlivní vaše workflow,
+   přidá to kód navíc do souborů. */
+
+
+/*Zanořování
+==============================*/
+
+
+
+/*Sass vám umožňuje zanořovat selektory do selektorů */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' nahradí rodičovský element. */
+/* Můžete také zanořovat pseudo třídy. */
+/* Pamatujte, že moc velké zanoření do hloubky snižuje čitelnost.
+   Doporučuje se používat maximálně trojité zanoření.
+   Na příklad: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Zkompiluje do: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/*Částečné soubory a importy
+==============================*/   
+
+
+
+/* Sass umožňuje vytvářet částečné soubory. Tyto soubory pomahájí udržovat váš
+   kód modulární. Tyto soubory by měli začínat vždy '_', např. _reset.css.
+   Částečné soubory se nepřevádí do CSS. */
+
+/* Toto je kód, který si uložíme do souboru _reset.css */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Sass obsahuje @import, které může být použit pro import částečných souborů.
+   Toto se liší od klasického CSS @import, který dělá HTTP požadavek na stáhnutí
+   souboru. Sass vezme importovaný soubor a vloží ho do kompilovaného kódu. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Zkompiluje do: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}   
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/*Zástupné selektory
+==============================*/  
+
+
+
+/* Zástupné selektory jsou užitečné, když vytváříte CSS výraz, ze kterého
+   chcete později dědit. Když chcete vytvořit výraz, ze kterého je možné pouze
+   dědit pomocí @extend, vytvořte zástupný selektor s CSS výrazem. Ten začíná
+   symbolem '%' místo '.' nebo '#'. Tyto výrazy se neobjeví ve výsledném CSS */
+
+%okno-obsahu {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.okno-zpravy {
+  @extend %okno-obsahu;
+  background-color: #0000ff;
+}
+
+/* Zkompiluje do: */
+
+.okno-zpravy {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.okno-zpravy {
+  background-color: #0000ff;
+}
+
+
+
+/*Matematické operace
+==============================*/   
+
+
+
+/* Sass obsahuje následující operátory: +, -, *, /, and %. Tyto operátory
+   můžou být velmi užitečné pro počítání hodnot přímo ve vašem souboru Sass.
+   Níže je příklad, jak udělat jednoduchý dvousloupcový layout. */
+
+$oblast-obsahu: 960px;
+$hlavni-obsah: 600px;
+$vedlejsi-sloupec: 300px;
+
+$obsah-velikost: $hlavni-obsah / $oblast-obsahu * 100%;
+$vedlejsi-sloupec-velikost: $vedlejsi-sloupec / $oblast-obsahu * 100%;
+$zbytek-velikost: 100% - ($main-size + $vedlejsi-sloupec-size);
+
+body {
+  width: 100%;
+}
+
+.hlavni-obsah {
+  width: $obsah-velikost;
+}
+
+.vedlejsi-sloupec {
+  width: $vedlejsi-sloupec-velikost;
+}
+
+.zbytek {
+  width: $zbytek-velikost;
+}
+
+/* Zkompiluje do: */
+
+body {
+  width: 100%;
+}
+
+.hlavni-obsah {
+  width: 62.5%;
+}
+
+.vedlejsi-sloupec {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+
+
+## SASS nebo Sass?
+Divili jste se někdy, jestli je Sass zkratka nebo ne? Pravděpodobně ne, ale řeknu vám to stejně. Jméno tohoto jazyka je slovo, "Sass", a ne zkratka.
+Protože to lidé konstatně píší jako "SASS", nazval ho autor jazyka jako "Syntactically Awesome StyleSheets" (Syntaktický úžasně styly).
+
+
+## Procvičování Sassu
+Pokud si chcete hrát se Sassem ve vašem prohlížeči, navštivte [SassMeister](http://sassmeister.com/).
+Můžete používát oba dva způsoby zápisu, stačí si vybrat v nastavení SCSS nebo SASS.
+
+
+## Kompatibilita
+
+Sass může být použit v jakémkoliv projektu, jakmile máte program, pomocí kterého ho zkompilujete do CSS. Pokud si chcete ověřit, že CSS, které Sass produkuje je kompatibilní s prohlížeči:
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) a [CanIUse](http://caniuse.com) jsou skvělé stránky pro kontrolu kompatibility.
+
+
+## Kam dál?
+* [Oficiální dokumentace](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) obsahuje tutoriál a řadu skvělých článků
-- 
cgit v1.2.3


From 7933ea3ce029a3418bac04210e0dd7f0f27e275d Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 21 Nov 2015 19:08:39 +0100
Subject: Applies a1ed02d6fad2b39137f52c6a04264a59e237d747 to translations

---
 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 6d2fd1eb..b498046a 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -566,7 +566,7 @@ Clovek.odkaslej_si()  # => "*ehm*"
 
 # Lze importovat moduly
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16.0))  # => 4
 
 # Lze také importovat pouze vybrané funkce z modulu
 from math import ceil, floor
-- 
cgit v1.2.3


From 38f2fb9a0bbd478bbbb4ccce0b33d1dcd34aa63a Mon Sep 17 00:00:00 2001
From: MichalMartinek <martinek8@gmail.com>
Date: Thu, 10 Dec 2015 22:45:40 +0100
Subject: Update sass.html.markdown

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

(limited to 'cs-cz')

diff --git a/cs-cz/sass.html.markdown b/cs-cz/sass.html.markdown
index e890debe..0d2fca64 100644
--- a/cs-cz/sass.html.markdown
+++ b/cs-cz/sass.html.markdown
@@ -1,12 +1,12 @@
 ---
 language: sass
-filename: learnsass.scss
+filename: learnsass-cz.scss
 contributors:
   - ["Laura Kyle", "https://github.com/LauraNK"]
   - ["Sean Corrales", "https://github.com/droidenator"]
 translators:
   - ["Michal Martinek", "https://github.com/MichalMartinek"]
-
+lang: cs-cz
 ---
 
 Sass je rozšíření jazyka CSS, který přidává nové vlastnosti jako proměnné, zanořování, mixiny a další.
-- 
cgit v1.2.3


From 442479a3c87d41fe1abf6ad344bb8733ef924fc8 Mon Sep 17 00:00:00 2001
From: Ondrej Simek <andrew@ondrejsimek.com>
Date: Thu, 17 Dec 2015 21:30:03 +0100
Subject: [markdown/cz] Fix missing 'lang' in front matter

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

(limited to 'cs-cz')

diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 637f0ab6..4cba38b4 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -5,6 +5,7 @@ contributors:
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
 filename: markdown.md
+lang: cs-cz
 ---
 
 Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce čitelná
-- 
cgit v1.2.3


From 8ad537a9ba9889234a63c5a38caeab3e225856e4 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 8 Jan 2016 14:35:16 +0800
Subject: unfuck markdown doc

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

(limited to 'cs-cz')

diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 637f0ab6..363af5e9 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: markdown
+lang: cs-cz
 contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
-- 
cgit v1.2.3


From 8d6d142e4afab0c6f9c3e27aef67bb82ac83587c Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Thu, 18 Feb 2016 19:18:35 -0800
Subject: Update markdown.html.markdown

---
 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 b5e5894f..0d44bc12 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
-filename: markdown.md
+filename: markdown-cz.md
 lang: cs-cz
 ---
 
-- 
cgit v1.2.3


From 484300f1db4509b08ed48526c61fcfcb48a6152b Mon Sep 17 00:00:00 2001
From: Zach Latta <zach@zachlatta.com>
Date: Tue, 23 Feb 2016 16:12:44 -0800
Subject: Fix capitalization of GitHub

---
 cs-cz/markdown.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'cs-cz')

diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 0d44bc12..568e4343 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -53,7 +53,7 @@ __Stejně jako tento.__
 **_Jako tento!_**
 *__A tento!__*
 
-<!-- Ve verzi Markdownu od Githubu, máme k dispozici taky prošktrnutí: -->
+<!-- Ve verzi Markdownu od GitHubu, máme k dispozici taky prošktrnutí: -->
 
 ~~Tento text je prošktrnutý.~~
 
@@ -152,7 +152,7 @@ Tento box bude zašktrnutý
 
 Jan nevědel, jak se dělá `go_to()` funkce!
 
-<!-- V Markdownu od Githubu , můžete použít speciální syntaxi pro kód -->
+<!-- V Markdownu od GitHubu , můžete použít speciální syntaxi pro kód -->
 
 \`\`\`ruby <!-- vyjma zpětných lomítek, jenom ```ruby ! -->
 def neco
@@ -160,7 +160,7 @@ def neco
 end
 \`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
 
-<!-- Text výše nepotřebuje odsazení a navíc Github použije zvýraznění označeného
+<!-- Text výše nepotřebuje odsazení a navíc GitHub použije zvýraznění označeného
  jazyka. -->
 
 <!-- Horizontální čára (<hr />) -->
@@ -232,13 +232,13 @@ Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a j
 Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
 
 <!-- Klávesové zkratky -->
-<!-- V Markdownu od Githubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
+<!-- V Markdownu od GitHubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
 
 Váš počítač přestal pracovat? Zkuste
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 
 <!-- Tabulky -->
-<!-- Tabulky jsou povolené pouze v Markdownu od Githubu a jsou trochu podivně,
+<!-- Tabulky jsou povolené pouze v Markdownu od GitHubu a jsou trochu podivně,
      ale když je opravdu chcete: -->
 
 | Sloupec1     | Sloupec2 | Sloupec3      |
-- 
cgit v1.2.3


From 1b0c8979824a797ffec3691ef345f66090ddb1c0 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Thu, 10 Mar 2016 23:05:24 +0100
Subject: Add a -cz suffix to the filename

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

(limited to 'cs-cz')

diff --git a/cs-cz/brainfuck.html.markdown b/cs-cz/brainfuck.html.markdown
index 92424ecf..29abc21f 100644
--- a/cs-cz/brainfuck.html.markdown
+++ b/cs-cz/brainfuck.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
-filename: learnbrainfuck.bf
+filename: learnbrainfuck-cz.bf
 lang: cs-cz
 ---
 
-- 
cgit v1.2.3


From 2e57c76561195431e09291378b934502483e3545 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Thu, 10 Mar 2016 23:06:40 +0100
Subject: Add a -cz suffix to the filename

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

(limited to 'cs-cz')

diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
index 8a685524..a566ee12 100644
--- a/cs-cz/json.html.markdown
+++ b/cs-cz/json.html.markdown
@@ -6,7 +6,7 @@ contributors:
   - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
     - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
-filename: learnjson.json
+filename: learnjson-cz.json
 lang: cs-cz
 ---
 
-- 
cgit v1.2.3


From cb83439fc964e1ff406f96f21f74626b487a8a41 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Fri, 11 Mar 2016 10:01:08 +0100
Subject: Fix duplicated attribute

---
 cs-cz/json.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
index a566ee12..5972da5e 100644
--- a/cs-cz/json.html.markdown
+++ b/cs-cz/json.html.markdown
@@ -1,6 +1,5 @@
 ---
 language: json
-filename: learnjson.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
-- 
cgit v1.2.3


From 81e3152c4a5a7b0ed120ba10e73827bdf3a50016 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Mon, 21 Mar 2016 16:31:18 -0700
Subject: Update python3.html.markdown

---
 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 b498046a..581ed3a3 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
 translators:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
-filename: learnpython3.py
+filename: learnpython3-cz.py
 lang: cs-cz
 ---
 
-- 
cgit v1.2.3


From f7e0953340fea2cd4831f4aab795333624c96e29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robin=20Pokorn=C3=BD?= <me@robinpokorny.com>
Date: Sun, 3 Apr 2016 14:47:59 +0200
Subject: Add Czech translation of Elm

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

(limited to 'cs-cz')

diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
new file mode 100644
index 00000000..26533c14
--- /dev/null
+++ b/cs-cz/elm.html.markdown
@@ -0,0 +1,373 @@
+---
+language: Elm
+contributors:
+    - ["Max Goldstein", "http://maxgoldste.in/"]
+translators:
+    - ["Robin Pokorný", "http://robinpokorny.com/"]
+filename: learnelm-cz.elm
+lang: cs-cz
+---
+
+Elm je funkcionální reaktivní jazyk, který se kompiluje do (klientského) JavaScriptu.
+Elm je silně typovaný, díky tomu je překladač schopen zachytit většinu chyb okamžitě a
+vypsat snadno srozumitelná chybová hlášení.
+Elm se hodí k tvorbě webových uživatelských rozhraní a her.
+
+
+```haskell
+-- Jednořádkové komentáře začínají dvěma pomlčkami.
+{- Víceřádkové komentáře mohou být takto uzavřeny do bloku.
+{- Mohou být i zanořeny. -}
+-}
+
+{-- Základy --}
+
+-- Aritmetika
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+
+-- Každý číselný literál bez desetinné tečky je typu Int nebo Float.
+33 / 2 -- 16.5 s reálným dělením
+33 // 2 -- 16 s celočíselným dělením
+
+-- Umocňování
+5 ^ 2 -- 25
+
+-- Logické proměnné
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Řetězce a znaky
+"Toto je textový řetězec, protože používá dvojité uvozovky."
+'a' -- znak v jednoduchých uvozovkách
+
+-- Řetězce lze spojovat.
+"Ahoj " ++ "světe!" -- "Ahoj světe!"
+
+{-- Seznamy (List), n-tice (Tuple) a Záznamy (Record) --}
+
+-- Každá položka seznamu musí být stejného typu.
+["příliš", "žluťoučký", "kůň", "úpěl"]
+[1, 2, 3, 4, 5]
+-- Druhý příklad lze také zapsat pomocí dvou teček.
+[1..5]
+
+-- Spojovat seznamy lze stejně jako řetězce.
+[1..5] ++ [6..10] == [1..10] -- True
+
+-- K přidání položky do seznamu použijte funkci "cons".
+0 :: [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 [] -- Nothing
+-- List.nazevFunkce odkazuje na funkci, která žije v modulu List.
+
+-- Každý prvek v n-tici může být jiného typu, ale n-tice má pevný počet prvků.
+("elm", 42)
+
+-- 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
+
+-- Prázná n-tice, neboli "unit", se občas používá jako placeholder.
+-- 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ží. 
+-- Povšimněte si, že hodnoty vlastností se přiřazují rovnítky, ne dvojtečkami.
+{ x = 3, y = 7 }
+
+-- K hodnotám se přistupuje pomocí tečky a názvu vlastnosti.
+{ x = 3, y = 7 }.x -- 3
+
+-- Nebo využitím přístupové funkce, což je jen tečka a název vlastnosti.
+.y { x = 3, y = 7 } -- 7
+
+-- Změna hodnoty vlastnosti v záznamu. (Záznam tuto vlastnost už musí mít.)
+{ osoba |
+  jmeno = "Jiří" }
+
+-- Změna více vlastností s využitím aktuálních hodnot.
+{ hmotnyBod |
+  poloha = hmotnyBod.poloha + hmotnyBod.rychlost,
+  rychlost = hmotnyBod.rychlost + hmotnyBod.zrychleni }
+
+{-- Řídicí struktury --}
+
+-- Podmínky vždy musí mít větev "else" a obě větve musí být stejného typu.
+if powerLevel > 9000 then
+  "PÁNI!"
+else
+  "hmm"
+
+-- Podmínky lze skládat za sebe.
+if n < 0 then
+  "n je záporné"
+else if n > 0 then
+  "n je kladné"
+else
+  "n je nula"
+
+-- Použíjte příkaz "case" k nalezení shody vzoru a různých možností.
+case seznam of
+  [] -> "odpovídá práznému seznamu"
+  [x]-> "odpovídá seznamu o právě jedné položce, " ++ toString x
+  x::xs -> "odpovídá seznamu o alespoň jedné položce, jehož prvním prvkem je " ++ toString x
+-- Shody se vyhodnocují v zapsaném pořadí. Kdybychom umístili [x] poslední, nikdy by nenastala shoda,
+-- protože x::xs také odpovídá  (xs by byl prázdný seznam). Shody "nepropadají".
+-- Překladač vždy upozorní na chybějící nebo přebývající větve.
+
+-- Větvení typu Maybe.
+case List.head seznam of
+  Just x -> "První položka je " ++ toString x
+  Nothing -> "Seznam byl prázdný."
+
+{-- Funkce --}
+
+-- Syntaxe funkcí je v Elmu velmi úsporná, založená spíše na mezerách
+-- než na závorkách. Neexistuje tu klíčové slovo "return".
+
+-- Funkci defunujeme jejím jménem, argumenty, rovnítkem a tělem.
+vynasob a b =
+  a * b
+
+-- Funkci voláme předáním argumentů (bez oddělujících čárek).
+vynasob 7 6 -- 42
+
+-- Částečně aplikované funkci předáme pouzne některé argumenty.
+-- Poté zvolíme nové jméno.
+zdvoj =
+  vynasob 2
+
+-- Konstanty jsou podobné, ale nepřijímají žádné argumenty.
+odpoved =
+  42
+
+-- Předejte funkci jako argument jiným funkcím.
+List.map zdvoj [1..4] -- [2, 4, 6, 8]
+
+-- Nebo použijte anonymní funkci.
+List.map (\a -> a * 2) [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 argumentů.
+obsah (sirka, delka) =
+  sirka * delka
+
+obsah (6, 7) -- 42
+
+-- Složenými závorkami vytvořte vzor pro názvy vlastností v záznamu.
+-- Použijte "let" k definici lokálních proměnných.
+objem {sirka, delka, hloubka} =
+  let
+    obsah = sirka * delka
+  in
+    obsah * hloubka
+
+objem { sirka = 3, delka = 2, hloubka = 7 } -- 42
+
+-- Funkce mohou být rekurzivní.
+fib n =
+  if n < 2 then
+    1
+  else
+    fib (n - 1) + fib (n - 2)
+
+List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+-- Jiná rekurzivní funkce (v praxi použijte List.length).
+delkaSeznamu seznam =
+  case seznam of
+    [] -> 0
+    x::xs -> 1 + delkaSeznamu xs
+
+-- Funkce se volají před jakýmkoli infixovým operátorem. Závorky určují prioritu.
+cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
+-- Nejprve se aplikuje "degrees" na číslo 30, výsledek je pak předán trigonometrickým
+-- funkcím, které jsou poté umocněny na druhou, na závěr proběhne sčítání.
+
+{-- Typy a typové anotace --}
+
+-- Překladač odvodí typ každé hodnoty ve vašem programu.
+-- Typy vždy začínají velkým písmenem. Čtete x : T jako "x je typu T".
+-- Některé běžné typy, které můžete videt v Elmovém REPLu.
+5 : Int
+6.7 : Float
+"ahoj" : String
+True : Bool
+
+-- Funkce mají také typy. Čtěte -> jako "vrací".
+-- O typu na konci uvažujte jako návratovém typu, o ostatních jako typech argumentů.
+not : Bool -> Bool
+round : Float -> Int
+
+-- Když definujete hodnotu je dobrým zvykem zapsat nad ní její typ.
+-- Anotace je formou dokumentace, která je ověřována překladačem.
+zdvoj : Int -> Int
+zdvoj x = x * 2
+
+-- Funkce jako argument je uzavřena v závorkách.
+-- Typy s malým počátečním písmenem jsou typové proměnné:
+-- mohou být libovolného typu, ale v každém volání musí být konzistetní.
+List.map : (a -> b) -> List a -> List b
+-- "List tečka map je typu a-vrací-b, vrací seznam-položek-typu-a, vrací seznam-položek-typu-b."
+
+-- Existují tři speciální typové proměnné:
+-- číslo (number), porovnatelné (comparable), and spojitelné (appendable).
+-- Čísla dovolují použít aritmetiku na Int a Float.
+-- Porovnatelné dovolují uspořádat čísla a řetězce, např. a < b.
+-- Spojitelné lze zřetězit pomocí a ++ b.
+
+{-- Typové aliasy a výčtové typy --}
+
+-- Pro záznamy a n-tice již typy automaticky existují.
+-- (Povšimněte si, že typ vlatnosti záznamu přiřazujeme dvojtečkou a hodnotu rovnítkem.)
+pocatek : { x : Float, y : Float, z : Float }
+pocatek =
+  { x = 0, y = 0, z = 0 }
+
+-- Stávajícím typům lze dávat jména využitím aliasů.
+type alias Bod3D =
+  { x : Float, y : Float, z : Float }
+
+-- Alias pro záznam funguje také jako jeho konstruktor.
+jinyPocatek : Bod3D
+jinyPocatek =
+  Bod3D 0 0 0
+
+-- Jedná se stále o stejný typ, lze je tedy porovnat.
+pocatek == jinyPocatek -- True
+
+-- Oproti tomu výčtový (union) typ definuje zcela nový typ.
+-- Výčtový typ se takto jmenuje, protože může být jedním z několika vybraných možností.
+-- Každá možnost je reprezentována jako "tag".
+type Smer =
+  Sever | Jih | Vychod | Zapad
+
+-- Tagy mohou obsahovat další hodnoty známých typů. Lze využít i rekurze.
+type IntStrom =
+  Vrchol | Uzel Int IntStrom IntStrom
+-- "Vrchol" i "Uzel" jsou tagy. Vše, co následuje za tagem, je typ.
+
+-- Tagy lze použít jako hodnoty funkcí.
+koren : IntStrom
+koren =
+  Vrchol 7 List List
+
+-- Výčtové typy (a typové aliasy) mohou obsahovat typové proměnné.
+type Strom a =
+  Vrchol | Uzel a (Strom a) (Strom a)
+-- "Typ strom-prvků-a je vrchol, nebo uzel obsahující a, strom-prvků-a a strom-prvků-a."
+
+-- Vzory se shodují s tagy. Tagy s velkým počátečním písmenem odpovídají přesně.
+-- Proměnné malým písmem odpovídají čemukoli. Podtržítko jaké odpovídá čemukoli,
+-- ale symbolizuje, že se nebude dále používat.
+nejviceVlevo : Strom a -> Maybe a
+nejviceVlevo strom =
+  case strom of
+    Vrchol -> Nothing
+    Uzel x Vrchol _ -> Just x
+    Uzel _ podstrom _ -> nejviceVlevo podstrom
+
+-- To je víceméně vše o jazyku samotném.
+-- Podívejme se nyní, jak organizovat a spouštět náš kód.
+
+{-- Moduly a importování --}
+
+-- Standardní knihovny jsou organizovány do modulů, stejně jako knihovny třetích stran,
+-- které můžete využívat. Ve větších projektech můžete definovat vlastní moduly.
+
+-- Vložte toto na začátek souboru. Pokud nic neuvedete, předpokládá se "Main".
+module Jmeno where
+
+-- Výchozím chováním je, že se exportuje vše.
+-- Případně můžete definovat exportované vlastnosti explicitně.
+module Jmeno (MujTyp, mojeHodnota) where
+
+-- Běžný návrhový vzor je expotovat pouze výčtový typ bez jeho tagů.
+-- Tento vzor je znám jako krycí typ a často se využívá v knihovnách.
+
+-- Z jiných modulů lze importovat kód a použít jej v aktuálním modulu.
+-- Nasledující umístí Dict do aktuálního scope, takže lze volat Dict.insert.
+import Dict
+
+-- Importuje modul Dict a typ Dict, takže v anotacích není nutné psát Dict.Dict.
+-- Stále lze volat Dict.insert.
+import Dict exposing (Dict)
+
+-- Přejmonování importu.
+import Graphics.Collage as C
+
+{-- Porty --}
+
+-- Port oznamuje, že budete komunikovat s vnějším světem.
+-- Porty jsou dovoleny pouze v modulu Main.
+
+-- Příchozí port je jen typová anotace.
+port idKlienta : Int
+
+-- Odchozí port má definici.
+port objednavkaKlienta : List String
+port objednavkaKlienta = ["Knihy", "Potraviny", "Nábytek"]
+
+-- Nebudeme zacházet do detailů, ale v JavaScriptu se dají nastavit
+-- callbacky pro zasílání na příchozí porty a čtení z odchozích portů.
+
+{-- Nástroje pro příkazovou řádku --}
+
+-- Kompilace souboru.
+$ elm make MujSoubor.elm
+
+-- Při prvním spuštění nainstaluje Elm standardní knihovny a vytvoří soubor
+-- elm-package.json, kde jsou uloženy informace o vašem projektu.
+
+-- Elm reactor je server, který překládá a spouští vaše soubory.
+-- Kliknutím na klíč vedle názvu souboru spustíte debugger s cestovám v čase!
+$ elm reactor
+
+-- Zkoušejte si jednoduché příkazy v Read-Eval-Print Loop.
+$ 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
+
+-- 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í, 
+-- takže minor verze nikdy nerozbije váš build.
+```
+
+Jazyk Elm je překvapivě malý. Nyní se můžete podívat do skoro jakéhokoli zdrojového kódu
+v Elmu a budete mít zběžnou představu o jeho fungování.
+Ovšem možnosti, jak psát kód, který je odolný vůči chybám a snadno se refaktoruje, jsou neomezené!
+
+Zde jsou některé užitečné zdroje (v angličtině).
+
+* [Hlavní stránka Elmu](http://elm-lang.org/). Obsahuje:
+  * Odkazy na [instalátory](http://elm-lang.org/install)
+  * [Documentaci](http://elm-lang.org/docs), včetně [popisu syntaxe](http://elm-lang.org/docs/syntax)
+  * Spoustu nápomocných [příkladů](http://elm-lang.org/examples)
+
+* Documentace pro [standardní knihovny Elmu](http://package.elm-lang.org/packages/elm-lang/core/latest/). Povšimněte si:
+  * [Základy](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), které jsou automaticky importovány
+  * Typ [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) a jeho bratranec typ [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), které se běžně používají pro chybějící hodnoty a ošetření chyb.
+  * Datové struktury jako [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) a [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
+  * JSON [enkódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) a [dekódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode)
+
+* [Architektura Elmu](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Esej od tvůrce Elmu s příklady, jak organizovat kód do komponent.
+
+* [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). Všichni jsou přátelští a nápomocní.
+
+* [Scope v Elmu](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) a [Jak číst typové anotace](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Další komunitní návody o základech Elmu, psáno pro JavaScriptové vývojáře.
+
+Běžte si zkusit něco napsat v Elmu!
-- 
cgit v1.2.3


From 1d15820b8f13a8b96f71d24265a8abd63f73966b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20=C5=BD=C3=A1ra?= <ondras@zarovi.cz>
Date: Mon, 4 Apr 2016 12:27:54 +0200
Subject: Update elm.html.markdown

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

(limited to 'cs-cz')

diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
index 26533c14..904507e2 100644
--- a/cs-cz/elm.html.markdown
+++ b/cs-cz/elm.html.markdown
@@ -27,14 +27,14 @@ Elm se hodí k tvorbě webových uživatelských rozhraní a her.
 8 - 1 -- 7
 10 * 2 -- 20
 
--- Každý číselný literál bez desetinné tečky je typu Int nebo Float.
+-- Každé číslo bez desetinné tečky je typu Int nebo Float.
 33 / 2 -- 16.5 s reálným dělením
 33 // 2 -- 16 s celočíselným dělením
 
 -- Umocňování
 5 ^ 2 -- 25
 
--- Logické proměnné
+-- Pravdivostní proměnné
 not True -- False
 not False -- True
 1 == 1 -- True
@@ -53,7 +53,7 @@ not False -- True
 -- Každá položka seznamu musí být stejného typu.
 ["příliš", "žluťoučký", "kůň", "úpěl"]
 [1, 2, 3, 4, 5]
--- Druhý příklad lze také zapsat pomocí dvou teček.
+-- Druhý příklad lze zapsat také pomocí dvou teček.
 [1..5]
 
 -- Spojovat seznamy lze stejně jako řetězce.
@@ -78,7 +78,7 @@ List.head [] -- Nothing
 fst ("elm", 42) -- "elm"
 snd ("elm", 42) -- 42
 
--- Prázná n-tice, neboli "unit", se občas používá jako placeholder.
+-- 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".
 ()
 
@@ -136,30 +136,30 @@ case List.head seznam of
 -- Syntaxe funkcí je v Elmu velmi úsporná, založená spíše na mezerách
 -- než na závorkách. Neexistuje tu klíčové slovo "return".
 
--- Funkci defunujeme jejím jménem, argumenty, rovnítkem a tělem.
+-- Funkci definujeme jejím jménem, parametry, rovnítkem a tělem.
 vynasob a b =
   a * b
 
--- Funkci voláme předáním argumentů (bez oddělujících čárek).
+-- Funkci voláme předáním parametrů (bez oddělujících čárek).
 vynasob 7 6 -- 42
 
--- Částečně aplikované funkci předáme pouzne některé argumenty.
+-- Částečně aplikované funkci předáme pouzne některé parametry.
 -- Poté zvolíme nové jméno.
 zdvoj =
   vynasob 2
 
--- Konstanty jsou podobné, ale nepřijímají žádné argumenty.
+-- Konstanty jsou podobné, ale nepřijímají žádné parametry.
 odpoved =
   42
 
--- Předejte funkci jako argument jiným funkcím.
+-- Předejte funkci jako parametr jiným funkcím.
 List.map zdvoj [1..4] -- [2, 4, 6, 8]
 
 -- Nebo použijte anonymní funkci.
 List.map (\a -> a * 2) [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 argumentů.
+-- Tato funkce přijímá jednu dvojici místo dvou parametrů.
 obsah (sirka, delka) =
   sirka * delka
 
@@ -193,7 +193,7 @@ delkaSeznamu seznam =
 -- Funkce se volají před jakýmkoli infixovým operátorem. Závorky určují prioritu.
 cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
 -- Nejprve se aplikuje "degrees" na číslo 30, výsledek je pak předán trigonometrickým
--- funkcím, které jsou poté umocněny na druhou, na závěr proběhne sčítání.
+-- funkcím, které jsou následně umocněny na druhou, na závěr proběhne sčítání.
 
 {-- Typy a typové anotace --}
 
@@ -205,19 +205,19 @@ cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
 "ahoj" : String
 True : Bool
 
--- Funkce mají také typy. Čtěte -> jako "vrací".
+-- Funkce mají také typy. Čtěte "->" jako "vrací".
 -- O typu na konci uvažujte jako návratovém typu, o ostatních jako typech argumentů.
 not : Bool -> Bool
 round : Float -> Int
 
--- Když definujete hodnotu je dobrým zvykem zapsat nad ní její typ.
+-- Když definujete hodnotu, je dobrým zvykem zapsat nad ni její typ.
 -- Anotace je formou dokumentace, která je ověřována překladačem.
 zdvoj : Int -> Int
 zdvoj x = x * 2
 
--- Funkce jako argument je uzavřena v závorkách.
+-- Funkce jako parametr je uzavřena v závorkách.
 -- Typy s malým počátečním písmenem jsou typové proměnné:
--- mohou být libovolného typu, ale v každém volání musí být konzistetní.
+-- mohou být libovolného typu, ale v každém volání musí být stejné.
 List.map : (a -> b) -> List a -> List b
 -- "List tečka map je typu a-vrací-b, vrací seznam-položek-typu-a, vrací seznam-položek-typu-b."
 
@@ -269,8 +269,8 @@ type Strom a =
 -- "Typ strom-prvků-a je vrchol, nebo uzel obsahující a, strom-prvků-a a strom-prvků-a."
 
 -- Vzory se shodují s tagy. Tagy s velkým počátečním písmenem odpovídají přesně.
--- Proměnné malým písmem odpovídají čemukoli. Podtržítko jaké odpovídá čemukoli,
--- ale symbolizuje, že se nebude dále používat.
+-- Proměnné malým písmem odpovídají čemukoli. Podtržítko také odpovídá čemukoli,
+-- ale určuje, že tuto hodnotu dále nechceme používat.
 nejviceVlevo : Strom a -> Maybe a
 nejviceVlevo strom =
   case strom of
@@ -304,7 +304,7 @@ import Dict
 -- Stále lze volat Dict.insert.
 import Dict exposing (Dict)
 
--- Přejmonování importu.
+-- Přejmenování importu.
 import Graphics.Collage as C
 
 {-- Porty --}
-- 
cgit v1.2.3


From 5ad3c1d9d197c1226b593bf4fa7243b33cf2e870 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robin=20Pokorn=C3=BD?= <me@robinpokorny.com>
Date: Tue, 5 Apr 2016 09:20:00 +0200
Subject: Fix typo

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

(limited to 'cs-cz')

diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
index 904507e2..babd46a2 100644
--- a/cs-cz/elm.html.markdown
+++ b/cs-cz/elm.html.markdown
@@ -143,7 +143,7 @@ vynasob a b =
 -- Funkci voláme předáním parametrů (bez oddělujících čárek).
 vynasob 7 6 -- 42
 
--- Částečně aplikované funkci předáme pouzne některé parametry.
+-- Částečně aplikované funkci předáme pouze některé parametry.
 -- Poté zvolíme nové jméno.
 zdvoj =
   vynasob 2
-- 
cgit v1.2.3


From 0edf991301fc4bafeda383649361c67f2f4e0235 Mon Sep 17 00:00:00 2001
From: Vojta Svoboda <vojtasvoboda.cz@gmail.com>
Date: Fri, 15 Apr 2016 12:08:55 +0200
Subject: [hack/cs] Add cs_CZ locale for Hack

* [hack/cs] Add cs_CZ locale for Hack

* Add -cs suffix

Add -cs suffix
---
 cs-cz/hack.html.markdown | 309 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 309 insertions(+)
 create mode 100644 cs-cz/hack.html.markdown

(limited to 'cs-cz')

diff --git a/cs-cz/hack.html.markdown b/cs-cz/hack.html.markdown
new file mode 100644
index 00000000..736ad7e0
--- /dev/null
+++ b/cs-cz/hack.html.markdown
@@ -0,0 +1,309 @@
+---
+language: Hack
+filename: learnhack-cs.hh
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+lang: cs-cz
+---
+
+Hack je nadmnožinou PHP a běží v rámci virtuálního stroje zvaného HHVM. Hack 
+dokáže skoro plně spolupracovat s existujícím PHP a přidává několik vylepšení, 
+které známe ze staticky typovaných jazyků.
+
+Níže jsou popsané pouze vlastnosti jazyka Hack. Detaily ohledně jazyka PHP a jeho
+syntaxe pak najdete na těchto stránkách v samostatném 
+[článku o PHP](http://learnxinyminutes.com/docs/php/).
+
+```php
+<?hh
+
+// Hack je aktivní pouze pro soubory, které začínají <?hh.
+// TODO <?hh soubory nemohou být jendoduše přeloženy v HTML tak jako <?php.
+// Použitím značky <?hh //strict zapnete striktní mód typové kontroly.
+
+
+// Typování skalární parametrů
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Typování návratových hodnot
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Funkce které nic nevrací jsou typované jako "void"
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// U typování musíme explicitně povolit prázdné (null) hodnoty
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Typování může být použito i na proměnné třídy
+class TypeHintedProperties
+{
+    public ?string $name;
+    
+    protected int $id;
+
+    private float $score = 100.0;
+
+    // Typ proměnné si můžeme zadat přímo u definice proměnné v rámci třídy,
+    // ale pak ho snadně přetížit v konstruktoru metody.
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Stručné anonymní funkce (lambda funkce)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Generika (generické funkce)
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Tvary
+// 
+// Hack zavádí koncept tvaru pro definování strukturovaných polí s garantovanou
+// typovou kontrolou pro klíče.
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Type aliasing
+// 
+// Hack přidává několik vylepšení pro lepší čitelnost komplexních typů
+newtype VectorArray = array<int, Vector<int>>;
+
+// Množina obsahující čísla
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Výčtový typ
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Automatické nastavení proměnných třídy
+// 
+// Aby se nemuseli definovat proměnné třídy a její konstruktor,
+// který pouze nastavuje třídní proměnné, můžeme v Hacku vše 
+// definovat najednou.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+// Takto by to vypadalo bez automatického nastavení proměnných
+class WithoutArugmentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Ko-operativní multi-tasking
+// 
+// Nová klíčová slova "async" and "await" mohou být použité pro spuštění mutli-taskingu
+// Tato vlastnost ovšem zahrnuje vícevláknové zpracování, pouze povolí řízení přenosu
+async function cooperativePrint(int $start, int $end) : Awaitable<void>
+{
+    for ($i = $start; $i <= $end; $i++) { 
+        echo "$i ";
+
+        // Dává ostatním úlohám šanci něco udělat
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Toto vypíše "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributy
+// 
+// Atributy jsou určitou formou metadat pro funkce. Hack přidává některé vestavěné 
+// atributy které aktivnují uživatečné chování funkcí.
+
+// Speciální atribut __Memoize způsobí, že výsledek funkce je uložen do cache
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Tělo funkce je v tomto případě vykonáno pouze jednou:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Speciální atribut __ConsistentConstruct signalizuje typové kontrole Hacku, že
+// zápis __construct bude stejný pro všechny podtřídy.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // Typová kontrola Hacku zajistí volání konstruktoru rodičovské třídy
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // Anotace __Override je volitelný signál pro typovou kontrolu Hacku, že
+    // tato metoda přetěžuje metodu rodičovské třídy, nebo traitu. Bez uvedení
+    // této anotace vyhodí typová kontrola chybu.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+    // Nedodržení zápisu dle rodičovského konstruktoru způsobí syntaktickou chybu:
+    //  
+    //  "Tento objekt je typu ConsistentBaz a není kompatibilní v tímto objektem,
+    //   který je typu ConsistentFoo protože některé jeho metody nejsou kompatibilní."
+    //
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Použitím anotace __Override na nepřetíženou metodu způsobí chybu typové kontroly:
+    //  
+    //  "InvalidFooSubclass::otherMethod() je označená jako přetížená, ale nebyla nalezena
+    //   taková rodičovská metoda, nebo rodič kterého přetěžujete není zapsán v <?hh kódu"
+    //
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+
+// Traity mohou implementovat rozhraní, což standardní PHP neumí
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Více informací
+
+Pro více informací navštivte [referenční příručku jazyka Hack](http://docs.hhvm.com/manual/en/hacklangref.php), 
+kde se dozvíte více detailu a vylepšení, které jazyk Hack přidává do PHP, a nebo navštivte [oficiální stránky jazyka Hack](http://hacklang.org/)
+pro obecné informace.
+
+Pro instrukce k instalaci jazyka Hack navštivte [oficiální HHVM stránky](http://hhvm.com/).
+
+Pro více informací ohledně zpětné kompatibility s PHP navštivte článek o [nepodporovaných PHP vlastnostech Hacku](http://docs.hhvm.com/manual/en/hack.unsupported.php).
-- 
cgit v1.2.3


From e0a5ad73538cb46637e7d66c88ea96b5ec8c10ff Mon Sep 17 00:00:00 2001
From: MichalMartinek <martinek8@gmail.com>
Date: Fri, 27 May 2016 11:24:07 +0200
Subject: Czech translation for CSS (#1771)

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

(limited to 'cs-cz')

diff --git a/cs-cz/css.html.markdown b/cs-cz/css.html.markdown
new file mode 100644
index 00000000..a86302f7
--- /dev/null
+++ b/cs-cz/css.html.markdown
@@ -0,0 +1,252 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+filename: learncss.css
+---
+
+V ranných dobách webu se nevyskytovaly žádné vizuální elementy, pouze čistý text, ale s vývojem webových browserů se staly stránky plné grafických prvků běžné.
+
+A právě proto vzniklo CSS, aby oddělilo obsah (HTML) od vzhledu webové stránky.
+
+Pomocí CSS můžete označit různé elementy na HTML stránce a přiřadit jim různé vzhledové vlastnosti.
+
+Tento návod byl napsán pro CSS 2, avšak CSS 3 se stalo velmi oblíbené a v dnešní době už běžné.
+
+**POZNÁMKA** Protože CSS produkuje vizuální výsledky, je nutné k jeho naučení všechno zkoušet třeba na [dabbletu](http://dabblet.com/).
+Tento článek se zaměřuje hlavně na syntaxi a poskytue také pár obecných tipů.
+
+```css
+/* komentáře jsou ohraničeny lomítkem s hvězdičkou, přesně jako tyto dva
+   řádky, v CSS není nic jako jednořádkový komentář, pouze tenhle zápis   */
+
+/* ################
+   ## SELEKTORY
+   ################ */
+
+/* Selektor se používá pro vybrání elementu na stránce:
+selektor { vlastnost: hodnota; /* více vlastností...  }*/
+
+/*
+Toto je náš element:
+<div trida='trida1 trida2' id='nejakeID' attr='hodnota' otherAttr='cs-cz co neco' />
+*/
+
+/* Můžeme vybrat tento element třeba podle jeho třídy */
+.trida1 { }
+
+/* nebo obou tříd! */
+.trida1.trida2 { }
+
+/* nebo jeho jména */
+div { }
+
+/* nebo jeho id */
+#nejakeID { }
+
+/* nebo podle toho, že má atribut! */
+[attr] { font-size:smaller; }
+
+/* nebo že argument nabývá specifické hodnoty*/
+[attr='hodnota'] { font-size:smaller; }
+
+/* začíná nějakou hodnotou (CSS 3) */
+[attr^='ho'] { font-size:smaller; }
+
+/* nebo končí něčím (CSS 3) */
+[attr$='ta'] { font-size:smaller; }
+
+/* nebo obsahuje nějakou hodnotu, která je v atributu oddělená mezerami */
+[otherAttr~='co'] { }
+[otherAttr~='neco'] { }
+
+/* nebo obsahuje hodnotu oddělenou pomlčkou - "-" (U+002D) */
+[otherAttr|='cs'] { font-size:smaller; }
+
+
+/* Můžeme spojit různé selektory, abychom získali specifičtější selektor.
+   Pozor, nedávejte mezi ně mezery! */
+div.nejaka-trida[attr$='ta'] { }
+
+/* Můžeme vybrat element, který je potomek jineho */
+div.vnejsi-element > .jmeno-tridy { }
+
+/* nebo zanořen ještě hlouběji. Potomci jsou přímo pod vnější třídou, pouze 1
+   úroveň pod rodičem. Tento selektor bude fungovat na jakékoliv úrovni pod
+   rodičem */
+div.rodic .jmeno-tridy { }
+
+/* Varování: stejný selektor bez mezery má úplně jiný význam
+   Vzpomínáte si jaký? */
+div.rodic.jmeno-tridy { }
+
+/* Možná budete chtít vybrat element, který leží přímo vedle */
+.jsem-primo-pred + .timto-elementem { }
+
+/* nebo kdekoliv na stejné úrovni stromu */
+.jsem-kdekoliv-pred ~ .timto-elementem { }
+
+/* Existují selektory nazvané pseudo třídy, kterými můžeme vybrat elementy,
+   když jsou v určitém stavu */
+
+/* na příklad, když kurzor najede na element */
+selektor:hover { }
+
+/* nebo již navštívený odkaz */
+selektor:visited { }
+
+/* nebo nebyl navštíven */
+selektor:link { }
+
+/* nebo když je vybrán, např kliknutím do inputu*/
+selektor:focus { }
+
+/* element, ktery je prvni potomek rodiče */
+selektor:first-child {}
+
+/* element, který je poslední potomek rodiče */
+selektor:last-child {}
+
+/* Stejně jako pseudo třídy, umožňují pseudo elementy stylizovat určité
+   části dokumentu */
+
+/* odpovídá virtuálnímu prvnímu potomku */
+selektor::before {}
+
+/* odpovídá virtuálnímu poslednímu potomku */
+selektor::after {}
+
+/* Na vhodném místě, může být použitá hvězdička jako žolík, který vybere každý element */
+* { } /* všechny elementy */
+.rodic * { } /* všechny vnořené elementy */
+.rodic > * { } /* všichni potomci */
+
+/* ####################
+   ## VLASTNOSTI
+   #################### */
+
+selektor {
+
+    /* Jednotky délky můžou být relativní nebo absolutní */
+
+    /* Relativní jednotky */
+    width: 50%;       /* počet procent šířky rodičovského elementu */
+    font-size: 2em;   /* násobek puvodní velikosti fontu elementu */
+    font-size: 2rem;  /* nebo kořenového elementu */
+    font-size: 2vw;   /* násobek 1% šířky zařízení (viewport) (CSS 3) */
+    font-size: 2vh;   /* nebo jeho výšky */
+    font-size: 2vmin; /* násobek 1% výšky nebo šířky, dle toho, co je menší */
+    font-size: 2vmax; /* nebo větší */
+
+    /* Absolutní jednotky */
+    width: 200px;     /* pixely */
+    font-size: 20pt;  /* body */
+    width: 5cm;       /* centimetry */
+    min-width: 50mm;  /* milimetry */
+    max-width: 5in;   /* palce */
+
+    /* Barvy */
+    color: #F6E;                 /* krátký hexadecimální formát */
+    color: #FF66EE;              /* dlouhý hexadecimální formát */
+    color: tomato;               /* pojmenovaná barva */
+    color: rgb(255, 255, 255);   /* hodnoty rgb */
+    color: rgb(10%, 20%, 50%);   /* procenta rgb */
+    color: rgba(255, 0, 0, 0.3); /* hodnoty rgba (CSS 3) Poznámka: 0 < a < 1 */
+    color: transparent;          /* ekvivalentní jako nastavení alfy 0 */
+    color: hsl(0, 100%, 50%);    /* procenta hsl (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* procenta hsl s alfou */
+
+    /* Obrázky jako pozadí elementu */
+    background-image: url(/cesta/k/obrazku.jpg); /* uvozovky jsou dobrovolné */
+
+    /* Fonty */
+    font-family: Arial;
+    /* když název fontu obsahuje mezeru, tak musí být v uvozovkách */
+    font-family: "Courier New";
+    /* když se první nenaleze, použije se další atd. */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Použití
+
+Uložte CSS soubor s příponou `.css`.
+
+```xml
+<!-- Musíte vložit css soubor do hlavičky vaší stránky. Toto je
+     doporučená metoda. Viz http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='cesta/k/stylu.css' />
+
+<!-- Také lze vložit CSS přímo do HTML. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Nebo přímo nastavit vlasnost elementu -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Priorita nebo kaskáda
+
+Element může být vybrán více selektory a jeho vlastnosti můžou být nastaveny více než jednou. V těchto případech, má jedno zadání vlastnosti prioritu před druhým. Obecně platí, že více specifické selektory mají přednost před těmi méně specifickými.
+
+Tento proces se nazývá kaskáda, proto i název kaskádové styly(Cascading Style Sheets).
+
+Máme následující CSS
+
+```css
+/* A */
+p.trida1[attr='hodnota']
+
+/* B */
+p.trida1 { }
+
+/* C */
+p.trida2 { }
+
+/* D */
+p { }
+
+/* E */
+p { vlastnost: hodnota !important; }
+```
+
+a tento element
+```xml
+<p style='/*F*/ vlastnost:hodnota;' trida='trida1 trida2' attr='hodnota' />
+```
+Priorita stylu je následující. Pamatujte, priorita pro každou **vlastnost**, ne pro celý blok.
+
+* `E` má nejvyšší prioritu kvůli slůvku `!important`. Je doporučováno se úplně vyhnout jeho použití.
+* `F` je další, kvůli stylu zadanému přimo do elementu
+* `A` je další, protože je více specifické, než cokoliv dalšího. Má 3 selektory: jméno elementu `p`, jeho třídu `trida1`, atribut `attr='hodnota'`.
+* `C` je další, i když je stejně specifický jako `B`, protože je uveden až po něm.
+* `B` je další
+* `D` je poslední
+
+## Kompatibilita
+
+Většina z možností v CSS 2 (a spousta v CSS 3) je dostupná napříč všemi browsery a zařízeními. Ale pořád je dobrá praxe, zkontrolovat dostupnost, před užitím nové vlastnosti/fičury.
+
+## Zdroje
+
+* Přehled dostupnosti [CanIUse](http://caniuse.com).
+* CSS hřiště [Dabblet](http://dabblet.com/).
+* [Mozilla Developer Network - CSS dokumentace](https://developer.mozilla.org/en-US/docs/Web/CSS)
+* [Codrops](http://tympanus.net/codrops/css_reference/)
+
+## Další čtení
+
+* [Pochopení priority v CSS: specifičnost, děditelnost a kaskáda](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Vybírání elementů pomocí atributů](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - překrývání obsahu](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) a [LESS](http://lesscss.org/) pro CSS pre-processing
+* [CSS-Triky](https://css-tricks.com)
-- 
cgit v1.2.3


From cdc8ff6e6cf1d14ec6cf4efd8820b46e64b8dc16 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Fri, 27 May 2016 11:24:54 +0200
Subject: Fix headers for cs-cz/css (#1771)

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

(limited to 'cs-cz')

diff --git a/cs-cz/css.html.markdown b/cs-cz/css.html.markdown
index a86302f7..54a0a08e 100644
--- a/cs-cz/css.html.markdown
+++ b/cs-cz/css.html.markdown
@@ -8,7 +8,8 @@ contributors:
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
-filename: learncss.css
+lang: cs-cz
+filename: learncss-cz.css
 ---
 
 V ranných dobách webu se nevyskytovaly žádné vizuální elementy, pouze čistý text, ale s vývojem webových browserů se staly stránky plné grafických prvků běžné.
-- 
cgit v1.2.3


From 9aea9445f2651e8cffb3831f452809e3ef5bb1dd Mon Sep 17 00:00:00 2001
From: MichalMartinek <martinek8@gmail.com>
Date: Fri, 27 May 2016 11:26:56 +0200
Subject: Czech translation for JS (#1773)

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

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
new file mode 100644
index 00000000..1adc2e89
--- /dev/null
+++ b/cs-cz/javascript.html.markdown
@@ -0,0 +1,550 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+filename: javascript.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 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).
+
+```js
+// Komentáře jsou jako v zayku C. 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í ;
+delejNeco();
+
+// ... ale nemusí, 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
+// středníky v našem návodu používat.
+
+/////////////////////////////////
+// 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¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Základní matematické operace fungují, jak byste očekávali
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Včetně dělení
+5 / 2; // = 2.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ů
+1 << 2; // = 4
+
+// Přednost se vynucuje závorkami.
+(1 + 3) * 2; // = 8
+
+// 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
+true; // pravda
+false; // nepravda
+
+// Řetězce znaků jsou obaleny  ' nebo ".
+'abc';
+"Ahoj světe!";
+
+// Negace se tvoří pomocí !
+!true; // = false
+!false; // = true
+
+// Rovnost se porovnává ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Nerovnost zase pomocí !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Další srovnávání
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Řetězce znaků se spojují pomocí +
+"Ahoj " + "světe!"; // = "Ahoj světe!"
+
+// a porovnávají se pomocí < nebo >
+"a" < "b"; // = true
+
+// Rovnost s převodem typů se dělá pomocí == ...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...dokud nepoužijete ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...což může občas způsobit divné chování...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// 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"
+
+// `length` znamená délka a je to vlastnost, takže nepoužívejte ()
+"Ahoj".length; // = 4
+
+// Existují také typy `null` a `undefined`.
+null;      // značí, že žádnou hodnotu
+undefined; // značí, že hodnota nebyla definovaná definovaná (ikdyž
+           // `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
+
+///////////////////////////////////
+// 2. Proměnné, pole a objekty
+
+// Proměnné jsou deklarovány pomocí slůvka `var`. JavaScript je dynamicky
+// typovaný, takže nemusíme specifikovat typ. K přiřazení hodnoty se používá
+// znak `=`.
+var promenna = 5;
+
+// 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
+
+// Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
+var dalsiPromenna; // = undefined
+
+// Existuje kratší forma pro matematické operace na proměnné
+promenna += 5; // se provede stejně jako promenna = promenna + 5;
+// promenna je ted 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];
+
+// 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");
+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
+// jazycích: je to neuspořádaná množina páru hodnot - klíč:hodnota.
+var mujObjekt = {klic1: "Ahoj", klic2: "světe"};
+
+// Klíče jsou řetězce, ale nejsou povinné uvozovky, pokud jsou validní
+// JavaScriptové 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
+
+// ... 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;
+
+// Pokud se snažíte přistoupit ke klíči, který není nastaven, dostanete undefined
+myObj.dalsiKlic; // = undefined
+
+///////////////////////////////////
+// 3. Řízení toku programu
+
+// Syntaxe pro tuto sekci je prakticky stejná jako pro Javu
+
+// `if` (když) funguje, jak byste čekali.
+var pocet = 1;
+if (pocet == 3){
+    // provede, když se pocet rovná 3
+} else if (pocet == 4){
+    // provede, když se pocet rovná 4
+} else {
+    // provede, když je pocet cokoliv jinného
+}
+
+// Stejně tak cyklus while
+while (true){
+    // nekonečný cyklus
+}
+
+// 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
+// inicializace; podmínka pro pokračování; iterace.
+for (var i = 0; i < 3; i++){
+    // provede třikrá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] + " ";
+}
+
+//Když chcete iterovat přes vlastnosti, které jsou přímo na objektu a nejsou
+//zděněné z prototypů, kontrolujte vlastnosti přes hasOwnProperty()
+var popis = "";
+var osoba = {prijmeni:"Jan", jmeno:"Novák", vek:18};
+for (var x in osoba){
+    if (osoba.hasOwnProperty(x)){
+        popis += osoba[x] + " ";
+    }
+}
+
+// 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í.
+
+// && je logické a, || je logické nebo
+if (dum.velikost == "velký" && dum.barva == "modrá"){
+    dum.obsahuje = "medvěd";
+}
+if (barva == "červená" || barva == "modrá"){
+    // barva je červená nebo modtrá
+}
+
+// && 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';
+switch (znamka) {
+  case 'A':
+    console.log("Výborná práce");
+    break;
+  case 'B':
+    console.log("Dobrá práce");
+    break;
+  case 'C':
+    console.log("Dokážeš to i lépe");
+    break;
+  default:
+    console.log("Ale ne");
+    break;
+}
+
+////////////////////////////////////////////////////////
+// 4. Funckce, Oblast platnosti (scope) a Vnitřní funkce
+
+// JavaScriptové funkce jsou definovány slůvkem `function`.
+function funkce(text){
+    return text.toUpperCase();
+}
+funkce("něco"); // = "NĚCO"
+
+// Dávejte si pozor na to, že hodnota k vrácení musí začínat na stejné řádce
+// 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()
+{
+    return // <- zde je automaticky vložen středník
+    {
+        tohleJe: "vlastnost objektu"
+    }
+}
+funkce(); // = undefined
+
+// JavaScriptové funkce jsou objekty, takže můžou být přiřazeny různým proměnným
+// a předány dalším funkcím jako argumenty, na příklad:
+function funkce(){
+    // tento kód bude zavolán za 5 vteřin
+}
+setTimeout(funkce, 5000);
+// Poznámka: setTimeout není část JS jazyka, ale funkce poskytována
+// prohlížeči a NodeJS
+
+// Objekty funkcí nemusíme ani deklarovat pomocí jména, můžeme je napsat jako
+// ananymní funkci přímo vloženou jako argument
+setTimeout(function(){
+  // tento kód bude zavolán za 5 vteřin    
+}, 5000);
+
+// JavaScript má oblast platnosti funkce, funkce ho mají, ale jiné bloky ne
+if (true){
+    var i = 5;
+}
+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
+//globální oblasti
+(function(){
+    var docasna = 5;
+    // Můžeme přistupovat k 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.
+    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čí
+function ahojPoPetiVterinach(jmeno){
+    var prompt = "Ahoj, " + jmeno + "!";
+    // Vnitřní funkce je dána do lokální oblasti platnosti, jako kdyby byla
+    // deklarovaná slůvkem 'var'
+    function vnitrni(){
+        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
+    // proměnné prompt, když je konečně zavolána.
+}
+ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
+
+///////////////////////////////////////////////////
+// 5. Více o objektech, konstuktorech a prototypech
+
+// Objekty můžou obsahovat funkce
+var mujObjekt = {
+    mojeFunkce: function(){
+        return "Ahoj světe!";
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Když jsou funkce z objektu zavolány, můžou přistupovat k objektu přes slůvko
+// 'this''
+var mujObjekt = {
+    text: "Ahoj světe!",
+    mojeFunkce: function(){
+        return this.text;
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// 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.
+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-
+var mojeDalsiFunkce = function(){
+    return this.text.toUpperCase();
+}
+mujObjekt.mojeDalsiFunkce = mojeDalsiFunkce;
+mujObjekt.mojeDalsiFunkce(); // = "AHOJ SVĚTE!"
+
+// 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!"
+
+// 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!"
+
+// To je praktické, když pracujete s funkcí, která bere sekvenci argumentů a
+// chcete předat pole.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Ale `call` a `apply` jsou pouze dočasné. Pokud je chcete připojit trvale
+// použijte `bind`.
+
+var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
+pripojenaFunkce(" A ahoj Saturne!"); // = "Ahoj světe! A ahoj Saturne!"
+
+// `bind` může být použito čatečně částečně i k používání
+
+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
+
+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.
+
+// 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.
+var mujObjekt = {
+    mujText: "Ahoj svete!"
+};
+var mujPrototyp = {
+    smyslZivota: 42,
+    mojeFunkce: function(){
+        return this.mujText.toLowerCase()
+    }
+};
+
+mujObjekt.__proto__ = mujPrototyp;
+mujObjekt.smyslZivota; // = 42
+
+// Toto funguje i pro funkce
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Samozřejmě, pokud není vlastnost na vašem prototypu, tak se hledá na
+// prototypu od prototypu atd.
+mujPrototyp.__proto__ = {
+    mujBoolean: true
+};
+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
+mujPrototyp.smyslZivota = 43;
+mujObjekt.smyslZivota // = 43
+
+// 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
+
+// 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
+
+// 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 = {
+    mojeCislo: 5,
+    ziskejMojeCislo: function(){
+        return this.mojeCislo;
+    }
+};
+var mujObjekt2 = new MujKonstruktor();
+mujObjekt2.ziskejMojeCislo(); // = 5
+mujObjekt2.mojeCislo = 6
+mujObjekt2.ziskejMojeCislo(); // = 6
+
+// Vestavěnné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
+// ekvivalentní obalovací objekty (wrappery).
+var mojeCislo = 12;
+var mojeCisloObj = new Number(12);
+mojeCislo == mojeCisloObj; // = true
+
+// Avšak nejsou úplně přesně stejné
+typeof mojeCislo; // = 'number'
+typeof mojeCisloObj; // = 'object'
+mojeCislo === mojeCisloObj; // = false
+if (0){
+    // Tento kód se nespustí, protože 0 je nepravdivá (false)
+}
+
+// Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
+// můžete přidat funkcionalitu k řetězci
+String.prototype.prvniZnak = function(){
+    return this.charAt(0);
+}
+"abc".prvniZnak(); // = "a"
+
+// 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
+
+// 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
+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
+        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.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+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)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) je varianta tohoto
+návodu i s úkoly-
+
+[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: 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, 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.
-- 
cgit v1.2.3


From 1288ddaac3e8ed928deee7cc73694503e34191c5 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Fri, 27 May 2016 11:27:36 +0200
Subject: Fix cs-cz/javascript headers (#1773)

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

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index 1adc2e89..0b053595 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -5,7 +5,8 @@ contributors:
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
-filename: javascript.js
+lang: cs-cz
+filename: javascript-cz.js
 ---
 
 JavaScript byl vytvořen Brendan Eichem v roce 1995 pro Netscape. Byl původně
-- 
cgit v1.2.3


From c6bfd82aa098ed8ef0c4d78e925f14a589940d59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Roun?= <tomas.roun@seznam.cz>
Date: Tue, 23 Aug 2016 21:36:57 +0200
Subject: added missing modulo division (#2339)

---
 cs-cz/javascript.html.markdown | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index 0b053595..b4596c40 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -1,4 +1,4 @@
----
+---
 language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
@@ -59,6 +59,11 @@ delejNeco()
 // Včetně dělení
 5 / 2; // = 2.5
 
+// A také dělení modulo
+10 % 2; // = 0
+30 % 4; // = 2
+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ů
 1 << 2; // = 4
-- 
cgit v1.2.3


From 6996dcf3e3304a60655fea1968ce0ee90d3eff77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Roun?= <rountoma@fel.cvut.cz>
Date: Wed, 24 Aug 2016 18:49:07 +0200
Subject: added missing js examples for czech translation

---
 cs-cz/javascript.html.markdown | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

(limited to 'cs-cz')

diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index b4596c40..e781db3e 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -105,6 +105,10 @@ false; // nepravda
 // Řetězce znaků se spojují pomocí +
 "Ahoj " + "světe!"; // = "Ahoj světe!"
 
+// ... což funguje nejenom s řetězci
+"1, 2, " + 3; // = "1, 2, 3"
+"Ahoj " + ["světe", "!"] // = "Ahoj světe,!"
+
 // a porovnávají se pomocí < nebo >
 "a" < "b"; // = true
 
@@ -131,7 +135,7 @@ null === undefined; // = false
 
 // Existují také typy `null` a `undefined`.
 null;      // značí, že žádnou hodnotu
-undefined; // značí, že hodnota nebyla definovaná definovaná (ikdyž
+undefined; // značí, že hodnota nebyla definovaná (ikdyž
            // `undefined` je hodnota sama o sobě)
 
 // false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
@@ -156,6 +160,9 @@ jinaPromenna = 10;
 // Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
 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é
 promenna += 5; // se provede stejně jako promenna = promenna + 5;
 // promenna je ted 10
@@ -313,6 +320,12 @@ setTimeout(funkce, 5000);
 // Poznámka: setTimeout není část JS jazyka, ale funkce poskytována
 // prohlížeči a NodeJS
 
+// Další funkce poskytovaná prohlížeči je je setInterval
+function myFunction(){
+    // tento kód bude volán každých 5 vteřin
+}
+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
 setTimeout(function(){
@@ -503,6 +516,11 @@ if (0){
     // Tento kód se nespustí, protože 0 je nepravdivá (false)
 }
 
+if (new Number(0)){
+   // Tento kód se spustí, protože obalená čísla jsou objekty,
+   // a objekty jsou vždy pravdivé
+}
+
 // Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
 // můžete přidat funkcionalitu k řetězci
 String.prototype.prvniZnak = function(){
-- 
cgit v1.2.3


From 30e5ceed3174347d675b5eb9a474c960e1542d44 Mon Sep 17 00:00:00 2001
From: Ondrej Linek <ondrej.linek@gmail.com>
Date: Mon, 5 Sep 2016 22:19:17 +0200
Subject: add Czech [cs-cz] translation of the Go intro. (#2357)

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

(limited to 'cs-cz')

diff --git a/cs-cz/go.html.markdown b/cs-cz/go.html.markdown
new file mode 100644
index 00000000..f814d2da
--- /dev/null
+++ b/cs-cz/go.html.markdown
@@ -0,0 +1,431 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+translators:
+    - ["Ondra Linek", "https://github.com/defectus/"]
+
+---
+
+Jazyk Go byl vytvořen, jelikož bylo potřeba dokončit práci. Není to poslední 
+trend ve světě počítačové vědy, ale je to nejrychlejší a nejnovější způsob,
+jak řešit realné problémy.
+
+Go používá známé koncepty imperativních jazyků se statickým typováním.
+Rychle se kompiluje a také rychle běží. Přidává snadno pochopitelnou
+podporu konkurenčnosti, což umožňuje využít výhody multi-core procesorů a
+jazyk také obsahuje utility, které pomáhají se škálovatelným programováním.
+
+Go má již v základu vynikající knihovnu a je s ním spojená nadšená komunita.
+
+```go
+// Jednořádkový komentář
+/* Několika
+ řádkový komentář */
+
+// Každý zdroják začíná deklarací balíčku (package)
+// Main je vyhrazené jméno, které označuje spustitelný soubor,
+// narozdíl od knihovny
+package main
+
+// Importní deklarace říkají, které knihovny budou použity v tomto souboru.
+import (
+	"fmt"       // Obsahuje formátovací funkce a tisk na konzolu
+	"io/ioutil" // Vstupně/výstupní funkce
+	m "math"    // Odkaz na knihovnu math (matematické funkce) pod zkratkou m
+	"net/http"  // Podpora http protokolu, klient i server.
+	"strconv"   // Konverze řetězců, např. na čísla a zpět.
+)
+
+// Definice funkce. Funkce main je zvláštní, je to vstupní bod do programu.
+// Ať se vám to líbí, nebo ne, Go používá složené závorky
+func main() {
+	// Println vypisuje na stdout.
+	// Musí být kvalifikováno jménem svého balíčko, ftm.
+	fmt.Println("Hello world!")
+
+	// Zavoláme další funkci
+	svetPoHello()
+}
+
+// Funkce mají své parametry v závorkách
+// Pokud funkce nemá parametry, tak musíme stejně závorky uvést.
+func svetPoHello() {
+	var x int // Deklarace proměnné. Proměnné musí být před použitím deklarované
+	x = 3     // Přiřazení hodnoty do proměnné
+	// Existuje "krátká" deklarace := kde se typ proměnné odvodí, 
+	// proměnná vytvoří a přiřadí se jí hodnota
+	y := 4
+	sum, prod := naucSeNasobit(x, y)        // Funkce mohou vracet více hodnot
+	fmt.Println("sum:", sum, "prod:", prod) // Jednoduchý výstup
+	naucSeTypy()                            // < y minut je za námi, je čas učit se víc!
+}
+
+/* <- začátek mnohořádkového komentáře
+Funkce mohou mít parametry a (několik) návratových hodnot.
+V tomto případě jsou `x`, `y` parametry a `sum`, `prod` jsou návratové hodnoty.
+Všiměte si, že `x` a `sum` jsou typu `int`.
+*/
+func naucSeNasobit(x, y int) (sum, prod int) {
+	return x + y, x * y // Vracíme dvě hodnoty
+}
+
+// zabudované typy a literáty.
+func naucSeTypy() {
+	// Krátká deklarace většinou funguje
+	str := "Learn Go!" // typ řetězec.
+
+	s2 := `"surový" literát řetězce
+může obsahovat nové řádky` // Opět typ řetězec.
+
+	// Můžeme použít ne ASCII znaky, Go používá UTF-8.
+	g := 'Σ' // type runa, což je alias na int32 a ukládá se do něj znak UTF-8
+
+	f := 3.14195 // float64, je IEEE-754 64-bit číslem s plovoucí čárkou.
+	c := 3 + 4i  // complex128, interně uložené jako dva float64.
+
+	// takhle vypadá var s inicializací
+	var u uint = 7 // Číslo bez znaménka, jehož velikost záleží na implementaci,
+	               // stejně jako int
+	var pi float32 = 22. / 7
+
+	// takto se převádí typy za pomoci krátké syntaxe
+	n := byte('\n') // byte je jiné jméno pro uint8.
+
+	// Pole mají fixní délku, které se určuje v době kompilace.
+	var a4 [4]int           // Pole 4 intů, všechny nastaveny na 0.
+	a3 := [...]int{3, 1, 5} // Pole nastaveno na tři hodnoty
+	// elementy mají hodntu 3, 1 a 5
+
+	// Slicy mají dynamickou velikost. Pole i slacy mají své výhody,
+	// ale většinou se používají slicy.
+	s3 := []int{4, 5, 9}    // Podobně jako a3, ale není tu výpustka.
+	s4 := make([]int, 4)    // Alokuj slice 4 intů, všechny nastaveny na 0.
+	var d2 [][]float64      // Deklarace slicu, nic se nealokuje.
+	bs := []byte("a slice") // Přetypování na slice
+
+	// Protože jsou dynamické, můžeme ke slicům přidávat za běhu
+	// Přidat ke slicu můžeme pomocí zabudované funkce append().
+	// Prvním parametrem je slice, návratová hodnota je aktualizovaný slice.
+	s := []int{1, 2, 3}		// Výsledkem je slice se 3 elementy.
+	s = append(s, 4, 5, 6)	// Přidány další 3 elementy. Slice má teď velikost 6.
+	fmt.Println(s) // Slice má hodnoty [1 2 3 4 5 6]
+
+	// Pokud chceme k poli přičíst jiné pole, můžeme předat referenci na slice,
+	// nebo jeho literát a přidat výpustku, čímž se slicu "rozbalí" a přidá se k
+	// původnímu slicu.
+	s = append(s, []int{7, 8, 9}...) // druhým parametrem je literát slicu.
+	fmt.Println(s)	// slice má teď hodnoty [1 2 3 4 5 6 7 8 9]
+
+	p, q := naucSePraciSPameti() // Deklarujeme p a q jako typ pointer na int.
+	fmt.Println(*p, *q)   // * dereferencuje pointer. Tím se vypíší dva inty.
+
+	// Mapy jsou dynamické rostoucí asociativní pole, jako hashmapa, nebo slovník
+	// (dictionary) v jiných jazycích
+	m := map[string]int{"tri": 3, "ctyri": 4}
+	m["jedna"] = 1
+
+	// Napoužité proměnné jsou v Go chybou.
+	// Použijte podtržítko, abychom proměnno "použili".
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	// Výpis promenné se počítá jako použití.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	naucSeVetveníProgramu() // Zpátky do běhu.
+}
+
+// narozdíl od jiných jazyků, v Go je možné mít pojmenované návratové hodnoty.
+// Tak můžeme vracet hodnoty z mnoha míst funkce, aniž bychom uváděli hodnoty v
+// return.
+func naucSePojmenovaneNavraty(x, y int) (z int) {
+	z = x * y
+	return // z je zde implicitní, jelikož bylo pojmenováno.
+}
+
+// Go má garbage collector. Používá pointery, ale neumožňuje jejich aritmetiku.
+// Můžete tedy udělat chybu použitím nil odkazu, ale ne jeho posunutím.
+func naucSePraciSPameti() (p, q *int) {
+	// Pojmenované parametry p a q mají typ odkaz na int.
+	p = new(int) // Zabudované funkce new alokuje paměť.
+	// Alokované místo pro int má hodnotu 0 a p už není nil.
+	s := make([]int, 20) // Alokujeme paměť pro 20 intů.
+	s[3] = 7             // Jednu z nich nastavíme.
+	r := -2              // Deklarujeme další lokální proměnnou.
+	return &s[3], &r     // a vezmeme si jejich odkaz pomocí &.
+}
+
+func narocnyVypocet() float64 {
+	return m.Exp(10)
+}
+
+func naucSeVetveníProgramu() {
+	// Výraz if vyžaduje složené závorky, ale podmínka nemusí být v závorkách.
+	if true {
+		fmt.Println("říkal jsme ti to")
+	}
+	// Formátování je standardizované pomocí utility "go fmt".
+	if false {
+		// posměšek.
+	} else {
+		// úšklebek.
+	}
+	// Použij switch, když chceš zřetězit if.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// jednotlivé case nepropadávají. není potřeba "break"
+	case 43:
+		// nedosažitelné, jelikož už bylo ošetřeno.
+	default:
+		// implicitní větev je nepovinná.
+	}
+	// Stejně jako if, for (smyčka) nepoužívá závorky.
+	// Proměnné definované ve for jsou lokální vůči smyčce.
+	for x := 0; x < 3; x++ { // ++ je výrazem.
+		fmt.Println("iterace", x)
+	}
+	// zde je x == 42.
+
+	// For je jediná smyčka v Go, ale má několik tvarů.
+	for { // Nekonečná smyčka
+		break    // Dělám si legraci
+		continue // Sem se nedostaneme
+	}
+
+	// Můžete použít klíčové slovo range pro iteraci nad mapami, poli, slicy,
+	// řetězci a kanály.
+	// range vrací jednu (kanál) nebo dvě hodnoty (pole, slice, řetězec a mapa).
+	for key, value := range map[string]int{"jedna": 1, "dva": 2, "tri": 3} {
+		// pro každý pár (klíč a hodnota) je vypiš
+		fmt.Printf("klíč=%s, hodnota=%d\n", key, value)
+	}
+
+	// stejně jako for, := v podmínce if přiřazuje hodnotu
+	// nejříve nastavíme y a pak otestujeme, jestli je y větší než x.
+	if y := narocnyVypocet(); y > x {
+		x = y
+	}
+	// Funkční literáty jsou tzv. uzávěry (closure)
+	xBig := func() bool {
+		return x > 10000 // odkazuje na x deklarované ve příkladu použití switch
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
+	x = 1.3e3                    // To udělá z x == 1300
+	fmt.Println("xBig:", xBig()) // teď už false.
+
+	// Dále je možné funkční literáty definovat a volat na místě jako parametr
+	// funkce, dokavaď:
+	// a) funkční literát je okamžitě volán pomocí (),
+	// b) výsledek se shoduje s očekávaným typem.
+	fmt.Println("Sečte + vynásobí dvě čísla: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Voláno s parametry 10 a 2
+	// => Sečti a vynásob dvě čísla. 24
+
+	// Když to potřebujete, tak to milujete
+	goto miluji
+miluji:
+
+	naučteSeFunkčníFactory() // funkce vracející funkce je zábava(3)(3)
+	naučteSeDefer()      // malá zajížďka k důležitému klíčovému slovu.
+	naučteSeInterfacy() // Přichází dobré věci!
+}
+
+func naučteSeFunkčníFactory() {
+	// Následující dvě varianty jsou stejné, ale ta druhá je praktičtější
+	fmt.Println(větaFactory("létní")("Hezký", "den!"))
+
+	d := větaFactory("letní")
+	fmt.Println(d("Hezký", "den!"))
+	fmt.Println(d("Líný", "odpoledne!"))
+}
+
+// Dekorátory jsou běžné v jiných jazycích. To samé můžete udělat v Go
+// pomocí parameterizovatelných funkčních literátů.
+func větaFactory(můjŘetězec string) func(před, po string) string {
+	return func(před, po string) string {
+		return fmt.Sprintf("%s %s %s", před, můjŘetězec, po) // nový řetězec
+	}
+}
+
+func naučteSeDefer() (ok bool) {
+	// Odloží (defer) příkazy na okamžik těsně před opuštěním funkce.
+	// tedy poslední se provede první
+	defer fmt.Println("odložené příkazy jsou zpravovaná v LIFO pořadí.")
+	defer fmt.Println("\nProto je tato řádka vytištěna první")
+	// Defer se běžně používá k zavírání souborů a tím se zajistí, že soubor
+	// bude po ukončení funkce zavřen.
+	return true
+}
+
+// definuje typ interfacu s jednou metodou String()
+type Stringer interface {
+	String() string
+}
+
+// Definuje pár jako strukturu se dvěma poli typu int x a y.
+type pár struct {
+	x, y int
+}
+
+// Definuje method pár. Pár tedy implementuje interface Stringer.
+func (p pár) String() string { // p je tu nazýváno "Receiver" - přijímač
+	// Sprintf je další veřejná funkce z balíčku fmt.
+	// Pomocí tečky přistupujeme k polím proměnné p
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func naučteSeInterfacy() {
+	// Složené závorky jsou "strukturální literáty. Vyhodnotí a inicializuje
+	// strukturu. Syntaxe := deklaruje a inicializuje strukturu.
+	p := pár{3, 4}
+	fmt.Println(p.String()) // Volá metodu String na p typu pár.
+	var i Stringer          // Deklaruje i jako proměnné typu Stringer.
+	i = p                   // Toto je možné, jelikož oba implementují Stringer
+	// zavolá metodu String(( typu Stringer a vytiskne to samé jako předchozí.
+	fmt.Println(i.String())
+
+	// Funkce ve balíčku fmt volají metodu String, když zjišťují, jak se má typ
+	// vytisknout.
+	fmt.Println(p) // Vytiskne to samé, jelikož Println volá String().
+	fmt.Println(i) // Ten samý výstup.
+
+	naučSeVariabilníParametry("super", "učit se", "tady!")
+}
+
+// Funcke mohou mít proměnlivé množství parametrů.
+func naučSeVariabilníParametry(mojeŘetězce ...interface{}) {
+	// Iterujeme přes všechny parametry
+	// Potržítku tu slouží k ignorování indexu v poli.
+	for _, param := range mojeŘetězce {
+		fmt.Println("parameter:", param)
+	}
+
+	// Použít variadický parametr jako variadický parametr, nikoliv pole.
+	fmt.Println("parametery:", fmt.Sprintln(mojeŘetězce...))
+
+	naučSeOšetřovatChyby()
+}
+
+func naučSeOšetřovatChyby() {
+	// ", ok" je metodou na zjištění, jestli něco fungovalo, nebo ne.
+	m := map[int]string{3: "tri", 4: "ctyri"}
+	if x, ok := m[1]; !ok { // ok bude false, jelikož 1 není v mapě.
+		fmt.Println("není tu jedna")
+	} else {
+		fmt.Print(x) // x by bylo tou hodnotou, pokud by bylo v mapě.
+	}
+	// hodnota error není jen znamením OK, ale může říct více o chybě.
+	if _, err := strconv.Atoi("ne-int"); err != nil { // _ hodnotu zahodíme
+		// vytiskne 'strconv.ParseInt: parsing "non-int": invalid syntax'
+		fmt.Println(err)
+	}
+	// Znovu si povíme o interfacech, zatím se podíváme na
+	naučSeKonkurenčnost()
+}
+
+// c je kanál, způsob, jak bezpečně komunikovat v konkurenčním prostředí.
+func zvyš(i int, c chan int) {
+	c <- i + 1 // <- znamená "pošli" a posílá data do kanálu na levé straně.
+}
+
+// Použijeme funkci zvyš a konkurečně budeme zvyšovat čísla.
+func naučSeKonkurenčnost() {
+	// funkci make jsme již použili na slicy. make alokuje a inicializuje slidy,
+	// mapy a kanály.
+	c := make(chan int)
+	// nastartuj tři konkurenční go-rutiny. Čísla se budou zvyšovat
+	// pravděpodobně paralelně pokud je počítač takto nakonfigurován.
+	// Všechny tři zapisují do toho samého kanálu.
+	go zvyš(0, c) // go je výraz pro start nové go-rutiny.
+	go zvyš(10, c)
+	go zvyš(-805, c)
+	// Přečteme si tři výsledky a vytiskeneme je..
+	// Nemůžeme říct, v jakém pořadí výsledky přijdou!
+	fmt.Println(<-c, <-c, <-c) // pokud je kanál na pravo, jedná se o "přijmi".
+
+	cs := make(chan string)       // Další kanál, tentokrát pro řetězce.
+	ccs := make(chan chan string) // Kanál kanálu řetězců.
+	go func() { c <- 84 }()       // Start nové go-rutiny na posílání hodnot.
+	go func() { cs <- "wordy" }() // To samé s cs.
+	// Select má syntaxi jako switch, ale vztahuje se k operacím nad kanály.
+	// Náhodně vybere jeden case, který je připraven na komunikaci.
+	select {
+        case i := <-c: // Přijatá hodnota může být přiřazena proměnné.
+            fmt.Printf("je to typ %T", i)
+        case <-cs: // nebo může být zahozena
+            fmt.Println("je to řetězec")
+        case <-ccs: // prázdný kanál, nepřipraven ke komunikaci.
+      		fmt.Println("to se nestane.")
+	}
+	// V tomto okamžiku máme hodnotu buď z kanálu c nabo cs. Jedna nebo druhá
+	// nastartovaná go-rutina skončila a další zůstane blokovaná.
+
+	naučSeProgramovatWeb() // Go to umí. A vy to chcete taky.
+}
+
+// jen jedna funkce z balíčku http spustí web server.
+func naučSeProgramovatWeb() {
+
+	// První parametr ListenAndServe je TCP adresa, kde poslouchat.
+	// Druhý parametr je handler, implementující interace http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pár{})
+		fmt.Println(err) // neignoruj chyby
+	}()
+
+	requestServer()
+}
+
+// Umožní typ pár stát se http tím, že implementuje její jedinou metodu
+// ServeHTTP.
+func (p pár) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Servíruj data metodou http.ResponseWriter
+	w.Write([]byte("Naučil ses Go za y minut!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nWebserver řekl: `%s`", string(body))
+}
+```
+
+## Kam dále
+
+Vše hlavní o Go se nachází na [oficiálních stránkách go](http://golang.org/).
+Tam najdete tutoriály, interaktivní konzolu a mnoho materiálu ke čtení.
+Kromě úvodu, [dokumenty](https://golang.org/doc/) tam obsahují jak psát čistý kód v Go
+popis balíčků (package), dokumentaci příkazové řádky a historii releasů.
+
+Také doporučujeme přečíst si definici jazyka. Je čtivá a překvapivě krátká. Tedy alespoň proti
+jiným současným jazyků.
+
+Pokud si chcete pohrát s Go, tak navštivte [hřiště Go](https://play.golang.org/p/r46YvCu-XX).
+Můžete tam spouštět programy s prohlížeče. Také můžete [https://play.golang.org](https://play.golang.org) použít jako
+[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop), kde si v rychlosti vyzkoušíte věci, bez instalace Go.
+
+Na vašem knižním seznamu, by neměly chybět [zdrojáky stadardní knihovny](http://golang.org/src/pkg/).
+Důkladně popisuje a dokumentuje Go, styl zápisu Go a Go idiomy. Pokud kliknete na [dokumentaci](http://golang.org/pkg/)
+tak se podíváte na dokumentaci.
+
+Dalším dobrým zdrojem informací je [Go v ukázkách](https://gobyexample.com/).
+
+Go mobile přidává podporu pro Android a iOS. Můžete s ním psát nativní mobilní aplikace nebo knihovny, které půjdou
+spustit přes Javu (pro Android), nebo Objective-C (pro iOS). Navštivte [web Go Mobile](https://github.com/golang/go/wiki/Mobile)
+pro více informací.
-- 
cgit v1.2.3


From ffba631fdd0413bbcde75d2d3791f679c7029d8e Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Mon, 5 Sep 2016 22:19:48 +0200
Subject: Update go.html.markdown

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

(limited to 'cs-cz')

diff --git a/cs-cz/go.html.markdown b/cs-cz/go.html.markdown
index f814d2da..36217414 100644
--- a/cs-cz/go.html.markdown
+++ b/cs-cz/go.html.markdown
@@ -2,7 +2,8 @@
 name: Go
 category: language
 language: Go
-filename: learngo.go
+filename: learngo-cs.go
+lang: cs-cz
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["Christopher Bess", "https://github.com/cbess"]
@@ -13,7 +14,6 @@ contributors:
     - ["Clayton Walker", "https://github.com/cwalk"]
 translators:
     - ["Ondra Linek", "https://github.com/defectus/"]
-
 ---
 
 Jazyk Go byl vytvořen, jelikož bylo potřeba dokončit práci. Není to poslední 
-- 
cgit v1.2.3


From 650f0b54510b5aa6faa24c1ea7c670de15f40955 Mon Sep 17 00:00:00 2001
From: samcv <samantham@posteo.net>
Date: Wed, 26 Oct 2016 01:19:06 -0700
Subject: =?UTF-8?q?Remove=20the=20byte=20order=20mark=20from=20the=20Czech?=
 =?UTF-8?q?=20Javascript=20file.=20=20This=20file=E2=80=A6=20(#2509)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Remove the byte order mark from the Czech Javascript file.  This file wasn't showing up on the site before but this will fix it :)

* Add info on how to check if a file has a byte order marker to the CONTRIBUTING file

* Fit into 80 columns width
---
 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 e781db3e..cbf7687e 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -1,4 +1,4 @@
----
+---
 language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
-- 
cgit v1.2.3


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