„Mohl bys to prosím ještě jednou vysvětlit? Začínám se v těch závorkách ztrácet — před chvílí jsi říkal, že slouží k jedné věci, a teď je používáš jinak.“
Tohle je typický dotaz, který často slýchám od začátečníků při výuce programování. Python je totiž tzv. kontextový jazyk – význam kulatých, hranatých a složených závorek se mění podle toho, v jakém kontextu se použijí.

V dnešním článku se podíváme právě na závorky – jaké mají typy, kde se v Pythonu používají a proč někdy působí zmatečně. Nebude to zrovna nejnapínavější čtení, ale cílem je vytvořit přehledný souhrn, který vám pomůže se v závorkách lépe vyznat a přestat je plést. Souhrn se dotkne i složitějších kontextů, takže se nelekejte, pokud některé části hned nepochopíte.

( ) – kulaté závorky

1. Volání funkce

Když se závorky objeví za názvem funkce, Python je interpretuje jako volání funkce – tedy spuštění jejího těla s danými argumenty.

print("Ahoj světě")
print() # prázdný řádek

Závorky zde obsahují argumenty funkce.
Pokud funkce žádné argumenty nemá, závorky jsou prázdné:

2. Definice funkce

Když se závorky nachází za klíčovým slovem def, určují parametry funkce, tedy názvy proměnných, které bude funkce přijímat.

def add(a, b):
    return a + b

print(add(3, 5))     # => 8

Parametry v závorkách mohou být:

• povinné (a, b),
• volitelné s výchozí hodnotou (b=0),
• sběrné (*args) a pojmenované (**kwargs) argumenty.

def example(x, *args, **kwargs):
    print(x, args, kwargs)

example(1, 2, 3, key="value")
# => 1 (2, 3) {'key': 'value'}

3. Definice třídy

Závorky v definici třídy určují dědičnost – tedy které třídy budou sloužit jako rodiče.

class Animal:
    pass

class Dog(Animal):  # dědí z Animal
    pass

Pokud třída nedědí z žádné jiné, můžeš závorky vynechat:

class Empty:
    pass

V opačném případě jsou povinné:

class MyClass(Base1, Base2):
    pass

4. Tvorba n-tice (tuple)

Závorky mohou označovat n-tici (tuple) – neměnnou sekvenci hodnot.

point = (3, 4)
print(point)        # => (3, 4)
print(type(point))  # => <class 'tuple'>

Pozor: závorky nejsou povinné, pokud Python může jednoznačně rozpoznat n-tici z kontextu:

pair = 1, 2         # závorky se doplní implicitně
print(type(pair))   # <class 'tuple'>

Pro jednoprvkovou n-tici je důležitá čárka:

single = (1)        # není tuple, ale číslo
print(type(single)) # <class 'int'>

single = (1,)       # tuple
print(type(single)) # <class 'tuple'>

5. Priorita (skupiny ve výrazech)

Závorky mohou měnit pořadí vyhodnocování matematických nebo logických výrazů.

result = (2 + 3) * 4   # => 20
result2 = 2 + (3 * 4)  # => 14

Stejně fungují i v podmínkách:

x = 10
if (x > 0) and (x < 20):
    print("x je mezi 0 a 20")

Závorky zde nemění typ, jen seskupují výraz.

6. Generátorový výraz

Kulaté závorky se používají také k vytvoření generátorového výrazu – podobného list comprehension, ale místo seznamu vytváří generátor (lazy sekvenci).

gen = (x**2 for x in range(5))
print(gen)          # => <generator object ...>

for n in gen:
    print(n)
# Výstup: 0, 1, 4, 9, 16

Rozdíl:

• [x**2 for x in range(5)] → seznam (v paměti)
• (x**2 for x in range(5)) → generátor (postupně generuje)

7. Dekorátor s parametry

Pokud dekorátor přijímá parametry, závorky za @ předávají hodnoty při jeho aplikaci.

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hi():
    print("Hi!")

say_hi()
# => Hi! Hi! Hi!

Dekorátor bez parametrů by měl jen @repeat bez závorek.

8. Závorky ve výrazech typu lambda

Někdy jsou závorky nutné pro zachování správné priority nebo pro okamžité volání lambda funkce:

# Okamžité volání anonymní funkce
result = (lambda x: x**2)(5)
print(result)  # => 25

Výborně.
Podívejme se tedy detailně na hranaté závorky [ ] v Pythonu – jeden z nejvšestrannějších symbolů jazyka.
Jejich význam se mění podle kontextu, ve kterém se používají: mohou vytvářet seznamy, indexovat, vyjadřovat řezy, typové parametry nebo i porozumění seznamům (list comprehensions).

[ ] – hranaté závorky

1. Vytváření seznamu (list)

Nejzákladnější použití hranatých závorek je vytvoření seznamu – tedy uspořádané, měnitelné kolekce prvků.

numbers = [1, 2, 3, 4]
names = ["Alice", "Bob", "Charlie"]

print(numbers[0])      # => 1
print(len(names))      # => 3

Závorky zde Python rozpozná podle toho, že:

• obsahují hodnoty oddělené čárkami,
• nejsou součástí volání nebo indexace,
• stojí jako výraz, který má vytvořit kolekci.

Seznam může obsahovat prvky libovolných typů:

mixed = [1, "a", 3.14, True]

2. Indexace prvků

Hranaté závorky za jménem proměnné se používají k přístupu ke konkrétnímu prvku v sekvenci nebo k položce v kolekci (list, tuple, str, dict, …).

numbers = [10, 20, 30]
print(numbers[0])   # => 10  (první prvek, index 0)
print(numbers[-1])  # => 30  (poslední prvek)

Víceúrovňová indexace:

matrix = [[1, 2], [3, 4]]
print(matrix[0][1])  # => 2

Funguje i na řetězcích:

text = "Python"
print(text[2])       # => 't'

3. Řezy (slicing)

Hranaté závorky se také používají pro výběr podsekvencí pomocí tzv. slice notation:

numbers = [0, 1, 2, 3, 4, 5, 6]
print(numbers[1:4])     # => [1, 2, 3]
print(numbers[:3])      # => [0, 1, 2]
print(numbers[3:])      # => [3, 4, 5, 6]
print(numbers[::2])     # => [0, 2, 4, 6]
print(numbers[::-1])    # => [6, 5, 4, 3, 2, 1, 0] (obrácený seznam)

Obecný tvar:

a[start:stop:step]

• start – odkud začít (včetně)
• stop – kde skončit (bez zahrnutí)
• step – krok (může být záporný)

4. List comprehension

Hranaté závorky mohou obklopovat porozumění seznamům – krátký zápis cyklu a filtru v jednom výrazu.

squares = [x**2 for x in range(5)]
print(squares)     # => [0, 1, 4, 9, 16]

Podmínky:

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # => [0, 4, 16, 36, 64]

Pod kapotou:

• [ ] říkají Pythonu: „výsledek bude seznam“,
• () by vytvořily generátor,
• {} by vytvořily množinu nebo slovník.

5. Parametrizované typy (type hints)

Od Pythonu 3.9 (PEP 585) lze hranaté závorky použít v type hintingu – k parametrizaci vestavěných typů.

def total(values: list[int]) -> int:
    return sum(values)

data: dict[str, float] = {"a": 1.0, "b": 2.5}

Zde hranaté závorky neoznačují indexaci, ale „typ uvnitř typu“:

• list[int] → seznam čísel,
• dict[str, float] → mapování řetězců na desetinná čísla.

Stejně funguje tuple[int, str], set[float] nebo Callable[[int], str].

6. Přístup k položce ve slovníku nebo objektu

Pokud je vlevo slovník, hranaté závorky fungují jako přístup pomocí klíče:

person = {"name": "Zlatan", "age": 32}
print(person["name"])  # => "Zlatan"

Pokud klíč neexistuje:

print(person.get("address"))  # bezpečnější varianta – vrátí None

Můžeš s nimi i zapisovat:

person["age"] = 33

U některých objektů (např. pandas.DataFrame, NumPy pole) může obj["key"] přistupovat k sloupcům nebo datům podle klíče.

8. Speciální použití v knihovnách

V některých kontextech mají hranaté závorky význam rozšířený:

• Typing / generics – např. Optional[int], Union[str, None], list[tuple[int, str]].

Pandas – výběr sloupce nebo více sloupců:

import pandas as pd
df = pd.DataFrame({"A": [1, 2], "B": [3, 4]})
print(df["A"])     # Series
print(df[["A", "B"]])  # DataFrame

NumPy – výběr podle více os:

import numpy as np
a = np.arange(9).reshape(3, 3)
print(a[:, 1])   # druhý sloupec všech řádků

Perfektní, pojďme tedy detailně rozebrat složené závorky { } – další z víceznačných symbolů v Pythonu, které mají odlišný význam podle kontextu.
Tento symbol se v Pythonu používá k vytváření datových struktur i k formátování řetězců.

{ } – složené závorky

1. Slovník (dictionary)

Složené závorky se nejčastěji používají k vytvoření slovníku (dict) – tedy struktury, která mapuje klíče na hodnoty.

person = {"name": "Josef", "age": 32, "city": "Praha"}
print(person["name"])    # => "Josef"
print(person["age"])     # => 32

Další příklady:

# prázdný slovník
empty_dict = {}

# smíšené typy hodnot
data = {"x": 1, "y": [1, 2, 3], "valid": True}

# přidání nové dvojice
data["z"] = 42

2. Množina (set)

Pokud Python v složených závorkách nevidí dvojtečku :, považuje výraz za množinu.
Množina (set) je neuspořádaná kolekce unikátních prvků.

numbers = {1, 2, 3, 3, 2}
print(numbers)        # => {1, 2, 3}

Typické použití:

unique_letters = set("banana")
print(unique_letters)  # => {'b', 'a', 'n'}

# množinové operace
A = {1, 2, 3}
B = {3, 4, 5}

print(A | B)  # sjednocení => {1, 2, 3, 4, 5}
print(A & B)  # průnik => {3}
print(A - B)  # rozdíl => {1, 2}
print(A ^ B)  # symetrický rozdíl => {1, 2, 4, 5}

Pro vytvoření prázdné množiny se musí použít funkce set():

empty_set = set()

3. Set comprehension

Podobně jako seznam, i množinu lze vytvořit pomocí comprehension zápisu.
Používají se složené závorky, ale bez dvojtečky :.

squares = {x**2 for x in range(5)}
print(squares)   # => {0, 1, 4, 9, 16}

Tento zápis automaticky eliminuje duplicity, protože množina nemůže obsahovat opakující se hodnoty:

even_squares = {x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # => {0, 4, 16, 36, 64}

4. Dictionary comprehension

Pokud složené závorky obsahují dvojtečku :, Python pochopí, že se jedná o dictionary comprehension.

numbers = [1, 2, 3, 4]
squares = {n: n**2 for n in numbers}
print(squares)   # => {1: 1, 2: 4, 3: 9, 4: 16}

Podmínky:

even_squares = {n: n**2 for n in range(10) if n % 2 == 0}
print(even_squares)  # => {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

5. Formátovací řetězce – str.format()

Složené závorky se používají i ve formátovacích řetězcích pro vkládání hodnot do textu.

• Základní použití:

name = "Zlatan"
age = 32
print("My name is {} and I am {} years old.".format(name, age))
# => My name is Daniel and I am 32 years old.

• S indexy:

print("{1} + {0} = {2}".format(2, 3, 5))
# => 3 + 2 = 5

• S pojmenovanými argumenty:

print("X: {x}, Y: {y}".format(x=10, y=20))
# => X: 10, Y: 20

• S formátovacími specifikátory:

pi = 3.1415926
print("Pi = {:.2f}".format(pi))   # => Pi = 3.14

6. f-string s vloženými výrazy

Od Pythonu 3.6 můžeš používat tzv. f-stringy, které umožňují vkládání výrazů přímo do řetězce – bez volání format().

name = "Daniel"
age = 32
print(f"My name is {name} and I am {age} years old.")
# => My name is Daniel and I am 32 years old.

Uvnitř složených závorek může být libovolný výraz:

x = 3
y = 4
print(f"{x} + {y} = {x + y}")  # => 3 + 4 = 7

Podporují i formátování:

pi = 3.1415926
print(f"Pi = {pi:.2f}")   # => Pi = 3.14

Nebo výrazy v cyklu:

for i in range(3):
    print(f"Value {i}: {i**2}")

7. Escapování složených závorek v řetězcích

Pokud chceš v řetězci zobrazit skutečné složené závorky { nebo }, musíš je zdvojit.
To platí jak pro metodu .format(), tak pro f-stringy:

print(f"Curly braces: {{ and }}")
# Výstup: Curly braces: { and }

Funguje to tedy stejně u obou způsobů formátování.