# 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-18 17:17+0200\n"

"PO-Revision-Date: 2021-11-06 20:46+0100\n"

"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\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"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

"X-Generator: Poedit 3.0\n"

#: library/collections.rst:2

msgid ":mod:`collections` --- Container datatypes"

msgstr ":mod:`collections` — Types de données de conteneurs"

#: library/collections.rst:10

msgid "**Source code:** :source:`Lib/collections/__init__.py`"

msgstr "**Code source :** :source:`Lib/collections/__init__.py`"

#: 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`."

#: library/collections.rst:25

msgid ":func:`namedtuple`"

msgstr ":func:`namedtuple`"

#: 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"

#: library/collections.rst:26

msgid ":class:`deque`"

msgstr ":class:`deque`"

#: 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é"

#: library/collections.rst:27

msgid ":class:`ChainMap`"

msgstr ":class:`ChainMap`"

#: 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"

#: library/collections.rst:28

msgid ":class:`Counter`"

msgstr ":class:`Counter`"

#: library/collections.rst:28

#, fuzzy

msgid "dict subclass for counting :term:`hashable` objects"

msgstr "sous-classe de ``dict`` pour compter des objets hachables"

#: library/collections.rst:29

msgid ":class:`OrderedDict`"

msgstr ":class:`OrderedDict`"

#: 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"

#: library/collections.rst:30

msgid ":class:`defaultdict`"

msgstr ":class:`defaultdict`"

#: 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"

#: library/collections.rst:31

msgid ":class:`UserDict`"

msgstr ":class:`UserDict`"

#: 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``"

#: library/collections.rst:32

msgid ":class:`UserList`"

msgstr ":class:`UserList`"

#: 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``"

#: library/collections.rst:33

msgid ":class:`UserString`"

msgstr ":class:`UserString`"

#: 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``"

#: library/collections.rst:38

msgid ":class:`ChainMap` objects"

msgstr "Objets :class:`ChainMap`"

#: library/collections.rst:42

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

#: library/collections.rst:46

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

#: library/collections.rst:50

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

#: library/collections.rst:54

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

#: library/collections.rst:57

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

#: library/collections.rst:60

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

#: library/collections.rst:64

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

#: library/collections.rst:70

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

#: library/collections.rst:77

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)``. If any keyword arguments are specified, they update passed map "

"or new empty dict. 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)``. Si des arguments sont passés "

"par mot-clé, ils sont insérés comme de nouvelles entrées du dictionnaire "

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

# Pas de majuscule car suit deux points.

#: library/collections.rst:86

msgid "The optional ``m`` parameter was added."

msgstr "ajout du paramètre optionnel ``m``."

#: library/collections.rst:89

msgid "Keyword arguments support was added."

msgstr "prise en charge des arguments par mot-clé."

#: library/collections.rst:94

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:])``."

#: library/collections.rst:102

msgid ""

"Note, the iteration order of a :class:`ChainMap()` is determined by scanning "

"the mappings last to first::"

msgstr ""

"Notez que l'itération de :class:`ChainMap()` se fait en parcourant les "

"tableaux de correspondances du dernier jusqu'au premier ::"

#: library/collections.rst:110

msgid ""

"This gives the same ordering as a series of :meth:`dict.update` calls "

"starting with the last mapping::"

msgstr ""

"Cela produit le même ordre qu'une suite d'appels à :meth:`dict.update` en "

"commençant par le dernier tableau de correspondances ::"

#: library/collections.rst:118

msgid "Added support for ``|`` and ``|=`` operators, specified in :pep:`584`."

msgstr ""

"Ajout de la gestion des opérateurs ``|`` et ``|=`` tels que définis dans :"

"pep:`584`."

#: library/collections.rst:123

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

#: library/collections.rst:129

msgid ""

"Django's `Context class <https://github.com/django/django/blob/main/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/main/"

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

#: library/collections.rst:136

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

#: library/collections.rst:141

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/>`_."

#: library/collections.rst:146

msgid ":class:`ChainMap` Examples and Recipes"

msgstr "Exemples et cas pratiques utilisant :class:`ChainMap`"

#: library/collections.rst:148

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

#: library/collections.rst:151

msgid "Example of simulating Python's internal lookup chain::"

msgstr "Exemple 1 : simulation de la chaîne de recherche interne de Python ::"

#: library/collections.rst:156

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

#: library/collections.rst:173

msgid ""

"Example patterns for using the :class:`ChainMap` class to simulate nested "

"contexts::"

msgstr ""

"Exemple 3 : modèles pour simuler des contextes imbriqués avec la classe :"

"class:`ChainMap` ::"

#: library/collections.rst:192

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

#: library/collections.rst:223

msgid ":class:`Counter` objects"

msgstr "Objets :class:`Counter`"

#: library/collections.rst:225

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

#: library/collections.rst:245

#, fuzzy

msgid ""

"A :class:`Counter` is a :class:`dict` subclass for counting :term:`hashable` "

"objects. It is a 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 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."

#: library/collections.rst:251

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

#: library/collections.rst:259

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

#: library/collections.rst:266

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

#: library/collections.rst:274

#, fuzzy

msgid ""

"As a :class:`dict` subclass, :class:`Counter` inherited the capability to "

"remember insertion order. Math operations on *Counter* objects also "

"preserve order. Results are ordered according to when an element is first "

"encountered in the left operand and then by the order encountered in the "

"right operand."

msgstr ""

"Puisqu'elle est une sous-classe de :class:`dict`, :class:`Counter` conserve "

"aussi l'ordre d'insertion. Les opérations mathématiques sur les objets "

"*Counter* préservent aussi l'ordre des insertions. Les résultats sont "

"ordonnés d'abord en fonction de la recherche d'apparition pour l'opérande de "

"gauche, puis dans l'ordre d'apparition de l'opérande de droite."

#: library/collections.rst:280

#, fuzzy

msgid ""

"Counter objects support additional 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 :"

#: library/collections.rst:285

msgid ""

"Return an iterator over elements repeating each as many times as its count. "

"Elements are returned in the order first encountered. 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 l'ordre selon "

"lequel ils sont rencontrés pour la première fois. Si le comptage d'un "

"élément est strictement inférieur à 1, alors :meth:`elements` l'ignore."

#: library/collections.rst:295

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 in the order first encountered:"

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 par l'ordre "

"selon lequel ils ont été rencontrés pour la première fois :"

#: library/collections.rst:305

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

#: library/collections.rst:319

msgid "Compute the sum of the counts."

msgstr "Calcule la somme totale des nombres d'occurrences."

#: library/collections.rst:327

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

#: library/collections.rst:332

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

#: library/collections.rst:336

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

#: library/collections.rst:341

msgid ""

"Counters support rich comparison operators for equality, subset, and "

"superset relationships: ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``. All of "

"those tests treat missing elements as having zero counts so that "

"``Counter(a=1) == Counter(a=1, b=0)`` returns true."

msgstr ""

"Les compteurs prennent en charge les comparaisons riches pour les tests "

"d'égalité ainsi que d'inclusion du membre gauche dans le membre droite et "

"réciproquement, avec les opérateurs ``==``, ``!=``, ``<``, ``<=``, ``>`` et "

"``>=``. Les éléments dont le nombre d'occurrences est à zéro sont ignorés. "

"Par exemple, on a ``Counter(a=1) == Counter(a=1, b=0)``."

#: library/collections.rst:346

msgid "Rich comparison operations were added."

msgstr "ajout des comparaisons riches."

#: library/collections.rst:349

msgid ""

"In equality tests, missing elements are treated as having zero counts. "

"Formerly, ``Counter(a=3)`` and ``Counter(a=3, b=0)`` were considered "

"distinct."

msgstr ""

"les éléments dont le nombre d'occurrences est à zéro sont désormais ignorés "

"dans les tests d'égalité. On avait auparavant ``Counter(a=3) != Counter(a=3, "

"b=0)``."

#: library/collections.rst:354

msgid "Common patterns for working with :class:`Counter` objects::"

msgstr "Opérations usuelles sur les objets :class:`Counter` ::"

#: library/collections.rst:366

#, fuzzy

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. Equality and inclusion compare "

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

#: library/collections.rst:391

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

#: library/collections.rst:400

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

#: library/collections.rst:405

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

#: library/collections.rst:410

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

#: library/collections.rst:414

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

#: library/collections.rst:416

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

#: library/collections.rst:422

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

#: library/collections.rst:427

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

#: library/collections.rst:432

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

#: library/collections.rst:435

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>`_)."

#: library/collections.rst:437

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

#: library/collections.rst:440

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

#: library/collections.rst:444

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` ::"

#: library/collections.rst:451

msgid ":class:`deque` objects"

msgstr "Objets :class:`deque`"

#: library/collections.rst:455

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

#: library/collections.rst:458

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

#: library/collections.rst:463

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

#: library/collections.rst:469

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

#: library/collections.rst:478

msgid "Deque objects support the following methods:"

msgstr "Les objets *deques* gèrent les méthodes suivantes :"

#: library/collections.rst:482

msgid "Add *x* to the right side of the deque."

msgstr "Ajoute *x* à l'extrémité droite de la *deque*."

#: library/collections.rst:487

msgid "Add *x* to the left side of the deque."

msgstr "Ajoute *x* à l'extrémité gauche de la *deque*."

#: library/collections.rst:492

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

#: library/collections.rst:497

msgid "Create a shallow copy of the deque."

msgstr "Crée une copie superficielle de la *deque*."

#: library/collections.rst:504

msgid "Count the number of deque elements equal to *x*."

msgstr "Compte le nombre d'éléments de la *deque* égaux à *x*."

#: library/collections.rst:511

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

#: library/collections.rst:517

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

#: library/collections.rst:524

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

#: library/collections.rst:533

msgid "Insert *x* into the deque at position *i*."

msgstr "Insère *x* dans la *deque* à la position *i*."

#: library/collections.rst:535

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

#: library/collections.rst:543

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

#: library/collections.rst:549

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

#: library/collections.rst:555

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

#: library/collections.rst:561

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

#: library/collections.rst:568

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

#: library/collections.rst:571

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())``."

#: library/collections.rst:576

msgid "Deque objects also provide one read-only attribute:"

msgstr ""

"Les objets *deques* fournissent également un attribut en lecture seule :"

#: library/collections.rst:580

msgid "Maximum size of a deque or ``None`` if unbounded."

msgstr "La taille maximale d'une *deque*, ou ``None`` si illimitée."

#: library/collections.rst:585

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[0]`` "

"to access the first element. 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 telles que ``d[0]`` pour accéder au premier élément. "

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

#: library/collections.rst:591

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__()``."

#: library/collections.rst:594

msgid "Example:"

msgstr "Exemple :"

#: library/collections.rst:651

msgid ":class:`deque` Recipes"

msgstr "Cas pratiques utilisant :class:`deque`"

#: library/collections.rst:653

msgid "This section shows various approaches to working with deques."

msgstr ""

"Cette partie montre diverses approches afin de travailler avec les *deques*."

#: library/collections.rst:655

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

#: library/collections.rst:663

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

#: library/collections.rst:678

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` ::"

#: library/collections.rst:697

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

#: library/collections.rst:706

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

#: library/collections.rst:716

msgid ":class:`defaultdict` objects"

msgstr "Objets :class:`defaultdict`"

#: library/collections.rst:720

msgid ""

"Return 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:"

"`defaultdict` est une sous-classe de 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."

#: library/collections.rst:725

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