0 dní v řadě · 0 bodů

Datové struktury · 20 min

Comprehensions

Přepíšeš cyklus plnící seznam na jeden čitelný řádek, zvládneš filtry, slovníky, množiny i generátorové výrazy.

Hloubka
Úkoly
Lidsky řečeno

Řekneš kuchaři: „Každou bramboru oloupej a dej do mísy, nahnilé vynech.“ Neříkáš mu, ať si připraví prázdnou mísu, vezme první bramboru, pak další a pokaždé zkontroluje, jestli ještě nějaká zbývá. Popíšeš výsledek a postup se rozumí sám. Comprehension je takový příkaz pro Python.

Z cyklu jeden řádek

Máš ceny bez DPH a chceš ceny s DPH. Zatím bys založil prázdný seznam a v cyklu do něj přidával. Comprehension (slovo se do češtiny většinou nepřekládá) zapíše totéž jako jeden výraz.

ceny = [100, 250, 89, 1200]

s_dph = []
for cena in ceny:
    s_dph.append(round(cena * 1.21, 2))
print(s_dph)

s_dph = [round(cena * 1.21, 2) for cena in ceny]
print(s_dph)
Výstup
[121.0, 302.5, 107.69, 1452.0]
[121.0, 302.5, 107.69, 1452.0]

Oba zápisy dělají totéž. Stačí přesunout pár kousků:

text
for cena in ceny:                        (1)
    s_dph.append(round(cena * 1.21, 2))  (2)

s_dph = [round(cena * 1.21, 2)  for cena in ceny]
         └─────────2─────────┘  └──────1───────┘

Čti to zleva: „seznam z round(...) pro každou cenu v cenách“. Hranaté závorky říkají, že výsledkem je nový seznam. Původní ceny zůstanou beze změny.

Úkol

Dvacet procent dolů

Do seznamu po_sleve ulož všechny ceny snížené o 20 %. Použij comprehension.

ceny = [100, 250, 80, 1999]

po_sleve = []
Výstup

Filtr a rozhodování

Na konec můžeš přidat if. Do výsledku pak projdou jen položky, které podmínku splní. Výraz vpředu i podmínka vzadu pracují s toutéž proměnnou.

teploty = [18, 25, 31, 12, 28, 35]
print([t for t in teploty if t >= 25])

jmena = ["  eva", "PETR ", "", "   ", "jana"]
ciste = [j.strip().capitalize() for j in jmena if j.strip()]
print(ciste)
Výstup
[25, 31, 28, 35]
['Eva', 'Petr', 'Jana']

Podmínka if j.strip() využívá toho, že prázdný text se bere jako nepravda.

Někdy nechceš položku vyhodit, ale nahradit. Na to je podmíněný výraz A if podminka else B, který vrátí jednu ze dvou hodnot. Ten patří dopředu, protože je součástí toho, co se ukládá.

teploty = [18, 25, 31, 12]

print(["teplo" if t >= 20 else "chladno" for t in teploty])
print([t if t >= 20 else 0 for t in teploty])
print([t for t in teploty if t >= 20])
Výstup
['chladno', 'teplo', 'teplo', 'chladno']
[0, 25, 31, 0]
[25, 31]
Kvíz

Kolik položek bude mít [x if x > 0 else 0 for x in [5, -1, 3, -2]]?

Úkol

Dlouhá slova

Z věty vyber slova delší než 4 znaky a převeď je na malá písmena. Výsledek ulož do seznamu dlouha, pořadí zachovej.

veta = "Kočka leze DÍROU pes OKNEM"

dlouha = []
Výstup

Slovníky a množiny

Stejný zápis funguje se složenými závorkami. S dvojtečkou vznikne slovník, bez ní množina. Funkce zip, která spáruje dva seznamy položku po položce, se tu hodí zvlášť často.

sklad = {"šrouby": 120, "matice": 0, "podložky": 45, "hmoždinky": 0}

skladem = {nazev: kusy for nazev, kusy in sklad.items() if kusy > 0}
print(skladem)

dvojnasobek = {nazev: kusy * 2 for nazev, kusy in sklad.items()}
print(dvojnasobek)

kody = {"CZ": "Praha", "SK": "Bratislava"}
print({mesto: kod for kod, mesto in kody.items()})

jmena = ["Eva", "Petr", "Jana"]
body = [81, 47, 93]
print({jmeno: bod for jmeno, bod in zip(jmena, body)})

print(sorted({nazev[0] for nazev in sklad}))
Výstup
{'šrouby': 120, 'podložky': 45}
{'šrouby': 240, 'matice': 0, 'podložky': 90, 'hmoždinky': 0}
{'Praha': 'CZ', 'Bratislava': 'SK'}
{'Eva': 81, 'Petr': 47, 'Jana': 93}
['h', 'm', 'p', 'š']

Když při prohazování klíčů a hodnot dvě položky vyjdou na stejný klíč, přežije ta poslední. Slovník víc stejných klíčů mít nemůže.

Úkol

Kdo prošel

Ze slovníku body vytvoř slovník prospeli, ve kterém zůstanou jen lidé s aspoň 50 body. Do množiny pismena ulož první písmena jmen všech lidí z body.

body = {"Eva": 81, "Petr": 47, "Jana": 93, "Ota": 50, "Pavla": 12}

# doplň
Výstup

Víc cyklů v jednom

Comprehension může mít několik for. Píšou se ve stejném pořadí jako vnořené cykly, jen bez odsazení. Výraz, který se ukládá, zůstává vpředu.

text
for radek in mrizka:                 [cislo
    for cislo in radek:      ──►      for radek in mrizka
        vysledek.append(cislo)        for cislo in radek]

Druhý případ je comprehension uvnitř comprehension. Ten vyrábí seznam seznamů, tedy zachovává tvar.

velikosti = ["S", "M"]
barvy = ["černá", "bílá", "šedá"]
print([f"{v}-{b}" for v in velikosti for b in barvy])

mrizka = [[1, 2, 3], [4, 5, 6]]

print([cislo for radek in mrizka for cislo in radek])
print([[cislo * 10 for cislo in radek] for radek in mrizka])
print([[radek[i] for radek in mrizka] for i in range(3)])
Výstup
['S-černá', 'S-bílá', 'S-šedá', 'M-černá', 'M-bílá', 'M-šedá']
[1, 2, 3, 4, 5, 6]
[[10, 20, 30], [40, 50, 60]]
[[1, 4], [2, 5], [3, 6]]

Poslední řádek prohodil řádky a sloupce. Kde začíná být čtení namáhavé, tam přestaň. Dva for jsou v pořádku. Tři for s podmínkami už patří do obyčejných cyklů:

python
# Takhle ne: funguje to, ale nikdo to nepřečte napoprvé.
vysledek = [z.upper() for s in data if s for r in s.split(";") if r for z in r.split(",") if z != "x"]
Úkol

Volná sedadla

Vytvoř seznam volna se všemi sedadly v řadách A a B s čísly 1 až 3, tedy A1, A2... B3, ale bez těch v množině obsazeno. Pořadí: nejdřív celá řada A, potom řada B.

rady = ["A", "B"]
obsazeno = {"A2", "B1"}

volna = []
Výstup

Generátorový výraz

S kulatými závorkami nevznikne n-tice, ale generátor. Ten nic nespočítá předem. Hodnoty vydává po jedné, až když si o ně někdo řekne. Je to ideální partner pro sum, min, max, any, all a join, které beztak potřebují každou hodnotu vidět jen jednou. Když je generátor jediný argument funkce, druhé závorky se vynechají.

any odpoví, jestli platí aspoň jedna hodnota, all, jestli platí všechny. Oba skončí, jakmile znají odpověď.

objednavky = [1200, 340, 5600, 89]

print(sum(c for c in objednavky if c >= 1000))
print(any(c > 5000 for c in objednavky))
print(all(c > 100 for c in objednavky))
print(max(len(s) for s in ["a", "bbb", "cc"]))
print(", ".join(str(c) for c in objednavky))

dvojnasobky = (c * 2 for c in objednavky)
print(type(dvojnasobky).__name__)
print(list(dvojnasobky))
print(list(dvojnasobky))
Výstup
6800
True
False
3
1200, 340, 5600, 89
generator
[2400, 680, 11200, 178]
[]

Všimni si konce. Generátor je na jedno použití. Po prvním průchodu je prázdný a podruhé už nic nedá. Podrobně se k němu vrátíš v lekci Generátory a líné zpracování.

Kvíz

Který zápis vytvoří množinu druhých mocnin?

Pod kapotou · rozsah platnosti a PEP 709

Od Pythonu 3 má řídicí proměnná vlastní rozsah a neprosákne ven. Do verze 3.11 se každá comprehension kompilovala jako skrytá vnořená funkce, která se hned zavolala. PEP 709 v Pythonu 3.12 vkládá comprehension pro seznam, slovník i množinu přímo do okolního kódu. Odpadá tvorba funkce a rámce, což je znát hlavně u krátkých comprehensions v horké smyčce. Sémantika izolace zůstala zachována. Viditelný rozdíl je v tracebacku (rámec <listcomp> zmizel) a v locals(), který uvnitř nově vidí i okolní proměnné. Generátorové výrazy zůstaly samostatnými objekty, protože si musí držet stav mezi kroky.

import dis

x = "venku"
cisla = [x for x in range(3)]
print(x)

def vytvari_funkci(zdroj):
    kod = compile(zdroj, "<ukazka>", "eval")
    return any(i.opname == "MAKE_FUNCTION" for i in dis.get_instructions(kod))

print(vytvari_funkci("[n * 2 for n in data]"))
print(vytvari_funkci("(n * 2 for n in data)"))
Výstup
venku
False
True

Volba mezi [...] a generátorem: generátor šetří paměť u velkých dat a umí skončit předčasně, seznam se ale rychleji prochází. Výjimkou je str.join, který si vstup stejně nejdřív převede na seznam, aby spočítal výslednou délku. "".join([...]) proto bývá o něco rychlejší než varianta s generátorem.

Pod kapotou · kdy se co vyhodnotí

U generátorového výrazu se hned vyhodnotí jen první iterovatelný objekt. Podmínky, další for i výsledný výraz běží až při čtení. Kód níže proto prochází starý seznam, ale ptá se už na novou množinu. Stejně se chová uzávěr: lambdy si pamatují proměnnou, ne hodnotu.

data = [1, 2, 3]
povolene = {1}
vybrane = (x for x in data if x in povolene)

data = [7, 8, 9]
povolene = {3, 8}
print(list(vybrane))

nasobitele = [lambda x: x * i for i in range(3)]
print([f(10) for f in nasobitele])

nasobitele = [lambda x, i=i: x * i for i in range(3)]
print([f(10) for f in nasobitele])

print([d for slovo in ["a", "bbb", "cc"] if (d := len(slovo)) > 1], d)
Výstup
[3]
[20, 20, 20]
[0, 10, 20]
[3, 2] 2

Poslední řádek ukazuje mroží operátor (PEP 572). Hodnotu spočítanou ve filtru jde znovu použít ve výrazu, takže drahá funkce neběží dvakrát. Jeho cíl se ale váže v okolním rozsahu, proto d po skončení existuje.

V těle třídy vidí comprehension proměnné třídy jen v prvním iterovatelném objektu, jinde skončí NameError. Tohle pravidlo PEP 709 zachoval.