0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 24 min

JSON a CSV

Uložíš slovníky a tabulky tak, aby je přečetl jiný program i Excel, a poradíš si s českými CSV, čárkami v datech a rozbitými soubory.

Hloubka
Úkoly
Lidsky řečeno

Když stěhuješ byt, nehodíš všechno volně do auta. Věci dáš do krabic a popíšeš je, aby je někdo jiný dokázal vybalit. JSON je taková popsaná krabice pro data s libovolnou strukturou. CSV je zase obyčejná tabulka přepsaná do textu: řádek pod řádkem, sloupce oddělené čárkou.

Proč nestačí obyčejný text

Máš slovník s objednávkou a chceš ho uložit. Přes str to vypadá hotově, ale zpátky se z textu slovník jen tak nestane a jiný program mu nebude rozumět. JSON je textový formát, kterému rozumí skoro každý jazyk, webové API i konfigurační nástroje. V Pythonu ho obsluhuje vestavěný modul json.

import json

objednavka = {"zakaznik": "Jana", "polozky": ["káva", "dort"], "zaplaceno": True, "sleva": None}

text = json.dumps(objednavka)
print(type(text).__name__, text)

zpet = json.loads(text)
print(type(zpet).__name__, zpet)
print(zpet["polozky"][1])
Výstup
str {"zakaznik": "Jana", "polozky": ["k\u00e1va", "dort"], "zaplaceno": true, "sleva": null}
dict {'zakaznik': 'Jana', 'polozky': ['káva', 'dort'], 'zaplaceno': True, 'sleva': None}
dort

Názvy si zapamatuješ snadno: dumps je dump string, tedy „vysyp do textu“, a loads je load string, „načti z textu“. Všimni si rozdílů: True je v JSONu true, None je null a texty mají vždy dvojité uvozovky.

PythonJSON
dictobjekt {...}
list, tuplepole [...]
strřetězec v dvojitých uvozovkách
int, floatčíslo
True, Falsetrue, false
Nonenull

Ve výstupu výše je káva zapsaná divně, protože dumps standardně převádí znaky mimo ASCII na kódy. Pro člověka je lepší výstup upravit.

import json

kavarna = {"název": "U Čápa", "stoly": 12, "menu": {"káva": 65, "čaj": 50}}

print(json.dumps(kavarna, ensure_ascii=False, indent=2, sort_keys=True))
Výstup
{
  "menu": {
    "káva": 65,
    "čaj": 50
  },
  "název": "U Čápa",
  "stoly": 12
}

JSON v souboru

Pro soubory jsou funkce bez s na konci: json.dump zapisuje a json.load čte. Tady je program, který si pamatuje nastavení mezi spuštěními. Tři průchody cyklem předstírají tři spuštění.

import json
from pathlib import Path

soubor = Path("nastaveni.json")
soubor.unlink(missing_ok=True)

def nacti():
    try:
        with open(soubor, encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return {"spusteni": 0, "jazyk": "čeština"}

def uloz(data):
    with open(soubor, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

for _ in range(3):
    nastaveni = nacti()
    nastaveni["spusteni"] += 1
    uloz(nastaveni)

print(soubor.read_text(encoding="utf-8"))
Výstup
{
  "spusteni": 3,
  "jazyk": "čeština"
}

JSON ale neumí všechno, co Python. Cesta tam a zpátky může data potichu změnit.

import json

puvodni = {"bod": (1, 2), 2026: "rok"}
kopie = json.loads(json.dumps(puvodni))

print(puvodni)
print(kopie)
print(puvodni == kopie)
Výstup
{'bod': (1, 2), 2026: 'rok'}
{'bod': [1, 2], '2026': 'rok'}
False

N-tice se změnila na seznam a číselný klíč na text, protože klíče objektu v JSONu jsou vždy texty. Když pak hledáš kopie[2026], dostaneš KeyError.

A co se nedá převést vůbec? Množiny, data, vlastní objekty. A soubor sám může být poškozený. Obojí má svou výjimku.

import json
from datetime import date

try:
    json.dumps({"tagy": {"python", "kurz"}})
except TypeError as e:
    print("Nejde uložit:", e)

print(json.dumps({"tagy": sorted({"python", "kurz"})}))
print(json.dumps({"den": date(2026, 11, 18)}, default=date.isoformat))

try:
    json.loads("{'jmeno': 'Anna'}")
except json.JSONDecodeError as e:
    print("Neplatný JSON:", e.msg)
    print("Řádek", e.lineno, "sloupec", e.colno)
Výstup
Nejde uložit: Object of type set is not JSON serializable
{"tagy": ["kurz", "python"]}
{"den": "2026-11-18"}
Neplatný JSON: Expecting property name enclosed in double quotes
Řádek 1 sloupec 2

Parametr default je funkce, kterou json zavolá na hodnotu, se kterou si neví rady. JSONDecodeError je potomek ValueError, přesnou pozici chyby v něm dostaneš zadarmo.

Kvíz

Co vrátí json.loads(json.dumps({1: "a"}))?

Úkol

Úkolníček v JSONu

Napiš funkci pridej_ukol(cesta, text). V JSON souboru je seznam úkolů. Funkce ho načte (když soubor neexistuje, začne s prázdným seznamem), přidá slovník {"text": text, "hotovo": False}, seznam uloží a vrátí počet úkolů.

import json

def pridej_ukol(cesta, text):
    pass
Výstup

CSV: tabulka v textu

CSV (comma-separated values) je tabulka, jakou vyexportuje e-shop, banka nebo Excel. První řádek bývá hlavička.

csv
produkt,kategorie,cena,kusy
"Káva, zrnková",nápoje,189,3
Čaj,nápoje,95,2
Bábovka,dezerty,60,4

První nápad zní radek.split(","). Funguje do chvíle, kdy se čárka objeví přímo v hodnotě. Proto je Káva, zrnková v uvozovkách a proto existuje modul csv, který tahle pravidla zná.

import csv

radek = '"Káva, zrnková",nápoje,189,3'

print(radek.split(","))
print(next(csv.reader([radek])))
Výstup
['"Káva', ' zrnková"', 'nápoje', '189', '3']
['Káva, zrnková', 'nápoje', '189', '3']

Čtečka csv.reader umí brát řádky odkudkoli, tady ze seznamu s jedním textem. Funkce next z ní vezme první výsledek.

Nejpohodlnější je csv.DictReader. Z hlavičky si vezme názvy sloupců a každý řádek vrátí jako slovník.

import csv

DATA = """produkt,kategorie,cena,kusy
"Káva, zrnková",nápoje,189,3
Čaj,nápoje,95,2
Bábovka,dezerty,60,4
"""
with open("prodej.csv", "w", encoding="utf-8", newline="") as f:
    f.write(DATA)

trzba = 0
with open("prodej.csv", encoding="utf-8", newline="") as f:
    for radek in csv.DictReader(f):
        print(radek)
        trzba += int(radek["cena"]) * int(radek["kusy"])

print("Tržba:", trzba)
Výstup
{'produkt': 'Káva, zrnková', 'kategorie': 'nápoje', 'cena': '189', 'kusy': '3'}
{'produkt': 'Čaj', 'kategorie': 'nápoje', 'cena': '95', 'kusy': '2'}
{'produkt': 'Bábovka', 'kategorie': 'dezerty', 'cena': '60', 'kusy': '4'}
Tržba: 997

CSV nezná typy. Všechno je text, i 189. Bez int by "189" * "3" skončilo chybou a "189" + "95" by dalo 18995.

Soubor pro csv otevírej s newline="". Modul si konce řádků hlídá sám a hodnota v uvozovkách může obsahovat i nový řádek.

Úkol

Tržby podle kategorie

Napiš funkci trzby_podle_kategorie(cesta). V CSV souboru jsou sloupce produkt, kategorie, cena, kusy. Vrať slovník, kde klíč je kategorie a hodnota součet cena * kusy jako celé číslo.

import csv

def trzby_podle_kategorie(cesta):
    vysledek = {}
    return vysledek
Výstup

Zápis CSV a český Excel

csv.DictWriter dostane názvy sloupců a zapisuje slovníky. O uvozovky se postará sám.

import csv

lide = [
    {"jmeno": "Novák, Jan", "mesto": "Brno", "vek": 41},
    {"jmeno": "Eva Malá", "mesto": "Plzeň"},
]

with open("lide.csv", "w", encoding="utf-8", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["jmeno", "mesto", "vek"])
    w.writeheader()
    w.writerows(lide)

with open("lide.csv", encoding="utf-8") as f:
    print(f.read())
Výstup
jmeno,mesto,vek
"Novák, Jan",Brno,41
Eva Malá,Plzeň,

Chybějící věk zůstal prázdný. Klíč, který není mezi sloupci, by naopak vyvolal ValueError, takže překlep v názvu sloupce neprojde bez povšimnutí.

Český Excel má dvě zvláštnosti. Protože čárka je u nás desetinný oddělovač, sloupce odděluje středníkem. A aby poznal UTF-8, chce na začátku souboru neviditelnou značku BOM, kterou zapíše kódování utf-8-sig. Když takový soubor otevřeš jako obyčejné utf-8, značka se ti nalepí na název prvního sloupce.

import csv

with open("excel.csv", "w", encoding="utf-8-sig", newline="") as f:
    w = csv.writer(f, delimiter=";")
    w.writerow(["položka", "cena"])
    w.writerow(["káva", "65,50"])

with open("excel.csv", encoding="utf-8", newline="") as f:
    print("utf-8:    ", next(csv.reader(f, delimiter=";")))

with open("excel.csv", encoding="utf-8-sig", newline="") as f:
    for r in csv.DictReader(f, delimiter=";"):
        cena = float(r["cena"].replace(",", "."))
        print("utf-8-sig:", r["položka"], cena)
Výstup
utf-8:     ['\ufeffpoložka', 'cena']
utf-8-sig: káva 65.5

To  je přesně důvod chyby, kdy radek["položka"] hlásí KeyError, přestože sloupec v souboru očividně je. Čtení přes utf-8-sig funguje i pro soubory bez BOM, takže u CSV z neznámých zdrojů nic nezkazíš.

Kvíz

Z exportu přišel soubor, kde r["jmeno"] hlásí KeyError, a výpis klíčů ukazuje 'jmeno'. Co s tím?

Z tabulky do JSONu

Běžná práce: přijde CSV, spočítáš souhrn a předáš ho dál jako JSON, třeba webové aplikaci.

import csv
import json

DATA = """datum;pobocka;trzba
2026-11-02;Brno;12400
2026-11-02;Praha;18950
2026-11-03;Brno;9800
2026-11-03;Praha;
"""
with open("trzby.csv", "w", encoding="utf-8", newline="") as f:
    f.write(DATA)

souhrn = {}
vadne = []
with open("trzby.csv", encoding="utf-8", newline="") as f:
    for cislo, r in enumerate(csv.DictReader(f, delimiter=";"), start=2):
        try:
            trzba = int(r["trzba"])
        except ValueError:
            vadne.append(cislo)
            continue
        pobocka = souhrn.setdefault(r["pobocka"], {"dnu": 0, "celkem": 0})
        pobocka["dnu"] += 1
        pobocka["celkem"] += trzba

vysledek = {"pobocky": souhrn, "vadne_radky": vadne}
with open("souhrn.json", "w", encoding="utf-8") as f:
    json.dump(vysledek, f, ensure_ascii=False, indent=2)

with open("souhrn.json", encoding="utf-8") as f:
    print(f.read())
Výstup
{
  "pobocky": {
    "Brno": {
      "dnu": 2,
      "celkem": 22200
    },
    "Praha": {
      "dnu": 1,
      "celkem": 18950
    }
  },
  "vadne_radky": [
    5
  ]
}

Číslování začíná dvojkou, protože první řádek souboru je hlavička. Metoda setdefault vrátí hodnotu klíče, a když klíč chybí, nejdřív ho založí. Vadný řádek nezastavil zpracování, ale taky nezmizel beze stopy. Číslo řádku v souboru se ti bude hodit, až se někdo zeptá, proč Praha vychází tak nízko.

Úkol

Export z Excelu do JSONu

Napiš funkci csv_na_json(vstup, vystup). Vstup je CSV z českého Excelu: oddělovač ;, kódování utf-8-sig, sloupce jmeno, vek, mesto. Do souboru vystup ulož JSON se seznamem slovníků se stejnými klíči, vek převeď na celé číslo a prázdné mesto nahraď None. Vrať počet záznamů.

import csv
import json

def csv_na_json(vstup, vystup):
    pass
Výstup
Pod kapotou · JSON v produkci

Není to tak přenositelné, jak se zdá. json.dumps(float("nan")) vrátí NaN, což podle RFC 8259 není platný JSON a parser v prohlížeči to odmítne. Zapni allow_nan=False. Duplicitní klíče json.loads přijme a vyhraje poslední, kontrolu dopíšeš přes object_pairs_hook. Celá čísla nad 2^53 ztratí přesnost v JavaScriptu, proto se dlouhá ID posílají jako text. Peníze načítej přes parse_float=decimal.Decimal, aby ses vyhnul binárním floatům. Limit převodu velkých čísel (4300 číslic, sys.set_int_max_str_digits) platí i pro json.loads a chrání před zneužitím výkonu.

Výkon. json.load načte celý soubor do paměti a stromová reprezentace zabere několikanásobek jeho velikosti. Na proudová data se hodí JSON Lines: jeden objekt na řádek, jde číst po řádcích, připisovat a dělit. V CPythonu 3.12 používá C akcelerátor jen dumps bez indent. json.dump do souboru jede přes pomalejší pythonní iterencode, takže u velkých dat bývá rychlejší f.write(json.dumps(data)), pokud se výsledek vejde do paměti.

Bezpečnost. json.loads na rozdíl od pickle.loads nespouští kód, takže je pro cizí vstup vhodný. Validaci struktury ale nedělá, to řeší až schéma nebo pydantic. Parametr default=str je pohodlný, jenže z omylem předaného objektu tiše udělá text, proto raději povol jen konkrétní typy.

Pod kapotou · CSV v produkci

CSV injection. Hodnota začínající =, +, - nebo @ se může v Excelu spustit jako vzorec. Když exportuješ data od uživatelů, je potřeba takové buňky neutralizovat, typicky předřazeným apostrofem, a počítat s tím, že to mění data pro strojové čtení.

Konce řádků. csv.writer standardně píše \r\n. Bez newline="" z toho na Windows vznikne \r\r\n a v Excelu prázdné řádky navíc.

Limity a kvótování. Pole delší než csv.field_size_limit(), výchozích 131072 znaků, skončí csv.Error. Neuzavřená uvozovka přitom umí spolknout zbytek souboru do jediné hodnoty, takže tuhle chybu často uvidíš až pozdě. Python 3.12 přidal QUOTE_NOTNULL a QUOTE_STRINGS, díky nimž writer odliší None od prázdného textu. Na reader se ve 3.12 kvůli chybě nepromítají, opraveno je to ve 3.13.

Paměť a detekce. reader i DictReader jsou líné, takže zvládnou soubory větší než RAM. DictReader je pomalejší, protože pro každý řádek skládá slovník. csv.Sniffer jen odhaduje, na krátkých vzorcích se plete, a v automatickém zpracování je bezpečnější formát určit napevno.