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)
káva 65 oběd 159
Rozebereme první řádek:
openotevř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 fuloží otevřený soubor dofa 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()))
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())
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:
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žim | Význam | Soubor neexistuje | Soubor existuje |
|---|---|---|---|
r | čtení, výchozí | FileNotFoundError | čte od začátku |
w | zápis | vytvoří ho | smaže obsah |
a | přidávání na konec | vytvoří ho | obsah zachová |
x | vytvoření nového | vytvoří ho | FileExistsError |
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())
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())
Soubor už existuje, nepřepisuji ho. podepsaná verze
Chceš k existujícímu logu připsat další řádek a staré řádky zachovat. Který režim zvolíš?
a zapisuje na konec a nic nemaže. w by soubor vyprázdnil, r neumí zapisovat a x by skončil chybou, protože soubor už existuje.
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
Č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()))
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}")
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.
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
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")))
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.
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()
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)
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())
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.
Co vrátí f.read(4), když je soubor otevřený v režimu rb a začíná textem čaj! v UTF-8?
V binárním režimu se počítají bajty. V textovém režimu by read(4) vrátilo čtyři znaky.
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í:
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)
raiseTř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.