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) bis zu einer komplexen Webanwendung bauen.
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.
Mal sehen, wie Python mit dem Betriebssystem interagiert.
Inhaltsverzeichnis
Wie interagiert Python mit dem Betriebssystem?
Niemand kann isoliert von seiner Umwelt leben. Das gilt auch für Python, wo es manchmal grundlegend ist, mit dem Betriebssystem zu interagieren, um Dinge zu erledigen.
Python verfügt über mehrere Module, mit denen wir mit dem Betriebssystem interagieren können. 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 Hauptfunktionalität jedes dieser Importe:
- Os: Tragbare Methode zur Verwendung systemspezifischer (abhängig von Ihrem Betriebssystem) Funktionen. 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 Interpreter-Variablen 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ührung und Verwaltung von Teilprozessen direkt aus Python. Dazu gehört die Arbeit mit den stdin-, stdout- und Rückgabecodes. Sie können mehr darüber erfahren, indem Sie unseren Python-Unterprozessleitfaden lesen.
Es gibt High-Level-Bibliotheken, die je nach Ihren Anforderungen noch spezifischere Funktionen enthalten. Meistens sind Sie jedoch mit den oben genannten Modulen gut beraten.
Hinweis: Die meisten der von diesen Modulen bereitgestellten Funktionen haben je nach Betriebssystem unterschiedliche Ausgaben. Denken Sie daran, dass normalerweise die beste Übereinstimmung ist UNIX und Python.
Jetzt haben Sie einen schnellen Überblick darüber, wie Python mit dem Betriebssystem interagiert. Lassen Sie uns in die Methoden zum Überprüfen der Datei- und Ordnergröße einsteigen. Alle folgenden Lösungen sind in der verfügbar Datei- und Ordnergröße in 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 über einen bestimmten Pfad zurück.
Hinweis: Die Funktion os.path.getsize() erledigt die Aufgabe ebenfalls. Der Vorteil der Verwendung von os.stat().st_size besteht darin, dass es keinen Simlinks folgt.
Bevor wir fortfahren, erstellen wir eine Testdatei mit dem Namen lorem.txt, in die wir etwas dummen Text einfügen werden. Wir können einen besuchen Lorem Ipsum Textgenerator und fügen Sie den Text in die Datei lorem.txt ein.
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 Größenvariable enthält die Größe der Datei lorem.txt
- Die Funktion os.stat() gibt eine Reihe von Informationen zu der Datei zurück
- Das Attribut st_size repräsentiert die Größe der Datei
- Wir drucken die Größenvariable
Versuchen Sie, das Python-Skript auszuführen. Abhängig vom 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 humanisieren, damit wir einen besseren Überblick über 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 Funktion naturalsize() verwenden, 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))
Zuerst gibt der obige Code die Größe der Datei in Bytes aus und druckt dann das Ergebnis in einer lesbaren Größe.
Ausgabe:
20064 20.1 kB
Mit Pathlib
Obwohl pathlib wurde entwickelt, um ausschließlich mit Pfaden zu arbeiten, es enthält einige nützliche Funktionen aus anderen Modulen als Methoden von Pfadobjekten (Instanzen der Pfadklasse).
Erstellen Sie eine Datei method2.py und importieren Sie die Klasse Pfad.
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 stat()-Methode der Path-Klasse zugreifen. Es funktioniert genauso wie die Funktion os.stat(), daher können Sie die Größe der Datei drucken.
print(file_.stat().st_size)
Ausgabe:
20064
Wie Sie sehen können, haben wir das gleiche Ergebnis wie mit der ersten Methode, die wir verwendet haben. Das obige Ergebnis wird auch im Byte-Format ausgegeben, sodass wir es mit dem Humanize-Modul lesbar machen können.
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
Verwenden von Unix-Befehlen mit Subprocess:
Das Unterprozessmodul ermöglicht es uns, Unterprozesse 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 Funktion ausführen aus dem Unterprozessmodul
- 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 statt als 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. 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 drucken.
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 schlussfolgern, 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 Subprozessmodul und mögliche Anwendungen erfahren möchten, sehen Sie sich unseren Leitfaden für Python-Subprozesse an.
Holen Sie sich die Größe eines Ordners rekursiv
Wenn Sie die Größe eines Ordners erhalten möchten, müssen Sie jede Datei durchlaufen, die im Verzeichnis und seinen Unterverzeichnissen vorhanden ist. Wir werden es mit zwei Methoden tun:
- Iteration über einen Pfad mit pathlib
- Verwenden des Befehls du mit Unterprozess
Der folgende Code verwendet einen Pfad zu einem Testverzeichnis in meinem Home-Ordner. Sie müssen den Pfad dieser Datei für das Verzeichnis ersetzen, in dem Sie die Größe erhalten möchten.
Iteration über einen Pfad mit pathlib
Sehen wir uns an, wie Sie die Größe eines Verzeichnisses ermitteln können, indem Sie über die Größen der Dateien iterieren.
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 jeder Teil tut.
- Importieren Sie die Klasse Path und die Funktion naturalsize()
- Definieren Sie die Funktion get_size() mit einem Parameterpfad, 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
- Iterieren Sie über jede Datei des Pfads
- Holen Sie sich die Größe jeder Datei 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 meiner Maschine verfügbar ist. Vergessen Sie nicht, den Pfad zu einem Ordner zu ändern, der auf Ihrem Computer vorhanden ist.
In meinem Fall bekomme ich folgende Ausgabe:
403.4 MB
Verwenden des Befehls du mit Unterprozess
Dieser Ansatz hat einige Vorteile:
- Das Ergebnis ist etwas genauer
- Es ist 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 dieses Mal erhalten wir die Größe eines Verzeichnisses anstelle einer Datei.
Ausgabe:
481M
Wie Sie sehen können, liefern diese beiden Möglichkeiten, die Größe eines Ordners zu ermitteln, ein etwas anderes Ergebnis. Je größer das Verzeichnis ist, desto größer ist der Unterschied.
Es liegt an Ihnen, zwischen dem Pathlib- oder dem Subprozess-Ansatz zu wählen. Wenn Sie wissen, dass Sie jedes Mal Linux verwenden, wenn Sie einen Unterprozess verwenden, können Sie andernfalls die pathlib-Lösung verwenden.
Um zusammenzufassen
Python ist äußerst praktisch bei der Interaktion mit dem Betriebssystem. 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 zur Durchführung von Betriebssystemoperationen
- 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 Befehl du zu berechnen