Jak v Pythonu pracovat se složkami rychle a přehledně

Co je adresář a složka v Pythonu

V počítačovém světě se pojmy adresář a složka používají prakticky jako synonyma, přestože mezi nimi existuje jemný historický rozdíl. Adresář (directory) je starší termín pocházející z unixového prostředí, zatímco složka (folder) je spíše grafická reprezentace téhož konceptu, která se ujala s příchodem grafických uživatelských rozhraní. V kontextu programování v Pythonu se setkáte s oběma termíny, přičemž samotný jazyk a jeho standardní knihovny pracují primárně s pojmem adresář.

Adresář je v podstatě kontejner v souborovém systému operačního systému, který může obsahovat soubory nebo další adresáře, jež se pak nazývají podadresáře. Tato hierarchická struktura tvoří základ organizace dat na jakémkoli moderním počítači. Každý adresář má svou cestu, tedy přesné umístění v rámci souborového systému, a tato cesta může být buď absolutní, nebo relativní. Absolutní cesta začíná od kořenového adresáře — na Linuxu a macOS je to lomítko `/`, na Windows písmeno disku jako `C:\`. Relativní cesta naproti tomu vychází z aktuálního pracovního adresáře, ve kterém se program právě nachází.

Python nabízí hned několik způsobů, jak s adresáři pracovat. Nejstarší a stále velmi rozšířený přístup využívá modul `os`, který je součástí standardní knihovny a poskytuje rozhraní k funkcím operačního systému. Pomocí funkce `os.getcwd()` zjistíte aktuální pracovní adresář, funkce `os.listdir()` vrátí seznam souborů a adresářů v daném umístění a `os.mkdir()` slouží k vytvoření nového adresáře. Tyto funkce jsou přímočaré a spolehlivé, ovšem jejich nevýhodou je, že pracují s cestami jako s prostými řetězci, což může vést k chybám při přenášení kódu mezi různými operačními systémy.

Modernějším a dnes velmi doporučovaným přístupem je použití modulu `pathlib`, který byl do Pythonu přidán ve verzi 3.4. Tento modul přináší objektově orientovaný přístup k práci se souborovými cestami a adresáři. Třída `Path` z tohoto modulu umožňuje pracovat s cestami přirozeným způsobem, přičemž se automaticky přizpůsobuje operačnímu systému. Místo ručního skládání cest pomocí řetězců a oddělovačů jednoduše používáte operátor `/` pro spojování částí cesty, což je intuitivní a přehledné.

Pochopení toho, jak Python vnímá adresáře a složky, je naprosto klíčové pro psaní jakéhokoli skriptu, který pracuje se soubory. Ať už píšete program pro zpracování dat, automatizaci úloh nebo vývoj webové aplikace, dříve nebo později narazíte na potřebu číst soubory z určitého adresáře, zapisovat výsledky do jiné složky nebo procházet celou adresářovou strukturu. Python vám k tomu dává velmi mocné nástroje, které jsou zároveň přenositelné mezi různými platformami, což je v dnešním různorodém prostředí obrovská výhoda.

Důležitým konceptem je také pracovní adresář (working directory nebo current directory), což je adresář, ve kterém Python skript aktuálně „stojí. Pokud ve skriptu otevřete soubor pouze pomocí jeho názvu bez jakékoli cesty, Python ho bude hledat právě v tomto pracovním adresáři. To může být zdrojem záludných chyb, pokud skript spouštíte z jiného umístění, než kde se nachází samotný soubor skriptu. Proto je vždy dobrou praxí pracovat s absolutními cestami nebo s cestami odvozenými od umístění samotného skriptu, například pomocí proměnné `__file__`, která obsahuje cestu k aktuálně spouštěnému souboru.

Souborový systém a jeho správná interpretace v Pythonu tedy nejsou jen technickým detailem, ale základním kamenem, na kterém stojí celá řada praktických aplikací. Čím lépe pochopíte, jak adresáře a složky fungují a jak s nimi Python pracuje, tím efektivnější a spolehlivější kód budete schopni psát.

Modul os a práce s cestami souborů

Python nabízí vývojářům celou řadu nástrojů pro práci se souborovým systémem, přičemž jedním z nejdůležitějších je bezesporu modul os. Tento modul je součástí standardní knihovny Pythonu a poskytuje přenositelný způsob, jak pracovat s operačním systémem, včetně manipulace s adresáři a cestami souborů. Pokud se chcete pohybovat po souborovém systému, vytvářet složky, mazat je nebo zjišťovat jejich obsah, modul os je váš nejlepší přítel.

Základem práce s adresáři je funkce os.getcwd(), která vrátí aktuální pracovní adresář. Tento adresář je místo, ze kterého Python spouští váš skript, a je důležité vědět, kde se právě nacházíte, abyste mohli správně sestavovat cesty k souborům. Pokud chcete pracovní adresář změnit, použijete funkci os.chdir(), které předáte cestu k novému adresáři jako řetězec.

Vytváření nových složek je možné pomocí funkce os.mkdir(), která vytvoří jednu složku na zadané cestě. Pokud však potřebujete vytvořit celou hierarchii adresářů najednou, například složku a všechny její nadřazené složky, které ještě neexistují, sáhnete po funkci os.makedirs(). Tato funkce je velmi praktická, protože vám ušetří psaní cyklů a kontrolních podmínek.

Práce s cestami souborů je oblast, kde začátečníci často dělají chyby. Ruční skládání cest pomocí řetězcového spojování je sice možné, ale silně nedoporučované, protože různé operační systémy používají různé oddělovače adresářů. Na Windows se používá zpětné lomítko, zatímco na Linuxu a macOS se používá lomítko dopředu. Právě proto existuje os.path.join(), která tyto rozdíly automaticky řeší a sestaví cestu správně bez ohledu na operační systém, na kterém váš kód běží.

Modul os.path obsahuje celou řadu dalších užitečných funkcí. Funkce os.path.exists() ověří, zda zadaná cesta vůbec existuje, ať už jde o soubor nebo adresář. Funkce os.path.isdir() pak konkrétně zjistí, zda se jedná o adresář, a os.path.isfile() ověří, zda jde o soubor. Tyto kontroly jsou nezbytné, pokud chcete psát robustní kód, který nezhavaruje při neočekávaných vstupech.

Pro získání obsahu adresáře slouží funkce os.listdir(), která vrátí seznam všech souborů a podsložek v zadaném adresáři. Pokud potřebujete procházet celou stromovou strukturu adresářů rekurzivně, funkce os.walk() je přesně to, co hledáte. Tato funkce generuje trojice obsahující aktuální adresář, seznam jeho podsložek a seznam souborů, což vám umožní systematicky projít celý souborový strom.

V novějších verzích Pythonu se stále více prosazuje alternativa k modulu os v podobě modulu pathlib. Tento modul přináší objektově orientovaný přístup k práci s cestami a mnoho programátorů ho považuje za čitelnější a intuitivnější. Třída Path z modulu pathlib umožňuje skládat cesty pomocí operátoru lomítko, kontrolovat existenci souborů, číst a zapisovat jejich obsah, a to vše prostřednictvím elegantního rozhraní.

Přesto modul os zůstává základním kamenem práce se souborovým systémem v Pythonu a znalost jeho funkcí je pro každého vývojáře nezbytná. Funkce jako os.rename() pro přejmenování souborů, os.remove() pro mazání souborů nebo os.rmdir() pro mazání prázdných adresářů jsou každodenním nástrojem při automatizaci souborových operací. Pro mazání celých adresářových stromů pak slouží funkce shutil.rmtree() z modulu shutil, která doplňuje možnosti modulu os.

Správné pochopení práce s cestami a adresáři je klíčové pro psaní přenositelného a spolehlivého kódu v Pythonu, který bude fungovat na různých platformách bez nutnosti úprav.

Vytváření nových složek pomocí os.mkdir

Práce s adresáři a složkami patří k naprosto základním dovednostem každého programátora v Pythonu. Ať už píšete skript pro automatizaci zálohovacích procesů, nebo vyvíjíte složitější aplikaci, která potřebuje dynamicky vytvářet strukturu složek, dříve nebo později se setkáte s potřebou vytvořit nový adresář přímo z kódu. Python na to nabízí elegantní řešení prostřednictvím modulu os, konkrétně pomocí funkce os.mkdir().

Modul os je součástí standardní knihovny Pythonu, takže ho nemusíte instalovat přes pip ani jiný správce balíčků. Stačí ho jednoduše importovat na začátku vašeho skriptu pomocí příkazu import os a máte okamžitě k dispozici celou řadu nástrojů pro práci s operačním systémem, včetně manipulace se souborovým systémem.

Samotná funkce os.mkdir() přijímá jako první argument cestu k adresáři, který chcete vytvořit. Tato cesta může být absolutní, tedy například /home/uzivatel/novy_adresar na Linuxu nebo C:\\Users\\Uzivatel\\NovaSloZka na Windows, nebo relativní, tedy vztažená k aktuálnímu pracovnímu adresáři vašeho skriptu. Funkce vytvoří přesně jeden adresář na zadané cestě, a to je důležitý detail, na který musíte myslet.

Proč je to důležité? Protože pokud se pokusíte vytvořit adresář, jehož nadřazená složka ještě neexistuje, Python vyhodí výjimku FileNotFoundError. Představte si situaci, kdy chcete vytvořit cestu projekty/2024/zima/archiv, ale složka projekty zatím vůbec neexistuje. V takovém případě vám os.mkdir() nepomůže a budete muset sáhnout po funkci os.makedirs(), která dokáže vytvořit celý strom adresářů najednou.

Druhý parametr, se kterým se u os.mkdir() setkáte, je mode. Tento parametr určuje přístupová práva nově vytvořeného adresáře a je relevantní především na unixových systémech. Výchozí hodnota je 0o777, což v osmičkové soustavě znamená plná práva pro vlastníka, skupinu i ostatní uživatele. Na Windows je tento parametr ignorován, takže se o něj nemusíte starat, pokud vyvíjíte výhradně pro tuto platformu.

Velmi důležitou součástí práce s funkcí os.mkdir() je ošetření výjimek. Pokud se pokusíte vytvořit adresář, který již existuje, Python vyhodí výjimku FileExistsError. Proto je dobrým zvykem zabalit volání funkce do bloku try-except. Profesionální přístup vypadá přibližně takto: nejprve zkontrolujete, zda adresář již existuje pomocí funkce os.path.exists() nebo os.path.isdir(), a teprve pokud neexistuje, přistoupíte k jeho vytvoření. Alternativně celé volání obalíte do bloku try-except a zachytíte případnou výjimku FileExistsError.

Praktický příklad použití může vypadat například tak, že máte aplikaci, která při každém spuštění vytváří složku s dnešním datem pro ukládání logů. Pomocí modulu datetime získáte aktuální datum, převedete ho na řetězec ve formátu, který vyhovuje názvům složek, a poté zavoláte os.mkdir() s touto cestou. Celý proces je rychlý, spolehlivý a nevyžaduje žádné externí závislosti.

Nezapomeňte také na to, že os.mkdir() funguje napříč platformami. Python se postará o to, aby správně interpretoval oddělovače cest na různých operačních systémech, ale přesto je doporučenou praxí používat pro skládání cest funkci os.path.join() místo ručního psaní lomítek. Tím zajistíte, že váš kód bude fungovat správně jak na Linuxu a macOS, kde se jako oddělovač používá lomítko, tak na Windows, kde se tradičně používá zpětné lomítko.

Celkově vzato je os.mkdir() jednoduchá, ale mocná funkce, která vám umožní plně ovládat strukturu adresářů ve vašich Python projektech. Jakmile ji jednou pochopíte a naučíte se správně ošetřovat výjimky, stane se nepostradatelnou součástí vašeho programátorského arzenálu.

Rekurzivní tvorba adresářů přes os.makedirs

Při práci s adresářovou strukturou v Pythonu narazíme dříve nebo později na situaci, kdy potřebujeme vytvořit nejen jeden adresář, ale celou hierarchii složek najednou. Právě pro tento účel existuje funkce os.makedirs(), která představuje výrazně mocnější nástroj než její jednodušší sestra os.mkdir(). Zatímco os.mkdir() dokáže vytvořit pouze jeden adresář a vyžaduje, aby všechny nadřazené složky již existovaly, os.makedirs() zvládne celou cestu vytvořit rekurzivně od základu.

Představme si situaci, kdy chceme vytvořit strukturu jako například projekty/python/skripty/testy. Pokud žádná z těchto složek neexistuje, os.mkdir() selže hned na první úrovni. Naproti tomu os.makedirs() projde celou cestu a vytvoří každou chybějící složku postupně, od nejvyšší úrovně až po tu nejhlubší. Toto chování je v praxi nesmírně užitečné, zejména při automatizaci nasazování projektů, generování reportů nebo při práci s dynamicky generovanými cestami.

Základní použití je velmi přímočaré. Stačí importovat modul os a zavolat funkci s požadovanou cestou jako argumentem. Klíčovým parametrem, který byste měli vždy zvažovat, je exist_ok. Pokud tento parametr nastavíte na True, funkce nevyhodí výjimku v případě, že adresář již existuje. Bez tohoto nastavení by Python při pokusu o vytvoření již existující složky vyhodil chybu FileExistsError, což může být v mnoha scénářích velmi nežádoucí chování. Nastavení exist_ok=True tedy zajišťuje, že váš kód bude robustní a nevyvolá výjimku jen proto, že adresář byl vytvořen při předchozím spuštění.

Dalším důležitým aspektem je práce s parametrem mode, který umožňuje nastavit oprávnění pro nově vytvořené adresáře. Tento parametr funguje stejně jako u os.mkdir() a přijímá osmičkové hodnoty oprávnění, jako například 0o755 nebo 0o777. Je však třeba mít na paměti, že na operačním systému Linux nebo macOS může hodnotu oprávnění ovlivnit aktuální umask procesu, takže výsledná oprávnění nemusí vždy přesně odpovídat zadané hodnotě.

V moderním Pythonu, konkrétně od verze 3.4, máme k dispozici také alternativu v podobě modulu pathlib. Třída Path nabízí metodu mkdir() s parametrem parents=True, která funguje obdobně jako os.makedirs(). Tato varianta je považována za modernější a více objektově orientovaný přístup. Nicméně os.makedirs() zůstává velmi rozšířenou a spolehlivou volbou, zejména v kódu, který musí být kompatibilní se staršími verzemi Pythonu nebo v prostředích, kde je preferován procedurální styl psaní.

Při práci s cestami je obecně doporučováno používat os.path.join() pro skládání cest místo ručního řetězení řetězců pomocí lomítek. Tento přístup zajišťuje kompatibilitu mezi různými operačními systémy, protože Windows používá zpětné lomítko jako oddělovač cest, zatímco Linux a macOS používají lomítko dopředu. Kombinace os.path.join() a os.makedirs() tak tvoří elegantní a přenositelné řešení pro správu adresářové struktury.

Chybové stavy jsou dalším tématem, které stojí za pozornost. Pokud nemáte dostatečná oprávnění k vytvoření adresáře v požadovaném umístění, Python vyhodí výjimku PermissionError. Proto je dobrou praxí obalovat volání os.makedirs() do bloku try-except, kde zachytíte jak PermissionError, tak případně OSError jako obecnější výjimku. Tímto způsobem může váš program elegantně reagovat na problémy s oprávněními a informovat uživatele srozumitelnou chybovou zprávou místo toho, aby havaroval s technickým traceback výpisem.

Praktické využití os.makedirs() najdeme v nejrůznějších oblastech. Při vývoji webových aplikací se tato funkce používá pro vytváření adresářů pro nahrávané soubory, cache nebo logy. V datové analytice se hodí pro organizaci výstupních souborů podle data nebo jiných kritérií. V automatizačních skriptech slouží k přípravě pracovního prostředí před spuštěním dalších operací. Zkrátka všude tam, kde potřebujete mít jistotu, že potřebná adresářová struktura existuje dříve, než do ní začnete zapisovat soubory, je os.makedirs() vaším nejlepším přítelem.

Výpis obsahu složky metodou os.listdir

Práce se souborovým systémem patří k jedněm z nejčastějších úkolů, které programátoři v Pythonu řeší. Ať už jde o zpracování dávek souborů, automatizaci zálohovacích procesů nebo třeba analýzu struktury adresářů, Python nabízí elegantní nástroje, které tuto práci výrazně zjednodušují. Jedním z nejzákladnějších a zároveň nejpoužívanějších nástrojů je metoda os.listdir(), která pochází z modulu `os` a slouží k výpisu obsahu libovolné složky na disku.

Než se pustíme do samotného použití, je důležité zmínit, že modul `os` je součástí standardní knihovny Pythonu, takže jej není potřeba instalovat přes pip ani žádný jiný správce balíčků. Stačí jej jednoduše importovat na začátku skriptu pomocí příkazu import os a okamžitě máme k dispozici celou řadu funkcí pro práci s operačním systémem a jeho souborovým systémem.

Samotné volání metody os.listdir() je velmi jednoduché. Funkci předáme jako argument cestu k adresáři, jehož obsah chceme vypsat, a ona nám vrátí seznam řetězců, kde každý řetězec představuje název jednoho záznamu v dané složce. Tímto záznamem může být jak soubor, tak i podsložka. Metoda tedy nerozlišuje mezi soubory a adresáři, vrací prostě vše, co se v dané složce nachází. Pokud chceme zjistit, zda jde o soubor nebo adresář, musíme použít další pomocné funkce, například os.path.isfile() nebo os.path.isdir().

Velmi důležitou vlastností metody os.listdir() je skutečnost, že nevrací absolutní cesty, ale pouze názvy položek. To znamená, že pokud chceme s jednotlivými soubory dále pracovat, musíme si absolutní nebo relativní cestu sestavit sami, nejčastěji pomocí funkce os.path.join(). Tato funkce správně spojí cestu k adresáři s názvem souboru a postará se přitom o správné oddělovače cesty, ať už pracujeme na systému Windows, Linux nebo macOS.

Dalším zajímavým aspektem je chování metody v případě, kdy jako argument nezadáme žádnou cestu. V takovém případě os.listdir() automaticky použije aktuální pracovní adresář, tedy ten, ze kterého byl skript spuštěn. Aktuální pracovní adresář lze zjistit pomocí funkce os.getcwd() a případně jej změnit funkcí os.chdir(). Toto chování je praktické pro rychlé skripty, ale v produkčním kódu je vždy lepší specifikovat cestu explicitně, aby nedocházelo k nejasnostem nebo chybám způsobeným spuštěním skriptu z jiného adresáře.

Metoda os.listdir() neprochází adresáře rekurzivně. Vrátí pouze obsah jedné konkrétní složky, nikoliv obsah jejích podsložek. Pokud potřebujeme procházet celý strom adresářů, musíme buď implementovat vlastní rekurzivní funkci, nebo sáhnout po metodě os.walk(), která je pro tento účel přímo navržena a umí procházet celou stromovou strukturu adresářů automaticky.

Je také dobré vědět, že výsledný seznam vrácený metodou os.listdir() není nijak seřazen. Pořadí položek závisí na operačním systému a souborovém systému, takže se může lišit napříč platformami nebo dokonce mezi různými spuštěními téhož skriptu. Pokud potřebujeme seřazený výpis, stačí výsledek obalit funkcí sorted(), která seznam seřadí abecedně. Pro složitější řazení, například podle data změny souboru nebo podle velikosti, je potřeba použít funkci sorted() s vlastním klíčem, kde si pomůžeme funkcemi jako os.path.getmtime() nebo os.path.getsize().

V praxi se metoda os.listdir() velmi často kombinuje s podmínkami a cyklem for, kdy procházíme seznam položek a každou z nich zpracováváme individuálně. Například můžeme filtrovat soubory podle přípony, přeskakovat skryté soubory začínající tečkou na Unixových systémech nebo sbírat statistiky o obsahu složky. Tato flexibilita dělá z os.listdir() základní stavební kámen mnoha skriptů pro automatizaci práce se soubory a adresáři v Pythonu.

Procházení adresářové struktury funkcí os.walk

Funkce os.walk() patří mezi nejužitečnější nástroje, které Python nabízí pro práci se souborovým systémem. Pokud potřebujete procházet celou adresářovou strukturu rekurzivně, bez nutnosti psát vlastní rekurzivní funkci, pak je os.walk() přesně to, co hledáte. Tato funkce je součástí modulu os, který je standardní součástí Pythonu a není třeba instalovat žádné externí balíčky.

Základní princip fungování os.walk() spočívá v tom, že funkce prochází adresářový strom shora dolů nebo zdola nahoru a pro každý adresář vrací trojici hodnot. Tato trojice obsahuje cestu k aktuálnímu adresáři, seznam podadresářů v tomto adresáři a seznam souborů nacházejících se přímo v daném adresáři. Výsledkem je generátor, který postupně produkuje tyto trojice pro každý adresář, na který při procházení narazí.

Aby bylo možné funkci použít, je nejprve nutné importovat modul os pomocí příkazu import os. Poté stačí zavolat os.walk() s cestou k výchozímu adresáři jako argumentem. Například pokud chcete procházet složku s názvem „projekty, napíšete os.walk('/cesta/k/projekty'). Funkce pak postupně projde všechny podadresáře a vrátí informace o každém z nich.

Při práci s touto funkcí je důležité pochopit, jak jsou hodnoty v trojici uspořádány. První hodnota, označovaná obvykle jako dirpath, obsahuje řetězec s cestou k aktuálně zpracovávanému adresáři. Druhá hodnota, dirnames, je seznam názvů podadresářů, které se nacházejí přímo v daném adresáři. Třetí hodnota, filenames, pak obsahuje seznam názvů souborů v aktuálním adresáři, přičemž nejde o úplné cesty, ale pouze o samotné názvy souborů.

Pokud chcete získat úplnou cestu k souboru, je třeba kombinovat dirpath a název souboru pomocí funkce os.path.join(). Tato kombinace je velmi běžná a prakticky nezbytná při reálném použití. Zápis by vypadal například takto: os.path.join(dirpath, filename). Výsledkem je kompletní cesta k souboru, se kterou lze dále pracovat, ať už ji chcete otevřít, kopírovat nebo jen vypsat.

Jedním z parametrů, který os.walk() přijímá, je topdown. Pokud je nastaven na True, což je výchozí hodnota, procházení probíhá shora dolů, tedy nejprve se zpracuje výchozí adresář a pak jeho podadresáře. Pokud je nastaven na False, procházení probíhá zdola nahoru, tedy nejprve se zpracují nejhlubší podadresáře a teprve poté se funkce dostane k nadřazeným adresářům. Volba směru procházení závisí na konkrétním případu použití.

Dalším zajímavým parametrem je onerror, který umožňuje definovat funkci, jež se zavolá v případě, že dojde k chybě při přístupu k některému adresáři. Bez tohoto parametru jsou chyby tiše ignorovány, což může být v některých situacích nežádoucí, zejména pokud potřebujete mít jistotu, že jste prošli celou strukturu bez problémů.

Existuje také parametr followlinks, který určuje, zda má os.walk() sledovat symbolické odkazy na adresáře. Ve výchozím nastavení je nastaven na False, takže symbolické odkazy nejsou sledovány. Pokud ho nastavíte na True, funkce bude do symbolicky odkazovaných adresářů vstupovat, ale pozor, může dojít k nekonečné smyčce, pokud symbolický odkaz ukazuje na nadřazený adresář.

Praktické využití os.walk() je velmi široké. Lze ji použít například pro hledání souborů s určitou příponou v celé adresářové struktuře, pro výpočet celkové velikosti všech souborů v adresáři, pro kopírování nebo přesouvání celých adresářových stromů, nebo pro mazání souborů splňujících určitá kritéria. Tato funkce je také velmi užitečná při vytváření zálohovacích skriptů nebo nástrojů pro správu souborů.

Je dobré si uvědomit, že os.walk() vrací generátor, nikoli seznam. To znamená, že hodnoty jsou generovány postupně a nezabírají zbytečně paměť. Pokud pracujete s velmi rozsáhlou adresářovou strukturou obsahující tisíce souborů a adresářů, je tato vlastnost velmi výhodná, protože celá struktura nemusí být načtena do paměti najednou.

Při modifikaci seznamu dirnames uvnitř smyčky lze ovlivnit, které podadresáře budou navštíveny. Pokud například z dirnames odstraníte určité adresáře, os.walk() do nich nevstoupí. Tato technika je velmi užitečná, pokud chcete přeskočit určité složky, například skryté adresáře začínající tečkou nebo systémové složky jako .git nebo __pycache__.

Mazání prázdných a plných adresářů

Práce se souborovým systémem patří k základním dovednostem každého programátora, který pracuje s Pythonem. Mazání adresářů je přitom operace, která vyžaduje určitou opatrnost, protože na rozdíl od přesunu do koše jde o nevratnou akci. Python nabízí hned několik způsobů, jak se s touto úlohou vypořádat, a každý z nich má své specifické využití.

Nejjednodušší situace nastane tehdy, když chcete smazat prázdný adresář. K tomu slouží funkce `os.rmdir()`, která je součástí standardního modulu `os`. Tato funkce funguje spolehlivě, ale má jednu zásadní podmínku — složka musí být skutečně prázdná. Pokud se pokusíte smazat adresář, který obsahuje jakýkoliv soubor nebo podsložku, Python vyhodí výjimku `OSError`. To je chování, které má svůj smysl, protože chrání uživatele před nechtěným smazáním dat.

```python

import os

os.rmdir(nazev_slozky)

```

Pokud pracujete s více úrovněmi prázdných adresářů najednou, může se hodit funkce `os.removedirs()`. Ta se pokouší rekurzivně odstraňovat prázdné adresáře od nejhlubší úrovně směrem nahoru. Jakmile narazí na složku, která není prázdná, zastaví se. Je to elegantní řešení pro situace, kdy jste vytvořili hlubokou strukturu složek a chcete ji po sobě uklidit.

Složitější a v praxi mnohem častější situací je mazání plného adresáře, tedy takového, který obsahuje soubory nebo další podsložky. Zde přichází ke slovu modul `shutil` a jeho funkce `shutil.rmtree()`. Tato funkce rekurzivně projde celou strukturu adresáře a smaže vše, co v ní najde — soubory, podsložky i jejich obsah. Je to mocný nástroj, ale právě proto je třeba jej používat s rozvahou.

```python

import shutil

shutil.rmtree(nazev_slozky)

```

Při použití `shutil.rmtree()` je dobré myslet na ošetření chyb. Pokud zadaná složka neexistuje, funkce vyhodí výjimku `FileNotFoundError`. Abyste se tomu vyhnuli, můžete před samotným mazáním ověřit existenci adresáře pomocí `os.path.exists()` nebo `os.path.isdir()`. Alternativně lze využít parametr `ignore_errors=True`, který způsobí, že funkce případné chyby tiše ignoruje. To se hodí v situacích, kdy vám nevadí, že složka neexistuje, ale obecně je lepší chyby explicitně ošetřovat.

```python

import shutil

import os

cesta = nazev_slozky

if os.path.exists(cesta):

shutil.rmtree(cesta)

```

V novějších verzích Pythonu, konkrétně od verze 3.4, je k dispozici také modul `pathlib`, který přináší objektově orientovaný přístup k práci se souborovým systémem. Pro mazání prázdného adresáře lze použít metodu `Path.rmdir()`, která funguje stejně jako `os.rmdir()` — tedy odstraní pouze prázdnou složku.

```python

from pathlib import Path

p = Path(nazev_slozky)

p.rmdir()

```

Pro mazání plných adresářů přes `pathlib` však neexistuje přímá metoda, která by to zvládla sama o sobě. I zde je tedy nutné sáhnout po `shutil.rmtree()` a předat mu cestu jako řetězec nebo přímo objekt `Path`, protože `shutil.rmtree()` objekty `Path` akceptuje.

Důležitým aspektem, na který se často zapomíná, jsou přístupová práva. Na systémech Unix/Linux může mazání adresáře selhat, pokud nemáte dostatečná oprávnění. Na Windows mohou problémy způsobit soubory, které jsou označeny jako pouze pro čtení. V takovém případě `shutil.rmtree()` nabízí parametr `onerror`, do kterého lze předat vlastní funkci pro zpracování chyb. Tato funkce přijímá tři argumenty — funkci, která selhala, cestu a informace o výjimce — a umožňuje například změnit oprávnění souboru a pokus o smazání zopakovat.

```python

import shutil

import stat

import os

def oprav_prava(func, cesta, exc_info):

os.chmod(cesta, stat.S_IWRITE)

func(cesta)

shutil.rmtree(nazev_slozky, onerror=oprav_prava)

```

Celkově lze říct, že Python poskytuje dostatečně bohatou sadu nástrojů pro mazání adresářů, ať už prázdných nebo plných. Klíčem k bezpečné práci je vždy ověřit, co mažete, a ošetřit případné výjimky. Nikdy není od věci přidat do kódu kontrolní mechanismy, které zabrání nechtěnému smazání důležitých dat. Mazání složek je operace, která se nedá vzít zpět, a proto je lepší být o krok napřed.

Modul pathlib jako moderní alternativa k os

Od verze 3.4 přinesl Python do svého standardního arzenálu modul pathlib, který zásadním způsobem změnil přístup k práci se souborovým systémem. Zatímco starší modul `os` a jeho podmodul `os.path` fungovaly primárně na bázi řetězců, pathlib přišel s objektově orientovaným přístupem, který je intuitivnější, čitelnější a v mnoha ohledech elegantnější. Pokud jste dosud pracovali výhradně s `os.getcwd()`, `os.path.join()` nebo `os.listdir()`, pak je nejvyšší čas se podívat na to, co pathlib nabízí jako plnohodnotnou moderní alternativu.

Základním stavebním kamenem celého modulu je třída Path. Pomocí ní lze reprezentovat libovolnou cestu v souborovém systému, ať už jde o soubor nebo adresář. Vytvoření objektu je jednoduché — stačí napsat `from pathlib import Path` a poté například `p = Path('/home/uzivatel/dokumenty')`. Od tohoto okamžiku máte k dispozici celou řadu metod a atributů, které vám práci s adresáři a složkami výrazně zjednoduší. Není třeba řetězce ručně spojovat pomocí `os.path.join()`, protože pathlib umožňuje používat operátor lomítka `/` přímo pro skládání cest. Výraz `Path('/home/uzivatel') / 'dokumenty' / 'projekt'` je naprosto validní a výsledkem je nový objekt Path reprezentující danou cestu.

Pokud chcete zjistit aktuální pracovní adresář, nemusíte volat `os.getcwd()`. Místo toho jednoduše použijete `Path.cwd()`, která vrátí objekt Path s aktuální cestou. Podobně metoda `Path.home()` vrátí domovský adresář aktuálního uživatele, což je velmi praktické při psaní přenositelných skriptů. Tyto metody jsou čistší a přímočařejší než jejich ekvivalenty v modulu os.

Procházení obsahu adresáře je s pathlib rovněž přirozenější. Metoda `iterdir()` vrací iterátor přes všechny položky v daném adresáři, aniž byste museli kombinovat `os.listdir()` s `os.path.join()`. Každá vrácená položka je opět objektem Path, takže s ní lze dále pracovat metodami jako `is_file()`, `is_dir()`, `exists()` nebo `stat()`. Pokud potřebujete rekurzivně procházet celý strom adresářů a složek, pak metoda `rglob()` nebo `glob()` s vzorem `**` odvede práci bez nutnosti importovat další moduly nebo psát vlastní rekurzivní funkce.

Vytváření nových adresářů je s pathlib rovněž přímočaré. Metoda `mkdir()` přijímá parametry `parents=True` a `exist_ok=True`, díky čemuž lze jedním příkazem vytvořit celou hierarchii složek bez obav z výjimek v případě, že adresář již existuje. To je výrazné zlepšení oproti kombinaci `os.makedirs()` s ošetřováním výjimek.

Dalším silným aspektem pathlib je přístup k atributům cesty. Pomocí `p.name` získáte název souboru nebo složky, `p.stem` vrátí název bez přípony, `p.suffix` příponu samotnou a `p.parent` nadřazený adresář. Tyto atributy nahrazují zdlouhavé volání funkcí jako `os.path.basename()`, `os.path.dirname()` nebo `os.path.splitext()`. Kód je díky tomu kratší a mnohem lépe čitelný.

Při práci se soubory v rámci adresářů pathlib nabízí i pohodlné metody pro čtení a zápis obsahu. Metody `read_text()` a `write_text()` umožňují pracovat s textovými soubory přímo na objektu Path, bez nutnosti explicitně otevírat soubor pomocí `open()`. Samozřejmě pro složitější operace zůstává `open()` k dispozici, ale i zde lze volat `p.open()` přímo na objektu Path.

Je důležité zmínit, že pathlib není jen syntaktický cukr nad modulem os. Jde o zásadní změnu paradigmatu v tom, jak Python přistupuje k souborovému systému. Místo manipulace s prostými řetězci pracujete s objekty, které nesou sémantiku cesty a poskytují bohaté rozhraní. Tento přístup snižuje riziko chyb způsobených nesprávným spojováním cest, problémy s oddělovači na různých operačních systémech nebo zapomenutím ošetřit krajní případy. Pathlib se automaticky přizpůsobuje operačnímu systému — na Windows vrací instance `WindowsPath`, na Unixových systémech `PosixPath`, přičemž rozhraní zůstává totožné.

Pro každého, kdo píše moderní Python kód a pracuje s adresáři a složkami, je modul pathlib de facto standardem, který by měl nahradit zastaralé vzory z modulu os. Komunita Pythonu tento přechod aktivně podporuje a většina nových projektů a knihoven pathlib plně využívá.

Kontrola existence složky před operacemi

Než se pustíme do jakékoliv práce se složkami v Pythonu, je naprosto zásadní ověřit, zda daná složka skutečně existuje. Tato kontrola není jen formalitou, ale chrání nás před celou řadou chyb, které by jinak mohly program shodit nebo způsobit neočekávané chování. Python nám k tomu nabízí několik nástrojů a je dobré vědět, kdy který použít.

Srovnání správců souborů a adresářové struktury v Pythonu

Vlastnost	Python (modul os)	Python (modul pathlib)	Python (modul shutil)
Vytvoření složky	os.mkdir() / os.makedirs()	Path.mkdir()	není přímo podporováno
Výpis obsahu adresáře	os.listdir()	Path.iterdir()	není přímo podporováno
Kopírování složky	není přímo podporováno	není přímo podporováno	shutil.copytree()
Přejmenování složky	os.rename()	Path.rename()	shutil.move()
Smazání složky	os.rmdir() / os.removedirs()	Path.rmdir()	shutil.rmtree()
Zjištění aktuálního adresáře	os.getcwd()	Path.cwd()	není podporováno
Kontrola existence složky	os.path.isdir()	Path.is_dir()	není podporováno
Dostupnost od verze Pythonu	Python 2.x a výše	Python 3.4 a výše	Python 2.x a výše
Objektově orientovaný přístup	Ne	Ano	Částečně
Práce s cestami napříč OS	os.path.join()	Automaticky (operátor /)	Závisí na os.path

Nejčastěji se setkáme s modulem os.path, konkrétně s funkcí os.path.exists(). Tato funkce vrací hodnotu True nebo False podle toho, zda zadaná cesta existuje. Je důležité si uvědomit, že tato funkce nekontroluje, zda jde o složku nebo soubor – pouze ověřuje existenci dané cesty. Pokud chceme být přesnější a ujistit se, že jde skutečně o adresář, použijeme funkci os.path.isdir(), která vrátí True jen tehdy, když cesta odkazuje na složku, nikoliv na soubor.

Moderní přístup pak nabízí modul pathlib, který byl do Pythonu přidán ve verzi 3.4 a od té doby si získal velkou oblibu pro svou čitelnost a eleganci. Pomocí objektu Path a jeho metody exists() nebo is_dir() lze provést totéž, ale kód je přehlednější a lépe čitelný. Například zápis Path(/cesta/ke/složce).is_dir() je mnohem intuitivnější než starší přístup přes os.path.

Proč je ale tato kontrola tak důležitá? Představte si situaci, kdy se váš program pokusí otevřít soubor ve složce, která neexistuje. Python v takovém případě vyhodí výjimku FileNotFoundError, která pokud není ošetřena, celý program ukončí. Podobně, pokud se pokusíte vytvořit složku, která již existuje, narazíte na výjimku FileExistsError. Předchozí kontrola existence tedy není zbytečná opatrnost, ale základní součást robustního kódu.

V praxi se velmi často setkáme s kombinací kontroly existence a následné tvorby složky. Klasický vzor vypadá tak, že nejprve ověříme, zda složka existuje, a pokud ne, vytvoříme ji. Tento postup je naprosto běžný například při generování výstupních adresářů pro logy, exporty dat nebo dočasné soubory. Funkce os.makedirs() s parametrem exist_ok=True tento vzor zjednodušuje – pokud složka existuje, nevyhodí chybu, ale jednoduše pokračuje dál. Jde o elegantní řešení, které eliminuje potřebu explicitní kontroly v mnoha jednoduchých případech.

Nicméně spoléhat se výhradně na exist_ok=True není vždy správné. Existují situace, kdy potřebujeme přesně vědět, zda složka existovala předem nebo byla nově vytvořena. Například při zálohování dat může být důležité rozlišit, zda zálohovací adresář byl připraven předem, nebo byl vytvořen až při spuštění programu. V takovém případě je explicitní kontrola pomocí os.path.isdir() nebo Path.is_dir() nezbytná.

Dalším aspektem, na který se často zapomíná, jsou přístupová práva. Složka může existovat, ale váš program k ní nemusí mít přístup. Samotná kontrola existence tedy nestačí – v kritických aplikacích je vhodné ověřit i oprávnění pomocí funkce os.access(), která umí otestovat, zda má aktuální proces právo číst, zapisovat nebo spouštět obsah dané složky. Tento krok bývá přehlížen, přesto může být rozdílem mezi spolehlivou aplikací a tou, která selhává na produkčním serveru s omezenými právy.

Správná kontrola existence složky před operacemi je tedy základním stavebním kamenem každého solidního Python skriptu, který pracuje se souborovým systémem. Ať už jde o čtení konfiguračních souborů, ukládání výstupů nebo manipulaci s dočasnými adresáři, vždy se vyplatí věnovat chvíli ověření, že prostředí, ve kterém náš kód pracuje, odpovídá našim očekáváním.

Přejmenování a přesun adresářů v Pythonu

Práce se souborovým systémem patří mezi základní dovednosti každého programátora, který píše skripty v Pythonu. Přejmenování a přesun adresářů jsou operace, které se v praxi vyskytují velmi často, ať už jde o automatizaci zálohovacích procesů, reorganizaci projektové struktury nebo jednoduché udržování pořádku v souborech. Python nabízí hned několik způsobů, jak tyto úkoly zvládnout elegantně a efektivně.

Nejstarší a nejznámější způsob, jak přejmenovat nebo přesunout adresář v Pythonu, je použití modulu os. Konkrétně funkce os.rename() slouží k přejmenování složky nebo souboru. Tato funkce přijímá dva argumenty — původní cestu a novou cestu. Pokud zadáte pouze jiný název ve stejném adresáři, dojde k přejmenování. Pokud však zadáte zcela jinou cestu, Python složku přesune na nové místo. Je důležité vědět, že os.rename() funguje spolehlivě pouze v rámci jednoho souborového systému. Pokud se pokoušíte přesunout adresář mezi různými disky nebo oddíly, může dojít k chybě.

Pro robustnější řešení, které funguje i napříč různými souborovými systémy, je vhodné použít modul shutil. Funkce shutil.move() je v tomto ohledu mnohem flexibilnější. Dokáže přesunout adresář i v případě, že zdrojová a cílová cesta leží na různých discích. Interně totiž nejprve zkopíruje obsah adresáře a poté odstraní původní složku. Toto chování je sice pomalejší než přímé přejmenování pomocí os.rename(), ale za cenu větší spolehlivosti a kompatibility.

Moderní Python přináší také modul pathlib, který představuje objektově orientovaný přístup k práci se souborovým systémem. Třída Path z tohoto modulu nabízí metodu rename(), která funguje podobně jako os.rename(). Syntaxe je přitom velmi čitelná a intuitivní. Místo řetězců pracujete s objekty Path, což výrazně snižuje riziko chyb způsobených nesprávným formátováním cest. Například na Windows systémech může být práce s lomítky problematická, ale pathlib tento problém elegantně řeší tím, že automaticky používá správné oddělovače cest.

Při přejmenování nebo přesunu adresářů je vždy nutné myslet na ošetření výjimek. Nejčastějšími chybami, na které narazíte, jsou situace, kdy zdrojový adresář neexistuje, cílová cesta již existuje, nebo nemáte dostatečná oprávnění k provedení operace. Python v těchto případech vyvolá výjimky jako FileNotFoundError, FileExistsError nebo PermissionError. Správně napsaný skript by měl tyto výjimky zachytávat a reagovat na ně smysluplným způsobem, například výpisem chybové zprávy nebo pokusem o alternativní řešení.

Dalším důležitým aspektem je práce s relativními a absolutními cestami. Relativní cesty jsou závislé na aktuálním pracovním adresáři, který lze zjistit pomocí os.getcwd(). Absolutní cesty jsou naproti tomu nezávislé na kontextu spuštění skriptu. Pro spolehlivé skripty je obecně doporučováno používat absolutní cesty nebo cesty sestavené dynamicky pomocí os.path.abspath() či pathlib.Path.resolve(). Tím se vyhnete situacím, kdy skript funguje správně při spuštění z jednoho místa, ale selhává při spuštění odjinud.

Zajímavou situací je přejmenování adresáře, který obsahuje velké množství souborů a podsložek. V takovém případě je přejmenování pomocí os.rename() nebo pathlib Path.rename() téměř okamžité, protože operační systém pouze změní záznam v souborovém systému, aniž by fyzicky přesouval data. Naproti tomu shutil.move() při přesunu mezi různými souborovými systémy musí skutečně zkopírovat všechna data, což může trvat podstatně déle.

V praxi se také setkáte s potřebou přejmenovat více adresářů najednou, například při dávkovém zpracování. Python umožňuje tuto operaci snadno automatizovat pomocí cyklů a funkcí os.listdir() nebo os.scandir(). Funkce os.scandir() je přitom výkonnější a modernější alternativou k os.listdir(), protože vrací objekty DirEntry, které obsahují nejen název položky, ale také metadata jako je typ položky nebo čas poslední modifikace. To vám umožní filtrovat pouze adresáře a ignorovat soubory, aniž byste museli volat další systémové funkce.

Nezapomeňte také na to, že přejmenování adresáře může ovlivnit relativní cesty v jiných skriptech nebo konfiguračních souborech, které na tento adresář odkazují. Proto je vždy dobré před provedením takové operace zvážit všechny závislosti a případně aktualizovat i ostatní části projektu. Python sám o sobě tuto kontrolu neprovádí — je na programátorovi, aby zajistil konzistenci celého systému.

Práce s relativními a absolutními cestami

Při práci se soubory a složkami v Pythonu se nevyhnutelně setkáte s pojmy relativní a absolutní cesta. Pochopení rozdílu mezi těmito dvěma typy cest je naprosto zásadní, protože špatně zadaná cesta může způsobit, že váš skript nebude fungovat správně, nebo ještě hůře, bude fungovat na vašem počítači, ale selže u kolegy nebo na serveru.

Absolutní cesta vždy začíná od kořenového adresáře systému. Na systémech Windows to typicky vypadá jako `C:\Users\uzivatel\dokumenty\projekt`, zatímco na Linuxu nebo macOS má absolutní cesta podobu `/home/uzivatel/dokumenty/projekt`. Absolutní cesta je jednoznačná a nezávisí na tom, kde se váš Python skript právě nachází. Pokud ji zadáte správně, Python vždy ví přesně, kde daný soubor nebo složku hledat.

Relativní cesta naproti tomu vychází z aktuálního pracovního adresáře, tedy z místa, odkud váš skript spouštíte. Pokud se nacházíte ve složce `/home/uzivatel/projekt` a chcete přistoupit k souboru `data.txt`, který leží ve složce `vstupni_data` uvnitř tohoto projektu, stačí napsat cestu jako `vstupni_data/data.txt`. Python si sám doplní zbytek. Právě tato flexibilita relativních cest je jejich největší výhodou, ale zároveň i potenciálním zdrojem problémů.

V Pythonu pracujete s cestami nejčastěji pomocí modulu `os` nebo modernějšího modulu `pathlib`. Pro zjištění aktuálního pracovního adresáře slouží funkce `os.getcwd()`, která vrátí absolutní cestu k adresáři, ze kterého byl skript spuštěn. Tuto funkci je dobré volat na začátku skriptu, abyste věděli, odkud Python relativní cesty odvozuje. Pokud chcete pracovní adresář změnit, použijete `os.chdir()`, kam předáte cestu k novému adresáři.

Velmi častou chybou začátečníků je předpoklad, že aktuální pracovní adresář je vždy složka, ve které leží samotný Python skript. To ovšem nemusí být pravda. Pokud skript spustíte z jiného adresáře, například příkazem `python /home/uzivatel/projekt/skript.py` z domovské složky, bude pracovní adresář `/home/uzivatel`, nikoli `/home/uzivatel/projekt`. Relativní cesty pak budou odkazovat na úplně jiná místa, než jste zamýšleli.

Aby se tomuto problému předešlo, doporučuje se používat speciální proměnnou `__file__`, která obsahuje cestu k aktuálně spuštěnému skriptu. Kombinací s funkcemi `os.path.dirname()` a `os.path.abspath()` lze získat absolutní cestu ke složce skriptu a od ní pak odvozovat všechny ostatní cesty. Typický vzorec vypadá takto: nejprve získáte adresář skriptu pomocí `os.path.dirname(os.path.abspath(__file__))` a poté k němu připojíte relativní cestu pomocí `os.path.join()`.

Modul `pathlib`, který byl do Pythonu přidán ve verzi 3.4, přináší ještě elegantnější přístup. Třída `Path` umožňuje pracovat s cestami jako s objekty, přičemž operátor `/` slouží ke spojování částí cesty. Výraz `Path(__file__).parent` vrátí adresář, ve kterém se nachází aktuální skript, a od tohoto objektu lze pak snadno budovat další cesty. Například `Path(__file__).parent / data / soubor.csv` vytvoří cestu k souboru `soubor.csv` ve složce `data`, která leží ve stejném adresáři jako skript.

Při práci s absolutními cestami je důležité myslet na přenositelnost kódu. Cesta, která funguje na vašem Windows počítači, bude na Linuxu pravděpodobně nefunkční, protože používá zpětná lomítka místo dopředných. Python sice v mnoha případech zvládne oba formáty na Windows, ale na Linuxu zpětná lomítka jako oddělovač cesty nefungují vůbec. Proto se vždy doporučuje používat `os.path.join()` nebo operátor `/` z modulu `pathlib`, které automaticky použijí správný oddělovač pro daný operační systém.

Převod relativní cesty na absolutní je v Pythonu velmi jednoduchý. Funkce `os.path.abspath()` přijme relativní cestu a vrátí její absolutní ekvivalent odvozený od aktuálního pracovního adresáře. Tato funkce je užitečná například při ladění, kdy chcete zjistit, kde přesně Python hledá váš soubor. Podobnou funkcionalitu nabízí metoda `Path.resolve()` z modulu `pathlib`, která navíc vyřeší i symbolické odkazy a odstraní nadbytečné části cesty jako `..` nebo `.`.

Tečka `.` v cestě označuje aktuální adresář a dvě tečky `..` označují nadřazený adresář. Tyto zkratky fungují jak v relativních, tak v absolutních cestách a Python je bez problémů interpretuje. Cesta jako `../../konfigurace/nastaveni.ini` tedy říká Pythonu, aby šel o dvě úrovně výše v adresářové struktuře a tam hledal složku `konfigurace` se souborem `nastaveni.ini`. Správné pochopení a používání relativních i absolutních cest je základem pro psaní přenositelného a spolehlivého Python kódu, který bude fungovat bez ohledu na to, kde je spuštěn.

Složka pojmenovaná Python je jako had v trávě – nikdy nevíš, co v ní najdeš, dokud ji neotevřeš, a někdy je lepší ji raději nechat být.

Rostislav Dvořáček

Nejčastější chyby při manipulaci se složkami

Práce se složkami v Pythonu se na první pohled může zdát jako jednoduchá záležitost, ale zkušení vývojáři dobře vědí, že právě tato oblast skrývá celou řadu záludností, které dokážou začátečníkům i pokročilým programátorům pořádně zamotat hlavu. Pojďme se podívat na to, co se nejčastěji pokazí a proč.

Jednou z nejrozšířenějších chyb je nesprávné sestavování cest k adresářům. Mnoho programátorů, zejména těch, kteří přecházejí z jiného operačního systému, používá pevně zakódované cesty s lomítky nebo zpětnými lomítky. Na systému Windows se používá zpětné lomítko, zatímco na Linuxu a macOS lomítko dopředu. Pokud napíšete cestu jako `C:\\Users\\jmeno\\dokumenty`, váš skript bude fungovat pouze na Windows a na jiných systémech selže. Správným řešením je použití modulu os.path nebo modernějšího přístupu přes knihovnu pathlib, která se o rozdíly mezi operačními systémy postará automaticky. Funkce `os.path.join()` nebo třída `Path` z pathlib jsou vaši nejlepší přátelé při sestavování cest, protože zajistí, že váš kód bude fungovat všude.

Další velmi častou chybou je zapomenutí zkontrolovat, zda složka existuje, než se ji pokusíte použít nebo vytvořit. Pokud se pokusíte vytvořit složku, která již existuje, pomocí `os.mkdir()`, Python vyhodí výjimku `FileExistsError`. Naopak pokud se pokusíte přistoupit ke složce, která neexistuje, dostanete `FileNotFoundError`. Mnoho začátečníků tuto kontrolu vynechává a pak se diví, proč jejich program padá. Řešením je buď použití `os.path.exists()` před samotnou operací, nebo ještě elegantnější způsob pomocí `os.makedirs()` s parametrem `exist_ok=True`, který vytvoří složku pouze tehdy, pokud ještě neexistuje, a pokud existuje, tiše to přeskočí.

Problémy nastávají také při práci s relativními a absolutními cestami. Relativní cesta je vždy vztažena k aktuálnímu pracovnímu adresáři, který se může lišit podle toho, odkud skript spouštíte. Pokud spustíte skript z jiného adresáře, než kde se nachází, relativní cesty přestanou fungovat. Spousta programátorů předpokládá, že aktuální pracovní adresář je vždy tam, kde leží jejich skript, ale to tak vůbec nemusí být. Správným přístupem je použití `__file__` pro zjištění umístění skriptu a od něj odvozovat cesty, nebo pracovat výhradně s absolutními cestami.

Zapomínání na uzavírání souborových deskriptorů při procházení složek je dalším problémem, který se projevuje zejména při zpracování velkého množství souborů. Pokud otevíráte soubory v cyklu a nezavíráte je, může dojít k vyčerpání systémových zdrojů. Vždy používejte kontextový manažer `with`, který zajistí správné uzavření souboru i v případě výjimky.

Velmi podceňovanou chybou je také ignorování oprávnění k adresářům. Python vám umožní napsat kód, který se pokusí číst nebo zapisovat do chráněné složky, ale bez příslušných oprávnění to skončí výjimkou `PermissionError`. Správně napsaný kód by měl tuto situaci ošetřit pomocí bloku `try-except` a uživateli srozumitelně sdělit, co se stalo.

Dalším kamenem úrazu je rekurzivní procházení adresářů bez omezení hloubky. Funkce `os.walk()` prochází celý strom adresářů, což může být při špatném použití velmi pomalé nebo dokonce způsobit problémy na systémech se symbolickými odkazy, které vytvářejí cyklické závislosti. Je důležité vědět, co přesně procházíte, a případně nastavit maximální hloubku rekurze nebo vyloučit symbolické odkazy.

Nezanedbatelnou chybou je také nesprávné nakládání s kódováním názvů souborů a složek. Na různých systémech mohou být názvy souborů kódovány různě a pokud váš kód předpokládá konkrétní kódování, může selhat při práci se soubory, jejichž názvy obsahují diakritiku nebo jiné speciální znaky. Python 3 tuto situaci výrazně zlepšil oproti Pythonu 2, ale stále je třeba být obezřetný, zejména při práci s operačním systémem Windows a staršími souborovými systémy.

Nakonec je třeba zmínit mazání složek bez ověření jejich obsahu. Funkce `os.rmdir()` smaže pouze prázdnou složku, ale `shutil.rmtree()` smaže složku i se vším jejím obsahem bez jakéhokoliv varování. Tato operace je nevratná a pokud ji použijete omylem na špatnou složku, přijdete o všechna data v ní uložená. Vždy si dvakrát ověřte, co mažete, a zvažte přidání potvrzovacího dialogu nebo alespoň výpisu obsahu před samotným smazáním.