pathlib — Objektorientierte Dateisystempfade

Hinzugefügt in Version 3.4.

Quellcode: Lib/pathlib/

---

Dieses Modul bietet Klassen, die Dateisystempfade mit einer für verschiedene Betriebssysteme geeigneten Semantik darstellen. Pfadklassen sind unterteilt in reine Pfade, die rein rechnerische Operationen ohne E/A bieten, und konkrete Pfade, die von reinen Pfaden erben, aber auch E/A-Operationen bereitstellen.

Wenn Sie dieses Modul noch nie verwendet haben oder sich nicht sicher sind, welche Klasse für Ihre Aufgabe die richtige ist, ist Path höchstwahrscheinlich das, was Sie brauchen. Es instanziiert einen konkreten Pfad für die Plattform, auf der der Code ausgeführt wird.

Reine Pfade sind in einigen Sonderfällen nützlich; zum Beispiel

1. Wenn Sie Windows-Pfade auf einem Unix-Rechner (oder umgekehrt) manipulieren möchten. Sie können keine WindowsPath instanziieren, wenn Sie unter Unix laufen, aber Sie können PureWindowsPath instanziieren.

2. Wenn Sie sicherstellen möchten, dass Ihr Code Pfade nur manipuliert, ohne tatsächlich auf das Betriebssystem zuzugreifen. In diesem Fall kann die Instanziierung einer der reinen Klassen nützlich sein, da diese einfach keine betriebssystemzugreifenden Operationen haben.

Siehe auch

PEP 428: Das Modul pathlib – objektorientierte Dateisystempfade.

Siehe auch

Für die Low-Level-Pfadmanipulation von Zeichenketten können Sie auch das Modul os.path verwenden.

Grundlegende Verwendung

Importieren der Hauptklasse

>>> from pathlib import Path

Auflisten von Unterverzeichnissen

>>> p = Path('.')
>>> [x for x in p.iterdir() if x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
 PosixPath('__pycache__'), PosixPath('build')]

Auflisten von Python-Quelldateien in diesem Verzeichnisbaum

>>> list(p.glob('**/*.py'))
[PosixPath('test_pathlib.py'), PosixPath('setup.py'),
 PosixPath('pathlib.py'), PosixPath('docs/conf.py'),
 PosixPath('build/lib/pathlib.py')]

Navigation innerhalb eines Verzeichnisbaums

>>> p = Path('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

Abfragen von Pfadeigenschaften

>>> q.exists()
True
>>> q.is_dir()
False

Öffnen einer Datei

>>> with q.open() as f: f.readline()
...
'#!/bin/bash\n'

Ausnahmen

exception pathlib.UnsupportedOperation

Eine Ausnahme, die von NotImplementedError erbt und ausgelöst wird, wenn eine nicht unterstützte Operation auf einem Pfadobjekt aufgerufen wird.

Hinzugefügt in Version 3.13.

Reine Pfade

Objekte reiner Pfade bieten Pfadbehandlungsoperationen, die kein Dateisystem tatsächlich zugreifen. Es gibt drei Möglichkeiten, auf diese Klassen zuzugreifen, die wir auch als Flavours bezeichnen

class pathlib.PurePath(*pathsegments)

Eine generische Klasse, die den Pfadgeschmack des Systems darstellt (ihre Instanziierung erstellt entweder einen PurePosixPath oder einen PureWindowsPath)

>>> PurePath('setup.py')      # Running on a Unix machine
PurePosixPath('setup.py')

Jedes Element von pathsegments kann entweder eine Zeichenkette sein, die ein Pfadsegment darstellt, oder ein Objekt, das die os.PathLike-Schnittstelle implementiert, bei der die Methode __fspath__() eine Zeichenkette zurückgibt, wie z. B. ein anderes Pfadobjekt

>>> PurePath('foo', 'some/path', 'bar')
PurePosixPath('foo/some/path/bar')
>>> PurePath(Path('foo'), Path('bar'))
PurePosixPath('foo/bar')

Wenn pathsegments leer ist, wird das aktuelle Verzeichnis angenommen

>>> PurePath()
PurePosixPath('.')

Wenn ein Segment ein absoluter Pfad ist, werden alle vorherigen Segmente ignoriert (wie bei os.path.join())

>>> PurePath('/etc', '/usr', 'lib64')
PurePosixPath('/usr/lib64')
>>> PureWindowsPath('c:/Windows', 'd:bar')
PureWindowsPath('d:bar')

Unter Windows wird das Laufwerk nicht zurückgesetzt, wenn ein gerootetes relatives Pfadsegment (z. B. r'\foo') angetroffen wird

>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/Program Files')

Überflüssige Schrägstriche und einfache Punkte werden zusammengeführt, aber doppelte Punkte ('..') und führende doppelte Schrägstriche ('//') nicht, da dies die Bedeutung eines Pfades aus verschiedenen Gründen (z. B. symbolische Links, UNC-Pfade) ändern würde

>>> PurePath('foo//bar')
PurePosixPath('foo/bar')
>>> PurePath('//foo/bar')
PurePosixPath('//foo/bar')
>>> PurePath('foo/./bar')
PurePosixPath('foo/bar')
>>> PurePath('foo/../bar')
PurePosixPath('foo/../bar')

(ein naiver Ansatz würde PurePosixPath('foo/../bar') äquivalent zu PurePosixPath('bar') machen, was falsch ist, wenn foo ein symbolischer Link zu einem anderen Verzeichnis ist)

Objekte reiner Pfade implementieren die os.PathLike-Schnittstelle, wodurch sie überall verwendet werden können, wo die Schnittstelle akzeptiert wird.

Geändert in Version 3.6: Unterstützung für die os.PathLike-Schnittstelle hinzugefügt.

class pathlib.PurePosixPath(*pathsegments)

Eine Unterklasse von PurePath, dieser Pfadgeschmack stellt Nicht-Windows-Dateisystempfade dar

>>> PurePosixPath('/etc/hosts')
PurePosixPath('/etc/hosts')

pathsegments wird ähnlich wie bei PurePath angegeben.

class pathlib.PureWindowsPath(*pathsegments)

Eine Unterklasse von PurePath, dieser Pfadgeschmack stellt Windows-Dateisystempfade dar, einschließlich UNC-Pfade

>>> PureWindowsPath('c:/', 'Users', 'Ximénez')
PureWindowsPath('c:/Users/Ximénez')
>>> PureWindowsPath('//server/share/file')
PureWindowsPath('//server/share/file')

pathsegments wird ähnlich wie bei PurePath angegeben.

Unabhängig von dem System, auf dem Sie sich befinden, können Sie alle diese Klassen instanziieren, da sie keine Operationen bereitstellen, die Systemaufrufe tätigen.

Allgemeine Eigenschaften

Pfade sind unveränderlich und hashbar. Pfade desselben Geschmacks sind vergleichbar und sortierbar. Diese Eigenschaften respektieren die Case-Folding-Semantik des Geschmacks

>>> PurePosixPath('foo') == PurePosixPath('FOO')
False
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
True
>>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }
True
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
True

Pfade unterschiedlicher Geschmacksrichtungen vergleichen sich ungleich und können nicht sortiert werden

>>> PureWindowsPath('foo') == PurePosixPath('foo')
False
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'PureWindowsPath' and 'PurePosixPath'

Operatoren

Der Schrägstrich-Operator hilft beim Erstellen von Kindpfaden, ähnlich wie os.path.join(). Wenn das Argument ein absoluter Pfad ist, wird der vorherige Pfad ignoriert. Unter Windows wird das Laufwerk nicht zurückgesetzt, wenn das Argument ein gerooteter relativer Pfad ist (z. B. r'\foo')

>>> p = PurePath('/etc')
>>> p
PurePosixPath('/etc')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/usr' / q
PurePosixPath('/usr/bin')
>>> p / '/an_absolute_path'
PurePosixPath('/an_absolute_path')
>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/Program Files')

Ein Pfadobjekt kann überall verwendet werden, wo ein Objekt, das os.PathLike implementiert, akzeptiert wird

>>> import os
>>> p = PurePath('/etc')
>>> os.fspath(p)
'/etc'

Die Zeichenkettenrepräsentation eines Pfades ist der rohe Dateisystempfad selbst (in nativer Form, z. B. mit Backslashes unter Windows), den Sie an jede Funktion übergeben können, die einen Dateipfad als Zeichenkette akzeptiert

>>> p = PurePath('/etc')
>>> str(p)
'/etc'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'c:\\Program Files'

Ebenso gibt die Umwandlung eines Pfades in bytes den rohen Dateisystempfad als Byte-Objekt zurück, wie er von os.fsencode() kodiert wurde

>>> bytes(p)
b'/etc'

Hinweis

Die Umwandlung in bytes wird nur unter Unix empfohlen. Unter Windows ist die Unicode-Form die kanonische Darstellung von Dateisystempfaden.

Zugriff auf einzelne Teile

Um auf die einzelnen „Teile“ (Komponenten) eines Pfades zuzugreifen, verwenden Sie die folgende Eigenschaft

PurePath.parts

Ein Tupel, das Zugriff auf die verschiedenen Komponenten des Pfades bietet

>>> p = PurePath('/usr/bin/python3')
>>> p.parts
('/', 'usr', 'bin', 'python3')

>>> p = PureWindowsPath('c:/Program Files/PSF')
>>> p.parts
('c:\\', 'Program Files', 'PSF')

(beachten Sie, wie das Laufwerk und der lokale Root zu einem einzigen Teil zusammengefasst werden)

Methoden und Eigenschaften

Reine Pfade bieten die folgenden Methoden und Eigenschaften

PurePath.parser

Die Implementierung des Moduls os.path, die für Low-Level-Pfad-Parsing und -Verknüpfung verwendet wird: entweder posixpath oder ntpath.

Hinzugefügt in Version 3.13.

PurePath.drive

Eine Zeichenkette, die den Laufwerksbuchstaben oder -namen darstellt, falls vorhanden

>>> PureWindowsPath('c:/Program Files/').drive
'c:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/etc').drive
''

UNC-Freigaben werden ebenfalls als Laufwerke betrachtet

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\host\\share'

PurePath.root

Eine Zeichenkette, die den (lokalen oder globalen) Root darstellt, falls vorhanden

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/etc').root
'/'

UNC-Freigaben haben immer einen Root

>>> PureWindowsPath('//host/share').root
'\\'

Wenn der Pfad mit mehr als zwei aufeinanderfolgenden Schrägstrichen beginnt, fasst PurePosixPath diese zusammen

>>> PurePosixPath('//etc').root
'//'
>>> PurePosixPath('///etc').root
'/'
>>> PurePosixPath('////etc').root
'/'

Hinweis

Dieses Verhalten entspricht den Open Group Base Specifications Issue 6, Absatz 4.11 Pfadnamensauflösung

„Ein Pfadname, der mit zwei aufeinanderfolgenden Schrägstrichen beginnt, kann in einer implementierungsdefinierten Weise interpretiert werden, obwohl mehr als zwei führende Schrägstriche als ein einziger Schrägstrich behandelt werden.“

PurePath.anchor

Die Verkettung von Laufwerk und Root

>>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'c:'
>>> PurePosixPath('/etc').anchor
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\host\\share\\'

PurePath.parents

Eine unveränderliche Sequenz, die Zugriff auf die logischen Vorfahren des Pfades bietet

>>> p = PureWindowsPath('c:/foo/bar/setup.py')
>>> p.parents[0]
PureWindowsPath('c:/foo/bar')
>>> p.parents[1]
PureWindowsPath('c:/foo')
>>> p.parents[2]
PureWindowsPath('c:/')

Geändert in Version 3.10: Die Elternsequenz unterstützt jetzt Slices und negative Indexwerte.

PurePath.parent

Der logische Elternteil des Pfades

>>> p = PurePosixPath('/a/b/c/d')
>>> p.parent
PurePosixPath('/a/b/c')

Sie können nicht über einen Anker oder einen leeren Pfad hinausgehen

>>> p = PurePosixPath('/')
>>> p.parent
PurePosixPath('/')
>>> p = PurePosixPath('.')
>>> p.parent
PurePosixPath('.')

Hinweis

Dies ist eine rein lexikalische Operation, daher das folgende Verhalten

>>> p = PurePosixPath('foo/..')
>>> p.parent
PurePosixPath('foo')

Wenn Sie einen beliebigen Dateisystempfad nach oben durchlaufen möchten, wird empfohlen, zuerst Path.resolve() aufzurufen, um Symlinks aufzulösen und ".."-Komponenten zu eliminieren.

PurePath.name

Eine Zeichenkette, die die letzte Pfadkomponente darstellt, ohne das Laufwerk und den Root, falls vorhanden

>>> PurePosixPath('my/library/setup.py').name
'setup.py'

UNC-Laufwerksnamen werden nicht berücksichtigt

>>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').name
''

PurePath.suffix

Der letzte punktgetrennte Teil der letzten Komponente, falls vorhanden

>>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffix
'.gz'
>>> PurePosixPath('my/library').suffix
''

Dies wird üblicherweise als Dateierweiterung bezeichnet.

Geändert in Version 3.14: Ein einzelner Punkt („.“) gilt als gültige Erweiterung.

PurePath.suffixes

Eine Liste der Erweiterungen des Pfades, oft als Dateierweiterungen bezeichnet

>>> PurePosixPath('my/library.tar.gar').suffixes
['.tar', '.gar']
>>> PurePosixPath('my/library.tar.gz').suffixes
['.tar', '.gz']
>>> PurePosixPath('my/library').suffixes
[]

Geändert in Version 3.14: Ein einzelner Punkt („.“) gilt als gültige Erweiterung.

PurePath.stem

Die letzte Pfadkomponente ohne ihre Erweiterung

>>> PurePosixPath('my/library.tar.gz').stem
'library.tar'
>>> PurePosixPath('my/library.tar').stem
'library'
>>> PurePosixPath('my/library').stem
'library'

PurePath.as_posix()

Gibt eine Zeichenkettenrepräsentation des Pfades mit Vorwärtsschrägstrichen (/) zurück

>>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'c:\\windows'
>>> p.as_posix()
'c:/windows'

PurePath.is_absolute()

Gibt zurück, ob der Pfad absolut ist oder nicht. Ein Pfad gilt als absolut, wenn er sowohl einen Root als auch (sofern der Geschmack dies zulässt) ein Laufwerk hat

>>> PurePosixPath('/a/b').is_absolute()
True
>>> PurePosixPath('a/b').is_absolute()
False

>>> PureWindowsPath('c:/a/b').is_absolute()
True
>>> PureWindowsPath('/a/b').is_absolute()
False
>>> PureWindowsPath('c:').is_absolute()
False
>>> PureWindowsPath('//some/share').is_absolute()
True

PurePath.is_relative_to(other)

Gibt zurück, ob dieser Pfad relativ zu dem von other dargestellten Pfad ist.

>>> p = PurePath('/etc/passwd')
>>> p.is_relative_to('/etc')
True
>>> p.is_relative_to('/usr')
False

Diese Methode basiert auf Zeichenketten; sie greift weder auf das Dateisystem zu noch behandelt sie „..“-Segmente speziell. Der folgende Code ist äquivalent

>>> u = PurePath('/usr')
>>> u == p or u in p.parents
False

Hinzugefügt in Version 3.9.

Vom 3.12 veraltet, in Version 3.14 entfernt: Das Übergeben zusätzlicher Argumente ist veraltet; falls vorhanden, werden sie mit other verknüpft.

PurePath.is_reserved()

Mit PureWindowsPath wird True zurückgegeben, wenn der Pfad unter Windows als reserviert gilt, andernfalls False. Mit PurePosixPath wird immer False zurückgegeben.

Geändert in Version 3.13: Windows-Pfadnamen, die einen Doppelpunkt enthalten oder mit einem Punkt oder einem Leerzeichen enden, gelten als reserviert. UNC-Pfade können reserviert sein.

Vom 3.13 veraltet, wird in Version 3.15 entfernt: Diese Methode ist veraltet; verwenden Sie os.path.isreserved(), um reservierte Pfade unter Windows zu erkennen.

PurePath.joinpath(*pathsegments)

Das Aufrufen dieser Methode entspricht dem Verknüpfen des Pfades mit jedem der angegebenen pathsegments nacheinander

>>> PurePosixPath('/etc').joinpath('passwd')
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath('init.d', 'apache2')
PurePosixPath('/etc/init.d/apache2')
>>> PureWindowsPath('c:').joinpath('/Program Files')
PureWindowsPath('c:/Program Files')

PurePath.full_match(pattern, *, case_sensitive=None)

Abgleich dieses Pfades gegen das bereitgestellte glob-ähnliche Muster. Gibt True zurück, wenn der Abgleich erfolgreich ist, andernfalls False. Zum Beispiel

>>> PurePath('a/b.py').full_match('a/*.py')
True
>>> PurePath('a/b.py').full_match('*.py')
False
>>> PurePath('/a/b/c.py').full_match('/a/**')
True
>>> PurePath('/a/b/c.py').full_match('**/*.py')
True

Siehe auch

Dokumentation zur Muster-Sprache.

Wie bei anderen Methoden folgt die Groß-/Kleinschreibung den Standardeinstellungen der Plattform

>>> PurePosixPath('b.py').full_match('*.PY')
False
>>> PureWindowsPath('b.py').full_match('*.PY')
True

Setzen Sie case_sensitive auf True oder False, um dieses Verhalten zu überschreiben.

Hinzugefügt in Version 3.13.

PurePath.match(pattern, *, case_sensitive=None)

Abgleich dieses Pfades gegen das bereitgestellte nicht-rekursive glob-ähnliche Muster. Gibt True zurück, wenn der Abgleich erfolgreich ist, andernfalls False.

Diese Methode ähnelt full_match(), aber leere Muster sind nicht erlaubt (ValueError wird ausgelöst), der rekursive Wildcard „**“ wird nicht unterstützt (er verhält sich wie ein nicht-rekursiver „*“) und wenn ein relatives Muster angegeben wird, erfolgt der Abgleich von rechts

>>> PurePath('a/b.py').match('*.py')
True
>>> PurePath('/a/b/c.py').match('b/*.py')
True
>>> PurePath('/a/b/c.py').match('a/*.py')
False

Geändert in Version 3.12: Der Parameter pattern akzeptiert ein pfadähnliches Objekt.

Geändert in Version 3.12: Der Parameter case_sensitive wurde hinzugefügt.

PurePath.relative_to(other, walk_up=False)

Berechnet eine Version dieses Pfades relativ zu dem von other dargestellten Pfad. Wenn dies nicht möglich ist, wird ValueError ausgelöst

>>> p = PurePosixPath('/etc/passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/etc')
PurePosixPath('passwd')
>>> p.relative_to('/usr')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 941, in relative_to
    raise ValueError(error_message.format(str(self), str(formatted)))
ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is relative and the other is absolute.

Wenn walk_up falsch ist (Standard), muss der Pfad mit other beginnen. Wenn das Argument wahr ist, können ..-Einträge hinzugefügt werden, um den relativen Pfad zu bilden. In allen anderen Fällen, z. B. wenn die Pfade unterschiedliche Laufwerke referenzieren, wird ValueError ausgelöst.

>>> p.relative_to('/usr', walk_up=True)
PurePosixPath('../etc/passwd')
>>> p.relative_to('foo', walk_up=True)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 941, in relative_to
    raise ValueError(error_message.format(str(self), str(formatted)))
ValueError: '/etc/passwd' is not on the same drive as 'foo' OR one path is relative and the other is absolute.

Warnung

Diese Funktion ist Teil von PurePath und arbeitet mit Zeichenketten. Sie überprüft oder greift nicht auf die zugrunde liegende Dateistruktur zu. Dies kann sich auf die Option walk_up auswirken, da sie davon ausgeht, dass keine Symlinks im Pfad vorhanden sind; rufen Sie resolve() zuerst auf, falls erforderlich, um Symlinks aufzulösen.

Geändert in Version 3.12: Der Parameter walk_up wurde hinzugefügt (das alte Verhalten ist dasselbe wie walk_up=False).

Vom 3.12 veraltet, in Version 3.14 entfernt: Das Übergeben zusätzlicher Positionsargumente ist veraltet; falls vorhanden, werden sie mit other verknüpft.

PurePath.with_name(name)

Gibt einen neuen Pfad zurück, bei dem der name geändert wurde. Wenn der ursprüngliche Pfad keinen Namen hat, wird ValueError ausgelöst

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_name('setup.py')
PureWindowsPath('c:/Downloads/setup.py')
>>> p = PureWindowsPath('c:/')
>>> p.with_name('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/antoine/cpython/default/Lib/pathlib.py", line 751, in with_name
    raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name

PurePath.with_stem(stem)

Gibt einen neuen Pfad zurück, bei dem der stem geändert wurde. Wenn der ursprüngliche Pfad keinen Namen hat, wird ValueError ausgelöst

>>> p = PureWindowsPath('c:/Downloads/draft.txt')
>>> p.with_stem('final')
PureWindowsPath('c:/Downloads/final.txt')
>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_stem('lib')
PureWindowsPath('c:/Downloads/lib.gz')
>>> p = PureWindowsPath('c:/')
>>> p.with_stem('')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/antoine/cpython/default/Lib/pathlib.py", line 861, in with_stem
    return self.with_name(stem + self.suffix)
  File "/home/antoine/cpython/default/Lib/pathlib.py", line 851, in with_name
    raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name

Hinzugefügt in Version 3.9.

PurePath.with_suffix(suffix)

Gibt einen neuen Pfad zurück, bei dem die suffix geändert wurde. Wenn der ursprüngliche Pfad keine Erweiterung hat, wird stattdessen die neue suffix angehängt. Wenn die suffix eine leere Zeichenkette ist, wird die ursprüngliche Erweiterung entfernt

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_suffix('.bz2')
PureWindowsPath('c:/Downloads/pathlib.tar.bz2')
>>> p = PureWindowsPath('README')
>>> p.with_suffix('.txt')
PureWindowsPath('README.txt')
>>> p = PureWindowsPath('README.txt')
>>> p.with_suffix('')
PureWindowsPath('README')

Geändert in Version 3.14: Ein einzelner Punkt („.“) gilt als gültige Erweiterung. In früheren Versionen wird ValueError ausgelöst, wenn ein einzelner Punkt übergeben wird.

PurePath.with_segments(*pathsegments)

Erstellt ein neues Pfadobjekt desselben Typs, indem die angegebenen pathsegments kombiniert werden. Diese Methode wird aufgerufen, wenn ein abgeleitetes Pfadobjekt erstellt wird, z. B. aus parent und relative_to(). Unterklassen können diese Methode überschreiben, um Informationen an abgeleitete Pfade weiterzugeben, zum Beispiel

from pathlib import PurePosixPath

class MyPath(PurePosixPath):
    def __init__(self, *pathsegments, session_id):
        super().__init__(*pathsegments)
        self.session_id = session_id

    def with_segments(self, *pathsegments):
        return type(self)(*pathsegments, session_id=self.session_id)

etc = MyPath('/etc', session_id=42)
hosts = etc / 'hosts'
print(hosts.session_id)  # 42

Hinzugefügt in Version 3.12.

Konkrete Pfade

Konkrete Pfade sind Unterklassen der reinen Pfadklassen. Zusätzlich zu den von letzteren bereitgestellten Operationen bieten sie auch Methoden für Systemaufrufe auf Pfadobjekten. Es gibt drei Möglichkeiten, konkrete Pfade zu instanziieren

class pathlib.Path(*pathsegments)

Eine Unterklasse von PurePath, diese Klasse stellt konkrete Pfade des Pfadgeschmacks des Systems dar (ihre Instanziierung erstellt entweder einen PosixPath oder einen WindowsPath)

>>> Path('setup.py')
PosixPath('setup.py')

pathsegments wird ähnlich wie bei PurePath angegeben.

class pathlib.PosixPath(*pathsegments)

Eine Unterklasse von Path und PurePosixPath, diese Klasse stellt konkrete Nicht-Windows-Dateisystempfade dar

>>> PosixPath('/etc/hosts')
PosixPath('/etc/hosts')

pathsegments wird ähnlich wie bei PurePath angegeben.

Geändert in Version 3.13: Löst UnsupportedOperation unter Windows aus. In früheren Versionen wurde stattdessen NotImplementedError ausgelöst.

class pathlib.WindowsPath(*pathsegments)

Eine Unterklasse von Path und PureWindowsPath, diese Klasse stellt konkrete Windows-Dateisystempfade dar

>>> WindowsPath('c:/', 'Users', 'Ximénez')
WindowsPath('c:/Users/Ximénez')

pathsegments wird ähnlich wie bei PurePath angegeben.

Geändert in Version 3.13: Löst UnsupportedOperation auf Nicht-Windows-Plattformen aus. In früheren Versionen wurde stattdessen NotImplementedError ausgelöst.

Sie können nur den Klassengeschmack instanziieren, der Ihrem System entspricht (Systemaufrufe auf inkompatiblen Pfadgeschmäckern können zu Fehlern oder Abstürzen Ihrer Anwendung führen)

>>> import os
>>> os.name
'posix'
>>> Path('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 798, in __new__
    % (cls.__name__,))
UnsupportedOperation: cannot instantiate 'WindowsPath' on your system

Einige Methoden konkreter Pfade können eine OSError auslösen, wenn ein Systemaufruf fehlschlägt (z. B. weil der Pfad nicht existiert).

Parsen und Generieren von URIs

Konkrete Pfadobjekte können aus ‚file‘-URIs erstellt und als solche dargestellt werden, die RFC 8089 entsprechen.

Hinweis

File-URIs sind nicht portabel zwischen Rechnern mit unterschiedlichen Dateisystem-Kodierungen.

classmethod Path.from_uri(uri)

Gibt ein neues Pfadobjekt aus dem Parsen eines ‚file‘-URIs zurück. Zum Beispiel

>>> p = Path.from_uri('file:///etc/hosts')
PosixPath('/etc/hosts')

Unter Windows können DOS-Geräte- und UNC-Pfade aus URIs geparst werden

>>> p = Path.from_uri('file:///c:/windows')
WindowsPath('c:/windows')
>>> p = Path.from_uri('file://server/share')
WindowsPath('//server/share')

Mehrere Variantenformen werden unterstützt

>>> p = Path.from_uri('file:////server/share')
WindowsPath('//server/share')
>>> p = Path.from_uri('file://///server/share')
WindowsPath('//server/share')
>>> p = Path.from_uri('file:c:/windows')
WindowsPath('c:/windows')
>>> p = Path.from_uri('file:/c|/windows')
WindowsPath('c:/windows')

ValueError wird ausgelöst, wenn die URI nicht mit file: beginnt oder der geparste Pfad nicht absolut ist.

Hinzugefügt in Version 3.13.

Geändert in Version 3.14: Die URL-Autorität wird verworfen, wenn sie mit dem lokalen Hostnamen übereinstimmt. Andernfalls, wenn die Autorität nicht leer ist oder localhost ist, wird unter Windows ein UNC-Pfad zurückgegeben (wie zuvor), und auf anderen Plattformen wird ein ValueError ausgelöst.

Path.as_uri()

Stellt den Pfad als ‚file‘-URI dar. ValueError wird ausgelöst, wenn der Pfad nicht absolut ist.

>>> p = PosixPath('/etc/passwd')
>>> p.as_uri()
'file:///etc/passwd'
>>> p = WindowsPath('c:/Windows')
>>> p.as_uri()
'file:///c:/Windows'

Vom 3.14 veraltet, wird in Version 3.19 entfernt: Das Aufrufen dieser Methode von PurePath anstelle von Path ist möglich, aber veraltet. Die Verwendung von os.fsencode() durch die Methode macht sie strikt unrein.

Pfade erweitern und auflösen

classmethod Path.home()

Gibt ein neues Pfadobjekt zurück, das das Home-Verzeichnis des Benutzers repräsentiert (wie von os.path.expanduser() mit dem Konstrukt ~ zurückgegeben). Wenn das Home-Verzeichnis nicht aufgelöst werden kann, wird ein RuntimeError ausgelöst.

>>> Path.home()
PosixPath('/home/antoine')

Hinzugefügt in Version 3.5.

Path.expanduser()

Gibt einen neuen Pfad mit erweiterten Konstrukten ~ und ~user zurück, wie von os.path.expanduser() zurückgegeben. Wenn ein Home-Verzeichnis nicht aufgelöst werden kann, wird ein RuntimeError ausgelöst.

>>> p = PosixPath('~/films/Monty Python')
>>> p.expanduser()
PosixPath('/home/eric/films/Monty Python')

Hinzugefügt in Version 3.5.

classmethod Path.cwd()

Gibt ein neues Pfadobjekt zurück, das das aktuelle Verzeichnis repräsentiert (wie von os.getcwd() zurückgegeben wird)

>>> Path.cwd()
PosixPath('/home/antoine/pathlib')

Path.absolute()

Macht den Pfad absolut, ohne Normalisierung oder Auflösung von Symlinks. Gibt ein neues Pfadobjekt zurück

>>> p = Path('tests')
>>> p
PosixPath('tests')
>>> p.absolute()
PosixPath('/home/antoine/pathlib/tests')

Path.resolve(strict=False)

Macht den Pfad absolut und löst alle Symlinks auf. Ein neues Pfadobjekt wird zurückgegeben

>>> p = Path()
>>> p
PosixPath('.')
>>> p.resolve()
PosixPath('/home/antoine/pathlib')

„..“-Komponenten werden ebenfalls eliminiert (dies ist die einzige Methode dafür)

>>> p = Path('docs/../setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')

Wenn ein Pfad nicht existiert oder eine Symlink-Schleife angetroffen wird und strict True ist, wird ein OSError ausgelöst. Wenn strict False ist, wird der Pfad so weit wie möglich aufgelöst und der verbleibende Teil angehängt, ohne zu prüfen, ob er existiert.

Geändert in Version 3.6: Der Parameter strict wurde hinzugefügt (Verhalten vor 3.6 war strikt).

Geändert in Version 3.13: Symlink-Schleifen werden wie andere Fehler behandelt: OSError wird im strikten Modus ausgelöst, und keine Ausnahme wird im nicht-striken Modus ausgelöst. In früheren Versionen wurde unabhängig vom Wert von strict ein RuntimeError ausgelöst.

Path.readlink()

Gibt den Pfad zurück, auf den der symbolische Link zeigt (wie von os.readlink() zurückgegeben)

>>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.readlink()
PosixPath('setup.py')

Hinzugefügt in Version 3.9.

Geändert in Version 3.13: Löst UnsupportedOperation aus, wenn os.readlink() nicht verfügbar ist. In früheren Versionen wurde NotImplementedError ausgelöst.

Abfragen des Dateityps und -status

Geändert in Version 3.8: exists(), is_dir(), is_file(), is_mount(), is_symlink(), is_block_device(), is_char_device(), is_fifo(), is_socket() geben nun False zurück, anstatt eine Ausnahme für Pfade auszulösen, die auf OS-Ebene nicht darstellbare Zeichen enthalten.

Geändert in Version 3.14: Die oben genannten Methoden geben nun False zurück, anstatt eine OSError-Ausnahme vom Betriebssystem auszulösen. In früheren Versionen wurden einige Arten von OSError-Ausnahmen ausgelöst und andere unterdrückt. Das neue Verhalten ist konsistent mit os.path.exists(), os.path.isdir(), usw. Verwenden Sie stat(), um den Dateistatus abzurufen, ohne Ausnahmen zu unterdrücken.

Path.stat(*, follow_symlinks=True)

Gibt ein os.stat_result-Objekt zurück, das Informationen über diesen Pfad enthält, ähnlich wie os.stat(). Das Ergebnis wird bei jedem Aufruf dieser Methode nachgeschlagen.

Diese Methode folgt normalerweise Symlinks; um einen Symlink zu staten, fügen Sie das Argument follow_symlinks=False hinzu oder verwenden Sie lstat().

>>> p = Path('setup.py')
>>> p.stat().st_size
956
>>> p.stat().st_mtime
1327883547.852554

Geändert in Version 3.10: Der Parameter follow_symlinks wurde hinzugefügt.

Path.lstat()

Ähnlich wie Path.stat(), aber wenn der Pfad auf einen symbolischen Link zeigt, werden die Informationen des symbolischen Links anstelle der seines Ziels zurückgegeben.

Path.exists(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad auf eine existierende Datei oder ein Verzeichnis zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Diese Methode folgt normalerweise Symlinks; um zu prüfen, ob ein Symlink existiert, fügen Sie das Argument follow_symlinks=False hinzu.

>>> Path('.').exists()
True
>>> Path('setup.py').exists()
True
>>> Path('/etc').exists()
True
>>> Path('nonexistentfile').exists()
False

Geändert in Version 3.12: Der Parameter follow_symlinks wurde hinzugefügt.

Path.is_file(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad auf eine reguläre Datei zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als eine reguläre Datei zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Diese Methode folgt normalerweise Symlinks; um Symlinks auszuschließen, fügen Sie das Argument follow_symlinks=False hinzu.

Geändert in Version 3.13: Der Parameter follow_symlinks wurde hinzugefügt.

Path.is_dir(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad auf ein Verzeichnis zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als ein Verzeichnis zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Diese Methode folgt normalerweise Symlinks; um Symlinks zu Verzeichnissen auszuschließen, fügen Sie das Argument follow_symlinks=False hinzu.

Geändert in Version 3.13: Der Parameter follow_symlinks wurde hinzugefügt.

Path.is_symlink()

Gibt True zurück, wenn der Pfad auf einen symbolischen Link zeigt, auch wenn dieser Symlink defekt ist. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als einen symbolischen Link zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Path.is_junction()

Gibt True zurück, wenn der Pfad auf eine Junction zeigt, und False für jeden anderen Dateityp. Derzeit unterstützt nur Windows Junctions.

Hinzugefügt in Version 3.12.

Path.is_mount()

Gibt True zurück, wenn der Pfad ein Mountpoint ist: ein Punkt in einem Dateisystem, an dem ein anderes Dateisystem eingehängt wurde. Unter POSIX prüft die Funktion, ob das übergeordnete Verzeichnis von path, path/.., sich auf einem anderen Gerät als path befindet, oder ob path/.. und path auf dasselbe Inode auf demselben Gerät zeigen — dies sollte Mountpoints für alle Unix- und POSIX-Varianten erkennen. Unter Windows wird ein Mountpoint als Laufwerksbuchstaben-Wurzel (z. B. c:\), eine UNC-Freigabe (z. B. \\server\share) oder ein eingehängtes Dateisystemverzeichnis betrachtet.

Hinzugefügt in Version 3.7.

Geändert in Version 3.12: Die Windows-Unterstützung wurde hinzugefügt.

Path.is_socket()

Gibt True zurück, wenn der Pfad auf einen Unix-Socket zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als einen Unix-Socket zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Path.is_fifo()

Gibt True zurück, wenn der Pfad auf eine FIFO zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als eine FIFO zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Path.is_block_device()

Gibt True zurück, wenn der Pfad auf ein Blockgerät zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als ein Blockgerät zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Path.is_char_device()

Gibt True zurück, wenn der Pfad auf ein Zeichengerät zeigt. False wird zurückgegeben, wenn der Pfad ungültig, unzugänglich oder nicht vorhanden ist oder wenn er auf etwas anderes als ein Zeichengerät zeigt. Verwenden Sie Path.stat(), um zwischen diesen Fällen zu unterscheiden.

Path.samefile(other_path)

Gibt zurück, ob dieser Pfad auf dieselbe Datei wie other_path zeigt, was entweder ein Pfadobjekt oder eine Zeichenkette sein kann. Die Semantik ähnelt os.path.samefile() und os.path.samestat().

Eine OSError kann ausgelöst werden, wenn eine der Dateien aus irgendeinem Grund nicht zugänglich ist.

>>> p = Path('spam')
>>> q = Path('eggs')
>>> p.samefile(q)
False
>>> p.samefile('spam')
True

Hinzugefügt in Version 3.5.

Path.info

Ein PathInfo-Objekt, das die Abfrage von Dateityp-Informationen unterstützt. Das Objekt stellt Methoden bereit, die ihre Ergebnisse cachen, was dazu beitragen kann, die Anzahl der Systemaufrufe zu reduzieren, wenn nach Dateityp unterschieden wird. Zum Beispiel

>>> p = Path('src')
>>> if p.info.is_symlink():
...     print('symlink')
... elif p.info.is_dir():
...     print('directory')
... elif p.info.exists():
...     print('something else')
... else:
...     print('not found')
...
directory

Wenn der Pfad aus Path.iterdir() generiert wurde, dann wird dieses Attribut mit einigen Informationen über den Dateityp initialisiert, die durch das Scannen des übergeordneten Verzeichnisses gewonnen wurden. Nur das Zugreifen auf Path.info führt keine Dateisystemabfragen durch.

Um aktuelle Informationen abzurufen, ist es am besten, Path.is_dir(), is_file() und is_symlink() aufzurufen, anstatt Methoden dieses Attributs. Es gibt keine Möglichkeit, den Cache zurückzusetzen; stattdessen können Sie ein neues Pfadobjekt mit einem leeren Info-Cache erstellen über p = Path(p).

Hinzugefügt in Version 3.14.

Dateien lesen und schreiben

Path.open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)

Öffnet die Datei, auf die der Pfad zeigt, wie die integrierte Funktion open()

>>> p = Path('setup.py')
>>> with p.open() as f:
...     f.readline()
...
'#!/usr/bin/env python3\n'

Path.read_text(encoding=None, errors=None, newline=None)

Gibt den dekodierten Inhalt der angesprochenen Datei als Zeichenkette zurück

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

Die Datei wird geöffnet und dann geschlossen. Die optionalen Parameter haben die gleiche Bedeutung wie bei open().

Hinzugefügt in Version 3.5.

Geändert in Version 3.13: Der Parameter newline wurde hinzugefügt.

Path.read_bytes()

Gibt den binären Inhalt der angesprochenen Datei als Bytes-Objekt zurück

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

Hinzugefügt in Version 3.5.

Path.write_text(data, encoding=None, errors=None, newline=None)

Öffnet die angesprochene Datei im Textmodus, schreibt data hinein und schließt die Datei

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

Eine existierende Datei mit demselben Namen wird überschrieben. Die optionalen Parameter haben die gleiche Bedeutung wie bei open().

Hinzugefügt in Version 3.5.

Geändert in Version 3.10: Der Parameter newline wurde hinzugefügt.

Path.write_bytes(data)

Öffnet die angesprochene Datei im Bytes-Modus, schreibt data hinein und schließt die Datei

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

Eine existierende Datei mit demselben Namen wird überschrieben.

Hinzugefügt in Version 3.5.

Verzeichnisse lesen

Path.iterdir()

Wenn der Pfad auf ein Verzeichnis zeigt, werden Pfadobjekte des Verzeichnisinhalts erzeugt

>>> p = Path('docs')
>>> for child in p.iterdir(): child
...
PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('docs/_static')
PosixPath('docs/Makefile')

Die Kinder werden in beliebiger Reihenfolge erzeugt und die speziellen Einträge '.' und '..' sind nicht enthalten. Wenn eine Datei nach der Erstellung des Iterators aus dem Verzeichnis entfernt oder hinzugefügt wird, ist es nicht spezifiziert, ob ein Pfadobjekt für diese Datei enthalten ist.

Wenn der Pfad kein Verzeichnis ist oder anderweitig unzugänglich ist, wird ein OSError ausgelöst.

Path.glob(pattern, *, case_sensitive=None, recurse_symlinks=False)

Globbt das gegebene relative pattern im durch diesen Pfad dargestellten Verzeichnis und erzeugt alle übereinstimmenden Dateien (beliebigen Typs)

>>> sorted(Path('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
>>> sorted(Path('.').glob('*/*.py'))
[PosixPath('docs/conf.py')]
>>> sorted(Path('.').glob('**/*.py'))
[PosixPath('build/lib/pathlib.py'),
 PosixPath('docs/conf.py'),
 PosixPath('pathlib.py'),
 PosixPath('setup.py'),
 PosixPath('test_pathlib.py')]

Siehe auch

Dokumentation zur Muster-Sprache.

Standardmäßig oder wenn das Keyword-only-Argument case_sensitive auf None gesetzt ist, gleicht diese Methode Pfade mithilfe von plattformspezifischen Groß-/Kleinschreibungsregeln ab: typischerweise Groß-/Kleinschreibung-sensitiv unter POSIX und Groß-/Kleinschreibung-unabhängig unter Windows. Setzen Sie case_sensitive auf True oder False, um dieses Verhalten zu überschreiben.

Standardmäßig oder wenn das Keyword-only-Argument recurse_symlinks auf False gesetzt ist, folgt diese Methode Symlinks, außer beim Erweitern von „**“-Wildcards. Setzen Sie recurse_symlinks auf True, um Symlinks immer zu folgen.

Löst ein Auditing Event pathlib.Path.glob mit den Argumenten self, pattern aus.

Geändert in Version 3.12: Der Parameter case_sensitive wurde hinzugefügt.

Geändert in Version 3.13: Der Parameter recurse_symlinks wurde hinzugefügt.

Geändert in Version 3.13: Der Parameter pattern akzeptiert ein pfadähnliches Objekt.

Geändert in Version 3.13: Alle von OSError ausgelösten Ausnahmen beim Scannen des Dateisystems werden unterdrückt. In früheren Versionen wurden solche Ausnahmen in vielen Fällen unterdrückt, aber nicht in allen.

Path.rglob(pattern, *, case_sensitive=None, recurse_symlinks=False)

Globbt das gegebene relative pattern rekursiv. Dies ist gleichbedeutend mit dem Aufruf von Path.glob() mit „**/“ vor dem pattern.

Siehe auch

Muster-Sprache und Path.glob() Dokumentation.

Löst ein Auditing-Ereignis pathlib.Path.rglob mit den Argumenten self, pattern aus.

Geändert in Version 3.12: Der Parameter case_sensitive wurde hinzugefügt.

Geändert in Version 3.13: Der Parameter recurse_symlinks wurde hinzugefügt.

Geändert in Version 3.13: Der Parameter pattern akzeptiert ein pfadähnliches Objekt.

Path.walk(top_down=True, on_error=None, follow_symlinks=False)

Generiert die Dateinamen in einer Verzeichnisstruktur, indem die Struktur von oben nach unten oder von unten nach oben durchlaufen wird.

Für jedes Verzeichnis im Verzeichnisbaum, der bei self verwurzelt ist (einschließlich self, aber ausschliesslich '.' und '..'), gibt die Methode ein 3-Tupel von (dirpath, dirnames, filenames) zurück.

dirpath ist ein Path zum aktuell durchlaufenen Verzeichnis, dirnames ist eine Liste von Strings für die Namen von Unterverzeichnissen in dirpath (ausschließlich '.' und '..'), und filenames ist eine Liste von Strings für die Namen der Nicht-Verzeichnis-Dateien in dirpath. Um einen vollständigen Pfad (der mit self beginnt) zu einer Datei oder einem Verzeichnis in dirpath zu erhalten, verwenden Sie dirpath / name. Ob die Listen sortiert sind oder nicht, ist vom Dateisystem abhängig.

Wenn das optionale Argument top_down true ist (was der Standard ist), wird das Tripel für ein Verzeichnis vor den Tripeln für seine Unterverzeichnisse generiert (Verzeichnisse werden von oben nach unten durchlaufen). Wenn top_down false ist, wird das Tripel für ein Verzeichnis nach den Tripeln für alle seine Unterverzeichnisse generiert (Verzeichnisse werden von unten nach oben durchlaufen). Unabhängig vom Wert von top_down wird die Liste der Unterverzeichnisse abgerufen, bevor die Tripel für das Verzeichnis und seine Unterverzeichnisse durchlaufen werden.

Wenn top_down true ist, kann der Aufrufer die Liste dirnames direkt ändern (z. B. mit del oder Slice-Zuweisung), und Path.walk() wird nur in die Unterverzeichnisse rekursiv eintreten, deren Namen in dirnames verbleiben. Dies kann verwendet werden, um die Suche zu beschneiden, eine bestimmte Besuchsreihenfolge festzulegen oder Path.walk() über vom Aufrufer erstellte oder umbenannte Verzeichnisse zu informieren, bevor es Path.walk() erneut aufruft. Die Änderung von dirnames, wenn top_down false ist, hat keine Auswirkung auf das Verhalten von Path.walk(), da die Verzeichnisse in dirnames bereits generiert wurden, wenn dirnames dem Aufrufer übergeben wird.

Standardmässig werden Fehler von os.scandir() ignoriert. Wenn das optionale Argument on_error angegeben ist, sollte es ein aufrufbares Objekt sein; es wird mit einem Argument, einer OSError-Instanz, aufgerufen. Das aufrufbare Objekt kann den Fehler behandeln, um den Walk fortzusetzen, oder ihn erneut auslösen, um den Walk zu stoppen. Beachten Sie, dass der Dateiname als Attribut filename des Ausnahmeobjekts verfügbar ist.

Standardmässig folgt Path.walk() keinen symbolischen Links, sondern fügt sie der Liste filenames hinzu. Setzen Sie follow_symlinks auf true, um Symlinks aufzulösen und sie entsprechend ihren Zielen in dirnames und filenames einzufügen und folglich Verzeichnisse zu besuchen, auf die Symlinks verweisen (wo unterstützt).

Hinweis

Beachten Sie, dass das Setzen von follow_symlinks auf true zu einer unendlichen Rekursion führen kann, wenn ein Link auf ein übergeordnetes Verzeichnis von sich selbst zeigt. Path.walk() verfolgt nicht, welche Verzeichnisse es bereits besucht hat.

Hinweis

Path.walk() geht davon aus, dass die durchlaufenen Verzeichnisse während der Ausführung nicht verändert werden. Wenn beispielsweise ein Verzeichnis aus dirnames durch einen Symlink ersetzt wurde und follow_symlinks false ist, wird Path.walk() trotzdem versuchen, in dieses einzudringen. Um ein solches Verhalten zu verhindern, entfernen Sie Verzeichnisse nach Bedarf aus dirnames.

Hinweis

Im Gegensatz zu os.walk() listet Path.walk() Symlinks zu Verzeichnissen in filenames auf, wenn follow_symlinks false ist.

Dieses Beispiel zeigt die Anzahl der Bytes an, die von allen Dateien in jedem Verzeichnis verwendet werden, während __pycache__-Verzeichnisse ignoriert werden.

from pathlib import Path
for root, dirs, files in Path("cpython/Lib/concurrent").walk(on_error=print):
  print(
      root,
      "consumes",
      sum((root / file).stat().st_size for file in files),
      "bytes in",
      len(files),
      "non-directory files"
  )
  if '__pycache__' in dirs:
        dirs.remove('__pycache__')

Das nächste Beispiel ist eine einfache Implementierung von shutil.rmtree(). Das Durchlaufen des Baumes von unten nach oben ist unerlässlich, da rmdir() das Löschen eines Verzeichnisses nicht zulässt, bevor es leer ist.

# Delete everything reachable from the directory "top".
# CAUTION:  This is dangerous! For example, if top == Path('/'),
# it could delete all of your files.
for root, dirs, files in top.walk(top_down=False):
    for name in files:
        (root / name).unlink()
    for name in dirs:
        (root / name).rmdir()

Hinzugefügt in Version 3.12.

Erstellen von Dateien und Verzeichnissen

Path.touch(mode=0o666, exist_ok=True)

Erstellt eine Datei unter dem angegebenen Pfad. Wenn mode angegeben wird, wird er mit dem umask-Wert des Prozesses kombiniert, um den Dateimodus und die Zugriffsflags zu bestimmen. Wenn die Datei bereits existiert, ist die Funktion erfolgreich, wenn exist_ok true ist (und ihre Änderungszeit auf die aktuelle Zeit aktualisiert wird), andernfalls wird FileExistsError ausgelöst.

Siehe auch

Die Methoden open(), write_text() und write_bytes() werden oft zum Erstellen von Dateien verwendet.

Path.mkdir(mode=0o777, parents=False, exist_ok=False)

Erstellt ein neues Verzeichnis unter dem angegebenen Pfad. Wenn mode angegeben wird, wird er mit dem umask-Wert des Prozesses kombiniert, um den Dateimodus und die Zugriffsflags zu bestimmen. Wenn der Pfad bereits existiert, wird FileExistsError ausgelöst.

Wenn parents true ist, werden alle fehlenden übergeordneten Verzeichnisse dieses Pfades bei Bedarf erstellt; sie werden mit den Standardberechtigungen erstellt, ohne mode zu berücksichtigen (ähnlich dem POSIX-Befehl mkdir -p).

Wenn parents false ist (Standard), löst ein fehlendes übergeordnetes Verzeichnis FileNotFoundError aus.

Wenn exist_ok false ist (Standard), wird FileExistsError ausgelöst, wenn das Zielverzeichnis bereits existiert.

Wenn exist_ok true ist, wird FileExistsError nicht ausgelöst, es sei denn, der angegebene Pfad existiert bereits im Dateisystem und ist kein Verzeichnis (gleiches Verhalten wie der POSIX-Befehl mkdir -p).

Geändert in Version 3.5: Der Parameter exist_ok wurde hinzugefügt.

Path.symlink_to(target, target_is_directory=False)

Macht diesen Pfad zu einem symbolischen Link, der auf target zeigt.

Unter Windows stellt ein Symlink entweder eine Datei oder ein Verzeichnis dar und passt sich nicht dynamisch an das Ziel an. Wenn das Ziel vorhanden ist, wird der Typ des Symlinks so erstellt, dass er übereinstimmt. Andernfalls wird der Symlink als Verzeichnis erstellt, wenn target_is_directory true ist, oder als Dateisymlink (Standard), andernfalls. Auf Nicht-Windows-Plattformen wird target_is_directory ignoriert.

>>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')
>>> p.stat().st_size
956
>>> p.lstat().st_size
8

Hinweis

Die Reihenfolge der Argumente (Link, Ziel) ist umgekehrt zu der von os.symlink().

Geändert in Version 3.13: Löst UnsupportedOperation aus, wenn os.symlink() nicht verfügbar ist. In früheren Versionen wurde NotImplementedError ausgelöst.

Path.hardlink_to(target)

Macht diesen Pfad zu einem Hardlink für dieselbe Datei wie target.

Hinweis

Die Reihenfolge der Argumente (Link, Ziel) ist umgekehrt zu der von os.link().

Hinzugefügt in Version 3.10.

Geändert in Version 3.13: Löst UnsupportedOperation aus, wenn os.link() nicht verfügbar ist. In früheren Versionen wurde NotImplementedError ausgelöst.

Kopieren, Verschieben und Löschen

Path.copy(target, *, follow_symlinks=True, preserve_metadata=False)

Kopiert diese Datei oder diesen Verzeichnisbaum in das angegebene target und gibt eine neue Path-Instanz zurück, die auf target zeigt.

Wenn die Quelle eine Datei ist, wird das Ziel überschrieben, wenn es sich um eine vorhandene Datei handelt. Wenn die Quelle ein Symlink ist und follow_symlinks true ist (Standard), wird das Ziel des Symlinks kopiert. Andernfalls wird der Symlink am Ziel neu erstellt.

Wenn preserve_metadata false ist (Standard), werden nur Verzeichnisstrukturen und Dateidaten garantiert kopiert. Setzen Sie preserve_metadata auf true, um sicherzustellen, dass Datei- und Verzeichnisberechtigungen, Flags, letzte Zugriffs- und Änderungszeiten sowie erweiterte Attribute, wo unterstützt, kopiert werden. Dieses Argument hat keine Auswirkung beim Kopieren von Dateien unter Windows (wo Metadaten immer beibehalten werden).

Hinweis

Wo vom Betriebssystem und Dateisystem unterstützt, führt diese Methode einen leichten Kopiervorgang durch, bei dem Datenblöcke nur bei Änderungen kopiert werden. Dies ist bekannt als Copy-on-Write.

Hinzugefügt in Version 3.14.

Path.copy_into(target_dir, *, follow_symlinks=True, preserve_metadata=False)

Kopiert diese Datei oder diesen Verzeichnisbaum in das angegebene target_dir, welches ein existierendes Verzeichnis sein sollte. Andere Argumente werden identisch zu Path.copy() behandelt. Gibt eine neue Path-Instanz zurück, die auf die Kopie zeigt.

Hinzugefügt in Version 3.14.

Path.rename(target)

Benennt diese Datei oder dieses Verzeichnis in das angegebene target um und gibt eine neue Path-Instanz zurück, die auf target zeigt. Unter Unix wird, wenn target existiert und eine Datei ist, diese stillschweigend ersetzt, wenn der Benutzer die Berechtigung hat. Unter Windows wird, wenn target existiert, FileExistsError ausgelöst. target kann entweder ein String oder ein anderes Pfadobjekt sein.

>>> p = Path('foo')
>>> p.open('w').write('some text')
9
>>> target = Path('bar')
>>> p.rename(target)
PosixPath('bar')
>>> target.open().read()
'some text'

Der Zielpfad kann absolut oder relativ sein. Relative Pfade werden relativ zum aktuellen Arbeitsverzeichnis interpretiert, *nicht* relativ zum Verzeichnis des Path-Objekts.

Es basiert auf os.rename() und bietet die gleichen Garantien.

Geändert in Version 3.8: Rückgabewert hinzugefügt, gibt die neue Path-Instanz zurück.

Path.replace(target)

Benennt diese Datei oder dieses Verzeichnis in das angegebene target um und gibt eine neue Path-Instanz zurück, die auf target zeigt. Wenn target auf eine existierende Datei oder ein leeres Verzeichnis zeigt, wird diese bedingungslos ersetzt.

Der Zielpfad kann absolut oder relativ sein. Relative Pfade werden relativ zum aktuellen Arbeitsverzeichnis interpretiert, *nicht* relativ zum Verzeichnis des Path-Objekts.

Geändert in Version 3.8: Rückgabewert hinzugefügt, gibt die neue Path-Instanz zurück.

Path.move(target)

Verschiebt diese Datei oder diesen Verzeichnisbaum in das angegebene target und gibt eine neue Path-Instanz zurück, die auf target zeigt.

Wenn das target nicht existiert, wird es erstellt. Wenn sowohl dieser Pfad als auch das target existierende Dateien sind, wird das Ziel überschrieben. Wenn beide Pfade auf dieselbe Datei oder dasselbe Verzeichnis zeigen oder das target ein nicht leeres Verzeichnis ist, wird OSError ausgelöst.

Wenn beide Pfade auf demselben Dateisystem liegen, wird die Verschiebung mit os.replace() durchgeführt. Andernfalls wird dieser Pfad kopiert (mit Beibehaltung von Metadaten und Symlinks) und dann gelöscht.

Hinzugefügt in Version 3.14.

Path.move_into(target_dir)

Verschiebt diese Datei oder diesen Verzeichnisbaum in das angegebene target_dir, welches ein existierendes Verzeichnis sein sollte. Gibt eine neue Path-Instanz zurück, die auf den verschobenen Pfad zeigt.

Hinzugefügt in Version 3.14.

Path.unlink(missing_ok=False)

Entfernt diese Datei oder diesen symbolischen Link. Wenn der Pfad auf ein Verzeichnis zeigt, verwenden Sie stattdessen Path.rmdir().

Wenn missing_ok false ist (Standard), wird FileNotFoundError ausgelöst, wenn der Pfad nicht existiert.

Wenn missing_ok true ist, werden FileNotFoundError-Ausnahmen ignoriert (gleiches Verhalten wie der POSIX-Befehl rm -f).

Geändert in Version 3.8: Der Parameter missing_ok wurde hinzugefügt.

Path.rmdir()

Entfernt dieses Verzeichnis. Das Verzeichnis muss leer sein.

Berechtigungen und Eigentümerschaft

Path.owner(*, follow_symlinks=True)

Gibt den Namen des Benutzers zurück, dem die Datei gehört. KeyError wird ausgelöst, wenn die Benutzer-ID (UID) der Datei nicht in der Systemdatenbank gefunden wird.

Diese Methode folgt normalerweise Symlinks; um den Eigentümer des Symlinks zu erhalten, fügen Sie das Argument follow_symlinks=False hinzu.

Geändert in Version 3.13: Löst UnsupportedOperation aus, wenn das Modul pwd nicht verfügbar ist. In früheren Versionen wurde NotImplementedError ausgelöst.

Geändert in Version 3.13: Der Parameter follow_symlinks wurde hinzugefügt.

Path.group(*, follow_symlinks=True)

Gibt den Namen der Gruppe zurück, der die Datei gehört. KeyError wird ausgelöst, wenn die Gruppen-ID (GID) der Datei nicht in der Systemdatenbank gefunden wird.

Diese Methode folgt normalerweise Symlinks; um die Gruppe des Symlinks zu erhalten, fügen Sie das Argument follow_symlinks=False hinzu.

Geändert in Version 3.13: Löst UnsupportedOperation aus, wenn das Modul grp nicht verfügbar ist. In früheren Versionen wurde NotImplementedError ausgelöst.

Geändert in Version 3.13: Der Parameter follow_symlinks wurde hinzugefügt.

Path.chmod(mode, *, follow_symlinks=True)

Ändert den Dateimodus und die Berechtigungen, wie os.chmod().

Diese Methode folgt normalerweise Symlinks. Einige Unix-Varianten unterstützen die Änderung der Berechtigungen für den Symlink selbst; auf diesen Plattformen können Sie das Argument follow_symlinks=False hinzufügen oder lchmod() verwenden.

>>> p = Path('setup.py')
>>> p.stat().st_mode
33277
>>> p.chmod(0o444)
>>> p.stat().st_mode
33060

Geändert in Version 3.10: Der Parameter follow_symlinks wurde hinzugefügt.

Path.lchmod(mode)

Wie Path.chmod(), aber wenn der Pfad auf einen symbolischen Link zeigt, wird der Modus des symbolischen Links geändert, nicht der seines Ziels.

Muster-Sprache

Die folgenden Wildcards werden in Mustern für full_match(), glob() und rglob() unterstützt.

** (ganzes Segment)

Passt auf eine beliebige Anzahl von Datei- oder Verzeichnissegmenten, einschliesslich null.

* (ganzes Segment)

Passt auf ein Datei- oder Verzeichnissegment.

* (Teil eines Segments)

Passt auf eine beliebige Anzahl von Nicht-Trennzeichen-Zeichen, einschliesslich null.

?

Passt auf ein Nicht-Trennzeichen-Zeichen.

[seq]

Passt auf ein Zeichen in seq, wobei seq eine Zeichensequenz ist. Bereichsausdrücke werden unterstützt; zum Beispiel passt [a-z] auf jeden Kleinbuchstaben im ASCII-Bereich. Mehrere Bereiche können kombiniert werden: [a-zA-Z0-9_] passt auf jeden ASCII-Buchstaben, jede Ziffer oder Unterstrich.

[!seq]

Passt auf ein Zeichen, das nicht in seq ist, wobei seq denselben Regeln wie oben folgt.

Für eine exakte Übereinstimmung wickeln Sie die Metazeichen in Klammern ein. Zum Beispiel passt "[?]" auf das Zeichen "?".

Der Wildcard-Operator "**" ermöglicht rekursives Globbing. Einige Beispiele:

Muster	Bedeutung
„**/*“	Jeder Pfad mit mindestens einem Segment.
„**/*.py“	Jeder Pfad mit einem letzten Segment, das auf ".py" endet.
„assets/**“	Jeder Pfad, der mit "assets/" beginnt.
„assets/**/*“	Jeder Pfad, der mit "assets/" beginnt, ausser "assets/" selbst.

Hinweis

Globbing mit dem "**"-Wildcard besucht jedes Verzeichnis im Baum. Grosse Verzeichnisbäume können lange Suchzeiten beanspruchen.

Geändert in Version 3.13: Globbing mit einem Muster, das auf "**" endet, gibt sowohl Dateien als auch Verzeichnisse zurück. In früheren Versionen wurden nur Verzeichnisse zurückgegeben.

In Path.glob() und Path.rglob() kann ein abschliessender Schrägstrich zum Muster hinzugefügt werden, um nur Verzeichnisse abzugleichen.

Geändert in Version 3.11: Globbing mit einem Muster, das mit einem Pfadkomponenten-Trennzeichen (sep oder altsep) endet, gibt nur Verzeichnisse zurück.

Vergleich mit dem Modul glob

Die von Path.glob() und Path.rglob() akzeptierten Muster und die generierten Ergebnisse unterscheiden sich geringfügig von denen des Moduls glob.

1. Dateien, die mit einem Punkt beginnen, sind in pathlib nicht speziell. Dies entspricht dem Aufruf von glob.glob() mit include_hidden=True.

2. Musterkomponenten mit "**" sind in pathlib immer rekursiv. Dies entspricht dem Aufruf von glob.glob() mit recursive=True.

3. „**“-Musterkomponenten folgen standardmäßig nicht Symlinks in pathlib. Dieses Verhalten hat keine Entsprechung in glob.glob(), aber Sie können recurse_symlinks=True an Path.glob() übergeben, um ein kompatibles Verhalten zu erzielen.

4. Wie alle Objekte vom Typ PurePath und Path enthalten die von Path.glob() und Path.rglob() zurückgegebenen Werte keine abschließenden Schrägstriche.

5. Die von pathlib’s path.glob() und path.rglob() zurückgegebenen Werte enthalten das *path* als Präfix, im Gegensatz zu den Ergebnissen von glob.glob(root_dir=path).

6. Die von pathlib’s path.glob() und path.rglob() zurückgegebenen Werte können *path* selbst enthalten, zum Beispiel beim Globbing von „**“, während die Ergebnisse von glob.glob(root_dir=path) niemals einen leeren String enthalten, der *path* entsprechen würde.

Vergleich mit den Modulen os und os.path

pathlib implementiert Pfadoperationen mithilfe von PurePath- und Path-Objekten und wird daher als *objektorientiert* bezeichnet. Auf der anderen Seite stellen die Module os und os.path Funktionen bereit, die mit Low-Level-str- und bytes-Objekten arbeiten, was einen *prozeduraleren* Ansatz darstellt. Einige Benutzer halten den objektorientierten Stil für lesbarer.

Viele Funktionen in os und os.path unterstützen bytes-Pfade und Pfade relativ zu Deskriptoren von Verzeichnissen. Diese Features sind in pathlib nicht verfügbar.

Die str- und bytes-Typen von Python und Teile der Module os und os.path sind in C geschrieben und sehr schnell. pathlib ist in reinem Python geschrieben und oft langsamer, aber selten langsam genug, um eine Rolle zu spielen.

Die Pfadnormalisierung von pathlib ist etwas meinungsfreudiger und konsistenter als die von os.path. Zum Beispiel eliminiert Path.absolute() „..“-Segmente aus einem Pfad, was dessen Bedeutung ändern kann, wenn Symlinks beteiligt sind, während os.path.abspath() diese Segmente zur größeren Sicherheit beibehält.

Die Pfadnormalisierung von pathlib kann sie für einige Anwendungen ungeeignet machen

1. pathlib normalisiert Path("my_folder/") zu Path("my_folder"), was die Bedeutung eines Pfades ändert, wenn er an verschiedene Betriebssystem-APIs und Befehlszeilendienstprogramme übergeben wird. Insbesondere kann das Fehlen eines abschließenden Trennzeichens dazu führen, dass der Pfad als Datei oder Verzeichnis aufgelöst wird, anstatt nur als Verzeichnis.

2. pathlib normalisiert Path("./my_program") zu Path("my_program"), was die Bedeutung eines Pfades ändert, wenn er als Pfad zur Programmsuche verwendet wird, z. B. in einer Shell oder beim Starten eines Kindprozesses. Insbesondere kann das Fehlen eines Trennzeichens im Pfad erzwingen, dass er in PATH statt im aktuellen Verzeichnis gesucht wird.

Als Konsequenz dieser Unterschiede ist pathlib kein direkter Ersatz für os.path.

Entsprechende Werkzeuge

Unten ist eine Tabelle, die verschiedene os-Funktionen ihren entsprechenden PurePath/Path-Äquivalenten zuordnet.

os und os.path	pathlib
os.path.dirname()	PurePath.parent
os.path.basename()	PurePath.name
os.path.splitext()	PurePath.stem, PurePath.suffix
os.path.join()	PurePath.joinpath()
os.path.isabs()	PurePath.is_absolute()
os.path.relpath()	PurePath.relative_to() [1]
os.path.expanduser()	Path.expanduser() [2]
os.path.realpath()	Path.resolve()
os.path.abspath()	Path.absolute() [3]
os.path.exists()	Path.exists()
os.path.isfile()	Path.is_file()
os.path.isdir()	Path.is_dir()
os.path.islink()	Path.is_symlink()
os.path.isjunction()	Path.is_junction()
os.path.ismount()	Path.is_mount()
os.path.samefile()	Path.samefile()
os.getcwd()	Path.cwd()
os.stat()	Path.stat()
os.lstat()	Path.lstat()
os.listdir()	Path.iterdir()
os.walk()	Path.walk() [4]
os.mkdir(), os.makedirs()	Path.mkdir()
os.link()	Path.hardlink_to()
os.symlink()	Path.symlink_to()
os.readlink()	Path.readlink()
os.rename()	Path.rename()
os.replace()	Path.replace()
os.remove(), os.unlink()	Path.unlink()
os.rmdir()	Path.rmdir()
os.chmod()	Path.chmod()
os.lchmod()	Path.lchmod()

Fußnoten

[1]

os.path.relpath() ruft abspath() auf, um Pfade absolut zu machen und „..“-Teile zu entfernen, während PurePath.relative_to() eine lexikalische Operation ist, die ValueError auslöst, wenn die Anker ihrer Eingaben unterschiedlich sind (z. B. wenn ein Pfad absolut und der andere relativ ist).

[2]

os.path.expanduser() gibt den Pfad unverändert zurück, wenn das Home-Verzeichnis nicht aufgelöst werden kann, während Path.expanduser() RuntimeError auslöst.

[3]

os.path.abspath() entfernt „..“-Komponenten, ohne Symlinks aufzulösen, was die Bedeutung des Pfades ändern kann, während Path.absolute() alle „..“-Komponenten im Pfad belässt.

[4]

os.walk() folgt immer Symlinks, wenn Pfade in *dirnames* und *filenames* kategorisiert werden, während Path.walk() alle Symlinks in *filenames* kategorisiert, wenn *follow_symlinks* falsch ist (Standard).

Protokolle

Das Modul pathlib.types stellt Typen für die statische Typüberprüfung bereit.

Hinzugefügt in Version 3.14.

class pathlib.types.PathInfo

Ein typing.Protocol, der das Attribut Path.info beschreibt. Implementierungen können zwischengespeicherte Ergebnisse von ihren Methoden zurückgeben.

exists(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad eine existierende Datei oder ein Verzeichnis oder eine andere Art von Datei ist; gibt False zurück, wenn der Pfad nicht existiert.

Wenn *follow_symlinks* False ist, gibt True für Symlinks zurück, ohne zu prüfen, ob deren Ziele existieren.

is_dir(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad ein Verzeichnis ist oder ein symbolischer Link, der auf ein Verzeichnis zeigt; gibt False zurück, wenn der Pfad eine andere Art von Datei ist (oder darauf zeigt) oder wenn er nicht existiert.

Wenn *follow_symlinks* False ist, gibt True nur zurück, wenn der Pfad ein Verzeichnis ist (ohne Symlinks zu folgen); gibt False zurück, wenn der Pfad eine andere Art von Datei ist oder wenn er nicht existiert.

is_file(*, follow_symlinks=True)

Gibt True zurück, wenn der Pfad eine Datei ist oder ein symbolischer Link, der auf eine Datei zeigt; gibt False zurück, wenn der Pfad ein Verzeichnis oder eine andere Nicht-Datei ist (oder darauf zeigt) oder wenn er nicht existiert.

Wenn *follow_symlinks* False ist, gibt True nur zurück, wenn der Pfad eine Datei ist (ohne Symlinks zu folgen); gibt False zurück, wenn der Pfad ein Verzeichnis oder eine andere Nicht-Datei ist oder wenn er nicht existiert.

is_symlink()

Gibt True zurück, wenn der Pfad ein symbolischer Link ist (auch wenn er defekt ist); gibt False zurück, wenn der Pfad ein Verzeichnis oder irgendeine Art von Datei ist oder wenn er nicht existiert.