forked from AFPy/python-docs-fr
1177 lines
32 KiB
Plaintext
1177 lines
32 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 2001-2022, Python Software Foundation
|
|
# This file is distributed under the same license as the Python package.
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
#
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3.11\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 <EMAIL@ADDRESS>\n"
|
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
|
"Language: fr\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: howto/enum.rst:3
|
|
msgid "Enum HOWTO"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:9
|
|
msgid ""
|
|
"An :class:`Enum` is a set of symbolic names bound to unique values. They "
|
|
"are similar to global variables, but they offer a more useful :func:"
|
|
"`repr()`, grouping, type-safety, and a few other features."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:26
|
|
msgid "Or perhaps the RGB primary colors::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:37
|
|
msgid "Case of Enum Members"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:42
|
|
msgid ""
|
|
"Depending on the nature of the enum a member's value may or may not be "
|
|
"important, but either way that value can be used to get the corresponding "
|
|
"member::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:49
|
|
msgid ""
|
|
"As you can see, the ``repr()`` of a member shows the enum name, the member "
|
|
"name, and the value. The ``str()`` of a member shows only the enum name and "
|
|
"member name::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:56
|
|
msgid "The *type* of an enumeration member is the enum it belongs to::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:63
|
|
msgid "Enum members have an attribute that contains just their :attr:`name`::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:68
|
|
msgid "Likewise, they have an attribute for their :attr:`value`::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:74
|
|
msgid ""
|
|
"Unlike many languages that treat enumerations solely as name/value pairs, "
|
|
"Python Enums can have behavior added. For example, :class:`datetime.date` "
|
|
"has two methods for returning the weekday: :meth:`weekday` and :meth:"
|
|
"`isoweekday`. The difference is that one of them counts from 0-6 and the "
|
|
"other from 1-7. Rather than keep track of that ourselves we can add a method "
|
|
"to the :class:`Weekday` enum to extract the day from the :class:`date` "
|
|
"instance and return the matching enum member::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:86
|
|
msgid "The complete :class:`Weekday` enum now looks like this::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:101
|
|
msgid "Now we can find out what today is! Observe::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:107
|
|
msgid ""
|
|
"Of course, if you're reading this on some other day, you'll see that day "
|
|
"instead."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:109
|
|
msgid ""
|
|
"This :class:`Weekday` enum is great if our variable only needs one day, but "
|
|
"what if we need several? Maybe we're writing a function to plot chores "
|
|
"during a week, and don't want to use a :class:`list` -- we could use a "
|
|
"different type of :class:`Enum`::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:127
|
|
msgid ""
|
|
"Just like the original :class:`Weekday` enum above, we can have a single "
|
|
"selection::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:133
|
|
msgid ""
|
|
"But :class:`Flag` also allows us to combine several members into a single "
|
|
"variable::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:140
|
|
msgid "You can even iterate over a :class:`Flag` variable::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:147
|
|
msgid "Okay, let's get some chores set up::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:155
|
|
msgid "And a function to display the chores for a given day::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:182
|
|
msgid "Programmatic access to enumeration members and their attributes"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:184
|
|
msgid ""
|
|
"Sometimes it's useful to access members in enumerations programmatically (i."
|
|
"e. situations where ``Color.RED`` won't do because the exact color is not "
|
|
"known at program-writing time). ``Enum`` allows such access::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:193
|
|
msgid "If you want to access enum members by *name*, use item access::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:200
|
|
msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:210
|
|
msgid "Duplicating enum members and values"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:212
|
|
msgid "Having two enum members with the same name is invalid::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:222
|
|
msgid ""
|
|
"However, an enum member can have other names associated with it. Given two "
|
|
"entries ``A`` and ``B`` with the same value (and ``A`` defined first), ``B`` "
|
|
"is an alias for the member ``A``. By-value lookup of the value of ``A`` "
|
|
"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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:249
|
|
msgid "Ensuring unique enumeration values"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:268
|
|
msgid "Using automatic values"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:270
|
|
msgid "If the exact value is unimportant you can use :class:`auto`::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:281
|
|
msgid ""
|
|
"The values are chosen by :func:`_generate_next_value_`, which can be "
|
|
"overridden::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:299
|
|
msgid ""
|
|
"The :meth:`_generate_next_value_` method must be defined before any members."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:302
|
|
msgid "Iteration"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:304
|
|
msgid "Iterating over the members of an enum does not provide the aliases::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:309
|
|
msgid ""
|
|
"The special attribute ``__members__`` is a read-only ordered mapping of "
|
|
"names to members. It includes all names defined in the enumeration, "
|
|
"including the aliases::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:329
|
|
msgid "Comparisons"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:331
|
|
msgid "Enumeration members are compared by identity::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:340
|
|
msgid ""
|
|
"Ordered comparisons between enumeration values are *not* supported. Enum "
|
|
"members are not integers (but see `IntEnum`_ below)::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:348
|
|
msgid "Equality comparisons are defined though::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:357
|
|
msgid ""
|
|
"Comparisons against non-enumeration values will always compare not equal "
|
|
"(again, :class:`IntEnum` was explicitly designed to behave differently, see "
|
|
"below)::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:366
|
|
msgid "Allowed members and attributes of enumerations"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:368
|
|
msgid ""
|
|
"Most of the examples above use integers for enumeration values. Using "
|
|
"integers is short and handy (and provided by default by the `Functional "
|
|
"API`_), but not strictly enforced. In the vast majority of use-cases, one "
|
|
"doesn't care what the actual value of an enumeration is. But if the value "
|
|
"*is* important, enumerations can have arbitrary values."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:374
|
|
msgid ""
|
|
"Enumerations are Python classes, and can have methods and special methods as "
|
|
"usual. If we have this enumeration::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:394
|
|
msgid "Then::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:403
|
|
msgid ""
|
|
"The rules for what is allowed are as follows: names that start and end with "
|
|
"a single underscore are reserved by enum and cannot be used; all other "
|
|
"attributes defined within an enumeration will become members of this "
|
|
"enumeration, with the exception of special methods (:meth:`__str__`, :meth:"
|
|
"`__add__`, etc.), descriptors (methods are also descriptors), and variable "
|
|
"names listed in :attr:`_ignore_`."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:410
|
|
msgid ""
|
|
"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__` "
|
|
"then any value(s) given to the enum member will be passed into those "
|
|
"methods. See `Planet`_ for an example."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:416
|
|
msgid "Restricted Enum subclassing"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:418
|
|
msgid ""
|
|
"A new :class:`Enum` class must have one base enum class, up to one concrete "
|
|
"data type, and as many :class:`object`-based mixin classes as needed. The "
|
|
"order of these base classes is::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:435
|
|
msgid "But this is allowed::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:446
|
|
msgid ""
|
|
"Allowing subclassing of enums that define members would lead to a violation "
|
|
"of some important invariants of types and instances. On the other hand, it "
|
|
"makes sense to allow sharing some common behavior between a group of "
|
|
"enumerations. (See `OrderedEnum`_ for an example.)"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:453
|
|
msgid "Pickling"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:455
|
|
msgid "Enumerations can be pickled and unpickled::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:462
|
|
msgid ""
|
|
"The usual restrictions for pickling apply: picklable enums must be defined "
|
|
"in the top level of a module, since unpickling requires them to be "
|
|
"importable from that module."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:468
|
|
msgid ""
|
|
"With pickle protocol version 4 it is possible to easily pickle enums nested "
|
|
"in other classes."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:476
|
|
msgid "Functional API"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:478
|
|
msgid ""
|
|
"The :class:`Enum` class is callable, providing the following functional API::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:491
|
|
msgid ""
|
|
"The second argument is the *source* of enumeration member names. It can be "
|
|
"a whitespace-separated string of names, a sequence of names, a sequence of 2-"
|
|
"tuples with key/value pairs, or a mapping (e.g. dictionary) of names to "
|
|
"values. The last two options enable assigning arbitrary values to "
|
|
"enumerations; the others auto-assign increasing integers starting with 1 "
|
|
"(use the ``start`` parameter to specify a different starting value). A new "
|
|
"class derived from :class:`Enum` is returned. In other words, the above "
|
|
"assignment to :class:`Animal` is equivalent to::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:507
|
|
msgid ""
|
|
"The reason for defaulting to ``1`` as the starting number and not ``0`` is "
|
|
"that ``0`` is ``False`` in a boolean sense, but by default enum members all "
|
|
"evaluate to ``True``."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:511
|
|
msgid ""
|
|
"Pickling enums created with the functional API can be tricky as frame stack "
|
|
"implementation details are used to try and figure out which module the "
|
|
"enumeration is being created in (e.g. it will fail if you use a utility "
|
|
"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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:525
|
|
msgid ""
|
|
"The new pickle protocol 4 also, in some circumstances, relies on :attr:"
|
|
"`~definition.__qualname__` being set to the location where pickle will be "
|
|
"able to find the class. For example, if the class was made available in "
|
|
"class SomeData in the global scope::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:532
|
|
msgid "The complete signature is::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "value"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:544
|
|
msgid "What the new enum class will record as its name."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "names"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:551
|
|
msgid "or an iterator of names::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:555
|
|
msgid "or an iterator of (name, value) pairs::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:559
|
|
msgid "or a mapping::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "module"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:563
|
|
msgid "name of module where new enum class can be found."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "qualname"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:565
|
|
msgid "where in module new enum class can be found."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "type"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:567
|
|
msgid "type to mix in to new enum class."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:0
|
|
msgid "start"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:569
|
|
msgid "number to start counting at if only names are passed in."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:571
|
|
msgid "The *start* parameter was added."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:576
|
|
msgid "Derived Enumerations"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:579
|
|
msgid "IntEnum"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:581
|
|
msgid ""
|
|
"The first variation of :class:`Enum` that is provided is also a subclass of :"
|
|
"class:`int`. Members of an :class:`IntEnum` can be compared to integers; by "
|
|
"extension, integer enumerations of different types can also be compared to "
|
|
"each other::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:602
|
|
msgid ""
|
|
"However, they still can't be compared to standard :class:`Enum` "
|
|
"enumerations::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:615
|
|
msgid ""
|
|
":class:`IntEnum` values behave like integers in other ways you'd expect::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:626
|
|
msgid "StrEnum"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:628
|
|
msgid ""
|
|
"The second variation of :class:`Enum` that is provided is also a subclass "
|
|
"of :class:`str`. Members of a :class:`StrEnum` can be compared to strings; "
|
|
"by extension, string enumerations of different types can also be compared to "
|
|
"each other."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:637
|
|
msgid "IntFlag"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:639
|
|
msgid ""
|
|
"The next variation of :class:`Enum` provided, :class:`IntFlag`, is also "
|
|
"based on :class:`int`. The difference being :class:`IntFlag` members can be "
|
|
"combined using the bitwise operators (&, \\|, ^, ~) and the result is still "
|
|
"an :class:`IntFlag` member, if possible. Like :class:`IntEnum`, :class:"
|
|
"`IntFlag` members are also integers and can be used wherever an :class:`int` "
|
|
"is used."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:647
|
|
msgid ""
|
|
"Any operation on an :class:`IntFlag` member besides the bit-wise operations "
|
|
"will lose the :class:`IntFlag` membership."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:657
|
|
msgid "Sample :class:`IntFlag` class::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:673
|
|
msgid "It is also possible to name the combinations::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:694
|
|
msgid ""
|
|
"Another important difference between :class:`IntFlag` and :class:`Enum` is "
|
|
"that if no flags are set (the value is 0), its boolean evaluation is :data:"
|
|
"`False`::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:713
|
|
msgid ""
|
|
"The negation operator, ``~``, always returns an :class:`IntFlag` member with "
|
|
"a positive value::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:719
|
|
msgid ":class:`IntFlag` members can also be iterated over::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:728
|
|
msgid "Flag"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:730
|
|
msgid ""
|
|
"The last variation is :class:`Flag`. Like :class:`IntFlag`, :class:`Flag` "
|
|
"members can be combined using the bitwise operators (&, \\|, ^, ~). Unlike :"
|
|
"class:`IntFlag`, they cannot be combined with, nor compared against, any "
|
|
"other :class:`Flag` enumeration, nor :class:`int`. While it is possible to "
|
|
"specify the values directly it is recommended to use :class:`auto` as the "
|
|
"value and let :class:`Flag` select an appropriate value."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:765
|
|
msgid ""
|
|
"Giving a name to the \"no flags set\" condition does not change its boolean "
|
|
"value::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:779
|
|
msgid ":class:`Flag` members can also be iterated over::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:789
|
|
msgid ""
|
|
"For the majority of new code, :class:`Enum` and :class:`Flag` are strongly "
|
|
"recommended, since :class:`IntEnum` and :class:`IntFlag` break some semantic "
|
|
"promises of an enumeration (by being comparable to integers, and thus by "
|
|
"transitivity to other unrelated enumerations). :class:`IntEnum` and :class:"
|
|
"`IntFlag` should be used only in cases where :class:`Enum` and :class:`Flag` "
|
|
"will not do; for example, when integer constants are replaced with "
|
|
"enumerations, or for interoperability with other systems."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:799
|
|
msgid "Others"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:801
|
|
msgid ""
|
|
"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very "
|
|
"simple to implement independently::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:807
|
|
msgid ""
|
|
"This demonstrates how similar derived enumerations can be defined; for "
|
|
"example a :class:`FloatEnum` that mixes in :class:`float` instead of :class:"
|
|
"`int`."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:810
|
|
msgid "Some rules:"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:812
|
|
msgid ""
|
|
"When subclassing :class:`Enum`, mix-in types must appear before :class:"
|
|
"`Enum` itself in the sequence of bases, as in the :class:`IntEnum` example "
|
|
"above."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:815
|
|
msgid ""
|
|
"Mix-in types must be subclassable. For example, :class:`bool` and :class:"
|
|
"`range` are not subclassable and will throw an error during Enum creation if "
|
|
"used as the mix-in type."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:818
|
|
msgid ""
|
|
"While :class:`Enum` can have members of any type, once you mix in an "
|
|
"additional type, all the members must have values of that type, e.g. :class:"
|
|
"`int` above. This restriction does not apply to mix-ins which only add "
|
|
"methods and don't specify another type."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:822
|
|
msgid ""
|
|
"When another data type is mixed in, the :attr:`value` attribute is *not the "
|
|
"same* as the enum member itself, although it is equivalent and will compare "
|
|
"equal."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:825
|
|
msgid ""
|
|
"%-style formatting: ``%s`` and ``%r`` call the :class:`Enum` class's :meth:"
|
|
"`__str__` and :meth:`__repr__` respectively; other codes (such as ``%i`` or "
|
|
"``%h`` for IntEnum) treat the enum member as its mixed-in type."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:828
|
|
msgid ""
|
|
":ref:`Formatted string literals <f-strings>`, :meth:`str.format`, and :func:"
|
|
"`format` will use the enum's :meth:`__str__` method."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:839
|
|
msgid "When to use :meth:`__new__` vs. :meth:`__init__`"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:841
|
|
msgid ""
|
|
":meth:`__new__` must be used whenever you want to customize the actual value "
|
|
"of the :class:`Enum` member. Any other modifications may go in either :meth:"
|
|
"`__new__` or :meth:`__init__`, with :meth:`__init__` being preferred."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:872
|
|
msgid "Finer Points"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:875
|
|
msgid "Supported ``__dunder__`` names"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:880
|
|
msgid ""
|
|
":meth:`__new__`, if specified, must create and return the enum members; it "
|
|
"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 ""
|
|
|
|
#: howto/enum.rst:886
|
|
msgid "Supported ``_sunder_`` names"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:888
|
|
msgid "``_name_`` -- name of the member"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:889
|
|
msgid ""
|
|
"``_value_`` -- value of the member; can be set / modified in ``__new__``"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:891
|
|
msgid ""
|
|
"``_missing_`` -- a lookup function used when a value is not found; may be "
|
|
"overridden"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:893
|
|
msgid ""
|
|
"``_ignore_`` -- a list of names, either as a :class:`list` or a :class:"
|
|
"`str`, that will not be transformed into members, and will be removed from "
|
|
"the final class"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:904
|
|
msgid ""
|
|
"For standard :class:`Enum` classes the next value chosen is the last value "
|
|
"seen incremented by one."
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:910
|
|
msgid "``_missing_``, ``_order_``, ``_generate_next_value_``"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:911
|
|
msgid "``_ignore_``"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:913
|
|
msgid ""
|
|
"To help keep Python 2 / Python 3 code in sync an :attr:`_order_` attribute "
|
|
"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 ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:936
|
|
msgid "_Private__names"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:938
|
|
msgid ""
|
|
":ref:`Private names <private-name-mangling>` are not converted to enum "
|
|
"members, but remain normal attributes."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:945
|
|
msgid "``Enum`` member type"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:947
|
|
msgid ""
|
|
"Enum members are instances of their enum class, and are normally accessed as "
|
|
"``EnumClass.member``. In Python versions ``3.5`` to ``3.10`` you could "
|
|
"access members from other members -- this practice was discouraged, and in "
|
|
"``3.11`` :class:`Enum` returns to not allowing it::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:968
|
|
msgid "Creating members that are mixed with other data types"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:970
|
|
msgid ""
|
|
"When subclassing other data types, such as :class:`int` or :class:`str`, "
|
|
"with an :class:`Enum`, all values after the ``=`` are passed to that data "
|
|
"type's constructor. For example::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:982
|
|
msgid "Boolean value of ``Enum`` classes and members"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:984
|
|
msgid ""
|
|
"Enum classes that are mixed with non-:class:`Enum` types (such as :class:"
|
|
"`int`, :class:`str`, etc.) are evaluated according to the mixed-in type's "
|
|
"rules; otherwise, all members evaluate as :data:`True`. To make your own "
|
|
"enum's boolean evaluation depend on the member's value add the following to "
|
|
"your class::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:993
|
|
msgid "Plain :class:`Enum` classes always evaluate as :data:`True`."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:997
|
|
msgid "``Enum`` classes with methods"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:999
|
|
msgid ""
|
|
"If you give your enum subclass extra methods, like the `Planet`_ class "
|
|
"below, those methods will show up in a :func:`dir` of the member, but not of "
|
|
"the class::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1010
|
|
msgid "Combining members of ``Flag``"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1030
|
|
msgid "``Flag`` and ``IntFlag`` minutia"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1032
|
|
msgid "Using the following snippet for our examples::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1043
|
|
msgid "the following are true:"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1045
|
|
msgid "single-bit flags are canonical"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1046
|
|
msgid "multi-bit and zero-bit flags are aliases"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1047
|
|
msgid "only canonical flags are returned during iteration::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1052
|
|
msgid ""
|
|
"negating a flag or flag set returns a new flag/flag set with the "
|
|
"corresponding positive integer value::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1061
|
|
msgid "names of pseudo-flags are constructed from their members' names::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1066
|
|
msgid "multi-bit flags, aka aliases, can be returned from operations::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1077
|
|
msgid ""
|
|
"membership / containment checking: zero-valued flags are always considered "
|
|
"to be contained::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1083
|
|
msgid ""
|
|
"otherwise, only if all bits of one flag are in the other flag will True be "
|
|
"returned::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1095
|
|
msgid "STRICT --> raises an exception when presented with invalid values"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1096
|
|
msgid "CONFORM --> discards any invalid bits"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1097
|
|
msgid "EJECT --> lose Flag status and become a normal int with the given value"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1101
|
|
msgid "KEEP --> keep the extra bits"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1099
|
|
msgid "keeps Flag status and extra bits"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1100
|
|
msgid "extra bits do not show up in iteration"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1101
|
|
msgid "extra bits do show up in repr() and str()"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1103
|
|
msgid ""
|
|
"The default for Flag is ``STRICT``, the default for ``IntFlag`` is "
|
|
"``EJECT``, and the default for ``_convert_`` is ``KEEP`` (see ``ssl."
|
|
"Options`` for an example of when ``KEEP`` is needed)."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1111
|
|
msgid "How are Enums different?"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1118
|
|
msgid "Enum Classes"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1120
|
|
msgid ""
|
|
"The :class:`EnumType` metaclass is responsible for providing the :meth:"
|
|
"`__contains__`, :meth:`__dir__`, :meth:`__iter__` and other methods that "
|
|
"allow one to do things with an :class:`Enum` class that fail on a typical "
|
|
"class, such as `list(Color)` or `some_enum_var in Color`. :class:`EnumType` "
|
|
"is responsible for ensuring that various other methods on the final :class:"
|
|
"`Enum` class are correct (such as :meth:`__new__`, :meth:`__getnewargs__`, :"
|
|
"meth:`__str__` and :meth:`__repr__`)."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1130
|
|
msgid "Enum Members (aka instances)"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1132
|
|
msgid ""
|
|
"The most interesting thing about enum members is that they are singletons. :"
|
|
"class:`EnumType` creates them all while it is creating the enum class "
|
|
"itself, and then puts a custom :meth:`__new__` in place to ensure that no "
|
|
"new ones are ever instantiated by returning only the existing member "
|
|
"instances."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1141
|
|
msgid ""
|
|
"While :class:`Enum`, :class:`IntEnum`, :class:`StrEnum`, :class:`Flag`, and :"
|
|
"class:`IntFlag` are expected to cover the majority of use-cases, they cannot "
|
|
"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 ""
|
|
|
|
#: howto/enum.rst:1148
|
|
msgid "Omitting values"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1153
|
|
msgid "use instances of :class:`auto` for the value"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1154
|
|
msgid "use instances of :class:`object` as the value"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1155
|
|
msgid "use a descriptive string as the value"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1159
|
|
msgid ""
|
|
"Using any of these methods signifies to the user that these values are not "
|
|
"important, and also enables one to add, remove, or reorder members without "
|
|
"having to renumber the remaining members."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1165
|
|
msgid "Using :class:`auto`"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1167
|
|
msgid "Using :class:`auto` would look like::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1179
|
|
msgid "Using :class:`object`"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1181
|
|
msgid "Using :class:`object` would look like::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1191
|
|
msgid ""
|
|
"This is also a good example of why you might want to write your own :meth:"
|
|
"`__repr__`::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1207
|
|
msgid "Using a descriptive string"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1209
|
|
msgid "Using a string as the value would look like::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1221
|
|
msgid "Using a custom :meth:`__new__`"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1223
|
|
msgid "Using an auto-numbering :meth:`__new__` would look like::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1240
|
|
msgid ""
|
|
"To make a more general purpose ``AutoNumber``, add ``*args`` to the "
|
|
"signature::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1250
|
|
msgid ""
|
|
"Then when you inherit from ``AutoNumber`` you can write your own "
|
|
"``__init__`` to handle any extra arguments::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1269
|
|
msgid ""
|
|
"The :meth:`__new__` method, if defined, is used during creation of the Enum "
|
|
"members; it is then replaced by Enum's :meth:`__new__` which is used after "
|
|
"class creation for lookup of existing members."
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1275
|
|
msgid "OrderedEnum"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1277
|
|
msgid ""
|
|
"An ordered enumeration that is not based on :class:`IntEnum` and so "
|
|
"maintains the normal :class:`Enum` invariants (such as not being comparable "
|
|
"to other enumerations)::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1311
|
|
msgid "DuplicateFreeEnum"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1313
|
|
msgid ""
|
|
"Raises an error if a duplicate member name is found instead of creating an "
|
|
"alias::"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1344
|
|
msgid "Planet"
|
|
msgstr ""
|
|
|
|
#: 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 ""
|
|
|
|
#: howto/enum.rst:1375
|
|
msgid "TimePeriod"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1377
|
|
msgid "An example to show the :attr:`_ignore_` attribute in use::"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1396
|
|
msgid "Subclassing EnumType"
|
|
msgstr ""
|
|
|
|
#: howto/enum.rst:1398
|
|
msgid ""
|
|
"While most enum needs can be met by customizing :class:`Enum` subclasses, "
|
|
"either with class decorators or custom functions, :class:`EnumType` can be "
|
|
"subclassed to provide a different Enum experience."
|
|
msgstr ""
|