# 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-04-14 13:19+0200\n" "PO-Revision-Date: 2021-11-06 20:46+0100\n" "Last-Translator: Jean Abou Samra \n" "Language-Team: FRENCH \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 `. 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 `), 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 `_ in the Enthought `CodeTools package " "`_ has options to support writing to " "any mapping in the chain." msgstr "" "La `classe MultiContext `_ dans le `package 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 `_ 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 `_ 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 `_ " "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 `_ 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 `_." msgstr "" "Une `version grandement simplifiée de Chainmap en lecture seule `_." #: 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 #, 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: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 `_ in Smalltalk." msgstr "" "`Bag class `_ dans Smalltalk." #: library/collections.rst:434 msgid "" "Wikipedia entry for `Multisets `_." msgstr "" "L'article Wikipédia sur les `multiensembles `_ sur Wikipédia (ou `l'article en anglais `_)." #: library/collections.rst:436 msgid "" "`C++ multisets `_ tutorial with examples." msgstr "" "Des guides et exemples à propos des `multiensembles en C++ `_." #: 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 `_ 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 `_ 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 `, 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 " "`." msgstr "" "Les paramètres *verbose* et *rename* deviennent des :ref:`arguments " "obligatoirement nommés `." #: 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 `_ 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 ` of :class:" "`OrderedDict` now support reverse iteration using :func:`reversed`." msgstr "" "Les :term:`vues ` 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."