diff --git a/howto/enum.po b/howto/enum.po index 6f1a0d7a..02fc5bd2 100644 --- a/howto/enum.po +++ b/howto/enum.po @@ -6,19 +6,20 @@ msgid "" msgstr "" "Project-Id-Version: Python 3.11\n" -"Report-Msgid-Bugs-To:\n" +"Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2022-05-22 23:13+0200\n" -"PO-Revision-Date: 2022-05-23 00:51+0200\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2023-01-07 22:56+0100\n" +"Last-Translator: \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" +"X-Generator: Poedit 3.2.1\n" #: howto/enum.rst:3 msgid "Enum HOWTO" -msgstr "" +msgstr "Guide sur l'utilisation d'*Enum*" #: howto/enum.rst:9 msgid "" @@ -26,32 +27,46 @@ msgid "" "are similar to global variables, but they offer a more useful :func:" "`repr()`, grouping, type-safety, and a few other features." msgstr "" +"Une :class:`Enum` est un ensemble de noms symboliques associés à des valeurs " +"uniques. Elles sont similaires aux variables globales, mais elles offrent " +"des particularités utiles telles qu'une meilleure :func:`repr()`, le " +"regroupement, une sécurité concernant le typage et quelques autres " +"fonctionnalités." #: howto/enum.rst:13 msgid "" "They are most useful when you have a variable that can take one of a limited " "selection of values. For example, the days of the week::" msgstr "" +"Elles sont particulièrement utiles lorsque vous avez une variable qui peut " +"prendre une valeur dans une plage limitée de valeurs. Par exemple, les jours " +"de la semaine ::" #: howto/enum.rst:26 msgid "Or perhaps the RGB primary colors::" -msgstr "" +msgstr "Ou alors les couleurs primaires *RVB* (NdT : *RGB* en anglais) ::" #: howto/enum.rst:34 msgid "" "As you can see, creating an :class:`Enum` is as simple as writing a class " "that inherits from :class:`Enum` itself." msgstr "" +"Comme vous pouvez le voir, créer une :class:`Enum` est très simple à écrire, " +"il suffit qu'elle hérite de :class:`Enum` elle-même." +# suit un : #: howto/enum.rst:37 msgid "Case of Enum Members" -msgstr "" +msgstr "casse des membres d'une énumération" #: howto/enum.rst:39 msgid "" "Because Enums are used to represent constants we recommend using UPPER_CASE " "names for members, and will be using that style in our examples." msgstr "" +"Étant donné que les énumérations sont utilisées pour représenter des " +"constantes, nous vous recommandons d'utiliser des noms en MAJUSCULES pour " +"les membres, et nous utiliserons ce style dans nos exemples." #: howto/enum.rst:42 msgid "" @@ -59,6 +74,9 @@ msgid "" "important, but either way that value can be used to get the corresponding " "member::" msgstr "" +"Selon la nature de l'énumération, il peut être important d'avoir accès à la " +"valeur d'un membre. Dans tous les cas, cette valeur peut être utilisée pour " +"obtenir le membre correspondant ::" #: howto/enum.rst:49 msgid "" @@ -66,18 +84,25 @@ msgid "" "name, and the value. The ``str()`` of a member shows only the enum name and " "member name::" msgstr "" +"Comme vous pouvez le constater, la ``repr()`` d'un membre affiche le nom de " +"l'énumération, le nom du membre et la valeur. La ``str()`` d'un membre " +"affiche uniquement le nom de l'énumération et le nom du membre ::" #: howto/enum.rst:56 msgid "The *type* of an enumeration member is the enum it belongs to::" msgstr "" +"Le *type* d'un membre d'énumération est l'énumération à laquelle il " +"appartient ::" #: howto/enum.rst:63 msgid "Enum members have an attribute that contains just their :attr:`name`::" msgstr "" +"Les membres d'une énumération possèdent un attribut :attr:`name` qui " +"contient leur nom ::" #: howto/enum.rst:68 msgid "Likewise, they have an attribute for their :attr:`value`::" -msgstr "" +msgstr "De même, ils ont un attribut :attr:`value` pour leur valeur ::" #: howto/enum.rst:74 msgid "" @@ -89,20 +114,34 @@ msgid "" "to the :class:`Weekday` enum to extract the day from the :class:`date` " "instance and return the matching enum member::" msgstr "" +"Contrairement à de nombreux langages qui traitent les énumérations " +"uniquement comme des paires nom-valeur, le comportement des énumérations " +"Python peut être augmenté. Par exemple, :class:`datetime.date` a deux " +"méthodes pour renvoyer le jour de la semaine : :meth:`weekday` et :meth:" +"`isoweekday`. La différence est que la première compte de 0 à 6 et la " +"seconde de 1 à 7. Plutôt que d'avoir à nous en rappeler nous-mêmes, nous " +"pouvons ajouter une méthode à l'énumération :class:`Weekday` pour extraire " +"le jour d'une instance :class:`date` et renvoyer le membre correspondant de " +"l'énumération ::" #: howto/enum.rst:86 msgid "The complete :class:`Weekday` enum now looks like this::" msgstr "" +"L'énumération :class:`Weekday` en entier ressemble maintenant à ceci ::" #: howto/enum.rst:101 msgid "Now we can find out what today is! Observe::" msgstr "" +"Maintenant, nous pouvons découvrir quel jour nous sommes aujourd'hui ! " +"Regardez ::" #: howto/enum.rst:107 msgid "" "Of course, if you're reading this on some other day, you'll see that day " "instead." msgstr "" +"Bien sûr, si vous lisez cette page un autre jour, vous verrez ce jour-là à " +"la place." #: howto/enum.rst:109 msgid "" @@ -111,46 +150,60 @@ msgid "" "during a week, and don't want to use a :class:`list` -- we could use a " "different type of :class:`Enum`::" msgstr "" +"Cette énumération :class:`Weekday` est idéale si notre variable n'a besoin " +"que d'un jour, mais que se passe-t-il si nous en avons besoin de plusieurs ? " +"Par exemple si nous écrivons une fonction pour garder une trace des tâches " +"pendant une semaine, et que nous ne voulons pas utiliser une :class:`list` — " +"nous pouvons utiliser un autre type :class:`Enum` ::" #: howto/enum.rst:124 msgid "" "We've changed two things: we're inherited from :class:`Flag`, and the values " "are all powers of 2." msgstr "" +"Nous avons changé deux choses : nous héritons de :class:`Flag` et les " +"valeurs sont toutes des puissances de 2." #: howto/enum.rst:127 msgid "" "Just like the original :class:`Weekday` enum above, we can have a single " "selection::" msgstr "" +"De la même manière que pour l'énumération originale :class:`Weekday` ci-" +"dessus, nous pouvons sélectionner un seul élément ::" #: howto/enum.rst:133 msgid "" "But :class:`Flag` also allows us to combine several members into a single " "variable::" msgstr "" +"Mais :class:`Flag` nous permet aussi de combiner plusieurs membres en une " +"seule variable ::" #: howto/enum.rst:140 msgid "You can even iterate over a :class:`Flag` variable::" -msgstr "" +msgstr "Nous pouvons même itérer sur une variable :class:`Flag` ::" #: howto/enum.rst:147 msgid "Okay, let's get some chores set up::" -msgstr "" +msgstr "Bien, préparons quelques corvées ::" #: howto/enum.rst:155 msgid "And a function to display the chores for a given day::" -msgstr "" +msgstr "Et une fonction pour afficher les corvées d'un jour donné ::" #: howto/enum.rst:164 msgid "" "In cases where the actual values of the members do not matter, you can save " "yourself some work and use :func:`auto()` for the values::" msgstr "" +"Au cas où les valeurs réelles des membres n'ont pas d'importance, nous " +"pouvons nous épargner du travail et utiliser :func:`auto()` pour les " +"valeurs ::" #: howto/enum.rst:182 msgid "Programmatic access to enumeration members and their attributes" -msgstr "" +msgstr "Accès par programme aux membres de l'énumération et à leurs attributs" #: howto/enum.rst:184 msgid "" @@ -158,22 +211,32 @@ msgid "" "e. situations where ``Color.RED`` won't do because the exact color is not " "known at program-writing time). ``Enum`` allows such access::" msgstr "" +"Il est parfois utile d'accéder aux membres d'une énumération " +"programmatiquement (c'est-à-dire les cas où ``Color.RED`` ne suffit pas car " +"la couleur exacte n'est pas connue au moment de l'écriture du programme). " +"``Enum`` permet de tels accès ::" #: howto/enum.rst:193 msgid "If you want to access enum members by *name*, use item access::" msgstr "" +"Si vous souhaitez accéder aux membres d'une énumération par leur nom, " +"utilisez l'accès par indice ::" #: howto/enum.rst:200 msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::" msgstr "" +"Si vous avez un membre d'une énumération et que vous avez besoin de son :" +"attr:`nom ` ou de sa :attr:`valeur `, utilisez ses attributs ::" #: howto/enum.rst:210 msgid "Duplicating enum members and values" -msgstr "" +msgstr "Duplication des membres et des valeurs d'une énumération" #: howto/enum.rst:212 msgid "Having two enum members with the same name is invalid::" msgstr "" +"Il n'est pas licite d'avoir deux membres d'une énumération avec le même " +"nom ::" #: howto/enum.rst:222 msgid "" @@ -183,50 +246,70 @@ msgid "" "will return the member ``A``. By-name lookup of ``A`` will return the " "member ``A``. By-name lookup of ``B`` will also return the member ``A``::" msgstr "" +"Cependant, un membre peut avoir d'autres noms qui lui sont associés. Étant " +"donné deux entrées ``A`` et ``B`` avec la même valeur (et ``A`` définie en " +"premier), ``B`` est un synonyme (ou alias) du membre ``A``. La recherche par " +"valeur de la valeur de ``A`` renvoie le membre ``A``. La recherche par nom " +"de ``A`` renvoie le membre ``A``. La recherche par nom de ``B`` renvoie " +"également le membre ``A`` ::" +# suit un : #: howto/enum.rst:243 msgid "" "Attempting to create a member with the same name as an already defined " "attribute (another member, a method, etc.) or attempting to create an " "attribute with the same name as a member is not allowed." msgstr "" +"tenter de créer un membre portant le même nom qu'un attribut déjà défini (un " +"autre membre, une méthode, etc.) ou tenter de créer un attribut portant le " +"même nom qu'un membre n'est pas autorisé." #: howto/enum.rst:249 msgid "Ensuring unique enumeration values" -msgstr "" +msgstr "Garantie de valeurs d'énumération uniques" #: howto/enum.rst:251 msgid "" "By default, enumerations allow multiple names as aliases for the same value. " "When this behavior isn't desired, you can use the :func:`unique` decorator::" msgstr "" +"Par défaut, les énumérations autorisent plusieurs noms comme synonymes pour " +"la même valeur. Lorsque ce comportement n'est pas souhaité, vous pouvez " +"utiliser le décorateur :func:`unique` ::" #: howto/enum.rst:268 msgid "Using automatic values" -msgstr "" +msgstr "Utilisation de valeurs automatiques" #: howto/enum.rst:270 msgid "If the exact value is unimportant you can use :class:`auto`::" msgstr "" +"Si la valeur exacte n'est pas importante, vous pouvez utiliser :class:" +"`auto` ::" #: howto/enum.rst:281 msgid "" "The values are chosen by :func:`_generate_next_value_`, which can be " "overridden::" msgstr "" +"Les valeurs sont choisies par :func:`_generate_next_value_`, qui peut être " +"surchargée ::" +# suit un : #: howto/enum.rst:299 msgid "" "The :meth:`_generate_next_value_` method must be defined before any members." msgstr "" +"la méthode :meth:`_generate_next_value_` doit être définie avant tout membre." #: howto/enum.rst:302 msgid "Iteration" -msgstr "" +msgstr "Itération" #: howto/enum.rst:304 msgid "Iterating over the members of an enum does not provide the aliases::" msgstr "" +"L'itération sur les membres d'une énumération ne fournit pas les synonymes ::" #: howto/enum.rst:309 msgid "" @@ -234,30 +317,39 @@ msgid "" "names to members. It includes all names defined in the enumeration, " "including the aliases::" msgstr "" +"L'attribut spécial ``__members__`` est un tableau de correspondances ordonné " +"en lecture seule des noms vers les membres. Il inclut tous les noms définis " +"dans l'énumération, y compris les synonymes ::" #: howto/enum.rst:321 msgid "" "The ``__members__`` attribute can be used for detailed programmatic access " "to the enumeration members. For example, finding all the aliases::" msgstr "" +"L'attribut ``__members__`` peut être utilisé pour un accès programmatique " +"détaillé aux membres de l'énumération. Par exemple, trouver tous les " +"synonymes ::" #: howto/enum.rst:329 msgid "Comparisons" -msgstr "" +msgstr "Comparaisons" #: howto/enum.rst:331 msgid "Enumeration members are compared by identity::" -msgstr "" +msgstr "Les membres de l'énumération sont comparés par identité ::" #: howto/enum.rst:340 msgid "" "Ordered comparisons between enumeration values are *not* supported. Enum " "members are not integers (but see `IntEnum`_ below)::" msgstr "" +"Les comparaisons ordonnées entre les valeurs d'énumération *ne sont pas* " +"prises en charge. Les membres d'une énumération ne sont pas des entiers " +"(mais voir `IntEnum`_ plus bas) ::" #: howto/enum.rst:348 msgid "Equality comparisons are defined though::" -msgstr "" +msgstr "Les comparaisons d'égalité sont cependant définies ::" #: howto/enum.rst:357 msgid "" @@ -265,10 +357,13 @@ msgid "" "(again, :class:`IntEnum` was explicitly designed to behave differently, see " "below)::" msgstr "" +"Les comparaisons avec des valeurs en dehors de l'énumération sont toujours " +"fausses (encore une fois, :class:`IntEnum` a été explicitement conçue pour " +"se comporter différemment, voir ci-dessous) ::" #: howto/enum.rst:366 msgid "Allowed members and attributes of enumerations" -msgstr "" +msgstr "Membres et attributs autorisés des énumérations" #: howto/enum.rst:368 msgid "" @@ -278,16 +373,24 @@ msgid "" "doesn't care what the actual value of an enumeration is. But if the value " "*is* important, enumerations can have arbitrary values." msgstr "" +"La plupart des exemples ci-dessus utilisent des nombres entiers pour les " +"valeurs d'énumération. L'utilisation d'entiers est rapide et pratique (et " +"fournie par défaut par l'`API fonctionnelle`_), mais n'est pas strictement " +"obligatoire. Dans la grande majorité des cas, on ne se soucie pas de la " +"valeur réelle des membres d'une énumération. Mais si la valeur *est* " +"importante, les énumérations peuvent avoir des valeurs arbitraires." #: howto/enum.rst:374 msgid "" "Enumerations are Python classes, and can have methods and special methods as " "usual. If we have this enumeration::" msgstr "" +"Les énumérations sont des classes Python et peuvent avoir des méthodes ainsi " +"que des méthodes spéciales comme d'habitude. Prenons cette énumération ::" #: howto/enum.rst:394 msgid "Then::" -msgstr "" +msgstr "alors ::" #: howto/enum.rst:403 msgid "" @@ -298,6 +401,13 @@ msgid "" "`__add__`, etc.), descriptors (methods are also descriptors), and variable " "names listed in :attr:`_ignore_`." msgstr "" +"Les règles concernant ce qui est autorisé ou pas sont les suivantes : les " +"noms qui commencent et se terminent par un seul caractère de soulignement " +"sont réservés par l'énumération et ne peuvent pas être utilisés ; tous les " +"autres attributs définis dans une énumération deviendront membres de cette " +"énumération, à l'exception des méthodes spéciales (:meth:`__str__`, :meth:" +"`__add__`, etc.), des descripteurs (les méthodes sont aussi des " +"descripteurs) et des noms de variables listés dans :attr:`_ignore_`." #: howto/enum.rst:410 msgid "" @@ -305,10 +415,13 @@ msgid "" "then any value(s) given to the enum member will be passed into those " "methods. See `Planet`_ for an example." msgstr "" +"Remarque : si votre énumération définit :meth:`__new__` ou :meth:`__init__`, " +"alors toute valeur donnée à un membre de l'énumération sera passée à ces " +"méthodes. Voir `Planète`_ pour un exemple." #: howto/enum.rst:416 msgid "Restricted Enum subclassing" -msgstr "" +msgstr "Restrictions sur la dérivation d'énumérations" #: howto/enum.rst:418 msgid "" @@ -316,16 +429,21 @@ msgid "" "data type, and as many :class:`object`-based mixin classes as needed. The " "order of these base classes is::" msgstr "" +"Une nouvelle classe :class:`Enum` doit avoir une classe mère *Enum*, jusqu'à " +"un type de données concret, et autant de classes mélangées filles de :class:" +"`object` que nécessaire. L'ordre de ces classes mères est ::" #: howto/enum.rst:425 msgid "" "Also, subclassing an enumeration is allowed only if the enumeration does not " "define any members. So this is forbidden::" msgstr "" +"De plus, la dérivation d'une énumération n'est autorisée que si " +"l'énumération ne définit aucun membre. Donc ceci est interdit ::" #: howto/enum.rst:435 msgid "But this is allowed::" -msgstr "" +msgstr "Mais ceci est autorisé ::" #: howto/enum.rst:446 msgid "" @@ -334,14 +452,19 @@ msgid "" "makes sense to allow sharing some common behavior between a group of " "enumerations. (See `OrderedEnum`_ for an example.)" msgstr "" +"Autoriser la dérivation d'énumérations qui définissent les membres " +"conduirait à une violation de certains invariants importants des types et " +"des instances. D'un autre côté, il est logique de permettre le partage d'un " +"comportement commun entre un groupe d'énumérations (voir `OrderedEnum`_ pour " +"un exemple)." #: howto/enum.rst:453 msgid "Pickling" -msgstr "" +msgstr "Sérialisation" #: howto/enum.rst:455 msgid "Enumerations can be pickled and unpickled::" -msgstr "" +msgstr "Les énumérations peuvent être sérialisées et désérialisées ::" #: howto/enum.rst:462 msgid "" @@ -349,33 +472,48 @@ msgid "" "in the top level of a module, since unpickling requires them to be " "importable from that module." msgstr "" +"Les restrictions habituelles pour la sérialisation s'appliquent : les " +"énumérations sérialisables doivent être définies au niveau supérieur d'un " +"module, car la sérialisation nécessite qu'elles puissent être importées à " +"partir de ce module." +# suit un : #: howto/enum.rst:468 msgid "" "With pickle protocol version 4 it is possible to easily pickle enums nested " "in other classes." msgstr "" +"avec la version 4 du protocole *pickle*, il est possible de sérialiser " +"facilement les énumérations imbriquées dans d'autres classes." #: howto/enum.rst:471 msgid "" "It is possible to modify how enum members are pickled/unpickled by defining :" "meth:`__reduce_ex__` in the enumeration class." msgstr "" +"Il est possible de modifier la manière dont les membres de l'énumération " +"sont sérialisés-désérialisés en définissant :meth:`__reduce_ex__` dans la " +"classe d'énumération." #: howto/enum.rst:476 msgid "Functional API" -msgstr "" +msgstr "API fonctionnelle" #: howto/enum.rst:478 msgid "" "The :class:`Enum` class is callable, providing the following functional API::" msgstr "" +"La classe :class:`Enum` est appelable, elle fournit l'API fonctionnelle " +"suivante ::" #: howto/enum.rst:488 msgid "" "The semantics of this API resemble :class:`~collections.namedtuple`. The " "first argument of the call to :class:`Enum` is the name of the enumeration." msgstr "" +"La sémantique de cette API ressemble à celle des :class:`~collections." +"namedtuple`. Le premier argument de l'appel à :class:`Enum` est le nom de " +"l'énumération." #: howto/enum.rst:491 msgid "" @@ -388,6 +526,16 @@ msgid "" "class derived from :class:`Enum` is returned. In other words, the above " "assignment to :class:`Animal` is equivalent to::" msgstr "" +"Le deuxième argument est la *source* des noms des membres de l'énumération. " +"Il peut s'agir d'une chaîne de noms séparés par des espaces, d'une séquence " +"de noms, d'une séquence de couples clé-valeur, ou d'un tableau de " +"correspondances (par exemple, un dictionnaire) de noms vers des valeurs. Les " +"deux dernières options permettent d'attribuer des valeurs arbitraires aux " +"énumérations ; les autres assignent automatiquement des entiers croissants " +"commençant à 1 (utilisez le paramètre ``start`` pour spécifier une valeur de " +"départ différente). Une nouvelle classe dérivée d':class:`Enum` est " +"renvoyée. En d'autres termes, l'affectation ci-dessus à :class:`Animal` est " +"équivalente à :" #: howto/enum.rst:507 msgid "" @@ -395,6 +543,9 @@ msgid "" "that ``0`` is ``False`` in a boolean sense, but by default enum members all " "evaluate to ``True``." msgstr "" +"La raison de la valeur par défaut de ``1`` comme numéro de départ et non de " +"``0`` est que le sens booléen de ``0`` est ``False``. Or, par défaut, les " +"membres d'une énumération s'évaluent tous à ``True``." #: howto/enum.rst:511 msgid "" @@ -404,13 +555,24 @@ msgid "" "function in a separate module, and also may not work on IronPython or " "Jython). The solution is to specify the module name explicitly as follows::" msgstr "" +"La sérialisation d'énumérations créées avec l'API fonctionnelle peut être " +"délicat car les détails d'implémentation de la pile d'appels sont utilisés " +"pour essayer de déterminer dans quel module l'énumération est créée (par " +"exemple, cela échoue si vous utilisez une fonction utilitaire dans un module " +"séparé, et peut également ne pas fonctionner sur *IronPython* ou *Jython*). " +"La solution consiste à spécifier explicitement le nom du module comme suit ::" +# suit un : #: howto/enum.rst:521 msgid "" "If ``module`` is not supplied, and Enum cannot determine what it is, the new " "Enum members will not be unpicklable; to keep errors closer to the source, " "pickling will be disabled." msgstr "" +"si le ``module`` n'est pas fourni et qu'*Enum* ne peut pas le déterminer, " +"les nouveaux membres de l'énumération ne pourront pas être sélectionnés ; " +"pour garder les erreurs au plus près de la source, la sérialisation est " +"désactivée." #: howto/enum.rst:525 msgid "" @@ -419,84 +581,97 @@ msgid "" "able to find the class. For example, if the class was made available in " "class SomeData in the global scope::" msgstr "" +"Le nouveau protocole *pickle* 4 s'appuie également, dans certaines " +"circonstances, sur :attr:`~definition.__qualname__` qui définit " +"l'emplacement où la sérialisation peut trouver la classe. Par exemple, si la " +"classe a été rendue disponible dans la classe *SomeData* avec une portée " +"globale ::" #: howto/enum.rst:532 msgid "The complete signature is::" -msgstr "" +msgstr "La signature complète est ::" #: howto/enum.rst:0 msgid "value" -msgstr "" +msgstr "*value*" +# suit un : #: howto/enum.rst:544 msgid "What the new enum class will record as its name." -msgstr "" +msgstr "ce que la nouvelle classe *enum* enregistre comme nom." #: howto/enum.rst:0 msgid "names" -msgstr "" +msgstr "*names*" +# suit un : #: howto/enum.rst:546 msgid "" "The enum members. This can be a whitespace- or comma-separated string " "(values will start at 1 unless otherwise specified)::" msgstr "" +"les membres de l'énumération. Il peut s'agir d'une chaîne séparée par des " +"espaces ou des virgules (les valeurs commencent à 1 sauf indication " +"contraire) ::" #: howto/enum.rst:551 msgid "or an iterator of names::" -msgstr "" +msgstr "ou un itérateur sur des noms ::" #: howto/enum.rst:555 msgid "or an iterator of (name, value) pairs::" -msgstr "" +msgstr "ou un itérateur sur des paires (nom, valeur) ::" #: howto/enum.rst:559 msgid "or a mapping::" -msgstr "" +msgstr "ou un tableau de correspondances ::" #: howto/enum.rst:0 msgid "module" -msgstr "" +msgstr "*module*" #: howto/enum.rst:563 msgid "name of module where new enum class can be found." -msgstr "" +msgstr "nom du module où la nouvelle classe *enum* peut être trouvée." #: howto/enum.rst:0 msgid "qualname" -msgstr "" +msgstr "*qualname*" #: howto/enum.rst:565 msgid "where in module new enum class can be found." msgstr "" +"à quel endroit dans le module la nouvelle classe *enum* peut être trouvée." #: howto/enum.rst:0 msgid "type" -msgstr "" +msgstr "*type*" #: howto/enum.rst:567 msgid "type to mix in to new enum class." -msgstr "" +msgstr "types à mélanger avec la nouvelle classe *enum*." #: howto/enum.rst:0 msgid "start" -msgstr "" +msgstr "*start*" #: howto/enum.rst:569 msgid "number to start counting at if only names are passed in." msgstr "" +"nombre à partir duquel commencer à compter si seuls les noms sont transmis." +# suit un : #: howto/enum.rst:571 msgid "The *start* parameter was added." -msgstr "" +msgstr "le paramètre *start* a été ajouté." #: howto/enum.rst:576 msgid "Derived Enumerations" -msgstr "" +msgstr "Déclinaisons d'énumérations" #: howto/enum.rst:579 msgid "IntEnum" -msgstr "" +msgstr "*IntEnum*" #: howto/enum.rst:581 msgid "" @@ -505,21 +680,29 @@ msgid "" "extension, integer enumerations of different types can also be compared to " "each other::" msgstr "" +"La première variante de :class:`Enum` fournie est également une sous-classe " +"de :class:`int`. Les membres d'une :class:`IntEnum` peuvent être comparés à " +"des entiers ; par extension, des énumérations *IntEnum* de différents types " +"peuvent aussi être comparées ::" #: howto/enum.rst:602 msgid "" "However, they still can't be compared to standard :class:`Enum` " "enumerations::" msgstr "" +"Cependant, elles ne peuvent toujours pas être comparées aux énumérations " +"classiques :class:`Enum` ::" #: howto/enum.rst:615 msgid "" ":class:`IntEnum` values behave like integers in other ways you'd expect::" msgstr "" +"Les valeurs :class:`IntEnum` se comportent comme des entiers, comme vous " +"pouvez vous y attendre ::" #: howto/enum.rst:626 msgid "StrEnum" -msgstr "" +msgstr "*StrEnum*" #: howto/enum.rst:628 msgid "" @@ -528,10 +711,14 @@ msgid "" "by extension, string enumerations of different types can also be compared to " "each other." msgstr "" +"La deuxième variante de :class:`Enum` fournie est également une sous-classe " +"de :class:`str`. Les membres d'une :class:`StrEnum` peuvent être comparés à " +"des chaînes ; par extension, les énumérations *StrEnum* de différents types " +"peuvent également être comparées les unes aux autres." #: howto/enum.rst:637 msgid "IntFlag" -msgstr "" +msgstr "*IntFlag*" #: howto/enum.rst:639 msgid "" @@ -542,32 +729,48 @@ msgid "" "`IntFlag` members are also integers and can be used wherever an :class:`int` " "is used." msgstr "" +"La variante suivante fournie d':class:`Enum` est :class:`IntFlag`, également " +"basée sur :class:`int`. La différence étant que les membres :class:`IntFlag` " +"peuvent être combinés à l'aide des opérateurs bit-à-bit (&, \\|, ^, ~) et le " +"résultat est toujours un membre :class:`IntFlag`, si possible. Comme :class:" +"`IntEnum`, les membres de :class:`IntFlag` sont aussi des entiers et peuvent " +"être utilisés partout où on utilise un :class:`int`." +# suit un : #: howto/enum.rst:647 msgid "" "Any operation on an :class:`IntFlag` member besides the bit-wise operations " "will lose the :class:`IntFlag` membership." msgstr "" +"toute opération sur un membre :class:`IntFlag`, en dehors des opérations bit-" +"à-bit, fait perdre l'appartenance à :class:`IntFlag`." #: howto/enum.rst:650 msgid "" "Bit-wise operations that result in invalid :class:`IntFlag` values will lose " "the :class:`IntFlag` membership. See :class:`FlagBoundary` for details." msgstr "" +"Les opérations bit-à-bit qui entraînent des valeurs :class:`IntFlag` " +"invalides font perdre l'appartenance à :class:`IntFlag`. Voir :class:" +"`FlagBoundary` pour plus de détails." #: howto/enum.rst:657 msgid "Sample :class:`IntFlag` class::" -msgstr "" +msgstr "Classe exemple dérivée d':class:`Intflag` ::" #: howto/enum.rst:673 msgid "It is also possible to name the combinations::" -msgstr "" +msgstr "Il est également possible de nommer les combinaisons ::" +# suit un : #: howto/enum.rst:689 msgid "" "Named combinations are considered aliases. Aliases do not show up during " "iteration, but can be returned from by-value lookups." msgstr "" +"les combinaisons nommées sont considérées être des synonymes (ou alias). Les " +"synonymes n'apparaissent pas dans une itération, mais peuvent être renvoyés " +"à partir de recherches par valeur." #: howto/enum.rst:694 msgid "" @@ -575,26 +778,35 @@ msgid "" "that if no flags are set (the value is 0), its boolean evaluation is :data:" "`False`::" msgstr "" +"Une autre différence importante entre :class:`IntFlag` et :class:`Enum` est " +"que si aucun indicateur n'est défini (la valeur est 0), son évaluation " +"booléenne est :data:`False` ::" #: howto/enum.rst:702 msgid "" "Because :class:`IntFlag` members are also subclasses of :class:`int` they " "can be combined with them (but may lose :class:`IntFlag` membership::" msgstr "" +"Comme les membres d'une :class:`IntFlag` sont aussi des sous-classes de :" +"class:`int`, ils peuvent être combinés avec eux (mais peuvent alors perdre " +"l'appartenance à :class:`IntFlag`) ::" +# suit un : #: howto/enum.rst:713 msgid "" "The negation operator, ``~``, always returns an :class:`IntFlag` member with " "a positive value::" msgstr "" +"l'opérateur de négation, ``~``, renvoie toujours un membre :class:`IntFlag` " +"avec une valeur positive ::" #: howto/enum.rst:719 msgid ":class:`IntFlag` members can also be iterated over::" -msgstr "" +msgstr "On peut aussi itérer sur les membres d'une :class:`IntFlag` ::" #: howto/enum.rst:728 msgid "Flag" -msgstr "" +msgstr "*Flag*" #: howto/enum.rst:730 msgid "" @@ -605,29 +817,45 @@ msgid "" "specify the values directly it is recommended to use :class:`auto` as the " "value and let :class:`Flag` select an appropriate value." msgstr "" +"La dernière variante est :class:`Flag`. Comme :class:`IntFlag`, les membres " +"de :class:`Flag` peuvent être combinés à l'aide des opérateurs bit-à-bit (&, " +"\\|, ^, ~). Contrairement à :class:`IntFlag`, ils ne peuvent être combinés " +"ni comparés à aucune autre énumération :class:`Flag`, ni à :class:`int`. " +"Bien qu'il soit possible de spécifier les valeurs directement, il est " +"recommandé d'utiliser :class:`auto` comme valeur et de laisser :class:`Flag` " +"sélectionner une valeur appropriée." #: howto/enum.rst:739 msgid "" "Like :class:`IntFlag`, if a combination of :class:`Flag` members results in " "no flags being set, the boolean evaluation is :data:`False`::" msgstr "" +"Comme pour :class:`IntFlag`, si une combinaison de membres :class:`Flag` " +"entraîne qu'aucun indicateur n'est défini, l'évaluation booléenne est :data:" +"`False` ::" #: howto/enum.rst:753 msgid "" "Individual flags should have values that are powers of two (1, 2, 4, " "8, ...), while combinations of flags won't::" msgstr "" +"Les indicateurs individuels doivent avoir des valeurs qui sont des " +"puissances de deux (1, 2, 4, 8…), tandis que les combinaisons d'indicateurs " +"ne le sont pas ::" #: howto/enum.rst:765 msgid "" "Giving a name to the \"no flags set\" condition does not change its boolean " "value::" msgstr "" +"Donner un nom à la condition « aucun indicateur défini » ne change pas sa " +"valeur booléenne ::" #: howto/enum.rst:779 msgid ":class:`Flag` members can also be iterated over::" -msgstr "" +msgstr "On peut aussi itérer sur les membres d'une :class:`Flag` ::" +# suit un : #: howto/enum.rst:789 msgid "" "For the majority of new code, :class:`Enum` and :class:`Flag` are strongly " @@ -638,16 +866,26 @@ msgid "" "will not do; for example, when integer constants are replaced with " "enumerations, or for interoperability with other systems." msgstr "" +"pour la majorité du code nouveau, :class:`Enum` et :class:`Flag` sont " +"fortement recommandées, car :class:`IntEnum` et :class:`IntFlag` brisent " +"certaines promesses sémantiques d'une énumération (en pouvant être comparées " +"à des entiers et donc, par transitivité, à d'autres énumérations sans " +"rapport). :class:`IntEnum` et :class:`IntFlag` ne doivent être utilisées que " +"dans les cas où :class:`Enum` et :class:`Flag` ne suffisent pas ; par " +"exemple, lorsque des constantes entières sont remplacées par des " +"énumérations, ou pour l'interopérabilité avec d'autres systèmes." #: howto/enum.rst:799 msgid "Others" -msgstr "" +msgstr "Autres énumérations" #: howto/enum.rst:801 msgid "" "While :class:`IntEnum` is part of the :mod:`enum` module, it would be very " "simple to implement independently::" msgstr "" +"Bien que :class:`IntEnum` fasse partie du module :mod:`enum`, il serait très " +"simple de l'implémenter indépendamment ::" #: howto/enum.rst:807 msgid "" @@ -655,10 +893,13 @@ msgid "" "example a :class:`FloatEnum` that mixes in :class:`float` instead of :class:" "`int`." msgstr "" +"Ceci montre comment définir des énumérations dérivées similaires ; par " +"exemple une :class:`FloatEnum` qui utilise :class:`float` au lieu de :class:" +"`int`." #: howto/enum.rst:810 msgid "Some rules:" -msgstr "" +msgstr "Quelques règles :" #: howto/enum.rst:812 msgid "" @@ -666,6 +907,9 @@ msgid "" "`Enum` itself in the sequence of bases, as in the :class:`IntEnum` example " "above." msgstr "" +"Lorsque vous dérivez :class:`Enum`, les classes mères mélangées doivent " +"apparaître avant :class:`Enum` elle-même dans la liste des classes mères, " +"comme dans l'exemple :class:`IntEnum` ci-dessus." #: howto/enum.rst:815 msgid "" @@ -673,6 +917,10 @@ msgid "" "`range` are not subclassable and will throw an error during Enum creation if " "used as the mix-in type." msgstr "" +"Les types mélangés doivent pouvoir être sous-classés. Par exemple, :class:" +"`bool` et :class:`range` ne peuvent pas être sous-classés et génèrent une " +"erreur lors de la création d'une énumération s'ils sont utilisés comme type " +"de mélange." #: howto/enum.rst:818 msgid "" @@ -681,6 +929,11 @@ msgid "" "`int` above. This restriction does not apply to mix-ins which only add " "methods and don't specify another type." msgstr "" +"Alors qu':class:`Enum` peut avoir des membres de n'importe quel type, une " +"fois que vous avez mélangé un type supplémentaire, tous les membres doivent " +"avoir des valeurs de ce type, par exemple :class:`int` ci-dessus. Cette " +"restriction ne s'applique pas aux classes de mélange qui ajoutent uniquement " +"des méthodes et ne spécifient pas d'autre type." #: howto/enum.rst:822 msgid "" @@ -688,6 +941,9 @@ msgid "" "same* as the enum member itself, although it is equivalent and will compare " "equal." msgstr "" +"Lorsqu'un autre type de données est mélangé, l'attribut :attr:`value` n'est " +"*pas le même* que le membre de l'énumération en tant que tel, bien qu'il " +"soit équivalent et renvoie égal lors d'une comparaison." #: howto/enum.rst:825 msgid "" @@ -695,23 +951,34 @@ msgid "" "`__str__` and :meth:`__repr__` respectively; other codes (such as ``%i`` or " "``%h`` for IntEnum) treat the enum member as its mixed-in type." msgstr "" +"Formatage de style % : ``%s`` et ``%r`` appellent respectivement les " +"méthodes :meth:`__str__` et :meth:`__repr__` de la classe :class:`Enum` ; " +"d'autres codes (tels que ``%i`` ou ``%h`` pour *IntEnum*) traitent le membre " +"de l’énumération comme son type mélangé." #: howto/enum.rst:828 msgid "" ":ref:`Formatted string literals `, :meth:`str.format`, and :func:" "`format` will use the enum's :meth:`__str__` method." msgstr "" +":ref:`Les littéraux de chaîne formatés `, :meth:`str.format` et :" +"func:`format` utilisent la méthode :meth:`__str__` de l'énumération." +# suit un : #: howto/enum.rst:833 msgid "" "Because :class:`IntEnum`, :class:`IntFlag`, and :class:`StrEnum` are " "designed to be drop-in replacements for existing constants, their :meth:" "`__str__` method has been reset to their data types :meth:`__str__` method." msgstr "" +"étant donné que :class:`IntEnum`, :class:`IntFlag` et :class:`StrEnum` sont " +"conçus pour remplacer des constantes existantes, leur méthode :meth:" +"`__str__` a été réinitialisée à la méthode :meth:`__str__` de leur type de " +"donnée." #: howto/enum.rst:839 msgid "When to use :meth:`__new__` vs. :meth:`__init__`" -msgstr "" +msgstr "Utilisation de :meth:`__new__` ou de :meth:`__init__`" #: howto/enum.rst:841 msgid "" @@ -719,26 +986,35 @@ msgid "" "of the :class:`Enum` member. Any other modifications may go in either :meth:" "`__new__` or :meth:`__init__`, with :meth:`__init__` being preferred." msgstr "" +":meth:`__new__` doit être utilisée chaque fois que vous souhaitez " +"personnaliser la valeur réelle des membres d'une :class:`Enum`. Pour les " +"autres personnalisations, elles peuvent être définies dans :meth:`__new__` " +"ou :meth:`__init__`, avec une préférence pour :meth:`__init__`." #: howto/enum.rst:845 msgid "" "For example, if you want to pass several items to the constructor, but only " "want one of them to be the value::" msgstr "" +"Par exemple, si vous souhaitez passer plusieurs éléments au constructeur, " +"mais que vous souhaitez qu'un seul d'entre eux soit la valeur ::" #: howto/enum.rst:872 msgid "Finer Points" -msgstr "" +msgstr "Approfondissements" #: howto/enum.rst:875 msgid "Supported ``__dunder__`` names" -msgstr "" +msgstr "Noms de la forme ``__dunder__`` disponibles" #: howto/enum.rst:877 msgid "" ":attr:`__members__` is a read-only ordered mapping of ``member_name``:" "``member`` items. It is only available on the class." msgstr "" +":attr:`__members__` est un dictionnaire ordonné d'éléments en lecture seule " +"de la forme ``nom_du_membre`` : ``membre``. Il n'est disponible que dans la " +"classe." #: howto/enum.rst:880 msgid "" @@ -746,25 +1022,33 @@ msgid "" "is also a very good idea to set the member's :attr:`_value_` appropriately. " "Once all the members are created it is no longer used." msgstr "" +"La méthode :meth:`__new__`, si elle est définie, doit créer et renvoyer les " +"membres de l'énumération ; affecter correctement l'attribut :attr:`_value_` " +"du membre est également conseillé. Une fois que tous les membres ont été " +"créés, cette méthode n'est plus utilisée." #: howto/enum.rst:886 msgid "Supported ``_sunder_`` names" -msgstr "" +msgstr "Noms de la forme ``_sunder_`` disponibles" #: howto/enum.rst:888 msgid "``_name_`` -- name of the member" -msgstr "" +msgstr "``_name_`` — nom du membre" #: howto/enum.rst:889 msgid "" "``_value_`` -- value of the member; can be set / modified in ``__new__``" msgstr "" +"``_value_`` — valeur du membre ; il est possible d'y accéder et de la " +"modifier dans ``__new__``" #: howto/enum.rst:891 msgid "" "``_missing_`` -- a lookup function used when a value is not found; may be " "overridden" msgstr "" +"``_missing_`` — fonction de recherche qui est appelée quand la valeur n'est " +"pas trouvée ; elle peut être surchargée" #: howto/enum.rst:893 msgid "" @@ -772,38 +1056,52 @@ msgid "" "`str`, that will not be transformed into members, and will be removed from " "the final class" msgstr "" +"``_ignore_`` — liste de noms, sous la forme d'une :func:`list` ou d'une :" +"func:`str`, qui ne sont pas convertis en membres et sont supprimés de la " +"classe résultante" #: howto/enum.rst:896 msgid "" "``_order_`` -- used in Python 2/3 code to ensure member order is consistent " "(class attribute, removed during class creation)" msgstr "" +"``_order_`` — utilisé en Python 2 ou 3 pour s'assurer que l'ordre des " +"membres est cohérent (attribut de classe, supprimé durant la création de la " +"classe)" #: howto/enum.rst:898 msgid "" "``_generate_next_value_`` -- used by the `Functional API`_ and by :class:" "`auto` to get an appropriate value for an enum member; may be overridden" msgstr "" +"``_generate_next_value_`` — utilisé par l'`API fonctionnelle`_ et par :class:" +"`auto` pour obtenir une valeur appropriée pour un membre de l'énumération ; " +"elle peut être surchargée" +# suit un : #: howto/enum.rst:904 msgid "" "For standard :class:`Enum` classes the next value chosen is the last value " "seen incremented by one." msgstr "" +"pour les classes standard :class:`Enum`, la valeur choisie suivante est la " +"dernière valeur vue incrémentée de un." #: howto/enum.rst:907 msgid "" "For :class:`Flag` classes the next value chosen will be the next highest " "power-of-two, regardless of the last value seen." msgstr "" +"Pour les classes :class:`Flag`, la valeur choisie suivante est la prochaine " +"puissance de deux la plus élevée, quelle que soit la dernière valeur vue." #: howto/enum.rst:910 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" -msgstr "" +msgstr "``_missing_``, ``_order_``, ``_generate_next_value_``" #: howto/enum.rst:911 msgid "``_ignore_``" -msgstr "" +msgstr "``_ignore_``" #: howto/enum.rst:913 msgid "" @@ -811,26 +1109,34 @@ msgid "" "can be provided. It will be checked against the actual order of the " "enumeration and raise an error if the two do not match::" msgstr "" +"Pour aider à garder le code Python 2 / Python 3 synchronisé, un attribut :" +"attr:`_order_` peut être fourni. Il est vérifié par rapport à l'ordre réel " +"de l'énumération et lève une erreur si les deux ne correspondent pas ::" +# suit un : #: howto/enum.rst:931 msgid "" "In Python 2 code the :attr:`_order_` attribute is necessary as definition " "order is lost before it can be recorded." msgstr "" +"dans le code Python 2, l'attribut :attr:`_order_` est nécessaire car l'ordre " +"de définition est perdu avant de pouvoir être enregistré." #: howto/enum.rst:936 msgid "_Private__names" -msgstr "" +msgstr "*_Private__names*" #: howto/enum.rst:938 msgid "" ":ref:`Private names ` are not converted to enum " "members, but remain normal attributes." msgstr "" +":ref:`Les noms privés ` ne sont pas convertis en " +"membres de l'énumération, mais restent des attributs normaux." #: howto/enum.rst:945 msgid "``Enum`` member type" -msgstr "" +msgstr "Types des membres d'une ``Enum``" #: howto/enum.rst:947 msgid "" @@ -839,10 +1145,15 @@ msgid "" "access members from other members -- this practice was discouraged, and in " "``3.11`` :class:`Enum` returns to not allowing it::" msgstr "" +"Les membres d'une énumération sont des instances de leur classe *Enum* et " +"sont normalement accessibles en tant que ``ClasseEnum.membre``. Dans les " +"versions Python ``3.5`` à ``3.10``, vous pouviez accéder aux membres à " +"partir d'autres membres — cette pratique était déconseillée et dans " +"``3.11`` :class:`Enum` ne l'autorise pas ::" #: howto/enum.rst:968 msgid "Creating members that are mixed with other data types" -msgstr "" +msgstr "Création de membres mélangés avec d'autres types de données" #: howto/enum.rst:970 msgid "" @@ -850,10 +1161,13 @@ msgid "" "with an :class:`Enum`, all values after the ``=`` are passed to that data " "type's constructor. For example::" msgstr "" +"Lorsque vous dérivez d'autres types de données, tels que :class:`int` ou :" +"class:`str`, avec une :class:`Enum`, toutes les valeurs après ``=`` sont " +"passées au constructeur de ce type de données. Par exemple ::" #: howto/enum.rst:982 msgid "Boolean value of ``Enum`` classes and members" -msgstr "" +msgstr "Valeur booléenne des classes et membres ``Enum``" #: howto/enum.rst:984 msgid "" @@ -863,14 +1177,20 @@ msgid "" "enum's boolean evaluation depend on the member's value add the following to " "your class::" msgstr "" +"Les classes *Enum* mélangées avec des types non-:class:`Enum` (tels que :" +"class:`int`, :class:`str`, etc.) sont évaluées selon les règles du type " +"mélangé ; sinon, tous les membres sont évalués comme :data:`True`. Pour que " +"l'évaluation booléenne de votre propre énumération dépende de la valeur du " +"membre, ajoutez ce qui suit à votre classe ::" #: howto/enum.rst:993 msgid "Plain :class:`Enum` classes always evaluate as :data:`True`." msgstr "" +"Les classes simples :class:`Enum` sont toujours évaluées comme :data:`True`." #: howto/enum.rst:997 msgid "``Enum`` classes with methods" -msgstr "" +msgstr "Méthodes dans les classes ``Enum``" #: howto/enum.rst:999 msgid "" @@ -878,100 +1198,123 @@ msgid "" "below, those methods will show up in a :func:`dir` of the member, but not of " "the class::" msgstr "" +"Si vous dotez votre sous-classe énumération de méthodes supplémentaires, " +"comme la classe `Planet`_ ci-dessous, ces méthodes apparaissent dans le :" +"func:`dir` des membres, mais pas dans celui de la classe ::" #: howto/enum.rst:1010 msgid "Combining members of ``Flag``" -msgstr "" +msgstr "Combinaisons de membres de ``Flag``" #: howto/enum.rst:1012 msgid "" "Iterating over a combination of :class:`Flag` members will only return the " "members that are comprised of a single bit::" msgstr "" +"L'itération sur une combinaison de membres :class:`Flag` ne renvoie que les " +"membres dont un seul bit est à 1 ::" #: howto/enum.rst:1030 msgid "``Flag`` and ``IntFlag`` minutia" -msgstr "" +msgstr "Précisions sur ``Flag`` et ``IntFlag``" #: howto/enum.rst:1032 msgid "Using the following snippet for our examples::" -msgstr "" +msgstr "En utilisant l'extrait suivant pour nos exemples ::" #: howto/enum.rst:1043 msgid "the following are true:" -msgstr "" +msgstr "ce qui suit est vrai :" #: howto/enum.rst:1045 msgid "single-bit flags are canonical" -msgstr "" +msgstr "les membres dont un seul bit est à 1 sont canoniques ;" #: howto/enum.rst:1046 msgid "multi-bit and zero-bit flags are aliases" -msgstr "" +msgstr "ceux qui ont plusieurs bits à 1 ou aucun bit à 1 sont des synonymes ;" #: howto/enum.rst:1047 msgid "only canonical flags are returned during iteration::" -msgstr "" +msgstr "seuls les membres canoniques sont renvoyés pendant une itération ::" #: howto/enum.rst:1052 msgid "" "negating a flag or flag set returns a new flag/flag set with the " "corresponding positive integer value::" msgstr "" +"la négation d'un membre ou d'une composition de membres renvoie un nouveau " +"membre (ou composition de membres) avec la valeur entière positive " +"correspondante ::" #: howto/enum.rst:1061 msgid "names of pseudo-flags are constructed from their members' names::" msgstr "" +"les noms des pseudo-membres sont construits à partir des noms de leurs " +"membres ::" #: howto/enum.rst:1066 msgid "multi-bit flags, aka aliases, can be returned from operations::" msgstr "" +"les membres avec plusieurs bits à 1 (des alias) peuvent être renvoyés par " +"les opérations ::" #: howto/enum.rst:1077 msgid "" "membership / containment checking: zero-valued flags are always considered " "to be contained::" msgstr "" +"pour la vérification d'appartenance, les membres dont la valeur est 0 sont " +"toujours considérés comme étant membres ::" #: howto/enum.rst:1083 msgid "" "otherwise, only if all bits of one flag are in the other flag will True be " "returned::" msgstr "" +"sinon, seulement si tous les bits à 1 d'un membre sont aussi à 1 dans " +"l'autre membre, renvoie *True* ::" #: howto/enum.rst:1092 msgid "" "There is a new boundary mechanism that controls how out-of-range / invalid " "bits are handled: ``STRICT``, ``CONFORM``, ``EJECT``, and ``KEEP``:" msgstr "" +"Il existe un nouveau mécanisme de délimitation qui contrôle la façon dont " +"les bits hors plage/invalides sont gérés : ``STRICT``, ``CONFORM``, " +"``EJECT`` et ``KEEP`` :" #: howto/enum.rst:1095 msgid "STRICT --> raises an exception when presented with invalid values" msgstr "" +"*STRICT* --> lève une exception lorsqu'on lui présente des valeurs invalides" #: howto/enum.rst:1096 msgid "CONFORM --> discards any invalid bits" -msgstr "" +msgstr "*CONFORM* --> ignore les bits invalides" #: howto/enum.rst:1097 msgid "EJECT --> lose Flag status and become a normal int with the given value" msgstr "" +"*EJECT* --> la valeur présentée perd le statut de membre et devient un " +"entier normal" #: howto/enum.rst:1101 msgid "KEEP --> keep the extra bits" -msgstr "" +msgstr "*KEEP* --> garde les bits supplémentaires" #: howto/enum.rst:1099 msgid "keeps Flag status and extra bits" -msgstr "" +msgstr "garde le statut de membre avec les bits supplémentaires" #: howto/enum.rst:1100 msgid "extra bits do not show up in iteration" -msgstr "" +msgstr "les bits supplémentaires ne sont pas produits dans une itération" #: howto/enum.rst:1101 msgid "extra bits do show up in repr() and str()" msgstr "" +"les bits supplémentaires ne sont pas représentés par *repr()* et *str()*" #: howto/enum.rst:1103 msgid "" @@ -979,20 +1322,26 @@ msgid "" "``EJECT``, and the default for ``_convert_`` is ``KEEP`` (see ``ssl." "Options`` for an example of when ``KEEP`` is needed)." msgstr "" +"La valeur par défaut pour *Flag* est ``STRICT``, la valeur par défaut pour " +"``IntFlag`` est ``EJECT`` et la valeur par défaut pour ``_convert_`` est " +"``KEEP`` (voir ``ssl.Options`` pour un exemple de cas où ``KEEP`` est " +"nécessaire)." #: howto/enum.rst:1111 msgid "How are Enums different?" -msgstr "" +msgstr "En quoi les énumérations sont-elles différentes ?" #: howto/enum.rst:1113 msgid "" "Enums have a custom metaclass that affects many aspects of both derived :" "class:`Enum` classes and their instances (members)." msgstr "" +"Les énumérations ont une métaclasse personnalisée qui modifie de nombreux " +"aspects des classes dérivées d':class:`Enum` et de leurs instances (membres)." #: howto/enum.rst:1118 msgid "Enum Classes" -msgstr "" +msgstr "Classes *Enum*" #: howto/enum.rst:1120 msgid "" @@ -1004,10 +1353,17 @@ msgid "" "`Enum` class are correct (such as :meth:`__new__`, :meth:`__getnewargs__`, :" "meth:`__str__` and :meth:`__repr__`)." msgstr "" +"La métaclasse :class:`EnumType` est chargée de fournir :meth:" +"`__contains__`, :meth:`__dir__`, :meth:`__iter__` et d'autres méthodes qui " +"permettent de faire des choses avec une classe :class:`Enum` et qui échouent " +"sur une classe typique, telle que `list(Color)` ou `une_variable_enum in " +"Color`. :class:`EnumType` est chargée de s'assurer que diverses autres " +"méthodes de la classe finale :class:`Enum` sont correctes (telles que :meth:" +"`__new__`, :meth:`__getnewargs__`, :meth:`__str__` et :meth:`__repr__`)." #: howto/enum.rst:1130 msgid "Enum Members (aka instances)" -msgstr "" +msgstr "Membres d'une *Enum* (les instances)" #: howto/enum.rst:1132 msgid "" @@ -1017,6 +1373,11 @@ msgid "" "new ones are ever instantiated by returning only the existing member " "instances." msgstr "" +"Le plus intéressant à propos des membres d'une énumération est que ce sont " +"des singletons. :class:`EnumType` les crée tous pendant qu'il crée la classe " +"*enum* elle-même, puis met en place une méthode :meth:`__new__` " +"personnalisée pour s'assurer qu'aucun nouveau membre n'est jamais instancié " +"(en renvoyant uniquement les instances de membres existantes)." #: howto/enum.rst:1141 msgid "" @@ -1025,34 +1386,44 @@ msgid "" "cover them all. Here are recipes for some different types of enumerations " "that can be used directly, or as examples for creating one's own." msgstr "" +":class:`Enum`, :class:`IntEnum`, :class:`StrEnum`, :class:`Flag` et :class:" +"`IntFlag` sont censées couvrir la majorité des cas d'utilisation, mais elles " +"ne peuvent pas tout couvrir. Voici quelques recettes pour différents types " +"d'énumérations qui peuvent être utilisées directement, ou pour servir " +"d'exemples afin de créer les vôtres." #: howto/enum.rst:1148 msgid "Omitting values" -msgstr "" +msgstr "Omission de valeurs" #: howto/enum.rst:1150 msgid "" "In many use-cases, one doesn't care what the actual value of an enumeration " "is. There are several ways to define this type of simple enumeration:" msgstr "" +"Dans de nombreux cas d'utilisation, on ne se soucie pas de la valeur réelle " +"d'une énumération. Il existe plusieurs manières de définir ce type " +"d'énumération simple :" #: howto/enum.rst:1153 msgid "use instances of :class:`auto` for the value" -msgstr "" +msgstr "utilisez des instances d':class:`auto` pour la valeur ;" #: howto/enum.rst:1154 msgid "use instances of :class:`object` as the value" -msgstr "" +msgstr "utilisez des instances d':class:`object` comme valeur ;" #: howto/enum.rst:1155 msgid "use a descriptive string as the value" -msgstr "" +msgstr "utilisez une chaîne de caractères descriptive comme valeur ;" #: howto/enum.rst:1156 msgid "" "use a tuple as the value and a custom :meth:`__new__` to replace the tuple " "with an :class:`int` value" msgstr "" +"utilisez un *n*-uplet comme valeur et une :meth:`__new__` personnalisée pour " +"remplacer le *n*-uplet par une valeur :class:`int`." #: howto/enum.rst:1159 msgid "" @@ -1060,56 +1431,65 @@ msgid "" "important, and also enables one to add, remove, or reorder members without " "having to renumber the remaining members." msgstr "" +"L'utilisation de l'une de ces méthodes signifie au lecteur que ces valeurs " +"ne sont pas importantes et permet également d'ajouter, de supprimer ou de " +"réorganiser des membres sans avoir à renuméroter les autres membres." #: howto/enum.rst:1165 msgid "Using :class:`auto`" -msgstr "" +msgstr "Utilisation d':class:`auto`" #: howto/enum.rst:1167 msgid "Using :class:`auto` would look like::" -msgstr "" +msgstr "Voici un exemple où nous utilisons :class:`auto` ::" #: howto/enum.rst:1179 msgid "Using :class:`object`" -msgstr "" +msgstr "Utilisation d':class:`object`" #: howto/enum.rst:1181 msgid "Using :class:`object` would look like::" -msgstr "" +msgstr "Voici un exemple où nous utilisons :class:`object` ::" #: howto/enum.rst:1191 msgid "" "This is also a good example of why you might want to write your own :meth:" "`__repr__`::" msgstr "" +"Voici un bon exemple montrant pourquoi vouloir écrire sa propre :meth:" +"`__repr__` ::" #: howto/enum.rst:1207 msgid "Using a descriptive string" -msgstr "" +msgstr "Utilisation d'une chaîne de caractères descriptive" #: howto/enum.rst:1209 msgid "Using a string as the value would look like::" -msgstr "" +msgstr "Voici un exemple où nous utilisons une chaîne de caractères ::" #: howto/enum.rst:1221 msgid "Using a custom :meth:`__new__`" -msgstr "" +msgstr "Utilisation d'une méthode :meth:`__new__` personnalisée" #: howto/enum.rst:1223 msgid "Using an auto-numbering :meth:`__new__` would look like::" -msgstr "" +msgstr "Cette méthode :meth:`__new__` numérote automatiquement :" #: howto/enum.rst:1240 msgid "" "To make a more general purpose ``AutoNumber``, add ``*args`` to the " "signature::" msgstr "" +"Pour créer une ``AutoNumber`` plus générale, ajoutons ``*args`` à la " +"signature ::" #: howto/enum.rst:1250 msgid "" "Then when you inherit from ``AutoNumber`` you can write your own " "``__init__`` to handle any extra arguments::" msgstr "" +"Ensuite, lorsque nous héritons de ``AutoNumber``, nous pouvons écrire notre " +"propre ``__init__`` pour gérer les arguments supplémentaires ::" #: howto/enum.rst:1269 msgid "" @@ -1117,10 +1497,14 @@ msgid "" "members; it is then replaced by Enum's :meth:`__new__` which is used after " "class creation for lookup of existing members." msgstr "" +"la méthode :meth:`__new__`, si elle est définie, est utilisée lors de la " +"création des membres de l'énumération ; elle est ensuite remplacée par :meth:" +"`__new__` de l'*Enum* qui est utilisée après la création de la classe pour " +"la recherche des membres existants." #: howto/enum.rst:1275 msgid "OrderedEnum" -msgstr "" +msgstr "Énumération ordonnée" #: howto/enum.rst:1277 msgid "" @@ -1128,45 +1512,58 @@ msgid "" "maintains the normal :class:`Enum` invariants (such as not being comparable " "to other enumerations)::" msgstr "" +"Voici une énumération ordonnée qui n'est pas basée sur :class:`IntEnum` et " +"maintient donc les invariants normaux d':class:`Enum` (comme ne pas pouvoir " +"être comparée à d'autres énumérations) ::" #: howto/enum.rst:1311 msgid "DuplicateFreeEnum" -msgstr "" +msgstr "Énumération sans doublon" +# name est bien corrigé par value dans upstream #: howto/enum.rst:1313 msgid "" "Raises an error if a duplicate member name is found instead of creating an " "alias::" msgstr "" +"Lève une erreur si plusieurs membres ont la même valeur, au lieu de créer un " +"synonyme ::" +# suit un : #: howto/enum.rst:1338 msgid "" "This is a useful example for subclassing Enum to add or change other " "behaviors as well as disallowing aliases. If the only desired change is " "disallowing aliases, the :func:`unique` decorator can be used instead." msgstr "" +"c'est un exemple utile de dérivation d'*Enum* pour ajouter ou modifier " +"d'autres comportements ainsi que pour interdire les synonymes. Si le seul " +"changement souhaité est l'interdiction des synonymes, le décorateur :func:" +"`unique` peut être utilisé à la place." #: howto/enum.rst:1344 msgid "Planet" -msgstr "" +msgstr "Planète" #: howto/enum.rst:1346 msgid "" "If :meth:`__new__` or :meth:`__init__` is defined, the value of the enum " "member will be passed to those methods::" msgstr "" +"Si :meth:`__new__` ou :meth:`__init__` est définie, la valeur du membre de " +"l'énumération est passée à ces méthodes ::" #: howto/enum.rst:1375 msgid "TimePeriod" -msgstr "" +msgstr "Intervalle de temps" #: howto/enum.rst:1377 msgid "An example to show the :attr:`_ignore_` attribute in use::" -msgstr "" +msgstr "Exemple pour montrer l'utilisation de l'attribut :attr:`_ignore_` ::" #: howto/enum.rst:1396 msgid "Subclassing EnumType" -msgstr "" +msgstr "Dérivations d'*EnumType*" #: howto/enum.rst:1398 msgid "" @@ -1174,3 +1571,7 @@ msgid "" "either with class decorators or custom functions, :class:`EnumType` can be " "subclassed to provide a different Enum experience." msgstr "" +"Alors que la plupart des besoins d'énumérations peuvent être satisfaits en " +"sous-classant :class:`Enum`, avec des décorateurs de classe ou des fonctions " +"personnalisées, :class:`EnumType` peut être dérivée pour créer des " +"énumérations vraiment différentes." diff --git a/library/enum.po b/library/enum.po index 16b984a4..8111a184 100644 --- a/library/enum.po +++ b/library/enum.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2022-05-22 23:13+0200\n" -"PO-Revision-Date: 2022-11-20 22:26+0100\n" +"PO-Revision-Date: 2023-01-07 22:57+0100\n" "Last-Translator: Antoine Wecxsteen\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" -"X-Generator: Poedit 2.4.2\n" +"X-Generator: Poedit 3.2.1\n" #: library/enum.rst:2 msgid ":mod:`enum` --- Support for enumerations" @@ -28,59 +28,64 @@ msgid "" "This page contains the API reference information. For tutorial information " "and discussion of more advanced topics, see" msgstr "" +"Cette page contient les informations de référence de l'API. Pour des " +"informations sur le didacticiel et une discussion sur des sujets plus " +"avancés, reportez-vous à" #: library/enum.rst:21 msgid ":ref:`Basic Tutorial `" -msgstr "" +msgstr ":ref:`Tutoriel de base `" #: library/enum.rst:22 msgid ":ref:`Advanced Tutorial `" -msgstr "" +msgstr ":ref:`Tutoriel avancé `" #: library/enum.rst:23 msgid ":ref:`Enum Cookbook `" -msgstr "" +msgstr ":ref:`Recettes pour les énumérations `" #: library/enum.rst:27 -#, fuzzy msgid "An enumeration:" -msgstr "Énumérations dérivées" +msgstr "Une énumération :" #: library/enum.rst:29 msgid "is a set of symbolic names (members) bound to unique values" msgstr "" +"est un ensemble de noms symboliques (appelés membres) liés à des valeurs " +"uniques," #: library/enum.rst:30 -#, fuzzy msgid "can be iterated over to return its members in definition order" msgstr "" -"Les énumérations sont itérables, l'ordre d'itération est celui dans lequel " -"les membres sont déclarés ::" +"peut être utilisée comme itérable et renvoie ses membres dans l'ordre de " +"définition," #: library/enum.rst:31 msgid "uses *call* syntax to return members by value" -msgstr "" +msgstr "utilise la syntaxe *d'appel* pour renvoyer les valeurs de ses membres," #: library/enum.rst:32 msgid "uses *index* syntax to return members by name" -msgstr "" +msgstr "utilise la syntaxe *d'indiçage* pour renvoyer les noms de ses membres." #: library/enum.rst:34 msgid "" "Enumerations are created either by using :keyword:`class` syntax, or by " "using function-call syntax::" msgstr "" +"Les énumérations sont créées soit en utilisant la syntaxe :keyword:`class`, " +"soit en utilisant la syntaxe d'appel de fonction ::" #: library/enum.rst:48 -#, fuzzy msgid "" "Even though we can use :keyword:`class` syntax to create Enums, Enums are " "not normal Python classes. See :ref:`How are Enums different? ` for more details." msgstr "" -"Même si on utilise la syntaxe en :keyword:`class` pour créer des " -"énumérations, les *Enums* ne sont pas des vraies classes Python. Voir `En " -"quoi les Enums sont différentes ?`_ pour plus de détails." +"Même si on peut utiliser la syntaxe :keyword:`class` pour créer des " +"énumérations, les *Enums* ne sont pas des vraies classes Python. Lisez :ref:" +"`En quoi les énumérations sont-elles différentes ? ` " +"pour plus de détails." #: library/enum.rst:52 msgid "Nomenclature" @@ -88,25 +93,25 @@ msgstr "Nomenclature" #: library/enum.rst:54 msgid "The class :class:`Color` is an *enumeration* (or *enum*)" -msgstr "La classe :class:`Color` est une *énumération* (ou un *enum*)." +msgstr "La classe :class:`Color` est une *énumération* (ou une *enum*)." #: library/enum.rst:55 -#, fuzzy msgid "" "The attributes :attr:`Color.RED`, :attr:`Color.GREEN`, etc., are " "*enumeration members* (or *members*) and are functionally constants." msgstr "" "Les attributs :attr:`Color.RED`, :attr:`Color.GREEN`, etc., sont les " -"*membres de l'énumération* (ou les *membres de l'enum*) et sont " -"fonctionnellement des constantes." +"*membres de l'énumération* (ou *membres*) et sont fonctionnellement des " +"constantes." #: library/enum.rst:57 msgid "" "The enum members have *names* and *values* (the name of :attr:`Color.RED` is " "``RED``, the value of :attr:`Color.BLUE` is ``3``, etc.)" msgstr "" -"Les membres de *l'enum* ont chacun un *nom* et une *valeur* ; le nom de :" -"attr:`Color.RED` est ``RED``, la valeur de :attr:`Color.BLUE` est ``3``, etc." +"Les membres de l’énumération ont chacun un *nom* et une *valeur* ; le nom " +"de :attr:`Color.RED` est ``RED``, la valeur de :attr:`Color.BLUE` est ``3``, " +"etc." #: library/enum.rst:64 msgid "Module Contents" @@ -114,55 +119,47 @@ msgstr "Contenu du module" #: library/enum.rst:66 msgid ":class:`EnumType`" -msgstr "" +msgstr ":class:`EnumType`" #: library/enum.rst:68 msgid "The ``type`` for Enum and its subclasses." -msgstr "" +msgstr "Le ``type`` d'*Enum* et de ses sous-classes." #: library/enum.rst:70 -#, fuzzy msgid ":class:`Enum`" -msgstr "Avec :class:`auto`" +msgstr ":class:`Enum`" #: library/enum.rst:72 -#, fuzzy msgid "Base class for creating enumerated constants." -msgstr "" -"Classe mère pour créer une énumération de constantes qui sont également des " -"sous-classes de :class:`int`." +msgstr "Classe mère pour créer une énumération de constantes." #: library/enum.rst:74 -#, fuzzy msgid ":class:`IntEnum`" -msgstr "IntEnum" +msgstr ":class:`IntEnum`" #: library/enum.rst:76 -#, fuzzy msgid "" "Base class for creating enumerated constants that are also subclasses of :" "class:`int`. (`Notes`_)" msgstr "" "Classe mère pour créer une énumération de constantes qui sont également des " -"sous-classes de :class:`int`." +"sous-classes de :class:`int` (`notes`_)." #: library/enum.rst:79 msgid ":class:`StrEnum`" -msgstr "" +msgstr ":class:`StrEnum`" #: library/enum.rst:81 -#, fuzzy msgid "" "Base class for creating enumerated constants that are also subclasses of :" "class:`str`. (`Notes`_)" msgstr "" "Classe mère pour créer une énumération de constantes qui sont également des " -"sous-classes de :class:`int`." +"sous-classes de :class:`str` (`notes`_)." #: library/enum.rst:84 -#, fuzzy msgid ":class:`Flag`" -msgstr "Avec :class:`auto`" +msgstr ":class:`Flag`" #: library/enum.rst:86 msgid "" @@ -174,12 +171,10 @@ msgstr "" "class:`Flag`." #: library/enum.rst:89 -#, fuzzy msgid ":class:`IntFlag`" -msgstr "Exemple d'une classe :class:`IntFlag` ::" +msgstr ":class:`IntFlag`" #: library/enum.rst:91 -#, fuzzy msgid "" "Base class for creating enumerated constants that can be combined using the " "bitwise operators without losing their :class:`IntFlag` membership. :class:" @@ -188,11 +183,11 @@ msgstr "" "Classe mère pour créer une énumération de constantes pouvant être combinées " "avec des opérateurs de comparaison bit-à-bit, sans perdre leur qualité de :" "class:`IntFlag`. Les membres de :class:`IntFlag` sont aussi des sous-classes " -"de :class:`int`." +"de :class:`int` (`notes`_)." #: library/enum.rst:95 msgid ":class:`EnumCheck`" -msgstr "" +msgstr ":class:`EnumCheck`" #: library/enum.rst:97 msgid "" @@ -200,10 +195,13 @@ msgid "" "``UNIQUE``, for use with :func:`verify` to ensure various constraints are " "met by a given enumeration." msgstr "" +"Énumération avec les valeurs ``CONTINUOUS``, ``NAMED_FLAGS`` et ``UNIQUE``, " +"à utiliser avec :func:`verify` pour s'assurer que diverses contraintes sont " +"satisfaites par une énumération donnée." #: library/enum.rst:101 msgid ":class:`FlagBoundary`" -msgstr "" +msgstr ":class:`FlagBoundary`" #: library/enum.rst:103 msgid "" @@ -211,35 +209,40 @@ msgid "" "``KEEP`` which allows for more fine-grained control over how invalid values " "are dealt with in an enumeration." msgstr "" +"Énumération avec les valeurs ``STRICT``, ``CONFORM``, ``EJECT`` et ``KEEP`` " +"qui permet un contrôle plus précis sur la façon dont les valeurs invalides " +"sont traitées dans une énumération." #: library/enum.rst:107 -#, fuzzy msgid ":class:`auto`" -msgstr "Avec :class:`auto`" +msgstr ":class:`auto`" #: library/enum.rst:109 -#, fuzzy msgid "" "Instances are replaced with an appropriate value for Enum members. :class:" "`StrEnum` defaults to the lower-cased version of the member name, while " "other Enums default to 1 and increase from there." msgstr "" "Les instances sont remplacées par une valeur appropriée pour les membres de " -"l'énumération. Par défaut, la valeur initiale démarre à 1." +"l'énumération. :class:`StrEnum` utilise par défaut la version minuscule du " +"nom du membre, tandis que les autres énumérations utilisent 1 par défaut et " +"puis augmentent." #: library/enum.rst:113 msgid ":func:`~enum.property`" -msgstr "" +msgstr ":func:`~enum.property`" #: library/enum.rst:115 msgid "" "Allows :class:`Enum` members to have attributes without conflicting with " "member names." msgstr "" +"Permet aux membres d'une :class:`Enum` d'avoir des attributs sans entrer en " +"conflit avec les noms des membres." #: library/enum.rst:118 msgid ":func:`unique`" -msgstr "" +msgstr ":func:`unique`" #: library/enum.rst:120 msgid "" @@ -250,32 +253,32 @@ msgstr "" #: library/enum.rst:122 msgid ":func:`verify`" -msgstr "" +msgstr ":func:`verify`" #: library/enum.rst:124 -#, fuzzy msgid "" "Enum class decorator that checks user-selectable constraints on an " "enumeration." msgstr "" -"Décorateur de classe qui garantit qu'une valeur ne puisse être associée qu'à " -"un seul nom." +"Décorateur de classe qui vérifie des contraintes personnalisées pour une " +"énumération." #: library/enum.rst:127 msgid ":func:`member`" -msgstr "" +msgstr ":func:`member`" #: library/enum.rst:129 msgid "Make ``obj`` a member. Can be used as a decorator." -msgstr "" +msgstr "Fait de ``obj`` un membre. Peut être utilisé comme décorateur." #: library/enum.rst:131 msgid ":func:`nonmember`" -msgstr "" +msgstr ":func:`nonmember`" #: library/enum.rst:133 msgid "Do not make ``obj`` a member. Can be used as a decorator." msgstr "" +"Fait que ``obj`` n'est pas un membre. Peut être utilisé comme décorateur." #: library/enum.rst:136 msgid "``Flag``, ``IntFlag``, ``auto``" @@ -283,15 +286,15 @@ msgstr "``Flag``, ``IntFlag``, ``auto``" #: library/enum.rst:137 msgid "``StrEnum``, ``EnumCheck``, ``FlagBoundary``, ``property``" -msgstr "" +msgstr "``StrEnum``, ``EnumCheck``, ``FlagBoundary``, ``property``" #: library/enum.rst:138 msgid "``member``, ``nonmember``" -msgstr "" +msgstr "``member``, ``nonmember``" #: library/enum.rst:143 msgid "Data Types" -msgstr "" +msgstr "Types de données" #: library/enum.rst:148 msgid "" @@ -299,6 +302,9 @@ msgid "" "to subclass *EnumType* -- see :ref:`Subclassing EnumType ` for details." msgstr "" +"*EnumType* est la :term:`métaclasse ` pour les énumérations. Il " +"est possible de sous-classer *EnumType* ­— voir :ref:`Sous-classer EnumType " +"` pour plus de détails." #: library/enum.rst:152 msgid "" @@ -307,10 +313,15 @@ msgid "" "*enum*, as well as creating the enum members, properly handling duplicates, " "providing iteration over the enum class, etc." msgstr "" +"*EnumType* est chargé de définir les méthodes correctes :meth:`__repr__`, :" +"meth:`__str__`, :meth:`__format__` et :meth:`__reduce__` sur l'énumération " +"finale, ainsi que de créer les membres de l'énumération, de gérer " +"correctement les doublons, de fournir une itération sur la classe *enum*, " +"etc." #: library/enum.rst:159 msgid "Returns ``True`` if member belongs to the ``cls``::" -msgstr "" +msgstr "Renvoie ``True`` si le membre appartient à ``cls`` ::" #: library/enum.rst:167 msgid "" @@ -318,51 +329,57 @@ msgid "" "members; until then, a ``TypeError`` will be raised if a non-Enum-member is " "used in a containment check." msgstr "" +"Dans Python 3.12, il sera possible de vérifier les valeurs des membres et " +"pas seulement les membres ; en attendant, une ``TypeError`` est levée si un " +"membre non-Enum est utilisé dans une vérification d'appartenance." #: library/enum.rst:173 msgid "" "Returns ``['__class__', '__doc__', '__members__', '__module__']`` and the " "names of the members in *cls*::" msgstr "" +"Renvoie ``['__class__', '__doc__', '__members__', '__module__']`` et les " +"noms des membres de *cls* ::" #: library/enum.rst:181 msgid "" "Returns the Enum member in *cls* matching *name*, or raises an :exc:" "`AttributeError`::" msgstr "" +"Renvoie le membre de l'énumération *cls* correspondant à *name* ou lève une :" +"exc:`AttributeError` ::" #: library/enum.rst:188 msgid "" "Returns the Enum member in *cls* matching *name*, or raises an :exc:" "`KeyError`::" msgstr "" +"Renvoie le membre de l'énumération *cls* correspondant à *name* ou lève une :" +"exc:`KeyError` ::" #: library/enum.rst:195 -#, fuzzy msgid "Returns each member in *cls* in definition order::" -msgstr "" -"Les énumérations sont itérables, l'ordre d'itération est celui dans lequel " -"les membres sont déclarés ::" +msgstr "Renvoie chaque membre de *cls* dans l'ordre de définition ::" #: library/enum.rst:202 msgid "Returns the number of member in *cls*::" -msgstr "" +msgstr "Renvoie le nombre de membres de *cls* ::" #: library/enum.rst:209 msgid "Returns each member in *cls* in reverse definition order::" -msgstr "" +msgstr "Renvoie chaque membre de *cls* dans l'ordre inverse de définition ::" #: library/enum.rst:217 msgid "*Enum* is the base class for all *enum* enumerations." -msgstr "" +msgstr "*Enum* est la classe mère de toutes les énumérations." #: library/enum.rst:221 msgid "The name used to define the ``Enum`` member::" -msgstr "" +msgstr "Le nom utilisé pour définir le membre de l'``Enum`` ::" #: library/enum.rst:228 msgid "The value given to the ``Enum`` member::" -msgstr "" +msgstr "La valeur attribuée au membre de l'``Enum`` ::" #: library/enum.rst:233 msgid "Enum member values" @@ -385,6 +402,8 @@ msgid "" "``_ignore_`` is only used during creation and is removed from the " "enumeration once creation is complete." msgstr "" +"``_ignore_`` n'est utilisé que lors de la création et est supprimé de " +"l'énumération une fois la création terminée." #: library/enum.rst:245 msgid "" @@ -392,22 +411,25 @@ msgid "" "names will also be removed from the completed enumeration. See :ref:" "`TimePeriod ` for an example." msgstr "" +"``_ignore_`` est une liste de noms qui ne deviendront pas membres et qui " +"seront également supprimés de l'énumération terminée. Voir :ref:`Intervalle " +"de temps ` pour un exemple." #: library/enum.rst:251 msgid "This method is called in two different ways:" -msgstr "" +msgstr "Cette méthode peut être appelée de deux manières différentes :" #: library/enum.rst:253 msgid "to look up an existing member:" -msgstr "" +msgstr "pour chercher un membre existant :" #: library/enum.rst:0 msgid "cls" -msgstr "" +msgstr "cls" #: library/enum.rst:260 msgid "The enum class being called." -msgstr "" +msgstr "Classe de l'énumération concernée." #: library/enum.rst:0 msgid "value" @@ -415,15 +437,16 @@ msgstr "value" #: library/enum.rst:256 msgid "The value to lookup." -msgstr "" +msgstr "Valeur à chercher." #: library/enum.rst:258 msgid "to use the ``cls`` enum to create a new enum:" msgstr "" +"pour utiliser l'énumération ``cls`` afin de créer une nouvelle énumération :" #: library/enum.rst:261 msgid "The name of the new Enum to create." -msgstr "" +msgstr "Nom de la nouvelle énumération à créer." #: library/enum.rst:0 msgid "names" @@ -431,25 +454,23 @@ msgstr "names" #: library/enum.rst:262 msgid "The names/values of the members for the new Enum." -msgstr "" +msgstr "Couples nom-valeur des membres de la nouvelle énumération." #: library/enum.rst:0 msgid "module" msgstr "module" #: library/enum.rst:263 -#, fuzzy msgid "The name of the module the new Enum is created in." -msgstr "nom du module dans lequel la classe *Enum* se trouve." +msgstr "Nom du module dans lequel la classe *Enum* se trouve." #: library/enum.rst:0 msgid "qualname" msgstr "qualname" #: library/enum.rst:264 -#, fuzzy msgid "The actual location in the module where this Enum can be found." -msgstr "nom du module dans lequel la classe *Enum* se trouve." +msgstr "Position dans le module où la classe *Enum* se trouve." #: library/enum.rst:0 msgid "type" @@ -457,7 +478,7 @@ msgstr "type" #: library/enum.rst:265 msgid "A mix-in type for the new Enum." -msgstr "" +msgstr "Type à mélanger pour la nouvelle énumération." #: library/enum.rst:0 msgid "start" @@ -465,92 +486,114 @@ msgstr "start" #: library/enum.rst:266 msgid "The first integer value for the Enum (used by :class:`auto`)" -msgstr "" +msgstr "Première valeur entière de l'énumération (utilisé par :class:`auto`)" #: library/enum.rst:0 msgid "boundary" -msgstr "" +msgstr "boundary" #: library/enum.rst:267 msgid "" "How to handle out-of-range values from bit operations (:class:`Flag` only)" msgstr "" +"Définit la gestion les valeurs hors plage des opérations bit-à-bit (:class:" +"`Flag` uniquement)" #: library/enum.rst:271 msgid "" "Returns ``['__class__', '__doc__', '__module__', 'name', 'value']`` and any " "public methods defined on *self.__class__*::" msgstr "" +"Renvoie ``['__class__', '__doc__', '__module__', 'name', 'value']`` et " +"toutes les méthodes publiques définies pour *self.__class__* ::" #: library/enum.rst:0 msgid "name" -msgstr "``name``" +msgstr "name" #: library/enum.rst:291 msgid "The name of the member being defined (e.g. 'RED')." -msgstr "" +msgstr "Nom du membre en cours de définition (par ex. `RED`)." #: library/enum.rst:292 msgid "The start value for the Enum; the default is 1." -msgstr "" +msgstr "Valeur de départ pour l'énumération ; 1 par défaut." #: library/enum.rst:0 msgid "count" -msgstr "" +msgstr "count" #: library/enum.rst:293 msgid "The number of members currently defined, not including this one." msgstr "" +"Nombre de membres actuellement définis, le membre actuel n'étant pas inclus." #: library/enum.rst:0 msgid "last_values" -msgstr "``last_values``" +msgstr "last_values" #: library/enum.rst:294 msgid "A list of the previous values." -msgstr "" +msgstr "Liste des valeurs précédentes." #: library/enum.rst:296 msgid "" "A *staticmethod* that is used to determine the next value returned by :class:" "`auto`::" msgstr "" +"Méthode statique utilisée pour déterminer la prochaine valeur à renvoyer " +"par :class:`auto` ::" #: library/enum.rst:311 msgid "" "A *classmethod* that is used to further configure subsequent subclasses. By " "default, does nothing." msgstr "" +"Méthode de classe utilisée pour personnaliser davantage les sous-classes à " +"venir. Ne fait rien par défaut." #: library/enum.rst:316 msgid "" "A *classmethod* for looking up values not found in *cls*. By default it " "does nothing, but can be overridden to implement custom search behavior::" msgstr "" +"Méthode de classe pour chercher des valeurs non trouvées dans *cls*. Ne fait " +"rien par défaut mais peut être surchargée pour implémenter un comportement " +"personnalisé de recherche ::" #: library/enum.rst:337 msgid "" "Returns the string used for *repr()* calls. By default, returns the *Enum* " "name, member name, and value, but can be overridden::" msgstr "" +"Renvoie la chaîne utilisée pour les appels à *repr()*. Par défaut, renvoie " +"le nom de l'énumération, le nom du membre et sa valeur, mais peut être " +"surchargée ::" #: library/enum.rst:352 msgid "" "Returns the string used for *str()* calls. By default, returns the *Enum* " "name and member name, but can be overridden::" msgstr "" +"Renvoie la chaîne utilisée pour les appels à *str()*. Par défaut, renvoie le " +"nom *Enum* et le nom du membre, mais peut être remplacé ::" #: library/enum.rst:366 msgid "" "Returns the string used for *format()* and *f-string* calls. By default, " "returns :meth:`__str__` returns, but can be overridden::" msgstr "" +"Renvoie la chaîne utilisée pour les appels à *format()* et *f-string*. Par " +"défaut, renvoie la valeur renvoyée par :meth:`__str__`, mais peut être " +"remplacé ::" #: library/enum.rst:380 msgid "" "Using :class:`auto` with :class:`Enum` results in integers of increasing " "value, starting with ``1``." msgstr "" +"L'utilisation de :class:`auto` avec :class:`Enum` donne des nombres entiers " +"de valeur croissante, en commençant par ``1``." #: library/enum.rst:386 msgid "" @@ -559,12 +602,18 @@ msgid "" "performed with an *IntEnum* member, the resulting value loses its " "enumeration status." msgstr "" +"*IntEnum* est identique à *Enum*, mais ses membres sont également des " +"entiers et peuvent être utilisés partout où un entier peut être utilisé. Si " +"une opération sur un entier est effectuée avec un membre *IntEnum*, la " +"valeur résultante perd son statut de membre d'énumération." #: library/enum.rst:406 msgid "" "Using :class:`auto` with :class:`IntEnum` results in integers of increasing " "value, starting with ``1``." msgstr "" +"L'utilisation de :class:`auto` avec :class:`IntEnum` donne des entiers de " +"valeur croissante, en commençant par ``1``." #: library/enum.rst:580 msgid "" @@ -572,6 +621,9 @@ msgid "" "*replacement of existing constants* use-case. :meth:`__format__` was " "already :func:`int.__format__` for that same reason." msgstr "" +":meth:`__str__` est maintenant :func:`int.__str__` pour mieux prendre en " +"charge le cas d'utilisation du *remplacement de constantes existantes*. :" +"meth:`__format__` était déjà :func:`int.__format__` pour la même raison." #: library/enum.rst:416 msgid "" @@ -580,6 +632,10 @@ msgid "" "any string operation performed on or with a *StrEnum* member is not part of " "the enumeration." msgstr "" +"*StrEnum* est identique à *Enum*, mais ses membres sont également des " +"chaînes et peuvent être utilisés dans la plupart des endroits où une chaîne " +"peut être utilisée. Le résultat de toute opération de chaîne effectuée sur " +"ou avec un membre *StrEnum* ne fait pas partie de l'énumération." #: library/enum.rst:420 msgid "" @@ -588,12 +644,19 @@ msgid "" "``isinstance(str, unknown)``), and in those locations you will need to use " "``str(StrEnum.member)``." msgstr "" +"Il y a des endroits dans la bibliothèque standard qui vérifient s'ils ont " +"affaire à une sous-classe :class:`str` exacte au lieu d'une sous-classe :" +"class:`str` (c'est-à-dire ``type(unknown) == str`` au lieu de " +"``isinstance(str, unknown)``) et, dans ce cas, vous devez utiliser " +"``str(StrEnum.member)``." #: library/enum.rst:427 msgid "" "Using :class:`auto` with :class:`StrEnum` results in the lower-cased member " "name as the value." msgstr "" +"L'utilisation de :class:`auto` avec :class:`StrEnum` donne le nom du membre " +"en minuscule comme valeur." #: library/enum.rst:430 msgid "" @@ -601,6 +664,9 @@ msgid "" "existing constants* use-case. :meth:`__format__` is likewise :func:`str." "__format__` for that same reason." msgstr "" +":meth:`__str__` est :func:`str.__str__` pour mieux prendre en charge le cas " +"d'utilisation de *remplacement de constantes existantes*. :meth:`__format__` " +"est également :func:`str.__format__` pour la même raison." #: library/enum.rst:438 msgid "" @@ -608,147 +674,188 @@ msgid "" "``^`` (*XOR*), and ``~`` (*INVERT*); the results of those operators are " "members of the enumeration." msgstr "" +"Les membres *Flag* prennent en charge les opérateurs bit-à-bit ``&`` (*ET*), " +"``|`` (*OU*), ``^`` (*OU EXCLUSIF*) et ``~`` (*NON*) ; les résultats de ces " +"opérations sont membres de l'énumération." #: library/enum.rst:444 msgid "Returns *True* if value is in self::" -msgstr "" +msgstr "Renvoie *True* si la valeur est dans *self* ::" #: library/enum.rst:464 msgid "Returns all contained members::" -msgstr "" +msgstr "Renvoie tous les membres ::" #: library/enum.rst:473 msgid "Returns number of members in flag::" -msgstr "" +msgstr "Renvoie le nombre de membres de *Flag* ::" #: library/enum.rst:482 msgid "Returns *True* if any members in flag, *False* otherwise::" msgstr "" +"Renvoie *True* s'il y a un membre dans les bits de *Flag*, *False* sinon ::" #: library/enum.rst:494 msgid "Returns current flag binary or'ed with other::" -msgstr "" +msgstr "Renvoie le *OU* logique entre le membre et *other* ::" #: library/enum.rst:501 msgid "Returns current flag binary and'ed with other::" -msgstr "" +msgstr "Renvoie le *ET* logique entre le membre et *other* ::" #: library/enum.rst:510 msgid "Returns current flag binary xor'ed with other::" -msgstr "" +msgstr "Renvoie le *OU Exclusif* logique entre le membre et *other* ::" #: library/enum.rst:519 msgid "Returns all the flags in *type(self)* that are not in self::" msgstr "" +"Renvoie tous les membres de *type(self)* qui ne sont pas dans *self* " +"(opération logique sur les bits) ::" #: library/enum.rst:530 msgid "" "Function used to format any remaining unnamed numeric values. Default is " "the value's repr; common choices are :func:`hex` and :func:`oct`." msgstr "" +"Fonction utilisée pour formater toutes les valeurs numériques sans nom " +"restantes. La valeur par défaut est la représentation de la valeur ; les " +"choix courants sont :func:`hex` et :func:`oct`." #: library/enum.rst:535 msgid "" "Using :class:`auto` with :class:`Flag` results in integers that are powers " "of two, starting with ``1``." msgstr "" +"L'utilisation de :class:`auto` avec :class:`Flag` donne des entiers qui sont " +"des puissances de deux, en commençant par ``1``." #: library/enum.rst:538 msgid "The *repr()* of zero-valued flags has changed. It is now::" -msgstr "" +msgstr "La *repr()* des membres de valeur zéro a changé. C'est maintenant ::" #: library/enum.rst:546 msgid "" "*IntFlag* is the same as *Flag*, but its members are also integers and can " "be used anywhere that an integer can be used." msgstr "" +"*IntFlag* est identique à *Flag*, mais ses membres sont également des " +"entiers et peuvent être utilisés partout où un entier peut être utilisé." #: library/enum.rst:559 msgid "" "If any integer operation is performed with an *IntFlag* member, the result " "is not an *IntFlag*::" msgstr "" +"Si une opération sur un entier est effectuée avec un membre d'un *IntFlag*, " +"le résultat n'est pas un *IntFlag* ::" #: library/enum.rst:565 msgid "If a *Flag* operation is performed with an *IntFlag* member and:" -msgstr "" +msgstr "Si une opération *Flag* est effectuée avec un membre *IntFlag* et :" #: library/enum.rst:567 msgid "the result is a valid *IntFlag*: an *IntFlag* is returned" -msgstr "" +msgstr "le résultat est un *IntFlag* valide : un *IntFlag* est renvoyé ;" #: library/enum.rst:568 msgid "" "the result is not a valid *IntFlag*: the result depends on the " "*FlagBoundary* setting" msgstr "" +"le résultat n'est pas un *IntFlag* valide : le résultat dépend du paramètre " +"*FlagBoundary*." #: library/enum.rst:570 msgid "The *repr()* of unnamed zero-valued flags has changed. It is now:" msgstr "" +"La *repr()* des *intflag* sans nom à valeur nulle a changé. C'est " +"maintenant :" #: library/enum.rst:577 msgid "" "Using :class:`auto` with :class:`IntFlag` results in integers that are " "powers of two, starting with ``1``." msgstr "" +"L'utilisation de :class:`auto` avec :class:`IntFlag` donne des entiers qui " +"sont des puissances de deux, en commençant par ``1``." #: library/enum.rst:587 msgid "" "*EnumCheck* contains the options used by the :func:`verify` decorator to " "ensure various constraints; failed constraints result in a :exc:`ValueError`." msgstr "" +"*EnumCheck* contient les options utilisées par le décorateur :func:`verify` " +"pour assurer diverses contraintes ; si une contrainte n'est pas validée, " +"une :exc:`ValueError` est levée." #: library/enum.rst:592 msgid "Ensure that each value has only one name::" -msgstr "" +msgstr "Assure que chaque valeur n'a qu'un seul nom ::" #: library/enum.rst:608 msgid "" "Ensure that there are no missing values between the lowest-valued member and " "the highest-valued member::" msgstr "" +"Assure qu'il n'y a pas de valeurs manquantes entre le membre ayant la valeur " +"la plus faible et le membre ayant la valeur la plus élevée ::" #: library/enum.rst:623 msgid "" "Ensure that any flag groups/masks contain only named flags -- useful when " "values are specified instead of being generated by :func:`auto`" msgstr "" +"Assure que tous les groupes/masques sont possibles en n'utilisant que des " +"membres nommés — utile lorsque des valeurs sont spécifiées au lieu d'être " +"générées par :func:`auto`" #: library/enum.rst:640 msgid "" "CONTINUOUS and NAMED_FLAGS are designed to work with integer-valued members." msgstr "" +"CONTINUOUS et NAMED_FLAGS sont conçus pour fonctionner avec des membres à " +"valeur entière." #: library/enum.rst:646 msgid "" "*FlagBoundary* controls how out-of-range values are handled in *Flag* and " "its subclasses." msgstr "" +"*FlagBoundary* contrôle la façon dont les valeurs hors plage sont gérées " +"dans *Flag* et ses sous-classes." #: library/enum.rst:651 msgid "" "Out-of-range values cause a :exc:`ValueError` to be raised. This is the " "default for :class:`Flag`::" msgstr "" +"Les valeurs hors plage provoquent la levée d'une :exc:`ValueError`. C'est la " +"valeur par défaut pour :class:`Flag` ::" #: library/enum.rst:668 msgid "" "Out-of-range values have invalid values removed, leaving a valid *Flag* " "value::" msgstr "" +"Les valeurs hors plage, invalides, sont supprimées laissant une valeur " +"*Flag* valide ::" #: library/enum.rst:681 msgid "" "Out-of-range values lose their *Flag* membership and revert to :class:`int`. " "This is the default for :class:`IntFlag`::" msgstr "" +"Les valeurs hors plage perdent leur appartenance à *Flag* et reviennent à :" +"class:`int`. C'est la valeur par défaut pour :class:`IntFlag` ::" #: library/enum.rst:694 msgid "" "Out-of-range values are kept, and the *Flag* membership is kept. This is " "used for some stdlib flags:" msgstr "" +"Les valeurs hors plage sont conservées et l'appartenance *Flag* est " +"conservée. C'est utilisé pour certains drapeaux de la bibliothèque standard :" #: library/enum.rst:710 msgid "Supported ``__dunder__`` names" @@ -760,7 +867,7 @@ msgid "" "``member`` items. It is only available on the class." msgstr "" ":attr:`__members__` est un dictionnaire en lecture seule ordonné d'éléments " -"``nom_du_membre`` / ``membre``. Il n'est disponible que depuis la classe." +"``nom_du_membre`` : ``membre``. Il n'est disponible que depuis la classe." #: library/enum.rst:715 msgid "" @@ -779,22 +886,22 @@ msgstr "Noms de la forme ``_sunder_`` disponibles" #: library/enum.rst:723 msgid "``_name_`` -- name of the member" -msgstr "``_name_`` -- nom du membre" +msgstr "``_name_`` — nom du membre" #: library/enum.rst:724 msgid "" "``_value_`` -- value of the member; can be set / modified in ``__new__``" msgstr "" -"``_value_`` -- valeur du membre ; il est possible d'y accéder ou de la muer " -"dans ``__new__``" +"``_value_`` — valeur du membre ; il est possible d'y accéder et de la " +"modifier dans ``__new__``" #: library/enum.rst:726 msgid "" "``_missing_`` -- a lookup function used when a value is not found; may be " "overridden" msgstr "" -"``_missing_`` -- une fonction de recherche qui est appelée quand la valeur " -"n'est pas trouvée ; elle peut être redéfinie" +"``_missing_`` — fonction de recherche appelée quand la valeur n'est pas " +"trouvée ; elle peut être redéfinie" #: library/enum.rst:728 msgid "" @@ -802,40 +909,42 @@ msgid "" "`str`, that will not be transformed into members, and will be removed from " "the final class" msgstr "" -"``_ignore_`` -- une liste de noms, sous la forme d'une :func:`list` ou " -"d'une :func:`str`, qui ne seront pas convertis en membres et seront " -"supprimés de la classe résultante" +"``_ignore_`` — liste de noms, sous la forme d'une :func:`list` ou d'une :" +"func:`str`, qui ne sont pas convertis en membres et sont supprimés de la " +"classe résultante" #: library/enum.rst:731 msgid "" "``_order_`` -- used in Python 2/3 code to ensure member order is consistent " "(class attribute, removed during class creation)" msgstr "" -"``_order_`` -- utilisé en Python 2 ou 3 pour s'assurer que l'ordre des " -"membres est cohérent (attribut de classe, supprimé durant la création de la " -"classe)" +"``_order_`` — utilisée en Python 2 ou 3 pour s'assurer que l'ordre des " +"membres est cohérent dans les différentes versions de Python (attribut de " +"classe, supprimé durant la création de la classe)" #: library/enum.rst:733 -#, fuzzy msgid "" "``_generate_next_value_`` -- used to get an appropriate value for an enum " "member; may be overridden" msgstr "" -"``_generate_next_value_`` -- utilisée par l' `API par fonction`_ et par :" -"class:`auto` pour obtenir une valeur appropriée à affecter à un membre de " -"*l'enum* ; elle peut être redéfinie" +"``_generate_next_value_`` — utilisée pour obtenir une valeur appropriée à " +"affecter à un membre de l’énumération ; elle peut être redéfinie" #: library/enum.rst:738 msgid "" "For standard :class:`Enum` classes the next value chosen is the last value " "seen incremented by one." msgstr "" +"Pour les classes standard :class:`Enum`, la valeur suivante choisie est la " +"dernière valeur vue incrémentée de un." #: library/enum.rst:741 msgid "" "For :class:`Flag` classes the next value chosen will be the next highest " "power-of-two, regardless of the last value seen." msgstr "" +"Pour les classes :class:`Flag`, la valeur suivante choisie est la puissance " +"de deux la plus élevée suivante, quelle que soit la dernière valeur vue." #: library/enum.rst:744 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" @@ -847,7 +956,7 @@ msgstr "``_ignore_``" #: library/enum.rst:750 msgid "Utilities and Decorators" -msgstr "" +msgstr "Utilitaires et décorateurs" #: library/enum.rst:754 msgid "" @@ -858,12 +967,20 @@ msgid "" "the last value; for *StrEnum* it will be the lower-cased version of the " "member's name." msgstr "" +"*auto* peut être utilisée à la place d'une valeur. Si elle est utilisée, le " +"fonctionnement interne d'*Enum* appelle :meth:`_generate_next_value_` pour " +"obtenir une valeur appropriée. Pour *Enum* et *IntEnum*, cette valeur " +"appropriée est la dernière valeur plus un ; pour *Flag* et *IntFlag*, c'est " +"la première puissance de deux supérieure à la plus grande valeur ; pour " +"*StrEnum*, c'est le nom du membre en minuscules." #: library/enum.rst:761 msgid "" "``_generate_next_value_`` can be overridden to customize the values used by " "*auto*." msgstr "" +"``_generate_next_value_`` peut être surchargée pour personnaliser les " +"valeurs produites par *auto*." #: library/enum.rst:766 msgid "" @@ -871,6 +988,9 @@ msgid "" "enumerations. It allows member attributes to have the same names as members " "themselves." msgstr "" +"Décorateur similaire au *property* natif, mais spécifique aux énumérations. " +"Il permet aux attributs de membre d'avoir les mêmes noms que les membres eux-" +"mêmes." #: library/enum.rst:770 msgid "" @@ -879,17 +999,21 @@ msgid "" "and *Enum* subclasses can define members with the names ``value`` and " "``name``." msgstr "" +"*property* et le membre doivent être définis dans des classes distinctes ; " +"par exemple, les attributs *value* et *name* sont définis dans la classe " +"*Enum*, et les sous-classes d'*Enum* peuvent définir des membres avec les " +"noms ``value`` et ``name``." #: library/enum.rst:779 -#, fuzzy msgid "" "A :keyword:`class` decorator specifically for enumerations. It searches an " "enumeration's :attr:`__members__`, gathering any aliases it finds; if any " "are found :exc:`ValueError` is raised with the details::" msgstr "" -"Un décorateur de :keyword:`class` spécifique aux énumérations. Il examine " -"l'attribut :attr:`__members__` d'une énumération et recherche des alias ; " -"s'il en trouve, l'exception :exc:`ValueError` est levée avec des détails ::" +"Décorateur de :keyword:`classe ` spécifique aux énumérations. Il " +"examine l'attribut :attr:`__members__` d'une énumération et recherche des " +"synonymes ; s'il en trouve, l'exception :exc:`ValueError` est levée avec des " +"détails ::" #: library/enum.rst:797 msgid "" @@ -897,48 +1021,63 @@ msgid "" "class:`EnumCheck` are used to specify which constraints should be checked on " "the decorated enumeration." msgstr "" +"Décorateur de :keyword:`classe ` spécifique aux énumérations. Utilisé " +"pour spécifier quelles contraintes doivent être vérifiées par les membres de " +"l':class:`EnumCheck` décorée." #: library/enum.rst:805 msgid "A decorator for use in enums: its target will become a member." msgstr "" +"Décorateur à utiliser dans les énumérations : sa cible devient un membre." #: library/enum.rst:811 msgid "A decorator for use in enums: its target will not become a member." msgstr "" +"Décorateur à utiliser dans les énumérations : sa cible ne devient pas un " +"membre." #: library/enum.rst:818 msgid "Notes" -msgstr "" +msgstr "Notes" #: library/enum.rst:820 msgid ":class:`IntEnum`, :class:`StrEnum`, and :class:`IntFlag`" -msgstr "" +msgstr ":class:`IntEnum`, :class:`StrEnum` et :class:`IntFlag`" #: library/enum.rst:822 msgid "" "These three enum types are designed to be drop-in replacements for existing " "integer- and string-based values; as such, they have extra limitations:" msgstr "" +"Ces trois types d'énumération sont conçus pour remplacer directement les " +"valeurs existantes basées sur des entiers et des chaînes ; en tant que tels, " +"ils ont des limitations supplémentaires :" #: library/enum.rst:825 msgid "``__str__`` uses the value and not the name of the enum member" -msgstr "" +msgstr "``__str__`` utilise la valeur et pas le nom du membre de l'énumération" #: library/enum.rst:827 msgid "" "``__format__``, because it uses ``__str__``, will also use the value of the " "enum member instead of its name" msgstr "" +"``__format__``, parce qu'elle fait appel à ``__str__``, utilise également la " +"valeur du membre de l'énumération au lieu de son nom" #: library/enum.rst:830 msgid "" "If you do not need/want those limitations, you can either create your own " "base class by mixing in the ``int`` or ``str`` type yourself::" msgstr "" +"Si ces limitations ne vous conviennent pas, vous pouvez créer votre propre " +"classe mère en mélangeant vous-même le type ``int`` ou ``str`` ::" #: library/enum.rst:837 msgid "or you can reassign the appropriate :meth:`str`, etc., in your enum::" msgstr "" +"ou vous pouvez réassigner la :meth:`str` appropriée, etc., dans votre " +"énumération ::" #~ msgid "" #~ "An enumeration is a set of symbolic names (members) bound to unique, "