Wie überprüfe ich die Datei- und Ordnergröße in Python?

In diesem Artikel erfahren Sie, wie Sie mit Python die Größe von Dateien und Verzeichnissen ermitteln können.

Python ist eine außergewöhnlich vielseitige Programmiersprache, mit der sich sowohl einfache Kommandozeilenprogramme als auch komplexe Webanwendungen realisieren lassen.

Eine oft unterschätzte Fähigkeit von Python ist die Interaktion mit dem Betriebssystem. Durch die Automatisierung von Betriebssystemaufgaben mit Python lässt sich viel Zeit sparen.

Lassen Sie uns untersuchen, wie Python mit dem Betriebssystem zusammenarbeitet.

Die Interaktion von Python mit dem Betriebssystem

Kein Programm existiert im luftleeren Raum. Insbesondere Python ist darauf angewiesen, mit dem Betriebssystem zu interagieren, um Aufgaben zu erledigen.

Python bietet mehrere Module für die Betriebssysteminteraktion. Die gebräuchlichsten sind os, sys, pathlib und subprocess.

Da diese Module Teil der Python-Standardbibliothek sind, müssen sie nicht mit pip installiert werden. Sie lassen sich einfach importieren:

import os
import sys
import pathlib
import subprocess
  

Hier eine Übersicht der Funktionen dieser Module:

• os: Bietet eine portierbare Methode zur Nutzung systemspezifischer Funktionen. In den meisten Fällen ist dies die erste Wahl, es sei denn, man benötigt fortgeschrittenere Optionen.
• sys: Ermöglicht den Zugriff auf systemspezifische Parameter und Funktionen, insbesondere auf Variablen und Funktionen des Python-Interpreters. Während os mit dem Betriebssystem interagiert, kommuniziert sys mit dem Python-Interpreter.
• pathlib: Dient der fortgeschrittenen Pfadmanipulation und ermöglicht die Darstellung von Dateisystemen als Objekte.
• subprocess: Erlaubt das Ausführen und Verwalten von Unterprozessen direkt aus Python, inklusive der Verarbeitung von stdin, stdout und Rückgabecodes.

Es gibt weitere, spezifischere Bibliotheken für bestimmte Anforderungen, jedoch decken die genannten Module die meisten Anwendungsfälle ab.

Hinweis: Die Ausgaben vieler Funktionen dieser Module können sich je nach Betriebssystem unterscheiden. Beachten Sie, dass UNIX und Python oft gut zusammenarbeiten.

Nach dieser Einführung in die Betriebssysteminteraktion mit Python, wenden wir uns nun den Methoden zur Ermittlung von Datei- und Verzeichnisgrößen zu. Die folgenden Beispiele sind im GitHub-Repository für Datei- und Verzeichnisgrößen in Python verfügbar.

Die Verwendung von os.stat().st_size

Diese Methode verwendet die stat()-Funktion aus dem os-Modul, die umfangreiche Informationen über einen Dateipfad liefert.

Hinweis: Die Funktion os.path.getsize() erfüllt ebenfalls diesen Zweck, doch os.stat().st_size hat den Vorteil, dass es Symlinks nicht folgt.

Erstellen wir zuerst eine Testdatei namens lorem.txt und fügen Sie etwas Text ein. Sie können dazu einen Lorem Ipsum Generator nutzen.

Erstellen Sie im selben Verzeichnis eine Datei method1.py mit folgendem Inhalt:

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

Eine kurze Erklärung des Codes:

• Zeile eins importiert das os-Modul.
• Die Variable size speichert die Größe von lorem.txt.
  • os.stat() gibt eine Vielzahl von Dateiinformationen zurück.
  • Das Attribut st_size steht für die Dateigröße.
• Die Größe wird ausgegeben.

Führen Sie das Skript aus. Das Ergebnis hängt von Ihrem Inhalt der Datei lorem.txt ab.

Beispielausgabe:

20064

Die Ausgabe wird in Bytes angezeigt, was nicht sehr übersichtlich ist. Daher humanisieren wir die Ausgabe mit dem Modul humanize.

Installieren Sie humanize mit folgendem Befehl:

pip install humanize

Die Funktion naturalsize() wandelt Bytes in lesbare Einheiten wie KB, MB, GB oder TB um.

import os
from humanize import naturalsize

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

print(size)
print(naturalsize(size))
  

Der Code gibt zuerst die Dateigröße in Bytes aus und dann in einer lesbaren Form.

Beispielausgabe:

20064
20.1 kB
  

Verwendung von pathlib

Obwohl pathlib primär für Pfadmanipulationen gedacht ist, enthält es auch nützliche Funktionen aus anderen Modulen, die als Methoden von Pfadobjekten implementiert sind.

Erstellen Sie eine Datei method2.py und importieren Sie die Klasse Path:

from pathlib import Path

Erstellen Sie ein Path-Objekt mit dem Pfad zu lorem.txt als Argument:

file_ = Path('lorem.txt')

Nun können Sie die stat()-Methode der Path-Klasse verwenden, die sich wie os.stat() verhält, um die Dateigröße auszugeben:

print(file_.stat().st_size)

Beispielausgabe:

20064

Wie zu erwarten war, entspricht das Ergebnis dem der ersten Methode. Die Ausgabe ist wieder in Bytes, die wir mit humanize lesbarer machen können:

from pathlib import Path
from humanize import naturalsize

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

print(naturalsize(size))
  

Diese Ausgabe sieht so aus:

20.1 kB

Verwendung von Unix-Befehlen mit subprocess

Mit dem subprocess-Modul können wir Unterprozesse aufrufen und verwalten. Dies ermöglicht uns, jeden Befehl auszuführen und dessen Ausgabe in Python zu verarbeiten.

Hinweis: Diese Methode funktioniert nur unter Unix-Betriebssystemen (Linux, macOS).

Erstellen Sie die Datei method3.py mit folgendem Code:

from subprocess import run

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

print(process.stdout)
  

Eine detailliertere Betrachtung des Codes:

• Wir importieren die run-Funktion aus dem subprocess-Modul.
• Die Variable process speichert das Ergebnis des Befehls du lorem.txt.
  • du ist ein Linux-Dienstprogramm zur Ermittlung des Speicherplatzes einer Datei.
  • capture_output ermöglicht den Zugriff auf die Standardausgabe.
  • text sorgt dafür, dass die Ausgabe als String und nicht als Bytes gespeichert wird.
• Die Standardausgabe wird ausgegeben.

Die Ausgabe dieses Codes sieht in etwa so aus:

20      lorem.txt

Wie man sieht, wird die Dateigröße und der Dateiname ausgegeben. Um nur die Größe zu erhalten, muss die Ausgabe aufgeteilt und das erste Element ausgegeben werden:

from subprocess import run

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

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

print(size)
  

Ausgabe:

20

Diese Ausgabe ist noch nicht besonders nützlich. Wir können vermuten, dass die Einheit KB ist (wie bei den vorherigen Beispielen), aber es ist schwierig, die Dateigröße exakt abzuschätzen.

Um das zu verbessern, können wir das Flag -h für „human-readable“ verwenden:

Hinweis: Man kann eine Anleitung zum Befehl du mit man du oder du --help erhalten.

from subprocess import run

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

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

print(size)
  

Nun ist die Ausgabe viel übersichtlicher:

20K

Weitere Informationen zum subprocess-Modul finden Sie in unserem Leitfaden für Python-Subprozesse.

Rekursive Ermittlung der Verzeichnisgröße

Um die Größe eines Verzeichnisses zu ermitteln, müssen alle Dateien im Verzeichnis und dessen Unterverzeichnissen durchlaufen werden. Wir tun dies mit zwei Ansätzen:

• Iteration über einen Pfad mit pathlib
• Verwendung des Befehls du mit subprocess

Der folgende Code verwendet ein Testverzeichnis in meinem Home-Ordner. Sie müssen den Pfad dieses Verzeichnisses entsprechend anpassen.

Iteration über einen Pfad mit pathlib

Sehen wir uns an, wie man die Größe eines Verzeichnisses durch Iteration über alle Dateigrößen berechnet:

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))

Dieser Code sieht zunächst etwas kompliziert aus. Lassen Sie uns jeden Teil aufschlüsseln:

• Import der Klasse Path und der Funktion naturalsize().
• Definition der Funktion get_size() mit einem Pfadparameter (Standardwert: aktuelles Verzeichnis).
• Die Variable size dient als Platzhalter für die Summe der Dateigrößen.
• Iteration über alle Dateien im Pfad.
• Ermittlung der Dateigröße und Addition zur size-Variable.
• Die Funktion gibt die Größe in einer lesbaren Form zurück.

Ich teste die Funktion mit einem Verzeichnis auf meiner Maschine. Bitte vergessen Sie nicht, den Pfad an Ihre Gegebenheiten anzupassen.

In meinem Fall ergibt sich folgende Ausgabe:

403.4 MB

Verwendung des Befehls du mit subprocess

Dieser Ansatz hat folgende Vorteile:

• Das Ergebnis ist etwas genauer.
• Es ist deutlich schneller.

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)

Wir verwenden denselben Ansatz wie in Methode 3, aber diesmal ermitteln wir die Größe eines Verzeichnisses anstelle einer Datei.

Ausgabe:

481M

Wie man sieht, liefern die beiden Ansätze zur Ermittlung der Verzeichnisgröße unterschiedliche Ergebnisse. Je größer das Verzeichnis ist, desto größer wird dieser Unterschied.

Die Wahl zwischen pathlib und subprocess ist Ihnen überlassen. Wenn Sie sicher sind, dass Sie stets unter Linux arbeiten, ist subprocess eine gute Wahl. Ansonsten ist die pathlib-Lösung eine gute Alternative.

Zusammenfassung

Python ist sehr nützlich bei der Interaktion mit dem Betriebssystem. Mit Python können Sie Prozesse automatisieren und so viel Zeit sparen. Die Hauptmodule für die Betriebssysteminteraktion sind os, sys, pathlib und subprocess.

In diesem Artikel haben Sie gelernt:

• Wie Python mit dem Betriebssystem interagiert
• Die Verwendung von integrierten Modulen zur Durchführung von Betriebssystemoperationen
• Die Anwendung des humanize-Moduls für eine benutzerfreundlichere Ausgabe
• Die Berechnung der Dateigröße mit drei Methoden
• Die Berechnung der Verzeichnisgröße rekursiv und mit dem Befehl du