python-docs-fr/library/collections.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-28 15:29+0200\n"
"PO-Revision-Date: 2018-10-05 15:34+0200\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"
"Last-Translator: Guillaume Fayard <guillaume.fayard@pycolore.fr>\n"
"X-Generator: Poedit 2.1.1\n"

#: ../Doc/library/collections.rst:2
msgid ":mod:`collections` --- Container datatypes"
msgstr ":mod:`collections` --- Types de données de conteneurs"

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

#: ../Doc/library/collections.rst:20
msgid ""
"This module implements specialized container datatypes providing alternatives to "
"Python's general purpose built-in containers, :class:`dict`, :class:`list`, :class:"
"`set`, and :class:`tuple`."
msgstr ""
"Ce module implémente des types de données de conteneurs spécialisés qui apportent des "
"alternatives aux conteneurs natifs de Python plus généraux :class:`dict`, :class:"
"`list`, :class:`set` et :class:`tuple`."

#: ../Doc/library/collections.rst:25
msgid ":func:`namedtuple`"
msgstr ":func:`namedtuple`"

#: ../Doc/library/collections.rst:25
msgid "factory function for creating tuple subclasses with named fields"
msgstr "fonction permettant de créer des sous-classes de ``tuple`` avec des champs nommés"

#: ../Doc/library/collections.rst:26
msgid ":class:`deque`"
msgstr ":class:`deque`"

#: ../Doc/library/collections.rst:26
msgid "list-like container with fast appends and pops on either end"
msgstr ""
"conteneur se comportant comme une liste avec des ajouts et retraits rapides à chaque "
"extrémité"

#: ../Doc/library/collections.rst:27
msgid ":class:`ChainMap`"
msgstr ":class:`ChainMap`"

#: ../Doc/library/collections.rst:27
msgid "dict-like class for creating a single view of multiple mappings"
msgstr ""
"classe semblable aux dictionnaires qui crée une unique vue à partir de plusieurs "
"dictionnaires"

#: ../Doc/library/collections.rst:28
msgid ":class:`Counter`"
msgstr ":class:`Counter`"

#: ../Doc/library/collections.rst:28
msgid "dict subclass for counting hashable objects"
msgstr "sous-classe de ``dict`` pour compter des objets hachables"

#: ../Doc/library/collections.rst:29
msgid ":class:`OrderedDict`"
msgstr ":class:`OrderedDict`"

#: ../Doc/library/collections.rst:29
msgid "dict subclass that remembers the order entries were added"
msgstr ""
"sous-classe de ``dict`` qui garde en mémoire l'ordre dans lequel les entrées ont été "
"ajoutées"

#: ../Doc/library/collections.rst:30
msgid ":class:`defaultdict`"
msgstr ":class:`defaultdict`"

#: ../Doc/library/collections.rst:30
msgid "dict subclass that calls a factory function to supply missing values"
msgstr ""
"sous-classe de ``dict`` qui appelle une fonction de fabrication en cas de valeur "
"manquante"

#: ../Doc/library/collections.rst:31
msgid ":class:`UserDict`"
msgstr ":class:`UserDict`"

#: ../Doc/library/collections.rst:31
msgid "wrapper around dictionary objects for easier dict subclassing"
msgstr "surcouche autour des objets dictionnaires pour faciliter l'héritage de ``dict``"

#: ../Doc/library/collections.rst:32
msgid ":class:`UserList`"
msgstr ":class:`UserList`"

#: ../Doc/library/collections.rst:32
msgid "wrapper around list objects for easier list subclassing"
msgstr "surcouche autour des objets listes pour faciliter l'héritage de ``list``"

#: ../Doc/library/collections.rst:33
msgid ":class:`UserString`"
msgstr ":class:`UserString`"

#: ../Doc/library/collections.rst:33
msgid "wrapper around string objects for easier string subclassing"
msgstr ""
"surcouche autour des objets chaînes de caractères pour faciliter l'héritage de ``str``"

#: ../Doc/library/collections.rst:36
msgid ""
"Moved :ref:`collections-abstract-base-classes` to the :mod:`collections.abc` module. "
"For backwards compatibility, they continue to be visible in this module through Python "
"3.7.  Subsequently, they will be removed entirely."
msgstr ""
"Les :ref:`collections-abstract-base-classes` ont été déplacées vers le module :mod:"
"`collections.abc`. Pour assurer la rétrocompatibilité, elles sont toujours disponibles "
"dans ce module en Python 3.7 mais seront ensuite totalement supprimées."

#: ../Doc/library/collections.rst:43
msgid ":class:`ChainMap` objects"
msgstr "Objets :class:`ChainMap`"

#: ../Doc/library/collections.rst:47
msgid ""
"A :class:`ChainMap` class is provided for quickly linking a number of mappings so they "
"can be treated as a single unit.  It is often much faster than creating a new "
"dictionary and running multiple :meth:`~dict.update` calls."
msgstr ""
"Le module fournit une classe :class:`ChainMap` afin de réunir rapidement plusieurs "
"dictionnaires en une unique entité. Cela est souvent plus rapide que de créer un "
"nouveau dictionnaire et d'effectuer plusieurs appels de :meth:`~dict.update`."

#: ../Doc/library/collections.rst:51
msgid "The class can be used to simulate nested scopes and is useful in templating."
msgstr ""
"Cette classe peut être utilisée pour simuler des portées imbriquées, elle est aussi "
"utile pour le *templating*."

#: ../Doc/library/collections.rst:55
msgid ""
"A :class:`ChainMap` groups multiple dicts or other mappings together to create a "
"single, updateable view.  If no *maps* are specified, a single empty dictionary is "
"provided so that a new chain always has at least one mapping."
msgstr ""
"Un objet :class:`ChainMap` regroupe plusieurs dictionnaires (ou autres tableaux de "
"correspondance) en une vue que l'on peut mettre à jour. Si le paramètre *maps* est "
"vide, un dictionnaire vide est fourni de telle manière qu'une nouvelle chaîne possède "
"toujours au moins un dictionnaire."

#: ../Doc/library/collections.rst:59
msgid ""
"The underlying mappings are stored in a list.  That list is public and can be accessed "
"or updated using the *maps* attribute.  There is no other state."
msgstr ""
"Les dictionnaires sous-jacents sont stockés dans une liste. Celle-ci est publique et "
"peut être consultée ou mise à jour via l'attribut *maps*. Il n'y a pas d'autre état."

#: ../Doc/library/collections.rst:62
msgid ""
"Lookups search the underlying mappings successively until a key is found.  In contrast, "
"writes, updates, and deletions only operate on the first mapping."
msgstr ""
"Les recherches s'effectuent successivement dans chaque dictionnaire jusqu'à la première "
"clé correspondante. En revanche, les écritures, mises à jour et suppressions "
"n'affectent que le premier dictionnaire."

#: ../Doc/library/collections.rst:65
msgid ""
"A :class:`ChainMap` incorporates the underlying mappings by reference.  So, if one of "
"the underlying mappings gets updated, those changes will be reflected in :class:"
"`ChainMap`."
msgstr ""
"Un objet :class:`ChainMap` incorpore les dictionnaires sous-jacents par leur référence. "
"Ainsi, si l'un d'eux est modifié, les changements affectent également la :class:"
"`ChainMap`."

#: ../Doc/library/collections.rst:69
msgid ""
"All of the usual dictionary methods are supported.  In addition, there is a *maps* "
"attribute, a method for creating new subcontexts, and a property for accessing all but "
"the first mapping:"
msgstr ""
"Toutes les méthodes usuelles des dictionnaires sont gérées. De plus, cette classe "
"fournit un attribut *maps*, une méthode pour créer de nouveaux sous-contextes et une "
"propriété pour accéder à tous les dictionnaires sous-jacents excepté le premier :"

#: ../Doc/library/collections.rst:75
msgid ""
"A user updateable list of mappings.  The list is ordered from first-searched to last-"
"searched.  It is the only stored state and can be modified to change which mappings are "
"searched.  The list should always contain at least one mapping."
msgstr ""
"Liste de dictionnaires éditable par l'utilisateur et classée selon l'ordre de "
"recherche. Il s'agit de l'unique état stocké et elle peut être modifiée pour changer "
"l'ordre de recherche. La liste doit toujours contenir au moins un dictionnaire."

#: ../Doc/library/collections.rst:82
msgid ""
"Returns a new :class:`ChainMap` containing a new map followed by all of the maps in the "
"current instance.  If ``m`` is specified, it becomes the new map at the front of the "
"list of mappings; if not specified, an empty dict is used, so that a call to ``d."
"new_child()`` is equivalent to: ``ChainMap({}, *d.maps)``.  This method is used for "
"creating subcontexts that can be updated without altering values in any of the parent "
"mappings."
msgstr ""
"Renvoie un nouvel objet :class:`ChainMap` contenant un nouveau dictionnaire suivi par "
"tous les autres de l'instance actuelle. Si ``m`` est spécifié, il devient le nouveau "
"dictionnaire au début de la liste ; sinon, un dictionnaire vide est utilisé, de telle "
"manière qu'appeler ``d.new_child()`` équivaut à appeler ``ChainMap({}, *d.maps)``. "
"Cette méthode est utile pour créer des sous-contextes qui peuvent être mis à jour sans "
"altérer les valeurs dans les dictionnaires parents."

#: ../Doc/library/collections.rst:90
msgid "The optional ``m`` parameter was added."
msgstr "Ajout du paramètre optionnel ``m``."

#: ../Doc/library/collections.rst:95
msgid ""
"Property returning a new :class:`ChainMap` containing all of the maps in the current "
"instance except the first one.  This is useful for skipping the first map in the "
"search.  Use cases are similar to those for the :keyword:`nonlocal` keyword used in :"
"term:`nested scopes <nested scope>`.  The use cases also parallel those for the built-"
"in :func:`super` function.  A reference to ``d.parents`` is equivalent to: "
"``ChainMap(*d.maps[1:])``."
msgstr ""
"Propriété qui renvoie un nouvel objet :class:`ChainMap` contenant tous les "
"dictionnaires de l'instance actuelle hormis le premier. Cette propriété est utile pour "
"ignorer le premier dictionnaire dans les recherches ; son utilisation rappelle le mot-"
"clé :keyword:`nonlocal` (utilisé pour les :term:`portées imbriquées <nested scope>`), "
"ou bien la fonction native :func:`super`. Une référence à ``d.parents`` est équivalente "
"à : ``ChainMap(*d.maps[1:])``."

#: ../Doc/library/collections.rst:106
msgid ""
"The `MultiContext class <https://github.com/enthought/codetools/blob/4.0.0/codetools/"
"contexts/multi_context.py>`_ in the Enthought `CodeTools package <https://github.com/"
"enthought/codetools>`_ has options to support writing to any mapping in the chain."
msgstr ""
"La `classe MultiContext <https://github.com/enthought/codetools/blob/4.0.0/codetools/"
"contexts/multi_context.py>`_ dans le `package CodeTools <https://github.com/enthought/"
"codetools>`_ d'Enthought possède des options pour gérer l'écriture dans n'importe quel "
"dictionnaire de la chaîne."

#: ../Doc/library/collections.rst:112
msgid ""
"Django's `Context class <https://github.com/django/django/blob/master/django/template/"
"context.py>`_ for templating is a read-only chain of mappings.  It also features "
"pushing and popping of contexts similar to the :meth:`~collections.ChainMap.new_child` "
"method and the :attr:`~collections.ChainMap.parents` property."
msgstr ""
"La `classe de contexte de Django <https://github.com/django/django/blob/master/django/"
"template/context.py>`_ pour la création de modèles est une chaîne de dictionnaires en "
"lecture seule. Elle comporte également des fonctionnalités d'ajouts et de retraits de "
"contextes similaires à la méthode :meth:`~collections.ChainMap.new_child` et à la "
"propriété :attr:`~collections.ChainMap.parents`."

#: ../Doc/library/collections.rst:119
msgid ""
"The `Nested Contexts recipe <https://code.activestate.com/recipes/577434/>`_ has "
"options to control whether writes and other mutations apply only to the first mapping "
"or to any mapping in the chain."
msgstr ""
"`Le Cas pratique des contextes imbriqués <https://code.activestate.com/recipes/577434/"
">`_ a des options pour contrôler si les écritures et autres mutations ne s'appliquent "
"qu'au premier ou à un autre dictionnaire de la chaîne."

#: ../Doc/library/collections.rst:124
msgid ""
"A `greatly simplified read-only version of Chainmap <https://code.activestate.com/"
"recipes/305268/>`_."
msgstr ""
"Une `version grandement simplifiée de Chainmap en lecture seule <https://code."
"activestate.com/recipes/305268/>`_."

#: ../Doc/library/collections.rst:129
msgid ":class:`ChainMap` Examples and Recipes"
msgstr "Exemples et cas pratiques utilisant :class:`ChainMap`"

#: ../Doc/library/collections.rst:131
msgid "This section shows various approaches to working with chained maps."
msgstr ""
"Cette partie montre diverses approches afin de travailler avec les dictionnaires "
"chaînés."

#: ../Doc/library/collections.rst:134
msgid "Example of simulating Python's internal lookup chain::"
msgstr "Exemple 1 : simulation de la chaîne de recherche interne de Python : ::"

#: ../Doc/library/collections.rst:139
msgid ""
"Example of letting user specified command-line arguments take precedence over "
"environment variables which in turn take precedence over default values::"
msgstr ""
"Exemple 2 : spécification d'une hiérarchie pour les options : ligne de commande, "
"variable d'environnement, valeurs par défaut : ::"

#: ../Doc/library/collections.rst:156
msgid ""
"Example patterns for using the :class:`ChainMap` class to simulate nested contexts::"
msgstr ""
"Exemple 3 : modèles pour simuler des contexte imbriqués avec la classe :class:"
"`ChainMap` ::"

#: ../Doc/library/collections.rst:175
msgid ""
"The :class:`ChainMap` class only makes updates (writes and deletions) to the first "
"mapping in the chain while lookups will search the full chain.  However, if deep writes "
"and deletions are desired, it is easy to make a subclass that updates keys found deeper "
"in the chain::"
msgstr ""
"La classe :class:`ChainMap` ne met à jour (écriture et suppression) que le premier "
"dictionnaire de la chaîne, alors qu'une recherche inspecte toute la chaîne. Cependant, "
"si l'on veut effectuer des écritures ou suppressions en profondeur, on peut facilement "
"faire une sous-classe qui met à jour les clés trouvées de la chaîne en profondeur : ::"

#: ../Doc/library/collections.rst:205
msgid ":class:`Counter` objects"
msgstr "Objets :class:`Counter`"

#: ../Doc/library/collections.rst:207
msgid "A counter tool is provided to support convenient and rapid tallies. For example::"
msgstr ""
"Ce module fournit un outil pour effectuer rapidement et facilement des dénombrements. "
"Par exemple : ::"

#: ../Doc/library/collections.rst:226
msgid ""
"A :class:`Counter` is a :class:`dict` subclass for counting hashable objects. It is an "
"unordered collection where elements are stored as dictionary keys and their counts are "
"stored as dictionary values.  Counts are allowed to be any integer value including zero "
"or negative counts.  The :class:`Counter` class is similar to bags or multisets in "
"other languages."
msgstr ""
"La classe :class:`Counter` est une sous-classe de :class:`dict` qui permet le "
"dénombrement d'objets hachables. Il s'agit d'une collection non ordonnée dans laquelle "
"les éléments sont stockés comme des clés de dictionnaire et leurs nombres d’occurrences "
"respectifs comme leurs valeurs. Ceux-ci peuvent être des entiers relatifs (positifs, "
"négatifs ou nuls). La classe :class:`Counter` est similaire aux sacs ou aux "
"multiensembles dans d'autres langages."

#: ../Doc/library/collections.rst:232
msgid ""
"Elements are counted from an *iterable* or initialized from another *mapping* (or "
"counter):"
msgstr ""
"Les éléments sont comptés à partir d'un itérable ou initialisés à partir d'un autre "
"dictionnaire (ou compteur) :"

#: ../Doc/library/collections.rst:240
msgid ""
"Counter objects have a dictionary interface except that they return a zero count for "
"missing items instead of raising a :exc:`KeyError`:"
msgstr ""
"Les objets Counter ont une interface de dictionnaire, à l'exception près qu'ils "
"renvoient zéro au lieu de lever une exception :exc:`KeyError` pour des éléments "
"manquants :"

#: ../Doc/library/collections.rst:247
msgid ""
"Setting a count to zero does not remove an element from a counter. Use ``del`` to "
"remove it entirely:"
msgstr ""
"Mettre un comptage à zéro pour un élément ne le retire pas de l'objet Counter. Il faut "
"utiliser ``del`` pour le supprimer complètement :"

#: ../Doc/library/collections.rst:256
msgid "Counter objects support three methods beyond those available for all dictionaries:"
msgstr ""
"En plus des méthodes disponibles pour tous les dictionnaires, les objets compteurs "
"gèrent trois méthodes supplémentaires :"

#: ../Doc/library/collections.rst:261
msgid ""
"Return an iterator over elements repeating each as many times as its count.  Elements "
"are returned in arbitrary order.  If an element's count is less than one, :meth:"
"`elements` will ignore it."
msgstr ""
"Renvoie un itérateur sur chaque élément en le répétant autant de fois que la valeur du "
"compteur associé. Les éléments sont renvoyés dans un ordre arbitraire. Si le comptage "
"d'un élément est strictement inférieur à 1, alors :meth:`elements` l'ignore."

#: ../Doc/library/collections.rst:271
msgid ""
"Return a list of the *n* most common elements and their counts from the most common to "
"the least.  If *n* is omitted or ``None``, :meth:`most_common` returns *all* elements "
"in the counter. Elements with equal counts are ordered arbitrarily:"
msgstr ""
"Renvoie une liste des *n* éléments les plus nombreux et leur valeur respective dans "
"l'ordre décroissant. Si *n* n'est pas fourni ou vaut ``None``, :meth:`most_common` "
"renvoie *tous* les éléments du compteur. Les éléments qui ont le même nombre "
"d'occurrences sont ordonnés de manière arbitraire :"

#: ../Doc/library/collections.rst:281
msgid ""
"Elements are subtracted from an *iterable* or from another *mapping* (or counter).  "
"Like :meth:`dict.update` but subtracts counts instead of replacing them.  Both inputs "
"and outputs may be zero or negative."
msgstr ""
"Les éléments sont soustraits à partir d'un itérable ou d'un autre dictionnaire (ou "
"compteur). Cette méthode se comporte comme :meth:`dict.update` mais soustrait les "
"nombres d'occurrences au lieu de les remplacer. Les entrées et sorties peuvent être "
"négatives ou nulles."

#: ../Doc/library/collections.rst:293
msgid ""
"The usual dictionary methods are available for :class:`Counter` objects except for two "
"which work differently for counters."
msgstr ""
"Les méthodes usuelles des dictionnaires sont disponibles pour les objets :class:"
"`Counter` à l'exception de deux méthodes qui fonctionnent différemment pour les "
"compteurs."

#: ../Doc/library/collections.rst:298
msgid "This class method is not implemented for :class:`Counter` objects."
msgstr "Cette méthode de classe n'est pas implémentée pour les objets :class:`Counter`."

#: ../Doc/library/collections.rst:302
msgid ""
"Elements are counted from an *iterable* or added-in from another *mapping* (or "
"counter).  Like :meth:`dict.update` but adds counts instead of replacing them.  Also, "
"the *iterable* is expected to be a sequence of elements, not a sequence of ``(key, "
"value)`` pairs."
msgstr ""
"Les éléments sont comptés à partir d'un itérable ou ajoutés d'un autre dictionnaire (ou "
"compteur). Cette méthode se comporte comme :meth:`dict.update` mais additionne les "
"nombres d'occurrences au lieu de les remplacer. De plus, l'itérable doit être une "
"séquence d'éléments et non une séquence de paires ``(clé, valeur)``."

#: ../Doc/library/collections.rst:307
msgid "Common patterns for working with :class:`Counter` objects::"
msgstr "Opérations usuelles sur les objets :class:`Counter` : ::"

#: ../Doc/library/collections.rst:319
msgid ""
"Several mathematical operations are provided for combining :class:`Counter` objects to "
"produce multisets (counters that have counts greater than zero). Addition and "
"subtraction combine counters by adding or subtracting the counts of corresponding "
"elements.  Intersection and union return the minimum and maximum of corresponding "
"counts.  Each operation can accept inputs with signed counts, but the output will "
"exclude results with counts of zero or less."
msgstr ""
"Quelques opérations mathématiques sont fournies pour combiner des objets :class:"
"`Counter` afin de créer des multiensembles (des compteurs dont les dénombrements des "
"éléments sont strictement supérieurs à zéro). Les additions et soustractions combinent "
"les compteurs en ajoutant ou retranchant les nombres d'occurrences des éléments "
"correspondants. Les intersections et unions renvoient les minimums et maximums des "
"comptages correspondants. Chaque opération peut accepter des entrées avec des comptages "
"relatifs, mais la sortie exclut les résultats avec des comptages négatifs ou nuls."

#: ../Doc/library/collections.rst:337
msgid ""
"Unary addition and subtraction are shortcuts for adding an empty counter or subtracting "
"from an empty counter."
msgstr ""
"L'addition et la soustraction unaires (avec un seul terme) sont des raccourcis pour "
"respectivement additionner un compteur avec un compteur vide ou et pour retrancher un "
"compteur d'un compteur vide."

#: ../Doc/library/collections.rst:346
msgid "Added support for unary plus, unary minus, and in-place multiset operations."
msgstr ""
"Ajout de la gestion des additions et soustractions unaires, et des remplacements dans "
"les multiensembles."

#: ../Doc/library/collections.rst:351
msgid ""
"Counters were primarily designed to work with positive integers to represent running "
"counts; however, care was taken to not unnecessarily preclude use cases needing other "
"types or negative values.  To help with those use cases, this section documents the "
"minimum range and type restrictions."
msgstr ""
"Les compteurs ont été conçus essentiellement pour fonctionner avec des entiers naturels "
"pour représenter les dénombrements en cours ; cependant, les cas d'utilisation "
"nécessitant d'autres types ou des valeurs négatives n'ont pas été écartés. Pour vous "
"aider dans ces cas particuliers, cette section documente la plage minimale et les "
"restrictions de type."

#: ../Doc/library/collections.rst:356
msgid ""
"The :class:`Counter` class itself is a dictionary subclass with no restrictions on its "
"keys and values.  The values are intended to be numbers representing counts, but you "
"*could* store anything in the value field."
msgstr ""
"La classe :class:`Counter` est elle-même une sous-classe de dictionnaire sans "
"restriction particulière sur ces clés ou valeurs. Les valeurs ont vocation à être des "
"nombres représentants des comptages, mais il est *possible* de stocker n'importe quel "
"type de valeur."

#: ../Doc/library/collections.rst:360
msgid ""
"The :meth:`~Counter.most_common` method requires only that the values be orderable."
msgstr ""
"La méthode :meth:`~Counter.most_common` exige uniquement que les valeurs soient "
"ordonnables."

#: ../Doc/library/collections.rst:362
msgid ""
"For in-place operations such as ``c[key] += 1``, the value type need only support "
"addition and subtraction.  So fractions, floats, and decimals would work and negative "
"values are supported.  The same is also true for :meth:`~Counter.update` and :meth:"
"`~Counter.subtract` which allow negative and zero values for both inputs and outputs."
msgstr ""
"Les opérations de remplacement telles que ``c[key] += 1`` exigent une valeur dont le "
"type gère l'addition et la soustraction. Cela inclut donc les fractions, les flottants "
"et les décimaux, y compris négatifs. Il en va de même pour :meth:`~Counter.update` et :"
"meth:`~Cointer.substract` qui acceptent des valeurs négatives ou nulles dans les "
"entrées et sorties."

#: ../Doc/library/collections.rst:368
msgid ""
"The multiset methods are designed only for use cases with positive values. The inputs "
"may be negative or zero, but only outputs with positive values are created.  There are "
"no type restrictions, but the value type needs to support addition, subtraction, and "
"comparison."
msgstr ""
"Les méthodes de multiensembles sont uniquement conçues pour les cas d'utilisation avec "
"des valeurs positives. Les entrées peuvent contenir des valeurs négatives ou nulles, "
"mais seules les sorties avec des valeurs positives sont créées. Il n'y a pas de "
"restriction de type, mais les types des valeurs doivent gérer l'addition, la "
"soustraction et la comparaison."

#: ../Doc/library/collections.rst:373
msgid ""
"The :meth:`~Counter.elements` method requires integer counts.  It ignores zero and "
"negative counts."
msgstr ""
"La méthode :meth:`~Counter.elements` exige des valeurs entières et ignore les valeurs "
"négatives ou nulles."

#: ../Doc/library/collections.rst:378
msgid ""
"`Bag class <https://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html>`_ in "
"Smalltalk."
msgstr ""
"`Bag class <https://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html>`_ "
"dans Smalltalk."

#: ../Doc/library/collections.rst:381
msgid "Wikipedia entry for `Multisets <https://en.wikipedia.org/wiki/Multiset>`_."
msgstr ""
"L'article Wikipédia sur les `multiensembles <https://fr.wikipedia.org/wiki/"
"Multiensemble>`_ sur Wikipédia (ou `l'article en anglais <https://en.wikipedia.org/wiki/"
"Multiset>`_)."

#: ../Doc/library/collections.rst:383
msgid ""
"`C++ multisets <http://www.java2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-"
"multiset.htm>`_ tutorial with examples."
msgstr ""
"Des guides et exemples à propos des `multiensembles en C++ <http://www.java2s.com/"
"Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm>`_."

#: ../Doc/library/collections.rst:386
msgid ""
"For mathematical operations on multisets and their use cases, see *Knuth, Donald. The "
"Art of Computer Programming Volume II, Section 4.6.3, Exercise 19*."
msgstr ""
"Pour les opérations mathématiques sur les multiensembles et leurs applications, voir "
"*Knuth, Donald. The Art of Computer Programming Volume II, Section 4.6.3, Exercise 19*."

#: ../Doc/library/collections.rst:390
msgid ""
"To enumerate all distinct multisets of a given size over a given set of elements, see :"
"func:`itertools.combinations_with_replacement`::"
msgstr ""
"Pour lister tous les multiensembles distincts de même taille parmi un ensemble donné "
"d'éléments, voir :func:`itertools.combinations_with_replacement` : ::"

#: ../Doc/library/collections.rst:397
msgid ":class:`deque` objects"
msgstr "Objets :class:`deque`"

#: ../Doc/library/collections.rst:401
msgid ""
"Returns a new deque object initialized left-to-right (using :meth:`append`) with data "
"from *iterable*.  If *iterable* is not specified, the new deque is empty."
msgstr ""
"Renvoie un nouvel objet *deque* initialisé de gauche à droite (en utilisant :meth:"
"`append`) avec les données d'*iterable*. Si *iterable* n'est pas spécifié, alors la "
"nouvelle *deque* est vide."

#: ../Doc/library/collections.rst:404
msgid ""
"Deques are a generalization of stacks and queues (the name is pronounced \"deck\" and "
"is short for \"double-ended queue\").  Deques support thread-safe, memory efficient "
"appends and pops from either side of the deque with approximately the same O(1) "
"performance in either direction."
msgstr ""
"Les *deques* sont une généralisation des piles et des files (*deque* se prononce "
"\"*dèque*\" et est l'abréviation de l'anglais *double-ended queue*) : il est possible "
"d'ajouter et retirer des éléments par les deux bouts des *deques*. Celles-ci gèrent des "
"ajouts et des retraits utilisables par de multiples fils d'exécution (*thread-safe*) et "
"efficients du point de vue de la mémoire des deux côtés de la *deque*, avec "
"approximativement la même performance en *O(1)* dans les deux sens."

#: ../Doc/library/collections.rst:409
msgid ""
"Though :class:`list` objects support similar operations, they are optimized for fast "
"fixed-length operations and incur O(n) memory movement costs for ``pop(0)`` and "
"``insert(0, v)`` operations which change both the size and position of the underlying "
"data representation."
msgstr ""
"Bien que les les objets :class:`list` gèrent des opérations similaires, ils sont "
"optimisés pour des opérations qui ne changent pas la taille de la liste. Les opérations "
"``pop(0)`` et ``insert(0, v)`` qui changent la taille et la position de la "
"représentation des données sous-jacentes entraînent des coûts de déplacement de mémoire "
"en *O(n)*."

#: ../Doc/library/collections.rst:415
msgid ""
"If *maxlen* is not specified or is ``None``, deques may grow to an arbitrary length.  "
"Otherwise, the deque is bounded to the specified maximum length.  Once a bounded length "
"deque is full, when new items are added, a corresponding number of items are discarded "
"from the opposite end.  Bounded length deques provide functionality similar to the "
"``tail`` filter in Unix. They are also useful for tracking transactions and other pools "
"of data where only the most recent activity is of interest."
msgstr ""
"Si *maxlen* n'est pas spécifié ou vaut *None*, les *deques* peuvent atteindre une "
"taille arbitraire. Sinon, la *deque* est limitée par cette taille maximale. Une fois "
"que celle-ci est atteinte, un ajout d'un ou plusieurs éléments engendre la suppression "
"du nombre correspondant d'éléments à l'autre extrémité de la *deque*. Les *deques* à "
"longueur limitée apportent des fonctionnalités similaire au filtre ``tail`` d'Unix. "
"Elles sont aussi utiles pour le suivi de transactions et autres lots de données où "
"seule l'activité récente est intéressante."

#: ../Doc/library/collections.rst:424
msgid "Deque objects support the following methods:"
msgstr "Les objets *deques* gèrent les méthodes suivantes :"

#: ../Doc/library/collections.rst:428
msgid "Add *x* to the right side of the deque."
msgstr "Ajoute *x* à l'extrémité droite de la *deque*."

#: ../Doc/library/collections.rst:433
msgid "Add *x* to the left side of the deque."
msgstr "Ajoute *x* à l'extrémité gauche de la *deque*."

#: ../Doc/library/collections.rst:438
msgid "Remove all elements from the deque leaving it with length 0."
msgstr "Supprime tous les éléments de la *deque* et la laisse avec une longueur de 0."

#: ../Doc/library/collections.rst:443
msgid "Create a shallow copy of the deque."
msgstr "Crée une copie superficielle de la *deque*."

#: ../Doc/library/collections.rst:450
msgid "Count the number of deque elements equal to *x*."
msgstr "Compte le nombre d'éléments de la *deque* égaux à *x*."

#: ../Doc/library/collections.rst:457
msgid ""
"Extend the right side of the deque by appending elements from the iterable argument."
msgstr ""
"Étend la *deque* en ajoutant les éléments de l'itérable en argument à son extrémité "
"droite."

#: ../Doc/library/collections.rst:463
msgid ""
"Extend the left side of the deque by appending elements from *iterable*. Note, the "
"series of left appends results in reversing the order of elements in the iterable "
"argument."
msgstr ""
"Étend la *deque* en ajoutant les éléments d'*iterable* à son extrémité gauche. Dans ce "
"cas, notez que la série d'ajouts inverse l'ordre des éléments de l'argument itérable."

#: ../Doc/library/collections.rst:470
msgid ""
"Return the position of *x* in the deque (at or after index *start* and before index "
"*stop*).  Returns the first match or raises :exc:`ValueError` if not found."
msgstr ""
"Renvoie la position de *x* dans la *deque* (à partir de *start* inclus et jusqu'à "
"*stop* exclus). Renvoie la première correspondance ou lève :exc:`ValueError` si aucune "
"n'est trouvée."

#: ../Doc/library/collections.rst:479
msgid "Insert *x* into the deque at position *i*."
msgstr "Insère *x* dans la *deque* à la position *i*."

#: ../Doc/library/collections.rst:481
msgid ""
"If the insertion would cause a bounded deque to grow beyond *maxlen*, an :exc:"
"`IndexError` is raised."
msgstr ""
"Si une insertion provoque un dépassement de la taille limitée d'une *deque*, alors elle "
"lève une exception :exc:`IndexError`."

#: ../Doc/library/collections.rst:489
msgid ""
"Remove and return an element from the right side of the deque. If no elements are "
"present, raises an :exc:`IndexError`."
msgstr ""
"Retire et renvoie un élément de l'extrémité droite de la *deque*. S'il n'y a aucun "
"élément, lève une exception :exc:`IndexError`."

#: ../Doc/library/collections.rst:495
msgid ""
"Remove and return an element from the left side of the deque. If no elements are "
"present, raises an :exc:`IndexError`."
msgstr ""
"Retire et renvoie un élément de l'extrémité gauche de la *deque*. S'il n'y a aucun "
"élément, lève une exception :exc:`IndexError`."

#: ../Doc/library/collections.rst:501
msgid "Remove the first occurrence of *value*.  If not found, raises a :exc:`ValueError`."
msgstr ""
"Supprime la première occurrence de *value*. Si aucune occurrence n'est trouvée, lève "
"une exception :exc:`ValueError`."

#: ../Doc/library/collections.rst:507
msgid "Reverse the elements of the deque in-place and then return ``None``."
msgstr ""
"Inverse le sens des éléments de la *deque* sans créer de copie et renvoie ``None``."

#: ../Doc/library/collections.rst:514
msgid "Rotate the deque *n* steps to the right.  If *n* is negative, rotate to the left."
msgstr ""
"Décale les éléments de la *deque* de *n* places vers la droite (le dernier élément "
"revient au début). Si *n* est négatif, décale vers la gauche."

#: ../Doc/library/collections.rst:517
msgid ""
"When the deque is not empty, rotating one step to the right is equivalent to ``d."
"appendleft(d.pop())``, and rotating one step to the left is equivalent to ``d.append(d."
"popleft())``."
msgstr ""
"Quand la *deque* n'est pas vide, un décalage d'une place vers la droite équivaut à ``d."
"appendleft(d.pop())`` et un décalage d'une place vers la gauche est équivalent à ``d."
"append(d.popleft())``."

#: ../Doc/library/collections.rst:522
msgid "Deque objects also provide one read-only attribute:"
msgstr "Les objets *deques* fournissent également un attribut en lecture seule :"

#: ../Doc/library/collections.rst:526
msgid "Maximum size of a deque or ``None`` if unbounded."
msgstr "La taille maximale d'une *deque*, ou ``None`` si illimitée."

#: ../Doc/library/collections.rst:531
msgid ""
"In addition to the above, deques support iteration, pickling, ``len(d)``, "
"``reversed(d)``, ``copy.copy(d)``, ``copy.deepcopy(d)``, membership testing with the :"
"keyword:`in` operator, and subscript references such as ``d[-1]``.  Indexed access is "
"O(1) at both ends but slows to O(n) in the middle.  For fast random access, use lists "
"instead."
msgstr ""
"En plus des méthodes précédentes, les *deques* gèrent l'itération, la sérialisation, "
"``len(d)``, ``reversed(d)``, ``copy.copy(d)``, ``copy.deepcopy(d)``, le test "
"d'appartenance avec l'opérateur :keyword:`in`, et les références en indice comme "
"``d[-1]``. L'accès par indice est en *O(1)* aux extrémités mais en *O(n)* au milieu. "
"Pour des accès aléatoires rapides, il est préférable d'utiliser des listes."

#: ../Doc/library/collections.rst:537
msgid ""
"Starting in version 3.5, deques support ``__add__()``, ``__mul__()``, and "
"``__imul__()``."
msgstr ""
"Depuis la version 3.5, les *deques* gèrent ``__add__()``, ``__mul__()`` et "
"``__imul__()``."

#: ../Doc/library/collections.rst:540
msgid "Example:"
msgstr "Exemple :"

#: ../Doc/library/collections.rst:597
msgid ":class:`deque` Recipes"
msgstr "Cas pratiques utilisant :class:`deque`"

#: ../Doc/library/collections.rst:599
msgid "This section shows various approaches to working with deques."
msgstr "Cette partie montre diverses approches afin de travailler avec les *deques*."

#: ../Doc/library/collections.rst:601
msgid ""
"Bounded length deques provide functionality similar to the ``tail`` filter in Unix::"
msgstr ""
"Les *deques* à taille limitée apportent une fonctionnalité similaire au filtre ``tail`` "
"d'Unix : ::"

#: ../Doc/library/collections.rst:609
msgid ""
"Another approach to using deques is to maintain a sequence of recently added elements "
"by appending to the right and popping to the left::"
msgstr ""
"Une autre approche d'utilisation des *deques* est de maintenir une séquence d'éléments "
"récemment ajoutés en les ajoutant à droite et en retirant les anciens par la gauche : ::"

#: ../Doc/library/collections.rst:624
msgid ""
"A `round-robin scheduler <https://en.wikipedia.org/wiki/Round-robin_scheduling>`_ can "
"be implemented with input iterators stored in a :class:`deque`.  Values are yielded "
"from the active iterator in position zero.  If that iterator is exhausted, it can be "
"removed with :meth:`~deque.popleft`; otherwise, it can be cycled back to the end with "
"the :meth:`~deque.rotate` method::"
msgstr ""
"Un `ordonnancement en round-robin <https://fr.wikipedia.org/wiki/Round-"
"robin_(informatique)>`_ peut être implémenté avec des entrées itérateurs stockées dans "
"une :class:`deque`. Les valeurs sont produites par l'itérateur actif en position zéro. "
"Si cet itérateur est épuisé, il peut être retiré avec la méthode :meth:`~deque."
"popleft` ; ou bien il peut être remis à la fin avec la méthode :meth:`~ deque."
"rotate` : ::"

#: ../Doc/library/collections.rst:643
msgid ""
"The :meth:`~deque.rotate` method provides a way to implement :class:`deque` slicing and "
"deletion.  For example, a pure Python implementation of ``del d[n]`` relies on the "
"``rotate()`` method to position elements to be popped::"
msgstr ""
"La méthode :meth:`~deque.rotate` apporte une façon d'implémenter la sélection "
"d'intervalle (*slicing*) et les suppressions pour les :class:`deques`. Par exemple, une "
"implémentation de ``del d[n]`` en Python pur utilise la méthode ``rotate()`` pour "
"mettre en position les éléments à éjecter : ::"

#: ../Doc/library/collections.rst:652
msgid ""
"To implement :class:`deque` slicing, use a similar approach applying :meth:`~deque."
"rotate` to bring a target element to the left side of the deque. Remove old entries "
"with :meth:`~deque.popleft`, add new entries with :meth:`~deque.extend`, and then "
"reverse the rotation. With minor variations on that approach, it is easy to implement "
"Forth style stack manipulations such as ``dup``, ``drop``, ``swap``, ``over``, "
"``pick``, ``rot``, and ``roll``."
msgstr ""
"Pour implémenter le *slicing* pour les :class:`deques <deque>`, il est possible "
"d'utiliser une approche similaire en appliquant :meth:`~deque.rotate` afin d'apporter "
"un élément cible à l'extrémité gauche de la *deque*. On éjecte les anciennes entrées "
"avec :meth:`~deque.popleft` et on ajoute les nouvelles avec :meth:`~deque.extend`, puis "
"on inverse la rotation. Il est aisé d'implémenter les manipulations des piles inspirées "
"du Forth telles que ``dup``, ``drop``, ``swap``, ``over``, ``pick``, ``rot`` et "
"``roll``."

#: ../Doc/library/collections.rst:662
msgid ":class:`defaultdict` objects"
msgstr "Objets :class:`defaultdict`"

#: ../Doc/library/collections.rst:666
msgid ""
"Returns a new dictionary-like object.  :class:`defaultdict` is a subclass of the built-"
"in :class:`dict` class.  It overrides one method and adds one writable instance "
"variable.  The remaining functionality is the same as for the :class:`dict` class and "
"is not documented here."
msgstr ""
"Renvoie un nouvel objet qui se comporte comme un dictionnaire. :class:`defaultdic` est "
"une sous-classe de la la classe native :class:`dict`. Elle surcharge une méthode et "
"ajoute une variable d'instance modifiable. Les autres fonctionnalités sont les mêmes "
"que celles des objets :class:`dict` et ne sont pas documentées ici."

#: ../Doc/library/collections.rst:671
msgid ""
"The first argument provides the initial value for the :attr:`default_factory` "
"attribute; it defaults to ``None``. All remaining arguments are treated the same as if "
"they were passed to the :class:`dict` constructor, including keyword arguments."
msgstr ""
"Le premier argument fournit la valeur initiale de l'attribut :attr:`default_factory` "
"qui doit être un objet appelable sans paramètre ou ``None``, sa valeur par défaut. Tous "
"les autres arguments sont traités comme si on les passait au constructeur de :class:"
"`dict`, y compris les arguments nommés."

#: ../Doc/library/collections.rst:677
msgid ""
":class:`defaultdict` objects support the following method in addition to the standard :"
"class:`dict` operations:"
msgstr ""
"En plus des opérations usuelles de :class:`dict`, les objets :class:`defaultdict` "
"gèrent les méthodes supplémentaires suivantes :"

#: ../Doc/library/collections.rst:682
msgid ""
"If the :attr:`default_factory` attribute is ``None``, this raises a :exc:`KeyError` "
"exception with the *key* as argument."
msgstr ""
"Si l'attribut :attr:`default_factory` est ``None``, lève une exception :exc:`KeyError` "
"avec *key* comme argument."

#: ../Doc/library/collections.rst:685
msgid ""
"If :attr:`default_factory` is not ``None``, it is called without arguments to provide a "
"default value for the given *key*, this value is inserted in the dictionary for the "
"*key*, and returned."
msgstr ""
"Si :attr:`default_fatory`` ne vaut pas ``None``, cet attribut est appelé sans argument "
"pour fournir une valeur par défaut pour la *key* demandée. Cette valeur est insérée "
"dans le dictionnaire avec pour clé *key* et est renvoyée."

#: ../Doc/library/collections.rst:689
msgid ""
"If calling :attr:`default_factory` raises an exception this exception is propagated "
"unchanged."
msgstr ""
"Si appeler :attr:`default_factory` lève une exception, celle-ci est transmise inchangée."

#: ../Doc/library/collections.rst:692
msgid ""
"This method is called by the :meth:`__getitem__` method of the :class:`dict` class when "
"the requested key is not found; whatever it returns or raises is then returned or "
"raised by :meth:`__getitem__`."
msgstr ""
"Cette méthode est appelée par la méthode :meth:`__getitem__` de la classe :class:`dict` "
"lorsque la clé demandée n'est pas trouvée. Ce qu'elle renvoie ou lève est alors renvoyé "
"ou levé par :meth:`__getitem__`."

#: ../Doc/library/collections.rst:696
msgid ""
"Note that :meth:`__missing__` is *not* called for any operations besides :meth:"
"`__getitem__`. This means that :meth:`get` will, like normal dictionaries, return "
"``None`` as a default rather than using :attr:`default_factory`."
msgstr ""
"Remarquez que :meth:`__missing__` n'est *pas* appelée pour les opérations autres que :"
"meth:`__getitem__`. Cela signifie que :meth:`get` renvoie ``None`` comme les "
"dictionnaires natifs dans les cas triviaux et n'utilise pas :attr:`default_factory`."

#: ../Doc/library/collections.rst:702
msgid ":class:`defaultdict` objects support the following instance variable:"
msgstr "Les objets :class:`defaultdict` gèrent la variable d'instance :"

#: ../Doc/library/collections.rst:707
msgid ""
"This attribute is used by the :meth:`__missing__` method; it is initialized from the "
"first argument to the constructor, if present, or to ``None``, if absent."
msgstr ""
"Cet attribut est utilisé par la méthode :meth:`__missing__` ; il est initialisé par le "
"premier argument passé au constructeur, s'il est spécifié, sinon par ``None``."

#: ../Doc/library/collections.rst:713
msgid ":class:`defaultdict` Examples"
msgstr "Exemples utilisant :class:`defaultdict`"

#: ../Doc/library/collections.rst:715
msgid ""
"Using :class:`list` as the :attr:`~defaultdict.default_factory`, it is easy to group a "
"sequence of key-value pairs into a dictionary of lists:"
msgstr ""
"Utiliser :class:`list` comme :attr:`~defaultdict.default_factory` facilite le "
"regroupement d'une séquence de paires clé-valeur en un dictionnaire de listes :"

#: ../Doc/library/collections.rst:726
msgid ""
"When each key is encountered for the first time, it is not already in the mapping; so "
"an entry is automatically created using the :attr:`~defaultdict.default_factory` "
"function which returns an empty :class:`list`.  The :meth:`list.append` operation then "
"attaches the value to the new list.  When keys are encountered again, the look-up "
"proceeds normally (returning the list for that key) and the :meth:`list.append` "
"operation adds another value to the list. This technique is simpler and faster than an "
"equivalent technique using :meth:`dict.setdefault`:"
msgstr ""
"Lorsque chaque clé est rencontrée pour la première fois, elle n'est pas encore présente "
"dans le dictionnaire, donc une entrée est automatiquement créée grâce à la fonction :"
"attr:`~defaultdict.default_factory` qui renvoie un objet :class:`list` vide. "
"L'opération :meth:`list.append` ajoute la valeur à la nouvelle liste. Quand les clés "
"sont à nouveau rencontrées, la recherche se déroule correctement (elle renvoie la liste "
"de cette clé) et l'opération :meth:`list.append` ajoute une autre valeur à la liste. "
"Cette technique est plus simple et plus rapide qu'une technique équivalente utilisant :"
"meth:`dict.setdefault` :"

#: ../Doc/library/collections.rst:741
msgid ""
"Setting the :attr:`~defaultdict.default_factory` to :class:`int` makes the :class:"
"`defaultdict` useful for counting (like a bag or multiset in other languages):"
msgstr ""
"Utiliser :class:`int` comme :attr:`~defaultdict.default_factory` rend la classe :class:"
"`defaultdict` pratique pour le comptage (comme un sac ou multi-ensemble dans d'autres "
"langages) :"

#: ../Doc/library/collections.rst:753
msgid ""
"When a letter is first encountered, it is missing from the mapping, so the :attr:"
"`~defaultdict.default_factory` function calls :func:`int` to supply a default count of "
"zero.  The increment operation then builds up the count for each letter."
msgstr ""
"Quand une lettre est rencontrée pour la première fois, elle n'est pas dans le "
"dictionnaire, donc la fonction :attr:`~defaultdict.default_factory` appelle :func:`int` "
"pour mettre un nouveau compteur à zéro. L'incrémentation augmente ensuite le comptage "
"pour chaque lettre."

#: ../Doc/library/collections.rst:757
msgid ""
"The function :func:`int` which always returns zero is just a special case of constant "
"functions.  A faster and more flexible way to create constant functions is to use a "
"lambda function which can supply any constant value (not just zero):"
msgstr ""
"La fonction :func:`int` qui retourne toujours zéro est simplement une fonction "
"constante particulière. Un moyen plus flexible et rapide de créer une fonction "
"constante est d'utiliser une fonction lambda qui peut fournir n'importe quelle valeur "
"constante (pas seulement zéro) :"

#: ../Doc/library/collections.rst:769
msgid ""
"Setting the :attr:`~defaultdict.default_factory` to :class:`set` makes the :class:"
"`defaultdict` useful for building a dictionary of sets:"
msgstr ""
"Utiliser :class:`set` comme :attr:`~defaultdict.default_factory` rend la classe :class:"
"`defaultdict` pratique pour créer un dictionnaire d'ensembles :"

#: ../Doc/library/collections.rst:782
msgid ":func:`namedtuple` Factory Function for Tuples with Named Fields"
msgstr ""
":func:`namedtuple`: fonction de construction pour *n-uplets* (*tuples*) avec des champs "
"nommés"

#: ../Doc/library/collections.rst:784
msgid ""
"Named tuples assign meaning to each position in a tuple and allow for more readable, "
"self-documenting code.  They can be used wherever regular tuples are used, and they add "
"the ability to access fields by name instead of position index."
msgstr ""
"Les tuples nommés assignent une signification à chacun de leur élément, ce qui rend le "
"code plus lisible et explicite. Ils peuvent être utilisés partout où les tuples natifs "
"sont utilisés, et ils ajoutent la possibilité d'accéder à leurs champs grâce à leur nom "
"au lieu de leur index de position."

#: ../Doc/library/collections.rst:790
msgid ""
"Returns a new tuple subclass named *typename*.  The new subclass is used to create "
"tuple-like objects that have fields accessible by attribute lookup as well as being "
"indexable and iterable.  Instances of the subclass also have a helpful docstring (with "
"typename and field_names) and a helpful :meth:`__repr__` method which lists the tuple "
"contents in a ``name=value`` format."
msgstr ""
"Renvoie une nouvelle sous-classe de ``tuple`` appelée *typename*. Elle est utilisée "
"pour créer des objets se comportant comme les *tuples* qui ont des champs accessibles "
"par recherche d'attribut en plus d'être indexables et itérables. Les instances de cette "
"sous-classe possèdent aussi une *docstring* explicite (avec *type_name* et les "
"*field_names*) et une méthode :meth:`__repr__` pratique qui liste le contenu du tuple "
"au format ``nom=valeur``."

#: ../Doc/library/collections.rst:796
msgid ""
"The *field_names* are a sequence of strings such as ``['x', 'y']``. Alternatively, "
"*field_names* can be a single string with each fieldname separated by whitespace and/or "
"commas, for example ``'x y'`` or ``'x, y'``."
msgstr ""
"*field_names* peut être une séquence de chaînes de caractères telle que ``['x', 'y']`` "
"ou bien une unique chaîne de caractères où les noms de champs sont séparés par un "
"espace et/ou une virgule, par exemple ``'x y'`` ou ``'x, y'``."

#: ../Doc/library/collections.rst:800
msgid ""
"Any valid Python identifier may be used for a fieldname except for names starting with "
"an underscore.  Valid identifiers consist of letters, digits, and underscores but do "
"not start with a digit or underscore and cannot be a :mod:`keyword` such as *class*, "
"*for*, *return*, *global*, *pass*, or *raise*."
msgstr ""
"N'importe quel identifiant Python peut être utilisé pour un nom de champ hormis ceux "
"commençant par un tiret bas. Les identifiants valides peuvent contenir des lettres, des "
"chiffres (sauf en première position) et des tirets bas (sauf en première position). Un "
"identifiant ne peut pas être un :mod:`keyword` tel que ``class``, ``for``, ``return``, "
"``global``, ``pass`` ou ``raise``."

#: ../Doc/library/collections.rst:806
msgid ""
"If *rename* is true, invalid fieldnames are automatically replaced with positional "
"names.  For example, ``['abc', 'def', 'ghi', 'abc']`` is converted to ``['abc', '_1', "
"'ghi', '_3']``, eliminating the keyword ``def`` and the duplicate fieldname ``abc``."
msgstr ""
"Si *rename* vaut ``True``, alors les noms de champs invalides sont automatiquement "
"renommés en noms positionnels. Par exemple, ``['abc', 'def', 'ghi', 'abc']`` est "
"converti en ``['abc, '_1', 'ghi', '_3']`` afin d'éliminer le mot-clé ``def`` et le "
"doublon de ``abc``."

#: ../Doc/library/collections.rst:811
msgid ""
"*defaults* can be ``None`` or an :term:`iterable` of default values. Since fields with "
"a default value must come after any fields without a default, the *defaults* are "
"applied to the rightmost parameters.  For example, if the fieldnames are ``['x', 'y', "
"'z']`` and the defaults are ``(1, 2)``, then ``x`` will be a required argument, ``y`` "
"will default to ``1``, and ``z`` will default to ``2``."
msgstr ""
"*defaults* peut être ``None`` ou un :term:`iterable` de valeurs par défaut. Comme les "
"champs avec une valeur par défaut doivent être définis après les champs sans valeur par "
"défaut, les *defaults* sont appliqués aux paramètres les plus à droite. Par exemple, si "
"les noms des champs sont ``['x', 'y', 'z']`` et les valeurs par défaut ``(1, 2)``, "
"alors ``x`` est un argument obligatoire tandis que ``y`` et ``y`` valent par défaut "
"``1`` et ``2``."

#: ../Doc/library/collections.rst:818
msgid ""
"If *module* is defined, the ``__module__`` attribute of the named tuple is set to that "
"value."
msgstr ""
"Si *module* est spécifié, alors il est assigné à l'attribut ``__module__`` du tuple "
"nommé."

#: ../Doc/library/collections.rst:821
msgid ""
"Named tuple instances do not have per-instance dictionaries, so they are lightweight "
"and require no more memory than regular tuples."
msgstr ""
"Les instances de tuples nommés n'ont pas de dictionnaires propres, elles sont donc "
"légères et ne requièrent pas plus de mémoire que les tuples natifs."

#: ../Doc/library/collections.rst:824
msgid "Added support for *rename*."
msgstr "Gestion de *rename*."

#: ../Doc/library/collections.rst:827
msgid ""
"The *verbose* and *rename* parameters became :ref:`keyword-only arguments <keyword-"
"only_parameter>`."
msgstr ""
"Les paramètres *verbose* et *rename* deviennent des :ref:`arguments obligatoirement "
"nommés <keyword-only_parameter>`."

#: ../Doc/library/collections.rst:831
msgid "Added the *module* parameter."
msgstr "Ajout du paramètre *module*."

#: ../Doc/library/collections.rst:834
msgid "Remove the *verbose* parameter and the :attr:`_source` attribute."
msgstr "Suppression du paramètre *verbose* et de l'attribut :attr:`_source`."

#: ../Doc/library/collections.rst:837
msgid "Added the *defaults* parameter and the :attr:`_field_defaults` attribute."
msgstr "Ajout du paramètre *defaults* et de l'attribut :attr:`_field_defaults`."

#: ../Doc/library/collections.rst:857
msgid ""
"Named tuples are especially useful for assigning field names to result tuples returned "
"by the :mod:`csv` or :mod:`sqlite3` modules::"
msgstr ""
"Les tuples nommés sont particulièrement utiles pour associer des noms de champs à des "
"tuples renvoyés par les modules :mod:`csv` ou :mod:`sqlite3` : ::"

#: ../Doc/library/collections.rst:873
msgid ""
"In addition to the methods inherited from tuples, named tuples support three additional "
"methods and two attributes.  To prevent conflicts with field names, the method and "
"attribute names start with an underscore."
msgstr ""
"En plus des méthodes héritées de ``tuple``, les tuples nommés implémentent trois "
"méthodes et deux attributs supplémentaires. Pour éviter les conflits avec noms de "
"champs, leurs noms commencent par un tiret bas."

#: ../Doc/library/collections.rst:879
msgid "Class method that makes a new instance from an existing sequence or iterable."
msgstr ""
"Méthode de classe qui construit une nouvelle instance à partir d'une séquence ou d'un "
"itérable existant."

#: ../Doc/library/collections.rst:889
msgid ""
"Return a new :class:`OrderedDict` which maps field names to their corresponding values:"
msgstr ""
"Renvoie un nouvel :class:`OrderedDict` qui associe chaque nom de champ à sa valeur "
"correspondante :"

#: ../Doc/library/collections.rst:898
msgid "Returns an :class:`OrderedDict` instead of a regular :class:`dict`."
msgstr "Renvoie un :class:`OrderedDict` au lieu d'un :class:`dict` natif."

#: ../Doc/library/collections.rst:903
msgid ""
"Return a new instance of the named tuple replacing specified fields with new values::"
msgstr ""
"Renvoie une nouvelle instance du tuple nommé en remplaçant les champs spécifiés par "
"leurs nouvelles valeurs : ::"

#: ../Doc/library/collections.rst:915
msgid ""
"Tuple of strings listing the field names.  Useful for introspection and for creating "
"new named tuple types from existing named tuples."
msgstr ""
"Tuple de chaînes de caractères listant les noms de champs. Pratique pour "
"l'introspection et pour créer de nouveaux types de tuples nommés à partir d'existants."

#: ../Doc/library/collections.rst:930
msgid "Dictionary mapping field names to default values."
msgstr "Dictionnaire qui assigne les valeurs par défaut aux noms des champs."

#: ../Doc/library/collections.rst:940
msgid ""
"To retrieve a field whose name is stored in a string, use the :func:`getattr` function:"
msgstr ""
"Pour récupérer un champ dont le nom est une chaîne de caractères, utilisez la fonction :"
"func:`getattr` :"

#: ../Doc/library/collections.rst:946
msgid ""
"To convert a dictionary to a named tuple, use the double-star-operator (as described "
"in :ref:`tut-unpacking-arguments`):"
msgstr ""
"Pour convertir un dictionnaire en tuple nommé, utilisez l'opérateur double-étoile "
"(comme expliqué dans :ref:`tut-unpacking-arguments`) :"

#: ../Doc/library/collections.rst:953
msgid ""
"Since a named tuple is a regular Python class, it is easy to add or change "
"functionality with a subclass.  Here is how to add a calculated field and a fixed-width "
"print format:"
msgstr ""
"Il est aisé d'ajouter ou de modifier les fonctionnalités des tuples nommés grâce à "
"l'héritage puisqu'il s'agit de simples classes. Voici comment ajouter un champ calculé "
"avec une longueur fixe d'affichage :"

#: ../Doc/library/collections.rst:972
msgid ""
"The subclass shown above sets ``__slots__`` to an empty tuple.  This helps keep memory "
"requirements low by preventing the creation of instance dictionaries."
msgstr ""
"La sous-classe ci-dessus définit ``__slots__`` comme un tuple vide. Cela permet de "
"garder une emprunte mémoire faible en empêchant la création de dictionnaire d'instance."

#: ../Doc/library/collections.rst:975
msgid ""
"Subclassing is not useful for adding new, stored fields.  Instead, simply create a new "
"named tuple type from the :attr:`~somenamedtuple._fields` attribute:"
msgstr ""
"L'héritage n'est pas pertinent pour ajouter de nouveaux champs. Il est préférable de "
"simplement créer un nouveau type de tuple nommé avec l'attribut :attr:`~somenamedtuple."
"_fields` :"

#: ../Doc/library/collections.rst:980
msgid ""
"Docstrings can be customized by making direct assignments to the ``__doc__`` fields:"
msgstr ""
"Les *docstrings* peuvent être personnalisées en modifiant directement l'attribut "
"``__doc__`` :"

#: ../Doc/library/collections.rst:989
msgid "Property docstrings became writeable."
msgstr "La propriété devient éditable."

#: ../Doc/library/collections.rst:992
msgid ""
"Default values can be implemented by using :meth:`~somenamedtuple._replace` to "
"customize a prototype instance:"
msgstr ""
"Les valeurs par défaut peuvent être implémentées en utilisant :meth:`~somenamedtuple."
"_replace` pour personnaliser une instance prototype :"

#: ../Doc/library/collections.rst:1003
msgid ""
"`Recipe for named tuple abstract base class with a metaclass mix-in <https://code."
"activestate.com/recipes/577629-namedtupleabc-abstract-base-class-mix-in-for-named/>`_ "
"by Jan Kaliszewski.  Besides providing an :term:`abstract base class` for named tuples, "
"it also supports an alternate :term:`metaclass`-based constructor that is convenient "
"for use cases where named tuples are being subclassed."
msgstr ""
"`Cas pratique : classe de base abstraite de tuple nommé grâce à une métaclasse mixin "
"<https://code.activestate.com/recipes/577629-namedtupleabc-abstract-base-class-mix-in-"
"for-named/>`_ par Jan Kaliszewski. En plus de fournir une :term:`abstract base class` "
"pour les tuples nommés, elle gère un constructeur de :term:`metaclass` pratique dans "
"les cas où l'on hérite de tuples nommés."

#: ../Doc/library/collections.rst:1010
msgid ""
"See :meth:`types.SimpleNamespace` for a mutable namespace based on an underlying "
"dictionary instead of a tuple."
msgstr ""
"Voir :meth:`types.SimpleNamespace` pour un espace de noms muable basé sur un "
"dictionnaire sous-jacent à la place d'un tuple."

#: ../Doc/library/collections.rst:1013
msgid "See :meth:`typing.NamedTuple` for a way to add type hints for named tuples."
msgstr ""
"Voir :meth:`typing.NamedTuple` pour un moyen d'ajouter des indications de type pour les "
"tuples nommés."

#: ../Doc/library/collections.rst:1017
msgid ":class:`OrderedDict` objects"
msgstr "Objets :class:`OrderedDict`"

#: ../Doc/library/collections.rst:1019
msgid ""
"Ordered dictionaries are just like regular dictionaries but they remember the order "
"that items were inserted.  When iterating over an ordered dictionary, the items are "
"returned in the order their keys were first added."
msgstr ""
"En plus de se comporter comme des dictionnaires natifs, les dictionnaires ordonnés "
"mémorisent l'ordre dans lequel les éléments ont été insérés. Quand on itère sur un "
"dictionnaire ordonné, les éléments sont renvoyés dans l'ordre d'insertion des clés."

#: ../Doc/library/collections.rst:1025
msgid ""
"Return an instance of a dict subclass, supporting the usual :class:`dict` methods.  An "
"*OrderedDict* is a dict that remembers the order that keys were first inserted. If a "
"new entry overwrites an existing entry, the original insertion position is left "
"unchanged.  Deleting an entry and reinserting it will move it to the end."
msgstr ""
"Renvoie une instance d'une sous-classe de ``dict`` qui gère les méthodes usuelles de :"
"class:`dict`. Un objet *OrderedDict* est un dictionnaire qui mémorise l'ordre "
"d'insertion des clés. Si une nouvelle entrée en écrase une autre, sa position reste "
"inchangé. Si une entrée est supprimée puis réinsérée, elle est placée en dernière "
"position."

#: ../Doc/library/collections.rst:1035
msgid ""
"The :meth:`popitem` method for ordered dictionaries returns and removes a (key, value) "
"pair.  The pairs are returned in :abbr:`LIFO (last-in, first-out)` order if *last* is "
"true or :abbr:`FIFO (first-in, first-out)` order if false."
msgstr ""
"La méthode :meth:`popitem` pour les dictionnaires ordonnés retire et renvoie une paire "
"``(clé, valeur)``. Les paires sont renvoyées comme pour une pile, c'est-à-dire dernier "
"entré, premier sorti (en anglais :abbr:`LIFO (last-in, first-out)`) si *last* vaut "
"``True``. Si *last* vaut ``False``, alors les paires sont renvoyées comme pour une "
"file, c'est-à-dire premier entré, premier sorti (en anglais :abbr:`FIFO (first-in, "
"first-out)`)."

#: ../Doc/library/collections.rst:1042
msgid ""
"Move an existing *key* to either end of an ordered dictionary.  The item is moved to "
"the right end if *last* is true (the default) or to the beginning if *last* is false.  "
"Raises :exc:`KeyError` if the *key* does not exist::"
msgstr ""
"Déplace une clé *key* existante à l'une des deux extrémités du dictionnaire : à droite "
"si *last* vaut ``True`` (comportement par défaut) ou à gauche sinon. Lève une "
"exception :exc:`KeyError` si la clé *key* n'est pas trouvée : ::"

#: ../Doc/library/collections.rst:1057
msgid ""
"In addition to the usual mapping methods, ordered dictionaries also support reverse "
"iteration using :func:`reversed`."
msgstr ""
"En plus des méthodes usuelles des dictionnaires, les dictionnaires ordonnés gèrent "
"l'itération en sens inverse grâce à :func:`reversed`."

#: ../Doc/library/collections.rst:1060
msgid ""
"Equality tests between :class:`OrderedDict` objects are order-sensitive and are "
"implemented as ``list(od1.items())==list(od2.items())``. Equality tests between :class:"
"`OrderedDict` objects and other :class:`~collections.abc.Mapping` objects are order-"
"insensitive like regular dictionaries.  This allows :class:`OrderedDict` objects to be "
"substituted anywhere a regular dictionary is used."
msgstr ""
"Les tests d'égalité entre deux objets :class:`OrderedDict` sont sensibles à l'ordre et "
"sont implémentés comme ceci : ``list(od1.items() == list(od2.items())``. Les tests "
"d'égalité entre un objet :class:`OrderedDict` et un objet :class:`~collections.abc."
"Mapping` ne sont pas sensibles à l'ordre (comme les dictionnaires natifs). Cela permet "
"substituer des objets :class:`OrderedDict` partout où les dictionnaires natifs sont "
"utilisés."

#: ../Doc/library/collections.rst:1067
msgid ""
"The items, keys, and values :term:`views <dictionary view>` of :class:`OrderedDict` now "
"support reverse iteration using :func:`reversed`."
msgstr ""
"Les :term:`vues <dictionary view>` d'éléments, de clés et de valeurs de :class:"
"`OrderedDict` gèrent maintenant l'itération en sens inverse en utilisant :func:"
"`reversed`."

#: ../Doc/library/collections.rst:1071
msgid ""
"With the acceptance of :pep:`468`, order is retained for keyword arguments passed to "
"the :class:`OrderedDict` constructor and its :meth:`update` method."
msgstr ""
"Suite à l'acceptation de la :pep:`468`, l'ordre des arguments nommés passés au "
"constructeur et à la méthode :meth:`update` de :class:`OrderedDict` est conservé."

#: ../Doc/library/collections.rst:1077
msgid ":class:`OrderedDict` Examples and Recipes"
msgstr "Exemples et cas pratiques utilisant :class:`OrderDict`"

#: ../Doc/library/collections.rst:1079
msgid ""
"Since an ordered dictionary remembers its insertion order, it can be used in "
"conjunction with sorting to make a sorted dictionary::"
msgstr ""
"Puisqu'un dictionnaire ordonné mémorise l'ordre d'insertion de ses éléments, il peut "
"être utilisé conjointement avec un classement pour créer un dictionnaire trié : ::"

#: ../Doc/library/collections.rst:1097
msgid ""
"The new sorted dictionaries maintain their sort order when entries are deleted.  But "
"when new keys are added, the keys are appended to the end and the sort is not "
"maintained."
msgstr ""
"Les nouveaux dictionnaires triés gardent leur classement quand des entrées sont "
"supprimées, mais si de nouvelles clés sont ajoutées, celles-ci sont ajoutée à la fin et "
"le classement est perdu."

#: ../Doc/library/collections.rst:1101
msgid ""
"It is also straight-forward to create an ordered dictionary variant that remembers the "
"order the keys were *last* inserted. If a new entry overwrites an existing entry, the "
"original insertion position is changed and moved to the end::"
msgstr ""
"Il est également facile de créer une variante de dictionnaire ordonné qui retient "
"l'ordre dans lequel les clés ont été insérées *en dernier*. Si une nouvelle entrée "
"écrase une existante, la position d'insertion d'origine est modifiée et déplacée à la "
"fin : ::"

#: ../Doc/library/collections.rst:1114
msgid ""
"An ordered dictionary can be combined with the :class:`Counter` class so that the "
"counter remembers the order elements are first encountered::"
msgstr ""
"Un dictionnaire ordonné peut être combiné avec la classe :class:`Counter` afin de "
"mémoriser l'ordre dans lequel les éléments ont été ajoutés pour la première fois : ::"

#: ../Doc/library/collections.rst:1128
msgid ":class:`UserDict` objects"
msgstr "Objets :class:`UserDict`"

#: ../Doc/library/collections.rst:1130
msgid ""
"The class, :class:`UserDict` acts as a wrapper around dictionary objects. The need for "
"this class has been partially supplanted by the ability to subclass directly from :"
"class:`dict`; however, this class can be easier to work with because the underlying "
"dictionary is accessible as an attribute."
msgstr ""
"La classe :class:`UserDict` se comporte comme une surcouche autour des dictionnaires. "
"L'utilité de cette classe est réduite car on peut maintenant hériter directement de :"
"class:`dict`. Cependant, il peut être plus facile de travailler avec celle-ci car le "
"dictionnaire sous-jacent est accessible comme attribut."

#: ../Doc/library/collections.rst:1138
msgid ""
"Class that simulates a dictionary.  The instance's contents are kept in a regular "
"dictionary, which is accessible via the :attr:`data` attribute of :class:`UserDict` "
"instances.  If *initialdata* is provided, :attr:`data` is initialized with its "
"contents; note that a reference to *initialdata* will not be kept, allowing it be used "
"for other purposes."
msgstr ""
"Classe simulant un dictionnaire. Les instances de :class:`UserDict` possèdent un "
"attribut :attr:`data` où est stocké leur contenu sous forme de dictionnaire natif. Si "
"*initialdata* est spécifié, alors :attr:`data` est initialisé avec son contenu. "
"Remarquez qu'une référence vers *initialdata* n'est pas conservée, ce qui permet de "
"l'utiliser pour d'autres tâches."

#: ../Doc/library/collections.rst:1144
msgid ""
"In addition to supporting the methods and operations of mappings, :class:`UserDict` "
"instances provide the following attribute:"
msgstr ""
"En plus de gérer les méthodes et opérations des dictionnaires, les instance de :class:"
"`UserDict` fournissent l'attribut suivant :"

#: ../Doc/library/collections.rst:1149
msgid "A real dictionary used to store the contents of the :class:`UserDict` class."
msgstr "Un dictionnaire natif où est stocké le contenu de la classe :class:`UserDict`."

#: ../Doc/library/collections.rst:1155
msgid ":class:`UserList` objects"
msgstr "Objets :class:`UserList`"

#: ../Doc/library/collections.rst:1157
msgid ""
"This class acts as a wrapper around list objects.  It is a useful base class for your "
"own list-like classes which can inherit from them and override existing methods or add "
"new ones.  In this way, one can add new behaviors to lists."
msgstr ""
"Cette classe agit comme une surcouche autour des objets ``list``. C'est une classe mère "
"utile pour vos classes listes-compatibles qui peuvent en hériter et surcharger les "
"méthodes existantes ou en ajouter de nouvelles. Ainsi, on peut ajouter de nouveaux "
"comportements aux listes."

#: ../Doc/library/collections.rst:1162
msgid ""
"The need for this class has been partially supplanted by the ability to subclass "
"directly from :class:`list`; however, this class can be easier to work with because the "
"underlying list is accessible as an attribute."
msgstr ""
"L'utilité de cette classe a été partiellement réduite par la possibilité d'hériter "
"directement de :class:`list`. Cependant, il peut être plus facile de travailler avec "
"cette classe car la liste sous-jacente est accessible via un attribut."

#: ../Doc/library/collections.rst:1168
msgid ""
"Class that simulates a list.  The instance's contents are kept in a regular list, which "
"is accessible via the :attr:`data` attribute of :class:`UserList` instances.  The "
"instance's contents are initially set to a copy of *list*, defaulting to the empty list "
"``[]``.  *list* can be any iterable, for example a real Python list or a :class:"
"`UserList` object."
msgstr ""
"Classe simulant une liste. Les instances de :class:`UserList` possèdent un attribut :"
"attr:`UserList` où est stocké leur contenu sous forme de liste native. Il est "
"initialement une copie de *list*, ou ``[]`` par défaut. *list* peut être un itérable, "
"par exemple une liste native ou un objet :class:`UserList`."

#: ../Doc/library/collections.rst:1174
msgid ""
"In addition to supporting the methods and operations of mutable sequences, :class:"
"`UserList` instances provide the following attribute:"
msgstr ""
"En plus de gérer les méthodes et opérations des séquences muables, les instances de :"
"class:`UserList` possèdent l'attribut suivant :"

#: ../Doc/library/collections.rst:1179
msgid ""
"A real :class:`list` object used to store the contents of the :class:`UserList` class."
msgstr ""
"Un objet :class:`list` natif utilisé pour stocker le contenu de la classe :class:"
"`UserList`."

#: ../Doc/library/collections.rst:1182
msgid ""
"**Subclassing requirements:** Subclasses of :class:`UserList` are expected to offer a "
"constructor which can be called with either no arguments or one argument.  List "
"operations which return a new sequence attempt to create an instance of the actual "
"implementation class.  To do so, it assumes that the constructor can be called with a "
"single parameter, which is a sequence object used as a data source."
msgstr ""
"**Prérequis pour l'héritage :** Les sous-classe de :class:`UserList` doivent "
"implémenter un constructeur qui peut être appelé avec zéro ou un argument. Les "
"opérations sur les listes qui renvoient une nouvelle séquence essayent de créer une "
"instance de la classe courante. C'est pour cela que le constructeur doit pouvoir être "
"appelé avec un unique paramètre, un objet séquence utilisé comme source de données."

#: ../Doc/library/collections.rst:1189
msgid ""
"If a derived class does not wish to comply with this requirement, all of the special "
"methods supported by this class will need to be overridden; please consult the sources "
"for information about the methods which need to be provided in that case."
msgstr ""
"Si une classe fille ne remplit pas cette condition, toutes les méthodes spéciales "
"gérées par cette classe devront être implémentées à nouveau. Merci de consulter les "
"sources pour obtenir des informations sur les méthodes qui doivent être fournies dans "
"ce cas."

#: ../Doc/library/collections.rst:1195
msgid ":class:`UserString` objects"
msgstr "Objets :class:`UserString`"

#: ../Doc/library/collections.rst:1197
msgid ""
"The class, :class:`UserString` acts as a wrapper around string objects. The need for "
"this class has been partially supplanted by the ability to subclass directly from :"
"class:`str`; however, this class can be easier to work with because the underlying "
"string is accessible as an attribute."
msgstr ""
"La classe :class:`UserString` agit comme une surcouche autour des objets ``str``. "
"L'utilité de cette classe a été partiellement réduite par la possibilité d'hériter "
"directement de :class:`str`. Cependant, il peut être plus facile de travailler avec "
"cette classe car la chaîne de caractère sous-jacente est accessible via un attribut."

#: ../Doc/library/collections.rst:1205
msgid ""
"Class that simulates a string object.  The instance's content is kept in a regular "
"string object, which is accessible via the :attr:`data` attribute of :class:"
"`UserString` instances.  The instance's contents are initially set to a copy of *seq*.  "
"The *seq* argument can be any object which can be converted into a string using the "
"built-in :func:`str` function."
msgstr ""
"Classe simulant une chaîne de caractères. Les instances de :class:`UserString` "
"possèdent un attribut :attr:`data` où est stocké leur contenu sous forme de chaîne de "
"caractères native. Le contenu de l'instance est initialement une copie de *seq*, qui "
"peut être n'importe quel objet convertible en chaîne de caractère avec la fonction "
"native :func:`str`."

#: ../Doc/library/collections.rst:1212
msgid ""
"In addition to supporting the methods and operations of strings, :class:`UserString` "
"instances provide the following attribute:"
msgstr ""
"En plus de gérer les méthodes et opérations sur les chaînes de caractères, les "
"instances de :class:`UserString` possèdent l'attribut suivant :"

#: ../Doc/library/collections.rst:1217
msgid ""
"A real :class:`str` object used to store the contents of the :class:`UserString` class."
msgstr ""
"Un objet :class:`str` natif utilisé pour stocker le contenu de la classe :class:"
"`UserString`."

#: ../Doc/library/collections.rst:1220
msgid ""
"New methods ``__getnewargs__``, ``__rmod__``, ``casefold``, ``format_map``, "
"``isprintable``, and ``maketrans``."
msgstr ""
"Nouvelles méthodes ``__getnewargs__``, ``__rmod__``, ``casefold``, ``format_map``, "
"``isprintable`` et ``maketrans``."