0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 22 min

Soubory a with

Program si zapamatuje data i po skončení. Naučíš se číst a zapisovat soubory, používat with a nepřijít o data ani o češtinu.

Hloubka
Úkoly
Lidsky řečeno

Proměnné jsou poznámky na tabuli: po skončení hodiny je někdo smaže. Soubor je sešit v šuplíku. Abys do něj psal, musíš ho vyndat a otevřít, a když skončíš, patří zase zavřít a vrátit. Blok with je kolega, který to za tebe udělá vždycky, i když tě uprostřed psaní vyruší požární poplach.

Program má krátkou paměť

Píšeš si evidenci výdajů. Dokud data leží jen v proměnných, po skončení programu zmizí. Aby přežila, musí jít do souboru.

with open("vydaje.txt", "w", encoding="utf-8") as f:
    f.write("káva 65\n")
    f.write("oběd 159\n")

with open("vydaje.txt", encoding="utf-8") as f:
    obsah = f.read()

print(obsah)
Výstup
káva 65
oběd 159

Rozebereme první řádek:

  • open otevře soubor a vrátí objekt, přes který s ním pracuješ.
  • "vydaje.txt" je jméno souboru, tady ve složce, kde program běží.
  • "w" je režim, znamená zápis (write).
  • encoding="utf-8" říká, jak se mají písmena převádět na bajty. Vrátíme se k tomu níž.
  • with ... as f uloží otevřený soubor do f a na konci odsazeného bloku ho zavře.

Metoda write nepřidává konec řádku sama, proto \n na konci textu.

Proč soubor zavírat

Python nezapisuje každý znak hned na disk. Sbírá je ve vyrovnávací paměti, bufferu, a posílá je po větších dávkách. Zavření soubor dopíše. Dokud neproběhne, nemusí být data na disku.

f = open("buffer.txt", "w", encoding="utf-8")
f.write("důležitá data")

with open("buffer.txt", encoding="utf-8") as kontrola:
    print("před zavřením:", repr(kontrola.read()))

f.close()

with open("buffer.txt", encoding="utf-8") as kontrola:
    print("po zavření:", repr(kontrola.read()))
Výstup
před zavřením: ''
po zavření: 'důležitá data'

Funkce repr ukazuje text tak, jak by se zapsal v kódu, takže je vidět i prázdný řetězec nebo \n. Ruční close() je snadné vynechat a při chybě se k němu program ani nedostane. Blok with soubor zavře vždy, i když uvnitř vyletí výjimka.

try:
    with open("rozdelano.txt", "w", encoding="utf-8") as f:
        f.write("první část\n")
        int("tady to spadne")
        f.write("druhá část\n")
except ValueError:
    print("Nastala chyba.")

print("Zavřeno:", f.closed)
with open("rozdelano.txt", encoding="utf-8") as f:
    print(f.read())
Výstup
Nastala chyba.
Zavřeno: True
první část

První řádek se uložil, protože with při odchodu soubor řádně zavřel. Na druhý zápis už nedošlo. Co přesně with dělá, je zhruba tohle:

python
f = open("data.txt", encoding="utf-8")
try:
    obsah = f.read()
finally:
    f.close()

Jak se takové chování píše pro vlastní objekty, ukáže lekce Context managery.

Režimy: čím otevíráš, tím rozhoduješ

RežimVýznamSoubor neexistujeSoubor existuje
rčtení, výchozíFileNotFoundErrorčte od začátku
wzápisvytvoří hosmaže obsah
apřidávání na konecvytvoří hoobsah zachová
xvytvoření novéhovytvoří hoFileExistsError

K režimu lze přidat b pro binární práci (rb, wb) nebo + pro čtení i zápis zároveň (r+).

with open("denik.txt", "w", encoding="utf-8") as f:
    print("pondělí: běh", file=f)

with open("denik.txt", "a", encoding="utf-8") as f:
    print("úterý: plavání", file=f)

with open("denik.txt", encoding="utf-8") as f:
    print("Po režimu a:")
    print(f.read())

with open("denik.txt", "w", encoding="utf-8") as f:
    print("středa: kolo", file=f)

with open("denik.txt", encoding="utf-8") as f:
    print("Po režimu w:")
    print(f.read())
Výstup
Po režimu a:
pondělí: běh
úterý: plavání

Po režimu w:
středa: kolo

Funkce print s parametrem file píše do souboru a konec řádku přidá sama.

with open("smlouva.txt", "w", encoding="utf-8") as f:
    f.write("podepsaná verze")

try:
    with open("smlouva.txt", "x", encoding="utf-8") as f:
        f.write("koncept")
except FileExistsError:
    print("Soubor už existuje, nepřepisuji ho.")

with open("smlouva.txt", encoding="utf-8") as f:
    print(f.read())
Výstup
Soubor už existuje, nepřepisuji ho.
podepsaná verze
Kvíz

Chceš k existujícímu logu připsat další řádek a staré řádky zachovat. Který režim zvolíš?

Úkol

Připiš do deníku

Napiš funkci pridej_radek(cesta, text). Přidá text na konec souboru jako nový řádek. Když soubor neexistuje, vznikne. Dosavadní obsah musí zůstat.

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

Čtení: celé, nebo po řádcích

Soubor lze přečíst několika způsoby. Všimni si, že řádky si svoje \n nechávají.

with open("nakup.txt", "w", encoding="utf-8") as f:
    f.write("mléko\nchleba\nmáslo\n")

with open("nakup.txt", encoding="utf-8") as f:
    print("read:", repr(f.read()))

with open("nakup.txt", encoding="utf-8") as f:
    print("readline:", repr(f.readline()))
    print("readline:", repr(f.readline()))

with open("nakup.txt", encoding="utf-8") as f:
    print("readlines:", f.readlines())

with open("nakup.txt", encoding="utf-8") as f:
    for radek in f:
        print("for:", radek.strip())

with open("nakup.txt", encoding="utf-8") as f:
    print("první read:", len(f.read()), "znaků")
    print("druhý read:", repr(f.read()))
    f.seek(0)
    print("po seek(0):", repr(f.readline()))
Výstup
read: 'mléko\nchleba\nmáslo\n'
readline: 'mléko\n'
readline: 'chleba\n'
readlines: ['mléko\n', 'chleba\n', 'máslo\n']
for: mléko
for: chleba
for: máslo
první read: 19 znaků
druhý read: ''
po seek(0): 'mléko\n'

Nejčastější a nejlepší je varianta s for. Bere soubor řádek po řádku a nenačítá ho celý do paměti, takže zvládne i soubor větší než RAM. Metoda strip() odstraní \n a mezery z okrajů.

Konec ukázky odhaluje, že otevřený soubor si pamatuje, kam až dočetl. Tomu místu se říká kurzor. Po přečtení je na konci, takže další read vrátí prázdný text. Metoda seek(0) ho vrátí na začátek.

Teď už evidenci výdajů dotáhneš: přečíst řádky, přeskočit prázdné, sečíst částky.

with open("vydaje.txt", "w", encoding="utf-8") as f:
    f.write("káva 65\n\noběd 159\nnové boty 1890\n")

celkem = 0
with open("vydaje.txt", encoding="utf-8") as f:
    for radek in f:
        radek = radek.strip()
        if not radek:
            continue
        nazev, castka = radek.rsplit(" ", 1)
        celkem += int(castka)
        print(f"{nazev:<12}{castka:>6}")

print(f"{'celkem':<12}{celkem:>6}")
Výstup
káva            65
oběd           159
nové boty     1890
celkem        2114

Volání rsplit(" ", 1) rozdělí text jen podle poslední mezery, takže název může mít víc slov.

Úkol

Součet ze souboru

Napiš funkci soucet_souboru(cesta). V souboru je na každém řádku jedno celé číslo, některé řádky mohou být prázdné nebo obsahovat jen mezery. Funkce vrátí součet.

def soucet_souboru(cesta):
    pass
Výstup

Když soubor chybí

Soubor nemusí existovat, může být zamčený nebo na něj nemusíš mít práva. Tohle jsou situace, které kód sám neovlivní, takže přesně sem patří try. Všechny tyhle chyby jsou potomci OSError.

def precti(cesta):
    try:
        with open(cesta, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError as e:
        print("Chyba:", e.strerror)
        print("Chybí soubor:", e.filename)
        return ""

print(repr(precti("tenhle_soubor_neni.txt")))
Výstup
Chyba: No such file or directory
Chybí soubor: tenhle_soubor_neni.txt
''

Kdybys vypsal rovnou e, uvidíš ještě číslo chyby v hranatých závorkách, třeba [Errno 2]. Číslo se liší podle operačního systému, proto tady vypisujeme jen text strerror.

Úkol

Seznam, který nemusí existovat

Napiš funkci nacti_seznam(cesta). Vrátí seznam neprázdných řádků bez okrajových mezer a bez \n. Když soubor neexistuje, vrátí prázdný seznam.

def nacti_seznam(cesta):
    with open(cesta, encoding="utf-8") as f:
        return f.readlines()
Výstup

Kódování: proč se z češtiny stávají klikyháky

Disk umí ukládat jen bajty, čísla od 0 do 255. Kódování je tabulka, která říká, jaké bajty odpovídají kterému znaku. Dnešní standard je UTF-8. Starší české programy často používají cp1250. Když soubor zapíšeš jednou tabulkou a čteš druhou, dostaneš nesmysl.

with open("kod.txt", "w", encoding="utf-8") as f:
    f.write("čeština")

with open("kod.txt", encoding="utf-8") as f:
    print("správně:", f.read())
with open("kod.txt", encoding="cp1250") as f:
    print("špatně: ", f.read())
with open("kod.txt", "rb") as f:
    print("bajty:  ", f.read())

with open("stary.txt", "w", encoding="cp1250") as f:
    f.write("čeština")
try:
    with open("stary.txt", encoding="utf-8") as f:
        f.read()
except UnicodeDecodeError as e:
    print("chyba:  ", e)
Výstup
správně: čeština
špatně:  ÄŤeština
bajty:   b'\xc4\x8de\xc5\xa1tina'
chyba:   'utf-8' codec can't decode byte 0xe8 in position 0: invalid continuation byte

Ty podivné znaky jsou klasika a teď už víš, odkud se berou: dvoubajtové č z UTF-8 se ve staré tabulce přečetlo jako dva samostatné znaky. Režim rb ukazuje syrové bajty, před kterými Python píše b.

Binární režim se hodí všude, kde nejde o text: obrázky, PDF, archivy. Čteš a zapisuješ bytes a žádné kódování se neřeší. Parametr u read určí, kolik bajtů chceš, takže i velký soubor zkopíruješ po částech. Operátor := v ukázce uloží přečtený kousek do proměnné a zároveň ho použije jako podmínku. Na konci souboru přijde prázdný kousek a cyklus skončí.

with open("obrazek.png", "wb") as f:
    f.write(bytes([137, 80, 78, 71, 13, 10, 26, 10]) + b"data obrazku")

with open("obrazek.png", "rb") as f:
    print("začátek:", f.read(4))

with open("obrazek.png", "rb") as zdroj, open("kopie.png", "wb") as cil:
    while kousek := zdroj.read(8):
        cil.write(kousek)

with open("kopie.png", "rb") as f:
    print("kopie:", f.read())
Výstup
začátek: b'\x89PNG'
kopie: b'\x89PNG\r\n\x1a\ndata obrazku'

Prvních pár bajtů souboru často prozradí jeho skutečný typ bez ohledu na příponu. PNG začíná právě bajtem 137 a písmeny PNG.

Kvíz

Co vrátí f.read(4), když je soubor otevřený v režimu rb a začíná textem čaj! v UTF-8?

Pod kapotou · tři vrstvy pod open a co znamená uloženo

open v textovém režimu skládá tři objekty: TextIOWrapper (kódování, konce řádků), pod ním BufferedWriter nebo BufferedReader (f.buffer) a nejníž FileIO (f.buffer.raw), který volá systém. f.flush() předá data operačnímu systému, ale ten je může držet ve své cache. Teprve os.fsync(f.fileno()) žádá zápis na zařízení.

Přepsat důležitý soubor na místě je riskantní, protože pád uprostřed zanechá polovinu dat. Standardní řešení je zápis do dočasného souboru ve stejné složce a atomické nahrazení:

python
import os, tempfile

def atomic_write(path, text):
    folder = os.path.dirname(os.path.abspath(path))
    fd, tmp = tempfile.mkstemp(dir=folder, suffix=".tmp")
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as f:
            f.write(text)
            f.flush()
            os.fsync(f.fileno())
        os.replace(tmp, path)
    except BaseException:
        os.unlink(tmp)
        raise

Tři detaily: mkstemp vytvoří soubor s právy 0600, takže případně je nastav podle originálu. Na POSIXu je pro odolnost proti výpadku proudu potřeba fsync i na složku. Na Windows může os.replace selhat s PermissionError, když má cíl otevřený jiný proces.

Pod kapotou · konce řádků, kódování a kurzor

Výchozí newline=None při čtení mění \r\n a \r na \n a při zápisu mění \n na os.linesep. Text s konci řádků proto na Windows zabere víc bajtů než na Linuxu. Parametr newline="" překlad vypne a potřebuje ho třeba modul csv.

Text a pozice: v textovém režimu vrací tell() neprůhledné číslo, se kterým se nedá počítat, a seek je bezpečný jen s nulou nebo s hodnotou z tell(). Během iterace for radek in f skončí tell() chybou OSError: telling position disabled by next() call.

Kódování: -X warn_default_encoding zapne EncodingWarning (PEP 597) a najde všechna open bez encoding. PEP 686 plánuje UTF-8 Mode jako výchozí od Pythonu 3.15. Soubory z Excelu často začínají BOM, čti je přes utf-8-sig. Parametr errors="replace" nebo "surrogateescape" řeší poškozené vstupy, první však data nevratně mění.

Neuzavřený soubor CPython obvykle zavře díky počítání referencí, PyPy až někdy později. python -X dev u takového kódu vypíše ResourceWarning.