python-docs-fr/library/pathlib.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-07-23 14:38+0200\n"
"PO-Revision-Date: 2023-03-07 22:46+0100\n"
"Last-Translator: Vincent Poulailleau <vpoulailleau@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.2.1\n"

#: library/pathlib.rst:3
msgid ":mod:`pathlib` --- Object-oriented filesystem paths"
msgstr ":mod:`pathlib` — Chemins de système de fichiers orientés objet"

#: library/pathlib.rst:10
msgid "**Source code:** :source:`Lib/pathlib.py`"
msgstr "**Code source :** :source:`Lib/pathlib.py`"

#: library/pathlib.rst:16
msgid ""
"This module offers classes representing filesystem paths with semantics "
"appropriate for different operating systems.  Path classes are divided "
"between :ref:`pure paths <pure-paths>`, which provide purely computational "
"operations without I/O, and :ref:`concrete paths <concrete-paths>`, which "
"inherit from pure paths but also provide I/O operations."
msgstr ""
"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 :ref:`chemins purs <pure-paths>`, qui "
"fournissent uniquement des opérations de manipulation sans entrées-sorties, "
"et :ref:`chemins concrets <concrete-paths>`, qui héritent des chemins purs "
"et fournissent également les opérations d'entrées-sorties."

#: library/pathlib.rst:26
msgid ""
"If you've never used this module before or just aren't sure which class is "
"right for your task, :class:`Path` is most likely what you need. It "
"instantiates a :ref:`concrete path <concrete-paths>` for the platform the "
"code is running on."
msgstr ""
"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, :class:`Path` est très "
"certainement ce dont vous avez besoin. Elle instancie un :ref:`chemin "
"concret <concrete-paths>` pour la plateforme sur laquelle s'exécute le code."

#: library/pathlib.rst:30
msgid "Pure paths are useful in some special cases; for example:"
msgstr ""
"Les chemins purs sont utiles dans certains cas particuliers ; par exemple :"

#: library/pathlib.rst:32
msgid ""
"If you want to manipulate Windows paths on a Unix machine (or vice versa). "
"You cannot instantiate a :class:`WindowsPath` when running on Unix, but you "
"can instantiate :class:`PureWindowsPath`."
msgstr ""
"Si vous voulez manipuler des chemins Windows sur une machine Unix (ou vice "
"versa). Vous ne pouvez pas instancier un :class:`WindowsPath` quand vous "
"êtes sous Unix, mais vous pouvez instancier :class:`PureWindowsPath`."

#: library/pathlib.rst:35
msgid ""
"You want to make sure that your code only manipulates paths without actually "
"accessing the OS. In this case, instantiating one of the pure classes may be "
"useful since those simply don't have any OS-accessing operations."
msgstr ""
"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."

#: library/pathlib.rst:40
msgid ":pep:`428`: The pathlib module -- object-oriented filesystem paths."
msgstr ""
":pep:`428` : le module *pathlib* – implémentation orientée-objet des chemins "
"de systèmes de fichiers."

#: library/pathlib.rst:43
msgid ""
"For low-level path manipulation on strings, you can also use the :mod:`os."
"path` module."
msgstr ""
"Pour de la manipulation de chemins bas-niveau avec des chaînes de "
"caractères, vous pouvez aussi utiliser le module :mod:`os.path`."

#: library/pathlib.rst:48
msgid "Basic use"
msgstr "Utilisation basique"

#: library/pathlib.rst:50
msgid "Importing the main class::"
msgstr "Importer la classe principale ::"

#: library/pathlib.rst:54
msgid "Listing subdirectories::"
msgstr "Lister les sous-dossiers ::"

#: library/pathlib.rst:61
msgid "Listing Python source files in this directory tree::"
msgstr ""
"Lister les fichiers source Python dans cette arborescence de dossiers ::"

#: library/pathlib.rst:68
msgid "Navigating inside a directory tree::"
msgstr "Naviguer à l'intérieur d'une arborescence de dossiers ::"

#: library/pathlib.rst:77
msgid "Querying path properties::"
msgstr "Récupérer les propriétés de chemin ::"

#: library/pathlib.rst:84
msgid "Opening a file::"
msgstr "Ouvrir un fichier ::"

#: library/pathlib.rst:94
msgid "Pure paths"
msgstr "Chemins purs"

#: library/pathlib.rst:96
msgid ""
"Pure path objects provide path-handling operations which don't actually "
"access a filesystem.  There are three ways to access these classes, which we "
"also call *flavours*:"
msgstr ""
"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* :"

#: library/pathlib.rst:102
msgid ""
"A generic class that represents the system's path flavour (instantiating it "
"creates either a :class:`PurePosixPath` or a :class:`PureWindowsPath`)::"
msgstr ""
"Une classe générique qui représente la famille de chemin du système "
"(l'instancier crée soit un :class:`PurePosixPath` soit un :class:"
"`PureWindowsPath`) ::"

#: library/pathlib.rst:108
msgid ""
"Each element of *pathsegments* can be either a string representing a path "
"segment, an object implementing the :class:`os.PathLike` interface which "
"returns a string, or another path object::"
msgstr ""
"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 :class:"
"`os.PathLike` qui renvoie une chaîne de caractères, soit un autre objet "
"chemin ::"

#: library/pathlib.rst:117
msgid "When *pathsegments* is empty, the current directory is assumed::"
msgstr "Quand *pathsegments* est vide, le dossier courant est utilisé ::"

#: library/pathlib.rst:122
msgid ""
"If a segment is an absolute path, all previous segments are ignored (like :"
"func:`os.path.join`)::"
msgstr ""
"Si un segment est un chemin absolu, tous les segments précédents sont "
"ignorés (comme :func:`os.path.join`) ::"

#: library/pathlib.rst:130
msgid ""
"On Windows, the drive is not reset when a rooted relative path segment (e."
"g., ``r'\\foo'``) is encountered::"
msgstr ""
"Sous Windows, le nom de lecteur est conservé quand un chemin relatif à la "
"racine (par exemple ``r'\\foo'``) est rencontré ::"

#: library/pathlib.rst:136
msgid ""
"Spurious slashes and single dots are collapsed, but double dots (``'..'``) "
"and leading double slashes (``'//'``) are not, since this would change the "
"meaning of a path for various reasons (e.g. symbolic links, UNC paths)::"
msgstr ""
"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) ::"

#: library/pathlib.rst:149
msgid ""
"(a naïve approach would make ``PurePosixPath('foo/../bar')`` equivalent to "
"``PurePosixPath('bar')``, which is wrong if ``foo`` is a symbolic link to "
"another directory)"
msgstr ""
"(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)"

#: library/pathlib.rst:153
msgid ""
"Pure path objects implement the :class:`os.PathLike` interface, allowing "
"them to be used anywhere the interface is accepted."
msgstr ""
"Les objets chemins purs implémentent l'interface :class:`os.PathLike`, leur "
"permettant d'être utilisés n'importe où l'interface est acceptée."

#: library/pathlib.rst:156
msgid "Added support for the :class:`os.PathLike` interface."
msgstr "ajout de la gestion de l'interface :class:`os.PathLike`."

#: library/pathlib.rst:161
msgid ""
"A subclass of :class:`PurePath`, this path flavour represents non-Windows "
"filesystem paths::"
msgstr ""
"Sous-classe de :class:`PurePath`, cette famille de chemin représente les "
"chemins de systèmes de fichiers en dehors des chemins Windows ::"

#: library/pathlib.rst:179 library/pathlib.rst:682 library/pathlib.rst:692
msgid "*pathsegments* is specified similarly to :class:`PurePath`."
msgstr "*pathsegments* est spécifié de manière similaire à :class:`PurePath`."

#: library/pathlib.rst:171
msgid ""
"A subclass of :class:`PurePath`, this path flavour represents Windows "
"filesystem paths, including `UNC paths`_::"
msgstr ""
"Sous-classe de :class:`PurePath`, cette famille de chemin représente les "
"chemins de systèmes de fichiers Windows, y compris les chemins UNC (voir "
"`UNC paths`_) ::"

#: library/pathlib.rst:183
msgid ""
"Regardless of the system you're running on, you can instantiate all of these "
"classes, since they don't provide any operation that does system calls."
msgstr ""
"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."

#: library/pathlib.rst:188
msgid "General properties"
msgstr "Propriétés générales"

#: library/pathlib.rst:190
#, fuzzy
msgid ""
"Paths are immutable and :term:`hashable`.  Paths of a same flavour are "
"comparable and orderable.  These properties respect the flavour's case-"
"folding semantics::"
msgstr ""
"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 ::"

#: library/pathlib.rst:203
msgid "Paths of a different flavour compare unequal and cannot be ordered::"
msgstr ""
"Les chemins de différentes familles ne sont pas égaux et ne peuvent être "
"ordonnés ::"

#: library/pathlib.rst:214
msgid "Operators"
msgstr "Opérateurs"

#: library/pathlib.rst:216
msgid ""
"The slash operator helps create child paths, like :func:`os.path.join`. If "
"the argument is an absolute path, the previous path is ignored. On Windows, "
"the drive is not reset when the argument is a rooted relative path (e.g., "
"``r'\\foo'``)::"
msgstr ""
"L'opérateur slash aide à créer les chemins enfants, de manière similaire à :"
"func:`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'``) ::"

#: library/pathlib.rst:234
msgid ""
"A path object can be used anywhere an object implementing :class:`os."
"PathLike` is accepted::"
msgstr ""
"Un objet chemin peut être utilisé n'importe où un objet implémentant :class:"
"`os.PathLike` est accepté ::"

#: library/pathlib.rst:242
msgid ""
"The string representation of a path is the raw filesystem path itself (in "
"native form, e.g. with backslashes under Windows), which you can pass to any "
"function taking a file path as a string::"
msgstr ""
"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 ::"

#: library/pathlib.rst:253
msgid ""
"Similarly, calling :class:`bytes` on a path gives the raw filesystem path as "
"a bytes object, as encoded by :func:`os.fsencode`::"
msgstr ""
"De manière similaire, appeler :class:`bytes` sur un chemin donne le chemin "
"brut du système de fichiers en tant que bytes, tel qu'encodé par :func:`os."
"fsencode` ::"

#: library/pathlib.rst:260
msgid ""
"Calling :class:`bytes` is only recommended under Unix.  Under Windows, the "
"unicode form is the canonical representation of filesystem paths."
msgstr ""
"Appeler :class:`bytes` est seulement recommandé sous Unix. Sous Windows, la "
"forme Unicode est la représentation canonique des chemins du système de "
"fichiers."

#: library/pathlib.rst:265
msgid "Accessing individual parts"
msgstr "Accéder aux parties individuelles"

#: library/pathlib.rst:267
msgid ""
"To access the individual \"parts\" (components) of a path, use the following "
"property:"
msgstr ""
"Pour accéder aux parties individuelles (composantes) d'un chemin, utilisez "
"les propriétés suivantes :"

#: library/pathlib.rst:272
msgid "A tuple giving access to the path's various components::"
msgstr "Un tuple donnant accès aux différentes composantes du chemin ::"

#: library/pathlib.rst:282
msgid "(note how the drive and local root are regrouped in a single part)"
msgstr ""
"(notez comme le lecteur et la racine locale sont regroupés en une seule "
"partie)"

#: library/pathlib.rst:286
msgid "Methods and properties"
msgstr "Méthodes et propriétés"

#: library/pathlib.rst:292
msgid "Pure paths provide the following methods and properties:"
msgstr "Les chemins purs fournissent les méthodes et propriétés suivantes :"

#: library/pathlib.rst:296
msgid "A string representing the drive letter or name, if any::"
msgstr ""
"Une chaîne représentant la lettre du lecteur ou le nom, s'il y en a un ::"

#: library/pathlib.rst:305
msgid "UNC shares are also considered drives::"
msgstr "Les partages UNC sont aussi considérés comme des lecteurs ::"

#: library/pathlib.rst:312
msgid "A string representing the (local or global) root, if any::"
msgstr ""
"Une chaîne de caractères représentant la racine (locale ou globale), s'il y "
"en a une ::"

#: library/pathlib.rst:321
msgid "UNC shares always have a root::"
msgstr "Les partages UNC ont toujours une racine ::"

#: library/pathlib.rst:326
msgid ""
"If the path starts with more than two successive slashes, :class:`~pathlib."
"PurePosixPath` collapses them::"
msgstr ""
"Si le chemin commence par plus de deux slashes successifs, :class:`~pathlib."
"PurePosixPath` n'en conserve qu'un ::"

#: library/pathlib.rst:338
msgid ""
"This behavior conforms to *The Open Group Base Specifications Issue 6*, "
"paragraph `4.11 Pathname Resolution <https://pubs.opengroup.org/"
"onlinepubs/009695399/basedefs/xbd_chap04.html#tag_04_11>`_:"
msgstr ""
"Ce comportement se conforme au paragraphe 4.11 `Pathname Resolution <https://"
"pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap04."
"html#tag_04_11>`_ des *Open Group Base Specifications* version 6 :"

#: library/pathlib.rst:342
msgid ""
"*\"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.\"*"
msgstr ""

#: library/pathlib.rst:348
msgid "The concatenation of the drive and root::"
msgstr "La concaténation du lecteur et de la racine ::"

#: library/pathlib.rst:362
msgid ""
"An immutable sequence providing access to the logical ancestors of the path::"
msgstr ""
"Une séquence immuable fournissant accès aux ancêtres logiques du chemin ::"

#: library/pathlib.rst:373
msgid ""
"The parents sequence now supports :term:`slices <slice>` and negative index "
"values."
msgstr ""
"La séquence de *parents* prend désormais en charge les :term:`tranches "
"<slice>` et les valeurs d’index négatives."

#: library/pathlib.rst:378
msgid "The logical parent of the path::"
msgstr "Le parent logique du chemin ::"

#: library/pathlib.rst:384
msgid "You cannot go past an anchor, or empty path::"
msgstr "Vous ne pouvez pas aller au-delà d'une ancre, ou d'un chemin vide ::"

#: library/pathlib.rst:394
msgid "This is a purely lexical operation, hence the following behaviour::"
msgstr "C'est une opération purement lexicale, d'où le comportement suivant ::"

#: library/pathlib.rst:400
msgid ""
"If you want to walk an arbitrary filesystem path upwards, it is recommended "
"to first call :meth:`Path.resolve` so as to resolve symlinks and eliminate "
"``\"..\"`` components."
msgstr ""
"Si vous voulez remonter un chemin arbitraire du système de fichiers, il est "
"recommandé d'appeler d'abord :meth:`Path.resolve` de manière à résoudre les "
"liens symboliques et éliminer les composantes ``\"..\"``."

#: library/pathlib.rst:407
msgid ""
"A string representing the final path component, excluding the drive and "
"root, if any::"
msgstr ""
"Une chaîne représentant la composante finale du chemin, en excluant le "
"lecteur et la racine, si présent ::"

#: library/pathlib.rst:413
msgid "UNC drive names are not considered::"
msgstr "Les noms de lecteur UNC ne sont pas pris en compte ::"

#: library/pathlib.rst:423
msgid "The file extension of the final component, if any::"
msgstr "L'extension du fichier de la composante finale, si présente ::"

#: library/pathlib.rst:435
msgid "A list of the path's file extensions::"
msgstr "Une liste des extensions du chemin de fichier ::"

#: library/pathlib.rst:447
msgid "The final path component, without its suffix::"
msgstr "La composante finale du chemin, sans son suffixe ::"

#: library/pathlib.rst:459
msgid ""
"Return a string representation of the path with forward slashes (``/``)::"
msgstr ""
"Renvoie une représentation en chaîne de caractères du chemin avec des slashs "
"(``/``) ::"

#: library/pathlib.rst:470
msgid ""
"Represent the path as a ``file`` URI.  :exc:`ValueError` is raised if the "
"path isn't absolute."
msgstr ""
"Représente le chemin en tant qu'URI de fichier. :exc:`ValueError` est levée "
"si le chemin n'est pas absolu."

#: library/pathlib.rst:483
msgid ""
"Return whether the path is absolute or not.  A path is considered absolute "
"if it has both a root and (if the flavour allows) a drive::"
msgstr ""
"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) ::"

#: library/pathlib.rst:503
msgid "Return whether or not this path is relative to the *other* path."
msgstr "Renvoie si ce chemin est relatif ou non au chemin *other*."

#: library/pathlib.rst:516
msgid ""
"With :class:`PureWindowsPath`, return ``True`` if the path is considered "
"reserved under Windows, ``False`` otherwise.  With :class:`PurePosixPath`, "
"``False`` is always returned."
msgstr ""
"Avec :class:`PureWindowsPath`, renvoie ``True`` si le chemin est considéré "
"réservé sous Windows, ``False`` sinon. Avec :class:`PurePosixPath`, "
"``False`` est systématiquement renvoyé."

#: library/pathlib.rst:525
msgid ""
"File system calls on reserved paths can fail mysteriously or have unintended "
"effects."
msgstr ""
"Les appels au système de fichier sur des chemins réservés peuvent échouer "
"mystérieusement ou avoir des effets inattendus."

#: library/pathlib.rst:531
msgid ""
"Calling this method is equivalent to combining the path with each of the "
"*other* arguments in turn::"
msgstr ""
"Appeler cette méthode équivaut à combiner le chemin avec chacun des "
"arguments *other* ::"

#: library/pathlib.rst:546
msgid ""
"Match this path against the provided glob-style pattern.  Return ``True`` if "
"matching is successful, ``False`` otherwise."
msgstr ""
"Fait correspondre ce chemin avec le motif (*glob pattern*) fourni. Renvoie "
"``True`` si la correspondance a réussi, ``False`` sinon."

#: library/pathlib.rst:549
msgid ""
"If *pattern* is relative, the path can be either relative or absolute, and "
"matching is done from the right::"
msgstr ""
"Si *pattern* est relatif, le chemin peut être soit relatif, soit absolu, et "
"la correspondance est faite à partir de la droite ::"

#: library/pathlib.rst:559
msgid ""
"If *pattern* is absolute, the path must be absolute, and the whole path must "
"match::"
msgstr ""
"Si *pattern* est absolu, le chemin doit être absolu, et la correspondance "
"doit être totale avec le chemin ::"

#: library/pathlib.rst:567
msgid "As with other methods, case-sensitivity follows platform defaults::"
msgstr ""
"Comme pour les autres méthodes, la sensibilité à la casse est la sensibilité "
"par défaut de la plate-forme ::"

#: library/pathlib.rst:577
msgid ""
"Compute a version of this path relative to the path represented by *other*.  "
"If it's impossible, ValueError is raised::"
msgstr ""
"Calcule une version du chemin en relatif au chemin représenté par *other*. "
"Si c'est impossible, une :exc:`!ValueError` est levée ::"

#: library/pathlib.rst:592
msgid ""
"NOTE: This function is part of :class:`PurePath` and works with strings. It "
"does not check or access the underlying file structure."
msgstr ""
"NOTE : cette fonction fait partie de :class:`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."

#: library/pathlib.rst:597
msgid ""
"Return a new path with the :attr:`name` changed.  If the original path "
"doesn't have a name, ValueError is raised::"
msgstr ""
"Renvoie un nouveau chemin avec :attr:`name` changé. Si le chemin original "
"n'a pas de nom, une :exc:`!ValueError` est levée ::"

#: library/pathlib.rst:614
msgid ""
"Return a new path with the :attr:`stem` changed.  If the original path "
"doesn't have a name, ValueError is raised::"
msgstr ""
"Renvoie un nouveau chemin avec :attr:`stem` changé. Si le chemin original "
"n'a pas de nom, *ValueError* est levée ::"

#: library/pathlib.rst:638
msgid ""
"Return a new path with the :attr:`suffix` changed.  If the original path "
"doesn't have a suffix, the new *suffix* is appended instead.  If the "
"*suffix* is an empty string, the original suffix is removed::"
msgstr ""
"Renvoie un nouveau chemin avec :attr:`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é ::"

#: library/pathlib.rst:657
msgid "Concrete paths"
msgstr "Chemins concrets"

#: library/pathlib.rst:659
msgid ""
"Concrete paths are subclasses of the pure path classes.  In addition to "
"operations provided by the latter, they also provide methods to do system "
"calls on path objects.  There are three ways to instantiate concrete paths:"
msgstr ""
"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 :"

#: library/pathlib.rst:665
msgid ""
"A subclass of :class:`PurePath`, this class represents concrete paths of the "
"system's path flavour (instantiating it creates either a :class:`PosixPath` "
"or a :class:`WindowsPath`)::"
msgstr ""
"Une sous-classe de :class:`PurePath`, cette classe représente les chemins "
"concrets d'une famille de chemins de système de fichiers (l'instancier créé "
"soit un :class:`PosixPath`, soit un :class:`WindowsPath`) ::"

#: library/pathlib.rst:676
msgid ""
"A subclass of :class:`Path` and :class:`PurePosixPath`, this class "
"represents concrete non-Windows filesystem paths::"
msgstr ""
"Une sous-classe de :class:`Path` et :class:`PurePosixPath`, cette classe "
"représente les chemins concrets de systèmes de fichiers non Windows ::"

#: library/pathlib.rst:686
msgid ""
"A subclass of :class:`Path` and :class:`PureWindowsPath`, this class "
"represents concrete Windows filesystem paths::"
msgstr ""
"Une sous-classe de :class:`Path` et :class:`PureWindowsPath`, cette classe "
"représente les chemins concrets de systèmes de fichiers Windows ::"

#: library/pathlib.rst:694
msgid ""
"You can only instantiate the class flavour that corresponds to your system "
"(allowing system calls on non-compatible path flavours could lead to bugs or "
"failures in your application)::"
msgstr ""
"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) ::"

#: library/pathlib.rst:714
msgid "Methods"
msgstr "Méthodes"

#: library/pathlib.rst:716
msgid ""
"Concrete paths provide the following methods in addition to pure paths "
"methods.  Many of these methods can raise an :exc:`OSError` if a system call "
"fails (for example because the path doesn't exist)."
msgstr ""
"Les chemins concrets fournissent les méthodes suivantes en plus des méthodes "
"des chemins purs. Beaucoup de ces méthodes peuvent lever :exc:`OSError` si "
"un appel au système échoue (par exemple car le chemin n'existe pas)."

#: library/pathlib.rst:722
msgid ""
":meth:`~Path.exists()`, :meth:`~Path.is_dir()`, :meth:`~Path.is_file()`, :"
"meth:`~Path.is_mount()`, :meth:`~Path.is_symlink()`, :meth:`~Path."
"is_block_device()`, :meth:`~Path.is_char_device()`, :meth:`~Path."
"is_fifo()`, :meth:`~Path.is_socket()` now return ``False`` instead of "
"raising an exception for paths that contain characters unrepresentable at "
"the OS level."
msgstr ""
":meth:`~Path.exists()`, :meth:`~Path.is_dir()`, :meth:`~Path.is_file()`, :"
"meth:`~Path.is_mount()`, :meth:`~Path.is_symlink()`, :meth:`~Path."
"is_block_device()`, :meth:`~Path.is_char_device()`, :meth:`~Path.is_fifo()` "
"et :meth:`~Path.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."

#: library/pathlib.rst:732
msgid ""
"Return a new path object representing the current directory (as returned by :"
"func:`os.getcwd`)::"
msgstr ""
"Renvoie un nouveau chemin représentant le dossier courant (comme renvoyé "
"par :func:`os.getcwd`) ::"

#: library/pathlib.rst:741
msgid ""
"Return a new path object representing the user's home directory (as returned "
"by :func:`os.path.expanduser` with ``~`` construct). If the home directory "
"can't be resolved, :exc:`RuntimeError` is raised."
msgstr ""
"Renvoie un nouveau chemin représentant le dossier d’accueil de l'utilisateur "
"(comme renvoyé par :func:`os.path.expanduser` avec la construction ``~``). "
"Si le dossier d’accueil de l'utilisateur ne peut être résolu, :exc:"
"`RuntimeError` est levée."

#: library/pathlib.rst:755
msgid ""
"Return a :class:`os.stat_result` object containing information about this "
"path, like :func:`os.stat`. The result is looked up at each call to this "
"method."
msgstr ""
"Renvoie un objet :class:`os.stat_result` contenant des informations sur ce "
"chemin, comme :func:`os.stat`. Le résultat est récupéré à chaque appel à "
"cette méthode."

#: library/pathlib.rst:758
msgid ""
"This method normally follows symlinks; to stat a symlink add the argument "
"``follow_symlinks=False``, or use :meth:`~Path.lstat`."
msgstr ""
"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 :meth:`~Path.lstat`."

#: library/pathlib.rst:789
msgid "The *follow_symlinks* parameter was added."
msgstr "ajout du paramètre *follow_symlinks*."

#: library/pathlib.rst:774
msgid "Change the file mode and permissions, like :func:`os.chmod`."
msgstr "Change le mode et les permissions du fichier, comme :func:`os.chmod`."

#: library/pathlib.rst:776
msgid ""
"This method normally follows symlinks. Some Unix flavours support changing "
"permissions on the symlink itself; on these platforms you may add the "
"argument ``follow_symlinks=False``, or use :meth:`~Path.lchmod`."
msgstr ""
"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 :meth:`~Path.lchmod`."

#: library/pathlib.rst:794
msgid "Whether the path points to an existing file or directory::"
msgstr "Si le chemin pointe sur un fichier ou dossier existant ::"

#: library/pathlib.rst:806
msgid ""
"If the path points to a symlink, :meth:`exists` returns whether the symlink "
"*points to* an existing file or directory."
msgstr ""
"Si le chemin pointe sur un lien symbolique, :meth:`exists` renvoie si le "
"lien symbolique *pointe vers* un fichier ou un dossier existant."

#: library/pathlib.rst:812
msgid ""
"Return a new path with expanded ``~`` and ``~user`` constructs, as returned "
"by :meth:`os.path.expanduser`. If a home directory can't be resolved, :exc:"
"`RuntimeError` is raised."
msgstr ""
"Renvoie un nouveau chemin avec les résolutions des constructions ``~`` et "
"``~user``, comme renvoyé par :meth:`os.path.expanduser`. Si le dossier "
"d’accueil de l'utilisateur ne peut être résolu, :exc:`RuntimeError` est "
"levée."

#: library/pathlib.rst:827
msgid ""
"Glob the given relative *pattern* in the directory represented by this path, "
"yielding all matching files (of any kind)::"
msgstr ""
"*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) ::"

#: library/pathlib.rst:835
msgid ""
"Patterns are the same as for :mod:`fnmatch`, with the addition of \"``**``\" "
"which means \"this directory and all subdirectories, recursively\".  In "
"other words, it enables recursive globbing::"
msgstr ""
"Le motif est pareil que pour :mod:`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 ::"

#: library/pathlib.rst:847
msgid ""
"Using the \"``**``\" pattern in large directory trees may consume an "
"inordinate amount of time."
msgstr ""
"Utiliser le motif \"``**``\" dans de grandes arborescences de dossier peut "
"consommer une quantité de temps démesurée."

#: library/pathlib.rst:850
msgid ""
"Raises an :ref:`auditing event <auditing>` ``pathlib.Path.glob`` with "
"arguments ``self``, ``pattern``."
msgstr ""
"Lève un :ref:`évènement d’audit <auditing>` ``pathlib.Path.glob`` avec comme "
"arguments ``self`` et ``pattern``."

#: library/pathlib.rst:1147
msgid ""
"Return only directories if *pattern* ends with a pathname components "
"separator (:data:`~os.sep` or :data:`~os.altsep`)."
msgstr ""
"Renvoie uniquement des répertoires si *pattern* finit par un séparateur "
"d'éléments de chemin (:data:`~os.sep` ou :data:`~os.altsep`)."

#: library/pathlib.rst:858
msgid ""
"Return the name of the group owning the file.  :exc:`KeyError` is raised if "
"the file's gid isn't found in the system database."
msgstr ""
"Renvoie le nom du groupe propriétaire du fichier. :exc:`KeyError` est levée "
"si le *gid* du fichier n'est pas trouvé dans la base de données du système."

#: library/pathlib.rst:864
msgid ""
"Return ``True`` if the path points to a directory (or a symbolic link "
"pointing to a directory), ``False`` if it points to another kind of file."
msgstr ""
"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."

#: library/pathlib.rst:876 library/pathlib.rst:914 library/pathlib.rst:932
msgid ""
"``False`` is also returned if the path doesn't exist or is a broken symlink; "
"other errors (such as permission errors) are propagated."
msgstr ""
"``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."

#: library/pathlib.rst:873
msgid ""
"Return ``True`` if the path points to a regular file (or a symbolic link "
"pointing to a regular file), ``False`` if it points to another kind of file."
msgstr ""
"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."

#: library/pathlib.rst:882
msgid ""
"Return ``True`` if the path is a :dfn:`mount point`: a point in a file "
"system where a different file system has been mounted.  On POSIX, the "
"function checks whether *path*'s parent, :file:`path/..`, is on a different "
"device than *path*, or whether :file:`path/..` and *path* point to the same "
"i-node on the same device --- this should detect mount points for all Unix "
"and POSIX variants.  Not implemented on Windows."
msgstr ""
"Renvoie ``True`` si le chemin pointe vers un :dfn:`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*, :file:`path/.."
"`, se trouve sur un autre périphérique que *path*, ou si :file:`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."

#: library/pathlib.rst:894
msgid ""
"Return ``True`` if the path points to a symbolic link, ``False`` otherwise."
msgstr ""
"Renvoie ``True`` si le chemin pointe sur un lien symbolique, ``False`` sinon."

#: library/pathlib.rst:896
msgid ""
"``False`` is also returned if the path doesn't exist; other errors (such as "
"permission errors) are propagated."
msgstr ""
"``False`` est aussi renvoyé si le chemin n'existe pas ; d'autres erreurs "
"(telles que les erreurs de permission) sont propagées."

#: library/pathlib.rst:902
msgid ""
"Return ``True`` if the path points to a Unix socket (or a symbolic link "
"pointing to a Unix socket), ``False`` if it points to another kind of file."
msgstr ""
"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."

#: library/pathlib.rst:911
msgid ""
"Return ``True`` if the path points to a FIFO (or a symbolic link pointing to "
"a FIFO), ``False`` if it points to another kind of file."
msgstr ""
"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."

#: library/pathlib.rst:920
msgid ""
"Return ``True`` if the path points to a block device (or a symbolic link "
"pointing to a block device), ``False`` if it points to another kind of file."
msgstr ""
"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."

#: library/pathlib.rst:929
msgid ""
"Return ``True`` if the path points to a character device (or a symbolic link "
"pointing to a character device), ``False`` if it points to another kind of "
"file."
msgstr ""
"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."

#: library/pathlib.rst:938
msgid ""
"When the path points to a directory, yield path objects of the directory "
"contents::"
msgstr ""
"Quand le chemin pointe vers un dossier, donne par séquences les objets "
"chemin du contenu du dossier ::"

#: library/pathlib.rst:952
msgid ""
"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 a path object for that file "
"be included is unspecified."
msgstr ""
"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é."

#: library/pathlib.rst:959
msgid ""
"Like :meth:`Path.chmod` but, if the path points to a symbolic link, the "
"symbolic link's mode is changed rather than its target's."
msgstr ""
"Comme :meth:`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."

#: library/pathlib.rst:965
msgid ""
"Like :meth:`Path.stat` but, if the path points to a symbolic link, return "
"the symbolic link's information rather than its target's."
msgstr ""
"Comme :meth:`Path.stat`, mais, si le chemin pointe vers un lien symbolique, "
"renvoie les informations du lien symbolique plutôt que celui de sa cible."

#: library/pathlib.rst:971
msgid ""
"Create a new directory at this given path.  If *mode* is given, it is "
"combined with the process' ``umask`` value to determine the file mode and "
"access flags.  If the path already exists, :exc:`FileExistsError` is raised."
msgstr ""
"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à, :exc:"
"`FileExistsError` est levée."

#: library/pathlib.rst:976
msgid ""
"If *parents* is true, any missing parents of this path are created as "
"needed; they are created with the default permissions without taking *mode* "
"into account (mimicking the POSIX ``mkdir -p`` command)."
msgstr ""
"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``)."

#: library/pathlib.rst:980
msgid ""
"If *parents* is false (the default), a missing parent raises :exc:"
"`FileNotFoundError`."
msgstr ""
"Si *parents* est faux (valeur par défaut), un parent manquant lève :exc:"
"`FileNotFoundError`."

#: library/pathlib.rst:983
msgid ""
"If *exist_ok* is false (the default), :exc:`FileExistsError` is raised if "
"the target directory already exists."
msgstr ""
"Si *exist_ok* est faux (valeur par défaut), :exc:`FileExistsError` est levé "
"si le dossier cible existe déjà."

#: library/pathlib.rst:986
msgid ""
"If *exist_ok* is true, :exc:`FileExistsError` exceptions will be ignored "
"(same behavior as the POSIX ``mkdir -p`` command), but only if the last path "
"component is not an existing non-directory file."
msgstr ""
"If *exist_ok* est vrai, les exceptions :exc:`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."

# « nouveau dans la version … »
#: library/pathlib.rst:990
msgid "The *exist_ok* parameter was added."
msgstr "ajout du paramètre *exist_ok*."

#: library/pathlib.rst:996
msgid ""
"Open the file pointed to by the path, like the built-in :func:`open` "
"function does::"
msgstr ""
"Ouvre le fichier pointé par le chemin, comme la fonction native :func:`open` "
"le fait ::"

#: library/pathlib.rst:1008
msgid ""
"Return the name of the user owning the file.  :exc:`KeyError` is raised if "
"the file's uid isn't found in the system database."
msgstr ""
"Renvoie le nom de l'utilisateur auquel appartient le fichier. :exc:"
"`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."

#: library/pathlib.rst:1014
msgid "Return the binary contents of the pointed-to file as a bytes object::"
msgstr ""
"Renvoie le contenu binaire du fichier pointé en tant que chaîne d’octets ::"

#: library/pathlib.rst:1027
msgid "Return the decoded contents of the pointed-to file as a string::"
msgstr ""
"Renvoie le contenu décodé du fichier pointé en tant que chaîne de "
"caractères ::"

#: library/pathlib.rst:1035
msgid ""
"The file is opened and then closed. The optional parameters have the same "
"meaning as in :func:`open`."
msgstr ""
"Le fichier est ouvert, puis fermé. Les paramètres optionnels ont la même "
"signification que dans :func:`open`."

#: library/pathlib.rst:1043
msgid ""
"Return the path to which the symbolic link points (as returned by :func:`os."
"readlink`)::"
msgstr ""
"Renvoie le chemin vers lequel le lien symbolique pointe (tel que renvoyé "
"par :func:`os.readlink`) ::"

#: library/pathlib.rst:1056
msgid ""
"Rename this file or directory to the given *target*, and return a new Path "
"instance pointing to *target*.  On Unix, if *target* exists and is a file, "
"it will be replaced silently if the user has permission. On Windows, if "
"*target* exists, :exc:`FileExistsError` will be raised. *target* can be "
"either a string or another path object::"
msgstr ""
"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 :exc:`FileExistsError` "
"est systématiquement levée. *target* peut être soit une chaîne de "
"caractères, soit un autre chemin ::"

#: library/pathlib.rst:1087
msgid ""
"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."
msgstr ""
"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."

#: library/pathlib.rst:1075
msgid ""
"It is implemented in terms of :func:`os.rename` and gives the same "
"guarantees."
msgstr ""
"Cette méthode est implémentée d'après :func:`os.rename` et fournit les mêmes "
"garanties."

# « nouveau dans la version … »
#: library/pathlib.rst:1091
msgid "Added return value, return the new Path instance."
msgstr "ajout de la valeur de retour, renvoie une nouvelle instance *Path*."

#: library/pathlib.rst:1083
msgid ""
"Rename this file or directory to the given *target*, and return a new Path "
"instance pointing to *target*.  If *target* points to an existing file or "
"empty directory, it will be unconditionally replaced."
msgstr ""
"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é."

#: library/pathlib.rst:1097
msgid ""
"Make the path absolute, without normalization or resolving symlinks. Returns "
"a new path object::"
msgstr ""
"Rend le chemin absolu, sans normaliser ou résoudre les liens symboliques. "
"Renvoie un nouveau ::"

#: library/pathlib.rst:1109
msgid ""
"Make the path absolute, resolving any symlinks.  A new path object is "
"returned::"
msgstr ""
"Rend le chemin absolu, résolvant les liens symboliques. Un nouveau chemin "
"est renvoyé ::"

#: library/pathlib.rst:1118
msgid ""
"\"``..``\" components are also eliminated (this is the only method to do "
"so)::"
msgstr ""
"Les composantes \"``..``\" sont aussi éliminées (c'est la seule méthode pour "
"le faire) ::"

#: library/pathlib.rst:1124
msgid ""
"If the path doesn't exist and *strict* is ``True``, :exc:`FileNotFoundError` "
"is raised.  If *strict* is ``False``, the path is resolved as far as "
"possible and any remainder is appended without checking whether it exists.  "
"If an infinite loop is encountered along the resolution path, :exc:"
"`RuntimeError` is raised."
msgstr ""
"Si le chemin n'existe pas et que *strict* est ``True``, :exc:"
"`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, :exc:`RuntimeError` est levée."

# « nouveau dans la version … »
#: library/pathlib.rst:1130
msgid "The *strict* argument (pre-3.6 behavior is strict)."
msgstr "l'argument *strict* (le comportement *pré-3.6* est strict par défaut)."

#: library/pathlib.rst:1135
msgid ""
"This is like calling :func:`Path.glob` with \"``**/``\" added in front of "
"the given relative *pattern*::"
msgstr ""
"C'est similaire à appeler :func:`Path.glob` avec \"``**/``\" ajouté au début "
"du motif *pattern* relatif ::"

#: library/pathlib.rst:1145
msgid ""
"Raises an :ref:`auditing event <auditing>` ``pathlib.Path.rglob`` with "
"arguments ``self``, ``pattern``."
msgstr ""
"Lève un :ref:`évènement d’audit <auditing>` ``pathlib.Path.glob`` avec comme "
"arguments ``self`` et ``pattern``."

#: library/pathlib.rst:1153
msgid "Remove this directory.  The directory must be empty."
msgstr "Supprime ce dossier. Le dossier doit être vide."

#: library/pathlib.rst:1158
msgid ""
"Return whether this path points to the same file as *other_path*, which can "
"be either a Path object, or a string.  The semantics are similar to :func:"
"`os.path.samefile` and :func:`os.path.samestat`."
msgstr ""
"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 à :func:`os.path.samefile` et :func:`os.path.samestat`."

#: library/pathlib.rst:1162
msgid ""
"An :exc:`OSError` can be raised if either file cannot be accessed for some "
"reason."
msgstr ""
":exc:`OSError` peut être levée si l'un des fichiers ne peut être accédé pour "
"quelque raison."

#: library/pathlib.rst:1179
msgid ""
"Make this path a symbolic link to *target*.  Under Windows, "
"*target_is_directory* must be true (default ``False``) if the link's target "
"is a directory.  Under POSIX, *target_is_directory*'s value is ignored."
msgstr ""
"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."

#: library/pathlib.rst:1195
msgid ""
"The order of arguments (link, target) is the reverse of :func:`os.symlink`'s."
msgstr ""
"L'ordre des arguments (lien, cible) est l'opposé de ceux de :func:`os."
"symlink`."

#: library/pathlib.rst:1200
msgid "Make this path a hard link to the same file as *target*."
msgstr "Crée un lien physique pointant sur le même fichier que *target*."

#: library/pathlib.rst:1203
msgid ""
"The order of arguments (link, target) is the reverse of :func:`os.link`'s."
msgstr ""
"L'ordre des arguments (lien, cible) est l'opposé de celui de :func:`os.link`."

#: library/pathlib.rst:1210
msgid "Make *target* a hard link to this path."
msgstr "Crée un lien physique pointant sur le même fichier que *target*."

#: library/pathlib.rst:1214
msgid ""
"This function does not make this path a hard link to *target*, despite the "
"implication of the function and argument names. The argument order (target, "
"link) is the reverse of :func:`Path.symlink_to` and :func:`Path."
"hardlink_to`, but matches that of :func:`os.link`."
msgstr ""
"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 :func:`Path.symlink_to` et :"
"func:`Path.hardlink_to`, mais correspond en fait à celui de :func:`os.link`."

#: library/pathlib.rst:1223
msgid ""
"This method is deprecated in favor of :meth:`Path.hardlink_to`, as the "
"argument order of :meth:`Path.link_to`  does not match that of :meth:`Path."
"symlink_to`."
msgstr ""
"Cette méthode est rendue obsolète au profit de :meth:`Path.hardlink_to`, car "
"l’ordre des arguments de :meth:`Path.link_to` ne correspond pas à celui de :"
"meth:`Path.symlink_to`."

#: library/pathlib.rst:1230
msgid ""
"Create a file at this given path.  If *mode* is given, it is combined with "
"the process' ``umask`` value to determine the file mode and access flags.  "
"If the file already exists, the function succeeds if *exist_ok* is true (and "
"its modification time is updated to the current time), otherwise :exc:"
"`FileExistsError` is raised."
msgstr ""
"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 :exc:`FileExistsError` est levée."

#: library/pathlib.rst:1239
msgid ""
"Remove this file or symbolic link.  If the path points to a directory, use :"
"func:`Path.rmdir` instead."
msgstr ""
"Supprime ce fichier ou lien symbolique. Si le chemin pointe vers un dossier, "
"utilisez :func:`Path.rmdir` à la place."

#: library/pathlib.rst:1242
msgid ""
"If *missing_ok* is false (the default), :exc:`FileNotFoundError` is raised "
"if the path does not exist."
msgstr ""
"Si *missing_ok* est faux (valeur par défaut), une :exc:`FileNotFoundError` "
"est levée si le chemin n'existe pas."

#: library/pathlib.rst:1245
msgid ""
"If *missing_ok* is true, :exc:`FileNotFoundError` exceptions will be ignored "
"(same behavior as the POSIX ``rm -f`` command)."
msgstr ""
"Si *missing_ok* est vrai, les exceptions :exc:`FileNotFoundError` sont "
"ignorées (même comportement que la commande POSIX ``rm -f``)."

#: library/pathlib.rst:1248
msgid "The *missing_ok* parameter was added."
msgstr "Ajout du paramètre *missing_ok*."

#: library/pathlib.rst:1254
msgid ""
"Open the file pointed to in bytes mode, write *data* to it, and close the "
"file::"
msgstr ""
"Ouvre le fichier pointé en mode binaire, écrit *data* dedans, et ferme le "
"fichier ::"

#: library/pathlib.rst:1263
msgid "An existing file of the same name is overwritten."
msgstr "Le fichier du même nom, s'il existe, est écrasé."

#: library/pathlib.rst:1270
msgid ""
"Open the file pointed to in text mode, write *data* to it, and close the "
"file::"
msgstr ""
"Ouvre le fichier pointé en mode texte, écrit *data* dedans, et ferme le "
"fichier ::"

#: library/pathlib.rst:1279
msgid ""
"An existing file of the same name is overwritten. The optional parameters "
"have the same meaning as in :func:`open`."
msgstr ""
"Le fichier du même nom, s'il existe, est écrasé. Les paramètres optionnels "
"ont la même signification que dans :func:`open`."

# « nouveau dans la version … »
# Pas de majuscule après « : »
#: library/pathlib.rst:1284
msgid "The *newline* parameter was added."
msgstr "ajout du paramètre *newline*."

#: library/pathlib.rst:1288
msgid "Correspondence to tools in the :mod:`os` module"
msgstr "Correspondance des outils du module :mod:`os`"

#: library/pathlib.rst:1290
msgid ""
"Below is a table mapping various :mod:`os` functions to their corresponding :"
"class:`PurePath`/:class:`Path` equivalent."
msgstr ""
"Ci-dessous se trouve un tableau associant diverses fonctions :mod:`os` à "
"leur équivalent :class:`PurePath` / :class:`Path` correspondant."

#: library/pathlib.rst:1295
msgid ""
"Not all pairs of functions/methods below are equivalent. Some of them, "
"despite having some overlapping use-cases, have different semantics. They "
"include :func:`os.path.abspath` and :meth:`Path.absolute`, :func:`os.path."
"relpath` and :meth:`PurePath.relative_to`."
msgstr ""
"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 :func:`os.path."
"abspath` et :meth:`Path.absolute`, ainsi que :func:`os.path.relpath` et :"
"meth:`PurePath.relative_to`."

#: library/pathlib.rst:1301
msgid ":mod:`os` and :mod:`os.path`"
msgstr ":mod:`os` et :mod:`os.path`"

#: library/pathlib.rst:1301
msgid ":mod:`pathlib`"
msgstr ":mod:`pathlib`"

#: library/pathlib.rst:1303
msgid ":func:`os.path.abspath`"
msgstr ":func:`os.path.abspath`"

#: library/pathlib.rst:1303
msgid ":meth:`Path.absolute` [#]_"
msgstr ":meth:`Path.absolute` [#]_"

#: library/pathlib.rst:1304
msgid ":func:`os.path.realpath`"
msgstr ":func:`os.path.realpath`"

#: library/pathlib.rst:1304
msgid ":meth:`Path.resolve`"
msgstr ":meth:`Path.resolve`"

#: library/pathlib.rst:1305
msgid ":func:`os.chmod`"
msgstr ":func:`os.chmod`"

#: library/pathlib.rst:1305
msgid ":meth:`Path.chmod`"
msgstr ":meth:`Path.chmod`"

#: library/pathlib.rst:1306
msgid ":func:`os.mkdir`"
msgstr ":func:`os.mkdir`"

#: library/pathlib.rst:1307
msgid ":meth:`Path.mkdir`"
msgstr ":meth:`Path.mkdir`"

#: library/pathlib.rst:1307
msgid ":func:`os.makedirs`"
msgstr ":func:`os.makedirs`"

#: library/pathlib.rst:1308
msgid ":func:`os.rename`"
msgstr ":func:`os.rename`"

#: library/pathlib.rst:1308
msgid ":meth:`Path.rename`"
msgstr ":meth:`Path.rename`"

#: library/pathlib.rst:1309
msgid ":func:`os.replace`"
msgstr ":func:`os.replace`"

#: library/pathlib.rst:1309
msgid ":meth:`Path.replace`"
msgstr ":meth:`Path.replace`"

#: library/pathlib.rst:1310
msgid ":func:`os.rmdir`"
msgstr ":func:`os.rmdir`"

#: library/pathlib.rst:1310
msgid ":meth:`Path.rmdir`"
msgstr ":meth:`Path.rmdir`"

#: library/pathlib.rst:1311
msgid ":func:`os.remove`, :func:`os.unlink`"
msgstr ":func:`os.remove`, :func:`os.unlink`"

#: library/pathlib.rst:1311
msgid ":meth:`Path.unlink`"
msgstr ":meth:`Path.unlink`"

#: library/pathlib.rst:1312
msgid ":func:`os.getcwd`"
msgstr ":func:`os.getcwd`"

#: library/pathlib.rst:1312
msgid ":func:`Path.cwd`"
msgstr ":func:`Path.cwd`"

#: library/pathlib.rst:1313
msgid ":func:`os.path.exists`"
msgstr ":func:`os.path.exists`"

#: library/pathlib.rst:1313
msgid ":meth:`Path.exists`"
msgstr ":meth:`Path.exists`"

#: library/pathlib.rst:1314
msgid ":func:`os.path.expanduser`"
msgstr ":func:`os.path.expanduser`"

#: library/pathlib.rst:1314
msgid ":meth:`Path.expanduser` and :meth:`Path.home`"
msgstr ":meth:`Path.expanduser` et :meth:`Path.home`"

#: library/pathlib.rst:1316
msgid ":func:`os.listdir`"
msgstr ":func:`os.listdir`"

#: library/pathlib.rst:1316
msgid ":meth:`Path.iterdir`"
msgstr ":meth:`Path.iterdir`"

#: library/pathlib.rst:1317
msgid ":func:`os.path.isdir`"
msgstr ":func:`os.path.isdir`"

#: library/pathlib.rst:1317
msgid ":meth:`Path.is_dir`"
msgstr ":meth:`Path.is_dir`"

#: library/pathlib.rst:1318
msgid ":func:`os.path.isfile`"
msgstr ":func:`os.path.isfile`"

#: library/pathlib.rst:1318
msgid ":meth:`Path.is_file`"
msgstr ":meth:`Path.is_file`"

#: library/pathlib.rst:1319
msgid ":func:`os.path.islink`"
msgstr ":func:`os.path.islink`"

#: library/pathlib.rst:1319
msgid ":meth:`Path.is_symlink`"
msgstr ":meth:`Path.is_symlink`"

#: library/pathlib.rst:1320
msgid ":func:`os.link`"
msgstr ":func:`os.link`"

#: library/pathlib.rst:1320
msgid ":meth:`Path.hardlink_to`"
msgstr ":meth:`Path.hardlink_to`"

#: library/pathlib.rst:1321
msgid ":func:`os.symlink`"
msgstr ":func:`os.symlink`"

#: library/pathlib.rst:1321
msgid ":meth:`Path.symlink_to`"
msgstr ":meth:`Path.symlink_to`"

#: library/pathlib.rst:1322
msgid ":func:`os.readlink`"
msgstr ":func:`os.readlink`"

#: library/pathlib.rst:1322
msgid ":meth:`Path.readlink`"
msgstr ":meth:`Path.readlink`"

#: library/pathlib.rst:1323
msgid ":func:`os.path.relpath`"
msgstr ":func:`os.path.relpath`"

#: library/pathlib.rst:1323
msgid ":meth:`PurePath.relative_to` [#]_"
msgstr ":meth:`PurePath.relative_to` [#]_"

#: library/pathlib.rst:1324
msgid ":func:`os.stat`"
msgstr ":func:`os.stat`"

#: library/pathlib.rst:1324
msgid ":meth:`Path.stat`, :meth:`Path.owner`, :meth:`Path.group`"
msgstr ":meth:`Path.stat`, :meth:`Path.owner`, :meth:`Path.group`"

#: library/pathlib.rst:1327
msgid ":func:`os.path.isabs`"
msgstr ":func:`os.path.isabs`"

#: library/pathlib.rst:1327
msgid ":meth:`PurePath.is_absolute`"
msgstr ":meth:`PurePath.is_absolute`"

#: library/pathlib.rst:1328
msgid ":func:`os.path.join`"
msgstr ":func:`os.path.join`"

#: library/pathlib.rst:1328
msgid ":func:`PurePath.joinpath`"
msgstr ":func:`PurePath.joinpath`"

#: library/pathlib.rst:1329
msgid ":func:`os.path.basename`"
msgstr ":func:`os.path.basename`"

#: library/pathlib.rst:1329
msgid ":attr:`PurePath.name`"
msgstr ":attr:`PurePath.name`"

#: library/pathlib.rst:1330
msgid ":func:`os.path.dirname`"
msgstr ":func:`os.path.dirname`"

#: library/pathlib.rst:1330
msgid ":attr:`PurePath.parent`"
msgstr ":attr:`PurePath.parent`"

#: library/pathlib.rst:1331
msgid ":func:`os.path.samefile`"
msgstr ":func:`os.path.samefile`"

#: library/pathlib.rst:1331
msgid ":meth:`Path.samefile`"
msgstr ":meth:`Path.samefile`"

#: library/pathlib.rst:1332
msgid ":func:`os.path.splitext`"
msgstr ":func:`os.path.splitext`"

#: library/pathlib.rst:1332
msgid ":attr:`PurePath.stem` and :attr:`PurePath.suffix`"
msgstr ":attr:`PurePath.stem` et :attr:`PurePath.suffix`"

#: library/pathlib.rst:1337
msgid "Footnotes"
msgstr "Notes"

#: library/pathlib.rst:1338
msgid ""
":func:`os.path.abspath` normalizes the resulting path, which may change its "
"meaning in the presence of symlinks, while :meth:`Path.absolute` does not."
msgstr ""
":func:`os.path.abspath` normalise le chemin généré, ce qui peut en changer "
"la signification en présence de liens symboliques, alors que :meth:`Path."
"absolute` ne le fait pas."

#: library/pathlib.rst:1339
msgid ""
":meth:`PurePath.relative_to` requires ``self`` to be the subpath of the "
"argument, but :func:`os.path.relpath` does not."
msgstr ""
":meth:`Path.relative_to` exige que ``self`` soit le sous-chemin de "
"l’argument, ce qui pas le cas de :func:`os.path.relpath`."

#: library/pathlib.rst:12
msgid "path"
msgstr ""

#: library/pathlib.rst:12
#, fuzzy
msgid "operations"
msgstr "Opérateurs"

#~ msgid ""
#~ "However, in a Windows path, changing the local root doesn't discard the "
#~ "previous drive setting::"
#~ msgstr ""
#~ "Cependant, dans un chemin Windows, changer la racine locale ne supprime "
#~ "pas la précédente configuration de lecteur ::"

#~ msgid ""
#~ "The slash operator helps create child paths, similarly to :func:`os.path."
#~ "join`::"
#~ msgstr ""
#~ "L'opérateur slash aide à créer les chemins enfants, de manière similaire "
#~ "à :func:`os.path.join` ::"

#~ msgid ""
#~ "Although :func:`os.path.relpath` and :meth:`PurePath.relative_to` have "
#~ "some overlapping use-cases, their semantics differ enough to warrant not "
#~ "considering them equivalent."
#~ msgstr ""
#~ "Bien que :func:`os.path.relpath` et :meth:`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."