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

Co je adresář a složka v Pythonu

V Pythonu se při práci se souborovým systémem velmi často setkáváme s pojmy adresář a složka. Ačkoliv se tyto dva výrazy v běžném hovoru používají jako synonyma a v praxi označují totéž, je dobré vědět, odkud oba pojmy pocházejí a jak s nimi Python pracuje. Adresář je v podstatě kontejner, který slouží k organizaci souborů a dalších adresářů na disku. Složka je pak modernější, graficky orientovaný termín, který se rozšířil spolu s příchodem grafických uživatelských rozhraní, kde jsou adresáře zobrazovány jako ikony složek. Z technického hlediska jde o totéž.

Pokud pracujete s Pythonem a potřebujete manipulovat se souborovým systémem, narazíte na celou řadu nástrojů a modulů, které vám tuto práci usnadní. Nejdůležitějším modulem pro práci s adresáři v Pythonu je modul `os`, respektive jeho podmodul `os.path`, a dále moderní modul `pathlib`, který byl do Pythonu přidán ve verzi 3.4 a přináší objektově orientovaný přístup k práci se souborovým systémem. Oba přístupy mají své výhody a záleží na konkrétním případu použití, který z nich zvolíte.

Adresář v kontextu Pythonu tedy není nic jiného než místo na disku, kde jsou uloženy soubory nebo další vnořené adresáře. Každý adresář má svou cestu, která může být buď absolutní, tedy začínající od kořenového adresáře systému, nebo relativní, která je vztažena k aktuálnímu pracovnímu adresáři programu. Aktuální pracovní adresář je ten adresář, ze kterého byl Python skript spuštěn, a lze jej zjistit pomocí funkce `os.getcwd()`, která vrátí jeho úplnou cestu jako řetězec.

Práce s adresáři v Pythonu zahrnuje celou řadu operací. Můžete vytvářet nové adresáře pomocí funkce `os.mkdir()` pro vytvoření jednoho adresáře, nebo `os.makedirs()` pro vytvoření celé hierarchie adresářů najednou. Pokud chcete adresář smazat, použijete `os.rmdir()`, přičemž tato funkce funguje pouze na prázdné adresáře. Pro smazání adresáře včetně veškerého jeho obsahu slouží funkce `shutil.rmtree()` z modulu `shutil`. Přejmenování nebo přesun adresáře lze provést pomocí funkce `os.rename()` nebo `shutil.move()`.

Moderní přístup přes modul `pathlib` přináší elegantnější syntaxi. Místo řetězců pracujete s objekty třídy `Path`, které mají metody jako `.mkdir()`, `.rmdir()`, `.rename()` nebo `.iterdir()`. Metoda `.iterdir()` je zvláště užitečná, protože umožňuje procházet obsah adresáře a pracovat s každou položkou zvlášť. Výhodou `pathlib` je také to, že se automaticky stará o rozdíly mezi operačními systémy, jako jsou různé oddělovače cest na Windows a Linuxu.

Je důležité si uvědomit, že Python při práci s adresáři vždy závisí na oprávněních, která má daný uživatel nebo proces k dispozici. Pokud se pokusíte vytvořit adresář v místě, kde k tomu nemáte práva, Python vyhodí výjimku `PermissionError`. Proto je při psaní skriptů pracujících se souborovým systémem vhodné ošetřovat výjimky pomocí bloků `try` a `except`, aby program nespadl při neočekávané situaci.

Pochopení toho, co adresář a složka v Pythonu jsou a jak s nimi pracovat, je základním předpokladem pro psaní skriptů, které automatizují práci se soubory, zpracovávají data z disku nebo spravují strukturu projektů. Bez solidního základu v oblasti práce se souborovým systémem se při vývoji v Pythonu daleko nedostanete, protože dříve nebo později narazíte na situaci, kdy budete potřebovat číst soubory z konkrétního adresáře, ukládat výsledky do nové složky nebo procházet celou stromovou strukturu adresářů rekurzivně.

Modul os a práce s cestami

Práce se soubory a adresáři je v Pythonu záležitostí, která se řeší velmi často, a modul os je v tomto ohledu naprosto klíčovým nástrojem. Tento modul je součástí standardní knihovny Pythonu, takže ho není potřeba instalovat přes pip ani žádný jiný správce balíčků. Stačí ho jednoduše importovat na začátku skriptu pomocí příkazu import os a okamžitě máte k dispozici celou sadu funkcí, které vám umožní pracovat s cestami, adresáři a soubory na úrovni operačního systému.

Srovnání správců souborů a jejich podpory adresářové struktury

Vlastnost	Python (os modul)	Bash (shell)	PowerShell	Node.js (fs modul)
Vytvoření složky	os.mkdir() / os.makedirs()	mkdir	New-Item -ItemType Directory	fs.mkdirSync()
Smazání složky	os.rmdir() / shutil.rmtree()	rmdir / rm -r	Remove-Item	fs.rmdirSync()
Výpis obsahu adresáře	os.listdir() / os.scandir()	ls / dir	Get-ChildItem	fs.readdirSync()
Přejmenování složky	os.rename()	mv	Rename-Item	fs.renameSync()
Zjištění aktuální složky	os.getcwd()	pwd	Get-Location	process.cwd()
Změna adresáře	os.chdir()	cd	Set-Location	process.chdir()
Rekurzivní procházení	os.walk()	find	Get-ChildItem -Recurse	fs.readdirSync() + rekurze
Kontrola existence složky	os.path.isdir()	[ -d "cesta" ]	Test-Path	fs.existsSync()
Multiplatformní podpora	Ano (Windows, Linux, macOS)	Linux, macOS	Ano (Windows, Linux, macOS)	Ano (Windows, Linux, macOS)
Verze / vydání	Python 3.12 (2023)	Bash 5.2 (2022)	PowerShell 7.4 (2023)	Node.js 21 (2023)

Jednou z nejzákladnějších věcí, které budete při práci s adresáři potřebovat, je zjistit, kde se právě nacházíte. K tomu slouží funkce os.getcwd(), která vrátí aktuální pracovní adresář jako řetězec. Pokud například spouštíte skript z domovského adresáře, tato funkce vám přesně ukáže, kde se Python v danou chvíli nachází. Je to velmi praktické, protože relativní cesty se vždy odvíjejí od tohoto aktuálního pracovního adresáře.

Pokud potřebujete pracovní adresář změnit, použijete funkci os.chdir(), které předáte cestu k novému adresáři. Tato změna platí po celou dobu běhu skriptu, dokud ji opět nezměníte nebo dokud program neskončí. Kombinace těchto dvou funkcí vám dává plnou kontrolu nad tím, kde se váš program pohybuje v rámci souborového systému.

Velmi důležitou součástí modulu os je podmodul os.path, který se specializuje přímo na práci s cestami. Pomocí funkce os.path.join() můžete skládat cesty z více částí způsobem, který je nezávislý na operačním systému. To je obrovská výhoda, protože Windows používá zpětná lomítka jako oddělovač adresářů, zatímco Linux a macOS používají lomítka dopředu. Funkce os.path.join() se o tuto kompatibilitu postará automaticky za vás.

Dalšími velmi užitečnými funkcemi jsou os.path.exists(), která ověří, zda daná cesta vůbec existuje, os.path.isfile(), jež zkontroluje, zda se jedná o soubor, a os.path.isdir(), která ověří, zda jde o adresář neboli složku. Tyto funkce jsou naprosto nezbytné v situacích, kdy chcete předejít chybám způsobeným tím, že se pokoušíte pracovat s neexistujícím souborem nebo adresářem.

Vytváření nových adresářů zajišťuje funkce os.mkdir(), která vytvoří jeden nový adresář. Pokud ale potřebujete vytvořit celou hierarchii adresářů najednou, tedy například složku a zároveň všechny její nadřazené složky, které ještě neexistují, sáhnete po funkci os.makedirs(). Tato funkce přijímá volitelný parametr exist_ok=True, díky kterému nevyhodí chybu v případě, že adresář již existuje.

Mazání adresářů probíhá pomocí funkce os.rmdir(), která ovšem funguje pouze na prázdných adresářích. Pokud chcete smazat celý adresář včetně jeho obsahu, je potřeba sáhnout po modulu shutil a jeho funkci shutil.rmtree(). Samotný modul os totiž tuto operaci z bezpečnostních důvodů neumožňuje.

Procházení adresářové struktury je další oblastí, kde modul os exceluje. Funkce os.listdir() vrátí seznam všech souborů a podsložek v daném adresáři. Pokud ale potřebujete procházet celou stromovou strukturu rekurzivně, tedy včetně všech vnořených podsložek, použijete funkci os.walk(). Tato funkce je generátor, který pro každý adresář vrátí trojici obsahující cestu k aktuálnímu adresáři, seznam jeho podsložek a seznam souborů v něm. Díky tomu lze velmi elegantně projít celý souborový systém nebo jeho část.

Práce s cestami zahrnuje také jejich rozdělování a analýzu. Funkce os.path.basename() vrátí název souboru nebo poslední složky z dané cesty, zatímco os.path.dirname() vrátí cestu k nadřazenému adresáři. Funkce os.path.split() pak cestu rozdělí na tyto dvě části najednou a vrátí je jako dvojici. Pro práci s příponami souborů existuje funkce os.path.splitext(), která oddělí příponu od zbytku názvu souboru.

Je také dobré vědět, že od Pythonu verze 3.4 existuje alternativa v podobě modulu pathlib, který přináší objektově orientovaný přístup k práci s cestami. Mnoho moderních projektů dává pathlib přednost před klasickým os.path, protože kód je pak čitelnější a přehlednější. Nicméně modul os zůstává stále velmi rozšířeným a plně funkčním nástrojem, který je součástí obrovského množství existujícího kódu a projektů po celém světě.

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

Práce se souborovým systémem je v Pythonu naprosto každodenní záležitost a jednou z nejzákladnějších operací, které budete potřebovat, je vytváření nových složek. K tomu slouží funkce os.mkdir(), která je součástí standardního modulu `os`. Tento modul poskytuje rozhraní pro interakci s operačním systémem a je dostupný na všech platformách, ať už pracujete na Windows, Linuxu nebo macOS.

Než začnete funkci os.mkdir() používat, musíte samozřejmě modul os importovat. Stačí na začátek vašeho skriptu napsat import os a máte přístup ke všem funkcím, které tento modul nabízí. Samotné volání funkce je pak velmi jednoduché — stačí zadat cestu k adresáři, který chcete vytvořit.

Základní syntaxe vypadá takto: os.mkdir(nazev_slozky). Pokud zadáte pouze název bez úplné cesty, Python vytvoří složku v aktuálním pracovním adresáři. Aktuální pracovní adresář si můžete kdykoliv ověřit pomocí funkce os.getcwd(), která vrátí řetězec s cestou k aktuálnímu umístění vašeho skriptu, respektive k místu, odkud byl spuštěn.

Jedna z věcí, na kterou je třeba dávat pozor, je to, že os.mkdir() vytvoří pouze jednu úroveň adresářů. To znamená, že pokud chcete vytvořit složku, jejíž nadřazená složka ještě neexistuje, funkce selže a vyhodí výjimku `FileNotFoundError`. Pokud tedy chcete vytvořit strukturu jako například `projekty/python/skripty`, musíte nejprve zajistit, že adresáře `projekty` a `projekty/python` již existují. Teprve poté můžete vytvořit `skripty` jako podsložku.

Pro případ, kdy potřebujete vytvořit celou hierarchii adresářů najednou, Python nabízí funkci os.makedirs(), která vytvoří všechny potřebné nadřazené adresáře automaticky. Je to výrazně pohodlnější přístup při práci se složitějšími strukturami adresářů.

Dalším důležitým aspektem je ošetření chyb. Pokud se pokusíte vytvořit složku, která již existuje, os.mkdir() vyhodí výjimku FileExistsError. Proto je dobrou praxí obalit volání funkce blokem try-except, kde tuto výjimku zachytíte a odpovídajícím způsobem zareagujete. Například:

try:

os.mkdir(nova_slozka)

except FileExistsError:

print(Složka již existuje.)

Tímto způsobem váš program nespadne, ale elegantně informuje uživatele o situaci. Alternativně můžete před samotným vytvářením složky zkontrolovat, zda již existuje, pomocí funkce os.path.exists() nebo os.path.isdir(). Obě tyto funkce vrátí hodnotu True nebo False podle toho, zda zadaná cesta existuje.

Funkce os.mkdir() přijímá také volitelný parametr mode, který definuje oprávnění nově vytvořeného adresáře. Tento parametr je relevantní především na unixových systémech, kde oprávnění hrají důležitou roli. Výchozí hodnota je 0o777, což znamená plná oprávnění pro vlastníka, skupinu i ostatní uživatele. Skutečná oprávnění jsou však ovlivněna hodnotou umask nastavenou v systému, takže výsledek nemusí vždy přesně odpovídat zadané hodnotě.

Při práci s cestami je také důležité myslet na přenositelnost kódu mezi různými operačními systémy. Windows používá zpětné lomítko jako oddělovač cest, zatímco Linux a macOS používají lomítko. Aby byl váš kód přenositelný, doporučuje se používat funkci os.path.join(), která automaticky použije správný oddělovač podle aktuálního operačního systému. Například `os.path.join(projekty, python, skripty)` vrátí správně formátovanou cestu bez ohledu na to, na jakém systému kód spouštíte.

Moderní Python nabízí také alternativu v podobě modulu pathlib, který přináší objektově orientovaný přístup k práci se souborovým systémem. Třída `Path` z tohoto modulu má metodu mkdir(), která funguje podobně jako os.mkdir(), ale nabízí navíc parametry `parents` a `exist_ok`. Parametr `parents=True` zajistí vytvoření všech chybějících nadřazených adresářů a `exist_ok=True` zabrání vyvolání výjimky v případě, že složka již existuje. Přesto os.mkdir() 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 který preferuje funkcionální styl programování.

Rekurzivní tvorba adresářů s os.makedirs

Při práci se souborovým systémem v Pythonu se velmi často setkáváme se situací, kdy potřebujeme vytvořit nejen jednu složku, ale celou hierarchii adresářů najednou. Funkce os.makedirs() je přesně to, co v takových chvílích potřebujeme. Na rozdíl od základní funkce os.mkdir(), která dokáže vytvořit pouze jeden adresář a vyžaduje, aby jeho nadřazená složka již existovala, funkce os.makedirs() zvládne vytvořit celou cestu adresářů rekurzivně, tedy od kořene až po poslední složku v řetězci.

Představte si situaci, kdy pracujete na projektu a potřebujete vytvořit strukturu jako například /data/rok/mesic/den/. Pokud žádná z těchto složek dosud neexistuje, os.mkdir() by selhala hned na první úrovni, protože by se pokoušela vytvořit složku rok uvnitř adresáře data, který ještě neexistuje. Funkce os.makedirs() tento problém elegantně řeší tím, že postupně prochází celou cestu a vytváří každý chybějící adresář.

Použití je velmi jednoduché. Stačí importovat modul os a zavolat funkci s požadovanou cestou. Základní syntaxe vypadá takto: os.makedirs(cesta/k/adresari). Python se postará o zbytek a projde celou zadanou cestu, přičemž vytvoří všechny chybějící adresáře.

Jeden z nejdůležitějších parametrů, který by měl každý programátor znát, je exist_ok. Pokud tento parametr nastavíte na hodnotu True, funkce nebude vyvolávat výjimku v případě, že cílový adresář již existuje. Bez tohoto parametru, respektive při jeho výchozí hodnotě False, by Python hodil chybu FileExistsError pokaždé, když se pokusíte vytvořit adresář, který již na disku existuje. V praxi se parametr exist_ok=True používá naprosto běžně, protože skripty se spouštějí opakovaně a není žádoucí, aby program havaroval jen proto, že složka z předchozího spuštění stále existuje.

Dalším parametrem je mode, který určuje oprávnění nově vytvořených adresářů. Tento parametr je relevantní především na unixových systémech jako Linux nebo macOS, kde souborový systém pracuje s klasickými POSIX oprávněními. Na Windows tento parametr nemá praktický efekt. Hodnota se zadává v osmičkové soustavě, například 0o755 znamená, že vlastník má plná práva a ostatní uživatelé mohou adresář číst a procházet.

Je důležité si uvědomit, že os.makedirs() vytváří adresáře, nikoli soubory. Pokud tedy zadáte cestu, která na konci obsahuje název souboru, Python se pokusí vytvořit i tento soubor jako adresář, což pravděpodobně není to, co jste zamýšleli. Vždy je proto dobré mít jasno v tom, co je složka a co je soubor, a případně použít funkci os.path.dirname() k oddělení adresářové části cesty od názvu souboru.

V moderním Pythonu, konkrétně od verze 3.4, existuje také alternativa v podobě modulu pathlib, který nabízí objektově orientovaný přístup ke správě cest a souborového systému. Metoda Path.mkdir(parents=True, exist_ok=True) dělá v podstatě totéž co os.makedirs() s parametrem exist_ok=True, ale mnozí vývojáři preferují pathlib pro jeho čitelnější syntaxi a intuitivnější práci s cestami. Přesto os.makedirs() zůstává velmi rozšířenou a spolehlivou volbou, zejména v starším kódu nebo v situacích, kde se pracuje s prostým řetězcem cesty.

Při psaní produkčního kódu je vždy vhodné ošetřit potenciální výjimky pomocí bloku try-except. I přes parametr exist_ok mohou nastat jiné chyby, například nedostatečná oprávnění k zápisu na daném místě souborového systému, nebo situace, kdy část cesty je soubor, nikoli adresář. Robustní kód by měl tyto situace předvídat a reagovat na ně smysluplně, ať už formou chybové hlášky pro uživatele, nebo zápisem do logu.

Celkově vzato, os.makedirs() je jednou z nejužitečnějších funkcí pro práci s adresáři v Pythonu a její zvládnutí výrazně usnadní každodenní práci se souborovým systémem, ať už jde o automatizaci, zpracování dat nebo organizaci výstupních souborů aplikace.

Výpis obsahu složky přes os.listdir

Práce se soubory a adresáři patří k základním dovednostem každého programátora, který pracuje s Pythonem. Jednou z nejpoužívanějších funkcí pro získání přehledu o obsahu složky je funkce os.listdir(), která je součástí standardního modulu os. Tento modul není potřeba instalovat, protože je přímo součástí standardní knihovny Pythonu, takže stačí jej pouze naimportovat na začátku skriptu pomocí příkazu import os.

Funkce os.listdir() přijímá jako argument cestu k adresáři, jehož obsah chceme vypsat. Pokud žádný argument nezadáme, funkce automaticky pracuje s aktuálním pracovním adresářem, ve kterém se skript nachází. Výsledkem volání této funkce je seznam (list) řetězců, kde každý řetězec představuje název jednoho souboru nebo podsložky, která se v daném adresáři nachází. Je důležité si uvědomit, že funkce vrací pouze názvy položek, nikoliv jejich úplné cesty. To znamená, že pokud potřebujeme pracovat s konkrétním souborem dále v kódu, musíme cestu sestavit ručně, například pomocí funkce os.path.join().

Praktické použití vypadá velmi jednoduše. Stačí napsat obsah = os.listdir('/cesta/k/adresari') a proměnná obsah bude obsahovat seznam všech položek v daném adresáři. Následně můžeme tento seznam procházet pomocí cyklu for a s každou položkou provádět různé operace. Například můžeme zjistit, zda se jedná o soubor nebo o podsložku, a to pomocí funkcí os.path.isfile() nebo os.path.isdir().

Jedna věc, na kterou je potřeba si dát pozor, je skutečnost, že os.listdir() neprochází adresáře rekurzivně. To znamená, že pokud máme složku, která obsahuje další podsložky, funkce nám vrátí pouze obsah nejvyšší úrovně a do podsložek se nepodívá. Pokud potřebujeme procházet celou stromovou strukturu adresářů, je vhodnější použít funkci os.walk(), která toto chování nabízí automaticky.

Dalším důležitým aspektem je pořadí, ve kterém jsou položky vráceny. os.listdir() negarantuje žádné konkrétní pořadí výpisu. Pořadí závisí na operačním systému a souborovém systému. Pokud potřebujeme abecedně seřazený seznam, musíme výsledek seřadit pomocí funkce sorted(), například takto: sorted(os.listdir('/cesta/k/adresari')). Tímto způsobem získáme přehledně seřazený výpis, se kterým se pracuje mnohem pohodlněji.

Při práci s funkcí os.listdir() je také dobré myslet na ošetření chyb. Pokud zadáme cestu k adresáři, který neexistuje, Python vyhodí výjimku FileNotFoundError. Proto je vhodné celý blok kódu obalit do konstrukce try-except, aby program nespadl při neočekávaném vstupu nebo při práci s dynamicky generovanými cestami. Správné ošetření výjimek je znakem kvalitního a robustního kódu.

Zajímavé je také to, že os.listdir() zobrazuje i skryté soubory a složky, tedy ty, jejichž název začíná tečkou, jako například .git nebo .env. Na rozdíl od grafických správců souborů, které tyto položky standardně skrývají, Python žádné takové filtrování automaticky neprovádí. Pokud tedy chceme skryté soubory z výpisu vyloučit, musíme to udělat ručně pomocí podmínky, která zkontroluje, zda název položky nezačíná tečkou.

Celkově lze říci, že os.listdir() je velmi užitečný nástroj pro každodenní práci s adresáři v Pythonu. Jeho jednoduchost a přímočarost z něj dělají ideální volbu pro základní operace s obsahem složek, a přestože existují i modernější alternativy jako například modul pathlib s metodou iterdir(), funkce os.listdir() zůstává oblíbenou a hojně používanou součástí pythonistického repertoáru.

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

Při práci s adresáři v Pythonu se dříve nebo později dostanete do situace, kdy potřebujete nějaký adresář smazat. Jenže mazání adresářů není tak jednoduché, jak by se mohlo zdát. Python totiž rozlišuje mezi prázdnými a plnými adresáři, a pro každý případ nabízí jiný přístup. Pojďme se na to podívat podrobněji.

Nejjednodušší případ nastane tehdy, když chcete smazat prázdný adresář. K tomu slouží funkce os.rmdir() z modulu os, který je součástí standardní knihovny Pythonu. Tato funkce přijímá jako argument cestu k adresáři, který chcete odstranit. Pokud je adresář skutečně prázdný, proběhne mazání bez problémů. Pokud ale adresář obsahuje jakékoliv soubory nebo jiné podadresáře, funkce vyhodí výjimku OSError a mazání se nezdaří. To je důležité si zapamatovat, protože právě tato vlastnost způsobuje mnoho chyb u začínajících programátorů.

Pokud tedy pracujete s adresářem, o kterém víte, že je prázdný, stačí napsat například os.rmdir(cesta/k/adresari) a adresář bude odstraněn. Vždy je ale dobré obalit tento příkaz do bloku try-except, abyste předešli neočekávaným chybám. Může se totiž stát, že adresář v době volání funkce již neexistuje, nebo naopak obsahuje soubory, o kterých jste nevěděli.

Složitější situace nastane, když potřebujete smazat adresář, který obsahuje soubory nebo další podadresáře. V takovém případě vám funkce os.rmdir() nepomůže. Musíte sáhnout po výkonnějším nástroji, a tím je funkce shutil.rmtree() z modulu shutil. Tato funkce rekurzivně projde celou strukturu adresáře, smaže všechny soubory i podadresáře a nakonec odstraní i samotný kořenový adresář. Je to velmi mocný nástroj, a právě proto je třeba s ním zacházet opatrně. Jednou smazaná data se standardně nepřesouvají do koše a jejich obnovení je velmi obtížné nebo zcela nemožné.

Funkce shutil.rmtree() přijímá jako první argument cestu k adresáři. Druhý volitelný argument ignore_errors umožňuje ignorovat chyby, které mohou při mazání nastat. Pokud ho nastavíte na hodnotu True, funkce jednoduše přeskočí soubory nebo adresáře, které nelze smazat, a pokračuje dál. To se hodí v situacích, kdy máte adresář s různými přístupovými právy a nechcete, aby celý proces selhal kvůli jednomu problematickému souboru.

Dalším parametrem je onerror, který přijímá funkci zpětného volání. Tato funkce se zavolá vždy, když dojde k chybě při mazání. Dostane tři argumenty: funkci, která chybu způsobila, cestu k souboru nebo adresáři a informaci o výjimce. Pomocí tohoto mechanismu můžete implementovat vlastní logiku pro ošetření chyb, například změnit přístupová práva k souboru a pokusit se ho smazat znovu.

V novějších verzích Pythonu, konkrétně od verze 3.12, byl parametr onerror nahrazen parametrem onexc, který funguje podobně, ale lépe odpovídá moderním konvencím Pythonu. Pokud tedy píšete kód, který má běžet na novějších verzích, je vhodné používat právě tento parametr.

Existuje ještě jeden zajímavý přístup k mazání adresářů, a to pomocí modulu pathlib, který byl do Pythonu přidán ve verzi 3.4. Třída Path z tohoto modulu nabízí objektově orientovaný přístup k práci se souborovým systémem. Pro mazání prázdného adresáře můžete použít metodu Path.rmdir(), která funguje stejně jako os.rmdir(). Pro mazání plných adresářů pak v kombinaci se shutil.rmtree() nebo od Pythonu 3.12 přímo pomocí metody Path.rmtree(), pokud je dostupná v dané verzi.

Při mazání adresářů je vždy důležité myslet na bezpečnost a správnost cesty. Nikdy byste neměli mazat adresáře na základě uživatelského vstupu bez důkladné validace. Chyba v cestě může vést ke smazání důležitých systémových souborů. Dobrým zvykem je před samotným mazáním zkontrolovat, zda daná cesta skutečně existuje a zda je to skutečně adresář, nikoliv soubor. K tomu slouží funkce os.path.exists() a os.path.isdir(), případně metody třídy Path jako Path.exists() a Path.is_dir().

Celkově lze říci, že Python nabízí dostatečné nástroje pro mazání jak prázdných, tak plných adresářů. Klíčem k úspěchu je vybrat správný nástroj pro danou situaci a vždy myslet na ošetření chyb a bezpečnost celého procesu.

Přejmenování a přesun složek v Pythonu

Práce se souborovým systémem je v Pythonu velmi intuitivní a přímočará, přičemž přejmenování a přesun složek patří mezi operace, které vývojáři provádějí poměrně často. Python nabízí hned několik způsobů, jak tyto úkoly zvládnout, a každý z nich má své specifické výhody v závislosti na konkrétní situaci.

Nejzákladnější přístup k přejmenování složky v Pythonu představuje modul os, který je součástí standardní knihovny. Funkce os.rename() umožňuje přejmenovat jak soubory, tak adresáře. Stačí jí předat dva argumenty – původní cestu a novou cestu. Pokud například chcete přejmenovat složku „stare_data na „nova_data, zavoláte jednoduše `os.rename(stare_data, nova_data)`. Důležité je si uvědomit, že tato funkce funguje i jako přesun, pokud zadáte jinou cílovou cestu. Pokud tedy napíšete `os.rename(stare_data, archiv/nova_data)`, složka se nejen přejmenuje, ale zároveň přesune do adresáře „archiv.

Nicméně `os.rename()` má jedno omezení, na které vývojáři narážejí poměrně brzy. Pokud cílový adresář neexistuje, funkce vyhodí výjimku, a proto je nutné předem ověřit, zda cílová cesta existuje, nebo ji vytvořit pomocí `os.makedirs()`. Toto chování se liší od chování na různých operačních systémech, takže přenositelnost kódu může být v některých případech problematická.

Modernějším a elegantnějším přístupem je využití modulu shutil, konkrétně funkce shutil.move(). Tato funkce je výrazně flexibilnější než `os.rename()`, protože dokáže přesunout složku i na jiný diskový oddíl nebo souborový systém. Při použití `os.rename()` přes různé souborové systémy totiž dochází k chybě, zatímco `shutil.move()` tento problém elegantně obchází tím, že v případě potřeby složku nejprve zkopíruje a poté odstraní originál. To je zásadní rozdíl, který může ušetřit hodiny ladění.

Od Pythonu 3.4 existuje ještě třetí možnost, a to modul pathlib, který přináší objektově orientovaný přístup k práci se souborovým systémem. Objekt třídy Path disponuje metodou rename(), která funguje podobně jako `os.rename()`, ale syntaxe je čitelnější a přirozenější. Kód vypadá například takto: `Path(stare_data).rename(nova_data)`. Metoda `rename()` vrací nový objekt `Path` odkazující na přejmenovanou složku, což umožňuje řetězení operací a obecně čistší kód.

Pro přesun složky pomocí `pathlib` lze také využít kombinaci s modulem `shutil`, protože samotný `pathlib` neposkytuje přímou metodu pro přesun přes různé souborové systémy. Kombinace `shutil.move()` a objektů `Path` je v praxi velmi oblíbená, protože spojuje čitelnost pathlib s robustností shutil.

Při přejmenování a přesunu složek je vždy vhodné ošetřit možné výjimky. Nejčastěji se setkáme s výjimkou FileNotFoundError, která nastane, pokud zdrojová složka neexistuje, a s výjimkou PermissionError, která signalizuje nedostatečná oprávnění k provedení operace. Správné ošetření těchto výjimek pomocí bloku `try/except` je základem robustního kódu, který se nezhroutí při nečekaných situacích.

Dalším aspektem, na který je třeba myslet, je atomičnost operace přejmenování. Na unixových systémech je `os.rename()` atomická operace, což znamená, že buď proběhne celá, nebo vůbec. To je důležité zejména v prostředích, kde více procesů přistupuje ke stejným souborům současně. Na Windows toto garantováno není, a proto je v kritických aplikacích vhodné použít zamykací mechanismy.

Při práci s relativními a absolutními cestami je dobré vždy vědět, z jakého adresáře skript spouštíte. Použití `os.path.abspath()` nebo `Path.resolve()` pomáhá předejít záměnám, které mohou vést k přejmenování špatné složky. Práce s absolutními cestami je obecně bezpečnější a doporučovaná pro produkční kód.

V neposlední řadě stojí za zmínku, že Python umožňuje přejmenovávat složky i rekurzivně, tedy včetně všech podsložek a souborů uvnitř. K tomu slouží zejména kombinace `os.walk()` s funkcemi pro přejmenování, nebo přímo `shutil.move()`, která celou strukturu přesune jako celek bez nutnosti procházet každý soubor zvlášť. To výrazně zjednodušuje kód a snižuje riziko chyb při manipulaci s komplexními adresářovými strukturami.

Modul pathlib jako moderní alternativa

Od verze 3.4 přinesl Python do světa práce se souborovým systémem zásadní změnu v podobě modulu pathlib, který nabízí objektově orientovaný přístup k práci s cestami, adresáři a soubory. Tento modul představuje moderní alternativu ke klasickému přístupu pomocí modulu `os` a jeho podmodulu `os.path`, přičemž výrazně zjednodušuje kód a zvyšuje jeho čitelnost. Práce s adresáři a složkami se díky pathlib stává intuitivnější a přirozenější, zejména pro vývojáře, kteří preferují objektový styl programování.

Základním stavebním kamenem celého modulu je třída Path, respektive její platformně specifické varianty `PosixPath` pro unixové systémy a `WindowsPath` pro operační systém Windows. Při importu stačí napsat `from pathlib import Path` a okamžitě máte k dispozici mocný nástroj, který zvládne prakticky vše, co kdy budete od práce s cestami potřebovat. Vytvoření objektu reprezentujícího adresář je pak otázkou jediného řádku: `adresar = Path('/home/uzivatel/dokumenty')`.

Jednou z nejpříjemnějších vlastností pathlib je možnost skládání cest pomocí operátoru lomítka. Zatímco v klasickém přístupu bylo nutné používat funkci `os.path.join()`, která je sice funkční, ale poněkud neohrabaná, v pathlib jednoduše napíšete `nova_cesta = adresar / 'projekty' / 'python'`. Tento zápis je nejen kratší, ale také výrazně čitelnější a přirozenější pro každého, kdo se podívá na kód poprvé.

Pro práci s adresáři nabízí pathlib celou řadu užitečných metod. Metoda `mkdir()` slouží k vytvoření nového adresáře, přičemž parametr `parents=True` zajistí vytvoření celé stromové struktury složek najednou, a parametr `exist_ok=True` zabrání vyvolání výjimky v případě, že adresář již existuje. Tato kombinace parametrů je v praxi nesmírně užitečná a šetří vývojářům spoustu starostí s ošetřováním výjimek.

Procházení obsahu adresáře je s pathlib také velmi elegantní záležitost. Metoda `iterdir()` vrátí iterátor přes všechny položky v daném adresáři, přičemž každá položka je opět objektem třídy Path. Pokud potřebujete hledat soubory nebo složky odpovídající určitému vzoru, přichází ke slovu metoda `glob()`, případně `rglob()` pro rekurzivní prohledávání celého stromu adresářů. Například `Path('/home/uzivatel').rglob('*.py')` vyhledá všechny Python soubory v celém domovském adresáři a všech jeho podsložkách.

Zjišťování informací o adresáři je s pathlib přímočaré a přehledné. Vlastnost `exists()` ověří, zda daná cesta skutečně existuje, `is_dir()` potvrdí, zda se jedná o adresář, a `is_file()` naopak zjistí, zda jde o soubor. Tyto metody nahrazují funkce z modulu `os.path` a dělají to způsobem, který je konzistentní s objektovým paradigmatem Pythonu.

Velmi praktická je také vlastnost `parent`, která vrátí nadřazený adresář aktuální cesty, nebo vlastnost `name`, jež poskytne pouze název souboru či složky bez celé cesty. Vlastnost `stem` pak vrátí název souboru bez přípony a `suffix` poskytne samotnou příponu. Tyto vlastnosti výrazně zjednodušují manipulaci s cestami v situacích, kdy potřebujete pracovat jen s určitou částí cesty.

Přejmenování a přesouvání adresářů zajišťuje metoda `rename()`, která přejmenuje nebo přesune adresář na nové místo. Metoda `replace()` funguje podobně, ale na rozdíl od `rename()` přepíše cílový adresář, pokud již existuje. Pro mazání prázdných adresářů slouží metoda `rmdir()`, přičemž pro smazání celého stromu adresářů včetně obsahu je nutné sáhnout po funkci `shutil.rmtree()`.

Nelze opomenout ani metodu `resolve()`, která převede relativní cestu na absolutní a zároveň vyřeší případné symbolické odkazy. Tato metoda je obzvláště užitečná v situacích, kdy pracujete s cestami zadanými uživatelem nebo načtenými z konfiguračního souboru a potřebujete mít jistotu, že pracujete se skutečnou absolutní cestou v souborovém systému.

Celkově lze říci, že modul pathlib představuje přirozený vývoj Pythonu směrem k čistšímu a modernějšímu kódu. Vývojáři, kteří přejdou na pathlib, zpravidla velmi rychle ocení, jak výrazně se zkrátí a zpřehlední jejich kód pro práci s adresáři a soubory. Modul je dnes standardní součástí Pythonu a není důvod jej nevyužívat v každém novém projektu.

Každý python je jako stará skříň plná zapomenutých věcí – nikdy nevíš, co v něm najdeš, ale vždy tam něco důležitého chybí, právě když to nejvíce potřebuješ.

Radovan Blažek

Kontrola existence adresáře před operacemi

Při práci se souborovým systémem v Pythonu narazíte velmi brzy na situaci, kdy potřebujete ověřit, zda určitý adresář skutečně existuje, než s ním začnete jakkoliv pracovat. Tato kontrola je naprosto zásadní, protože bez ní riskujete, že váš program skončí chybou, která mohla být snadno předvídána a ošetřena. Python nabízí několik způsobů, jak tuto kontrolu provést, a každý z nich má své místo v závislosti na konkrétním kontextu použití.

Nejzákladnějším přístupem je využití modulu os, konkrétně funkce os.path.exists(). Tato funkce přijímá cestu jako argument a vrací hodnotu True nebo False podle toho, zda daná cesta v souborovém systému existuje. Je důležité si uvědomit, že tato funkce vrací True jak pro soubory, tak pro adresáře, takže pokud chcete ověřit specificky existenci adresáře, měli byste použít funkci os.path.isdir(). Rozdíl mezi těmito dvěma funkcemi je v praxi velmi podstatný. Představte si situaci, kdy máte soubor pojmenovaný stejně jako adresář, který očekáváte — os.path.exists() by vrátila True, ale os.path.isdir() by správně vrátila False, čímž vás upozorní na nesrovnalost.

Moderní Python od verze 3.4 nabízí také modul pathlib, který přináší objektově orientovaný přístup k práci se souborovým systémem. Pomocí třídy Path lze kontrolu existence adresáře provést velmi čitelným způsobem. Metoda Path.exists() funguje podobně jako os.path.exists(), ale díky objektovému přístupu je kód přehlednější a snáze udržovatelný. Stejně tak existuje metoda Path.is_dir(), která přímo ověří, zda se jedná o adresář, nikoliv o soubor nebo symbolický odkaz vedoucí jinam.

Kontrola existence adresáře před operacemi jako je vytváření souborů, kopírování obsahu nebo mazání je jednou z nejlepších praktik, které byste měli dodržovat. Pokud se například pokusíte otevřít soubor pro zápis v adresáři, který neexistuje, Python vyhodí výjimku FileNotFoundError. Tato chyba sice může být zachycena pomocí bloku try-except, ale elegantněji je situaci předejít právě předchozí kontrolou existence adresáře. Oba přístupy mají své opodstatnění — někdy je skutečně vhodnější nechat výjimku nastat a zachytit ji, jindy je čistší nejprve ověřit podmínky a teprve pak jednat.

Zajímavou situací je takzvaná race condition, tedy stav, kdy mezi okamžikem kontroly existence a samotnou operací může jiný proces adresář smazat nebo vytvořit. V takovém případě ani předchozí kontrola nepomůže a je nutné kombinovat oba přístupy — kontrolu i zachytávání výjimek. Tato problematika je zvláště relevantní v prostředích, kde běží více procesů nebo vláken současně.

Při vytváření nového adresáře pomocí funkce os.makedirs() nebo metody Path.mkdir() lze použít parametr exist_ok=True, který zajistí, že funkce nevyhodí výjimku, pokud adresář již existuje. Toto nastavení je velmi praktické právě proto, že interně řeší problém race condition a zároveň eliminuje potřebu explicitní předchozí kontroly v mnoha běžných scénářích. Přesto existují situace, kdy chcete přesně vědět, zda adresář existoval před vaší operací, a v takovém případě je explicitní kontrola stále nezbytná.

Správná kontrola existence adresáře tedy není jen o jednom řádku kódu — je to o pochopení kontextu, ve kterém váš program běží, a o volbě správného nástroje pro danou situaci. Python vám dává dostatek nástrojů k tomu, abyste mohli psát robustní a spolehlivý kód, který se elegantně vypořádá s různými stavy souborového systému bez zbytečných pádů nebo neočekávaného chování.

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

Práce se souborovým systémem je v Pythonu velmi častou záležitostí a jedním z nejpoužívanějších nástrojů pro procházení adresářové struktury je funkce os.walk() ze standardní knihovny `os`. Tato funkce umožňuje rekurzivně procházet celou stromovou strukturu adresářů a podadresářů, přičemž pro každý navštívený adresář vrací trojici hodnot, se kterými lze dále pracovat.

Základní princip fungování `os.walk()` spočívá v tom, že funkce přijímá jako první argument cestu k výchozímu adresáři, od kterého má procházení začít. Poté postupně prochází každý podadresář a pro každý z nich vrací trojici ve formátu (dirpath, dirnames, filenames). Hodnota `dirpath` představuje aktuální cestu k procházenému adresáři jako řetězec, `dirnames` je seznam názvů podadresářů nacházejících se v daném adresáři a `filenames` obsahuje seznam názvů souborů, které se v daném adresáři přímo nacházejí.

Jednoduchý příklad použití vypadá takto:

```python

import os

for dirpath, dirnames, filenames in os.walk('/cesta/k/adresari'):

for soubor in filenames:

print(os.path.join(dirpath, soubor))

```

Tento kód projde celou adresářovou strukturu a vypíše absolutní cestu ke každému souboru. Kombinace `os.path.join()` a proměnné `dirpath` zajistí, že výsledná cesta bude vždy správně sestavena bez ohledu na operační systém.

Důležitou vlastností `os.walk()` je parametr topdown, který ve výchozím nastavení nabývá hodnoty `True`. Pokud je nastaven na `True`, funkce prochází adresářovou strukturu shora dolů, tedy nejprve zpracuje nadřazený adresář a teprve poté jeho podadresáře. Při nastavení na `False` se pořadí obrátí a procházení probíhá zdola nahoru. Toto nastavení má praktický dopad například při mazání souborů a adresářů, kdy je nutné nejprve odstranit obsah podadresářů a teprve poté samotné adresáře.

Dalším zajímavým parametrem je onerror, který umožňuje předat funkci, jež bude zavolána v případě výskytu chyby při procházení. Bez tohoto parametru jsou chyby standardně ignorovány, což může vést k neúplnému průchodu strukturou. Pokud chceme mít přehled o všech problémech, je vhodné tento parametr využít.

Velmi užitečnou vlastností, která bývá méně známá, je možnost ovlivnit průchod adresáři přímo za běhu. Pokud je parametr `topdown` nastaven na `True`, lze modifikovat seznam `dirnames` přímo v průběhu iterace. Pokud například chceme přeskočit určité adresáře, stačí je ze seznamu `dirnames` odstranit a `os.walk()` do nich nevstoupí. Toto chování je velmi praktické například při ignorování skrytých adresářů nebo adresářů jako `.git`, `node_modules` a podobných složek, které nás při procházení nezajímají.

```python

import os

for dirpath, dirnames, filenames in os.walk('/cesta/k/projektu', topdown=True):

dirnames[:] = [d for d in dirnames if not d.startswith('.')]

for soubor in filenames:

print(os.path.join(dirpath, soubor))

```

Výše uvedený kód elegantně přeskočí všechny skryté adresáře začínající tečkou. Modifikace seznamu pomocí `dirnames[:]` je klíčová, protože zajišťuje změnu přímo na místě a ne vytvoření nového objektu, na který by `os.walk()` již nereagoval.

V praxi se `os.walk()` velmi často používá například při hledání souborů s určitou příponou v celém projektu, při výpočtu celkové velikosti adresáře nebo při vytváření zálohovacích skriptů. Kombinací s modulem `fnmatch` nebo regulárními výrazy lze vytvořit velmi mocné nástroje pro práci se souborovým systémem.

Je také dobré zmínit, že v moderním Pythonu existuje alternativa v podobě modulu pathlib, konkrétně metody `Path.rglob()`, která může být v některých situacích čitelnější a elegantnější. Přesto `os.walk()` zůstává velmi rozšířeným a spolehlivým nástrojem, který je součástí Pythonu již od velmi raných verzí a jehož chování je dobře zdokumentováno a predikovatelné. Znalost tohoto nástroje je proto pro každého Python programátora, který pracuje se souborovým systémem, naprosto nezbytná.

Relativní a absolutní cesty v praxi

Při práci se soubory a adresáři v Pythonu se nevyhnutelně setkáte s pojmy relativní a absolutní cesta. Je to jedno z těch témat, které se zdá na první pohled triviální, ale v praxi způsobuje nespočet problémů, zejména tehdy, když váš skript spouštíte z různých míst nebo když jej sdílíte s ostatními vývojáři, kteří mají jinak strukturovaný disk.

Absolutní cesta je taková cesta, která začíná od kořenového adresáře systému. Na systémech Windows to bývá typicky písmeno disku, například `C:\Users\Jan\projekty\muj_skript.py`, zatímco na Linuxu nebo macOS cesta začíná lomítkem, třeba `/home/jan/projekty/muj_skript.py`. Absolutní cesta je jednoznačná a nezávisí na tom, odkud váš program spouštíte. Python ji interpretuje vždy stejně, bez ohledu na aktuální pracovní adresář.

Relativní cesta naproti tomu vychází z aktuálního pracovního adresáře, tedy z toho místa, kde se Python v danou chvíli „nachází. Pokud spustíte skript z adresáře `/home/jan/projekty`, pak relativní cesta `data/soubor.txt` bude odpovídat absolutní cestě `/home/jan/projekty/data/soubor.txt`. Problém nastává ve chvíli, kdy skript spustíte z jiného adresáře — Python pak hledá soubor na jiném místě a výsledkem je chyba `FileNotFoundError`, která dokáže potrápit i zkušené programátory.

V Pythonu se pro práci s cestami nejčastěji používá modul `os` a modernější modul `pathlib`, který byl představen v Pythonu 3.4 a dnes je považován za preferovaný způsob manipulace s cestami. Pomocí `pathlib.Path.cwd()` zjistíte aktuální pracovní adresář, což je ekvivalent příkazu `os.getcwd()`. Pokud chcete zjistit absolutní cestu k souboru, který se nachází ve stejném adresáři jako váš skript, velmi užitečnou proměnnou je `__file__`. Z ní lze pomocí `Path(__file__).resolve().parent` získat adresář, ve kterém skript fyzicky leží, a to bez ohledu na to, odkud byl spuštěn.

Toto rozlišení je naprosto zásadní například při práci s konfiguračními soubory nebo šablonami. Představte si situaci, kdy váš projekt má strukturu se složkou `config` a v ní soubor `nastaveni.json`. Pokud v kódu napíšete cestu jako `config/nastaveni.json`, bude vše fungovat pouze tehdy, když skript spustíte přímo z kořenového adresáře projektu. Jakmile jej spustíte z jiného místa, Python složku nenajde. Správným řešením je sestavit cestu dynamicky, například takto: `Path(__file__).resolve().parent / config / nastaveni.json`. Operátor lomítka v `pathlib` slouží ke spojování částí cesty a výsledkem je vždy správná cesta bez ohledu na operační systém nebo aktuální pracovní adresář.

Modul `os.path` nabízí funkci `os.path.abspath()`, která převede relativní cestu na absolutní na základě aktuálního pracovního adresáře. Je to starší přístup, ale stále funkční a v mnoha projektech běžně používaný. Funkce `os.path.join()` pak umožňuje skládat části cesty způsobem, který je kompatibilní s různými operačními systémy, protože automaticky používá správný oddělovač — zpětné lomítko na Windows a lomítko na Unixových systémech.

Při ladění problémů s cestami je velmi praktické vypsat aktuální pracovní adresář přímo v kódu. Stačí přidat `print(os.getcwd())` nebo `print(Path.cwd())` a okamžitě vidíte, odkud Python cestu odvozuje. Tato jednoduchá technika ušetří hodiny zbytečného hledání chyby. Nikdy nepředpokládejte, že pracovní adresář je tam, kde si myslíte, že je — ověřte si to, zejména pokud skript spouštíte přes IDE, příkazovou řádku nebo automatizovaný nástroj jako je cron nebo CI/CD pipeline, kde se výchozí adresář může lišit od toho, co očekáváte.

Správné zacházení s cestami je základem robustního kódu a vyplatí se věnovat mu pozornost hned od začátku projektu, než se problémy začnou hromadit.

Nejčastější chyby při práci se složkami

Práce se složkami v Pythonu je na první pohled jednoduchá záležitost, ale v praxi naráží mnoho programátorů na celou řadu problémů, které mohou způsobit nečekané chování programu nebo dokonce jeho pád. Jednou z nejrozšířenějších chyb je používání pevně zadaných cest, které fungují pouze na konkrétním operačním systému. Pokud napíšete cestu ve stylu `C:\Users\Jan\Documents`, váš skript selže na Linuxu nebo macOS, protože tyto systémy používají lomítko místo zpětného lomítka. Správným řešením je vždy používat modul `os.path` nebo modernější `pathlib`, které automaticky zajistí správný formát cesty bez ohledu na platformu.

Další velmi častou chybou je předpoklad, že složka existuje, aniž by to program předem ověřil. Spousta začátečníků prostě zavolá `os.makedirs()` nebo se pokusí otevřít soubor v adresáři, který ještě nebyl vytvořen, a pak se diví, proč program vyhodí výjimku `FileNotFoundError`. Správný přístup je vždy nejprve zkontrolovat existenci složky pomocí `os.path.exists()` nebo `Path.exists()` z modulu `pathlib`, případně použít parametr `exist_ok=True` při volání `os.makedirs()`, který zabrání vyhození výjimky v případě, že složka již existuje.

Velmi podceňovanou oblastí jsou také relativní a absolutní cesty. Mnoho programátorů si neuvědomuje, že relativní cesta je vždy vztažena k aktuálnímu pracovnímu adresáři procesu, nikoliv k umístění samotného skriptu. To může vést k situaci, kdy skript funguje perfektně při spuštění z jednoho místa, ale selže při spuštění z jiného adresáře. Řešením je používat `__file__` v kombinaci s `os.path.dirname()` nebo `Path(__file__).parent`, čímž získáte cestu vztaženou k umístění skriptu bez ohledu na to, odkud byl spuštěn.

Problematická je také práce s oprávněními k adresářům. Pokud se program pokouší vytvořit složku v místě, kde nemá dostatečná oprávnění, dostanete výjimku `PermissionError`. Tato situace nastává zejména při práci se systémovými adresáři nebo při nasazení aplikace na server. Vždy je dobré ošetřit tyto výjimky pomocí bloku `try-except` a poskytnout uživateli srozumitelnou chybovou zprávu místo záplavy technických informací.

Dalším problémem, na který programátoři narážejí, je mazání složek, které nejsou prázdné. Funkce `os.rmdir()` totiž umí smazat pouze prázdný adresář a pokud se pokusíte smazat složku obsahující soubory nebo podsložky, dostanete výjimku `OSError`. Pro rekurzivní mazání celého stromu adresářů je třeba použít `shutil.rmtree()`, ale i zde je nutná opatrnost, protože tato operace je nevratná a smazaná data nelze jednoduše obnovit.

Nezanedbatelnou chybou je také ignorování kódování názvů souborů a složek. Na různých systémech mohou být názvy adresářů obsahující diakritiku nebo speciální znaky interpretovány odlišně, což vede k problémům při přenosu souborů mezi systémy nebo při práci s externími knihovnami. Python 3 sice pracuje s řetězci jako s Unicode ve výchozím nastavení, ale při interakci s operačním systémem mohou stále vznikat problémy, zejména na starších systémech Windows.

Race condition je dalším pokročilým problémem, který se týká práce se složkami. Nastane tehdy, když program nejprve zkontroluje existenci složky a pak ji vytvoří, ale mezi těmito dvěma operacemi jiný proces nebo vlákno složku vytvoří nebo smaže. Výsledkem je neočekávané chování nebo výjimka. Správným řešením je používat atomické operace nebo ošetřovat výjimky, místo aby se program spoléhal na předchozí kontrolu stavu.

Programátoři také často zapomínají na uzavírání souborových deskriptorů po práci se soubory v adresáři. I když to přímo nesouvisí se složkami, nevhodné zacházení s otevřenými soubory může způsobit, že operace se složkami selžou, protože operační systém stále drží zámek na příslušných souborech. Použití kontextového manažeru pomocí klíčového slova `with` je nejlepší způsob, jak zajistit správné uzavření souborů za všech okolností.