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

[image]

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

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

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


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: '<' 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()" :

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

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

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

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

   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, 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 "~" ) :

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

   Nouveau dans la version 3.5.

Path.stat()

   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.

      >>> 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 fichier, 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é par "os.path.expanduser()" :

      >>> 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 ""**"" signifie « ce dossier et ses sous-dossiers,
   récursivement ». En d'autres mots, il permet un 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".

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

   The children are yielded in arbitrary order, and the special
   entries "'.'" and "'..'" are not included.  If a file is removed
   from or added to the directory after creating the iterator, whether
   an path object for that file be included is unspecified.

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* est vrai, les exceptions "FileExistsError" seront
   ignorées (même comportement que la commande POSIX "mkdir -p"), mais
   seulement si le dernier segment de chemin existe et n'est pas un
   dossier.

   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*. Sous
   Unix, si *target* existe et est un fichier, il est remplacé sans
   avertissement si l'utilisateur en 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)
      PosixPath('bar')
      >>> target.open().read()
      'some text'

   The target path may be absolute or relative. Relative paths are
   interpreted relative to the current working directory, *not* the
   directory of the Path object.

   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 sur *target*. Si
   *target* pointe sur un fichier ou un dossier existant, il est
   systématiquement remplacé.

   The target path may be absolute or relative. Relative paths are
   interpreted relative to the current working directory, *not* the
   directory of the Path object.

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

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

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)

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

   Crée un lien matériel pointant sur le chemin nommé *target*.

   Nouveau dans la version 3.8.

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)

   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.


Correspondance des outils du module "os"
========================================

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

Note:

  Bien que "os.path.relpath()" et "PurePath.relative_to()" aient des
  cas d'utilisation qui se chevauchent, leur sémantique diffère
  suffisamment pour ne pas les considérer comme équivalentes.

+--------------------------------------+--------------------------------+
| *os* et *os.path*                    | pathlib                        |
|======================================|================================|
| "os.path.abspath()"                  | "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.link_to()"               |
+--------------------------------------+--------------------------------+
| "os.symlink()"                       | "Path.symlink_to()"            |
+--------------------------------------+--------------------------------+
| "os.readlink()"                      | "Path.readlink()"              |
+--------------------------------------+--------------------------------+
| "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.suffix"              |
+--------------------------------------+--------------------------------+
