Ein umfassender Leitfaden zur Verwendung von pathlib in Python für die Manipulation des Dateisystems

Bis vor kurzem war die Manipulation des Dateisystems in Python bekanntermaßen schwierig. Entwickler hatten oft mit falschen Dateipfaden zu kämpfen, die fehleranfällig waren, weil sie lange Zeichenketten als Eingabe benötigten. Außerdem berichteten die Entwickler, dass ihr Code aufgrund von Inkonsistenzen zwischen verschiedenen Betriebssystemen häufig nicht funktioniert.

Glücklicherweise haben die Entwickler von Python in Version 3.4 das Modul pathlib in die Standardbibliothek aufgenommen. pathlib bietet eine elegante Lösung für die Handhabung von Dateisystempfaden mit einem lang erwarteten objektorientierten Ansatz und gewährleistet zudem ein plattformunabhängiges Verhalten.

In diesem umfassenden Lernprogramm lernst du die Funktionen des Moduls pathlib kennen, die dich bei deiner täglichen Arbeit mit deinem Dateisystem unterstützen. Mit pathlib profitierst du von effizienten Arbeitsabläufen und einem einfachen Datenabruf. pathlib hat sich im Laufe der Jahre erheblich weiterentwickelt, und wir sind immer auf dem neuesten Stand, damit du das nicht tun musst. Lass uns loslegen.

Python os Module vs. pathlib

Vor Python 3.4 wurden Dateipfade traditionell mit dem Modul os behandelt. Während das Modul os einst sehr effektiv war, ist es mittlerweile in die Jahre gekommen.

Wir können den einzigartigen Wert von pathlib zeigen, indem wir eine häufige Aufgabe in der Datenwissenschaft betrachten: Wie findet man alle png Dateien innerhalb eines bestimmten Verzeichnisses und all seiner Unterverzeichnisse?

Wenn wir das Modul os verwenden würden, könnten wir den folgenden Code schreiben:

import os
dir_path = "/home/user/documents"
files = [
os.path.join(dir_path, f)
for f in os.listdir(dir_path)
if os.path.isfile(os.path.join(dir_path, f)) and f.endswith(".png")
]
Bereitgestellt von

Obwohl dieser Code die unmittelbare Aufgabe löst, unsere png Dateien zu finden, offenbart er einige große Nachteile des os Moduls. Zum einen ist der Code lang und fast unlesbar, was schade ist, wenn man bedenkt, dass es sich um einen relativ einfachen Vorgang handelt. Ein zweiter Punkt ist, dass unser Code die Kenntnis von List Comprehensions voraussetzt, was nicht als selbstverständlich vorausgesetzt werden sollte. Ein dritter Punkt ist, dass der Code String-Operationen beinhaltet, die fehleranfällig sind. Und obendrein ist der Code nicht sehr prägnant. 

Wenn wir stattdessen das Modul pathlib verwenden würden, wäre unser Code viel einfacher. Wie wir bereits erwähnt haben, bietet pathlib einen objektorientierten Ansatz für den Umgang mit Dateisystempfaden. Sieh es dir an:

from pathlib import Path

# Create a path object
dir_path = Path(dir_path)

# Find all text files inside a directory
files = list(dir_path.glob("*.png"))Bereitgestellt von

Diese objektorientierte Programmierung organisiert den Code rund um Objekte und ihre Interaktionen, was zu einem modulareren, wiederverwendbaren und wartbaren Code führt. Wenn du mit objektorientierter Programmierung nicht vertraut bist, lohnt es sich, sie in unseremKurs Objektorientierte Python-Programmierung zu lernen.

Arbeiten mit Pfadobjekten in Python

Die Bibliothek pathlib basiert auf sogenannten Path Objekten, die Dateisystempfade auf strukturierte und plattformunabhängige Weise darstellen.

Zu Beginn dieses Lehrgangs haben wir die Klasse Path aus dem Modul pathlib mit der folgenden Codezeile in unseren aktuellen Namespace gebracht:

from pathlib import PathBereitgestellt von

Nachdem wir die Klasse Path von pathlib aus aufgerufen haben, können wir Path Objekte auf verschiedene Arten erstellen, z. B. aus Strings, aus anderen Path Objekten, aus dem aktuellen Arbeitsverzeichnis und aus dem Home-Verzeichnis.

Schauen wir sie uns nacheinander an.

Pfadobjekte aus Strings erstellen

Wir können ein Path Objekt erstellen, indem wir einen String, der einen Dateisystempfad darstellt, an eine Variable übergeben. Dies wandelt die String-Repräsentation des Dateipfads in ein Path Objekt um.

file_path_str = "data/union_data.csv"

data_path = Path(file_path_str)Bereitgestellt von

Pfadobjekte aus anderen Pfadobjekten erstellen

Vorhandene Path Objekte können als Bausteine für die Erstellung neuer Pfade dienen. 

Dazu kombinieren wir einen Basispfad, ein Datenverzeichnis und einen Dateinamen zu einem einzigen Dateipfad. Wir müssen daran denken, einen Schrägstrich zu verwenden, um unsere Path Objekte zu erweitern.

base_path = Path("/home/user")
data_dir = Path("data")

# Combining multiple paths
file_path = base_path / data_dir / "prices.csv"  
print(file_path)
Bereitgestellt von

'/home/user/data/prices.csv'Bereitgestellt von

Pfadobjekte aus dem aktuellen Arbeitsverzeichnis erstellen

Hier weisen wir der Variablen cwd mit der Methode Path.cwd() das aktuelle Arbeitsverzeichnis zu. Wir können dann den Pfad des aktuellen Arbeitsverzeichnisses abfragen, in dem unser Skript läuft. 

cwd = Path.cwd()

print(cwd)Bereitgestellt von

'/home/bexgboost/articles/2024/4_april/8_pathlib'Bereitgestellt von

Pfadobjekte aus dem Hauptarbeitsverzeichnis erstellen

Wir können einen Pfad konstruieren, indem wir unser Heimatverzeichnis mit weiteren Unterverzeichnissen kombinieren. Hier kombinieren wir unser Home-Verzeichnis mit den Unterverzeichnissen "Downloads" und "Projekte". 

home = Path.home()

home / "downloads" / "projects"Bereitgestellt von

PosixPath('/home/bexgboost/downloads/projects')Bereitgestellt von

Ein wichtiger Hinweis: Die Klasse Path selbst führt keine Dateisystemoperationen durch, wie z. B. die Überprüfung von Pfaden, das Erstellen von Verzeichnissen oder Dateien. Sie wurde entwickelt, um Pfade darzustellen und zu manipulieren. Um tatsächlich mit dem Dateisystem zu interagieren (Existenz prüfen, Dateien lesen/schreiben), müssen wir spezielle Methoden der Path Objekte verwenden und für einige fortgeschrittene Fälle Hilfe vom os Modul erhalten.

Arbeiten mit Pfadkomponenten in Python

Dateipfadattribute sind verschiedene Eigenschaften und Komponenten eines Dateipfads, die bei der Identifizierung und Verwaltung von Dateien und Verzeichnissen in einem Dateisystem helfen. Genauso wie eine physische Adresse aus verschiedenen Teilen besteht, z. B. Straßennummer, Stadt, Land und Postleitzahl, kann ein Dateisystempfad in kleinere Komponenten unterteilt werden. pathlib ermöglicht es uns, auf diese Komponenten zuzugreifen und sie mit Hilfe von Pfadattributen in Punktnotation zu bearbeiten.

Arbeiten mit dem Stammverzeichnis

Die Wurzel ist das oberste Verzeichnis in einem Dateisystem. In Unix-ähnlichen Systemen wird es durch einen Schrägstrich (/) dargestellt. In Windows ist es normalerweise ein Laufwerksbuchstabe, gefolgt von einem Doppelpunkt, wie C:.

image_file = home / "downloads" / "midjourney.png"

image_file.rootBereitgestellt von

'/'Bereitgestellt von

Arbeiten mit dem übergeordneten Verzeichnis

Das Elternteil enthält die aktuelle Datei oder das aktuelle Verzeichnis. Es ist eine Ebene höher relativ zum aktuellen Verzeichnis oder zur aktuellen Datei. 

image_file.parentBereitgestellt von

PosixPath('/home/bexgboost/downloads')Bereitgestellt von

Arbeiten mit dem Dateinamen

Dieses Attribut gibt den gesamten Dateinamen, einschließlich der Erweiterung, als String zurück.

image_file.nameBereitgestellt von

'midjourney.png'Bereitgestellt von

Arbeiten mit dem Dateisuffix

Das Suffix-Attribut gibt die Dateierweiterung einschließlich des Punktes als String zurück (oder einen leeren String, wenn es keine Erweiterung gibt).

image_file.suffixBereitgestellt von

'.png'Bereitgestellt von

Arbeiten mit dem Feilenstamm

Der Stamm gibt den Dateinamen ohne die Erweiterung zurück. Die Arbeit mit dem Stamm kann beim Konvertieren von Dateien in verschiedene Formate nützlich sein.

image_file.stemBereitgestellt von

'midjourney'Bereitgestellt von

Hinweis: Auf einem Mac wird bei den Dateipfaden zwischen Groß- und Kleinschreibung unterschieden, so dass /Users/username/Documents und /users/username/documents anders aussehen würden. 

Das Attribut pathlib parts

Wir können das Attribut .parts verwenden, um ein Path Objekt in seine Komponenten zu zerlegen.

image_file.partsBereitgestellt von

('/', 'home', 'bexgboost', 'downloads', 'midjourney.png')Bereitgestellt von

Das Attribut pathlib parents

Das Attribut parents, das einen Generator liefert, verwandelt diese Komponenten in Path Objekte. 

list(image_file.parents)Bereitgestellt von

[PosixPath('/home/bexgboost/downloads'),
PosixPath('/home/bexgboost'),
PosixPath('/home'),
PosixPath('/')]Bereitgestellt von

Gemeinsame Pfadoperationen mit pathlib

Path Objekte haben viele Methoden, mit denen du effizient mit Verzeichnissen und ihren Inhalten arbeiten kannst. Schauen wir uns an, wie man einige der häufigsten Vorgänge durchführt.

Verzeichnis der Verzeichnisse

Mit der Methode iterdir() kannst du alle Dateien und Unterverzeichnisse in einem Ordner durchsuchen. Sie ist besonders nützlich, um alle Dateien in einem Verzeichnis zu bearbeiten oder Operationen an jedem einzelnen Eintrag durchzuführen.

cwd = Path.cwd()Bereitgestellt von

 for entry in cwd.iterdir():
# Process the entry here
...
# print(entry)Bereitgestellt von

Da iterdir() einen Iterator zurückgibt, werden die Einträge bei Bedarf abgerufen, während du die Schleife durchläufst.

Die Methode is_dir()

Die Methode is_dir() gibt True zurück, wenn der Pfad auf ein Verzeichnis zeigt, ansonsten False.

for entry in cwd.iterdir():
   if entry.is_dir():
      print(entry.name)Bereitgestellt von

.ipynb_checkpoints
data
imagesBereitgestellt von

Die Methode is_file()

Die Methode .is_file() gibt True zurück, wenn der Pfad auf eine Datei zeigt, ansonsten False.

for entry in cwd.iterdir():
   if entry.is_file():
      print(entry.suffix)Bereitgestellt von

.ipynb
.txtBereitgestellt von

Die Methode exists()

Da Path Objekte nur Pfade darstellen, musst du manchmal mit der Methode .exists() überprüfen, ob ein Pfad existiert:

Die Methode .exists() prüft, ob ein Pfad existiert. Das ist nützlich, weil Path Objekte Dateien und Verzeichnisse repräsentieren können, die im Dateisystem vorhanden sein können oder auch nicht.

image_file.exists()Bereitgestellt von

FalseBereitgestellt von

Pfade erstellen und löschen

pathlib bietet auch Funktionen zum Erstellen und Löschen von Dateien und Verzeichnissen. Lass uns sehen, wie.

Die Methode mkdir()

Die Methode mkdir() erstellt ein neues Verzeichnis unter dem angegebenen Pfad. Standardmäßig wird das Verzeichnis im aktuellen Arbeitsverzeichnis erstellt.

from pathlib import Path

data_dir = Path("new_data_dir")

# Create the directory 'new_data_dir' in the current working directory
data_dir.mkdir()Bereitgestellt von

Die Methode mkdir(parents=True)

Die Methode mkdir(parents=True) ist besonders nützlich, wenn du eine Verzeichnisstruktur erstellen willst, in der einige übergeordnete Verzeichnisse nicht existieren. Die Einstellung parents=True stellt sicher, dass alle notwendigen übergeordneten Verzeichnisse auf dem Weg erstellt werden.

sub_dir = Path("data/nested/subdirectory")

# Create 'data/nested/subdirectory', even if 'data' or 'nested' don't exist
sub_dir.mkdir(parents=True)
Bereitgestellt von

Beachte, dass mkdir() eine Ausnahme auslöst, wenn bereits ein Verzeichnis mit demselben Namen existiert.

Path('data').mkdir()Bereitgestellt von

FileExistsError: [Errno 17] File exists: 'data'Bereitgestellt von

Die Methode unlink()

Die Methode unlink() löscht eine Datei, die durch das Objekt Path repräsentiert wird, dauerhaft. Es wird empfohlen, vor dem Ausführen dieser Methode zu prüfen, ob eine Datei vorhanden ist, um eine Fehlermeldung zu vermeiden.

to_delete = Path("data/prices.csv")

if to_delete.exists():
   to_delete.unlink()
   print(f"Successfully deleted {to_delete.name}")Bereitgestellt von

Successfully deleted prices.csvBereitgestellt von

Die Methode rmdir()

Die Methode rmdir() löscht ein leeres Verzeichnis. Denke daran, dass rmdir() nur leere Verzeichnisse entfernen kann. Der einfachste Weg, ein nicht leeres Verzeichnis zu löschen, ist die Verwendung der shutil-Bibliothek oder des Terminals.

empty_dir = Path("new_data_dir")

empty_dir.rmdir()Bereitgestellt von

Hinweis: Sei bitte vorsichtig, wenn du unlink() oder rmdir() benutzt, denn die Ergebnisse sind dauerhaft.

Erweiterte Pfadmanipulation

Kommen wir nun zu einigen fortgeschrittenen Konzepten der Pfadmanipulation und wie man sie in der Praxis mit pathlib anwendet.

Relative vs. absolute Pfade

Wir fangen damit an, die Unterschiede zwischen absoluten und relativen Pfaden zu verstehen, da sie oft vorkommen.

Relative Pfade

Relative Pfade geben den Ort einer Datei oder eines Verzeichnisses relativ zum aktuellen Verzeichnis an, daher das Wort relativ. Sie sind kurz und flexibel innerhalb deines Projekts, können aber verwirrend sein, wenn du das Arbeitsverzeichnis wechselst.

Ich habe zum Beispiel einen Bilderordner in meinem aktuellen Arbeitsverzeichnis, der die Datei midjourney.png enthält.

image = Path("images/midjourney.png")

imageBereitgestellt von

PosixPath('images/midjourney.png')Bereitgestellt von

Der obige Code funktioniert jetzt, aber wenn ich das Notebook, das ich benutze, an einen anderen Ort verschiebe, bricht das Snippet ab, weil der Bilderordner nicht mit dem Notebook verschoben wurde.

Absolute Pfade

Absolute Pfade geben den vollständigen Speicherort einer Datei oder eines Verzeichnisses vom Stamm des Dateisystems aus an. Sie sind unabhängig vom aktuellen Verzeichnis und bieten einen eindeutigen Bezugspunkt für jeden Benutzer überall im System.

image_absolute = Path("/home/bexgboost/articles/2024/4_april/8_pathlib/images/midjourney.png")

image_absoluteBereitgestellt von

PosixPath('/home/bexgboost/articles/2024/4_april/8_pathlib/images/midjourney.png')Bereitgestellt von

Wie du siehst, können absolute Pfade ziemlich lang sein, besonders in komplexen Projekten mit verschachtelten Baumstrukturen. Aus diesem Grund bevorzugen die meisten Menschen relative Pfade, die kürzer sind.

Methode auflösen

pathlib bietet Methoden, um relative Pfade mit der Methode resolve() in absolute umzuwandeln.

relative_image = Path("images/midjourney.png")

absolute_image = relative_image.resolve()

absolute_imageBereitgestellt von

PosixPath('/home/bexgboost/articles/2024/4_april/8_pathlib/images/midjourney.png')Bereitgestellt von

Wir können auch den umgekehrten Weg gehen: Wenn wir einen absoluten Pfad haben, können wir ihn in einen relativen Pfad umwandeln, der auf einem Referenzverzeichnis basiert.

relative_path = Path.cwd()

absolute_image.relative_to(relative_path)Bereitgestellt von

PosixPath('images/midjourney.png')Bereitgestellt von

Globbing

Um das Globbing zu veranschaulichen, können wir zu dem Beispiel zurückkehren, das wir zu Beginn des Artikels vorgestellt haben. Dort haben wir einen Code geschrieben, um alle png Dateien in einem bestimmten Verzeichnis zu finden.

files = list(dir_path.glob("*.png"))Bereitgestellt von

pathlib verwendet das eingebaute Modul .glob(), um in einem beliebigen Verzeichnis effizient nach Dateien zu suchen, die einem bestimmten Muster entsprechen. Dieses Modul ist sehr nützlich, wenn Dateien mit ähnlichen Namen oder Erweiterungen verarbeitet werden sollen.

Die glob-Methode akzeptiert eine Zeichenkette mit Platzhaltern als Eingabe und gibt ein Generatorobjekt zurück, das bei Bedarf passende Path Objekte liefert:

• *: Passt auf null oder mehr Zeichen.

• ?: Passt auf jedes einzelne Zeichen.

• []: Entspricht einem Bereich von Zeichen, die in Klammern eingeschlossen sind (z. B. [a-z] entspricht einem beliebigen Kleinbuchstaben).

Zur Veranschaulichung wollen wir versuchen, alle Jupyter-Notizbücher in meinem Artikelverzeichnis zu finden.

articles_dir = Path.home() / "articles"

# Find all scripts
notebooks = articles_dir.glob("*.ipynb")

# Print how many found
print(len(list(notebooks)))
Bereitgestellt von

0Bereitgestellt von

Die Methode .glob() hat keine Notizbücher gefunden, was auf den ersten Blick überraschend erscheint, weil ich über 150 Artikel geschrieben habe. Der Grund dafür ist, dass .glob() nur innerhalb des angegebenen Verzeichnisses sucht, nicht in dessen Unterverzeichnissen.

Wir können dieses Problem durch eine rekursive Suche lösen, für die wir die Methode rglob() verwenden müssen, die eine ähnliche Syntax hat:

notebooks = articles_dir.rglob("*.ipynb")

print(len(list(notebooks)))Bereitgestellt von

357Bereitgestellt von

Dieses Mal hat unser Code alle 357 Dateien gefunden.

Arbeiten mit Dateien

Wie wir gesehen haben, repräsentieren Path Objekte nur Dateien, führen aber keine Operationen mit ihnen durch. Sie verfügen jedoch über bestimmte Methoden für gängige Dateioperationen. Wir werden in diesem Abschnitt sehen, wie man sie benutzt.

Dateien lesen

Das Lesen von Dateiinhalten ist ein grundlegender Vorgang in vielen Python-Anwendungen. pathlib bietet bequeme Kurzbefehle, um Dateien entweder als Text oder als Rohbytes zu lesen.

Mit der Methode read_text() können wir den Inhalt einer Textdatei lesen und die Datei schließen.

file = Path("file.txt")

print(file.read_text())Bereitgestellt von

This is sample text.Bereitgestellt von

Für Binärdateien können wir stattdessen die Methode read_bytes() verwenden.

image = Path("images/midjourney.png")

image.read_bytes()[:10]Bereitgestellt von

b'\x89PNG\r\n\x1a\n\x00\x00'Bereitgestellt von

Denke daran, dass bei der Verwendung einer read_* Methode die Fehlerbehandlung wichtig ist:

nonexistent_file = Path("gibberish.txt")

try:
   contents = nonexistent_file.read_text()
except FileNotFoundError:
   print("No such thing.")Bereitgestellt von

No such thing.Bereitgestellt von

Dateien schreiben

Das Schreiben in Dateien ist so einfach wie das Lesen von Dateien. Um Dateien zu schreiben, haben wir die Methode write_text().

file = Path("file.txt")

file.write_text("This is new text.")Bereitgestellt von

17Bereitgestellt von

file.read_text()Bereitgestellt von

'This is new text.'Bereitgestellt von

Wie wir sehen können, überschreibt die Methode write_text() den Text. Obwohl es für write_text() keinen Anfügemodus gibt, können wir read_text() und write_text() zusammen verwenden, um Text an das Ende der Datei anzuhängen.

old_text = file.read_text() + "\n"
final_text = "This is the final text."

# Combine old and new texts and write them back
file.write_text(old_text + final_text)

print(file.read_text())
Bereitgestellt von

This is new text.

This is the final text.Bereitgestellt von

write_bytes() funktioniert auf ähnliche Weise. Zur Veranschaulichung duplizieren wir zunächst das Bild midjourney.png mit einem neuen Namen.

original_image = Path("images/midjourney.png")

new_image = original_image.with_stem("duplicated_midjourney")

new_imageBereitgestellt von

PosixPath('images/duplicated_midjourney.png')Bereitgestellt von

Die Methode with_stem() gibt einen Dateipfad mit einem anderen Dateinamen zurück (obwohl das Suffix dasselbe bleibt). So können wir ein Originalbild lesen und seinen Kontext in ein neues Bild schreiben. 

new_image.write_bytes(original_image.read_bytes())Bereitgestellt von

1979612Bereitgestellt von

Umbenennen und Verschieben von Dateien

Zusätzlich zur Funktion with_stem(), mit der du den Stamm einer Datei umbenennen kannst, bietet pathlib die Methode rename(), mit der du die Datei noch vollständiger umbenennen kannst. 

file = Path("file.txt")

target_path = Path("new_file.txt")

file.rename(target_path)Bereitgestellt von

PosixPath('new_file.txt')Bereitgestellt von

rename() akzeptiert einen Zielpfad, der ein String oder ein anderes Pfadobjekt sein kann.

Um Dateien zu verschieben, kannst du die Funktion replace() verwenden, die auch einen Zielpfad akzeptiert:

# Define the file to be moved
source_file = Path("new_file.txt")

# Define the location to put the file
destination = Path("data/new/location")

# Create the directories if they don't exist
destination.mkdir(parents=True)

# Move the file
source_file.replace(destination / source_file.name)
Bereitgestellt von

PosixPath('data/new/location/new_file.txt')Bereitgestellt von

Leere Dateien erstellen

pathlib ermöglicht es uns, leere Dateien mit der Methode touch zu erstellen:

# Define new file path
new_dataset = Path("data/new.csv")

new_dataset.exists()
Bereitgestellt von

FalseBereitgestellt von

new_dataset.touch()

new_dataset.exists()Bereitgestellt von

TrueBereitgestellt von

Die Methode touch ist ursprünglich dafür gedacht, die Änderungszeit einer Datei zu aktualisieren, sie kann also auch für bestehende Dateien verwendet werden.

original_image.touch()Bereitgestellt von

Wenn du einen Dateinamen für eine spätere Verwendung reservieren musst, aber im Moment keinen Inhalt hast, den du hineinschreiben kannst, können wir mit touch einen Rohling erstellen. Die Methode wurde vom Unix-Terminalbefehl touch inspiriert.

Berechtigungen und Dateisysteminformationen

Als letzten Punkt lernen wir, wie man mit der Methode .stat() auf Dateieigenschaften zugreift. Wenn du mit os vertraut bist, wirst du feststellen, dass diese neue Methode die gleiche Ausgabe wie os.stat() hat.

image_stats = original_image.stat()

image_statsBereitgestellt von

os.stat_result(st_mode=33188, st_ino=1950175, st_dev=2080, st_nlink=1, st_uid=1000, st_gid=1000, st_size=1979612, st_atime=1714664562, st_mtime=1714664562, st_ctime=1714664562)Bereitgestellt von

Wir können die Dateigröße auch mit der Punktnotation abfragen.

image_size = image_stats.st_size

# File size in megabytes
image_size / (1024**2)
Bereitgestellt von

1.8879051208496094Bereitgestellt von

Fazit

Die Einführung des Moduls pathlib in Python 3.4 hat die Manipulation des Dateisystems für Entwickler erheblich vereinfacht. Durch einen objektorientierten Ansatz für die Behandlung von Dateipfaden bietet pathlib eine strukturierte und einfache Möglichkeit, Dateisystempfade darzustellen. pathlib ist außerdem plattformunabhängig, d.h. pathlib behandelt Pfadseparatoren auf verschiedenen Betriebssystemen einheitlich, sodass unser Code auf einem neuen Rechner nicht kaputt geht. Wie wir gesehen haben, bietet pathlib eine große Anzahl von prägnanten und ausdrucksstarken Methoden für gängige Dateisystemoperationen. 

Vergiss nicht, dass pathlib eine von vielen leistungsstarken integrierten Bibliotheken in Python ist. In unseren Kursen "Data Scientist With Python Career Lernpfad", "Python Programming Skill Lernpfad" und "Intro to Python for Data Science" lernst du eine Vielzahl integrierter Bibliotheken kennen, die dich zu einem starken Python-Programmierer machen. 

Danke fürs Lesen!