Python
Dateien in einem Verzeichnis mühelos mit Python abrufen

Dateien mühelos mit Python in einem Verzeichnis abrufen

MoeNagy Dev

Abrufen aller Dateien in einem Verzeichnis mit Python

Die Kraft von os.listdir()

Die Funktion os.listdir() verstehen

Die Funktion os.listdir() ist ein leistungsstolles Werkzeug in der Standard-Bibliothek von Python. Sie ermöglicht es, eine Liste aller Dateien und Verzeichnisse in einem angegebenen Verzeichnis abzurufen. Diese Funktion ist Teil des Moduls os, welches eine Möglichkeit bietet, mit dem Betriebssystem zu interagieren.

Hier ist ein grundlegendes Beispiel, wie man os.listdir() verwendet:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
dateiliste = os.listdir(verzeichnispfad)
print(dateiliste)

Dieser Code gibt eine Liste aller Dateien und Verzeichnisse im angegebenen verzeichnispfad aus.

Auflisten aller Dateien in einem Verzeichnis

Um eine Liste nur der Dateien (und nicht der Verzeichnisse) in einem Verzeichnis zu erhalten, kann man folgenden Ansatz verwenden:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
dateiliste = [d for d in os.listdir(verzeichnispfad) if os.path.isfile(os.path.join(verzeichnispfad, d))]
print(dateiliste)

In diesem Beispiel verwenden wir eine List Comprehension, um die Liste, die von os.listdir() zurückgegeben wird, zu filtern und nur die Elemente einzuschließen, die Dateien (anstatt Verzeichnisse) sind. Dafür verwenden wir die Funktion os.path.isfile().

Umgang mit Unterverzeichnissen und rekursivem Abrufen von Dateien

Wenn man Dateien nicht nur aus dem angegebenen Verzeichnis, sondern auch aus seinen Unterverzeichnissen abrufen möchte, kann man einen rekursiven Ansatz verwenden. Hier ist ein Beispiel:

import os
 
def alle_dateien_abrufen(verzeichnispfad):
    dateiliste = []
    for verzeichnis, unterverzeichnisse, dateien in os.walk(verzeichnispfad):
        for datei in dateien:
            dateiliste.append(os.path.join(verzeichnis, datei))
    return dateiliste
 
verzeichnispfad = '/pfad/zum/verzeichnis'
alle_dateien = alle_dateien_abrufen(verzeichnispfad)
print(alle_dateien)

In diesem Beispiel definieren wir eine Funktion alle_dateien_abrufen(), die die Funktion os.walk() verwendet, um den Verzeichnisbaum rekursiv durchzugehen. Für jede gefundene Datei erstellen wir den vollständigen Dateipfad mit os.path.join() und fügen ihn zur dateiliste hinzu.

Dateien nach Dateierweiterung filtern

Spezifische Dateierweiterungen angeben

Um nur die Dateien mit bestimmten Dateierweiterungen abzurufen, kann man den folgenden Ansatz verwenden:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
erlaubte_erweiterungen = ['.txt', '.py', '.jpg']
 
dateiliste = [d for d in os.listdir(verzeichnispfad) if any(d.endswith(erweiterung) for erweiterung in erlaubte_erweiterungen)]
print(dateiliste)

In diesem Beispiel definieren wir eine Liste erlaubte_erweiterungen und verwenden eine List Comprehension, um die Liste der von os.listdir() zurückgegebenen Dateien zu filtern und nur die Dateien einzuschließen, die eine der angegebenen Erweiterungen haben.

Ausschließen bestimmter Dateierweiterungen

Ebenso kann man bestimmte Dateierweiterungen ausschließen, indem man die List Comprehension modifiziert:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
ausgeschlossene_erweiterungen = ['.pyc', '.log']
 
dateiliste = [d for d in os.listdir(verzeichnispfad) if not any(d.endswith(erweiterung) for erweiterung in ausgeschlossene_erweiterungen)]
print(dateiliste)

Hier definieren wir eine Liste ausgeschlossene_erweiterungen und verwenden eine List Comprehension, um die Liste der Dateien zu filtern und alle Dateien auszuschließen, die eine der angegebenen Erweiterungen haben.

Umgang mit mehreren Dateierweiterungen

Man kann auch mit mehreren Dateierweiterungen auf flexiblere Weise umgehen, indem man ein Set oder ein Dictionary verwendet:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
erlaubte_erweiterungen = {'.txt', '.py', '.jpg'}
 
dateiliste = [d for d in os.listdir(verzeichnispfad) if any(d.endswith(erweiterung) for erweiterung in erlaubte_erweiterungen)]
print(dateiliste)

In diesem Beispiel verwenden wir ein Set erlaubte_erweiterungen anstelle einer Liste. Dies ermöglicht es uns, Erweiterungen leicht hinzuzufügen oder zu entfernen, ohne die List Comprehension zu ändern.

Sortieren und Organisieren der Dateiliste

Alphabetisches Sortieren der Dateiliste

Um die Dateiliste alphabetisch zu sortieren, kann man die integrierte Funktion sorted() verwenden:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
dateiliste = os.listdir(verzeichnispfad)
sortierte_dateiliste = sorted(dateiliste)
print(sortierte_dateiliste)

Dies sortiert die Dateiliste in aufsteigender alphabetischer Reihenfolge.

Sortieren nach Dateigröße oder Änderungsdatum

Um die Dateiliste nach Dateigröße oder Änderungsdatum zu sortieren, kann man die Funktionen os.path.getsize() bzw. os.path.getmtime() verwenden:

import os
 
verzeichnispfad = '/pfad/zum/verzeichnis'
dateiliste = os.listdir(verzeichnispfad)
 
# Sortieren nach Dateigröße
sortiert_nach_groesse = sorted(dateiliste, key=lambda x: os.path.getsize(os.path.join(verzeichnispfad, x)))
print(sortiert_nach_groesse)
 
# Sortieren nach Änderungsdatum
sortiert_nach_datum = sorted(dateiliste, key=lambda x: os.path.getmtime(os.path.join(verzeichnispfad, x)))
print(sortiert_nach_datum)

Im ersten Beispiel verwenden wir die Funktion sorted() mit einer benutzerdefinierten Schlüsselfunktion, die die Dateigröße mithilfe von os.path.getsize() abruft. Im zweiten Beispiel verwenden wir das Änderungsdatum, das mit os.path.getmtime() abgerufen wird, als Sortierschlüssel.

Dateien nach Erweiterung gruppieren

Um die Dateien nach ihren Dateierweiterungen zu gruppieren, kann man ein Dictionary verwenden, um die Dateien nach ihren Erweiterungen zu speichern:

import os
from collections import defaultdict
 
verzeichnispfad = '/pfad/zum/verzeichnis'
dateiliste = os.listdir(verzeichnispfad)
 
datei_gruppen = defaultdict(list)
for dateiname in dateiliste:
    erweiterung = os.path.splitext(dateiname)[1].lower()
    datei_gruppen[erweiterung].append(dateiname)
 
for erweiterung, dateien in datei_gruppen.items():
    print(f"Dateien mit der Erweiterung '{erweiterung}': {', '.join(dateien)}")

In diesem Beispiel verwenden wir ein defaultdict aus dem Modul collections, um ein Wörterbuch zu erstellen, das automatisch leere Listen für neue Dateierweiterungen initialisiert. Anschließend durchlaufen wir die Dateiliste, extrahieren die Dateierweiterung mit Hilfe von os.path.splitext() und fügen den Dateinamen zur entsprechenden Liste im Wörterbuch file_groups hinzu.

Arbeiten mit Pathlib

Die Pathlib-Modul einführen

Das pathlib-Modul in Python bietet eine objektorientierte Möglichkeit, mit Dateipfaden zu arbeiten. Es bietet einen intuitiveren und plattformübergreifenden Ansatz im Vergleich zum herkömmlichen os.path-Modul.

Dateien mit Pathlib auflisten

Hier ist ein Beispiel, wie man Pathlib verwendet, um Dateien in einem Verzeichnis aufzulisten:

from pathlib import Path
 
directory_path = '/Pfad/zum/Verzeichnis'
file_list = [p.name for p in Path(directory_path).glob('*')]
print(file_list)

In diesem Beispiel verwenden wir die Klasse Path aus dem Modul pathlib, um den Verzeichnispfad darzustellen. Die Methode glob() wird dann verwendet, um eine Liste aller Dateien und Verzeichnisse im angegebenen Verzeichnis abzurufen.

Zugriff auf Dateimetadaten mit Pathlib

Sie können auch Pathlib verwenden, um einfach auf Dateimetadaten wie Dateigröße und Änderungsdatum zuzugreifen:

from pathlib import Path
 
file_path = '/Pfad/zur/Datei.txt'
file_path = Path(file_path)
 
print(f"Dateiname: {file_path.name}")
print(f"Dateigröße: {file_path.stat().st_size} Bytes")
print(f"Änderungszeit: {file_path.stat().st_mtime}")

Dieser Code zeigt, wie man den Dateinamen, die Dateigröße und die Änderungszeit mit dem pathlib.Path-Objekt abruft.

Umgang mit versteckten Dateien und Verzeichnissen

Erkennen versteckter Dateien und Verzeichnisse

In vielen Dateisystemen gelten Dateien und Verzeichnisse, die mit einem Punkt beginnen (z.B. .gitignore), als "versteckt" und werden in der Regel nicht in Verzeichnislisten angezeigt. Um diese versteckten Objekte ein- oder auszuschließen, kann man den folgenden Ansatz verwenden:

import os
 
directory_path = '/Pfad/zum/Verzeichnis'
all_items = os.listdir(directory_path)
visible_items = [item for item in all_items if not item.startswith('.')]
hidden_items = [item for item in all_items if item.startswith('.')]
 
print("Sichtbare Objekte:", visible_items)
print("Versteckte Objekte:", hidden_items)

In diesem Beispiel rufen wir zunächst die vollständige Liste der Objekte im Verzeichnis mit os.listdir() ab. Anschließend verwenden wir zwei Listenverständnisse, um die sichtbaren und versteckten Objekte auf der Grundlage des Beginns des Objektnamens mit einem Punkt zu trennen.

Entscheiden, ob sie einbezogen oder ausgeschlossen werden sollen

Je nach Anwendungsfall möchten Sie möglicherweise die versteckten Dateien und Verzeichnisse ein- oder ausschließen. Hier ist ein Beispiel, wie man dies handhabt:

import os
 
directory_path = '/Pfad/zum/Verzeichnis'
include_hidden = False
 
all_items = os.listdir(directory_path)
if include_hidden:
    file_list = all_items
else:
    file_list = [item for item in all_items if not item.startswith('.')]
 
print(file_list)

In diesem Beispiel führen wir eine boolesche Variable include_hidden ein, die steuert, ob die versteckten Objekte in der endgültigen Dateiliste enthalten sein sollen oder nicht.

Anpassen des Dateisuchverhaltens

Sie können das Dateisuchverhalten weiter anpassen, indem Sie eine Funktion erstellen, mit der Sie benutzerdefinierte Regeln für das Ein- oder Ausschließen von Dateien und Verzeichnissen festlegen können:

import os
 
def get_file_list(directory_path, include_hidden=False, allowed_extensions=None, excluded_extensions=None):
    all_items = os.listdir(directory_path)
    file_list = []
 
    for item in all_items:
        item_path = os.path.join(directory_path, item)
        if os.path.isfile(item_path):
            if allowed_extensions:
                if any(item.endswith(ext) for ext in allowed_extensions):
                    file_list.append(item)
            elif excluded_extensions:
                if not any(item.endswith(ext) for ext in excluded_extensions):
                    file_list.append(item)
            else:
                file_list.append(item)
        elif include_hidden or not item.startswith('.'):
            file_list.append(item)
 
    return file_list
 
# Beispielverwendung
directory_path = '/Pfad/zum/Verzeichnis'
file_list = get_file_list(directory_path, include_hidden=False, allowed_extensions=['.txt', '.py'])
print(file_list)

In diesem Beispiel ermöglicht Ihnen die Funktion get_file_list() die Angabe, ob versteckte Dateien und Verzeichnisse einbezogen werden sollen, sowie die Angabe von Dateierweiterungen, die ein- oder ausgeschlossen werden sollen. Dies bietet eine flexible und anpassungsfähige Möglichkeit, die Dateiliste basierend auf Ihren spezifischen Anforderungen abzurufen.

Kombinieren von os.listdir() und os.path.join()

Verwendung von os.path.join(), um vollständige Dateipfade zu erstellen

Bei der Arbeit mit der Dateiliste, die mit os.listdir() abgerufen wurde, müssen Sie oft die vollständigen Dateipfade erstellen. Hier können Sie die Funktion os.path.join() verwenden:

import os
 
directory_path = '/Pfad/zum/Verzeichnis'
file_list = os.listdir(directory_path)
full_file_paths = [os.path.join(directory_path, filename) for filename in file_list]
print(full_file_paths)

In diesem Beispiel verwenden wir eine List Comprehension, um durch die Dateiliste zu iterieren und die vollständigen Dateipfade zu erstellen, indem wir den Verzeichnispfad und die einzelnen Dateinamen mit Hilfe von os.path.join() verbinden.

Durch das Verzeichnis iterieren und die Dateiliste erstellen

Sie können os.listdir() und os.path.join() kombinieren, um die Dateiliste effizienter zu erstellen:

import os
 
def get_file_list(directory_path):
    file_list = []
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        if os.path.isfile(file_path):
            file_list.append(file_path)
    return file_list
 
directory_path = '/Pfad/zum/Verzeichnis'
all_files = get_file_list(directory_path)
print(all_files)

In diesem Beispiel wird die Funktion get_file_list() verwendet, um die Dateiliste zu erstellen. Sie ermöglicht es Ihnen, den angegebenen Verzeichnispfad zu durchlaufen und den vollständigen Dateipfad für jede Datei zu erhalten, die eine tatsächliche Datei ist.

Datenstrukturen

Listen

Listen sind eine der grundlegendsten Datenstrukturen in Python. Sie sind geordnete Sammlungen von Elementen, die verschiedene Datentypen haben können. Sie können eine Liste mit eckigen Klammern [] erstellen und die Elemente mit Kommas trennen.

fruits = ['Apfel', 'Banane', 'Kirsche']
print(fruits)  # Ausgabe: ['Apfel', 'Banane', 'Kirsche']

Sie können einzelne Elemente in einer Liste mit ihrem Index abrufen, der bei 0 beginnt.

print(fruits[0])  # Ausgabe: 'Apfel'
print(fruits[1])  # Ausgabe: 'Banane'

Sie können auch negative Indizes verwenden, um Elemente vom Ende der Liste abzurufen.

print(fruits[-1])  # Ausgabe: 'Kirsche'
print(fruits[-2])  # Ausgabe: 'Banane'

Listen unterstützen eine Vielzahl von Operationen wie Slicing, Verkettung und Änderung.

# Slicing
print(fruits[1:3])  # Ausgabe: ['Banane', 'Kirsche']
 
# Verkettung
more_fruits = ['Orange', 'Kiwi']
all_fruits = fruits + more_fruits
print(all_fruits)  # Ausgabe: ['Apfel', 'Banane', 'Kirsche', 'Orange', 'Kiwi']
 
# Änderung
fruits[0] = 'Birne'
print(fruits)  # Ausgabe: ['Birne', 'Banane', 'Kirsche']

Tupel

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

point = (3, 4)
print(point)  # Ausgabe: (3, 4)
print(point[0])  # Ausgabe: 3
print(point[1])  # Ausgabe: 4

Tupel können nützlich sein, wenn Sie einen festen Satz von Werten speichern möchten, z.B. Koordinaten oder Datenbankeinträge.

Wörterbücher

Wörterbücher sind ungeordnete Sammlungen von Schlüssel-Wert-Paaren. Sie werden mit geschweiften Klammern {} definiert und die Schlüssel und Werte werden durch Doppelpunkte getrennt.

person = {
    'name': 'John Doe',
    'alter': 35,
    'beruf': 'Software Engineer'
}
print(person)  # Ausgabe: {'name': 'John Doe', 'alter': 35, 'beruf': 'Software Engineer'}

Sie können auf die Werte in einem Wörterbuch mit ihren Schlüsseln zugreifen.

print(person['name'])  # Ausgabe: 'John Doe'
print(person['alter'])  # Ausgabe: 35

Wörterbücher sind vielseitig und können verwendet werden, um verschiedene Arten von Daten zu speichern, einschließlich Listen und anderen Wörterbüchern.

person = {
    'name': 'John Doe',
    'alter': 35,
    'hobbys': ['lesen', 'wandern', 'fotografieren'],
    'adresse': {
        'straße': '123 Hauptstraße',
        'stadt': 'Irgendwo',
        'bundesland': 'CA'
    }
}
 
print(person['hobbys'])  # Ausgabe: ['lesen', 'wandern', 'fotografieren']
print(person['adresse']['stadt'])  # Ausgabe: 'Irgendwo'

Mengen

Mengen sind ungeordnete Sammlungen von eindeutigen Elementen. Sie werden mit geschweiften Klammern {} definiert und die Elemente werden durch Kommas getrennt.

farben = {'rot', 'grün', 'blau'}
print(farben)  # Ausgabe: {'rot', 'grün', 'blau'}

Sie können Mengen verwenden, um verschiedene Operationen wie Vereinigung, Schnittmenge und Differenz durchzuführen.

farben1 = {'rot', 'grün', 'blau'}
farben2 = {'grün', 'gelb', 'orange'}
 
# Vereinigung
alle_farben = farben1 | farben2
print(alle_farben)  # Ausgabe: {'rot', 'grün', 'blau', 'gelb', 'orange'}
 
# Schnittmenge
gemeinsame_farben = farben1 & farben2
print(gemeinsame_farben)  # Ausgabe: {'grün'}
 
# Differenz
eindeutige_farben1 = farben1 - farben2
print(eindeutige_farben1)  # Ausgabe: {'rot', 'blau'}

Kontrollstrukturen

Bedingte Anweisungen

In Python können Sie bedingte Anweisungen verwenden, um den Ablauf Ihres Programms basierend auf bestimmten Bedingungen zu steuern.

Die if-elif-else Anweisung ist die häufigste Möglichkeit, bedingte Logik zu implementieren.

alter = 25
if alter < 18:
    print("Du bist minderjährig.")
elif alter < 65:
    print("Du bist erwachsen.")
else:
    print("Du bist Senior.")

Sie können auch den ternären Operator verwenden, der eine verkürzte Schreibweise für einfache if-else Anweisungen ist.

ist_student = True
status = "Student" if ist_student else "Nicht-Student"
print(status)  # Ausgabe: "Student"

Schleifen

Schleifen in Python ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen. Die beiden häufigsten Arten von Schleifen sind for und while Schleifen.

Eine for Schleife wird verwendet, um über eine Sequenz zu iterieren, wie z.B. eine Liste oder einen String.

fruits = ['Apfel', 'Banane', 'Kirsche']
for fruit in fruits:
    print(fruit)

Eine while Schleife wird verwendet, um einen Codeblock so lange wiederholt auszuführen, wie eine bestimmte Bedingung wahr ist.

count = 0
while count < 5:
    print(count)
    count += 1

Sie können auch die break und continue Anweisungen verwenden, um den Ablauf Ihrer Schleifen zu steuern.

for i in range(10):
    if i == 5:
        break
    print(i)  # Ausgabe: 0 1 2 3 4
 
for j in range(10):
    if j % 2 == 0:
        continue
    print(j)  # Ausgabe: 1 3 5 7 9

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe ausführen. Sie werden mit dem Schlüsselwort def definiert.

def grüße(name):
    print(f"Hallo, {name}!")
 
greet("Alice")  # Ausgabe: "Hallo, Alice!"

Funktionen können auch Werte mit dem return Statement zurückgeben.

def addiere_zahlen(a, b):
    return a + b
 
resultat = addiere_zahlen(3, 4)
print(resultat)  # Ausgabe: 7

Sie können auch Funktionen mit Standardparameterwerten und variable Länge Argumenten definieren.

def drucke_info(name, alter=30, *args):
    print(f"Name: {name}")
    print(f"Alter: {alter}")
    print("Zusätzliche Informationen:")
    for arg in args:
        print(arg)
 
drucke_info("John", 35, "Software Engineer", "Liebt wandern")

Module und Pakete

In Python können Sie Ihren Code in Module und Pakete organisieren, um ihn modularer und wiederverwendbarer zu machen.

Ein Modul ist eine einzelne Python-Datei, die Funktionen, Klassen und Variablen enthält. Sie können Module mit der import Anweisung importieren.

import math
print(math.pi)  # Ausgabe: 3.141592653589793

Sie können auch bestimmte Elemente aus einem Modul mit dem from Schlüsselwort importieren.

from math import sqrt
print(sqrt(16))  # Ausgabe: 4.0

Pakete sind Sammlungen von verwandten Modulen. Sie sind in Verzeichnissen mit einer __init__.py Datei organisiert, die das Paket definiert.

mein_paket/
```de
---
language: de
---

__init__.py
module1.py
module2.py

Sie können dann Elemente aus einem Paket mit der Punkt-Schreibweise importieren.

```python
import my_package.module1
result = my_package.module1.my_function()

Fehlerbehandlung

Der Fehlerbehandlungsmechanismus von Python ermöglicht Ihnen, Laufzeitfehler und unerwartete Situationen in Ihrem Code zu behandeln.

Sie können das try-except-Statement verwenden, um Ausnahmen abzufangen und zu behandeln.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null")

Sie können auch mehrere Ausnahmen behandeln und ein standardmäßiges except-Block zur Verfügung stellen.

try:
    num = int(input("Geben Sie eine Zahl ein: "))
    print(10 / num)
except ValueError:
    print("Fehler: Ungültige Eingabe")
except ZeroDivisionError:
    print("Fehler: Division durch Null")
except:
    print("Ein unbekannter Fehler ist aufgetreten")

Sie können auch eigene Ausnahmen mit dem raise-Statement werfen.

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Unzureichende Guthaben")
    return balance - amount
 
try:
    new_balance = withdraw(100, 150)
except ValueError as e:
    print(e)

Fazit

In diesem Tutorial haben Sie verschiedene Datenstrukturen, Kontrollflussstatements, Funktionen, Module und Fehlerbehandlung in Python kennengelernt. Diese Konzepte sind entscheidend für den Aufbau von komplexeren und robusteren Python-Anwendungen. Denken Sie daran, zu üben und mit den bereitgestellten Beispielen zu experimentieren, um Ihr Verständnis dieser Themen zu festigen.

MoeNagy Dev