Python
Schnell eine Liste von Dateien in einem Verzeichnis erhalten: Ein Python-Leitfaden

Schnell eine Liste von Dateien in einem Verzeichnis erhalten: Ein Python-Leitfaden

MoeNagy Dev

Erkunden der Module os und os.path

Überblick über die Module os und os.path

Die Module os und os.path in Python bieten eine plattformunabhängige Möglichkeit, mit dem Dateisystem des Betriebssystems zu interagieren. Diese Module bieten eine Vielzahl von Funktionen, vom Auflisten von Dateien in einem Verzeichnis bis zum Verwalten von Datei- und Verzeichnispfaden.

Zugriff auf das aktuelle Arbeitsverzeichnis

Sie können die Funktion os.getcwd() verwenden, um das aktuelle Arbeitsverzeichnis zu erhalten:

import os
 
current_dir = os.getcwd()
print(current_dir)

Dies gibt den absoluten Pfad des aktuellen Arbeitsverzeichnisses aus.

Auflisten von Dateien im aktuellen Verzeichnis

Die Funktion os.listdir() kann verwendet werden, um alle Dateien und Verzeichnisse im aktuellen Arbeitsverzeichnis aufzulisten:

import os
 
files_and_dirs = os.listdir()
print(files_and_dirs)

Dies gibt eine Liste aller Elemente (Dateien und Verzeichnisse) im aktuellen Verzeichnis zurück.

Verwendung der Funktion os.listdir()

Grundlagen von os.listdir()

Die Funktion os.listdir() nimmt ein optionales Argument entgegen, das der Pfad zum Verzeichnis ist, dessen Inhalt Sie auflisten möchten. Wenn kein Argument angegeben wird, werden die Inhalte des aktuellen Arbeitsverzeichnisses aufgelistet.

import os
 
# Dateien im aktuellen Verzeichnis auflisten
files_and_dirs = os.listdir()
print(files_and_dirs)
 
# Dateien in einem bestimmten Verzeichnis auflisten
specific_dir = "/Pfad/zu/Verzeichnis"
files_and_dirs = os.listdir(specific_dir)
print(files_and_dirs)

Auflisten von Dateien in einem bestimmten Verzeichnis

Um Dateien in einem bestimmten Verzeichnis aufzulisten, geben Sie den Pfad zum Verzeichnis als Argument an os.listdir() an:

import os
 
specific_dir = "/Pfad/zu/Verzeichnis"
files_and_dirs = os.listdir(specific_dir)
print(files_and_dirs)

Dies gibt eine Liste aller Elemente (Dateien und Verzeichnisse) im angegebenen Verzeichnis zurück.

Umgang mit relativen und absoluten Pfaden

Sie können sowohl relative als auch absolute Pfade mit os.listdir() verwenden. Relative Pfade werden relativ zum aktuellen Arbeitsverzeichnis interpretiert, während absolute Pfade als vollständiger Pfad zum Verzeichnis interpretiert werden.

import os
 
# Verwendung eines relativen Pfads
rel_path = "Dokumente"
files_and_dirs = os.listdir(rel_path)
print(files_and_dirs)
 
# Verwendung eines absoluten Pfads
abs_path = "/home/user/dokumente"
files_and_dirs = os.listdir(abs_path)
print(files_and_dirs)

Filtern der Dateiliste

Ausschluss von Verzeichnissen aus der Liste

Wenn Sie nur die Dateien in einem Verzeichnis auflisten möchten und nicht die Verzeichnisse selbst, können Sie die Funktion os.path.isfile() verwenden, um die Liste zu filtern:

import os
 
verzeichnis = "/Pfad/zu/Verzeichnis"
alle_elemente = os.listdir(verzeichnis)
dateien = [element for element in alle_elemente if os.path.isfile(os.path.join(verzeichnis, element))]
print(dateien)

Dies erstellt eine neue Liste dateien, die nur die Dateinamen enthält und Verzeichnisse ausschließt.

Filtern nach Dateierweiterung

Um die Liste der Dateien nach Dateierweiterung zu filtern, können Sie eine List Comprehension verwenden:

import os
 
verzeichnis = "/Pfad/zu/Verzeichnis"
alle_elemente = os.listdir(verzeichnis)
txt_dateien = [element for element in alle_elemente if element.endswith(".txt")]
print(txt_dateien)

Dies erstellt eine neue Liste txt_dateien, die nur die Dateinamen mit der Erweiterung .txt enthält.

Verwendung von List Comprehension für erweitertes Filtern

List Comprehensions können verwendet werden, um komplexere Filterlogik anzuwenden. Zum Beispiel, um eine Liste von Dateien zu erhalten, die eine bestimmte Erweiterung haben und größer als eine bestimmte Größe sind:

import os
 
verzeichnis = "/Pfad/zu/Verzeichnis"
alle_elemente = os.listdir(verzeichnis)
große_csv_dateien = [
    element
    for element in alle_elemente
    if element.endswith(".csv") and os.path.getsize(os.path.join(verzeichnis, element)) > 1024 * 1024
]
print(große_csv_dateien)

Dies erstellt eine neue Liste große_csv_dateien, die nur die CSV-Dateien im Verzeichnis enthält, die größer als 1 MB sind.

Rekursives Auflisten von Dateien in Unterverzeichnissen

Erkunden von Unterverzeichnissen mit os.walk()

Die Funktion os.walk() kann verwendet werden, um rekursiv einen Verzeichnisbaum zu durchlaufen und alle Dateien in den Unterverzeichnissen aufzulisten. Sie gibt einen Generator zurück, der für jeden besuchten Ordner ein 3-Tupel liefert: den Pfad zum Verzeichnis, eine Liste der Unterverzeichnisse in diesem Verzeichnis und eine Liste der Dateien in diesem Verzeichnis.

import os
 
verzeichnis = "/Pfad/zu/Verzeichnis"
for root, dirs, files in os.walk(verzeichnis):
    for datei in files:
        print(os.path.join(root, datei))

Dies gibt den vollständigen Pfad jeder Datei im Verzeichnisbaum aus, beginnend mit dem angegebenen verzeichnis.

Behandlung von Dateipfaden auf rekursive Weise

Wenn Sie mit os.walk() arbeiten, müssen Sie die Dateipfade korrekt behandeln, insbesondere beim Umgang mit Unterverzeichnissen. Die Funktion os.path.join() kann verwendet werden, um den vollständigen Pfad einer Datei zu konstruieren, indem der Verzeichnispfad und der Dateiname kombiniert werden.

import os
 
verzeichnis = "/Pfad/zu/Verzeichnis"
for root, dirs, files in os.walk(verzeichnis):
    for datei in files:
        vollständiger_pfad = os.path.join(root, datei)
        print(vollständiger_pfad)

Dies gibt den vollständigen Pfad jeder Datei aus und berücksichtigt dabei die Verzeichnisstruktur.

Anpassen des Ausgabeformats

Sie können das Ausgabeformat an Ihre Bedürfnisse anpassen. Zum Beispiel können Sie die Dateigröße und das Änderungsdatum zusammen mit dem Dateipfad ausgeben:

import os
from datetime import datetime
 
verzeichnis = "/Pfad/zu/Verzeichnis"
for root, dirs, files in os.walk(verzeichnis):
    for datei in files:
        vollständiger_pfad = os.path.join(root, datei)
```python
import os
 
file_size = os.path.getsize(full_path)
mod_time = os.path.getmtime(full_path)
mod_time_str = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
print(f"{full_path} - Größe: {file_size} Bytes - Geändert: {mod_time_str}")

Dieser Code gibt den Dateipfad, die Größe und die Änderungszeit für jede Datei im Verzeichnisbaum aus.

Arbeit mit dem os.path-Modul

Verbinden von Pfaden mit os.path.join()

Die Funktion os.path.join() wird verwendet, um Dateipfade intelligent zu verbinden, indem sie einen oder mehrere Pfadkomponenten zusammenfügt. Sie behandelt die entsprechenden Pfadtrennzeichen (z. B. Schrägstriche auf Unix-ähnlichen Systemen, Rückwärtsschrägstriche auf Windows) basierend auf dem Betriebssystem.

import os
 
verzeichnis = "/pfad/zum/verzeichnis"
dateiname = "beispiel.txt"
voller_pfad = os.path.join(verzeichnis, dateiname)
print(voller_pfad)

Dies gibt den vollen Pfad zur Datei aus, mit den entsprechenden Pfadtrennzeichen für das aktuelle Betriebssystem.

Überprüfen, ob ein Pfad eine Datei oder ein Verzeichnis ist

Die Funktionen os.path.isfile() und os.path.isdir() können verwendet werden, um zu überprüfen, ob ein bestimmter Pfad eine Datei oder ein Verzeichnis darstellt.

import os
 
pfad = "/pfad/zur/datei.txt"
if os.path.isfile(pfad):
    print(f"{pfad} ist eine Datei.")
else:
    print(f"{pfad} ist keine Datei.")
 
pfad = "/pfad/zum/verzeichnis"
if os.path.isdir(pfad):
    print(f"{pfad} ist ein Verzeichnis.")
else:
    print(f"{pfad} ist kein Verzeichnis.")

Ermitteln von Dateigröße und Änderungszeit

Die Funktionen os.path.getsize() und os.path.getmtime() können verwendet werden, um die Größe einer Datei und die Zeit ihrer letzten Änderung zu ermitteln.

import os
from datetime import datetime
 
pfad = "/pfad/zur/datei.txt"
dateigroesse = os.path.getsize(pfad)
aenderungszeit = os.path.getmtime(pfad)
aenderungszeit_str = datetime.fromtimestamp(aenderungszeit).strftime("%Y-%m-%d %H:%M:%S")
print(f"Dateigröße: {dateigroesse} Bytes")
print(f"Letzte Änderung: {aenderungszeit_str}")

Dies gibt die Dateigröße in Bytes und die letzte Änderungszeit der Datei aus.

Umgang mit plattformübergreifender Kompatibilität

Unterschiede zwischen Betriebssystemen berücksichtigen

Die Module os und os.path sind so konzipiert, dass sie eine plattformunabhängige Schnittstelle bereitstellen, jedoch gibt es immer noch einige Unterschiede in der Art und Weise, wie Dateipfade auf unterschiedlichen Betriebssystemen behandelt werden (z. B. verwendet Windows Rückwärtsschrägstriche, während Unix-ähnliche Systeme Schrägstriche verwenden).

Konsistentes Verhalten auf verschiedenen Plattformen sicherstellen

Um sicherzustellen, dass Ihr Code konsistent auf verschiedenen Plattformen funktioniert, sollten Sie die entsprechenden Funktionen und Methoden aus dem os.path-Modul verwenden, wie z. B. os.path.join(), os.path.normpath() und os.path.normcase().

Verwendung von os.path.normpath() und os.path.normcase()

Die Funktion os.path.normpath() kann verwendet werden, um einen Pfad zu normalisieren, indem überflüssige Trennzeichen und übergeordnete Verweise (z. B. ../) zusammengeführt werden. Die Funktion os.path.normcase() kann verwendet werden, um die Groß- und Kleinschreibung eines Pfads zu normalisieren, was auf dateisystemen mit Groß-/Kleinschreibung wichtig ist.

import os
 
# Einen Pfad normalisieren
pfad = "/pfad/zum/../datei.txt"
normalisierter_pfad = os.path.normpath(pfad)
print(normalisierter_pfad)  # Ausgabe: "/pfad/datei.txt"
 
# Die Groß- und Kleinschreibung eines Pfads normalisieren
pfad = "/PFAD/zU/DATEI.txt"
normalisierter_pfad = os.path.normcase(pfad)
print(normalisierter_pfad)  # Ausgabe: "/pfad/zu/datei.txt" (auf Unix-ähnlichen Systemen)

Durch die Verwendung dieser Funktionen können Sie sicherstellen, dass Ihre Dateipfade auf verschiedenen Betriebssystemen einheitlich formatiert sind.

Sortieren und Organisieren der Dateiliste

Sortieren der Dateiliste nach Name, Größe oder Änderungszeit

Sie können die Dateiliste basierend auf verschiedenen Attributen wie dem Dateinamen, der Größe oder der Änderungszeit sortieren. Die Funktion sorted() kann zu diesem Zweck verwendet werden, zusammen mit den entsprechenden Schlüsselfunktionen.

import os
 
verzeichnis = "/pfad/zum/verzeichnis"
dateien = os.listdir(verzeichnis)
 
# Sortieren nach Dateiname
sortierte_dateien = sorted(dateien)
print(sortierte_dateien)
 
# Sortieren nach Dateigröße
dateigroessen = [(d, os.path.getsize(os.path.join(verzeichnis, d))) for d in dateien]
sortierte_dateien = sorted(dateigroessen, key=lambda x: x[1])
print(sortierte_dateien)
 
# Sortieren nach Änderungszeit
aenderungszeiten = [(d, os.path.getmtime(os.path.join(verzeichnis, d))) for d in dateien]
sortierte_dateien = sorted(aenderungszeiten, key=lambda x: x[1])
print(sortierte_dateien)

Dies gibt die Dateiliste sortiert nach Name, Größe und Änderungszeit aus.

Gruppieren von Dateien nach Dateierweiterung oder anderen Attributen

Sie können die Dateien anhand ihrer Dateierweiterung oder anderer Attribute mithilfe eines Wörterbuchs oder eines defaultdict gruppieren:

import os
from collections import defaultdict
 
verzeichnis = "/pfad/zum/verzeichnis"
dateien = os.listdir(verzeichnis)
 
# Dateien nach Erweiterung gruppieren
dateigruppen = defaultdict(list)
for datei in dateien:
    erweiterung = os.path.splitext(datei)[1][1:]
    dateigruppen[erweiterung].append(datei)
 
for erweiterung, dateien in dateigruppen.items():
    print(f"{erweiterung}-Dateien: {', '.join(dateien)}")
 
# Dateien nach Größe (in MB) gruppieren
dateigroessen = [(d, os.path.getsize(os.path.join(verzeichnis, d))) for d in dateien]
dateigruppen = defaultdict(list)
for datei, groesse in dateigroessen:
    groesse_mb = groesse / (1024 * 1024)
    dateigruppen[f"{groesse_mb:.2f} MB"].append(datei)
 
for groesse, dateien in dateigruppen.items():
    print(f"{groesse}-Dateien: {', '.join(dateien)}")

Dies gruppiert die Dateien nach Dateierweiterung bzw. Größe.

Datenstrukturen

Listen

Listen gehören zu den vielseitigsten Datenstrukturen in Python. Sie sind geordnete Sammlungen von Elementen, die unterschiedliche Datentypen haben können. Hier ist ein Beispiel:

meine_liste = [1, 'Apfel', 3.14, True]

Sie können auf einzelne Elemente in einer Liste über ihren Index zugreifen, der bei 0 beginnt:

print(meine_liste[0])  # Ausgabe: 1
print(meine_liste[2])  # Ausgabe: 3.14

Sie können auch Elemente in einer Liste ändern:

meine_liste[1] = 'Banane'
print(meine_liste)  # Ausgabe: [1, 'Banane', 3.14, True]

Listen haben viele integrierte Methoden wie append(), insert(), remove() und sort().

Tupel

Tupel sind ähnlich wie Listen, aber sie sind unveränderlich, das bedeutet, dass ihre Elemente nach ihrer Erstellung nicht geändert werden können. Tupel werden mit Klammern () anstelle von eckigen Klammern [] definiert.

my_tuple = (1, 'apple', 3.14, True)
print(my_tuple[0])  # Output: 1

Tupel sind nützlich, wenn Sie sicherstellen möchten, dass die Reihenfolge und der Inhalt einer Datenkollektion unverändert bleiben.

Wörterbücher

Wörterbücher sind ungeordnete Sammlungen von Schlüssel-Wert-Paaren. Sie werden mit geschweiften Klammern {} definiert und jedes Schlüssel-Wert-Paar wird durch einen Doppelpunkt : getrennt.

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print(my_dict['name'])  # Output: 'John'

Sie können Schlüssel-Wert-Paare in einem Wörterbuch hinzufügen, ändern und entfernen:

my_dict['email'] = 'john@example.com'
my_dict['age'] = 31
del my_dict['city']

Wörterbücher sind leistungsstark, um Daten basierend auf eindeutigen Schlüsseln zu speichern und abzurufen.

Mengen

Mengen sind ungeordnete Sammlungen von eindeutigen Elementen. Sie werden mit geschweiften Klammern {} oder der set()-Funktion definiert.

my_set = {1, 2, 3, 4, 5}
print(2 in my_set)  # Output: True
print(6 in my_set)  # Output: False

Mengen sind nützlich für Operationen wie Vereinigung, Schnittmenge und Differenz zwischen Datenkollektionen.

Kontrollstrukturen

Bedingte Anweisungen

Bedingte Anweisungen in Python verwenden die Schlüsselwörter if, elif und else, um verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen.

x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

Schleifen

Python hat zwei Haupt-Schleifenstrukturen: for und while. Die for-Schleife wird verwendet, um über Sequenzen zu iterieren (wie Listen, Tupel oder Strings), während die while-Schleife verwendet wird, um einen Codeblock auszuführen, solange eine bestimmte Bedingung wahr ist.

# For-Schleife
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)
 
# While-Schleife
count = 0
while count < 5:
    print(count)
    count += 1

Sie können auch die Anweisungen break und continue verwenden, um den Fluss einer Schleife zu steuern.

Listen-Comprehensions

Listen-Comprehensions bieten eine prägnante Möglichkeit, basierend auf vorhandenen Listen neue Listen zu erstellen. Sie sind besonders nützlich zum Transformieren oder Filtern von Daten.

# Erstellen Sie eine neue Liste mit Quadraten von Zahlen von 1 bis 10
squares = [x**2 for x in range(1, 11)]
print(squares)  # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
# Erstellen Sie eine neue Liste mit geraden Zahlen von 1 bis 10
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)  # Output: [2, 4, 6, 8, 10]

Funktionen

Funktionen in Python werden mit dem Schlüsselwort def definiert. Sie können Parameter akzeptieren und Rückgabewerte liefern.

def greet(name):
    """Begrüßen Sie die Person mit dem angegebenen Namen."""
    print(f"Hallo, {name}!")
 
greet("Alice")  # Output: Hallo, Alice!

Sie können auch Funktionen mit Standardparameterwerten und variabler Anzahl von Argumenten definieren.

def calculate_area(length, width=1):
    """Berechnen Sie die Fläche eines Rechtecks."""
    return length * width
 
print(calculate_area(5, 3))  # Output: 15
print(calculate_area(4))  # Output: 4 (standardmäßige Breite ist 1)
 
def sum_numbers(*args):
    """Berechnen Sie die Summe einer beliebigen Anzahl von Argumenten."""
    return sum(args)
 
print(sum_numbers(1, 2, 3))  # Output: 6
print(sum_numbers(4, 5, 6, 7, 8))  # Output: 30

Funktionen können auch als Lambda-Funktionen (anonyme Funktionen) definiert werden, um einfache, einzeilige Operationen auszuführen.

square = lambda x: x**2
print(square(5))  # Output: 25

Module und Pakete

Die Python-Standardbibliothek bietet eine Vielzahl von integrierten Modulen, die Sie in Ihren Programmen verwenden können. Sie können auch Ihre eigenen Module und Pakete erstellen, um Ihren Code zu organisieren.

# Verwendung eines integrierten Moduls
import math
print(math.pi)  # Output: 3.141592653589793
 
# Erstellen eines benutzerdefinierten Moduls
# my_module.py
def greet(name):
    print(f"Hallo, {name}!")
 
# Verwendung des benutzerdefinierten Moduls
import my_module
my_module.greet("Alice")  # Output: Hallo, Alice!

Pakete sind Sammlungen von Modulen und helfen Ihnen dabei, Ihren Code zu strukturieren und Abhängigkeiten zu verwalten.

Ausnahmebehandlung

Das Ausnahmebehandlungsmechanismus von Python ermöglicht es Ihnen, Fehler und unerwartete Situationen in Ihrem Code zu behandeln.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null")
else:
    print(f"Ergebnis: {result}")
finally:
    print("Dieser Block wird immer ausgeführt.")

Sie können auch Ihre eigenen benutzerdefinierten Ausnahmen definieren und bei Bedarf auslösen.

class InvalidInputError(Exception):
    pass
 
def divide(a, b):
    if b == 0:
        raise InvalidInputError("Fehler: Division durch Null")
    return a / b
 
try:
    print(divide(10, 0))
except InvalidInputError as e:
    print(e)

Datei-Ein-/Ausgabe

Python bietet integrierte Funktionen zum Lesen aus und Schreiben in Dateien.

# Schreiben in eine Datei
with open("output.txt", "w") as file:
    file.write("Hallo, Welt!")
 
# Lesen aus einer Datei
with open("input.txt", "r") as file:
    content = file.read()
    print(content)

Die with-Anweisung stellt sicher, dass die Datei nach Abschluss des Vorgangs ordnungsgemäß geschlossen wird.

Fazit

In diesem Python-Tutorial haben wir eine Vielzahl von Themen behandelt, einschließlich Datenstrukturen, Kontrollstrukturen, Funktionen, Module und Pakete, Ausnahmebehandlung und Datei-Ein-/Ausgabe. Indem Sie diese Konzepte verstehen, werden Sie auf dem besten Weg sein, ein kompetenter Python-Programmierer zu werden. Denken Sie daran, regelmäßig zu üben und das umfangreiche Ökosystem von Python-Bibliotheken und -Frameworks zu erkunden, um Ihre Fähigkeiten zu erweitern und leistungsstarke Anwendungen zu erstellen.

MoeNagy Dev