Skip to content

Python Pathlib: Der moderne Leitfaden zur Dateipfadbearbeitung

Soren Atelier
Name
Soren Atelier

Updated on

Wenn Sie jemals Python-Code wie os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'output') geschrieben haben, kennen Sie das Problem bereits. String-basierte Dateipfadmanipulation mit os.path ist umständlich, schwer lesbar und fehleranfällig. Sie verketten Strings und vergessen Trennzeichen. Sie hartkodieren / und das Skript bricht unter Windows zusammen. Sie verketten fünf os.path-Aufrufe, nur um den Stammnamen einer Datei zu erhalten, und drei Monate später kann niemand den Code lesen – einschließlich Ihnen selbst.

Dies sind keine Randfälle. Jede Data-Science-Pipeline, jede Webanwendung und jedes Automatisierungsskript greift auf das Dateisystem zu. Pfade, die auf Ihrem Mac funktionieren, scheitern auf dem Windows-Laptop eines Kollegen. Temporäre Pfadvariablen sammeln sich in Ihrem Code wie technische Schulden an. Und je mehr os.path.join(os.path.dirname(...))-Aufrufe Sie verschachteln, desto wahrscheinlicher ist es, dass Sie einen subtilen Bug einführen, der erst in der Produktion zum Vorschein kommt.

Pythons pathlib-Modul löst dies. Eingeführt in Python 3.4 und seit Python 3.6 vollständig ausgereift, ersetzt pathlib string-basierte Pfadmanipulation durch ordentliche Path-Objekte. Pfade werden mit dem /-Operator verbunden. Dateiattribute wie .name, .suffix und .stem sind Eigenschaften, keine Funktionsaufrufe. Das Lesen und Schreiben von Dateien erfolgt in einer Zeile. Und alles funktioniert plattformübergreifend identisch. Dieser Leitfaden behandelt alle wesentlichen pathlib-Funktionen, von der grundlegenden Pfaderstellung bis hin zu fortgeschrittenen Mustern für Data-Science-Workflows.

📚

    Warum pathlib statt os.path

    Vor pathlib verließen sich Python-Entwickler auf os.path für Pfadoperationen und auf os für Dateisysteminteraktionen. Dieser Ansatz funktioniert, behandelt Pfade aber als einfache Strings. Dies führt zu drei dauerhaften Problemen:

    1. Lesbarkeit verschlechtert sich schnell. Vergleichen Sie os.path.splitext(os.path.basename(filepath))[0] mit Path(filepath).stem. Beide extrahieren den Dateinamen ohne Erweiterung. Eines ist selbsterklärend; das andere erfordert mentales Parsen.

    2. Plattformübergreifende Bugs. Hartkodierte / als Trennzeichen oder die Verwendung von String-Verkettung bedeuten, dass Ihr Linux-Skript unter Windows stillschweigend abstürzt. os.path.join hilft, aber es auch nur einmal zu vergessen, erzeugt einen latenten Bug.

    3. Zerstreute Funktionalität. Um mit Pfaden zu arbeiten, benötigen Sie os.path für Dekomposition, os für Verzeichniserstellung, glob für Mustervergleich und open() für Datei-Ein-/Ausgabe. pathlib konsolidiert all dies in einem einzigen Path-Objekt.

    Hier ist dieselbe Aufgabe – finde alle .csv-Dateien in einem Datenverzeichnis und lies die erste – in beiden Stilen:

    # os.path-Ansatz
import os
import glob
 
data_dir = os.path.join(os.path.expanduser('~'), 'projects', 'data')
csv_files = glob.glob(os.path.join(data_dir, '**', '*.csv'), recursive=True)
if csv_files:
    with open(csv_files[0], 'r') as f:
        content = f.read()
    # pathlib-Ansatz
from pathlib import Path
 
data_dir = Path.home() / 'projects' / 'data'
csv_files = list(data_dir.rglob('*.csv'))
if csv_files:
    content = csv_files[0].read_text()

    Die pathlib-Version ist kürzer, einfacher zu lesen und macht genau dasselbe. Keine Imports über Path hinaus. Keine String-Verkettung. Kein separater open()-Aufruf.

    Erstellen von Path-Objekten

    Jede pathlib-Operation beginnt mit der Erstellung eines Path-Objekts. Die Path-Klasse gibt automatisch ein PosixPath unter Linux/macOS oder ein WindowsPath unter Windows zurück.

    from pathlib import Path
 
# Aus einem String
p = Path('/home/user/documents/report.csv')
 
# Aus mehreren Segmenten (automatisch verbunden)
p = Path('home', 'user', 'documents', 'report.csv')
 
# Aktuelles Arbeitsverzeichnis
cwd = Path.cwd()
print(cwd)  # z.B., /home/user/projects/myapp
 
# Benutzerverzeichnis
home = Path.home()
print(home)  # z.B., /home/user
 
# Relativer Pfad
p = Path('data/output/results.csv')
 
# Aus einem bestehenden Pfad
base = Path('/home/user')
full = Path(base, 'documents', 'file.txt')
print(full)  # /home/user/documents/file.txt

    Path() ohne Argumente gibt Path('.') zurück, einen relativen Pfad zum aktuellen Verzeichnis. Verwenden Sie Path.cwd(), wenn Sie das absolute aktuelle Verzeichnis benötigen.

    Verknüpfen von Pfaden mit dem /-Operator

    Das markanteste Merkmal von pathlib ist der überladene /-Operator. Statt os.path.join() verketten Sie Pfadsegmente mit /:

    from pathlib import Path
 
# Pfade natürlich aufbauen
project = Path.home() / 'projects' / 'analysis'
data_file = project / 'data' / 'sales_2026.csv'
print(data_file)  # /home/user/projects/analysis/data/sales_2026.csv
 
# Path-Objekte und Strings mischen
base = Path('/var/log')
app_log = base / 'myapp' / 'error.log'
print(app_log)  # /var/log/myapp/error.log
 
# Mit Variablen kombinieren
filename = 'report.pdf'
output = Path('output') / filename
print(output)  # output/report.pdf

    Der /-Operator behandelt Trennzeichen automatisch. Unter Windows erzeugt Path('C:/Users') / 'data' C:\Users\data. Sie müssen nie wieder über / vs \ nachdenken.

    Sie können auch joinpath() für dasselbe Ergebnis verwenden:

    from pathlib import Path
 
# Äquivalent zu Path('data') / 'raw' / 'file.csv'
p = Path('data').joinpath('raw', 'file.csv')
print(p)  # data/raw/file.csv

    Pfadkomponenten

    Jedes Path-Objekt macht seine Komponenten als Eigenschaften verfügbar. Keine Funktionsaufrufe, kein String-Splitting.

    from pathlib import Path
 
p = Path('/home/user/projects/analysis/data/sales_report.final.csv')
 
print(p.name)       # sales_report.final.csv  (Dateiname mit Erweiterung)
print(p.stem)       # sales_report.final      (Dateiname ohne letzte Erweiterung)
print(p.suffix)     # .csv                    (letzte Erweiterung)
print(p.suffixes)   # ['.final', '.csv']      (alle Erweiterungen)
print(p.parent)     # /home/user/projects/analysis/data
print(p.anchor)     # /                       (Wurzel unter Unix, C:\ unter Windows)
print(p.parts)      # ('/', 'home', 'user', 'projects', 'analysis', 'data', 'sales_report.final.csv')

    Navigation durch übergeordnete Verzeichnisse

    Die .parent-Eigenschaft gibt das unmittelbar übergeordnete Verzeichnis zurück. Verketten Sie es, um höher zu gelangen:

    from pathlib import Path
 
p = Path('/home/user/projects/analysis/data/output.csv')
 
print(p.parent)            # /home/user/projects/analysis/data
print(p.parent.parent)     # /home/user/projects/analysis
print(p.parent.parent.parent)  # /home/user/projects
 
# .parents gibt indexierten Zugriff auf alle Vorfahren
print(p.parents[0])  # /home/user/projects/analysis/data
print(p.parents[1])  # /home/user/projects/analysis
print(p.parents[2])  # /home/user/projects
print(p.parents[3])  # /home/user

    Ändern von Pfadkomponenten

    Verwenden Sie .with_name(), .with_stem() und .with_suffix(), um neue Pfade mit modifizierten Komponenten zu erstellen:

    from pathlib import Path
 
p = Path('/data/reports/sales_q1.csv')
 
# Den Dateinamen vollständig ändern
print(p.with_name('revenue_q1.csv'))    # /data/reports/revenue_q1.csv
 
# Nur den Stamm ändern (Python 3.9+)
print(p.with_stem('sales_q2'))          # /data/reports/sales_q2.csv
 
# Nur die Erweiterung ändern
print(p.with_suffix('.parquet'))        # /data/reports/sales_q1.parquet
 
# Die Erweiterung entfernen
print(p.with_suffix(''))                # /data/reports/sales_q1
 
# Eine Erweiterung hinzufügen
backup = p.with_suffix(p.suffix + '.bak')
print(backup)                           # /data/reports/sales_q1.csv.bak

    Diese Methoden geben neue Path-Objekte zurück. Sie benennen Dateien auf der Festplatte nicht um.

    Datei-Ein-/Ausgabe: Lesen und Schreiben

    pathlib eliminiert das open() / with-Boilerplate für einfache Dateioperationen:

    from pathlib import Path
 
file_path = Path('example.txt')
 
# Text in eine Datei schreiben (erstellt, falls nicht existiert, überschreibt, falls existiert)
file_path.write_text('Hello, pathlib!\nSecond line.')
 
# Text aus einer Datei lesen
content = file_path.read_text()
print(content)
# Hello, pathlib!
# Second line.
 
# Bytes schreiben
binary_path = Path('data.bin')
binary_path.write_bytes(b'\x00\x01\x02\x03')
 
# Bytes lesen
raw = binary_path.read_bytes()
print(raw)  # b'\x00\x01\x02\x03'

    Geben Sie bei der Arbeit mit Nicht-ASCII-Text explizit die Kodierung an:

    from pathlib import Path
 
# UTF-8-Text schreiben
Path('greeting.txt').write_text('こんにちは世界', encoding='utf-8')
 
# Mit Kodierung lesen
text = Path('greeting.txt').read_text(encoding='utf-8')
print(text)  # こんにちは世界

    Für große Dateien oder Streaming-Operationen verwenden Sie .open(), das einen Dateihandle genau wie das eingebaute open() zurückgibt:

    from pathlib import Path
 
log_file = Path('application.log')
 
# Zeile für Zeile schreiben
with log_file.open('w') as f:
    for i in range(1000):
        f.write(f'Event {i}: processed\n')
 
# Zeile für Zeile lesen (speichereffizient für große Dateien)
with log_file.open('r') as f:
    for line in f:
        if 'error' in line.lower():
            print(line.strip())

    Verzeichnisoperationen

    Erstellen von Verzeichnissen

    from pathlib import Path
 
# Ein einzelnes Verzeichnis erstellen
Path('output').mkdir()
 
# Mit übergeordneten Verzeichnissen (wie os.makedirs)
Path('data/raw/2026/february').mkdir(parents=True, exist_ok=True)
 
# parents=True erstellt alle fehlenden übergeordneten Verzeichnisse
# exist_ok=True verhindert Fehler, wenn das Verzeichnis bereits existiert

    Ein häufiger Fehler ist das Vergessen von parents=True. Ohne dieses wirft mkdir() einen FileNotFoundError, wenn ein übergeordnetes Verzeichnis fehlt. Verwenden Sie immer parents=True, wenn Sie verschachtelte Verzeichnisse erstellen, und exist_ok=True, um die Operation idempotent zu machen.

    Auflisten von Verzeichnisinhalten

    from pathlib import Path
 
project = Path('.')
 
# Alle Einträge auflisten (Dateien und Verzeichnisse)
for entry in project.iterdir():
    print(entry.name, '(dir)' if entry.is_dir() else '(file)')
 
# Nur auf Dateien filtern
files = [f for f in project.iterdir() if f.is_file()]
print(f"Found {len(files)} files")
 
# Nur auf Verzeichnisse filtern
dirs = [d for d in project.iterdir() if d.is_dir()]
print(f"Found {len(dirs)} directories")
 
# Nach Name sortieren
for entry in sorted(project.iterdir()):
    print(entry.name)

    Entfernen von Verzeichnissen und Dateien

    from pathlib import Path
 
# Eine Datei entfernen
Path('temp_output.csv').unlink()
 
# Eine Datei nur entfernen, wenn sie existiert (Python 3.8+)
Path('temp_output.csv').unlink(missing_ok=True)
 
# Ein leeres Verzeichnis entfernen
Path('empty_dir').rmdir()

    rmdir() entfernt nur leere Verzeichnisse. Für nicht-leere Verzeichnisse verwenden Sie shutil.rmtree():

    from pathlib import Path
import shutil
 
target = Path('data/old_output')
if target.exists():
    shutil.rmtree(target)

    Glob-Muster: Dateien finden

    pathlib hat eingebaute Glob-Unterstützung. Kein separater Import des glob-Moduls nötig.

    Basis-Glob

    from pathlib import Path
 
project = Path('/home/user/project')
 
# Alle Python-Dateien in einem Verzeichnis finden
for py_file in project.glob('*.py'):
    print(py_file.name)
 
# Alle CSV-Dateien finden
csv_files = list(project.glob('*.csv'))
print(f"Found {len(csv_files)} CSV files")
 
# Dateien finden, die einem Muster entsprechen
reports = list(project.glob('report_*.xlsx'))

    Rekursiver Glob mit rglob

    rglob() durchsucht rekursiv alle Unterverzeichnisse. Es ist äquivalent zu glob('**/*.pattern'), aber bequemer:

    from pathlib import Path
 
project = Path('/home/user/project')
 
# Alle Python-Dateien in allen Unterverzeichnissen finden
all_py = list(project.rglob('*.py'))
print(f"Found {len(all_py)} Python files across all directories")
 
# Alle Jupyter-Notebooks rekursiv finden
notebooks = list(project.rglob('*.ipynb'))
for nb in notebooks:
    print(f"  {nb.relative_to(project)}")
 
# Alle Bilddateien finden
images = list(project.rglob('*.png')) + list(project.rglob('*.jpg'))
 
# Alle Dateien (kein Filter)
all_files = [f for f in project.rglob('*') if f.is_file()]

    Erweiterte Glob-Muster

    from pathlib import Path
 
data = Path('data')
 
# Einzelnes Zeichen als Platzhalter
data.glob('file_?.csv')        # file_1.csv, file_a.csv
 
# Zeichenbereiche
data.glob('report_202[456].csv')  # report_2024.csv, report_2025.csv, report_2026.csv
 
# Beliebige Unterverzeichnisebene
data.glob('**/output/*.csv')   # data/raw/output/result.csv, data/processed/output/result.csv
 
# Mehrere Erweiterungen (zwei Globs kombinieren)
from itertools import chain
all_data = chain(data.rglob('*.csv'), data.rglob('*.parquet'))

    Pfadüberprüfung

    pathlib bietet klare, boolesche Methoden zur Pfadstatusprüfung:

    from pathlib import Path
 
p = Path('/home/user/projects/data.csv')
 
# Existiert der Pfad?
print(p.exists())       # True oder False
 
# Ist es eine Datei?
print(p.is_file())      # True, wenn existiert und eine reguläre Datei ist
 
# Ist es ein Verzeichnis?
print(p.is_dir())       # True, wenn existiert und ein Verzeichnis ist
 
# Ist es ein symbolischer Link?
print(p.is_symlink())   # True, wenn existiert und ein Symlink ist
 
# Ist es ein absoluter Pfad?
print(p.is_absolute())  # True (/home/... beginnt mit Wurzel)
print(Path('data.csv').is_absolute())  # False (relativer Pfad)

    Diese Methoden werfen niemals Ausnahmen für nicht-existente Pfade. Sie geben einfach False zurück, was sie sicher für Bedingungen macht:

    from pathlib import Path
 
config = Path('config.yaml')
if config.is_file():
    settings = config.read_text()
else:
    print("Config file not found, using defaults")

    Pfadmanipulation

    Auflösen und Normalisieren von Pfaden

    from pathlib import Path
 
# In absoluten Pfad auflösen (löst auch Symlinks auf)
p = Path('data/../data/./output.csv')
print(p.resolve())  # /home/user/project/data/output.csv
 
# Absoluten Pfad ohne Auflösen von Symlinks erhalten
print(p.absolute())  # /home/user/project/data/../data/./output.csv
 
# Benutzerverzeichnis erweitern
p = Path('~/Documents/report.csv')
print(p.expanduser())  # /home/user/Documents/report.csv

    Relative Pfade

    from pathlib import Path
 
full_path = Path('/home/user/projects/analysis/data/output.csv')
base = Path('/home/user/projects')
 
# Den relativen Pfad von base zu full_path erhalten
relative = full_path.relative_to(base)
print(relative)  # analysis/data/output.csv
 
# Dies wirft ValueError, wenn der Pfad nicht relativ zur Basis ist
try:
    Path('/var/log/app.log').relative_to(base)
except ValueError as e:
    print(e)  # '/var/log/app.log' is not relative to '/home/user/projects'
 
# Python 3.12+: is_relative_to() Prüfung
print(full_path.is_relative_to(base))   # True
print(Path('/var/log').is_relative_to(base))  # False

    Dateimetadaten und Stat

    from pathlib import Path
from datetime import datetime
 
p = Path('data.csv')
 
# Dateistatistik erhalten
stat = p.stat()
print(f"Size: {stat.st_size} bytes")
print(f"Modified: {datetime.fromtimestamp(stat.st_mtime)}")
print(f"Created: {datetime.fromtimestamp(stat.st_ctime)}")
 
# Bequem: Größe direkt erhalten (über stat)
size_mb = p.stat().st_size / (1024 * 1024)
print(f"Size: {size_mb:.2f} MB")
 
# Prüfen, ob zwei Pfade auf dieselbe Datei zeigen
p1 = Path('/home/user/data.csv')
p2 = Path.home() / 'data.csv'
print(p1.samefile(p2))  # True (wenn sie zur selben Datei auflösen)

    Umbenennen und Verschieben von Dateien

    from pathlib import Path
 
# Eine Datei umbenennen (gibt den neuen Pfad zurück)
old = Path('report_draft.csv')
new = old.rename('report_final.csv')
print(new)  # report_final.csv
 
# In ein anderes Verzeichnis verschieben
source = Path('output/temp_results.csv')
dest = source.rename(Path('archive') / source.name)
 
# Eine Datei ersetzen (überschreibt, wenn Ziel existiert)
Path('new_data.csv').replace('data.csv')

    Hinweis: .rename() überschreibt die Zieldatei unter Unix, kann aber unter Windows einen Fehler auslösen. Verwenden Sie .replace() für garantiertes plattformübergreifendes Überschreibverhalten.

    os.path vs pathlib: Vollständiger Vergleich

    Hier ist eine Referenztabelle, die jede gängige os.path-Operation mit ihrem pathlib-Äquivalent abgleicht:

    Operationos.path / ospathlib
    Pfade verknüpfenos.path.join('a', 'b')Path('a') / 'b'
    Aktuelles Verzeichnisos.getcwd()Path.cwd()
    Heimatverzeichnisos.path.expanduser('~')Path.home()
    Absoluter Pfados.path.abspath(p)Path(p).resolve()
    Dateinameos.path.basename(p)Path(p).name
    Verzeichnisos.path.dirname(p)Path(p).parent
    Erweiterungos.path.splitext(p)[1]Path(p).suffix
    Stamm (Name ohne Ext)os.path.splitext(os.path.basename(p))[0]Path(p).stem
    Existiertos.path.exists(p)Path(p).exists()
    Ist Dateios.path.isfile(p)Path(p).is_file()
    Ist Verzeichnisos.path.isdir(p)Path(p).is_dir()
    Ist Symlinkos.path.islink(p)Path(p).is_symlink()
    Ist absolutos.path.isabs(p)Path(p).is_absolute()
    Dateigrößeos.path.getsize(p)Path(p).stat().st_size
    Verzeichnis auflistenos.listdir(p)Path(p).iterdir()
    Verzeichnis erstellenos.makedirs(p, exist_ok=True)Path(p).mkdir(parents=True, exist_ok=True)
    Datei entfernenos.remove(p)Path(p).unlink()
    Verzeichnis entfernenos.rmdir(p)Path(p).rmdir()
    Umbenennenos.rename(old, new)Path(old).rename(new)
    Datei lesenopen(p).read()Path(p).read_text()
    Datei schreibenopen(p, 'w').write(text)Path(p).write_text(text)
    Globglob.glob('*.py')Path('.').glob('*.py')
    Rekursiver Globglob.glob('**/*.py', recursive=True)Path('.').rglob('*.py')
    Benutzer erweiternos.path.expanduser(p)Path(p).expanduser()
    Relativer Pfados.path.relpath(p, base)Path(p).relative_to(base)

    Arbeiten mit temporären Dateien

    pathlib integriert sich sauber mit Pythons tempfile-Modul:

    from pathlib import Path
import tempfile
 
# Ein temporäres Verzeichnis als Path erstellen
with tempfile.TemporaryDirectory() as tmp_dir:
    tmp_path = Path(tmp_dir)
 
    # Temporäre Dateien mit pathlib schreiben
    data_file = tmp_path / 'intermediate_results.csv'
    data_file.write_text('col1,col2\n1,2\n3,4\n')
 
    config_file = tmp_path / 'run_config.json'
    config_file.write_text('{"epochs": 100, "lr": 0.001}')
 
    # Auflisten, was wir erstellt haben
    for f in tmp_path.iterdir():
        print(f"{f.name}: {f.stat().st_size} bytes")
 
    # Dateien verarbeiten...
    print(data_file.read_text())
 
# Verzeichnis und alle Dateien werden hier automatisch gelöscht
    from pathlib import Path
import tempfile
 
# Eine benannte temporäre Datei erstellen
tmp = tempfile.NamedTemporaryFile(suffix='.csv', delete=False)
tmp_path = Path(tmp.name)
tmp.close()
 
# Mit pathlib hineinschreiben
tmp_path.write_text('id,value\n1,100\n2,200\n')
print(f"Temp file at: {tmp_path}")
 
# Aufräumen, wenn fertig
tmp_path.unlink()

    Pathlib in Data-Science-Workflows

    Data-Science-Projekte beinhalten typischerweise das Lesen von Datensätzen aus mehreren Verzeichnissen, das Erstellen von Ausgabeordnern für Ergebnisse und die Verwaltung von Experimentartefakten. pathlib macht diese Muster sauber und zuverlässig.

    Organisieren von Projektverzeichnissen

    from pathlib import Path
 
def setup_experiment(experiment_name):
    """Create a standard experiment directory structure."""
    base = Path('experiments') / experiment_name
 
    dirs = ['data/raw', 'data/processed', 'models', 'results/figures', 'results/tables', 'logs']
 
    for d in dirs:
        (base / d).mkdir(parents=True, exist_ok=True)
 
    # Create a config file
    config = base / 'config.json'
    if not config.exists():
        config.write_text('{"learning_rate": 0.001, "epochs": 50}')
 
    print(f"Experiment directory ready: {base.resolve()}")
    return base
 
project = setup_experiment('sales_forecast_v2')

    Lesen mehrerer Datendateien

    from pathlib import Path
import pandas as pd
 
data_dir = Path('data/raw')
 
# Read all CSV files into a single DataFrame
dfs = []
for csv_file in sorted(data_dir.glob('*.csv')):
    print(f"Loading {csv_file.name}...")
    df = pd.read_csv(csv_file)
    df['source_file'] = csv_file.stem  # Add source filename
    dfs.append(df)
 
combined = pd.concat(dfs, ignore_index=True)
print(f"Loaded {len(combined)} rows from {len(dfs)} files")
 
# Save to processed directory
output_path = Path('data/processed') / 'combined_sales.parquet'
output_path.parent.mkdir(parents=True, exist_ok=True)
combined.to_parquet(output_path)

    Nachdem Sie Ihre CSV-Daten mit pathlib geladen haben, können Sie sie visuell mit PyGWalker (opens in a new tab) erkunden. Es verwandelt jeden Pandas DataFrame in eine Tableau-ähnliche interaktive Oberfläche für Drag-and-Drop-Datenexploration – ohne zusätzlichen Code.

    Speichern von Experiment-Ergebnissen

    from pathlib import Path
from datetime import datetime
import json
 
def save_results(metrics, experiment_dir):
    """Save experiment metrics with timestamp."""
    results_dir = Path(experiment_dir) / 'results'
    results_dir.mkdir(parents=True, exist_ok=True)
 
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    output_file = results_dir / f'metrics_{timestamp}.json'
 
    output_file.write_text(json.dumps(metrics, indent=2))
    print(f"Results saved to {output_file}")
    return output_file
 
# Usage
metrics = {'accuracy': 0.94, 'f1_score': 0.91, 'loss': 0.187}
save_results(metrics, 'experiments/sales_forecast_v2')

    Verwalten von Dateipfaden in Notebooks

    Bei der Arbeit in Jupyter Notebooks brechen Pfade oft, weil das Arbeitsverzeichnis des Notebooks vom Projektstamm abweichen kann. pathlib macht dies einfach zu handhaben:

    from pathlib import Path
 
# Always resolve to absolute path from the notebook location
NOTEBOOK_DIR = Path.cwd()
PROJECT_ROOT = NOTEBOOK_DIR.parent  # if notebook is in notebooks/
DATA_DIR = PROJECT_ROOT / 'data'
OUTPUT_DIR = PROJECT_ROOT / 'output'
 
# Now all paths are absolute and reliable
train_data = DATA_DIR / 'train.csv'
print(f"Loading: {train_data}")
assert train_data.exists(), f"Missing: {train_data}"

    Wenn Sie intensiv in Jupyter arbeiten und eine KI-gestützte Umgebung wünschen, die beim Verwalten von Projektdateien und Datenpfaden hilft, fügt RunCell (opens in a new tab) eine KI-Agent-Ebene zu Ihrem Notebook hinzu. Beschreiben Sie, was Sie brauchen – "finde alle Parquet-Dateien im Datenverzeichnis und lade die neueste" – und es generiert den pathlib-Code und führt ihn für Sie aus.

    Häufige Muster und Rezepte

    Sicheres Dateischreiben mit atomarer Ersetzung

    Verhindern Sie Datenkorruption, indem Sie zuerst in eine temporäre Datei schreiben und dann atomar das Ziel ersetzen:

    from pathlib import Path
import tempfile
 
def safe_write(target_path, content):
    """Write content to file atomically to prevent corruption."""
    target = Path(target_path)
    target.parent.mkdir(parents=True, exist_ok=True)
 
    # Write to temp file in the same directory
    tmp = tempfile.NamedTemporaryFile(
        mode='w', dir=target.parent, suffix='.tmp', delete=False
    )
    tmp_path = Path(tmp.name)
    try:
        tmp.write(content)
        tmp.close()
        tmp_path.replace(target)  # Atomic on most file systems
    except Exception:
        tmp_path.unlink(missing_ok=True)
        raise
 
safe_write('config/settings.json', '{"debug": true}')

    Stapelweise Dateiumbenennung

    from pathlib import Path
 
photos_dir = Path('photos')
 
# Rename all .jpeg files to .jpg
for f in photos_dir.glob('*.jpeg'):
    f.rename(f.with_suffix('.jpg'))
 
# Add prefix to all files
for i, f in enumerate(sorted(photos_dir.glob('*.jpg')), start=1):
    new_name = f.parent / f'photo_{i:04d}{f.suffix}'
    f.rename(new_name)

    Finden von Duplikatdateien nach Größe

    from pathlib import Path
from collections import defaultdict
 
def find_potential_duplicates(directory):
    """Find files with identical sizes (potential duplicates)."""
    size_map = defaultdict(list)
 
    for f in Path(directory).rglob('*'):
        if f.is_file():
            size_map[f.stat().st_size].append(f)
 
    # Return only groups with more than one file
    return {size: files for size, files in size_map.items() if len(files) > 1}
 
dupes = find_potential_duplicates('data')
for size, files in dupes.items():
    print(f"\n{size} bytes:")
    for f in files:
        print(f"  {f}")

    Erstellen einer Dateibaum-Visualisierung

    from pathlib import Path
 
def tree(directory, prefix='', max_depth=3, _depth=0):
    """Print a tree structure of a directory."""
    if _depth >= max_depth:
        return
 
    path = Path(directory)
    entries = sorted(path.iterdir(), key=lambda e: (e.is_file(), e.name))
 
    for i, entry in enumerate(entries):
        is_last = (i == len(entries) - 1)
        connector = '└── ' if is_last else '├── '
        print(f'{prefix}{connector}{entry.name}')
 
        if entry.is_dir():
            extension = '    ' if is_last else '│   '
            tree(entry, prefix + extension, max_depth, _depth + 1)
 
tree('my_project', max_depth=3)

    Ausgabe:

    ├── data
│   ├── processed
│   │   └── combined.csv
│   └── raw
│       ├── sales_2025.csv
│       └── sales_2026.csv
├── notebooks
│   └── analysis.ipynb
├── output
│   └── figures
└── requirements.txt

    Häufige Fehler und wie man sie vermeidet

    Fehler 1: Vergleichen von Strings mit Path-Objekten

    from pathlib import Path
 
p = Path('data/output.csv')
 
# WRONG: Comparing string to Path
if p == 'data/output.csv':  # May work but fragile
    print("Match")
 
# RIGHT: Compare Path to Path, or use str()
if p == Path('data/output.csv'):
    print("Match")
 
# RIGHT: Convert to string if needed
if str(p) == 'data/output.csv':
    print("Match")

    Fehler 2: Vergessen von parents=True in mkdir

    from pathlib import Path
 
# WRONG: Raises FileNotFoundError if 'data' doesn't exist
# Path('data/raw/2026').mkdir()
 
# RIGHT: Create all missing parents
Path('data/raw/2026').mkdir(parents=True, exist_ok=True)

    Fehler 3: Verwendung von String-Verkettung statt /

    from pathlib import Path
 
base = Path('/home/user')
 
# WRONG: String concatenation breaks pathlib
# bad = base + '/data/file.csv'  # TypeError
 
# RIGHT: Use the / operator
good = base / 'data' / 'file.csv'

    Fehler 4: Übergeben von Path an Bibliotheken, die Strings erwarten

    Die meisten modernen Bibliotheken (Pandas, NumPy, PIL, etc.) akzeptieren Path-Objekte nativ. Aber wenn Sie auf eine ältere Bibliothek stoßen, die Strings benötigt, konvertieren Sie explizit:

    from pathlib import Path
 
p = Path('data/output.csv')
 
# Most libraries accept Path directly
import pandas as pd
df = pd.read_csv(p)  # Works fine
 
# For older libraries that need strings
import some_legacy_lib
some_legacy_lib.process(str(p))  # Convert with str()
 
# os.fspath() also works (Python 3.6+)
import os
some_legacy_lib.process(os.fspath(p))

    Fehler 5: Verwendung von hartkodierten Pfaden

    from pathlib import Path
 
# WRONG: Hardcoded absolute path
# data_path = Path('/home/alice/project/data/sales.csv')
 
# RIGHT: Build from relative or dynamic components
data_path = Path.cwd() / 'data' / 'sales.csv'
 
# RIGHT: Build from home directory
config_path = Path.home() / '.config' / 'myapp' / 'settings.json'
 
# RIGHT: Build from environment variable
import os
data_root = Path(os.getenv('DATA_DIR', 'data'))
data_path = data_root / 'sales.csv'

    Häufig gestellte Fragen

    Was ist pathlib in Python?

    pathlib ist ein Standardbibliotheksmodul (eingeführt in Python 3.4), das objektorientierte Klassen für die Arbeit mit Dateisystempfaden bereitstellt. Statt Pfade als Strings zu behandeln und Funktionen wie os.path.join() zu verwenden, erstellen Sie Path-Objekte und verwenden Methoden und Operatoren. Es behandelt plattformübergreifende Pfadunterschiede automatisch.

    Wann sollte ich pathlib statt os.path verwenden?

    Verwenden Sie pathlib für alle neuen Python 3.6+ Projekte. Es produziert saubereren, lesbareren Code, konsolidiert Pfadoperationen in einem einzigen Objekt und behandelt plattformübergreifende Probleme automatisch. Der einzige Grund, os.path zu verwenden, ist die Wartung von Legacy-Code, der Python 2 unterstützen muss, oder die Verwendung der wenigen os-Funktionen, die kein pathlib-Äquivalent haben (wie os.environ für Umgebungsvariablen).

    Funktioniert pathlib unter Windows?

    Ja. pathlib verwendet automatisch WindowsPath-Objekte unter Windows und PosixPath unter Linux/macOS. Der /-Operator erzeugt unter Windows Pfade mit Backslash-Slashes. Sie schreiben denselben Code auf allen Plattformen und pathlib behandelt die Unterschiede.

    Kann ich Path-Objekte mit Pandas verwenden?

    Ja. Seit Python 3.6 und Pandas 0.21+ können Sie Path-Objekte direkt an pd.read_csv(), pd.read_excel(), df.to_csv() und andere I/O-Funktionen übergeben. Keine str()-Konvertierung nötig.

    Was ist der Unterschied zwischen Path.resolve() und Path.absolute()?

    .resolve() gibt den absoluten Pfad zurück und löst auch symbolische Links und ../.-Komponenten auf. .absolute() gibt den absoluten Pfad zurück, ohne Symlinks zu lösen oder den Pfad zu normalisieren. In den meisten Fällen wollen Sie .resolve().

    Wie konvertiere ich zwischen Path-Objekten und Strings?

    Verwenden Sie str(path), um einen Path in einen String zu konvertieren. Verwenden Sie Path(string), um einen Path aus einem String zu erstellen. Sie können auch os.fspath(path) für explizite String-Konvertierung verwenden. Die meisten modernen Python-Bibliotheken akzeptieren Path-Objekte direkt, daher ist Konvertierung selten nötig.

    Fazit

    Pythons pathlib-Modul ist der moderne Standard für Dateipfadmanipulation. Der /-Operator macht Pfadverknüpfung lesbar. Eigenschaften wie .name, .stem, .suffix und .parent eliminieren umständliche os.path-Funktionsketten. Eingebaute Methoden zum Lesen, Schreiben, Erstellen von Verzeichnissen und Globbing konsolidieren das, was früher os, os.path, glob und open() erforderte, in einer einzigen, konsistenten API.

    Die Migration von os.path zu pathlib ist unkompliziert: Ersetzen Sie os.path.join() durch /, ersetzen Sie os.path.exists() durch .exists(), ersetzen Sie os.makedirs() durch .mkdir(parents=True) und ersetzen Sie glob.glob() durch .glob() oder .rglob(). Jede große Python-Bibliothek – Pandas, NumPy, PIL, PyTorch – akzeptiert jetzt nativ Path-Objekte. Es gibt keinen Grund, es in neuen Projekten zu vermeiden.

    Beginnen Sie klein. Wählen Sie ein Skript mit unübersichtlichem os.path-Code. Ersetzen Sie die Pfadoperationen durch pathlib. Der Code wird kürzer, lesbarer und portabler. Dann tun Sie dasselbe mit dem nächsten Skript.

    📚