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])
str {"zakaznik": "Jana", "polozky": ["k\u00e1va", "dort"], "zaplaceno": true, "sleva": null}
dict {'zakaznik': 'Jana', 'polozky': ['káva', 'dort'], 'zaplaceno': True, 'sleva': None}
dortNá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.
| Python | JSON |
|---|---|
dict | objekt {...} |
list, tuple | pole [...] |
str | řetězec v dvojitých uvozovkách |
int, float | číslo |
True, False | true, false |
None | null |
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))
{
"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"))
{
"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)
{'bod': (1, 2), 2026: 'rok'}
{'bod': [1, 2], '2026': 'rok'}
FalseN-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)
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 2Parametr 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.
Co vrátí json.loads(json.dumps({1: "a"}))?
dumps celočíselný klíč převede na text, protože klíče objektů v JSONu jsou vždy řetězce. Zpátky už se sám nepřevede.
Ú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
CSV: tabulka v textu
CSV (comma-separated values) je tabulka, jakou vyexportuje e-shop, banka nebo Excel. První řádek bývá hlavička.
produkt,kategorie,cena,kusy
"Káva, zrnková",nápoje,189,3
Čaj,nápoje,95,2
Bábovka,dezerty,60,4První 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])))
['"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)
{'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: 997CSV 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.
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
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())
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)
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íš.
Z exportu přišel soubor, kde r["jmeno"] hlásí KeyError, a výpis klíčů ukazuje 'jmeno'. Co s tím?
je BOM na začátku souboru. Kódování utf-8-sig ho při čtení odstraní.
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())
{
"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.
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
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.