pathlib – Online in der Cloud

PROGRAMM:

NAME/FUNKTION

pathlib – pathlib-Dokumentation

Das Bearbeiten von Dateisystempfaden als String-Objekte kann schnell umständlich werden: mehrere
ruft an os.path.join () or os.path.dirname()usw. Dieses Modul bietet eine Reihe von Klassen
mit allen gängigen Operationen auf Pfaden auf einfache, objektorientierte Weise.

Dieses Modul lässt sich am besten mit Python 3.2 oder höher verwenden, ist aber auch mit Python kompatibel
2.7

Anmerkungen:
Dieses Modul wurde inklusive in der Python 3.4-Standardbibliothek nach PEP 428
Annahme. Sie müssen es nur für Python 3.3 oder älter installieren.

SEHEN EBENFALLS:
PEP 428: Begründung für das endgültige Pathlib-Design und die API.

HERUNTERLADEN

Eigenständige Versionen sind auf PyPI verfügbar: http://pypi.python.org/pypi/pathlib/

Die Hauptentwicklung findet jetzt in der Python-Standardbibliothek statt: siehe Python
Entwickler Guide.

Das Wartungs-Repository für dieses eigenständige Backport-Modul finden Sie auf BitBucket.
Es wird jedoch erwartet, dass die Aktivität recht gering ist: https://bitbucket.org/pitrou/pathlib/

HOHES LEVEL ENTDECKE

Dieses Modul bietet Klassen, die Dateisystempfade mit geeigneter Semantik darstellen
verschiedene Betriebssysteme. Pfadklassen sind unterteilt zwischen auch Pfade, die liefern
rein rechnerische Operationen ohne I/O, und Beton Pfade, die von pure erben
Pfade, sondern stellen auch I/O-Operationen bereit. [Bild]

Wenn Sie dieses Modul noch nie verwendet haben oder einfach nicht sicher sind, welcher Kurs für Sie der richtige ist
Aufgabe, Path ist höchstwahrscheinlich das, was Sie brauchen. Es instanziiert a Beton Weg für die Plattform
Der Code läuft weiter.

In einigen Sonderfällen sind reine Pfade nützlich. Zum Beispiel:

1. Wenn Sie Windows-Pfade auf einem Unix-Rechner bearbeiten möchten (oder umgekehrt). Sie können nicht
instanziieren a WindowsPath wenn es unter Unix läuft, aber Sie können es instanziieren
PureWindowsPath.

2. Sie möchten sicherstellen, dass Ihr Code nur Pfade manipuliert, ohne tatsächlich darauf zuzugreifen
das Betriebssystem. In diesem Fall kann es sinnvoll sein, eine der reinen Klassen zu instanziieren, da diese
Sie haben einfach keine Zugriffsvorgänge auf das Betriebssystem.

BASIC VERWENDUNG

Importieren der Modulklassen:

>>> aus Pathlib-Import *

Unterverzeichnisse auflisten:

>>> p = Pfad('.')
>>> [x für x in p.iterdir() if x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
PosixPath('__pycache__'), PosixPath('build')]

Auflistung der 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')]

Navigieren in einem Verzeichnisbaum:

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

Pfadeigenschaften abfragen:

>>> q.exists()
Wahre
>>> q.is_dir()
falsch

Eine Datei öffnen:

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

PURE PFADE

Reine Pfadobjekte stellen Pfadverarbeitungsoperationen bereit, die nicht wirklich auf a zugreifen
Dateisystem. Es gibt drei Möglichkeiten, auf diese Klassen zuzugreifen, die wir auch nennen Aromen:

Klasse pathlib.PurePath(*pathsegments)
Eine generische Klasse, die die Pfadvariante des Systems darstellt (instanziiert).
entweder ein PurePosixPath oder eine PureWindowsPath):

>>> PurePath('setup.py') # Läuft auf einer Unix-Maschine
PurePosixPath('setup.py')

Jedes Element von Pfadsegmente kann entweder ein String- oder ein Byte-Objekt sein, das a darstellt
Pfadsegment; es kann auch ein anderes Pfadobjekt sein:

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

Wann Pfadsegmente leer ist, wird das aktuelle Verzeichnis angenommen:

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

Wenn mehrere absolute Pfade angegeben sind, wird der letzte als Anker genommen (Nachahmung).
os.path.join ()'s Verhalten):

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

Allerdings wird in einem Windows-Pfad durch die Änderung des lokalen Stammverzeichnisses das vorherige nicht verworfen
Antriebseinstellung:

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

Falsche Schrägstriche und einzelne Punkte werden ausgeblendet, doppelte Punkte ('..') sind nicht,
da dies die Bedeutung eines Pfades angesichts symbolischer Links verändern würde:

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

(ein naiver Ansatz würde ausreichen PurePosixPath('foo/../bar') entspricht
PurePosixPath('bar'), was falsch ist, wenn foo ist eine symbolische Verbindung zu einem anderen
Verzeichnis)

Klasse pathlib.PurePosixPath(*pathsegments)
Eine Unterklasse von PurePath, diese Pfadvariante stellt Nicht-Windows-Dateisystempfade dar:

>>> PurePosixPath('/ Etc')
PurePosixPath('/ Etc')

Pfadsegmente wird ähnlich angegeben PurePath.

Klasse pathlib.PureWindowsPath(*pathsegments)
Eine Unterklasse von PurePath, diese Pfadvariante stellt Windows-Dateisystempfade dar:

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

Pfadsegmente wird ähnlich angegeben PurePath.

Unabhängig davon, auf welchem ​​System Sie arbeiten, können Sie alle diese Klassen instanziieren.
da sie keine Operation bereitstellen, die Systemaufrufe ausführt.

Allgemein immobilien
Pfade sind unveränderlich und hashbar. Wege gleicher Art sind vergleichbar und bestellbar.
Diese Eigenschaften respektieren die Groß-/Kleinschreibungssemantik der Variante:

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

Pfade unterschiedlicher Geschmacksrichtung sind ungleich und können nicht bestellt werden:

>>> PureWindowsPath('foo') == PurePosixPath('foo')
falsch
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (jüngste Aufforderung zuletzt):
Datei " ", Zeile 1, in
TypeError: nicht ordbare Typen: PureWindowsPath() < PurePosixPath()

Betreiber
Der Schrägstrich-Operator hilft beim Erstellen untergeordneter Pfade, ähnlich wie os.path.join:

>>> p = PurePath('/ Etc')
>>>S
PurePosixPath('/ Etc')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/ usr' / Q
PurePosixPath('/ usr / bin')

Die Zeichenfolgendarstellung eines Pfads ist der rohe Dateisystempfad selbst (in nativer Form,
z. B. mit Backslashes unter Windows), die Sie an jede Funktion übergeben können, die eine Datei entgegennimmt
Pfad als String:

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

Ebenso anrufen Bytes on a path gibt den rohen Dateisystempfad als Byte-Objekt an, als
Codiert von os.fsencode:

>>> Bytes(p)
b'/ Etc'

Zugriff auf Krankengymnastik 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 Pfads ermöglicht:

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

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

(Beachten Sie, dass das Laufwerk und das lokale Stammverzeichnis in einem einzigen Teil zusammengefasst sind.)

Methoden und immobilien
Reine Pfade stellen die folgenden Methoden und Eigenschaften bereit:

PurePath.drive
Eine Zeichenfolge, die den Laufwerksbuchstaben oder -namen darstellt, falls vorhanden:

>>> PureWindowsPath('c:/Program Files/').drive
'C:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/ Etc').fahren
''

Auch UNC-Freigaben gelten als Laufwerke:

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

PurePath.root
Eine Zeichenfolge, die ggf. den (lokalen oder globalen) Stamm darstellt:

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Programme/').root
''
>>> PurePosixPath('/ Etc').Wurzel
'/'

UNC-Freigaben haben immer einen Root:

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

PurePath.anker
Die Verkettung von Laufwerk und Root:

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

PurePath.parents
Eine unveränderliche Sequenz, die Zugriff auf die logischen Vorfahren des Pfads bietet:

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

PurePath.parent
Das logische übergeordnete Element des Pfads:

>>> 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('.')

Anmerkungen:
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 dies empfohlen
erster Aufruf Path.resolve() um Symlinks aufzulösen und zu beseitigen ".."
Komponenten.

PurePath.name
Eine Zeichenfolge, die die endgültige Pfadkomponente darstellt, mit Ausnahme des Laufwerks und des Stammverzeichnisses, falls
beliebig:

>>> 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
Die Dateierweiterung der endgültigen Komponente, falls vorhanden:

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

PurePath.suffixes
Eine Liste der Dateierweiterungen des Pfads:

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

PurePath.stem
Die letzte Pfadkomponente ohne ihr Suffix:

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

PurePath.as_posix()
Gibt eine Zeichenfolgendarstellung des Pfads mit Schrägstrichen zurück (/):

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

PurePath.as_uri()
Stellen Sie den Pfad als dar Datei TYP. WertFehler wird ausgelöst, wenn der Pfad nicht absolut ist.

>>> p = PurePosixPath('/ etc / passwd')
>>> p.as_uri()
'Datei:/// etc / passwd'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'file:///c:/Windows'

PurePath.is_absolute()
Gibt zurück,ob der Pfad absolut ist oder nicht. Ein Pfad gilt als absolut, wenn er
hat sowohl eine Wurzel als auch (sofern es die Variante zulässt) ein Laufwerk:

>>> PurePosixPath('/a/b').is_absolute()
Wahre
>>> PurePosixPath('a/b').is_absolute()
falsch

>>> PureWindowsPath('c:/a/b').is_absolute()
Wahre
>>> PureWindowsPath('/a/b').is_absolute()
falsch
>>> PureWindowsPath('c:').is_absolute()
falsch
>>> PureWindowsPath('//some/share').is_absolute()
Wahre

PurePath.is_reserved()
Bei PureWindowsPath, Rückkehr Wahre wenn der Pfad unter Windows als reserviert gilt,
falsch ansonsten. Mit PurePosixPath, falsch wird immer zurückgegeben.

>>> PureWindowsPath('nul').is_reserved()
Wahre
>>> PurePosixPath('nul').is_reserved()
falsch

Dateisystemaufrufe auf reservierten Pfaden können auf mysteriöse Weise oder unbeabsichtigt fehlschlagen
Effekte.

PurePath.joinpath(*other)
Der Aufruf dieser Methode entspricht dem Kombinieren des Pfads mit jedem der mehr
Argumente der Reihe nach:

>>> 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.match(Muster)
Vergleichen Sie diesen Pfad mit dem bereitgestellten Muster im Glob-Stil. Zurückkehren Wahre wenn passend
ist erfolgreich, falsch Andernfalls.

If Anleitungen relativ ist, kann der Pfad entweder relativ oder absolut sein und übereinstimmen
erfolgt von rechts:

>>> PurePath('a/b.py').match('*.py')
Wahre
>>> PurePath('/a/b/c.py').match('b/*.py')
Wahre
>>> PurePath('/a/b/c.py').match('a/*.py')
falsch

If Anleitungen absolut ist, muss der Pfad absolut sein und der gesamte Pfad muss übereinstimmen:

>>> PurePath('/a.py').match('/*.py')
Wahre
>>> PurePath('a/b.py').match('/*.py')
falsch

Wie bei anderen Methoden wird die Groß-/Kleinschreibung beachtet:

>>> PureWindowsPath('b.py').match('*.PY')
Wahre

PurePath.relative_to(*other)
Berechnen Sie eine Version dieses Pfades relativ zu dem durch dargestellten Pfad mehr. Wenn es
unmöglich, ValueError wird ausgelöst:

>>> p = PurePosixPath('/ etc / passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/ Etc')
PurePosixPath('passwd')
>>> p.relative_to('/ usr')
Traceback (jüngste Aufforderung zuletzt):
Datei " ", Zeile 1, in
Datei „pathlib.py“, Zeile 694, in relative_to
.format(str(self), str(formatted)))
ValueError: '/ etc / passwd' beginnt nicht mit '/ usr'

PurePath.with_name(name)
Geben Sie einen neuen Pfad mit dem zurück Name geändert. Wenn der ursprüngliche Pfad keinen Namen hat,
ValueError wird 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 (jüngste Aufforderung zuletzt):
Datei " ", Zeile 1, in
Datei „/home/antoine/cpython/default/Lib/pathlib.py“, Zeile 751, in with_name
raise ValueError("%r hat einen leeren Namen" % (self,))
ValueError: PureWindowsPath('c:/') hat einen leeren Namen

PurePath.with_suffix(suffix)
Geben Sie einen neuen Pfad mit dem zurück Suffix geändert. Wenn der ursprüngliche Pfad keine hat
Suffix, das Neue Suffix Stattdessen wird angehängt:

>>> 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')

BETON PFADE

Konkrete Pfade sind Unterklassen der reinen Pfadklassen. Neben Operationen
Von Letzterem bereitgestellt, stellen sie auch Methoden bereit, um Systemaufrufe für Pfadobjekte durchzuführen.
Es gibt drei Möglichkeiten, konkrete Pfade zu instanziieren:

Klasse pathlib.Path(*pathsegments)
Eine Unterklasse von PurePathDiese Klasse repräsentiert konkrete Pfade des Systempfads
Flavour (Instanziierung erzeugt entweder a PosixPath oder eine WindowsPath):

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

Pfadsegmente wird ähnlich angegeben PurePath.

Klasse pathlib.PosixPath(*pathsegments)
Eine Unterklasse von Path und PurePosixPath, diese Klasse repräsentiert konkrete Nicht-Windows
Dateisystempfade:

>>> PosixPath('/ Etc')
PosixPath('/ Etc')

Pfadsegmente wird ähnlich angegeben PurePath.

Klasse pathlib.WindowsPath(*pathsegments)
Eine Unterklasse von Path und PureWindowsPath, diese Klasse repräsentiert konkrete Windows
Dateisystempfade:

>>> WindowsPath('c:/Programme/')
WindowsPath('c:/Programme')

Pfadsegmente wird ähnlich angegeben PurePath.

Sie können nur die Klassenvariante instanziieren, die Ihrem System entspricht (was zulässt).
Systemaufrufe für nicht kompatible Pfadvarianten können zu Fehlern oder Ausfällen in Ihrem System führen
Anwendung):

>>> Betriebssystem importieren
>>> Betriebssystemname
'posix'
>>> Pfad('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (jüngste Aufforderung zuletzt):
Datei " ", Zeile 1, in
Datei „pathlib.py“, Zeile 798, in __new__
% (cls.__name__,))
NotImplementedError: „WindowsPath“ kann auf Ihrem System nicht instanziiert werden

Methoden
Konkrete Pfade bieten zusätzlich zu reinen Pfadmethoden die folgenden Methoden. Viele von
Diese Methoden können ein Problem verursachen OSError wenn ein Systemaufruf fehlschlägt (z. B. weil der Pfad
existiert nicht):

Klassenmethode Path.cwd()
Gibt ein neues Pfadobjekt zurück, das das aktuelle Verzeichnis darstellt (wie von zurückgegeben).
os.getcwd()):

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

Path.stat()
Gibt Informationen zu diesem Pfad zurück (ähnlich wie os.stat()). Das Ergebnis wird angeschaut
wird bei jedem Aufruf dieser Methode angezeigt.

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

Path.chmod(Modus)
Ändern Sie den Dateimodus und die Berechtigungen, z os.chmod():

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

Path.exists()
Ob der Pfad auf eine vorhandene Datei oder ein vorhandenes Verzeichnis verweist:

>>> aus Pathlib-Import *
>>> Path('.').exists()
Wahre
>>> Path('setup.py').exists()
Wahre
>>> Pfad('/ Etc').exists()
Wahre
>>> Path('nonexistentfile').exists()
falsch

Path.glob(Muster)
Glob das Gegebene Anleitungen in dem durch diesen Pfad dargestellten Verzeichnis, was alle ergibt
passende Dateien (jeglicher Art):

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

Die "**„Muster bedeutet „dieses Verzeichnis und alle Unterverzeichnisse, rekursiv“. In
Mit anderen Worten, es ermöglicht rekursives Globbing:

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

Anmerkungen:
Verwendung der "**" Muster in großen Verzeichnisbäumen kann übermäßig viel verbrauchen
Zeit.

Path.group()
Gibt den Namen der Gruppe zurück, der die Datei gehört. Schlüsselfehler wird ausgelöst, wenn die GID der Datei
wird nicht in der Systemdatenbank gefunden.

Path.is_dir()
Return Wahre wenn der Pfad auf ein Verzeichnis zeigt (oder ein symbolischer Link, der auf ein
Verzeichnis), falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.is_file()
Return Wahre wenn der Pfad auf eine reguläre Datei zeigt (oder ein symbolischer Link, der auf eine
reguläre Datei), falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.is_symlink()
Return Wahre wenn der Pfad auf einen symbolischen Link verweist, falsch Andernfalls.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert; andere Fehler (z. B. Erlaubnis
Fehler) werden weitergegeben.

Path.is_socket()
Return Wahre wenn der Pfad auf einen Unix-Socket zeigt (oder ein symbolischer Link, der auf einen
Unix-Socket), falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.is_fifo()
Return Wahre wenn der Pfad auf einen FIFO zeigt (oder ein symbolischer Link, der auf einen FIFO zeigt),
falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.is_block_device()
Return Wahre wenn der Pfad auf ein Blockgerät zeigt (oder ein symbolischer Link, der auf ein
Blockgerät), falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.is_char_device()
Return Wahre wenn der Pfad auf ein Zeichengerät zeigt (oder auf einen symbolischen Link).
zu einem Zeichengerät), falsch wenn es auf eine andere Art von Datei verweist.

falsch wird auch zurückgegeben, wenn der Pfad nicht existiert oder ein defekter Symlink ist; andere
Fehler (z. B. Berechtigungsfehler) werden weitergegeben.

Path.iterdir()
Wenn der Pfad auf ein Verzeichnis zeigt, werden Pfadobjekte des Verzeichnisinhalts zurückgegeben:

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

Path.lchmod(Modus)
Like Path.chmod() Wenn der Pfad jedoch auf einen symbolischen Link zeigt, wird der symbolische Link angezeigt
Der Modus wird geändert und nicht der seines Ziels.

Path.lstat()
Like Path.stat() Wenn der Pfad jedoch auf einen symbolischen Link zeigt, wird der symbolische Link zurückgegeben
Die Informationen des Links und nicht die seines Ziels.

Path.mkdir(mode=0o777, Eltern=Falsch)
Erstellen Sie unter diesem angegebenen Pfad ein neues Verzeichnis. Wenn Modus gegeben ist, wird es mit kombiniert
der Prozess' umask Wert, um den Dateimodus und die Zugriffsflags zu bestimmen. Wenn der Weg
ist bereits vorhanden, OSError angehoben wird.

If Eltern stimmt, alle fehlenden übergeordneten Elemente dieses Pfads werden nach Bedarf erstellt; Sie
werden mit den Standardberechtigungen erstellt, ohne sie zu übernehmen Modus berücksichtigen
(Nachahmung des POSIX mkdir -p Befehl).

If Eltern falsch ist (Standardeinstellung), wird ein fehlendes übergeordnetes Element ausgelöst OSError.

Path.open(mode='r', Pufferung=-1, Kodierung=Keine, Fehler=Keine, newline=Keine)
Öffnen Sie die Datei, auf die der Pfad verweist, wie in der integrierten Datei öffnen() Funktion macht:

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

Path.owner()
Gibt den Namen des Benutzers zurück, dem die Datei gehört. Schlüsselfehler wird ausgelöst, wenn die UID der Datei
wird nicht in der Systemdatenbank gefunden.

Path.rename(target)
Benennen Sie diese Datei oder dieses Verzeichnis in das angegebene um Ziel. Ziel kann entweder eine Zeichenfolge sein
oder ein anderes Pfadobjekt:

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

Path.replace(target)
Benennen Sie diese Datei oder dieses Verzeichnis in das angegebene um Ziel. Wenn Ziel weist auf eine vorhandene hin
Datei oder Verzeichnis, wird es bedingungslos ersetzt.

Diese Methode ist nur mit Python 3.3 verfügbar; es wird steigen Nicht implementierter Fehler on
frühere Python-Versionen.

Path.resolve()
Machen Sie den Pfad absolut und lösen Sie alle symbolischen Links auf. Es wird ein neues Pfadobjekt zurückgegeben:

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

".." Komponenten werden ebenfalls eliminiert (dies ist die einzige Möglichkeit, dies zu tun):

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

Wenn der Pfad nicht existiert, wird ein OSError wird angehoben. Wenn eine Endlosschleife vorliegt
auf dem Lösungsweg angetroffen werden, Laufzeit Fehler angehoben wird.

Path.rglob(Muster)
Das ist wie ein Anruf glob () mit "**" vor dem angegebenen hinzugefügt Anleitungen:

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

Path.rmdir()
Entfernen Sie dieses Verzeichnis. Das Verzeichnis muss leer sein.

Path.symlink_to(target, target_is_directory=False)
Machen Sie diesen Pfad zu einem symbolischen Link Ziel. Unter Windows, target_is_directory sollen
wahr sein (Standard falsch), wenn das Ziel des Links ein Verzeichnis ist. Unter POSIX,
target_is_directoryDer Wert wird 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

Anmerkungen:
Die Reihenfolge der Argumente (Link, Ziel) ist umgekehrt os.symlink()'S.

Path.touch(mode=0o777, exist_ok=True)
Erstellen Sie eine Datei unter diesem angegebenen Pfad. Wenn Modus gegeben ist, wird es mit dem kombiniert
Verfahren' umask Wert, um den Dateimodus und die Zugriffsflags zu bestimmen. Wenn die Datei
bereits existiert, ist die Funktion erfolgreich, wenn exist_ok ist wahr (und seine Modifikation
andernfalls wird die Uhrzeit auf die aktuelle Uhrzeit aktualisiert OSError angehoben wird.

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

Verwenden Sie Pathlib online über die Dienste von onworks.net