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:
Windows: C:\Users\anna\faktury\leden.pdf
Linux, macOS: /home/anna/faktury/leden.pdf
Relativní: faktury/leden.pdfSklá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)
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í.
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())
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í: TrueCesty 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)
fotky/leto.png fotky/zima.jpeg fotky/leto_mala.jpeg fotky/nahledy/leto.jpeg fotky/leto.jpeg
Jaká je hodnota suffix u cesty zaloha.tar.gz?
suffix je jen poslední přípona. Všechny najdeš v seznamu suffixes, tady ['.tar', '.gz'].
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)
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())
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())
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 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.
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
Ú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())
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.
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
Č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")
False True /etc/passwd nahrane/../../etc/passwd
- Velikost písmen. Na Linuxu jsou
Foto.JPGafoto.jpgdva 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.
renamena Linuxu cílový soubor potichu přepíše, na Windows skončíFileExistsError. Když chceš přepsání všude stejně, použijreplace. Když ho nechceš, ověř si předem, že cíl neexistuje.
Čím bude PurePosixPath("zalohy") / "/tmp/x.txt"?
Absolutní cesta vpravo nahradí vše nalevo. Proto se jména od uživatele nesmí bez kontroly lepit k cílové složce.
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:
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 targetresolve() 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).