pathlib - En ligne dans le Cloud

PROGRAMME:

Nom

pathlib - Documentation pathlib

Manipuler les chemins du système de fichiers en tant qu'objets de chaîne peut rapidement devenir fastidieux : plusieurs
appelle à os.path.join () or os.chemin.dirname(), etc. Ce module propose un ensemble de cours
présentant toutes les opérations courantes sur les chemins d'une manière simple et orientée objet.

Ce module est mieux utilisé avec Python 3.2 ou version ultérieure, mais il est également compatible avec Python
2.7.

NOTE:
Ce module a été inclus dans la bibliothèque standard Python 3.4 après PEP 428
acceptation. Vous n'avez besoin de l'installer que pour Python 3.3 ou une version antérieure.

VOIR AUSSI:
PEP 428: Justification de la conception finale de pathlib et de l'API.

TÉLÉCHARGER

Des versions autonomes sont disponibles sur PyPI : http://pypi.python.org/pypi/pathlib/

Le développement principal a maintenant lieu dans la bibliothèque standard Python : voir le Python
développeur guide.

Le référentiel de maintenance de ce module de backport autonome se trouve sur BitBucket,
mais l'activité devrait être assez faible : https://bitbucket.org/pitrou/pathlib/

HAUT NIVEAU VOIR

Ce module propose des classes représentant les chemins du système de fichiers avec une sémantique appropriée pour
différents systèmes d'exploitation. Les classes de chemin sont réparties entre pur chemins, qui fournissent
opérations purement informatiques sans E/S, et béton chemins, qui héritent du pur
chemins, mais fournissent également des opérations d'E/S. [image]

Si vous n'avez jamais utilisé ce module auparavant ou si vous n'êtes tout simplement pas sûr de la classe qui convient à votre
tâche, Chemin est probablement ce dont vous avez besoin. Il instancie un béton chemin pour la plateforme
le code est en cours d'exécution.

Les chemins purs sont utiles dans certains cas particuliers ; par exemple:

1. Si vous souhaitez manipuler les chemins Windows sur une machine Unix (ou vice versa). Vous ne pouvez pas
instancier un Chemin Windows lors de l'exécution sur Unix, mais vous pouvez instancier
PureWindowsPath.

2. Vous voulez vous assurer que votre code ne manipule que les chemins sans réellement accéder
le système d'exploitation. Dans ce cas, l'instanciation d'une des classes pures peut être utile puisque celles-ci
n'avez tout simplement aucune opération d'accès au système d'exploitation.

BASIQUE UTILISATION

Importation des classes du module :

>>> à partir de l'importation pathlib *

Liste des sous-répertoires :

>>> p = Chemin('.')
>>> [x pour x dans p.iterdir() si x.is_dir()]
[Chemin Posix('.hg'), Chemin Posix('docs'), Chemin Posix('dist'),
PosixPath('__pycache__'), PosixPath('build')]

Liste des fichiers source Python dans cette arborescence de répertoires :

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

Naviguer dans une arborescence de répertoires :

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

Interrogation des propriétés du chemin :

>>> q.existe()
Vrai
>>> q.is_dir()
Faux

Ouvrir un fichier :

>>> avec q.open() comme f : f.readline()

'#!/ bin / bash\n'

PURE Les chemins

Les objets de chemin pur fournissent des opérations de gestion de chemin qui n'accèdent pas réellement à un
système de fichiers. Il existe trois façons d'accéder à ces classes, que nous appelons également les saveurs:

classe pathlib.PurePath(*pathsegments)
Une classe générique qui représente la saveur du chemin du système (l'instanciation crée
soit un PurePosixPath ou PureWindowsPath):

>>> PurePath('setup.py') # Exécution sur une machine Unix
PurePosixPath('setup.py')

Chaque élément de segments de chemin peut être un objet chaîne ou octets représentant un
segment de chemin ; il peut également s'agir d'un autre objet chemin :

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

Lorsque segments de chemin est vide, le répertoire courant est supposé :

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

Lorsque plusieurs chemins absolus sont donnés, le dernier est pris comme ancre (imitant
os.path.join ()comportement de ):

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

Cependant, dans un chemin Windows, la modification de la racine locale ne supprime pas la précédente
réglage du lecteur :

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

Les barres obliques et les points simples sont réduits, mais les points doubles ('..') ne sont pas,
car cela changerait le sens d'un chemin face aux liens symboliques :

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

(une approche naïve rendrait PurePosixPath('foo/../bar') équivalente à
PurePosixPath('bar'), ce qui est faux si foo est un lien symbolique vers un autre
annuaire)

classe pathlib.PurePosixPath(*pathsegments)
Une sous-classe de Chemin pur, cette variante de chemin représente des chemins de système de fichiers non Windows :

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

segments de chemin est spécifié de la même manière que Chemin pur.

classe pathlib.PureWindowsPath(*pathsegments)
Une sous-classe de Chemin pur, cette variante de chemin représente les chemins du système de fichiers Windows :

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

segments de chemin est spécifié de la même manière que Chemin pur.

Quel que soit le système sur lequel vous exécutez, vous pouvez instancier toutes ces classes,
car ils ne fournissent aucune opération qui effectue des appels système.

Général propriétés
Les chemins sont immuables et hachables. Les chemins d'une même saveur sont comparables et commandables.
Ces propriétés respectent la sémantique de pliage de la saveur :

>>> PurePosixPath('FOO') == PurePosixPath('FOO')
Faux
>>> PureWindowsPath('FOO') == PureWindowsPath('FOO')
Vrai
>>> PureWindowsPath('FOO') dans { PureWindowsPath('foo') }
Vrai
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
Vrai

Les chemins d'une saveur différente sont inégaux et ne peuvent pas être commandés :

>>> PureWindowsPath('foo') == PurePosixPath('foo')
Faux
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (appel le plus récent dernier):
Fichier " ", ligne 1, dans
TypeError : types non ordonnés : PureWindowsPath() < PurePosixPath()

Les opérateurs
L'opérateur slash permet de créer des chemins enfants, de la même manière que os.path.join:

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

La représentation sous forme de chaîne d'un chemin est le chemin brut du système de fichiers lui-même (sous forme native,
par exemple avec des barres obliques inverses sous Windows), que vous pouvez passer à n'importe quelle fonction prenant un fichier
chemin sous forme de chaîne :

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

De même, appeler octets sur un chemin donne le chemin brut du système de fichiers en tant qu'objet d'octets, comme
codé par os.fsencode:

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

Accès individuels les pièces
Pour accéder aux "parties" individuelles (composants) d'un chemin, utilisez la propriété suivante :

PurePath.parts
Un tuple donnant accès aux différents composants du chemin :

>>> p = PurePath('/usr/bin/python3')
>>> p.pièces
('/', 'usr', 'bin', 'python3')

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

(notez comment le lecteur et la racine locale sont regroupés en une seule partie)

Méthodologie et propriétés
Les chemins purs fournissent les méthodes et propriétés suivantes :

PurePath.drive
Une chaîne représentant la lettre ou le nom du lecteur, le cas échéant :

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

Les partages UNC sont également considérés comme des lecteurs :

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\hôte\\partage'

PurePath.root
Une chaîne représentant la racine (locale ou globale), le cas échéant :

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

Les partages UNC ont toujours une racine :

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

PurePath.ancre
La concaténation du lecteur et de la racine :

>>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'c:'
>>> PurePosixPath('/ Etc').ancre
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\hôte\\partage\\'

PurePath.parents
Une séquence immuable donnant accès aux ancêtres logiques du chemin :

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

PurePath.parent
Le parent logique du chemin :

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

Vous ne pouvez pas dépasser une ancre ou un chemin vide :

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

NOTE:
Il s'agit d'une opération purement lexicale, d'où le comportement suivant :

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

Si vous voulez remonter un chemin de système de fichiers arbitraire, il est recommandé de
premier appel Chemin.resolve() afin de résoudre les liens symboliques et d'éliminer ".."
composants.

PurePath.nom
Une chaîne représentant le composant de chemin final, à l'exclusion du lecteur et de la racine, si
tout:

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

Les noms de lecteur UNC ne sont pas pris en compte :

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

PurePath.suffixe
L'extension de fichier du composant final, le cas échéant :

>>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffixe
'.gz'
>>> PurePosixPath('ma/bibliothèque').suffixe
''

PurePath.suffixes
Une liste des extensions de fichier du chemin :

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

PurePath.stem
Le composant de chemin final, sans son suffixe :

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

PurePath.as_posix()
Renvoie une représentation sous forme de chaîne du chemin avec des barres obliques (/):

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

PurePath.as_uri()
Représenter le chemin comme un filet TAPER. Erreur de valeur est levé si le chemin n'est pas absolu.

>>> p = PurePosixPath('/ Etc / passwd')
>>> p.as_uri()
'déposer:/// Etc / passwd'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'fichier:///c:/Windows'

PurePath.is_absolute()
Renvoie si le chemin est absolu ou non. Un chemin est considéré comme absolu s'il
a à la fois une racine et (si la saveur le permet) un lecteur :

>>> PurePosixPath('/a/b').is_absolute()
Vrai
>>> PurePosixPath('a/b').is_absolute()
Faux

>>> PureWindowsPath('c:/a/b').is_absolute()
Vrai
>>> PureWindowsPath('/a/b').is_absolute()
Faux
>>> PureWindowsPath('c:').is_absolute()
Faux
>>> PureWindowsPath('//some/share').is_absolute()
Vrai

PurePath.is_reserved()
Chez PureWindowsPath, revenir Vrai si le chemin est considéré comme réservé sous Windows,
Faux autrement. Avec PurePosixPath, Faux est toujours retourné.

>>> PureWindowsPath('nul').is_reserved()
Vrai
>>> PurePosixPath('nul').is_reserved()
Faux

Les appels du système de fichiers sur les chemins réservés peuvent échouer mystérieusement ou avoir des
effets.

PurePath.joinpath(*autre)
Appeler cette méthode équivaut à combiner le chemin avec chacun des autre
arguments tour à tour :

>>> 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(motif)
Faites correspondre ce chemin avec le modèle de style glob fourni. Revenir Vrai si correspondant
est réussi, Faux autrement.

If modèle est relatif, le chemin peut être relatif ou absolu, et la correspondance
se fait à partir de la droite :

>>> PurePath('a/b.py').match('*.py')
Vrai
>>> PurePath('/a/b/c.py').match('b/*.py')
Vrai
>>> PurePath('/a/b/c.py').match('a/*.py')
Faux

If modèle est absolu, le chemin doit être absolu et le chemin entier doit correspondre :

>>> PurePath('/a.py').match('/*.py')
Vrai
>>> PurePath('a/b.py').match('/*.py')
Faux

Comme avec d'autres méthodes, la sensibilité à la casse est observée :

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

PurePath.relative_to(*autre)
Calculer une version de ce chemin par rapport au chemin représenté par autre. Si c'est
impossible, ValueError est levée :

>>> p = PurePosixPath('/ Etc / passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/ Etc')
PurePosixPath('passwd')
>>> p.relative_to('/ usr')
Traceback (appel le plus récent dernier):
Fichier " ", ligne 1, dans
Fichier "pathlib.py", ligne 694, dans relative_to
.format(str(self), str(formaté)))
ValueError : '/ Etc / passwd' ne commence pas par '/ usr'

PurePath.with_name(nom)
Retournez un nouveau chemin avec le prénom modifié. Si le chemin d'origine n'a pas de nom,
ValueError est levée :

>>> 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 (appel le plus récent dernier):
Fichier " ", ligne 1, dans
Fichier "/home/antoine/cpython/default/Lib/pathlib.py", ligne 751, dans with_name
augmenter ValueError("%r a un nom vide" % (self,))
ValueError : PureWindowsPath('c:/') a un nom vide

PurePath.with_suffix(suffixe)
Retournez un nouveau chemin avec le suffixe modifié. Si le chemin d'origine n'a pas de
suffixe, le nouveau suffixe est ajouté à la place :

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

BÉTON Les chemins

Les chemins concrets sont des sous-classes des classes de chemins purs. En plus des opérations
fournis par ce dernier, ils fournissent également des méthodes pour faire des appels système sur des objets chemin.
Il existe trois façons d'instancier des chemins concrets :

classe pathlib.Path(*pathsegments)
Une sous-classe de Chemin pur, cette classe représente les chemins concrets du chemin du système
saveur (l'instanciation crée soit un Chemin Posix ou Chemin Windows):

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

segments de chemin est spécifié de la même manière que Chemin pur.

classe pathlib.PosixPath(*pathsegments)
Une sous-classe de Chemin et PurePosixPath, cette classe représente du béton non Windows
chemins du système de fichiers :

>>> Chemin Posix('/ Etc')
Chemin Posix('/ Etc')

segments de chemin est spécifié de la même manière que Chemin pur.

classe pathlib.WindowsPath(*pathsegments)
Une sous-classe de Chemin et PureWindowsPath, cette classe représente des fenêtres concrètes
chemins du système de fichiers :

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

segments de chemin est spécifié de la même manière que Chemin pur.

Vous ne pouvez instancier que la saveur de classe qui correspond à votre système (permettant
les appels système sur des chemins non compatibles peuvent entraîner des bogues ou des échecs dans votre
application):

>>> importer le système d'exploitation
>>> os.nom
'positif'
>>> Chemin('setup.py')
PosixPath('setup.py')
>>> Chemin Posix('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (appel le plus récent dernier):
Fichier " ", ligne 1, dans
Fichier "pathlib.py", ligne 798, dans __new__
% (cls.__nom__,))
NotImplementedError : impossible d'instancier 'WindowsPath' sur votre système

Méthodologie
Les chemins concrets fournissent les méthodes suivantes en plus des méthodes de chemins purs. Un grand nombre de
ces méthodes peuvent soulever une OSErreur si un appel système échoue (par exemple parce que le chemin
n'existe pas):

méthode de classe Chemin.cwd()
Renvoie un nouvel objet chemin représentant le répertoire courant (tel que renvoyé par
os.getcwd()):

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

Chemin.stat()
Renvoie des informations sur ce chemin (de la même manière que os.stat()). Le résultat est regardé
à chaque appel de cette méthode.

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

Chemin.chmod(mode)
Changez le mode de fichier et les autorisations, comme os.chmod():

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

Chemin.existe()
Que le chemin pointe vers un fichier ou un répertoire existant :

>>> à partir de l'importation pathlib *
>>> Chemin('.').exists()
Vrai
>>> Chemin('setup.py').exists()
Vrai
>>> Chemin('/ Etc').existe()
Vrai
>>> Path('nonexistantfile').exists()
Faux

Chemin.glob(motif)
Glob le donné modèle dans le répertoire représenté par ce chemin, donnant tous
fichiers correspondants (de toute nature) :

>>> trié(Chemin('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
>>> trié(Chemin('.').glob('*/*.py'))
[Chemin Posix('docs/conf.py')]

"**" pattern signifie "ce répertoire et tous les sous-répertoires, de manière récursive".
en d'autres termes, il permet le globbing récursif :

>>> trié(Chemin('.').glob('**/*.py'))
[Chemin Posix('build/lib/pathlib.py'),
PosixPath('docs/conf.py'),
PosixPath('pathlib.py'),
PosixPath('setup.py'),
PosixPath('test_pathlib.py')]

NOTE:
En utilisant le "**" Le motif dans les grandes arborescences de répertoires peut consommer une quantité excessive
de temps.

Chemin.group()
Renvoie le nom du groupe propriétaire du fichier. Erreur de clé est levé si le gid du fichier
n'est pas trouvé dans la base de données système.

Chemin.is_dir()
Retour Vrai si le chemin pointe vers un répertoire (ou un lien symbolique pointant vers un
annuaire), Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.is_file()
Retour Vrai si le chemin pointe vers un fichier normal (ou un lien symbolique pointant vers un
fichier ordinaire), Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.is_symlink()
Retour Vrai si le chemin pointe vers un lien symbolique, Faux autrement.

Faux est également renvoyé si le chemin n'existe pas ; d'autres erreurs (telles que l'autorisation
erreurs) se propagent.

Chemin.is_socket()
Retour Vrai si le chemin pointe vers une socket Unix (ou un lien symbolique pointant vers un
socket Unix), Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.is_fifo()
Retour Vrai si le chemin pointe vers une FIFO (ou un lien symbolique pointant vers une FIFO),
Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.is_block_device()
Retour Vrai si le chemin pointe vers un périphérique bloc (ou un lien symbolique pointant vers un
périphérique de blocage), Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.is_char_device()
Retour Vrai si le chemin pointe vers un périphérique caractère (ou un lien symbolique pointant
à un périphérique de caractères), Faux s'il pointe vers un autre type de fichier.

Faux est également renvoyé si le chemin n'existe pas ou s'il s'agit d'un lien symbolique rompu ; autre
les erreurs (telles que les erreurs d'autorisation) sont propagées.

Chemin.iterdir()
Lorsque le chemin pointe vers un répertoire, renvoyez les objets chemin du contenu du répertoire :

>>> p = Chemin('docs')
>>> pour enfant dans p.iterdir() : enfant

PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('docs/_static')
PosixPath('docs/Makefile')

Chemin.lchmod(mode)
J'aime Chemin.chmod() mais, si le chemin pointe vers un lien symbolique, le lien symbolique
le mode est modifié plutôt que celui de sa cible.

Chemin.lstat()
J'aime Chemin.stat() mais, si le chemin pointe vers un lien symbolique, retourne le symbolique
les informations du lien plutôt que celles de sa cible.

Chemin.mkdir(mode=0o777, parents=Faux)
Créez un nouveau répertoire sur ce chemin donné. Si mode est donné, il est combiné avec
le processus' umask value pour déterminer le mode de fichier et les indicateurs d'accès. Si le chemin
existe déjà, OSErreur est soulevé.

If parents est vrai, tous les parents manquants de ce chemin sont créés selon les besoins ; elles ou ils
sont créés avec les autorisations par défaut sans prendre mode en compte
(imitant le POSIX mkdir -p commander).

If parents est faux (valeur par défaut), un parent manquant lève OSErreur.

Chemin.open(mode='r', mise en mémoire tampon=-1, encodage=Aucun, erreurs=Aucune, newline=Aucun)
Ouvrez le fichier pointé par le chemin, comme le fichier intégré ouvrir() la fonction fait :

>>> p = Chemin('setup.py')
>>> avec p.open() comme f :
... f.readline()

'#!/ usr / bin / env python3\n'

Chemin.propriétaire()
Renvoie le nom de l'utilisateur propriétaire du fichier. Erreur de clé est levé si l'uid du fichier
n'est pas trouvé dans la base de données système.

Chemin.renommer(cible)
Renommez ce fichier ou répertoire au nom donné l'objectif. l'objectif peut être soit une chaîne
ou un autre objet chemin :

>>> p = Chemin('foo')
>>> p.open('w').write('du texte')
9
>>> cible = Chemin('bar')
>>> p.renommer(cible)
>>> cible.open().read()
'Du texte'

Chemin.remplacer(cible)
Renommez ce fichier ou répertoire au nom donné l'objectif. Si l'objectif pointe vers un existant
fichier ou répertoire, il sera remplacé sans condition.

Cette méthode n'est disponible qu'avec Python 3.3 ; il augmentera NonImplementedError on
versions précédentes de Python.

Chemin.resolve()
Rendez le chemin absolu, en résolvant tous les liens symboliques. Un nouvel objet chemin est renvoyé :

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

".." les composants sont également éliminés (c'est la seule méthode pour le faire) :

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

Si le chemin n'existe pas, un OSErreur est élevé. Si une boucle infinie est
rencontrés le long du chemin de résolution, Erreur d'exécution est soulevé.

Chemin.rglob(motif)
C'est comme appeler globe () avec "**" ajouté devant le donné modèle:

>>> trié(Chemin().rglob("*.py"))
[Chemin Posix('build/lib/pathlib.py'),
PosixPath('docs/conf.py'),
PosixPath('pathlib.py'),
PosixPath('setup.py'),
PosixPath('test_pathlib.py')]

Chemin.rmdir()
Supprimez ce répertoire. Le répertoire doit être vide.

Path.symlink_to(cible, target_is_directory=Faux)
Faites de ce chemin un lien symbolique vers l'objectif. Sous Windows, target_is_directory doit
être vrai (par défaut Faux) si la cible du lien est un répertoire. Sous POSIX,
target_is_directoryLa valeur de est ignorée.

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

NOTE:
L'ordre des arguments (lien, cible) est l'inverse de os.symlink()'s.

Chemin.touch(mode=0o777, exist_ok=Vrai)
Créez un fichier à ce chemin donné. Si mode est donné, il est combiné avec le
traiter' umask value pour déterminer le mode de fichier et les indicateurs d'accès. Si le fichier
existe déjà, la fonction réussit si existe_ok est vrai (et sa modification
l'heure est mise à jour à l'heure actuelle), sinon OSErreur est soulevé.

Chemin.unlink()
Supprimez ce fichier ou lien symbolique. Si le chemin pointe vers un répertoire, utilisez
Chemin.rmdir() à la place.

Utiliser pathlib en ligne à l'aide des services onworks.net