Wie prüft man die Größe von Dateien und Ordnern in Python?

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

Python ist eine der vielseitigsten Programmiersprachen. Mit ihr können Sie von einem kleinen CLI-Programm (Command-line interface) bis hin zu einer komplexen Webanwendung alles erstellen

Eine der am meisten unterschätzten Funktionen ist jedoch die Fähigkeit, mit Betriebssystemen zu interagieren. Die Verwaltung von Betriebssystemen mit Python kann Ihnen bei der Erstellung von Automatisierungsprozessen eine Menge Zeit ersparen

Lassen Sie uns sehen, wie Python mit dem Betriebssystem interagiert

Wie interagiert Python mit dem Betriebssystem?

Niemand kann isoliert von seiner Umgebung leben. Das gilt auch für Python, denn manchmal ist es unerlässlich, 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 eingebaute Module handelt, müssen Sie sie nicht mit PIP installieren. Sie können sie alle mit der folgenden Anweisung importieren

import os
import sys
import pathlib
import subprocess

In der folgenden Liste finden Sie die wichtigsten Funktionen jedes dieser Importe

• Os: Portabler Weg, um systemspezifische Funktionen zu nutzen (abhängig von Ihrem Betriebssystem). Dies ist in den meisten Fällen die richtige Wahl, es sei denn, Sie benötigen etwas Fortgeschritteneres
• Sys: Systemspezifische Parameter und Funktionen. Dieses Modul ermöglicht den Zugriff auf Interpreter-Variablen und -Funktionen. Das Modul os interagiert mit dem Betriebssystem und sys interagiert mit dem Python-Interpreter
• Pathlib: Erweiterte Pfadverwendung. Ermöglicht es Ihnen, Dateisysteme als Objekte darzustellen, mit der entsprechenden Semantik für jedes Betriebssystem.
• Unterprozess: Ausführung und Verwaltung von Unterprozessen direkt von Python aus. Dazu gehört die Arbeit mit stdin, stdout und Rückgabecodes. Mehr darüber erfahren Sie in unserem Python-Leitfaden zu Subprozessen.

Es gibt High-Level-Bibliotheken, die je nach Ihrem Bedarf noch spezifischere Funktionen enthalten. In den meisten Fällen sind Sie jedoch mit den oben genannten Modulen gut bedient

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

Nachdem Sie nun wissen, wie Python mit dem Betriebssystem interagiert, wollen wir uns nun mit den Methoden zur Überprüfung der Datei- und Ordnergröße beschäftigen. Alle der folgenden Lösungen sind im Abschnitt Datei- und Ordnergröße im Python GitHub Repository verfügbar

Verwendung von os.stat().st_size

Bei dieser Methode verwenden wir die stat() -Funktion aus dem os-Modul. Sie liefert eine Vielzahl von Informationen über einen bestimmten Pfad

Hinweis: Die Funktion os.path.getsize() erledigt diese Aufgabe ebenfalls. Der Vorteil der Verwendung von os.stat().st_size ist, dass sie keine Simlinks verfolgt

Bevor wir fortfahren, lassen Sie uns eine Testdatei mit dem Namen lorem.txt erstellen, 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 gleichen 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)

Schauen wir uns an, was wir mit diesem Code tun

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

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

Ausgabe

20064

Die Ausgabe wird in Bytes dargestellt. Das ist überhaupt nicht lesbar, also lassen Sie uns die Datei humanisieren, damit wir eine bessere Vorstellung von der Größe der Datei bekommen

Installieren Sie zunächst das Paket humanize, 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, zum Beispiel 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

Ausgabe

20064
20.1 kB

Pathlib verwenden

Obwohl pathlib ausschließlich für die Arbeit mit Pfaden konzipiert ist, 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 Klasse Path

from pathlib import Path

Erstellen Sie dann ein Path-Objekt und übergeben Sie den Pfad zur Datei lorem.txt als Argument

file_ = Path('lorem.txt')

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

print(datei_.stat().st_size)

Ausgabe

20064

Wie Sie sehen, erhalten wir das gleiche Ergebnis wie bei der ersten Methode, die wir verwendet haben. Das obige Ergebnis wird ebenfalls im Byte-Format ausgegeben, so dass wir das Modul humanize 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

Verwendung von Unix-Befehlen mit Subprocess:

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 verarbeiten

Hinweis: Diese Methode funktioniert nur, wenn Sie mit einem Unix-Betriebssystem (Linux, Mac)

arbeiten
Ö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 in dieses Stück Code ein

• Wir importieren die Funktion run aus dem Modul subprocess
• 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 ermitteln können
  • capture_output gibt uns Zugriff auf das Attribut standout (Standardausgabe)
  • text bedeutet, dass wir die Ausgabe als String statt als Bytes speichern
• Wir geben die Standardausgabe des Prozesses aus

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

20 lorem.txt

Wie Sie sehen können, erhalten wir 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 einen String handelt) und das erste Element ausgeben

from subprocess import run

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

size = process.stdout.split()<x><x>[0]</x></x>

print(size)

Ausgabe

20

Diese Ausgabe ist überhaupt nicht lesbar. Wir können zwar ableiten, dass die verwendete Maßeinheit KB ist (aufgrund der vorherigen Methoden), aber niemand sonst könnte die Größe der Datei erraten

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

Hinweis: Eine Anleitung zu diesem Befehl erhalten Sie, indem

Sie

man du oder du –help aufrufen

from subprocess import run

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

size = process.stdout.split()<x><x>[0]</x></x>

print(size)

Jetzt wird die Ausgabe dieses Skripts viel besser lesbar sein

20K

Wenn Sie mehr über das Modul subprocess und mögliche Anwendungen erfahren möchten, lesen Sie unsere Anleitung zu Python subprocess

Die Größe eines Ordners rekursiv ermitteln

Wenn Sie die Größe eines Ordners ermitteln möchten, müssen Sie jede Datei in diesem Verzeichnis und seinen Unterverzeichnissen durchlaufen. Dazu stehen Ihnen zwei Methoden zur Verfügung

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

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 ermitteln möchten

Iterieren über einen Pfad mit pathlib

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

Dieser Code scheint ein wenig unheimlich zu sein, lassen Sie uns die einzelnen Teile aufschlüsseln

• Importieren Sie die Klasse Path und die Funktion naturalsize()
• Definieren Sie die Funktion get_size() mit einem Parameter path, der standardmäßig auf das aktuelle Verzeichnis zeigt.
• Die Variable size ist nur ein Platzhalter, in den wir die Größe der einzelnen Dateien eintragen werden
• Iterieren Sie über jede Datei des Pfades
  • Die Methode rglob() gibt rekursiv die Dateien zurück, die dem Muster entsprechen
  • rglob(‘*’), bedeutet, dass wir alle Dateien innerhalb des Verzeichnisses erhalten
• Ermitteln Sie die Größe jeder Datei und fügen Sie sie der Variablen size hinzu
• Gibt die Größenvariable in einer für Menschen lesbaren Form zurück

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

In meinem Fall erhalte ich die folgende Ausgabe
403.

4 MB

Verwenden des du-Befehls mit Subprocess

Dieser Ansatz hat einige Vorteile

• Das Ergebnis ist ein wenig genauer
• Es ist viel schneller

from subprocess import run
from pathlib import Path

test_path = Path.home() / 'Dokumente/Tests/'

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

size = process.stdout.split()<x><x>[0]</x></x>

print(size)

Wir verwenden den gleichen Ansatz wie bei Methode 3, aber dieses Mal ermitteln wir die Größe eines Verzeichnisses statt einer Datei

Ausgabe

481M

Wie Sie sehen können, liefern diese beiden Methoden zur Ermittlung der Größe eines Ordners ein leicht unterschiedliches Ergebnis. Je größer das Verzeichnis ist, desto größer ist der Unterschied, den Sie erhalten

Es liegt an Ihnen, ob Sie sich für die pathlib oder die subprocess Methode entscheiden. Wenn Sie wissen, dass Sie immer mit Linux arbeiten werden, verwenden Sie subprocess, ansonsten können Sie die pathlib-Lösung verwenden

Zusammengefasst

Python erweist sich bei der Interaktion mit dem Betriebssystem als äußerst praktisch. Mit Python können Sie Prozesse automatisieren und eine Menge Zeit sparen. Die wichtigsten Module für die Interaktion mit dem Betriebssystem sind os, sys, path und subprocess

In diesem Lernprogramm haben Sie gelernt

• Wie Python mit dem Betriebssystem interagiert
• Die Verwendung von eingebauten Modulen zur Durchführung von OS-Operationen
• Wie Sie das Modul humanize verwenden, um menschenlesbar zu drucken
• Wie man die Größe einer Datei mit 3 Ansätzen berechnet
• Wie Sie die Größe eines Verzeichnisses rekursiv oder mit dem Befehl du berechnen können