• Erledigen Sie die Anwendungssicherheit auf die richtige Weise! Erkennen, schützen, überwachen, beschleunigen und mehr…
  • In diesem Artikel lernst du Überprüfen Sie die Größe einer Datei oder eines Ordners in Python

    Python ist eine der vielseitigsten Programmiersprachen. Damit können Sie von einem kleinen CLI-Programm (Command-Line Interface) zu einem komplexe Webanwendung.

    Eines seiner 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?

    Python interagiert mit dem Betriebssystem mit den Modulen os, sys, path und subprocessprocess

    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 Unterprozess.

    Da es sich um integrierte Module handelt, müssen Sie sie nicht mit installieren install PIP. 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
    • System: 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.
    • Teilprozess: Ausführungs- und Teilprozessverwaltung direkt aus Python. Dazu gehört die Arbeit mit den  stdinstdout, und Rückkehrcodes. Sie können mehr darüber erfahren, indem Sie unsere Leitfaden für Python-Unterprozesse.

    Es gibt High-Level-Bibliotheken, die je nach Ihren Anforderungen 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 normalerweise die beste Übereinstimmung ist match UNIX und Python.

    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

    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: Das os.path.getsize() Funktion erledigt auch die Arbeit. Der Vorteil der Verwendung os.stat().st_größe ist, dass es Simlinks nicht folgt.

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

    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 die os Modul
    • Die Größenvariable enthält die Größe der Datei lorem.txt
      • Das  os.stat() Funktion gibt eine Reihe von Informationen zur Datei zurück
      • Das st_größe Attribut repräsentiert die Größe der Datei
    • Wir drucken die Größe Variable

    Versuchen Sie, Führen Sie das Python-Skript aus. Sie erhalten ein anderes Ergebnis je nach Inhalt Ihres lorem.txt Datei.

    Ausgang:

    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 die vermenschlichen Paket, indem Sie den folgenden Befehl in Ihrer Shell ausführen:

    pip install humanize

    Dann können Sie die verwenden natürliche Größe () Funktion, die einen Wert in Bytes in eine lesbare Dateigröße umwandelt, z. B. 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 einer lesbaren Größe aus.

    Ausgang:

    20064
    20.1 kB

    Pathlib verwenden

    Obwohl Pfadlib wurde ausschließlich für die Arbeit mit Pfaden entwickelt und enthält 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 Pfadklasse.

    from pathlib import Path

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

    file_ = Path('lorem.txt')

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

    print(file_.stat().st_size)

    Ausgang:

    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 die 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 Funktion ausführen aus dem Teilprozessmodul
    • Die Variable process 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 anstelle von Bytes speichern storing
    • 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)

    Ausgang:

    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 die -h (für Menschen lesbare) Flagge.

    Hinweis: Sie können eine Anleitung dieses Befehls erhalten, indem Sie ausführen Mann dubezeichnet, oder du –hilfe.

    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, besuchen Sie unsere Leitfaden für Python-Unterprozesse.

    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 Weg Klasse und die natürliche Größe () Funktion
    • Definiere das get_size() Funktion mit einem Parameter Weg, die standardmäßig auf das aktuelle Verzeichnis verweist.
    • Die Größenvariable ist nur ein Platzhalter, in dem wir die Größe jeder Datei hinzufügen
    • Über jede Datei des Pfads iterieren
      • Das  rglob() Methode 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ößenvariable 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.

    Ausgang:

    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.

    Sie haben die Wahl zwischen den Pfadlib oder im Unterprozess Ansätze. Wenn Sie wissen, dass Sie jedes Mal Linux verwenden werden Unterprozess, andernfalls können Sie die pathlib-Lösung verwenden.

    Um zusammenzufassen

    Python-Ergebnisse sind bei der Interaktion mit dem Betriebssystem äußerst praktisch. Sie können Prozesse automatisieren und viel Zeit sparen mit Python. 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 OS-Operationen zu machen
    • Wie die Verwendung vermenschlichen Modul für menschenlesbares Drucken
    • Um die Größe einer Datei mit 3 Ansätzen zu berechnen
    • Um die Größe eines Verzeichnisses rekursiv oder mit dem . zu berechnen du Befehl