Jak zkontrolovat velikost souboru a složky v Pythonu?

V tomto článku si ukážeme, jak v Pythonu zjistit velikost souborů a složek.

Python je mimořádně univerzální programovací jazyk, který umožňuje vytvářet širokou škálu aplikací – od jednoduchých nástrojů pro příkazovou řádku až po sofistikované webové aplikace.

Jednou z jeho často opomíjených schopností je interakce s operačním systémem. Správa systémových operací pomocí Pythonu může výrazně usnadnit automatizaci různých procesů a ušetřit vám mnoho času.

Pojďme se podívat, jak Python spolupracuje s OS.

Jak Python interaguje s operačním systémem?

Žádný program neexistuje izolovaně. V Pythonu je interakce s operačním systémem nezbytná pro efektivní provádění mnoha úkolů.

Python nabízí několik modulů, které umožňují komunikaci s OS. Mezi nejčastěji používané patří moduly os, sys, pathlib a subprocess.

Vzhledem k tomu, že jde o standardní moduly, není třeba je instalovat pomocí PIP. Stačí je jednoduše importovat pomocí následujícího kódu:

import os
import sys
import pathlib
import subprocess

Následující seznam stručně popisuje hlavní funkce každého z těchto modulů:

os: Poskytuje přenosný způsob, jak využívat funkce specifické pro daný operační systém. Většinou je to vhodná volba, pokud nepotřebujete žádné pokročilejší funkce.
sys: Umožňuje přístup k parametrům a funkcím specifickým pro systém. Tento modul nabízí přístup k proměnným a funkcím interpretu Pythonu. Modul `os` pracuje s operačním systémem, zatímco `sys` s interpretem Pythonu.
pathlib: Zajišťuje pokročilou manipulaci s cestami. Umožňuje reprezentovat souborový systém jako objekty s odpovídající sémantikou pro každý operační systém.
subprocess: Slouží pro správu spouštění a interakci s podprocesy přímo z Pythonu. To zahrnuje práci se standardním vstupem, výstupem a návratovými kódy. Více informací se dozvíte v našem specializovaném průvodci pro práci s podprocesy v Pythonu.

Existují i další specializované knihovny, které nabízejí ještě podrobnější funkce. Pro většinu běžných úkolů však bohatě postačí výše uvedené moduly.

Poznámka: Výstup funkcí z těchto modulů se může lišit v závislosti na operačním systému. Je dobré mít na paměti, že Python je obvykle nejvíce kompatibilní se systémy založenými na UNIX.

Nyní, když máte základní přehled o tom, jak Python komunikuje s OS, pojďme se podívat na metody pro zjišťování velikosti souborů a složek. Všechna následující řešení jsou dostupná v repozitáři na GitHubu s názvem "Velikost souboru a složky v Pythonu".

Využití os.stat().st_size

V tomto přístupu použijeme funkci stat() z modulu os. Tato funkce vrací podrobné informace o zadané cestě.

Poznámka: Funkce os.path.getsize() by také fungovala, avšak os.stat().st_size má výhodu v tom, že nesleduje symbolické odkazy.

Než začneme, vytvoříme si testovací soubor s názvem `lorem.txt`, do kterého vložíme nějaký vzorový text. Můžete navštívit web Lorem Ipsum generátor textu a zkopírovat text do souboru lorem.txt.

Ve stejném adresáři vytvořte soubor s názvem `method1.py` a vložte do něj následující kód:

import os
size = os.stat('lorem.txt').st_size
print(size)

Pojďme si tento kód rozebrat:

Na prvním řádku importujeme modul `os`.
Proměnná `size` uchovává velikost souboru `lorem.txt`.
- Funkce `os.stat()` vrací obsáhlé informace o souboru.
- Atribut `st_size` představuje konkrétní velikost souboru.
Nakonec vytiskneme proměnnou `size`.

Spusťte tento Python skript. Výsledná velikost bude záviset na obsahu vašeho souboru lorem.txt.

Výstup:

Výstup je udáván v bajtech. Pro lepší čitelnost převedeme tuto hodnotu na srozumitelnější formát.

Nejprve nainstalujte balíček humanize pomocí následujícího příkazu v terminálu:

pip install humanize

Poté můžete použít funkci `naturalsize()`, která převede velikost v bajtech na formát čitelný pro člověka (např. KB, MB, GB nebo TB).

import os
from humanize import naturalsize

size = os.stat('lorem.txt').st_size

print(size)
print(naturalsize(size))

Výše uvedený kód nejprve vypíše velikost souboru v bajtech a poté převede tento výsledek na čitelnou velikost.

Výstup:

20064
20.1 kB

Využití Pathlib

Ačkoliv modul pathlib je primárně určen pro práci s cestami, obsahuje užitečné funkce z jiných modulů jako metody objektů Path (instance třídy Path).

Vytvořte soubor `method2.py` a importujte třídu Path.

from pathlib import Path

Nyní vytvořte objekt `Path`, kterému předáte cestu k souboru `lorem.txt` jako argument.

file_ = Path('lorem.txt')

Nyní máte přístup k metodě `stat()` třídy `Path`. Tato metoda funguje podobně jako funkce `os.stat()`, takže můžete snadno získat velikost souboru.

print(file_.stat().st_size)

Výstup:

Jak vidíte, obdrželi jsme stejný výsledek jako v první metodě. I tento výsledek je v bajtech, můžeme tedy použít modul `humanize` pro lepší čitelnost.

from pathlib import Path
from humanize import naturalsize

size = Path('lorem.txt').stat().st_size

print(naturalsize(size))

Tento kód generuje následující výstup:

20.1 kB

Využití Unixových příkazů s modulem subprocess

Modul `subprocess` nám umožňuje spouštět a spravovat subprocesy z Pythonu. Můžeme tedy spustit libovolný příkaz a zpracovat jeho výstup přímo v Pythonu.

Poznámka: Tato metoda funguje pouze v operačních systémech UNIX (Linux, Mac).

Otevřete soubor `method3.py` a vložte do něj následující kód:

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

print(process.stdout)

Pojďme se na tento kód podívat blíže:

Importujeme funkci run z modulu `subprocess`.
Proměnná `process` obsahuje výsledek spuštění příkazu `du lorem.txt`.
- `du` je nástroj v Linuxu, který umožňuje získat informace o využití diskového prostoru pro daný soubor.
- `capture_output` nám poskytuje přístup k atributu `stdout` (standardní výstup).
- `text` zajišťuje, že výstup je uložen jako řetězec, nikoli jako bajty.
Tiskneme standardní výstup procesu.

Po spuštění výše uvedeného kódu obdržíte následující výstup:

20      lorem.txt

Jak vidíte, zobrazí se velikost a název souboru. Pokud chcete získat pouze velikost, musíte výstup rozdělit (nezapomeňte, že je to řetězec) a vytisknout první prvek.

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Výstup:

Tento výstup není příliš čitelný. Můžeme se domnívat, že se jedná o KB (na základě předchozích metod), ale bez dalšího kontextu je těžké odhadnout velikost souboru.

Pro vyřešení tohoto problému můžeme použít parametr `-h` (human-readable).

Poznámka: Manuál k tomuto příkazu zobrazíte pomocí příkazu `man du` nebo `du --help`.

from subprocess import run

process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Nyní bude výstup tohoto skriptu mnohem srozumitelnější:

20K

Chcete-li se dozvědět více o modulu `subprocess` a jeho využití, doporučujeme si přečíst našeho průvodce o práci s podprocesy v Pythonu.

Získání velikosti složky rekurzivně

Pokud potřebujete získat velikost celé složky, musíte projít všechny soubory v daném adresáři a jeho podadresářích. Ukážeme si dva způsoby, jak toho docílit:

Iterace přes cesty pomocí modulu `pathlib`.
Využití příkazu `du` s modulem `subprocess`.

V následujícím kódu použijeme testovací adresář v mém domovském adresáři. Budete muset nahradit cestu v kódu vaší konkrétní cestou k adresáři, jehož velikost chcete zjistit.

Iterace přes cestu s pathlib

Podívejme se, jak zjistit velikost adresáře pomocí iterace přes soubory.

from pathlib import Path
from humanize import naturalsize

def get_size(path="."):
    size = 0

    for file_ in Path(path).rglob('*'):

        size += file_.stat().st_size
    
    return naturalsize(size)

test_path = Path.home() / 'Documents/tests/'

print(get_size(test_path))

Tento kód vypadá možná trochu složitě, takže si ho rozebereme po částech:

Importujeme třídu `Path` a funkci `naturalsize()`.
Definujeme funkci `get_size()` s parametrem `path`, který ve výchozím nastavení ukazuje na aktuální adresář.
Proměnná `size` je inicializována na 0 a bude postupně navyšována o velikosti jednotlivých souborů.
Iterujeme přes všechny soubory v zadané cestě pomocí metody `rglob()` pro rekurzivní procházení.
Zjišťujeme velikost každého souboru a přičítáme ji k proměnné `size`.
Funkce vrací proměnnou `size` ve formátu čitelném pro člověka.

Tuto funkci testuji na adresáři, který je dostupný pouze v mém počítači. Nezapomeňte nahradit cestu k adresáři vaší konkrétní cestou.

V mém případě dostanu následující výstup:

403.4 MB

Využití příkazu `du` s modulem `subprocess`

Tento přístup má několik výhod:

Výsledky jsou o něco přesnější.
Je to rychlejší.

from subprocess import run
from pathlib import Path

test_path = Path.home() / 'Documents/tests/'

process = run(['du', '-sh', test_path], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Používáme stejný přístup jako v metodě 3, ale tentokrát získáváme velikost celého adresáře, nikoli jen jednoho souboru.

Výstup:

481M

Jak můžete vidět, tyto dva způsoby získání velikosti složky vrací mírně odlišné výsledky. Čím větší je adresář, tím větší je i rozdíl v naměřených hodnotách.

Je na vás, zda upřednostníte přístup s `pathlib` nebo s `subprocess`. Pokud víte, že budete vždy používat Linux, můžete zvolit `subprocess`, jinak je univerzálnější řešení s `pathlib`.

Shrnutí

Python je mimořádně užitečný při interakci s operačním systémem. S jeho pomocí můžete automatizovat různé procesy a ušetřit spoustu času. Klíčovými moduly pro interakci s OS jsou `os`, `sys`, `pathlib` a `subprocess`.

V tomto článku jste se naučili:

Jak Python interaguje s operačním systémem.
Jak používat vestavěné moduly pro provádění operací s OS.
Jak využít modul `humanize` pro výpis hodnot v čitelné formě.
Tři způsoby výpočtu velikosti souboru.
Jak rekurzivně spočítat velikost adresáře nebo použít příkaz `du`.