11.1. pathlib
— Chemins de système de fichiers orientés objet¶
Nouveau dans la version 3.4.
Code source : Lib/pathlib.py
Ce module offre des classes représentant le système de fichiers avec la sémantique appropriée pour différents systèmes d’exploitation. Les classes de chemins sont divisées en chemins purs, qui fournissent purement du calcul sans entrées/sorties, et chemins concrets, qui héritent des chemins purs et fournissent également les opérations d’entrées/sorties.
Si vous n’avez jamais utilisé ce module précédemment, ou si vous n’êtes pas sûr de quelle classe est faite pour votre tâche, Path
est très certainement ce dont vous avez besoin. Elle instancie un chemin concret pour la plateforme sur laquelle s’exécute le code.
Les chemins purs sont utiles dans certains cas particuliers ; par exemple :
- Si vous voulez manipuler des chemins Windows sur une machine Unix (ou vice versa). Vous ne pouvez pas instancier un
WindowsPath
quand vous êtes sous Unix, mais vous pouvez instancierPureWindowsPath
. - Vous voulez être sûr que votre code manipule des chemins sans réellement accéder au système d’exploitation. Dans ce cas, instancier une de ces classes pures peut être utile puisqu’elle ne possède tout simplement aucune opérations permettant d’accéder au système d’exploitation.
Note
This module has been included in the standard library on a provisional basis. Backwards incompatible changes (up to and including removal of the package) may occur if deemed necessary by the core developers.
Voir aussi
PEP 428: Le module pathlib – chemins de système de fichiers orientés objet.
Voir aussi
Pour de la manipulation de chemins bas-niveau avec des chaînes de caractères, vous pouvez aussi utiliser le module os.path
.
11.1.1. Utilisation basique¶
Importer la classe principale :
>>> from pathlib import Path
Lister les sous-dossiers :
>>> p = Path('.')
>>> [x for x in p.iterdir() if x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
PosixPath('__pycache__'), PosixPath('build')]
Lister les fichiers source Python dans cette arborescence de dossiers :
>>> list(p.glob('**/*.py'))
[PosixPath('test_pathlib.py'), PosixPath('setup.py'),
PosixPath('pathlib.py'), PosixPath('docs/conf.py'),
PosixPath('build/lib/pathlib.py')]
Naviguer à l’intérieur d’une arborescence de dossiers :
>>> p = Path('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')
Récupérer les propriétés de chemin :
>>> q.exists()
True
>>> q.is_dir()
False
Ouvrir un fichier :
>>> with q.open() as f: f.readline()
...
'#!/bin/bash\n'
11.1.2. Chemins purs¶
Les objets chemins purs fournissent les opérations de gestion de chemin qui n’accèdent pas réellement au système de fichiers. Il y a trois façons d’accéder à ces classes que nous appelons aussi familles :
-
class
pathlib.
PurePath
(*pathsegments)¶ Une classe générique qui représente la famille de chemin du système (l’instancier crée soit un
PurePosixPath
soit unPureWindowsPath
) :>>> PurePath('setup.py') # Running on a Unix machine PurePosixPath('setup.py')
Each element of pathsegments can be either a string representing a path segment, or another path object:
>>> PurePath('foo', 'some/path', 'bar') PurePosixPath('foo/some/path/bar') >>> PurePath(Path('foo'), Path('bar')) PurePosixPath('foo/bar')
Quand pathsegments est vide, le dossier courant est utilisé :
>>> PurePath() PurePosixPath('.')
Quand plusieurs chemins absolus sont fournis, le dernier est pris comme ancre (recopiant le comportement de
os.path.join()
) :>>> PurePath('/etc', '/usr', 'lib64') PurePosixPath('/usr/lib64') >>> PureWindowsPath('c:/Windows', 'd:bar') PureWindowsPath('d:bar')
Cependant, dans un chemin Windows, changer la racine locale ne supprime pas la précédente configuration de lecteur :
>>> PureWindowsPath('c:/Windows', '/Program Files') PureWindowsPath('c:/Program Files')
Les points et slashs malencontreux sont supprimés, mais les doubles points (
'..'
) ne le sont pas, puisque cela changerait la signification du chemin dans le cas de liens symboliques :>>> PurePath('foo//bar') PurePosixPath('foo/bar') >>> PurePath('foo/./bar') PurePosixPath('foo/bar') >>> PurePath('foo/../bar') PurePosixPath('foo/../bar')
(une analyse naïve considérerait
PurePosixPath('foo/../bar')
équivalent àPurePosixPath('bar')
, ce qui est faux sifoo
est un lien symbolique vers un autre dossier)
-
class
pathlib.
PurePosixPath
(*pathsegments)¶ Une sous-classe de
PurePath
, cette famille de chemin représente les chemins de systèmes de fichiers en dehors des chemins Windows :>>> PurePosixPath('/etc') PurePosixPath('/etc')
pathsegments est spécifié de manière similaire à
PurePath
.
-
class
pathlib.
PureWindowsPath
(*pathsegments)¶ Une sous-classe de
PurePath
, cette famille de chemin représente les chemins de systèmes de fichiers Windows :>>> PureWindowsPath('c:/Program Files/') PureWindowsPath('c:/Program Files')
pathsegments est spécifié de manière similaire à
PurePath
.
Sans tenir compte du système sur lequel vous êtes, vous pouvez instancier toutes ces classes, puisqu’elle en fournissent aucune opération qui appelle le système d’exploitation.
11.1.2.1. Propriétés générales¶
Les chemins sont immuables et hachables. Les chemins d’une même famille sont comparables et ordonnables. Ces propriétés respectent l’ordre lexicographique défini par la famille :
>>> PurePosixPath('foo') == PurePosixPath('FOO')
False
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
True
>>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }
True
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
True
Les chemins de différentes familles ne sont pas égaux et ne peuvent être ordonnés :
>>> PureWindowsPath('foo') == PurePosixPath('foo')
False
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: PureWindowsPath() < PurePosixPath()
11.1.2.2. Opérateurs¶
L’opérateur slash aide à créer les chemins enfants, de manière similaire à 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 d’un chemin en chaîne de caractères est celle du chemin brut du système de fichiers lui-même (dans sa forme native, i.e. avec des antislashs sous Windows), et que vous pouvez passer à n’importe quelle fonction prenant un chemin en tant que chaîne de caractères :
>>> p = PurePath('/etc')
>>> str(p)
'/etc'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'c:\\Program Files'
De manière similaire, appeler bytes
sur un chemin donne le chemin brut du système de fichiers en tant que bytes, tel qu’encodé par os.fsencode()
:
>>> bytes(p)
b'/etc'
Note
Appeler bytes
est seulement recommandé sous Unix. Sous Windows, la forme Unicode est la représentation canonique des chemins du système de fichiers.
11.1.2.3. Accéder aux parties individuelles¶
Pour accéder aux parties individuelles (composantes) d’un chemin, utilisez les propriétés suivantes :
-
PurePath.
parts
¶ Un tuple donnant accès aux différentes composantes du chemin :
>>> p = PurePath('/usr/bin/python3') >>> p.parts ('/', 'usr', 'bin', 'python3') >>> p = PureWindowsPath('c:/Program Files/PSF') >>> p.parts ('c:\\', 'Program Files', 'PSF')
(notez comme le lecteur et la racine locale sont regroupée en une seule partie)
11.1.2.4. Méthodes 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 du lecteur ou le nom, s’il y en a un :
>>> PureWindowsPath('c:/Program Files/').drive 'c:' >>> PureWindowsPath('/Program Files/').drive '' >>> PurePosixPath('/etc').drive ''
Les partages UNC sont aussi considérés comme des lecteurs :
>>> PureWindowsPath('//host/share/foo.txt').drive '\\\\host\\share'
-
PurePath.
root
¶ Une chaîne de caractères représentant la racine (locale ou globale), s’il y en a une :
>>> PureWindowsPath('c:/Program Files/').root '\\' >>> PureWindowsPath('c:Program Files/').root '' >>> PurePosixPath('/etc').root '/'
Les partages UNC ont toujours une racine :
>>> PureWindowsPath('//host/share').root '\\'
-
PurePath.
anchor
¶ La concaténation du lecteur et de la racine :
>>> PureWindowsPath('c:/Program Files/').anchor 'c:\\' >>> PureWindowsPath('c:Program Files/').anchor 'c:' >>> PurePosixPath('/etc').anchor '/' >>> PureWindowsPath('//host/share').anchor '\\\\host\\share\\'
-
PurePath.
parents
¶ Une séquence immuable fournissant 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 aller au-delà d’une ancre, ou d’un chemin vide :
>>> p = PurePosixPath('/') >>> p.parent PurePosixPath('/') >>> p = PurePosixPath('.') >>> p.parent PurePosixPath('.')
Note
C’est une opération purement lexicale, d’où le comportement suivant :
>>> p = PurePosixPath('foo/..') >>> p.parent PurePosixPath('foo')
Si vous voulez parcourir un chemin arbitraire du système de fichiers, il est recommandé de d’abord appeler
Path.resolve()
de manière à résoudre les liens symboliques et éliminer les composantes « .. ».
-
PurePath.
name
¶ Une chaîne représentant la composante finale du chemin, en excluant le lecteur et la racine, si présent :
>>> PurePosixPath('my/library/setup.py').name 'setup.py'
Les noms de lecteur UNC ne sont pas pris en compte :
>>> PureWindowsPath('//some/share/setup.py').name 'setup.py' >>> PureWindowsPath('//some/share').name ''
-
PurePath.
suffix
¶ L’extension du fichier de la composante finale, si présente :
>>> PurePosixPath('my/library/setup.py').suffix '.py' >>> PurePosixPath('my/library.tar.gz').suffix '.gz' >>> PurePosixPath('my/library').suffix ''
-
PurePath.
suffixes
¶ Une liste des extensions du chemin de fichier :
>>> PurePosixPath('my/library.tar.gar').suffixes ['.tar', '.gar'] >>> PurePosixPath('my/library.tar.gz').suffixes ['.tar', '.gz'] >>> PurePosixPath('my/library').suffixes []
-
PurePath.
stem
¶ La composante finale du chemin, sans son suffixe :
>>> PurePosixPath('my/library.tar.gz').stem 'library.tar' >>> PurePosixPath('my/library.tar').stem 'library' >>> PurePosixPath('my/library').stem 'library'
-
PurePath.
as_posix
()¶ Renvoie une représentation en chaîne de caractères du chemin avec des slashs (
/
) :>>> p = PureWindowsPath('c:\\windows') >>> str(p) 'c:\\windows' >>> p.as_posix() 'c:/windows'
-
PurePath.
as_uri
()¶ Représente le chemin en tant qu’URI de fichier.
ValueError
est levée si le chemin n’est pas absolu.>>> p = PurePosixPath('/etc/passwd') >>> p.as_uri() 'file:///etc/passwd' >>> p = PureWindowsPath('c:/Windows') >>> p.as_uri() 'file:///c:/Windows'
-
PurePath.
is_absolute
()¶ Renvoie si le chemin est absolu ou non. Un chemin est considéré absolu s’il a une racine et un lecteur (si la famille le permet) :
>>> 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_reserved
()¶ Avec
PureWindowsPath
, renvoieTrue
si le chemin est considéré réservé sous Windows,False
sinon. AvecPurePosixPath
,False
est systématiquement renvoyé.>>> PureWindowsPath('nul').is_reserved() True >>> PurePosixPath('nul').is_reserved() False
Les appels au système de fichier sur des chemins réservés peuvent échouer mystérieusement ou avoir des effets inattendus.
-
PurePath.
joinpath
(*other)¶ Appeler cette méthode équivaut à combiner le chemin avec chacun des arguments other :
>>> 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
(pattern)¶ Fait correspondre ce chemin avec le motif (glob pattern) fourni. Renvoie
True
si la correspondance a réussi,False
sinon.Si pattern est relatif, le chemin peut être soit relatif, soit absolu, et la correspondance est faite à partir de la droite :
>>> 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
Si pattern est absolu, le chemin doit être absolu, et la correspondance doit être totale avec le chemin :
>>> PurePath('/a.py').match('/*.py') True >>> PurePath('a/b.py').match('/*.py') False
Comme avec les autres méthodes, la casse est prise en compte :
>>> PureWindowsPath('b.py').match('*.PY') True
-
PurePath.
relative_to
(*other)¶ Calcule une version du chemin en relatif au chemin représenté par other. 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 (most recent call last): File "<stdin>", line 1, in <module> File "pathlib.py", line 694, in relative_to .format(str(self), str(formatted))) ValueError: '/etc/passwd' does not start with '/usr'
-
PurePath.
with_name
(name)¶ Renvoie un nouveau chemin avec
name
changé. Si le chemin original 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 (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_suffix
(suffix)¶ Return a new path with the
suffix
changed. If the original path doesn’t have a suffix, the new suffix is appended instead:>>> 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')
11.1.3. Chemins concrets¶
Les chemins concrets sont des sous-classes des chemins purs. En plus des opérations fournies par ces derniers, ils fournissent aussi des méthodes pour faire appel au système sur des objets chemin. Il y a trois façons d’instancier des chemins concrets :
-
class
pathlib.
Path
(*pathsegments)¶ Une sous-classe de
PurePath
, cette classe représente les chemins concrets d’une famille de chemins de système de fichiers (l’instancier créé soit unPosixPath
, soit unWindowsPath
) :>>> Path('setup.py') PosixPath('setup.py')
pathsegments est spécifié de manière similaire à
PurePath
.
-
class
pathlib.
PosixPath
(*pathsegments)¶ Une sous classe de
Path
etPurePosixPath
, cette classe représente les chemins concrets de systèmes de fichiers non Windows :>>> PosixPath('/etc') PosixPath('/etc')
pathsegments est spécifié de manière similaire à
PurePath
.
-
class
pathlib.
WindowsPath
(*pathsegments)¶ Une sous classe de
Path
etPureWindowsPath
, cette classe représente les chemins concrets de systèmes de fichiers Windows :>>> WindowsPath('c:/Program Files/') WindowsPath('c:/Program Files')
pathsegments est spécifié de manière similaire à
PurePath
.
Vous ne pouvez instancier la classe de la famille qui correspond à votre système (permettre des appels au système pour des familles de chemins non compatible pourrait mener à des bogues ou à des pannes de votre application) :
>>> 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__,))
NotImplementedError: cannot instantiate 'WindowsPath' on your system
11.1.3.1. Méthodes¶
Les chemins concrets fournissent les méthodes suivantes en plus des méthodes des chemins purs. Beaucoup de ces méthodes peuvent lever OSError
si un appel au système échoue (par exemple car le chemin n’existe pas) :
-
classmethod
Path.
cwd
()¶ Renvoie un nouveau chemin représentant le dossier courant (comme renvoyé par
os.getcwd()
) :>>> Path.cwd() PosixPath('/home/antoine/pathlib')
-
classmethod
Path.
home
()¶ Renvoie un nouveau chemin représentant le dossier home de l’utilisateur (comme retourné par
os.path.expanduser()
avec la construction~
) :>>> Path.home() PosixPath('/home/antoine')
Nouveau dans la version 3.5.
-
Path.
stat
()¶ Renvoie les informations à propos de ce chemin (de manière similaire à
os.stat()
). Le résultat est récupéré à chaque appel à cette méthode.>>> p = Path('setup.py') >>> p.stat().st_size 956 >>> p.stat().st_mtime 1327883547.852554
-
Path.
chmod
(mode)¶ Change le mode et les permissions du fichiers, comme
os.chmod()
:>>> p = Path('setup.py') >>> p.stat().st_mode 33277 >>> p.chmod(0o444) >>> p.stat().st_mode 33060
-
Path.
exists
()¶ Si le chemin pointe sur un fichier ou dossier existant :
>>> Path('.').exists() True >>> Path('setup.py').exists() True >>> Path('/etc').exists() True >>> Path('nonexistentfile').exists() False
Note
Si le chemin pointe sur un lien symbolique,
exists()
renvoie si le lien symbolique pointe vers un fichier ou un dossier existant.
-
Path.
expanduser
()¶ Renvoie un nouveau chemin avec les résolutions des constructions
~
et~user
, comme retourné paros.path.expanduser()
:>>> p = PosixPath('~/films/Monty Python') >>> p.expanduser() PosixPath('/home/eric/films/Monty Python')
Nouveau dans la version 3.5.
-
Path.
glob
(pattern)¶ Globalise le pattern fourni dans le dossier représenté par ce chemin, donnant tous les fichiers correspondants (de n’importe quelle sorte) :
>>> sorted(Path('.').glob('*.py')) [PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')] >>> sorted(Path('.').glob('*/*.py')) [PosixPath('docs/conf.py')]
Le motif «
**
» signifie que « ce dossier et ses sous-dossiers, récursivement ». En d’autres mots, il active la récursivité de la globalisation :>>> sorted(Path('.').glob('**/*.py')) [PosixPath('build/lib/pathlib.py'), PosixPath('docs/conf.py'), PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
Note
Utiliser le motif «
**
» dans de grandes arborescences de dossier peut consommer une quantité de temps démesurée.
-
Path.
group
()¶ Renvoie le nom du groupe auquel appartient le fichier.
KeyError
est levée si l’identifiant de groupe du fichier n’est pas trouvé dans la base de données système.
-
Path.
is_dir
()¶ Renvoie
True
si le chemin pointe vers un dossier (ou un lien symbolique pointant vers un dossier),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_file
()¶ Renvoie
True
si le chemin pointe vers un fichier normal (ou un lien symbolique pointe vers un fichier normal),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_symlink
()¶ Renvoie
True
si le chemin pointe sur un lien symbolique,False
sinon.False
est aussi renvoyé si le chemin n’existe pas ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_socket
()¶ Renvoie
True
si le chemin pointe vers une socket Unix (ou un lien symbolique pointant vers une socket Unix),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_fifo
()¶ Renvoie
True
si le chemin pointe vers une FIFO (ou un lien symbolique pointant vers une FIFO),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_block_device
()¶ Renvoie
True
si le chemin pointe vers un périphérique (ou un lien symbolique pointant vers un périphérique),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
is_char_device
()¶ Renvoie
True
si le chemin pointe vers un périphérique à caractères (ou un lien symbolique pointant vers un périphérique à caractères),False
si il pointe vers une autre sorte de fichier.False
est aussi renvoyé si le chemin n’existe pas ou est un lien symbolique cassé ; d’autres erreurs (telles que les erreurs de permission) sont propagées.
-
Path.
iterdir
()¶ Quand le chemin pointe vers un dossier, donne les chemins du contenu du dossier :
>>> 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')
-
Path.
lchmod
(mode)¶ Comme
Path.chmod()
, mais, si le chemin pointe vers un lien symbolique, le mode du lien symbolique est changé plutôt que celui de sa cible.
-
Path.
lstat
()¶ Comme
Path.stat()
, mais, si le chemin pointe vers un lien symbolique, renvoie les informations du lien symbolique plutôt que celui de sa cible.
-
Path.
mkdir
(mode=0o777, parents=False, exist_ok=False)¶ Créer un nouveau dossier au chemin fourni. Si mode est fourni, il est combiné avec la valeur de l”
umask
du processus pour déterminer le mode de fichier et les droits d’accès. Si le chemin existe déjà,FileExistsError
est levée.Si parents est vrai, chaque parents de ce chemin est créé si besoin ; il sont créés avec les permissions par défaut sans prendre en compte mode (reproduisant la commande POSIX
mkdir -p
).Si parents est faux (valeur par défaut), un parent manquant lève
FileNotFoundError
.Si exist_ok est faux (valeur par défaut),
FileExistsError
est levé si le dossier cible existe déjà.If exist_ok est vrai, les exceptions
FileExistsError
seront ignorée (même comportement que la commande POSIXmkdir -p
), mais seulement si le dernier segment de chemin existe et n’est pas un dossier.Modifié dans la version 3.5: Le paramètre exist_ok a été ajouté.
-
Path.
open
(mode='r', buffering=-1, encoding=None, errors=None, newline=None)¶ Ouvre le fichier pointé par le chemin, comme la fonction native
open()
le fait :>>> p = Path('setup.py') >>> with p.open() as f: ... f.readline() ... '#!/usr/bin/env python3\n'
-
Path.
owner
()¶ Renvoie le nom de l’utilisateur auquel appartient le fichier.
KeyError
est levée si l’identifiant utilisateur du fichier n’est pas trouvé dans la base de données du système.
-
Path.
read_bytes
()¶ Renvoie le contenu binaire du fichier pointé en tant que bytes :
>>> p = Path('my_binary_file') >>> p.write_bytes(b'Binary file contents') 20 >>> p.read_bytes() b'Binary file contents'
Nouveau dans la version 3.5.
-
Path.
read_text
(encoding=None, errors=None)¶ Renvoie le contenu décodé du fichier pointé en tant que chaîne de caractères :
>>> p = Path('my_text_file') >>> p.write_text('Text file contents') 18 >>> p.read_text() 'Text file contents'
The optional parameters have the same meaning as in
open()
.Nouveau dans la version 3.5.
-
Path.
rename
(target)¶ Renomme ce fichier ou dossier vers la cible target fournie. Sur Unix, si target existe et que c’est un fichier, il sera remplacé silencieusement si l’utilisateur a la permission. target peut être soit une chaîne de caractères, soit un autre chemin :
>>> p = Path('foo') >>> p.open('w').write('some text') 9 >>> target = Path('bar') >>> p.rename(target) >>> target.open().read() 'some text'
-
Path.
replace
(target)¶ Renomme ce fichier ou dossier vers la cible target fournie. Si target pointe sur un fichier ou un dossier existant, il sera remplacé de manière inconditionnelle.
-
Path.
resolve
()¶ Rend le chemin absolu, résolvant les liens symboliques. Un nouveau chemin est renvoyé :
>>> p = Path() >>> p PosixPath('.') >>> p.resolve() PosixPath('/home/antoine/pathlib')
Les composantes «
..
» sont aussi éliminées (c’est la seule méthode pour le faire) :>>> p = Path('docs/../setup.py') >>> p.resolve() PosixPath('/home/antoine/pathlib/setup.py')
If the path doesn’t exist,
FileNotFoundError
is raised. If an infinite loop is encountered along the resolution path,RuntimeError
is raised.
-
Path.
rglob
(pattern)¶ This is like calling
Path.glob()
with «**
» added in front of the given pattern:>>> 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
()¶ Supprime ce dossier. Le dossier doit être vide.
-
Path.
samefile
(other_path)¶ Renvoie si ce chemin pointe vers le même fichier que other_path, qui peut être soit un chemin, soit une chaîne de caractères. La sémantique est similaire à
os.path.samefile()
etos.path.samestat()
.OSError
peut être levée si l’un des fichier ne peut être accédé pour quelque raison.>>> p = Path('spam') >>> q = Path('eggs') >>> p.samefile(q) False >>> p.samefile('spam') True
Nouveau dans la version 3.5.
-
Path.
symlink_to
(target, target_is_directory=False)¶ Fait de ce chemin un lien symbolique vers target. Sous Windows, target_is_directory doit être vrai (la valeur par défaut étant
False
) si la cible du lien est un dossier. Sous POSIX, la valeur de target_is_directory est ignorée.>>> 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
Note
L’ordre des arguments (lien, cible) est l’opposé de ceux de
os.symlink()
.
-
Path.
touch
(mode=0o666, exist_ok=True)¶ Créer un fichier au chemin donné. Si mode est fourni, il est combiné avec la valeur de l”
umask
du processus pour déterminer le mode du fichier et les drapeaux d’accès. Si le fichier existe déjà, la fonction réussit si exist_ok est vrai (et si l’heure de modification est mise à jour avec l’heure courante), sinonFileExistsError
est levée.
-
Path.
unlink
()¶ Supprime ce fichier ou lien symbolique. Si le chemin pointe vers un dossier, utilisez
Path.rmdir()
à la place.
-
Path.
write_bytes
(data)¶ Ouvre le fichier pointé en mode binaire, écrit data dedans, et ferme le fichier :
>>> p = Path('my_binary_file') >>> p.write_bytes(b'Binary file contents') 20 >>> p.read_bytes() b'Binary file contents'
Un fichier existant au même nom est écrasé.
Nouveau dans la version 3.5.
-
Path.
write_text
(data, encoding=None, errors=None)¶ Ouvre le fichier pointé en mode texte, écrit data dedans, et ferme le fichier :
>>> p = Path('my_text_file') >>> p.write_text('Text file contents') 18 >>> p.read_text() 'Text file contents'
Nouveau dans la version 3.5.