forked from AFPy/python-docs-fr
1856 lines
80 KiB
Plaintext
1856 lines
80 KiB
Plaintext
# 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: 2022-03-23 18:39+0100\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
|
||
msgid "dict subclass for counting 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:244
|
||
msgid ""
|
||
"A :class:`Counter` is a :class:`dict` subclass for counting 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:250
|
||
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:258
|
||
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:265
|
||
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:273
|
||
#, 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:279
|
||
#, 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:284
|
||
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:294
|
||
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:304
|
||
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:318
|
||
msgid "Compute the sum of the counts."
|
||
msgstr "Calcule la somme totale des nombres d'occurrences."
|
||
|
||
#: library/collections.rst:326
|
||
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:331
|
||
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:335
|
||
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:340
|
||
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:345
|
||
msgid "Rich comparison operations were added."
|
||
msgstr "ajout des comparaisons riches."
|
||
|
||
#: library/collections.rst:348
|
||
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:353
|
||
msgid "Common patterns for working with :class:`Counter` objects::"
|
||
msgstr "Opérations usuelles sur les objets :class:`Counter` ::"
|
||
|
||
#: library/collections.rst:365
|
||
#, 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:390
|
||
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:399
|
||
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:404
|
||
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:409
|
||
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:413
|
||
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:415
|
||
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:421
|
||
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:426
|
||
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:431
|
||
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:434
|
||
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:436
|
||
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:439
|
||
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:443
|
||
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:450
|
||
msgid ":class:`deque` objects"
|
||
msgstr "Objets :class:`deque`"
|
||
|
||
#: library/collections.rst:454
|
||
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:457
|
||
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:462
|
||
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:468
|
||
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:477
|
||
msgid "Deque objects support the following methods:"
|
||
msgstr "Les objets *deques* gèrent les méthodes suivantes :"
|
||
|
||
#: library/collections.rst:481
|
||
msgid "Add *x* to the right side of the deque."
|
||
msgstr "Ajoute *x* à l'extrémité droite de la *deque*."
|
||
|
||
#: library/collections.rst:486
|
||
msgid "Add *x* to the left side of the deque."
|
||
msgstr "Ajoute *x* à l'extrémité gauche de la *deque*."
|
||
|
||
#: library/collections.rst:491
|
||
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:496
|
||
msgid "Create a shallow copy of the deque."
|
||
msgstr "Crée une copie superficielle de la *deque*."
|
||
|
||
#: library/collections.rst:503
|
||
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:510
|
||
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:516
|
||
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:523
|
||
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:532
|
||
msgid "Insert *x* into the deque at position *i*."
|
||
msgstr "Insère *x* dans la *deque* à la position *i*."
|
||
|
||
#: library/collections.rst:534
|
||
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:542
|
||
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:548
|
||
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:554
|
||
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:560
|
||
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:567
|
||
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:570
|
||
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:575
|
||
msgid "Deque objects also provide one read-only attribute:"
|
||
msgstr ""
|
||
"Les objets *deques* fournissent également un attribut en lecture seule :"
|
||
|
||
#: library/collections.rst:579
|
||
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:584
|
||
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:590
|
||
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:593
|
||
msgid "Example:"
|
||
msgstr "Exemple :"
|
||
|
||
#: library/collections.rst:650
|
||
msgid ":class:`deque` Recipes"
|
||
msgstr "Cas pratiques utilisant :class:`deque`"
|
||
|
||
#: library/collections.rst:652
|
||
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:654
|
||
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:662
|
||
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:677
|
||
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:696
|
||
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:705
|
||
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:715
|
||
msgid ":class:`defaultdict` objects"
|
||
msgstr "Objets :class:`defaultdict`"
|
||
|
||
#: library/collections.rst:719
|
||
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:724
|
||
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."
|
||
|
||
#: library/collections.rst:730
|
||
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 :"
|
||
|
||
#: library/collections.rst:735
|
||
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."
|
||
|
||
#: library/collections.rst:738
|
||
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."
|
||
|
||
#: library/collections.rst:742
|
||
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."
|
||
|
||
#: library/collections.rst:745
|
||
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__`."
|
||
|
||
#: library/collections.rst:749
|
||
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`."
|
||
|
||
#: library/collections.rst:755
|
||
msgid ":class:`defaultdict` objects support the following instance variable:"
|
||
msgstr "Les objets :class:`defaultdict` gèrent la variable d'instance :"
|
||
|
||
#: library/collections.rst:760
|
||
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``."
|
||
|
||
#: library/collections.rst:1180
|
||
msgid ""
|
||
"Added merge (``|``) and update (``|=``) operators, specified in :pep:`584`."
|
||
msgstr ""
|
||
"ajout des opérateurs fusion (``|``) et mise-à-jour (``|=``) tels que définis "
|
||
"dans :pep:`584`."
|
||
|
||
#: library/collections.rst:770
|
||
msgid ":class:`defaultdict` Examples"
|
||
msgstr "Exemples utilisant :class:`defaultdict`"
|
||
|
||
#: library/collections.rst:772
|
||
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 :"
|
||
|
||
#: library/collections.rst:783
|
||
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` :"
|
||
|
||
#: library/collections.rst:798
|
||
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) :"
|
||
|
||
#: library/collections.rst:810
|
||
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."
|
||
|
||
#: library/collections.rst:814
|
||
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) :"
|
||
|
||
#: library/collections.rst:826
|
||
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 :"
|
||
|
||
#: library/collections.rst:839
|
||
msgid ":func:`namedtuple` Factory Function for Tuples with Named Fields"
|
||
msgstr ""
|
||
":func:`namedtuple` : fonction de construction pour *n*-uplets avec des "
|
||
"champs nommés"
|
||
|
||
#: library/collections.rst:841
|
||
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 *n*-uplets 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 *n*-uplets 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."
|
||
|
||
#: library/collections.rst:847
|
||
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 *n*-uplets 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 *n*-uplet au "
|
||
"format ``nom=valeur``."
|
||
|
||
#: library/collections.rst:853
|
||
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'``."
|
||
|
||
#: library/collections.rst:857
|
||
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``."
|
||
|
||
#: library/collections.rst:863
|
||
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``."
|
||
|
||
#: library/collections.rst:868
|
||
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``."
|
||
|
||
#: library/collections.rst:875
|
||
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 *n*-uplet nommé."
|
||
|
||
#: library/collections.rst:878
|
||
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 *n*-uplets 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 *n*-uplets "
|
||
"natifs."
|
||
|
||
#: library/collections.rst:881
|
||
msgid ""
|
||
"To support pickling, the named tuple class should be assigned to a variable "
|
||
"that matches *typename*."
|
||
msgstr ""
|
||
"Pour permettre la sérialisation, la classe de *n*-uplet nommée doit être "
|
||
"assignée à une variable qui correspond à *typename*."
|
||
|
||
#: library/collections.rst:884
|
||
msgid "Added support for *rename*."
|
||
msgstr "Gestion de *rename*."
|
||
|
||
#: library/collections.rst:887
|
||
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>`."
|
||
|
||
#: library/collections.rst:891
|
||
msgid "Added the *module* parameter."
|
||
msgstr "Ajout du paramètre *module*."
|
||
|
||
#: library/collections.rst:894
|
||
msgid "Removed the *verbose* parameter and the :attr:`_source` attribute."
|
||
msgstr "Suppression du paramètre *verbose* et de l'attribut :attr:`_source`."
|
||
|
||
#: library/collections.rst:897
|
||
msgid ""
|
||
"Added the *defaults* parameter and the :attr:`_field_defaults` attribute."
|
||
msgstr ""
|
||
"Ajout du paramètre *defaults* et de l'attribut :attr:`_field_defaults`."
|
||
|
||
#: library/collections.rst:917
|
||
msgid ""
|
||
"Named tuples are especially useful for assigning field names to result "
|
||
"tuples returned by the :mod:`csv` or :mod:`sqlite3` modules::"
|
||
msgstr ""
|
||
"Les *n*-uplets nommés sont particulièrement utiles pour associer des noms de "
|
||
"champs à des *n*-uplets renvoyés par les modules :mod:`csv` ou :mod:"
|
||
"`sqlite3` ::"
|
||
|
||
#: library/collections.rst:933
|
||
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 *n*-uplets 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."
|
||
|
||
#: library/collections.rst:939
|
||
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."
|
||
|
||
#: library/collections.rst:949
|
||
msgid ""
|
||
"Return a new :class:`dict` which maps field names to their corresponding "
|
||
"values:"
|
||
msgstr ""
|
||
"Renvoie un nouveau :class:`dict` qui associe chaque nom de champ à sa valeur "
|
||
"correspondante :"
|
||
|
||
#: library/collections.rst:958
|
||
msgid "Returns an :class:`OrderedDict` instead of a regular :class:`dict`."
|
||
msgstr "Renvoie un :class:`OrderedDict` au lieu d'un :class:`dict` natif."
|
||
|
||
#: library/collections.rst:961
|
||
msgid ""
|
||
"Returns a regular :class:`dict` instead of an :class:`OrderedDict`. As of "
|
||
"Python 3.7, regular dicts are guaranteed to be ordered. If the extra "
|
||
"features of :class:`OrderedDict` are required, the suggested remediation is "
|
||
"to cast the result to the desired type: ``OrderedDict(nt._asdict())``."
|
||
msgstr ""
|
||
"renvoie un :class:`dict` natif plutôt qu'un :class:`OrderedDict`. À partir "
|
||
"de Python 3.7, les dictionnaires natifs garantissent la préservation de "
|
||
"l'ordre. Si les autres fonctionnalités d':class:`OrderedDict` sont "
|
||
"nécessaires, la solution préconisée est de convertir le résultat vers le "
|
||
"type souhaité : ``OrderedDict(nt._asdict())``."
|
||
|
||
#: library/collections.rst:970
|
||
msgid ""
|
||
"Return a new instance of the named tuple replacing specified fields with new "
|
||
"values::"
|
||
msgstr ""
|
||
"Renvoie une nouvelle instance du *n*-uplet nommé en remplaçant les champs "
|
||
"spécifiés par leurs nouvelles valeurs ::"
|
||
|
||
#: library/collections.rst:982
|
||
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 *n*-uplets nommés à "
|
||
"partir d'existants."
|
||
|
||
#: library/collections.rst:997
|
||
msgid "Dictionary mapping field names to default values."
|
||
msgstr "Dictionnaire qui assigne les valeurs par défaut aux noms des champs."
|
||
|
||
#: library/collections.rst:1007
|
||
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` :"
|
||
|
||
#: library/collections.rst:1013
|
||
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 *n*-uplet nommé, utilisez l'opérateur "
|
||
"double-étoile (comme expliqué dans :ref:`tut-unpacking-arguments`) :"
|
||
|
||
#: library/collections.rst:1020
|
||
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 *n*-uplets "
|
||
"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 :"
|
||
|
||
#: library/collections.rst:1039
|
||
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 *n*-uplet vide. Cela "
|
||
"permet de garder une emprunte mémoire faible en empêchant la création de "
|
||
"dictionnaire d'instance."
|
||
|
||
#: library/collections.rst:1042
|
||
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 *n*-uplet nommé avec "
|
||
"l'attribut :attr:`~somenamedtuple._fields` :"
|
||
|
||
#: library/collections.rst:1047
|
||
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__`` :"
|
||
|
||
#: library/collections.rst:1056
|
||
msgid "Property docstrings became writeable."
|
||
msgstr "La propriété devient éditable."
|
||
|
||
#: library/collections.rst:1061
|
||
msgid ""
|
||
"See :class:`typing.NamedTuple` for a way to add type hints for named "
|
||
"tuples. It also provides an elegant notation using the :keyword:`class` "
|
||
"keyword::"
|
||
msgstr ""
|
||
"Voir :meth:`typing.NamedTuple` pour un moyen d'ajouter des indications de "
|
||
"type pour les *n*-uplets nommés. Cela propose aussi une notation élégante "
|
||
"utilisant le mot-clé :keyword:`class` ::"
|
||
|
||
#: library/collections.rst:1070
|
||
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 nommage muable basé sur "
|
||
"un dictionnaire sous-jacent à la place d'un *n*-uplet."
|
||
|
||
#: library/collections.rst:1073
|
||
msgid ""
|
||
"The :mod:`dataclasses` module provides a decorator and functions for "
|
||
"automatically adding generated special methods to user-defined classes."
|
||
msgstr ""
|
||
"Le module :mod:`dataclasses` fournit un décorateur et des fonctions pour "
|
||
"ajouter automatiquement des méthodes spéciales générées aux classes définies "
|
||
"par l’utilisateur."
|
||
|
||
#: library/collections.rst:1078
|
||
msgid ":class:`OrderedDict` objects"
|
||
msgstr "Objets :class:`OrderedDict`"
|
||
|
||
#: library/collections.rst:1080
|
||
msgid ""
|
||
"Ordered dictionaries are just like regular dictionaries but have some extra "
|
||
"capabilities relating to ordering operations. They have become less "
|
||
"important now that the built-in :class:`dict` class gained the ability to "
|
||
"remember insertion order (this new behavior became guaranteed in Python 3.7)."
|
||
msgstr ""
|
||
"Les dictionnaires ordonnés sont des dictionnaires comme les autres mais "
|
||
"possèdent des capacités supplémentaires pour s'ordonner. Ils sont maintenant "
|
||
"moins importants puisque la classe native :class:`dict` sait se souvenir de "
|
||
"l'ordre d'insertion (cette fonctionnalité a été garantie par Python 3.7)."
|
||
|
||
#: library/collections.rst:1086
|
||
msgid "Some differences from :class:`dict` still remain:"
|
||
msgstr "Quelques différences persistent vis-à-vis de :class:`dict` :"
|
||
|
||
#: library/collections.rst:1088
|
||
msgid ""
|
||
"The regular :class:`dict` was designed to be very good at mapping "
|
||
"operations. Tracking insertion order was secondary."
|
||
msgstr ""
|
||
"Les :class:`dict` classiques ont été conçus pour être performants dans les "
|
||
"opérations de correspondance. Garder une trace de l'ordre d'insertion était "
|
||
"secondaire."
|
||
|
||
#: library/collections.rst:1091
|
||
msgid ""
|
||
"The :class:`OrderedDict` was designed to be good at reordering operations. "
|
||
"Space efficiency, iteration speed, and the performance of update operations "
|
||
"were secondary."
|
||
msgstr ""
|
||
"Les :class:`OrderedDict` ont été conçus pour être performants dans les "
|
||
"opérations de ré-arrangement. L'occupation mémoire, la vitesse de parcours "
|
||
"et les performances de mise à jour étaient secondaires."
|
||
|
||
#: library/collections.rst:1095
|
||
#, fuzzy
|
||
msgid ""
|
||
"The :class:`OrderedDict` algorithm can handle frequent reordering operations "
|
||
"better than :class:`dict`. As shown in the recipes below, this makes it "
|
||
"suitable for implementing various kinds of LRU caches."
|
||
msgstr ""
|
||
"Algorithmiquement, :class:`OrderedDict` gère mieux les ré-arrangements "
|
||
"fréquents que :class:`dict`. Ceci la rend adaptée pour suivre les accès les "
|
||
"plus récents (par exemple pour implémenter un `cache LRU <https://medium."
|
||
"com/@krishankantsinghal/my-first-blog-on-medium-583159139237>`_ pour *Least "
|
||
"Recently Used* en anglais)."
|
||
|
||
#: library/collections.rst:1099
|
||
msgid ""
|
||
"The equality operation for :class:`OrderedDict` checks for matching order."
|
||
msgstr ""
|
||
"Le test d'égalité de :class:`OrderedDict` vérifie si l'ordre correspond."
|
||
|
||
#: library/collections.rst:1101
|
||
msgid ""
|
||
"A regular :class:`dict` can emulate the order sensitive equality test with "
|
||
"``p == q and all(k1 == k2 for k1, k2 in zip(p, q))``."
|
||
msgstr ""
|
||
|
||
#: library/collections.rst:1104
|
||
msgid ""
|
||
"The :meth:`popitem` method of :class:`OrderedDict` has a different "
|
||
"signature. It accepts an optional argument to specify which item is popped."
|
||
msgstr ""
|
||
"La méthode :meth:`popitem` de :class:`OrderedDict` possède une signature "
|
||
"différente. Elle accepte un argument optionnel pour spécifier quel élément "
|
||
"doit être enlevé."
|
||
|
||
#: library/collections.rst:1107
|
||
msgid ""
|
||
"A regular :class:`dict` can emulate OrderedDict's ``od.popitem(last=True)`` "
|
||
"with ``d.popitem()`` which is guaranteed to pop the rightmost (last) item."
|
||
msgstr ""
|
||
|
||
#: library/collections.rst:1110
|
||
msgid ""
|
||
"A regular :class:`dict` can emulate OrderedDict's ``od.popitem(last=False)`` "
|
||
"with ``(k := next(iter(d)), d.pop(k))`` which will return and remove the "
|
||
"leftmost (first) item if it exists."
|
||
msgstr ""
|
||
|
||
#: library/collections.rst:1114
|
||
msgid ""
|
||
":class:`OrderedDict` has a :meth:`move_to_end` method to efficiently "
|
||
"reposition an element to an endpoint."
|
||
msgstr ""
|
||
":class:`OrderedDict` possède une méthode :meth:`move_to_end` pour déplacer "
|
||
"efficacement un élément à la fin."
|
||
|
||
#: library/collections.rst:1117
|
||
msgid ""
|
||
"A regular :class:`dict` can emulate OrderedDict's ``od.move_to_end(k, "
|
||
"last=True)`` with ``d[k] = d.pop(k)`` which will move the key and its "
|
||
"associated value to the rightmost (last) position."
|
||
msgstr ""
|
||
|
||
#: library/collections.rst:1121
|
||
msgid ""
|
||
"A regular :class:`dict` does not have an efficient equivalent for "
|
||
"OrderedDict's ``od.move_to_end(k, last=False)`` which moves the key and its "
|
||
"associated value to the leftmost (first) position."
|
||
msgstr ""
|
||
|
||
#: library/collections.rst:1125
|
||
msgid "Until Python 3.8, :class:`dict` lacked a :meth:`__reversed__` method."
|
||
msgstr ""
|
||
"Avant Python 3.8, :class:`dict` n'a pas de méthode :meth:`__reversed__`."
|
||
|
||
#: library/collections.rst:1130
|
||
msgid ""
|
||
"Return an instance of a :class:`dict` subclass that has methods specialized "
|
||
"for rearranging dictionary order."
|
||
msgstr ""
|
||
"Renvoie une instance d'une sous-classe de :class:`dict` qui possède des "
|
||
"méthodes spécialisées pour redéfinir l'ordre du dictionnaire."
|
||
|
||
#: library/collections.rst:1137
|
||
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)`)."
|
||
|
||
#: library/collections.rst:1144
|
||
#, fuzzy
|
||
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 ::"
|
||
|
||
#: library/collections.rst:1161
|
||
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`."
|
||
|
||
#: library/collections.rst:1164
|
||
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."
|
||
|
||
#: library/collections.rst:1171
|
||
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`."
|
||
|
||
#: library/collections.rst:1175
|
||
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é."
|
||
|
||
#: library/collections.rst:1185
|
||
msgid ":class:`OrderedDict` Examples and Recipes"
|
||
msgstr "Exemples et cas pratiques utilisant :class:`OrderDict`"
|
||
|
||
#: library/collections.rst:1187
|
||
msgid ""
|
||
"It is straightforward 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 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 ::"
|
||
|
||
#: library/collections.rst:1199
|
||
msgid ""
|
||
"An :class:`OrderedDict` would also be useful for implementing variants of :"
|
||
"func:`functools.lru_cache`:"
|
||
msgstr ""
|
||
"Un :class:`OrderedDict` peut aussi être utile pour implémenter des variantes "
|
||
"de :func:`functools.lru_cache` :"
|
||
|
||
#: library/collections.rst:1297
|
||
msgid ":class:`UserDict` objects"
|
||
msgstr "Objets :class:`UserDict`"
|
||
|
||
#: library/collections.rst:1299
|
||
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."
|
||
|
||
#: library/collections.rst:1307
|
||
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 to 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."
|
||
|
||
#: library/collections.rst:1313
|
||
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 instances "
|
||
"de :class:`UserDict` fournissent l'attribut suivant :"
|
||
|
||
#: library/collections.rst:1318
|
||
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`."
|
||
|
||
#: library/collections.rst:1324
|
||
msgid ":class:`UserList` objects"
|
||
msgstr "Objets :class:`UserList`"
|
||
|
||
#: library/collections.rst:1326
|
||
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."
|
||
|
||
#: library/collections.rst:1331
|
||
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."
|
||
|
||
#: library/collections.rst:1337
|
||
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`."
|
||
|
||
#: library/collections.rst:1343
|
||
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 :"
|
||
|
||
#: library/collections.rst:1348
|
||
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`."
|
||
|
||
#: library/collections.rst:1351
|
||
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-classes 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."
|
||
|
||
#: library/collections.rst:1358
|
||
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."
|
||
|
||
#: library/collections.rst:1364
|
||
msgid ":class:`UserString` objects"
|
||
msgstr "Objets :class:`UserString`"
|
||
|
||
#: library/collections.rst:1366
|
||
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."
|
||
|
||
#: library/collections.rst:1374
|
||
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`."
|
||
|
||
#: library/collections.rst:1381
|
||
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 :"
|
||
|
||
#: library/collections.rst:1386
|
||
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`."
|
||
|
||
#: library/collections.rst:1389
|
||
msgid ""
|
||
"New methods ``__getnewargs__``, ``__rmod__``, ``casefold``, ``format_map``, "
|
||
"``isprintable``, and ``maketrans``."
|
||
msgstr ""
|
||
"Nouvelles méthodes ``__getnewargs__``, ``__rmod__``, ``casefold``, "
|
||
"``format_map``, ``isprintable`` et ``maketrans``."
|
||
|
||
#~ 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.9."
|
||
#~ 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 dans Python 3.9."
|