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

In diesem Artikel erfahren Sie, wie Sie die Größe einer Datei oder eines Ordners in Python überprüfen

Python ist eine der vielseitigsten Programmiersprachen. Damit können Sie von einem kleinen CLI-Programm (Befehlszeilenschnittstelle) zu einer komplexen Webanwendung aufbauen.

Eines der am meisten unterschätzten Merkmale ist jedoch die Fähigkeit, mit Betriebssystemen zu interagieren. Die Verwaltung von Betriebssystemvorgängen mit Python kann Ihnen beim Erstellen von Automatisierungsprozessen viel Zeit sparen.

Sehen wir uns an, wie Python mit dem Betriebssystem interagiert.

Wie interagiert Python mit dem Betriebssystem?

Niemand kann isoliert von seiner Umgebung leben. Das gilt auch in Python, wo es manchmal grundlegend ist, mit dem Betriebssystem zu interagieren, um Dinge zu erledigen.

Python hat mehrere Module, die uns mit dem Betriebssystem interagieren lassen. Die am häufigsten verwendeten sind os, sys, pathlib und subprocess.

Da es sich um integrierte Module handelt, müssen Sie sie nicht mit PIP installieren. Sie können alle mit der folgenden Anweisung importieren:

 import os import sys import pathlib import subprocess

Die folgende Liste zeigt die Hauptfunktionen jedes dieser Importe:

• Os: Tragbare Möglichkeit, systemspezifische (je nach Betriebssystem) Funktionalität zu verwenden. Es ist in den meisten Fällen die richtige Wahl, es sei denn, Sie benötigen etwas fortgeschritteneres
• Sys: Systemspezifische Parameter und Funktionen. Dieses Modul bietet Zugriff auf Interpretervariablen und -funktionen. Das os-Modul interagiert mit dem Betriebssystem und sys interagiert mit dem Python-Interpreter
• Pathlib: Erweiterte Pfadnutzung . Ermöglicht die Darstellung von Dateisystemen als Objekte mit der entsprechenden Semantik für jedes Betriebssystem.
• Subprozess : Ausführungs- und Subprozessverwaltung direkt aus Python. Dazu gehört die Arbeit mit den Codes stdin , stdout und Returncodes. Sie können mehr darüber erfahren, indem Sie unseren Python-Unterprozessleitfaden lesen.

Es gibt High-Level-Bibliotheken, die je nach Bedarf noch spezifischere Funktionen enthalten. In den meisten Fällen können Sie jedoch die oben genannten Module verwenden.

Hinweis: Die meisten der von diesen Modulen bereitgestellten Funktionen haben je nach Betriebssystem eine andere Ausgabe. Denken Sie daran, dass UNIX und Python normalerweise am besten zusammenpassen.

Jetzt haben Sie einen schnellen Überblick darüber, wie Python mit dem Betriebssystem interagiert. Lassen Sie uns nun zu den Methoden zum Überprüfen der Datei- und Ordnergröße springen. Alle der folgenden Lösungen sind in der Datei- und Ordnergröße im Python GitHub-Repository verfügbar

Verwenden von os.stat().st_size

In dieser Methode verwenden wir die stat()-Funktion aus dem os-Modul. Es gibt viele Informationen zu einem bestimmten Pfad zurück.

Hinweis: Die Funktion os.path.getsize() erledigt die Aufgabe ebenfalls. Der Vorteil der Verwendung von os.stat(). st_size ist, dass es Simlinks nicht folgt.

Bevor wir fortfahren, erstellen wir eine Testdatei namens lorem.txt , in die wir einen dummen Text einfügen werden. Wir können einen Lorem Ipsum Textgenerator besuchen und den Text in die Datei lorem.txt einfügen .

Erstellen Sie im selben Verzeichnis eine Datei mit dem Namen method1.py und fügen Sie den folgenden Code ein:

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

Lassen Sie uns aufschlüsseln, was wir mit diesem Code tun:

• In der ersten Zeile importieren wir das os- Modul
• Die Variable size enthält die Größe der Datei lorem.txt
  • Die Funktion os.stat() gibt eine Reihe von Informationen zur Datei zurück
  • Das Attribut st_size repräsentiert die Größe der Datei
• Wir drucken die Größe variabel

Versuchen Sie, das Python-Skript auszuführen. Je nach Inhalt Ihrer lorem.txt- Datei erhalten Sie ein anderes Ergebnis.

Ausgabe:

 20064

Die Ausgabe wird in Bytes dargestellt. Dies ist überhaupt nicht lesbar, also lassen Sie es uns vermenschlichen, damit wir eine bessere Perspektive auf die Größe der Datei haben.

Installieren Sie zuerst das humanize-Paket, indem Sie den folgenden Befehl in Ihrer Shell ausführen:

 pip install humanize

Dann können Sie die Funktion naturalsize() verwenden, die einen Wert in Bytes in eine lesbare Dateigröße umwandelt, beispielsweise KB, MB, GB oder TB.

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

Der obige Code gibt zunächst die Größe der Datei in Bytes aus und gibt dann das Ergebnis in lesbarer Größe aus.

Ausgabe:

 20064 20.1 kB

Pathlib verwenden

Obwohl pathlib ausschließlich für die Arbeit mit Pfaden entwickelt wurde, enthält es einige nützliche Funktionen aus anderen Modulen als Methoden von Path-Objekten (Instanzen der Path-Klasse).

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

 from pathlib import Path

Erstellen Sie dann ein Path-Objekt, das den Pfad zur Datei lorem.txt als Argument übergibt .

 file_ = Path('lorem.txt')

Jetzt können Sie auf die Methode stat() der Path-Klasse zugreifen. Es funktioniert genauso wie die Funktion os.stat() , daher können Sie die Größe der Datei ausgeben .

 print(file_.stat().st_size)

Ausgabe:

 20064

Wie Sie sehen, haben wir das gleiche Ergebnis wie bei der ersten von uns verwendeten Methode erhalten. Das obige Ergebnis wird auch im Byte-Format gedruckt, sodass wir das Humanize-Modul verwenden können, um es lesbar zu machen.

 from pathlib import Path from humanize import naturalsize size = Path('lorem.txt').stat().st_size print(naturalsize(size))

Dieser Code erzeugt die folgende Ausgabe:

 20.1 kB

Unix-Befehle mit Subprocess verwenden:

Das Subprocess-Modul ermöglicht es uns, Subprozesse von Python aus aufzurufen und zu verwalten. Daher können wir jeden Befehl ausführen und seine Ausgabe direkt in Python behandeln.

Hinweis: Diese Methode funktioniert nur, wenn Sie ein Unix-Betriebssystem (Linux, Mac) ausführen.

Öffnen Sie eine Datei method3.py und fügen Sie den folgenden Code ein:

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)

Tauchen Sie ein in dieses Stück Code:

• Wir importieren die Run-Funktion aus dem Subprocess-Modul
• Der variable Prozess enthält das Ergebnis der Ausführung des Befehls du lorem.txt
  • du ist ein Linux-Dienstprogramm, mit dem wir den Speicherplatz einer Datei abrufen können
  • capture_output gibt uns Zugriff auf das herausragende Attribut (Standardausgabe)
  • text bedeutet, dass wir die Ausgabe als String statt in Bytes speichern
• Wir drucken die Standardausgabe des Prozesses

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe:

 20 lorem.txt

Wie Sie sehen können, gibt es uns die Größe und den Namen der Datei an. Wenn Sie nur die Größe der Datei erhalten möchten, müssen Sie die Ausgabe aufteilen (denken Sie daran, dass es sich um eine Zeichenfolge handelt) und das erste Element ausgeben.

 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 überhaupt nicht lesbar. Wir können daraus schließen, dass die verwendete Maßeinheit KB ist (aufgrund der vorherigen Methoden), aber niemand sonst konnte die Größe der Datei erraten.

Um dieses Problem zu lösen, können wir das Flag -h (für Menschen lesbar) verwenden.

Hinweis: Sie können eine Anleitung zu diesem Befehl erhalten, indem Sie man du oder du –help ausführen .

 from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Jetzt wird die Ausgabe dieses Skripts viel besser lesbar sein:

 20K

Wenn Sie mehr über das Teilprozessmodul und mögliche Anwendungen erfahren möchten, lesen Sie unseren Python-Teilprozessleitfaden.

Abrufen der Größe eines Ordners rekursiv

Wenn Sie die Größe eines Ordners ermitteln möchten, müssen Sie jede Datei im Verzeichnis und seinen Unterverzeichnissen durchlaufen. Wir machen es mit zwei Methoden:

• Iterieren über einen Pfad mit pathlib
• Verwenden des du-Befehls mit Unterprozess

Der folgende Code verwendet einen Pfad zu einem Testverzeichnis in meinem Home-Ordner. Sie müssen den Pfad dieser Datei durch das Verzeichnis ersetzen, dessen Größe Sie erhalten möchten.

Iterieren über einen Pfad mit pathlib

Sehen wir uns an, wie Sie die Größe eines Verzeichnisses ermitteln können, indem Sie die Größe der Dateien durchlaufen.

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

Dieses Stück Code scheint ein wenig beängstigend zu sein, lassen Sie uns aufschlüsseln, was die einzelnen Teile tun.

• Importieren Sie die Path- Klasse und die naturalsize()- Funktion
• Definieren Sie die Funktion get_size() mit einem Parameter path , der standardmäßig auf das aktuelle Verzeichnis zeigt.
• Die Größenvariable ist nur ein Platzhalter, in dem wir die Größe jeder Datei hinzufügen
• Über jede Datei des Pfads iterieren
  • Die Methode rglob() gibt rekursiv die Dateien zurück, die dem Muster entsprechen
  • rglob('*') , bedeutet, dass wir alle Dateien im Verzeichnis erhalten
• Rufen Sie die Größe jeder Datei ab und fügen Sie sie der Größenvariablen hinzu
• Gibt die Größenvariable in einer für Menschen lesbaren Weise zurück

Natürlich teste ich die Funktion mit einem Verzeichnis, das nur auf meinem Computer verfügbar ist. Vergessen Sie nicht, den Pfad zu einem Ordner zu ändern, der auf Ihrem Computer vorhanden ist.

In meinem Fall erhalte ich folgende Ausgabe:

 403.4 MB

Verwenden des du-Befehls mit Unterprozess

Dieser Ansatz hat einige Vorteile:

• Das Ergebnis ist etwas genauer
• Es geht viel 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 den gleichen Ansatz wie Methode 3, aber diesmal erhalten wir die Größe eines Verzeichnisses anstelle einer Datei.

Ausgabe:

 481M

Wie Sie sehen können, geben diese beiden Möglichkeiten zum Abrufen der Größe eines Ordners ein etwas anderes Ergebnis zurück. Je größer das Verzeichnis ist, desto mehr Unterschied erhalten Sie.

Es liegt an Ihnen, zwischen dem pathlib- oder dem Subprozess- Ansatz zu wählen. Wenn Sie wissen , werden Sie Linux jedes Mal Gebrauch subprocess verwenden, sonst können Sie die pathlib Lösung verwenden.

Um zusammenzufassen

Python-Ergebnisse sind bei der Interaktion mit dem Betriebssystem äußerst praktisch. Mit Python können Sie Prozesse automatisieren und viel Zeit sparen. Die Hauptmodule für die Interaktion mit dem Betriebssystem sind os, sys, path und subprocess.

In diesem Tutorial haben Sie gelernt:

• Wie Python mit dem Betriebssystem interagiert
• Die Verwendung von integrierten Modulen, um Betriebssystemvorgänge durchzuführen
• So verwenden Sie das Humanize- Modul, um menschenlesbar zu drucken
• Um die Größe einer Datei mit 3 Ansätzen zu berechnen
• Um die Größe eines Verzeichnisses rekursiv oder mit dem du- Befehl zu berechnen