# `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 uniquement des opérations de manipulation 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 :

1. 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 instancier `PureWindowsPath`.

2. 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ération permettant d'accéder au système d'exploitation.

Voir aussi

PEP 428 : le module pathlib – implémentation orientée-objet des chemins de systèmes de fichiers.

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`.

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

## 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 un `PureWindowsPath`) :

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

  Chaque élément de pathsegments peut soit être une chaîne de caractères représentant un segment de chemin, un objet implémentant l'interface `os.PathLike` qui renvoie une chaîne de caractères, soit un autre objet chemin :

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

  Si un segment est un chemin absolu, tous les segments précédents sont ignorés (comme `os.path.join()`) :

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

  Sous Windows, le nom de lecteur est conservé quand un chemin relatif à la racine (par exemple `r'\foo'`) est rencontré :

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

  Les points et slashs superflus sont supprimés, mais les doubles points (`'..'`) et les double slashes (`'//'`) en début de segment ne le sont pas, puisque cela changerait la signification du chemin pour différentes raisons (par exemple pour des liens symboliques ou des chemins UNC) :

      >>> PurePath('foo//bar')
      PurePosixPath('foo/bar')
      >>> 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 si `foo` est un lien symbolique vers un autre dossier)

  Les objets chemins purs implémentent l'interface `os.PathLike`, leur permettant d'être utilisés n'importe où l'interface est acceptée.

  Modifié dans la version 3.6: ajout de la gestion de l'interface `os.PathLike`.

class pathlib.PurePosixPath(*pathsegments)

  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)

  Sous-classe de `PurePath`, cette famille de chemin représente les chemins de systèmes de fichiers Windows, y compris les chemins UNC (voir UNC paths) :

      >>> PureWindowsPath('c:/Program Files/')
      PureWindowsPath('c:/Program Files')
      >>> PureWindowsPath('//server/share/file')
      PureWindowsPath('//server/share/file')

  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'elles ne fournissent aucune opération qui appelle le système d'exploitation.

### Propriétés générales

Paths are immutable and hashable. Paths of a same flavour are comparable and orderable. These properties respect the flavour's case-folding semantics:

    >>> 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: '<' not supported between instances of 'PureWindowsPath' and 'PurePosixPath'

### Opérateurs

L'opérateur slash aide à créer les chemins enfants, de manière similaire à `os.path.join()`. Si l'argument est un chemin absolu, le chemin précédent est ignoré. Sous Windows, le lecteur n'est pas effacé quand l'argument est un chemin relatif enraciné (par exemple `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')

Un objet chemin peut être utilisé n'importe où un objet implémentant `os.PathLike` est accepté :

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

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, c.-à-d. avec des antislashs sous Windows), telle que vous pouvez la 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.

### 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és en une seule partie)

### 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
      '\\'

  Si le chemin commence par plus de deux slashes successifs, `PurePosixPath` n'en conserve qu'un :

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

  Note

  Ce comportement se conforme au paragraphe 4.11 Pathname Resolution des Open Group Base Specifications version 6 :

  "A pathname that begins with two successive slashes may be interpreted in an implementation-defined manner, although more than two leading slashes shall be treated as a single slash."

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

  Modifié dans la version 3.10: La séquence de parents prend désormais en charge les tranches et les valeurs d’index négatives.

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 remonter un chemin arbitraire du système de fichiers, il est recommandé d'appeler d'abord `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_relative_to(*other)

  Renvoie si ce chemin est relatif ou non au chemin other.

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

  If multiple arguments are supplied, they are joined together.

  This method is string-based; it neither accesses the filesystem nor treats "`..`" segments specially. The following code is equivalent:

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

  Nouveau dans la version 3.9.

PurePath.is_reserved()

  Avec `PureWindowsPath`, renvoie `True` si le chemin est considéré réservé sous Windows, `False` sinon. Avec `PurePosixPath`, `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 pour les autres méthodes, la sensibilité à la casse est la sensibilité par défaut de la plate-forme :

      >>> PurePosixPath('b.py').match('*.PY')
      False
      >>> 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, une `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' is not in the subpath of '/usr' OR one path is relative and the other absolute.

  If multiple arguments are supplied, they are joined together.

  NOTE : cette fonction fait partie de `PurePath` et fonctionne avec des chaînes de caractères. Elle n'accède donc pas au système de fichiers sous-jacente, et ne vérifie donc pas son résultat.

PurePath.with_name(name)

  Renvoie un nouveau chemin avec `name` changé. Si le chemin original n'a pas de nom, une `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_stem(stem)

  Renvoie un nouveau chemin avec `stem` changé. Si le chemin original n'a pas de nom, ValueError est levée :

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

  Nouveau dans la version 3.9.

PurePath.with_suffix(suffix)

  Renvoie un nouveau chemin avec `suffix` changé. Si le chemin original n'a pas de suffixe, le nouveau suffix est alors ajouté. Si suffix est une chaîne vide, le suffixe d'origine est retiré :

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

## 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 un `PosixPath`, soit un `WindowsPath`) :

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

  pathsegments est spécifié de manière similaire à `PurePath`.

class pathlib.PosixPath(*pathsegments)

  Une sous-classe de `Path` et `PurePosixPath`, 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` et `PureWindowsPath`, 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 pouvez seulement instancier la classe de la famille qui correspond à votre système (permettre des appels au système pour des familles de chemins non compatibles 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

### 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).

Modifié dans la version 3.8: `exists()`, `is_dir()`, `is_file()`, `is_mount()`, `is_symlink()`, `is_block_device()`, `is_char_device()`, `is_fifo()` et `is_socket()` renvoient maintenant `False` au lieu de lever une exception pour les chemins qui contiennent des caractères non représentables au niveau du système d'exploitation.

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 d’accueil de l'utilisateur (comme renvoyé par `os.path.expanduser()` avec la construction `~`). Si le dossier d’accueil de l'utilisateur ne peut être résolu, `RuntimeError` est levée.

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

  Nouveau dans la version 3.5.

Path.stat(*, follow_symlinks=True)

  Renvoie un objet `os.stat_result` contenant des informations sur ce chemin, comme `os.stat()`. Le résultat est récupéré à chaque appel à cette méthode.

  Cette méthode suit normalement les liens symboliques ; pour appeler `stat` sur un lien symbolique lui-même, ajoutez l’argument `follow_symlinks=False`, ou utilisez `lstat()`.

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

  Modifié dans la version 3.10: ajout du paramètre follow_symlinks.

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

  Change le mode et les permissions du fichier, comme `os.chmod()`.

  Cette méthode suit normalement les liens symboliques. Certaines versions d’Unix prennent en charge la modification des permissions sur le lien symbolique lui-même ; sur ces plateformes, vous pouvez ajouter l’argument `follow_symlinks=False`, ou utiliser `lchmod()`.

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

  Modifié dans la version 3.10: ajout du paramètre follow_symlinks.

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 renvoyé par `os.path.expanduser()`. Si le dossier d’accueil de l'utilisateur ne peut être résolu, `RuntimeError` est levée.

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

  Nouveau dans la version 3.5.

Path.glob(pattern)

  Glob de manière relative suivant le motif 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 est pareil que pour `fnmatch`, avec l'ajout de `"**"`, qui signifie « ce dossier et ses sous-dossiers, récursivement ». En d'autres termes, il permet d’effectuer un globbing récursif :

      >>> 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.

  Lève un évènement d’audit `pathlib.Path.glob` avec comme arguments `self` et `pattern`.

  Modifié dans la version 3.11: Renvoie uniquement des répertoires si pattern finit par un séparateur d'éléments de chemin (`sep` ou `altsep`).

Path.group()

  Renvoie le nom du groupe propriétaire du fichier. `KeyError` est levée si le gid du fichier n'est pas trouvé dans la base de données du système.

Path.is_dir()

  Renvoie `True` si le chemin pointe vers un dossier (ou un lien symbolique pointant vers un dossier), `False` s'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` s'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_mount()

  Renvoie `True` si le chemin pointe vers un point de montage : un point dans le système de fichiers où un système de fichiers différent a été monté. Sous POSIX, la fonction vérifie si le parent de path, `path/..`, se trouve sur un autre périphérique que path, ou si `path/..` et path pointe sur le même i-node sur le même périphérique — ceci devrait détecter tous les points de montage pour toutes les variantes Unix et POSIX. Non implémenté sous Windows.

  Nouveau dans la version 3.7.

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 un connecteur Unix (ou un lien symbolique pointant vers un connecteur Unix), `False` s'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` s'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` s'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` s'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 par séquences les objets chemin 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')

  Les éléments enfants sont renvoyés dans un ordre arbitraire, et les éléments spéciaux `'.'` et `'..'` ne sont pas inclus. Si un fichier est supprimé ou ajouté au répertoire après la création de l’itérateur, il se peut qu'un élément soit renvoyé pour ce fichier, ou non ; ce comportement n'est pas déterminé.

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 parent de ce chemin est créé si besoin ; ils 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 is true, `FileExistsError` will not be raised unless the given path already exists in the file system and is not a directory (same behavior as the POSIX `mkdir -p` command).

  Modifié dans la version 3.5: ajout du paramètre exist_ok.

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’uid de l’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 chaîne d’octets :

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

  Le fichier est ouvert, puis fermé. Les paramètres optionnels ont la même signification que dans `open()`.

  Nouveau dans la version 3.5.

Path.readlink()

  Renvoie le chemin vers lequel le lien symbolique pointe (tel que renvoyé par `os.readlink()`) :

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

  Nouveau dans la version 3.9.

Path.rename(target)

  Renomme ce fichier ou dossier vers la cible target fournie et renvoie une nouvelle instance de Path pointant sur target. Si target existe déjà, le comportement dépend du système. Sous Unix, si target est un fichier, il est remplacé sans avertissement (à condition que l'utilisateur en ait la permission). En revanche, sous Windows, une erreur `FileExistsError` est systématiquement levée. 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)
      PosixPath('bar')
      >>> target.open().read()
      'some text'

  La cible peut être un chemin absolu ou relatif. Attention, une cible relative est interprétée par rapport au dossier courant, et pas par rapport au dossier du `Path` sur lequel cette méthode est appelée.

  Cette méthode est implémentée d'après `os.rename()` et fournit les mêmes garanties.

  Modifié dans la version 3.8: ajout de la valeur de retour, renvoie une nouvelle instance Path.

Path.replace(target)

  Renomme ce fichier ou dossier vers la cible target fournie et renvoie une nouvelle instance de Path pointant vers target. Si target pointe vers un fichier ou un dossier vide existant, il sera systématiquement remplacé.

  La cible peut être un chemin absolu ou relatif. Attention, une cible relative est interprétée par rapport au dossier courant, et pas par rapport au dossier du `Path` sur lequel cette méthode est appelée.

  Modifié dans la version 3.8: ajout de la valeur de retour, renvoie une nouvelle instance Path.

Path.absolute()

  Rend le chemin absolu, sans normaliser ou résoudre les liens symboliques. Renvoie un nouveau :

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

Path.resolve(strict=False)

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

  Si le chemin n'existe pas et que strict est `True`, `FileNotFoundError` est levée. Si strict est `False`, le chemin est résolu aussi loin que possible et le reste potentiel est ajouté à la fin sans vérifier s'il existe. Si une boucle infinie est rencontrée lors de la résolution du chemin, `RuntimeError` est levée.

  Nouveau dans la version 3.6: l'argument strict (le comportement pré-3.6 est strict par défaut).

Path.rglob(pattern)

  C'est similaire à appeler `Path.glob()` avec "`**/`" ajouté au début du motif pattern relatif :

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

  Lève un évènement d’audit `pathlib.Path.glob` avec comme arguments `self` et `pattern`.

  Modifié dans la version 3.11: Renvoie uniquement des répertoires si pattern finit par un séparateur d'éléments de chemin (`sep` ou `altsep`).

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()` et `os.path.samestat()`.

  `OSError` peut être levée si l'un des fichiers 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)

  Make this path a symbolic link pointing to target.

  On Windows, a symlink represents either a file or a directory, and does not morph to the target dynamically. If the target is present, the type of the symlink will be created to match. Otherwise, the symlink will be created as a directory if target_is_directory is `True` or a file symlink (the default) otherwise. On non-Windows platforms, target_is_directory is ignored.

      >>> 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.hardlink_to(target)

  Crée un lien physique pointant sur le même fichier que target.

  Note

  L'ordre des arguments (lien, cible) est l'opposé de celui de `os.link()`.

  Nouveau dans la version 3.10.

Path.link_to(target)

  Crée un lien physique pointant sur le même fichier que target.

  Avertissement

  Cette fonction ne fait pas de ce chemin un lien physique vers target, malgré ce que le nom de la fonction et des arguments laisse penser. L’ordre des arguments (cible, lien) est l’inverse de `Path.symlink_to()` et `Path.hardlink_to()`, mais correspond en fait à celui de `os.link()`.

  Nouveau dans la version 3.8.

  Obsolète depuis la version 3.10: Cette méthode est rendue obsolète au profit de `Path.hardlink_to()`, car l’ordre des arguments de `Path.link_to()` ne correspond pas à celui de `Path.symlink_to()`.

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), sinon `FileExistsError` est levée.

Path.unlink(missing_ok=False)

  Supprime ce fichier ou lien symbolique. Si le chemin pointe vers un dossier, utilisez `Path.rmdir()` à la place.

  Si missing_ok est faux (valeur par défaut), une `FileNotFoundError` est levée si le chemin n'existe pas.

  Si missing_ok est vrai, les exceptions `FileNotFoundError` sont ignorées (même comportement que la commande POSIX `rm -f`).

  Modifié dans la version 3.8: Ajout du paramètre missing_ok.

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'

  Le fichier du même nom, s'il existe, est écrasé.

  Nouveau dans la version 3.5.

Path.write_text(data, encoding=None, errors=None, newline=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'

  Le fichier du même nom, s'il existe, est écrasé. Les paramètres optionnels ont la même signification que dans `open()`.

  Nouveau dans la version 3.5.

  Modifié dans la version 3.10: ajout du paramètre newline.

## Correspondance des outils du module `os`

Ci-dessous se trouve un tableau associant diverses fonctions `os` à leur équivalent `PurePath` / `Path` correspondant.

Note

Sur chaque ligne du tableau ci-dessous, les fonctions/méthodes ne sont pas toujours équivalentes. Certaines, malgré des fonctionnalités similaires ont des comportements différents. C'est notamment le cas de `os.path.abspath()` et `Path.absolute()`, ainsi que `os.path.relpath()` et `PurePath.relative_to()`.

`os` et `os.path` | `pathlib`
--- | ---
`os.path.abspath()` | `Path.absolute()` [1]
`os.path.realpath()` | `Path.resolve()`
`os.chmod()` | `Path.chmod()`
`os.mkdir()` | `Path.mkdir()`
`os.makedirs()` | `Path.mkdir()`
`os.rename()` | `Path.rename()`
`os.replace()` | `Path.replace()`
`os.rmdir()` | `Path.rmdir()`
`os.remove()`, `os.unlink()` | `Path.unlink()`
`os.getcwd()` | `Path.cwd()`
`os.path.exists()` | `Path.exists()`
`os.path.expanduser()` | `Path.expanduser()` et `Path.home()`
`os.listdir()` | `Path.iterdir()`
`os.path.isdir()` | `Path.is_dir()`
`os.path.isfile()` | `Path.is_file()`
`os.path.islink()` | `Path.is_symlink()`
`os.link()` | `Path.hardlink_to()`
`os.symlink()` | `Path.symlink_to()`
`os.readlink()` | `Path.readlink()`
`os.path.relpath()` | `PurePath.relative_to()` [2]
`os.stat()` | `Path.stat()`, `Path.owner()`, `Path.group()`
`os.path.isabs()` | `PurePath.is_absolute()`
`os.path.join()` | `PurePath.joinpath()`
`os.path.basename()` | `PurePath.name`
`os.path.dirname()` | `PurePath.parent`
`os.path.samefile()` | `Path.samefile()`
`os.path.splitext()` | `PurePath.stem` et `PurePath.suffix`

Notes

[1]

`os.path.abspath()` normalise le chemin généré, ce qui peut en changer la signification en présence de liens symboliques, alors que `Path.absolute()` ne le fait pas.

[2]

`Path.relative_to()` exige que `self` soit le sous-chemin de l’argument, ce qui pas le cas de `os.path.relpath()`.