← Zpět na hodinu

9. hodina – Slovníky

Slovník jako dvojice klíč a hodnota, chybějící klíč, procházení, slovník jako počítadlo a skupiny, záznamy a seznam slovníků.

Výklad a cvičení

Výklad si můžeš přečíst přímo na webu. Příklady procházej po pořadí a kód si zkoušej ve VS Code.

Zpět na přehled materiálů

Slovníky

Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.

Zpět na přehled hodiny

Proč slovník

Spusť soubor a porovnej výsledky.

Na konci lekce 8 jsi hledala, co přinese Petra. Seznam dvojic jsi musela projít cyklem, dokud jsi ji nenašla:

darky = [("Anna", "dort"), ("Petra", "víno"), ("Jana", "chlebíčky")]

for jmeno, darek in darky:
    if jmeno == "Petra":
        print(darek)        # víno

Slovník ukládá dvojice: klíč a hodnotu. Je trochu jako seznam, jen se k hodnotě nedostaneš indexem, ale klíčem. Proto ho nemusíš procházet: řekneš klíč a slovník rovnou vrátí hodnotu.

Píše se do složených závorek. Před dvojtečkou je klíč, za ní hodnota a dvojice oddělují čárky:

darky = {"Anna": "dort", "Petra": "víno", "Jana": "chlebíčky"}

Hodnotu dostaneš rovnou podle klíče, bez cyklu:

print(darky["Petra"])       # víno

print(darky)        # {'Anna': 'dort', 'Petra': 'víno', 'Jana': 'chlebíčky'}
print(len(darky))   # 3 – počet dvojic

Když v f-stringu čteš hodnotu podle textového klíče, napiš klíč do apostrofů. Stejné uvozovky jako kolem celého f-stringu by ho ukončily:

print(f"Petra přinese {darky['Petra']}.")   # Petra přinese víno.

Odkud ten název? Funguje jako překladový slovník: najdeš slovo a vedle něj stojí překlad. Anglicky se mu říká dictionary, v Pythonu zkráceně dict. To slovo uvidíš v chybových hláškách.

preklady = {"pes": "dog", "kočka": "cat", "večírek": "party"}
print(preklady["večírek"])  # party

Hledá se jen jedním směrem. V telefonním seznamu najdeš podle jména číslo, ale podle čísla jméno ne:

telefony = {"Anna": "602 111 222", "Petra": "731 333 444"}
print(telefony["Anna"])     # 602 111 222

U seznamu je klíčem pořadí (index). U slovníku si klíč vybereš sama. Nejčastěji je to text, ale může to být i číslo:

stoly = {1: "Anna", 2: "Petra", 7: "Jana"}
print(stoly[7])             # Jana

Tady 7 neznamená osmou položku. Je to klíč 7 a slovník má jen tři dvojice.

Hodnotou může být cokoli, co znáš: text, číslo, True a False, seznam i n-tice. Klíčem bývá text nebo číslo:

oblibene = {"Anna": ["dort", "víno"], "Petra": ["džus"]}
print(oblibene["Anna"])     # ['dort', 'víno']

V jednom slovníku můžou být hodnoty různých druhů. Když ale slovníkem hledáš (ceník, překlady), drž hodnoty stejného druhu. Jinak bys u každé musela hlídat, jestli s ní jde třeba počítat. Kdy je míchání v pořádku, uvidíš ve třetí sekci.


Zpět na téma: Slovníky · Další: Když klíč chybí

Zdrojový Python soubor

Když klíč chybí

Spusť soubor. Skončí chybou, a to schválně: vysvětlení je na konci souboru.

darky = {"Anna": "dort", "Petra": "víno", "Jana": "chlebíčky"}

Zápis in znáš z lekce 8. U slovníku hledá mezi klíči, ne mezi hodnotami:

print("Petra" in darky)     # True
print("víno" in darky)      # False – víno je hodnota, ne klíč

Čtení klíče, který ve slovníku není, skončí chybou. Uvidíš ji na konci souboru. Proto se před čtením hodí zeptat, jestli tam klíč je:

jmeno = "Karel"

if jmeno in darky:
    print(darky[jmeno])
else:
    print(f"{jmeno} není na seznamu.")     # Karel není na seznamu.

Kratší cesta je metoda get. Když klíč chybí, nespadne a vrátí None, které znáš z lekce 5:

print(darky.get("Petra"))   # víno
print(darky.get("Karel"))   # None

Jestli jsi dostala None, zjistíš zápisem is None:

darek = darky.get("Karel")

if darek is None:
    print("Karel nic nepřinese.")   # Karel nic nepřinese.

Proč is, a ne ==? Porovnání == se ptá, jestli mají dvě věci stejný obsah. Zápis is se ptá, jestli jde o jednu a tutéž věc. Ten rozdíl znáš z lekce 8: kopie seznamu má stejný obsah, ale je to jiný seznam.

hoste = ["Anna", "Petra"]
catering = hoste.copy()

print(catering == hoste)    # True – stejný obsah
print(catering is hoste)    # False – dva různé seznamy

None existuje v Pythonu jen jedno. Když se ptáš, jestli máš None, ptáš se, jestli je to právě tohle jedno None, a to je otázka pro is. Zápis == None by většinou fungoval taky, ale is None je přesnější a takhle ho běžně uvidíš i v cizím kódu.

Jako druhý argument můžeš metodě get dát hodnotu, kterou má vrátit místo None:

print(darky.get("Karel", "nic"))    # nic

Klíče rozlišují velká a malá písmena. "petra" je jiný klíč než "Petra":

print("petra" in darky)     # False

Když klíč chybí a čteš ho hranatými závorkami, program spadne. Je to obdoba IndexError ze seznamů: čteš něco, co tam není.

print(darky["Karel"])       # KeyError: 'Karel'

Zpět na téma: Slovníky · Další: Slovník se dá měnit

Zdrojový Python soubor

Slovník se dá měnit

Spusť soubor a porovnej výsledky.

darky = {"Anna": "dort", "Petra": "víno"}

Slovník nemá append. Novou dvojici přidáš přiřazením:

darky["Jana"] = "chlebíčky"
print(darky)    # {'Anna': 'dort', 'Petra': 'víno', 'Jana': 'chlebíčky'}

Dvojice zůstávají v pořadí, v jakém jsi je přidala.

Stejný zápis hodnotu přepíše, když klíč už ve slovníku je. Petra si to rozmyslela:

darky["Petra"] = "džus"
print(darky)    # {'Anna': 'dort', 'Petra': 'džus', 'Jana': 'chlebíčky'}

Každý klíč je ve slovníku jen jednou, takže druhá Petra nevznikne. Hodnoty se opakovat můžou:

darky["Eva"] = "dort"
print(darky)    # {'Anna': 'dort', 'Petra': 'džus', 'Jana': 'chlebíčky', 'Eva': 'dort'}

Jana se omluvila. Metodu pop znáš ze seznamů. U slovníku odebere dvojici podle klíče a vrátí její hodnotu:

darek = darky.pop("Jana")
print(darek)    # chlebíčky
print(darky)    # {'Anna': 'dort', 'Petra': 'džus', 'Eva': 'dort'}

Hodnotu můžeš změnit i výpočtem. Kolik kdo vypil sklenek:

sklenky = {"Anna": 1, "Petra": 2}

sklenky["Anna"] = sklenky["Anna"] + 1
print(sklenky)  # {'Anna': 2, 'Petra': 2}

Je to stejné jako pocet = pocet + 1 z lekce 3. Nejdřív se vyhodnotí pravá strana: přečte se 1, přičte se 1 a výsledek 2 se uloží zpátky pod klíč "Anna".


Zpět na téma: Slovníky · Další: Procházení slovníku

Zdrojový Python soubor

Procházení slovníku

Spusť soubor a porovnej výsledky.

darky = {"Anna": "dort", "Petra": "víno", "Jana": "chlebíčky"}

Cyklus for prochází klíče:

for jmeno in darky:
    print(jmeno)

Anna Petra Jana

Hodnotu si ke klíči přečteš jako obvykle:

for jmeno in darky:
    print(f"{jmeno} přinese {darky[jmeno]}.")

Anna přinese dort. Petra přinese víno. Jana přinese chlebíčky.

Metoda values vrátí jen hodnoty:

for darek in darky.values():
    print(darek)

dort víno chlebíčky

Když hodnoty rovnou vypíšeš, vypadá to zvláštně. V cyklu nebo v sum se s nimi ale pracuje jako se seznamem:

print(darky.values())   # dict_values(['dort', 'víno', 'chlebíčky'])

Metoda items vrátí dvojice klíč–hodnota. Rozbalíš je stejně jako seznam n-tic v lekci 8. Je to nejčastější způsob, jak slovník projít:

for jmeno, darek in darky.items():
    print(f"{jmeno} přinese {darek}.")

Anna přinese dort. Petra přinese víno. Jana přinese chlebíčky.

Na čísla ve slovníku fungují sum, min a max. Stačí jim dát hodnoty:

utrata = {"víno": 450, "dort": 420, "chlebíčky": 360}

print(sum(utrata.values()))     # 1230
print(max(utrata.values()))     # 450

Funkce max vrátí jen nejvyšší částku, ne zboží, ke kterému patří. Jak najít i klíč, uvidíš v další sekci.

Shrnutí:

for klic in slovnik: jen klíče for hodnota in slovnik.values(): jen hodnoty for klic, hodnota in slovnik.items(): obojí

Pamatovat si to nemusíš – všechno ze slovníků najdeš v taháku.


Zpět na téma: Slovníky · Další: Stavíme slovník v cyklu

Zdrojový Python soubor

Stavíme slovník v cyklu

Spusť soubor a porovnej výsledky.

Slovník může být prázdný. Píše se jako prázdné složené závorky:

hlasy = {}
print(hlasy)            # {}
print(len(hlasy))       # 0

V lekci 8 jsi stavěla seznam: začala jsi prázdným a v cyklu přidávala. Se slovníkem je to stejné, jen místo append přiřazuješ pod klíč. Tak převedeš seznam dvojic z lekce 8 na slovník:

darky_seznam = [("Anna", "dort"), ("Petra", "víno"), ("Jana", "chlebíčky")]

darky = {}
for jmeno, darek in darky_seznam:
    darky[jmeno] = darek

print(darky)            # {'Anna': 'dort', 'Petra': 'víno', 'Jana': 'chlebíčky'}
print(darky["Petra"])   # víno

Hodnotu můžeš i spočítat. Kolik písmen má které jméno:

hoste = ["Anna", "Petra", "Jana"]

delky = {}
for jmeno in hoste:
    delky[jmeno] = len(jmeno)

print(delky)            # {'Anna': 4, 'Petra': 5, 'Jana': 4}

Klíče můžou být i čísla. Na začátku večírku nesedí u žádného ze tří stolů nikdo:

u_stolu = {}
for stul in range(1, 4):
    u_stolu[stul] = 0

print(u_stolu)          # {1: 0, 2: 0, 3: 0}

Slovník postavíš i z textu. Metoda split ti vrátí seznam a ten se dá rozbalit stejně jako n-tice:

zprava = "Anna:dort, Petra:víno, Jana:chlebíčky"

darky = {}
for odpoved in zprava.split(", "):
    jmeno, darek = odpoved.split(":")
    darky[jmeno] = darek

print(darky)            # {'Anna': 'dort', 'Petra': 'víno', 'Jana': 'chlebíčky'}

Zpět na téma: Slovníky · Další: Seznam vs slovník – kdy použít který

Zdrojový Python soubor

Seznam vs slovník – kdy použít který

Spusť soubor a porovnej výsledky.

Oba drží víc hodnot. Liší se tím, jak se k nim dostaneš: seznam – hodnoty stojí v pořadí a sahá se na ně indexem 0, 1, 2… slovník – každá hodnota má klíč, který si zvolíš, a sahá se podle něj

Stejná data oběma způsoby. Kolik let je Petře?

Seznamem: musíš vědět, že Petra je druhá, tedy index 1. Ze seznamu samotného to nepoznáš:

veky_seznam = [34, 25, 41]
print(veky_seznam[1])   # 25

Slovníkem: zeptáš se rovnou na Petru:

veky = {"Anna": 34, "Petra": 25, "Jana": 41}
print(veky["Petra"])    # 25

Index se navíc posouvá. Když Anna odejde, Petra je najednou první:

veky_seznam.pop(0)
print(veky_seznam[1])   # 41 – to už je Jana

Klíč zůstává, ať se ve slovníku děje cokoli:

veky.pop("Anna")
print(veky["Petra"])    # 25

Slovníky – názorné vysvětlení

Kdy co: seznam – záleží na pořadí, nebo hodnoty nemají jméno: fronta, playlist, naměřené teploty, žebříček slovník – hledáš podle jména nebo kódu: ceník, telefonní seznam, překlady, kdo co přinese

N-tice z lekce 8 se dál hodí na pevnou skupinu hodnot, které patří k sobě, třeba jméno a dárek.


Zpět na téma: Slovníky · Další: Cvičení: Slovníky

Zdrojový Python soubor

Cvičení: Slovníky

Každé cvičení má vlastní soubor ve složce lekce09-slovniky/01_slovniky/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Cvičení 1

Soubor: cviceni/01_bar.py

Na večírku je bar a tohle je jeho ceník. Postupně:

Voda stojí 20 Kč. {'pivo': 50, 'víno': 60, 'džus': 35, 'cola': 40} Položek: 4

cenik = {"pivo": 45, "víno": 60, "džus": 35, "voda": 20}
Zobrazit řešeníSkrýt řešení

Klíč v apostrofech – proč, najdeš v 01_proc_slovnik.py.

print(f"Voda stojí {cenik['voda']} Kč.")

cenik["cola"] = 40
cenik["pivo"] = cenik["pivo"] + 5
cenik.pop("voda")

print(cenik)
print(f"Položek: {len(cenik)}")

Cvičení 2

Soubor: cviceni/02_oprav_cenik.py

Oprav kód a soubor spusť (Run).

Program se zeptá na nápoj a vypíše jeho cenu. Když ale napíšeš "Pivo" nebo " pivo", spadne. Spadne i na "rum". Spusť ho, přečti si hlášku a oprav ho tak, aby:

cenik = {"pivo": 45, "víno": 60, "džus": 35}

napoj = input("Co si dáš? ")
print(f"{napoj} stojí {cenik[napoj]} Kč.")
Zobrazit řešeníSkrýt řešení
cenik = {"pivo": 45, "víno": 60, "džus": 35}

napoj = input("Co si dáš? ").strip().lower()

if napoj in cenik:
    print(f"{napoj} stojí {cenik[napoj]} Kč.")
else:
    print("Tohle nemáme.")

Cvičení 3

Soubor: cviceni/03_ucet.py

Petra si u baru objednala několik nápojů. Spočítej, kolik zaplatí. Nápoj, který v ceníku není, nepočítej a vypiš "Tohle nemáme: ...".

Tohle nemáme: šampaňské Celkem: 185 Kč

cenik = {"pivo": 45, "víno": 60, "džus": 35, "voda": 20}
objednavka = ["pivo", "víno", "šampaňské", "pivo", "džus"]
Zobrazit řešeníSkrýt řešení
cenik = {"pivo": 45, "víno": 60, "džus": 35, "voda": 20}
objednavka = ["pivo", "víno", "šampaňské", "pivo", "džus"]

celkem = 0

for napoj in objednavka:
    if napoj in cenik:
        celkem = celkem + cenik[napoj]
    else:
        print(f"Tohle nemáme: {napoj}")

print(f"Celkem: {celkem} Kč")

Cvičení 4

Soubor: cviceni/04_telefonni_seznam.py

Telefonní seznam. Ptej se "Jméno: ", dokud uživatel nenapíše "konec".

Jméno: anna

602 111 222
Jméno: Eva
Číslo: 777 555 666
Jméno: EVA
777 555 666

Jméno: konec Anna: 602 111 222 Petra: 731 333 444 Eva: 777 555 666

telefony = {"Anna": "602 111 222", "Petra": "731 333 444"}
Zobrazit řešeníSkrýt řešení
telefony = {"Anna": "602 111 222", "Petra": "731 333 444"}

while True:
    jmeno = input("Jméno: ").strip().lower()
    if jmeno == "konec":
        break
    if jmeno == "":
        continue

    jmeno = jmeno.title()
    if jmeno in telefony:
        print(telefony[jmeno])
    else:
        telefony[jmeno] = input("Číslo: ").strip()

for jmeno, cislo in telefony.items():
    print(f"{jmeno}: {cislo}")

Vstup se nejdřív zbaví mezer a převede na malá písmena. Díky tomu projde i "KONEC". Teprve potom dostane jméno velké první písmeno, aby sedělo s klíči ve slovníku.

Cvičení 5

Soubor: cviceni/05_prekladac.py

Napiš funkci preloz, která má na vstupu větu a slovník s překlady. Vrátí větu přeloženou slovo po slově. Slova, která ve slovníku nejsou, nechá, jak jsou. Velikost písmen ve větě nehraje roli.

Pak se zeptej na větu a vypiš její překlad. Větu piš bez tečky a čárek.

Věta: Kočka pije mléko cat drinks milk

Věta: pes jí knedlík dog eats knedlík

slovnik = {
    "pes": "dog",
    "kočka": "cat",
    "jí": "eats",
    "pije": "drinks",
    "mléko": "milk",
    "maso": "meat",
    "a": "and",
}
Zobrazit řešeníSkrýt řešení
slovnik = {
    "pes": "dog",
    "kočka": "cat",
    "jí": "eats",
    "pije": "drinks",
    "mléko": "milk",
    "maso": "meat",
    "a": "and",
}

def preloz(veta, slovnik):
    prelozena = []
    for slovo in veta.lower().split():
        if slovo in slovnik:
            prelozena.append(slovnik[slovo])
        else:
            prelozena.append(slovo)
    return " ".join(prelozena)

veta = input("Věta: ")
print(preloz(veta, slovnik))

Podmínku v cyklu jde zkrátit metodou get. Když slovo ve slovníku není, vrátí místo překladu slovo samotné:

prelozena.append(slovnik.get(slovo, slovo))

Funkce větu nevypisuje, ale vrací. Díky tomu ji můžeš vyzkoušet i bez psaní do terminálu:

print(preloz("pes a kočka", slovnik))     # dog and cat

Proč bez tečky? Metoda split dělí jen podle mezer, takže z věty "Kočka pije mléko." vznikne slovo "mléko." i s tečkou. Takový klíč ve slovníku není a slovo zůstane nepřeložené.

Cvičení 6

Soubor: cviceni/06_morseovka.py

Napiš funkci do_morseovky, která má na vstupu text a vrátí ho v Morseově abecedě:

Pak se zeptej na text a vypiš ho v morseovce.

Text: Ahoj Petro

.- .... --- .--- / .--. . - .-. ---
MORSE = {
    "a": ".-", "b": "-...", "c": "-.-.", "d": "-..", "e": ".",
    "f": "..-.", "g": "--.", "h": "....", "i": "..", "j": ".---",
    "k": "-.-", "l": ".-..", "m": "--", "n": "-.", "o": "---",
    "p": ".--.", "q": "--.-", "r": ".-.", "s": "...", "t": "-",
    "u": "..-", "v": "...-", "w": ".--", "x": "-..-", "y": "-.--",
    "z": "--..",
}
Zobrazit řešeníSkrýt řešení
MORSE = {
    "a": ".-", "b": "-...", "c": "-.-.", "d": "-..", "e": ".",
    "f": "..-.", "g": "--.", "h": "....", "i": "..", "j": ".---",
    "k": "-.-", "l": ".-..", "m": "--", "n": "-.", "o": "---",
    "p": ".--.", "q": "--.-", "r": ".-.", "s": "...", "t": "-",
    "u": "..-", "v": "...-", "w": ".--", "x": "-..-", "y": "-.--",
    "z": "--..",
}

def do_morseovky(text):
    znacky = []
    for znak in text.lower():
        if znak == " ":
            znacky.append("/")
        elif znak in MORSE:
            znacky.append(MORSE[znak])
        else:
            znacky.append("?")
    return " ".join(znacky)

text = input("Text: ").strip()
print(do_morseovky(text))

Poslední dvě větve jde zkrátit metodou get:

else:
    znacky.append(MORSE.get(znak, "?"))

Zpět na téma: Slovníky · Další: Bonusová cvičení: Slovníky

Zdrojové soubory na GitHubu

Bonusová cvičení: Slovníky

Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce09-slovniky/01_slovniky/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Bonus 1

Soubor: cviceni_bonusy/01_scrabble.py

V naší verzi Scrabblu má každé písmeno svoji hodnotu. Napiš funkci body_za_slovo, která má na vstupu slovo a vrátí součet bodů za jeho písmena. Písmena, která ve slovníku nejsou, mají 0 bodů.

Pak se zeptej na dvě slova a vypiš, které má víc bodů.

První slovo: pes Druhé slovo: kočka pes: 3 b. kočka: 8 b. Vyhrává kočka.

BODY = {
    "a": 1, "e": 1, "i": 1, "o": 1, "n": 1, "s": 1, "t": 1, "v": 1,
    "d": 1, "k": 1, "l": 1, "p": 1, "r": 1, "m": 2, "u": 2, "y": 2,
    "b": 3, "c": 3, "j": 2, "z": 2, "h": 2, "č": 4, "ž": 4, "š": 4,
    "f": 5, "g": 5, "x": 10,
}
Zobrazit řešeníSkrýt řešení
BODY = {
    "a": 1, "e": 1, "i": 1, "o": 1, "n": 1, "s": 1, "t": 1, "v": 1,
    "d": 1, "k": 1, "l": 1, "p": 1, "r": 1, "m": 2, "u": 2, "y": 2,
    "b": 3, "c": 3, "j": 2, "z": 2, "h": 2, "č": 4, "ž": 4, "š": 4,
    "f": 5, "g": 5, "x": 10,
}

def body_za_slovo(slovo):
    soucet = 0
    for pismeno in slovo.lower():
        soucet = soucet + BODY.get(pismeno, 0)
    return soucet

prvni = input("První slovo: ")
druhe = input("Druhé slovo: ")

body_prvni = body_za_slovo(prvni)
body_druhe = body_za_slovo(druhe)

print(f"{prvni}: {body_prvni} b.")
print(f"{druhe}: {body_druhe} b.")

if body_prvni > body_druhe:
    print(f"Vyhrává {prvni}.")
elif body_druhe > body_prvni:
    print(f"Vyhrává {druhe}.")
else:
    print("Remíza.")

Bonus 2

Soubor: cviceni_bonusy/02_obraceny_seznam.py

Ve slovníku se hledá jen podle klíče. Někdo ti volá z čísla 731 333 444 a ty chceš vědět, kdo to je.

Napiš funkci otoc_slovnik, která má na vstupu slovník a vrátí nový slovník, kde jsou klíče a hodnoty prohozené. Pak v něm číslo najdi.

Volá: Petra

telefony = {"Anna": "602 111 222", "Petra": "731 333 444", "Jana": "608 999 000"}
Zobrazit řešeníSkrýt řešení
telefony = {"Anna": "602 111 222", "Petra": "731 333 444", "Jana": "608 999 000"}

def otoc_slovnik(slovnik):
    otoceny = {}
    for klic, hodnota in slovnik.items():
        otoceny[hodnota] = klic
    return otoceny

podle_cisla = otoc_slovnik(telefony)
print(f"Volá: {podle_cisla['731 333 444']}")

Pozor: kdyby dva lidé měli stejné číslo, v otočeném slovníku zůstane jen poslední z nich. Klíč může být ve slovníku jen jednou.


Zpět na téma: Slovníky

Zdrojové soubory na GitHubu

Počítání a skupiny

Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.

Zpět na přehled hodiny

Slovník jako počítadlo

Spusť soubor a porovnej výsledky.

Hosté hlasovali, která písnička na večírku zazní jako první:

hlasy = ["Trezor", "Jožin z bažin", "Trezor", "Holky z naší školky",
         "Trezor", "Jožin z bažin"]

Metodou count z lekce 8 spočítáš hlasy pro jednu písničku:

print(hlasy.count("Trezor"))    # 3

Na všechny písničky bys ale musela předem vědět, které to jsou, a zavolat count pro každou zvlášť. Slovník spočítá všechny najednou, za jeden průchod cyklem. Klíč je písnička a hodnota počet hlasů.

V první sekci jsi přičítala sklenky řádkem sklenky["Anna"] = sklenky["Anna"] + 1. Tady by stejný řádek spadl hned u prvního hlasu:

pocty = {}
pocty["Trezor"] = pocty["Trezor"] + 1     KeyError: 'Trezor'

Pravá strana čte klíč, který ve slovníku ještě není. Proto se nejdřív zeptáš, jestli tam písnička už je:

pocty = {}

for pisnicka in hlasy:
    if pisnicka in pocty:
        pocty[pisnicka] = pocty[pisnicka] + 1
    else:
        pocty[pisnicka] = 1

print(pocty)    # {'Trezor': 3, 'Jožin z bažin': 2, 'Holky z naší školky': 1}

Když písnička ve slovníku ještě není, dostane první hlas. Když už tam je, přičte se jí jednička. Je to počítadlo z lekce 3, jen jich máš tolik, kolik je různých písniček.

Totéž jde napsat kratší cestou, metodou get. Vrátí dosavadní počet hlasů, nebo 0, když písnička ještě žádný nemá:

pocty = {}

for pisnicka in hlasy:
    pocty[pisnicka] = pocty.get(pisnicka, 0) + 1

print(pocty)    # {'Trezor': 3, 'Jožin z bažin': 2, 'Holky z naší školky': 1}

Oba zápisy dělají totéž. Používej ten, kterému rozumíš líp.

Text se prochází po znacích (lekce 3), takže stejně spočítáš písmena:

pismena = {}

for pismeno in "ananas":
    if pismeno in pismena:
        pismena[pismeno] = pismena[pismeno] + 1
    else:
        pismena[pismeno] = 1

print(pismena)  # {'a': 3, 'n': 2, 's': 1}

Zpět na téma: Počítání a skupiny · Další: Kdo vyhrál

Zdrojový Python soubor

Kdo vyhrál

Spusť soubor a porovnej výsledky.

pocty = {"Trezor": 3, "Jožin z bažin": 2, "Holky z naší školky": 1}

Funkce max ti řekne nejvyšší počet hlasů, ale ne písničku:

print(max(pocty.values()))      # 3

Vítěze najdeš stejným cyklem, jakým jsi v lekci 3 hledala největší číslo. Jen si k počtu pamatuješ i klíč.

Na začátku vítěze ještě neznáš, proto je v proměnné None, tedy „nic“ (lekce 5). Když nikdo nehlasoval a slovník je prázdný, cyklus neproběhne ani jednou a vitez zůstane None. Podle toho to poznáš: if vitez is None.

vitez = None
nejvic = 0

for pisnicka, pocet in pocty.items():
    if pocet > nejvic:
        vitez = pisnicka
        nejvic = pocet

print(f"Vyhrála písnička {vitez} ({nejvic} hlasy).")

Vyhrála písnička Trezor (3 hlasy).

Co když mají dvě písničky stejně hlasů? Porovnání > pustí dál jen větší počet, takže vyhraje ta, která byla ve slovníku dřív:

pocty = {"Trezor": 2, "Jožin z bažin": 2}

vitez = None
nejvic = 0

for pisnicka, pocet in pocty.items():
    if pocet > nejvic:
        vitez = pisnicka
        nejvic = pocet

print(vitez)    # Trezor

Když chceš všechny vítěze, najdi nejdřív nejvyšší počet a pak posbírej všechny písničky, které ho mají:

nejvic = max(pocty.values())

vitezove = []
for pisnicka, pocet in pocty.items():
    if pocet == nejvic:
        vitezove.append(pisnicka)

print(vitezove)     # ['Trezor', 'Jožin z bažin']

Zpět na téma: Počítání a skupiny · Další: Rozdělení do skupin

Zdrojový Python soubor

Rozdělení do skupin

Spusť soubor a porovnej výsledky.

prinesou = [("Anna", "dort"), ("Petra", "víno"), ("Jana", "chlebíčky"),
            ("Eva", "víno"), ("Marie", "dort")]

Kdo přinese který dárek? Klíč je dárek a hodnota seznam jmen. Seznam pro dárek založíš, když na dárek narazíš poprvé. Pak do něj přidáváš:

podle_darku = {}

for jmeno, darek in prinesou:
    if darek not in podle_darku:
        podle_darku[darek] = []
    podle_darku[darek].append(jmeno)

print(podle_darku)

{'dort': ['Anna', 'Marie'], 'víno': ['Petra', 'Eva'], 'chlebíčky': ['Jana']}

Řádek s append čti po krocích. Dělá totéž co tyhle dva řádky:

jmena = podle_darku[darek]      seznam, který patří k dárku
jmena.append(jmeno)             přidá do něj jméno

Seznam ve slovníku se tím změní. Proměnná jmena a podle_darku[darek] jsou dvě jména pro jeden seznam, jako v lekci 8.

Skupiny pak projdeš jako každý slovník. Seznam jmen spojíš metodou join:

for darek, jmena in podle_darku.items():
    print(f"{darek}: {', '.join(jmena)}")

dort: Anna, Marie víno: Petra, Eva chlebíčky: Jana

Klíčem může být i n-tice. Tak rozdělíš hosty podle dvou věcí najednou, třeba podle stolu a nápoje:

hoste = [("Anna", 1, "víno"), ("Petra", 1, "džus"), ("Jana", 2, "víno"),
         ("Eva", 1, "víno")]

skupiny = {}

for jmeno, stul, napoj in hoste:
    klic = (stul, napoj)
    if klic not in skupiny:
        skupiny[klic] = []
    skupiny[klic].append(jmeno)

print(skupiny)

{(1, 'víno'): ['Anna', 'Eva'], (1, 'džus'): ['Petra'], (2, 'víno'): ['Jana']}

print(skupiny[(1, "víno")])     # ['Anna', 'Eva']

Seznam klíčem být nemůže, protože se dá měnit. Python by spadl s hláškou TypeError: unhashable type: 'list'. N-tice se měnit nedá (lekce 8), proto klíčem být může.


Zpět na téma: Počítání a skupiny · Další: Cvičení: Počítání a skupiny

Zdrojový Python soubor

Cvičení: Počítání a skupiny

Každé cvičení má vlastní soubor ve složce lekce09-slovniky/02_pocitani_a_skupiny/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Cvičení 1

Soubor: cviceni/01_hlasovani.py

Hosté vybírají dezert. Ptej se "Hlas: ", dokud někdo nenapíše "konec".

Hlas: dort Hlas: Zmrzlina Hlas: dort Hlas: konec dort: 2 zmrzlina: 1 Vyhrává dort.

Zobrazit řešeníSkrýt řešení
def najdi_viteze(hlasy):
    vitez = None
    nejvic = 0
    for dezert, pocet in hlasy.items():
        if pocet > nejvic:
            vitez = dezert
            nejvic = pocet
    return vitez

hlasy = {}

while True:
    hlas = input("Hlas: ").strip().lower()
    if hlas == "konec":
        break
    if hlas == "":
        continue

    if hlas in hlasy:
        hlasy[hlas] = hlasy[hlas] + 1
    else:
        hlasy[hlas] = 1

for dezert, pocet in hlasy.items():
    print(f"{dezert}: {pocet}")

vitez = najdi_viteze(hlasy)
if vitez is None:
    print("Nikdo nehlasoval.")
else:
    print(f"Vyhrává {vitez}.")

Když je slovník prázdný, cyklus ve funkci neproběhne ani jednou a vitez zůstane None. Zápis is None znáš z první sekce.

Cvičení 2

Soubor: cviceni/02_slova_ve_zprave.py

Napiš funkci spocitej_slova, která má na vstupu text a vrátí slovník: klíč je slovo a hodnota říká, kolikrát v textu je. Velikost písmen nehraje roli.

Pak vypiš jen slova, která jsou ve zprávě víc než jednou.

kdo: 3 přinese: 2 a: 2

zprava = "Kdo přinese víno a kdo přinese dort a kdo přijde pozdě"
Zobrazit řešeníSkrýt řešení
zprava = "Kdo přinese víno a kdo přinese dort a kdo přijde pozdě"

def spocitej_slova(text):
    pocty = {}
    for slovo in text.lower().split():
        if slovo in pocty:
            pocty[slovo] = pocty[slovo] + 1
        else:
            pocty[slovo] = 1
    return pocty

pocty = spocitej_slova(zprava)

for slovo, pocet in pocty.items():
    if pocet > 1:
        print(f"{slovo}: {pocet}")

Podmínku ve funkci jde zkrátit metodou get:

pocty[slovo] = pocty.get(slovo, 0) + 1

Pro prázdný text vrátí funkce prázdný slovník:

print(spocitej_slova(""))       # {}

Cvičení 3

Soubor: cviceni/03_kostky.py

Hoď kostkou 600krát a spočítej, kolikrát padlo které číslo.

1: ********* (97)
2: ********** (104)
...

Na první řádek patří: from random import randrange randrange(1, 7) vrátí náhodné číslo od 1 do 6.

Zobrazit řešeníSkrýt řešení
from random import randrange
pocty = {}
for cislo in range(1, 7):
    pocty[cislo] = 0

for hod in range(600):
    cislo = randrange(1, 7)
    pocty[cislo] = pocty[cislo] + 1

for cislo, pocet in pocty.items():
    hvezdicky = "*" * (pocet // 10)
    print(f"{cislo}: {hvezdicky} ({pocet})")

Cvičení 4

Soubor: cviceni/04_podle_pismene.py

Napiš funkci rozdel_podle_pismene, která má na vstupu seznam jmen a vrátí slovník: klíč je první písmeno a hodnota seznam jmen, která jím začínají.

Pak vypiš každé písmeno a za ním jména oddělená čárkou.

A: Anna, Adéla P: Petra, Pavla J: Jana

hoste = ["Anna", "Petra", "Jana", "Adéla", "Pavla"]
Zobrazit řešeníSkrýt řešení
hoste = ["Anna", "Petra", "Jana", "Adéla", "Pavla"]

def rozdel_podle_pismene(jmena):
    skupiny = {}
    for jmeno in jmena:
        pismeno = jmeno[0]
        if pismeno not in skupiny:
            skupiny[pismeno] = []
        skupiny[pismeno].append(jmeno)
    return skupiny

podle_pismene = rozdel_podle_pismene(hoste)

for pismeno, jmena in podle_pismene.items():
    print(f"{pismeno}: {', '.join(jmena)}")

Funkce počítá s tím, že žádné jméno není prázdný text. U prázdného textu by jmeno[0] spadlo na IndexError.

Cvičení 5

Soubor: cviceni/05_zmizele_objednavky.py

Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.

Program má spočítat, kolikrát si hosté objednali který nápoj. Vypíše ale jen {'pivo': 1}. Dej breakpoint na řádek s if a krokuj. V panelu Variables sleduj napoj a pocty. Pak program oprav.

Vyjít má: {'víno': 1, 'pivo': 3, 'džus': 1}

objednavky = ["víno", "pivo", "džus", "pivo", "pivo"]

for napoj in objednavky:
    pocty = {}
    if napoj in pocty:
        pocty[napoj] = pocty[napoj] + 1
    else:
        pocty[napoj] = 1

print(pocty)
Zobrazit řešeníSkrýt řešení
objednavky = ["víno", "pivo", "džus", "pivo", "pivo"]

pocty = {}
for napoj in objednavky:
    if napoj in pocty:
        pocty[napoj] = pocty[napoj] + 1
    else:
        pocty[napoj] = 1

print(pocty)

Řádek pocty = {} byl uvnitř cyklu. V každém průchodu tak vznikl nový prázdný slovník a do něj se zapsal jen aktuální nápoj. Prázdný slovník se musí založit jednou, před cyklem.

Cvičení 6

Soubor: cviceni/06_utrata_hostu.py

Jsou tu tři chyby a každá je jiného druhu. Jednu ti ukáže chybová hláška, další dvě najdeš debuggerem. Oprav je po jedné a po každé opravě program spusť.

Barman si zapisoval, kdo si co objednal. Píše, jak ho napadne, takže víno může být i "Víno". Program má spočítat útratu každého hosta a najít, kdo utratil nejvíc. Vypsat má:

Anna: 105 Kč Petra: 120 Kč Jana: 35 Kč Nejvíc utratila Petra (120 Kč).

cenik = {"pivo": 45, "víno": 60, "džus": 35}
objednavky = [("Anna", "pivo"), ("Petra", "víno"), ("Anna", "Víno"),
              ("Jana", "džus"), ("Petra", "víno")]

def spocitej_utraty(objednavky, cenik):
    utraty = {}
    for jmeno, napoj in objednavky:
        cena = cenik[napoj]
        if jmeno in utraty:
            utraty[jmeno] = cena
        else:
            utraty[jmeno] = cena
    return utraty

def kdo_nejvic(utraty):
    kdo = ""
    nejvic = 0
    for jmeno, castka in utraty.items():
        if castka > nejvic:
            kdo = jmeno
    return kdo, nejvic

utraty = spocitej_utraty(objednavky, cenik)

for jmeno, castka in utraty.items():
    print(f"{jmeno}: {castka} Kč")

kdo, castka = kdo_nejvic(utraty)
print(f"Nejvíc utratila {kdo} ({castka} Kč).")
Zobrazit řešeníSkrýt řešení
cenik = {"pivo": 45, "víno": 60, "džus": 35}
objednavky = [("Anna", "pivo"), ("Petra", "víno"), ("Anna", "Víno"),
              ("Jana", "džus"), ("Petra", "víno")]

def spocitej_utraty(objednavky, cenik):
    utraty = {}
    for jmeno, napoj in objednavky:
        cena = cenik[napoj.lower()]                 # 1. chyba
        if jmeno in utraty:
            utraty[jmeno] = utraty[jmeno] + cena    # 2. chyba
        else:
            utraty[jmeno] = cena
    return utraty

def kdo_nejvic(utraty):
    kdo = ""
    nejvic = 0
    for jmeno, castka in utraty.items():
        if castka > nejvic:
            kdo = jmeno
            nejvic = castka                         # 3. chyba
    return kdo, nejvic

utraty = spocitej_utraty(objednavky, cenik)

for jmeno, castka in utraty.items():
    print(f"{jmeno}: {castka} Kč")

kdo, castka = kdo_nejvic(utraty)
print(f"Nejvíc utratila {kdo} ({castka} Kč).")
  1. KeyError: 'Víno' – v ceníku jsou nápoje malými písmeny. Ukázala ji chybová hláška.

  2. Když host už ve slovníku byl, jeho útrata se přepsala cenou posledního nápoje místo toho, aby se k ní přičetla. V debuggeru je vidět, že Anně se z 45 stane 60.

  3. Proměnná nejvic zůstávala na nule, takže podmínku splnil každý host a vyhrál ten poslední. V debuggeru je vidět, že nejvic se nemění.


Zpět na téma: Počítání a skupiny · Další: Bonusová cvičení: Počítání a skupiny

Zdrojové soubory na GitHubu

Bonusová cvičení: Počítání a skupiny

Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce09-slovniky/02_pocitani_a_skupiny/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Bonus 1

Soubor: cviceni_bonusy/01_anagramy.py

Anagramy jsou slova ze stejných písmen, jen jinak poskládaných, třeba "rak" a "kra". Rozděl slova do skupin anagramů a vypiš skupiny, ve kterých je víc než jedno slovo.

Tip: dvě slova jsou anagramy, když mají po seřazení písmen stejný text. Slovo převedeš na seznam písmen funkcí list (lekce 8), seznam seřadíš metodou sort a zpátky spojíš metodou join.

rak, kra kos, sok loket, kotel lak, kal

slova = ["rak", "kos", "loket", "kra", "les", "sok", "kotel", "lak", "kal"]
Zobrazit řešeníSkrýt řešení
slova = ["rak", "kos", "loket", "kra", "les", "sok", "kotel", "lak", "kal"]

def serazena_pismena(slovo):
    pismena = list(slovo)
    pismena.sort()
    return "".join(pismena)

skupiny = {}
for slovo in slova:
    klic = serazena_pismena(slovo)
    if klic not in skupiny:
        skupiny[klic] = []
    skupiny[klic].append(slovo)

for slova_ve_skupine in skupiny.values():
    if len(slova_ve_skupine) > 1:
        print(", ".join(slova_ve_skupine))

Bonus 2

Soubor: cviceni_bonusy/02_turnaj.py

Na večírku se hraje turnaj v ping-pongu. Každý zápas je dvojice (vítěz, poražený). Spočítej, kolik zápasů kdo vyhrál. Ve výsledku musí být každý hráč, i ten, kdo nevyhrál nic.

Anna: 2 Petra: 1 Jana: 0

zapasy = [("Anna", "Petra"), ("Petra", "Jana"), ("Anna", "Jana")]
Zobrazit řešeníSkrýt řešení
zapasy = [("Anna", "Petra"), ("Petra", "Jana"), ("Anna", "Jana")]

vyhry = {}
for vitez, porazeny in zapasy:
    if vitez in vyhry:
        vyhry[vitez] = vyhry[vitez] + 1
    else:
        vyhry[vitez] = 1
    if porazeny not in vyhry:
        vyhry[porazeny] = 0

for hrac, pocet in vyhry.items():
    print(f"{hrac}: {pocet}")

Zpět na téma: Počítání a skupiny

Zdrojové soubory na GitHubu

Záznamy

Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.

Zpět na přehled hodiny

Slovník jako záznam

Spusť soubor a porovnej výsledky.

V lekci 8 jsi o hostovi držela víc údajů v n-tici:

anna = ("Anna", 34, "dort")
print(anna[1])          # 34

Co je 34? Musíš si pamatovat, že na indexu 1 je věk.

Slovník může držet údaje o jedné věci. Klíče jsou názvy údajů, takže je hned vidět, co je co:

anna = {"jmeno": "Anna", "vek": 34, "darek": "dort"}

print(anna["vek"])      # 34
print(f"{anna['jmeno']} přinese {anna['darek']}.")     # Anna přinese dort.

V lekci 8 jsme si řekli, že míchat v seznamu různé druhy hodnot nebývá dobrý nápad. V záznamu je to naopak běžné: text, číslo, cokoli. Každý klíč má svůj vlastní údaj, takže víš, co pod ním najdeš.

Údaj přidáš nebo změníš jako u každého slovníku:

anna["telefon"] = "602 111 222"
anna["darek"] = "koláč"
print(anna)

{'jmeno': 'Anna', 'vek': 34, 'darek': 'koláč', 'telefon': '602 111 222'}

Takhle může vypadat i výsledek funkce. V lekci 8 vracela funkce n-tici a ty sis musela pamatovat pořadí. Ve slovníku má každá hodnota jméno.

Dlouhý slovník se dá rozepsat na víc řádků, jako seznam s kvízem v lekci 8. Každá dvojice na vlastním řádku se líp čte.

def statistika(veky):
    if len(veky) == 0:
        return {"pocet": 0, "prumer": None, "nejstarsi": None}

    return {
        "pocet": len(veky),
        "prumer": sum(veky) / len(veky),
        "nejstarsi": max(veky),
    }

vysledek = statistika([34, 25, 41])
print(f"{vysledek['prumer']:.1f}")     # 33.3
print(vysledek["nejstarsi"])    # 41

print(statistika([]))   # {'pocet': 0, 'prumer': None, 'nejstarsi': None}

Prázdný seznam se kontroluje jako první. Jinak by funkce spadla na dělení nulou.


Zpět na téma: Záznamy · Další: Seznam slovníků: tabulka

Zdrojový Python soubor

Seznam slovníků: tabulka

Spusť soubor a porovnej výsledky.

Hostů je víc, takže záznamy dáš do seznamu. Každý slovník je jeden host a všechny mají stejné klíče:

hoste = [
    {"jmeno": "Anna", "vek": 34, "darek": "dort"},
    {"jmeno": "Petra", "vek": 25, "darek": "víno"},
    {"jmeno": "Jana", "vek": 41, "darek": "víno"},
]

Je to vlastně tabulka. Položky seznamu jsou řádky, klíče sloupce:

jmeno vek darek Anna 34 dort Petra 25 víno Jana 41 víno

Jeden údaj přečteš ve dvou krocích. Nejdřív vezmeš hosta ze seznamu, pak údaj ze slovníku:

prvni = hoste[0]
print(prvni["jmeno"])           # Anna

Oba kroky jde napsat za sebe. Čte se to zleva doprava:

print(hoste[0]["jmeno"])        # Anna

Kratší ale neznamená lepší. Když se ti to líp čte ve dvou krocích, piš to ve dvou krocích.

V cyklu dostaneš po jednom celé záznamy:

for host in hoste:
    print(f"{host['jmeno']:6} {host['vek']:3}   {host['darek']}")

Anna 34 dort Petra 25 víno Jana 41 víno

Se záznamy funguje všechno, co už znáš. Kdo přinese víno:

vino = []
for host in hoste:
    if host["darek"] == "víno":
        vino.append(host["jmeno"])

print(vino)                     # ['Petra', 'Jana']

Průměrný věk:

soucet = 0
for host in hoste:
    soucet = soucet + host["vek"]

print(f"Průměrný věk: {soucet / len(hoste):.1f}")      # Průměrný věk: 33.3

Přesně takhle vypadají data z tabulky v souboru CSV. Každý řádek se načte jako jeden slovník. Na workshopu a v lekci 13 to uvidíš naživo.


Zpět na téma: Záznamy · Další: Data v datech

Zdrojový Python soubor

Data v datech

Spusť soubor a porovnej výsledky.

Seznam jako hodnotu ve slovníku znáš ze skupin v minulé sekci. Hodnotou může být i další slovník. Nové je tu čtení o dvě úrovně hluboko. Celý večírek v jedné proměnné:

vecirek = {
    "datum": "21. 11.",
    "hoste": ["Anna", "Petra", "Jana"],
    "rozpocet": {"jidlo": 1500, "piti": 800},
}

Čte se to po krocích, stejně jako seznam slovníků. Pod klíčem "hoste" je seznam:

hoste = vecirek["hoste"]
print(hoste)                    # ['Anna', 'Petra', 'Jana']
print(hoste[0])                 # Anna

Za sebou:

print(vecirek["hoste"][0])      # Anna

Pod klíčem "rozpocet" je další slovník:

rozpocet = vecirek["rozpocet"]
print(rozpocet["piti"])         # 800

Za sebou:

print(vecirek["rozpocet"]["piti"])      # 800

Zápis za sebou je kratší, s mezikrokem přehlednější. Vyber si, co se ti líp čte.

Když si nejsi jistá, co je pod klíčem schované, vypiš to. Hranaté závorky ve výpisu znamenají seznam, složené slovník.

Měnit se to dá stejně. Přišla Eva a na pití se přidává 200 Kč:

vecirek["hoste"].append("Eva")
vecirek["rozpocet"]["piti"] = vecirek["rozpocet"]["piti"] + 200

print(vecirek["hoste"])         # ['Anna', 'Petra', 'Jana', 'Eva']
print(vecirek["rozpocet"])      # {'jidlo': 1500, 'piti': 1000}

Celkový rozpočet sečteš přes hodnoty vnitřního slovníku:

print(sum(vecirek["rozpocet"].values()))       # 2500

Data z webových služeb a ze souborů JSON vypadají přesně takhle: slovníky a seznamy v sobě. Potkáš je na workshopu.


Zpět na téma: Záznamy · Další: Slovník ve funkci a kopie

Zdrojový Python soubor

Slovník ve funkci a kopie

Spusť soubor a porovnej výsledky.

Se slovníkem je to stejné jako se seznamem v lekci 8. Funkce dostane ten samý slovník, a když ho změní, je to vidět i venku:

def pridej_skupinu(host):
    if host["vek"] < 18:
        host["skupina"] = "dítě"
    else:
        host["skupina"] = "dospělý"

anna = {"jmeno": "Anna", "vek": 34}
pridej_skupinu(anna)
print(anna)     # {'jmeno': 'Anna', 'vek': 34, 'skupina': 'dospělý'}

Funkce nic nevrací, a přesto se slovník změnil. Někdy je to přesně to, co chceš. Funkce pak upraví všechny záznamy v seznamu jedním cyklem:

hoste = [{"jmeno": "Petra", "vek": 25}, {"jmeno": "Tom", "vek": 9}]

for host in hoste:
    pridej_skupinu(host)

print(hoste)

[{'jmeno': 'Petra', 'vek': 25, 'skupina': 'dospělý'}, {'jmeno': 'Tom', 'vek': 9, 'skupina': 'dítě'}]

Pozor na to i mimo funkce. Přiřazení slovník nezkopíruje, obě proměnné pak ukazují na jeden slovník:

jana = {"jmeno": "Jana", "vek": 41}
druha = jana
druha["vek"] = 99
print(jana["vek"])          # 99

Když původní slovník změnit nechceš, udělej si kopii metodou copy. Funguje stejně jako u seznamů v lekci 8 (soubor 07_dve_jmena.py):

def s_kontaktem(host, telefon):
    novy = host.copy()
    novy["telefon"] = telefon
    return novy

jana = {"jmeno": "Jana", "vek": 41}
jana_s_kontaktem = s_kontaktem(jana, "608 999 000")

print(jana_s_kontaktem)     # {'jmeno': 'Jana', 'vek': 41, 'telefon': '608 999 000'}
print(jana)                 # {'jmeno': 'Jana', 'vek': 41}

Shrnutí celé lekce. Slovník se hodí na tři věci:

hledání podle klíče ceník, telefonní seznam, překlady počítání a skupiny hlasy pro písničky, kdo přinese co záznam o jedné věci host se jménem, věkem a dárkem

Seznam slovníků je pak celá tabulka. Přesně s těmihle třemi postupy budeš pracovat na sobotním workshopu.


Zpět na téma: Záznamy · Další: Cvičení: Záznamy

Zdrojový Python soubor

Cvičení: Záznamy

Každé cvičení má vlastní soubor ve složce lekce09-slovniky/03_zaznamy/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Cvičení 1

Soubor: cviceni/01_vizitka.py

Vytvoř slovník o sobě s klíči jmeno, mesto a oblibene_jidlo. Pak:

Zobrazit řešeníSkrýt řešení
ja = {"jmeno": "Anna", "mesto": "Brno", "oblibene_jidlo": "knedlíky"}

print(f"Jmenuju se {ja['jmeno']} a bydlím ve městě {ja['mesto']}.")
print(f"Nejradši jím {ja['oblibene_jidlo']}.")

ja["konicky"] = ["lezení", "šachy", "Python"]

for konicek in ja["konicky"]:
    print(f"- {konicek}")

Cvičení 2

Soubor: cviceni/02_filmovy_vecer.py

Na filmový večer hosté obodovali filmy od 1 do 10. Napiš tři funkce, které mají na vstupu seznam filmů:

Když je seznam prázdný, vrátí prumer_bodu a nejlepsi_film None. Pak pomocí funkcí vypiš:

Od roku 2000: Kytice, Tmavomodrý svět, Samotáři Průměr: 7.5 Nejlepší: Pelíšky (9 bodů)

filmy = [
    {"nazev": "Vesničko má středisková", "rok": 1985, "body": 8},
    {"nazev": "Kytice", "rok": 2000, "body": 6},
    {"nazev": "Tmavomodrý svět", "rok": 2001, "body": 7},
    {"nazev": "Pelíšky", "rok": 1999, "body": 9},
    {"nazev": "Samotáři", "rok": 2000, "body": 8},
    {"nazev": "Obecná škola", "rok": 1991, "body": 7},
]
Zobrazit řešeníSkrýt řešení
filmy = [
    {"nazev": "Vesničko má středisková", "rok": 1985, "body": 8},
    {"nazev": "Kytice", "rok": 2000, "body": 6},
    {"nazev": "Tmavomodrý svět", "rok": 2001, "body": 7},
    {"nazev": "Pelíšky", "rok": 1999, "body": 9},
    {"nazev": "Samotáři", "rok": 2000, "body": 8},
    {"nazev": "Obecná škola", "rok": 1991, "body": 7},
]

def filmy_od_roku(filmy, rok):
    nazvy = []
    for film in filmy:
        if film["rok"] >= rok:
            nazvy.append(film["nazev"])
    return nazvy

def prumer_bodu(filmy):
    if len(filmy) == 0:
        return None

    soucet = 0
    for film in filmy:
        soucet = soucet + film["body"]
    return soucet / len(filmy)

def nejlepsi_film(filmy):
    if len(filmy) == 0:
        return None

    nejlepsi = filmy[0]
    for film in filmy:
        if film["body"] > nejlepsi["body"]:
            nejlepsi = film
    return nejlepsi

print(f"Od roku 2000: {', '.join(filmy_od_roku(filmy, 2000))}")
print(f"Průměr: {prumer_bodu(filmy):.1f}")

nejlepsi = nejlepsi_film(filmy)
print(f"Nejlepší: {nejlepsi['nazev']} ({nejlepsi['body']} bodů)")

U nejlepšího filmu si stačí pamatovat celý záznam. Název i body z něj pak přečteš.

Kontrola prázdného seznamu je ve funkcích první. Bez ní by průměr spadl na dělení nulou a filmy[0] na IndexError.

Cvičení 3

Soubor: cviceni/03_ukoly_na_vecirek.py

Na večírek je potřeba spoustu věcí zařídit. Vypiš:

Hotovo: 2 z 5 Anna: upéct dort Petra: nafouknout balonky, připravit playlist

ukoly = [
    {"ukol": "koupit víno", "kdo": "Petra", "hotovo": True},
    {"ukol": "upéct dort", "kdo": "Anna", "hotovo": False},
    {"ukol": "nafouknout balonky", "kdo": "Petra", "hotovo": False},
    {"ukol": "poslat pozvánky", "kdo": "Jana", "hotovo": True},
    {"ukol": "připravit playlist", "kdo": "Petra", "hotovo": False},
]
Zobrazit řešeníSkrýt řešení
ukoly = [
    {"ukol": "koupit víno", "kdo": "Petra", "hotovo": True},
    {"ukol": "upéct dort", "kdo": "Anna", "hotovo": False},
    {"ukol": "nafouknout balonky", "kdo": "Petra", "hotovo": False},
    {"ukol": "poslat pozvánky", "kdo": "Jana", "hotovo": True},
    {"ukol": "připravit playlist", "kdo": "Petra", "hotovo": False},
]

hotovych = 0
zbyva = {}

for ukol in ukoly:
    if ukol["hotovo"]:
        hotovych = hotovych + 1
    else:
        kdo = ukol["kdo"]
        if kdo not in zbyva:
            zbyva[kdo] = []
        zbyva[kdo].append(ukol["ukol"])

print(f"Hotovo: {hotovych} z {len(ukoly)}")

for kdo, jeho_ukoly in zbyva.items():
    print(f"{kdo}: {', '.join(jeho_ukoly)}")

Cvičení 4

Soubor: cviceni/04_oprav_kontakty.py

Oprav kód a soubor spusť (Run).

Program má vypsat telefon každého hosta. Petra ale telefon nenechala a program na ní spadne. Spusť ho, přečti si hlášku a oprav ho tak, aby u Petry vypsal "neuvedeno".

Anna: 602 111 222 Petra: neuvedeno Jana: 608 999 000

hoste = [
    {"jmeno": "Anna", "telefon": "602 111 222"},
    {"jmeno": "Petra"},
    {"jmeno": "Jana", "telefon": "608 999 000"},
]

for host in hoste:
    print(f"{host['jmeno']}: {host['telefon']}")
Zobrazit řešeníSkrýt řešení
hoste = [
    {"jmeno": "Anna", "telefon": "602 111 222"},
    {"jmeno": "Petra"},
    {"jmeno": "Jana", "telefon": "608 999 000"},
]

for host in hoste:
    telefon = host.get("telefon", "neuvedeno")
    print(f"{host['jmeno']}: {telefon}")

Hláška KeyError: 'telefon' říká, že v jednom záznamu klíč chybí. Metoda get vrátí místo chyby výchozí hodnotu.

Cvičení 5

Soubor: cviceni/05_rozpocet.py

Plánovala jsi, kolik utratíš za večírek, a teď víš, kolik jsi opravdu utratila. U každé položky vypiš, o kolik jsi plán překročila nebo kolik ušetřila. Na konci vypiš, kolik jsi utratila celkem a kolik jsi plánovala.

jídlo: přes plán o 220 Kč pití: ušetřeno 150 Kč výzdoba: přesně podle plánu Celkem utraceno 2670 Kč z plánovaných 2600 Kč.

rozpocet = {
    "jídlo": {"plan": 1500, "utraceno": 1720},
    "pití": {"plan": 800, "utraceno": 650},
    "výzdoba": {"plan": 300, "utraceno": 300},
}
Zobrazit řešeníSkrýt řešení
rozpocet = {
    "jídlo": {"plan": 1500, "utraceno": 1720},
    "pití": {"plan": 800, "utraceno": 650},
    "výzdoba": {"plan": 300, "utraceno": 300},
}

celkem_plan = 0
celkem_utraceno = 0

for polozka, castky in rozpocet.items():
    plan = castky["plan"]
    utraceno = castky["utraceno"]
    celkem_plan = celkem_plan + plan
    celkem_utraceno = celkem_utraceno + utraceno

    if utraceno > plan:
        print(f"{polozka}: přes plán o {utraceno - plan} Kč")
    elif utraceno < plan:
        print(f"{polozka}: ušetřeno {plan - utraceno} Kč")
    else:
        print(f"{polozka}: přesně podle plánu")

print(f"Celkem utraceno {celkem_utraceno} Kč z plánovaných {celkem_plan} Kč.")

Cvičení 6

Soubor: cviceni/06_vstupenky.py

Jsou tu tři chyby a každá je jiného druhu. Jednu ti ukáže chybová hláška, další dvě najdeš debuggerem. Oprav je po jedné a po každé opravě program spusť.

Program prodává vstupenky na večírek. Děti do 15 let platí 100 Kč, ostatní 250 Kč. Funkce s_cenou má vrátit kopii hosta s cenou, původní seznam hostů se nemá změnit. Vypsat má:

Anna: 250 Kč Tom: 100 Kč Petra: 250 Kč Ema: 100 Kč Celkem: 700 Kč Původní záznam: {'jmeno': 'Anna', 'vek': 34}

hoste = [
    {"jmeno": "Anna", "vek": 34},
    {"jmeno": "Tom", "vek": 9},
    {"jmeno": "Petra", "vek": 25},
    {"jmeno": "Ema", "vek": 12},
]

def s_cenou(host):
    novy = host
    if host["vek"] < 15:
        novy["cena"] = 100
    else:
        novy["cena"] = 250
    return novy

def celkem(vstupenky):
    soucet = 0
    for vstupenka in vstupenky:
        soucet = soucet + vstupenka["cena"]
        return soucet

vstupenky = []
for host in hoste:
    vstupenky.append(s_cenou(host))

for vstupenka in vstupenky:
    print(f"{vstupenka['jmneo']}: {vstupenka['cena']} Kč")

print(f"Celkem: {celkem(vstupenky)} Kč")
print(f"Původní záznam: {hoste[0]}")
Zobrazit řešeníSkrýt řešení
hoste = [
    {"jmeno": "Anna", "vek": 34},
    {"jmeno": "Tom", "vek": 9},
    {"jmeno": "Petra", "vek": 25},
    {"jmeno": "Ema", "vek": 12},
]

def s_cenou(host):
    novy = host.copy()                  # 2. chyba
    if host["vek"] < 15:
        novy["cena"] = 100
    else:
        novy["cena"] = 250
    return novy

def celkem(vstupenky):
    soucet = 0
    for vstupenka in vstupenky:
        soucet = soucet + vstupenka["cena"]
    return soucet                       # 3. chyba

vstupenky = []
for host in hoste:
    vstupenky.append(s_cenou(host))

for vstupenka in vstupenky:
    print(f"{vstupenka['jmeno']}: {vstupenka['cena']} Kč")     # 1. chyba

print(f"Celkem: {celkem(vstupenky)} Kč")
print(f"Původní záznam: {hoste[0]}")
  1. KeyError: 'jmneo' – překlep v klíči. Ukázala ji chybová hláška.

  2. Bez copy byl novy jen druhé jméno pro původní slovník, takže cena se zapsala i do seznamu hostů. V debuggeru je vidět, že po prvním volání má cenu i hoste[0].

  3. Return byl odsazený uvnitř cyklu, takže funkce skončila po první vstupence a vrátila 250. Krokováním je vidět, že cyklus proběhne jen jednou.


Zpět na téma: Záznamy · Další: Bonusová cvičení: Záznamy

Zdrojové soubory na GitHubu

Bonusová cvičení: Záznamy

Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce09-slovniky/03_zaznamy/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Bonus 1

Soubor: cviceni_bonusy/01_recept.py

Recept je na 4 porce. Zeptej se, pro kolik lidí vaříš, a vypiš suroviny přepočítané na tolik porcí. Množství zaokrouhli na celé číslo (funkce round z lekce 3).

Když uživatel nezadá kladné celé číslo, vypiš "Zadej kladné celé číslo." a nic nepočítej.

Pro kolik lidí? 6 mouka: 750 g mléko: 450 ml vejce: 3 ks cukr: 150 g

recept = {
    "porce": 4,
    "suroviny": {
        "mouka": (500, "g"),
        "mléko": (300, "ml"),
        "vejce": (2, "ks"),
        "cukr": (100, "g"),
    },
}
Zobrazit řešeníSkrýt řešení
recept = {
    "porce": 4,
    "suroviny": {
        "mouka": (500, "g"),
        "mléko": (300, "ml"),
        "vejce": (2, "ks"),
        "cukr": (100, "g"),
    },
}

odpoved = input("Pro kolik lidí? ").strip()

if not odpoved.isdigit() or int(odpoved) == 0:
    print("Zadej kladné celé číslo.")
else:
    pomer = int(odpoved) / recept["porce"]

    for surovina, udaj in recept["suroviny"].items():
        mnozstvi, jednotka = udaj
        print(f"{surovina}: {round(mnozstvi * pomer)} {jednotka}")

Metodu isdigit znáš z lekce 6. Text jako "šest" nebo "-2" neprojde, takže se na něm int nespustí. Nulu je potřeba vyloučit zvlášť.

Bonus 2

Soubor: cviceni_bonusy/02_vyrovnani.py

Tři kamarádky platily za večírek každá něco. Náklady se mají rozdělit rovným dílem.

Anna zaplatila 510 Kč Petra zaplatila 480 Kč Jana zaplatila 360 Kč Na jednu: 450 Kč Anna dostane zpátky 60 Kč Petra dostane zpátky 30 Kč Jana doplatí 90 Kč

platby = [
    {"kdo": "Anna", "za_co": "dort", "castka": 420},
    {"kdo": "Petra", "za_co": "víno", "castka": 450},
    {"kdo": "Anna", "za_co": "balonky", "castka": 90},
    {"kdo": "Jana", "za_co": "chlebíčky", "castka": 360},
    {"kdo": "Petra", "za_co": "led", "castka": 30},
]
Zobrazit řešeníSkrýt řešení
platby = [
    {"kdo": "Anna", "za_co": "dort", "castka": 420},
    {"kdo": "Petra", "za_co": "víno", "castka": 450},
    {"kdo": "Anna", "za_co": "balonky", "castka": 90},
    {"kdo": "Jana", "za_co": "chlebíčky", "castka": 360},
    {"kdo": "Petra", "za_co": "led", "castka": 30},
]

def kolik_kdo_zaplatil(platby):
    zaplatila = {}
    for platba in platby:
        kdo = platba["kdo"]
        zaplatila[kdo] = zaplatila.get(kdo, 0) + platba["castka"]
    return zaplatila

zaplatila = kolik_kdo_zaplatil(platby)

if len(zaplatila) == 0:
    print("Nikdo nic neplatil.")
else:
    for kdo, castka in zaplatila.items():
        print(f"{kdo} zaplatila {castka} Kč")

    # Podíl se zaokrouhlí na celé koruny hned. Jinak by se porovnávaly
    # i haléře, které výpis nezobrazí, a mohlo by vyjít „doplatí 0 Kč“.
    na_jednu = round(sum(zaplatila.values()) / len(zaplatila))
    print(f"Na jednu: {na_jednu} Kč")

    for kdo, castka in zaplatila.items():
        rozdil = castka - na_jednu
        if rozdil > 0:
            print(f"{kdo} dostane zpátky {rozdil} Kč")
        elif rozdil < 0:
            print(f"{kdo} doplatí {-rozdil} Kč")
        else:
            print(f"{kdo} je vyrovnaná")

Zpět na téma: Záznamy

Zdrojové soubory na GitHubu