0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 20 min

Cesty a pathlib

Naučíš se skládat cesty, které fungují na každém systému, procházet složky a napíšeš si program na úklid stažených souborů.

Hloubka
Úkoly
Lidsky řečeno

Cesta k souboru je adresa. Absolutní cesta je celá adresa s městem a ulicí, doručí se odkudkoli. Relativní cesta je popis „o dvě patra výš a druhé dveře vlevo“. Funguje jen tehdy, když víš, kde právě stojíš. Program taky někde stojí a tomu místu se říká pracovní složka.

Co je cesta

Soubory leží ve složkách a složky v dalších složkách. Cesta je výčet jmen od začátku až k cíli. Jenže každý systém ji píše trochu jinak:

text
Windows:       C:\Users\anna\faktury\leden.pdf
Linux, macOS:  /home/anna/faktury/leden.pdf
Relativní:     faktury/leden.pdf

Skládat cesty jako obyčejný text je proto cesta do pekel. Snadno vynecháš oddělovač nebo použiješ ten pro jiný systém. Modul pathlib má objekt Path, který pravidla zná. Části spojuješ lomítkem /.

from pathlib import PurePosixPath, PureWindowsPath

print("data" + "faktury" + "leden.pdf")

linux = PurePosixPath("data") / "faktury" / "leden.pdf"
windows = PureWindowsPath("data") / "faktury" / "leden.pdf"
print(linux)
print(windows)
Výstup
datafakturyleden.pdf
data/faktury/leden.pdf
data\faktury\leden.pdf

Stejný zápis, správný výsledek pro oba systémy. Lomítko tu neznamená dělení, ale spojení částí cesty.

Ve svých programech budeš psát prostě Path, který se sám zařídí podle systému. PurePosixPath a PureWindowsPath jsou „čisté“ cesty: počítají jen s textem cesty a na disk nesahají. V ukázkách je používám proto, aby výstup vypadal všude stejně.

Kde právě stojíš, zjistíš takto. Výsledek záleží na počítači, proto je ukázka jen na čtení.

python
from pathlib import Path

print(Path.cwd())                     # pracovní složka
print(Path.home())                    # tvoje domovská složka
print(Path("data.txt").resolve())     # z relativní cesty absolutní

Rozebrat a poskládat

Cesta není jen text. Umí ti říct, z čeho se skládá.

from pathlib import PurePosixPath

p = PurePosixPath("/home/anna/fotky/dovolena.2025.jpg")

print("jméno:    ", p.name)
print("kmen:     ", p.stem)
print("přípona:  ", p.suffix)
print("přípony:  ", p.suffixes)
print("rodič:    ", p.parent)
print("prarodič: ", p.parent.parent)
print("části:    ", p.parts)
print("absolutní:", p.is_absolute())
Výstup
jméno:     dovolena.2025.jpg
kmen:      dovolena.2025
přípona:   .jpg
přípony:   ['.2025', '.jpg']
rodič:     /home/anna/fotky
prarodič:  /home/anna
části:     ('/', 'home', 'anna', 'fotky', 'dovolena.2025.jpg')
absolutní: True

Cesty jsou neměnné. Metody with_... proto vrací novou cestu a původní nechají být.

from pathlib import PurePosixPath

p = PurePosixPath("fotky/leto.jpeg")

print(p.with_suffix(".png"))
print(p.with_name("zima.jpeg"))
print(p.with_stem("leto_mala"))
print(p.parent / "nahledy" / p.name)
print(p)
Výstup
fotky/leto.png
fotky/zima.jpeg
fotky/leto_mala.jpeg
fotky/nahledy/leto.jpeg
fotky/leto.jpeg
Kvíz

Jaká je hodnota suffix u cesty zaloha.tar.gz?

Úkol

Jméno pro zálohu

Napiš funkci zalozni_cesta(cesta). Dostane text s cestou a vrátí Path, kde je před příponou doplněno _zaloha. Z fotky/leto.jpg vznikne fotky/leto_zaloha.jpg, z README vznikne README_zaloha.

from pathlib import Path

def zalozni_cesta(cesta):
    return Path(cesta)
Výstup

Práce s diskem

Objekt Path umí i skutečné operace se soubory. Jednorázové čtení a zápis zvládne jedním řádkem, open tu nepotřebuješ.

import shutil
from pathlib import Path

shutil.rmtree("projekt", ignore_errors=True)  # úklid po minulém spuštění

slozka = Path("projekt") / "data" / "2026"
print("existuje:", slozka.exists())

slozka.mkdir(parents=True, exist_ok=True)
print("existuje:", slozka.exists(), "| je složka:", slozka.is_dir())

soubor = slozka / "napoj.txt"
znaku = soubor.write_text("čaj", encoding="utf-8")
print("zapsáno znaků:", znaku)
print("bajtů na disku:", soubor.stat().st_size)
print("obsah:", soubor.read_text(encoding="utf-8"))
print("je soubor:", soubor.is_file())
Výstup
existuje: False
existuje: True | je složka: True
zapsáno znaků: 3
bajtů na disku: 4
obsah: čaj
je soubor: True

Tři znaky zabírají čtyři bajty, protože č má v UTF-8 bajty dva. parents=True vytvoří i chybějící nadřazené složky. exist_ok=True nevadí, když složka už je.

Přesun, přejmenování a mazání:

import shutil
from pathlib import Path

shutil.rmtree("sklad", ignore_errors=True)
sklad = Path("sklad")
sklad.mkdir()

navrh = sklad / "navrh.txt"
navrh.write_text("verze 1", encoding="utf-8")

hotovo = navrh.rename(sklad / "hotovo.txt")
print(navrh.exists(), hotovo.exists())

hotovo.unlink()
print(hotovo.exists())
hotovo.unlink(missing_ok=True)

sklad.rmdir()
print(sklad.exists())
Výstup
False True
False
False

unlink maže soubor, rmdir prázdnou složku a shutil.rmtree složku i s celým obsahem. Mazání neprochází košem, soubor je pryč hned.

Hledání souborů

iterdir projde obsah jedné složky. glob hledá podle vzoru, kde * znamená cokoli. rglob hledá i ve všech podsložkách. Pořadí výsledků není zaručené, takže když na něm záleží, použij sorted.

import shutil
from pathlib import Path

web = Path("web")
shutil.rmtree(web, ignore_errors=True)
for jmeno in ["index.html", "kontakt.html", "css/styl.css", "css/tisk.css", "img/logo.png"]:
    cesta = web / jmeno
    cesta.parent.mkdir(parents=True, exist_ok=True)
    cesta.write_text("x" * 100, encoding="utf-8")

print("V hlavní složce:")
for polozka in sorted(web.iterdir()):
    druh = "složka" if polozka.is_dir() else "soubor"
    print(" ", polozka.name, "-", druh)

print("HTML:", [p.name for p in sorted(web.glob("*.html"))])

print("CSS kdekoli:")
for p in sorted(web.rglob("*.css")):
    print(" ", p.relative_to(web).as_posix())

velikost = sum(p.stat().st_size for p in web.rglob("*") if p.is_file())
print("Celkem bajtů:", velikost)
Výstup
V hlavní složce:
  css - složka
  img - složka
  index.html - soubor
  kontakt.html - soubor
HTML: ['index.html', 'kontakt.html']
CSS kdekoli:
  css/styl.css
  css/tisk.css
Celkem bajtů: 500

relative_to odřízne začátek cesty a as_posix vrátí text s obyčejnými lomítky na každém systému.

Úkol

Co v té složce vlastně je

Napiš funkci spocitej_pripony(slozka). Dostane Path a vrátí slovník, kolik souborů má kterou příponu, včetně podsložek. Přípony převeď na malá písmena (.JPG a .jpg jsou totéž). Soubory bez přípony a složky nepočítej.

from pathlib import Path

def spocitej_pripony(slozka):
    vysledek = {}
    return vysledek
Výstup

Úklid složky Stažené

Teď to spojíš do něčeho užitečného. Ve složce leží směs souborů a každý má odejít do podsložky podle typu.

import shutil
from pathlib import Path

stazene = Path("stazene")
shutil.rmtree(stazene, ignore_errors=True)
stazene.mkdir()
for jmeno in ["faktura.pdf", "dovolena.JPG", "pes.jpg", "smlouva.pdf", "README"]:
    (stazene / jmeno).write_text("obsah", encoding="utf-8")

KATEGORIE = {".jpg": "obrazky", ".png": "obrazky", ".pdf": "dokumenty"}

for soubor in sorted(stazene.iterdir()):
    if not soubor.is_file():
        continue
    jmeno_slozky = KATEGORIE.get(soubor.suffix.lower(), "ostatni")
    cil = stazene / jmeno_slozky
    cil.mkdir(exist_ok=True)
    soubor.rename(cil / soubor.name)

for soubor in sorted(stazene.rglob("*")):
    if soubor.is_file():
        print(soubor.relative_to(stazene).as_posix())
Výstup
dokumenty/faktura.pdf
dokumenty/smlouva.pdf
obrazky/dovolena.JPG
obrazky/pes.jpg
ostatni/README

sorted tu má ještě jednu roli: vytvoří hotový seznam dřív, než začneš složku měnit. Měnit složku, kterou zrovna procházíš, je spolehlivý recept na přeskočené položky.

Úkol

Roztřiď podle přípony

Napiš funkci roztrid(slozka). Dostane Path. Každý soubor ležící přímo ve složce přesune do podsložky pojmenované podle přípony, malými písmeny a bez tečky (a.JPG jde do jpg/a.JPG). Soubory bez přípony jdou do ostatni. Existující podsložky nech být. Funkce vrátí počet přesunutých souborů.

from pathlib import Path

def roztrid(slozka):
    return 0
Výstup

Čtyři pasti

Cesty vypadají nevinně, dokud se program nedostane na jiný systém nebo k cizím datům.

from pathlib import PurePosixPath, PureWindowsPath

print(PurePosixPath("Foto.JPG") == PurePosixPath("foto.jpg"))
print(PureWindowsPath("Foto.JPG") == PureWindowsPath("foto.jpg"))

print(PurePosixPath("nahrane") / "/etc/passwd")
print(PurePosixPath("nahrane") / "../../etc/passwd")
Výstup
False
True
/etc/passwd
nahrane/../../etc/passwd
  • Velikost písmen. Na Linuxu jsou Foto.JPG a foto.jpg dva různé soubory, na Windows jeden. Skript z Windows pak na serveru soubor nenajde.
  • Absolutní část vše přepíše. Když je napravo od / absolutní cesta, levá strana se zahodí.
  • Dvě tečky. .. znamená „o složku výš“. Jméno souboru od uživatele tak může vést úplně mimo složku, do které jsi ho chtěl uložit.
  • Přejmenování na existující cíl. rename na Linuxu cílový soubor potichu přepíše, na Windows skončí FileExistsError. Když chceš přepsání všude stejně, použij replace. Když ho nechceš, ověř si předem, že cíl neexistuje.
Kvíz

Čím bude PurePosixPath("zalohy") / "/tmp/x.txt"?

Pod kapotou · bezpečné cesty a co dělá resolve

Spojení cest nic nekontroluje, takže útok přes ../ (path traversal) i přes absolutní cestu projde. Ověřuj až výslednou cestu:

python
from pathlib import Path

def safe_path(base: Path, name: str) -> Path:
    base = base.resolve()
    target = (base / name).resolve()
    if not target.is_relative_to(base):
        raise ValueError(f"Path escapes the base folder: {name!r}")
    return target

resolve() je podstatné, protože rozbalí .. i symbolické odkazy. Mezi kontrolou a použitím se ale disk může změnit (TOCTOU). Kde to vadí, sáhni po otevírání relativně k deskriptoru složky přes dir_fd a O_NOFOLLOW. Pro samotné vytvoření souboru je open(p, "x") lepší než if not p.exists(), protože test a vytvoření jsou jedna atomická operace.

Čisté cesty .. záměrně nezkracují. Když je a symbolický odkaz, a/../b nemusí být b. absolute() jen doplní pracovní složku, resolve() se ptá disku. os.path.normpath krátí čistě textově a tenhle rozdíl ignoruje.

Pod kapotou · pathlib v Pythonu 3.12 a výkon

Python 3.12 přidal Path.walk() jako obdobu os.walk, parametr case_sensitive u glob a rglob, PurePath.with_segments() pro podtřídy a is_junction(). Bez case_sensitive se glob řídí konvencí systému, proto *.txt na Windows najde i A.TXT a na Linuxu ne.

Path.glob("*") na rozdíl od glob.glob("*") vrací i skryté soubory začínající tečkou. Modul glob je dostane až s include_hidden=True.

Každé stat() a is_file() je samostatné volání systému. Na obrovských stromech nebo síťových discích je citelně rychlejší os.scandir, jehož DirEntry si typ a na Windows i velikost nese z výpisu složky (PEP 471). Do API přijímajících cestu patří typ str | os.PathLike[str] a převod přes os.fspath() (PEP 519).