`enum` — Unterstützung für Aufzählungen¶

Hinzugefügt in Version 3.4.

Eine Aufzählung

ist eine Menge von symbolischen Namen (Mitgliedern), die eindeutigen Werten zugeordnet sind.
kann durchlaufen werden, um ihre kanonischen (d. h. Nicht-Alias-) Mitglieder in der Definitionsreihenfolge zurückzugeben.
verwendet die Aufruf-Syntax, um Mitglieder nach Wert zurückzugeben.
verwendet die Index-Syntax, um Mitglieder nach Namen zurückzugeben.

Aufzählungen werden entweder durch Verwendung der class-Syntax oder durch Verwendung der Funktionsaufruf-Syntax erstellt.

>>> from enum import Enum

>>> # class syntax
>>> class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3

>>> # functional syntax
>>> Color = Enum('Color', [('RED', 1), ('GREEN', 2), ('BLUE', 3)])

Obwohl wir die class-Syntax zum Erstellen von Enums verwenden können, sind Enums keine normalen Python-Klassen. Weitere Einzelheiten finden Sie unter Wie unterscheiden sich Enums?.

Hinweis

Nomenklatur

Die Klasse Color ist eine Aufzählung (oder Enum).
Die Attribute Color.RED, Color.GREEN usw. sind Aufzählungsmitglieder (oder Mitglieder) und sind funktionell Konstanten.
Die Enum-Mitglieder haben Namen und Werte (der Name von Color.RED ist RED, der Wert von Color.BLUE ist 3 usw.).

Modulinhalt¶

EnumType

Der type für Enum und seine Unterklassen.

Enum

Basisklasse zum Erstellen von aufgezählten Konstanten.

IntEnum

Basisklasse zum Erstellen von aufgezählten Konstanten, die auch Unterklassen von int sind. (Hinweise)

StrEnum

Basisklasse zum Erstellen von aufgezählten Konstanten, die auch Unterklassen von str sind. (Hinweise)

Flag

Basisklasse zum Erstellen von aufgezählten Konstanten, die mit den bitweisen Operationen kombiniert werden können, ohne ihre Flag-Mitgliedschaft zu verlieren.

IntFlag

Basisklasse zum Erstellen von aufgezählten Konstanten, die mit den bitweisen Operatoren kombiniert werden können, ohne ihre IntFlag-Mitgliedschaft zu verlieren. IntFlag-Mitglieder sind auch Unterklassen von int. (Hinweise)

ReprEnum

Wird von IntEnum, StrEnum und IntFlag verwendet, um den str() des gemischten Typs beizubehalten.

EnumCheck

Eine Aufzählung mit den Werten CONTINUOUS, NAMED_FLAGS und UNIQUE, zur Verwendung mit verify(), um sicherzustellen, dass verschiedene Einschränkungen von einer gegebenen Aufzählung erfüllt werden.

FlagBoundary

Eine Aufzählung mit den Werten STRICT, CONFORM, EJECT und KEEP, die eine feinere Kontrolle darüber ermöglicht, wie ungültige Werte in einer Aufzählung behandelt werden.

EnumDict

Eine Unterklasse von dict zur Verwendung beim Unterklassen von EnumType.

auto

Instanzen werden durch einen geeigneten Wert für Enum-Mitglieder ersetzt. StrEnum verwendet standardmäßig die kleingeschriebene Version des Mitgliedsnamens, während andere Enums standardmäßig mit 1 beginnen und von dort aus aufsteigen.

property()

Ermöglicht, dass Enum-Mitglieder Attribute haben, ohne mit Mitgliedernamen zu kollidieren. Die Attribute value und name werden auf diese Weise implementiert.

unique()

Enum-Klassendekorator, der sicherstellt, dass nur ein Name an einen Wert gebunden ist.

verify()

Enum-Klassendekorator, der vom Benutzer wählbare Einschränkungen für eine Aufzählung prüft.

member()

Macht obj zu einem Mitglied. Kann als Dekorator verwendet werden.

nonmember()

Macht obj nicht zu einem Mitglied. Kann als Dekorator verwendet werden.

global_enum()

Ändert die str() und repr() einer Enum, um ihre Mitglieder als zum Modul gehörig anstelle der Klasse anzuzeigen, und exportiert die Enum-Mitglieder in den globalen Namensraum.

show_flag_values()

Gibt eine Liste aller Zweierpotenzen zurück, die in einem Flag enthalten sind.

Hinzugefügt in Version 3.6: Flag, IntFlag, auto

Hinzugefügt in Version 3.11: StrEnum, EnumCheck, ReprEnum, FlagBoundary, property, member, nonmember, global_enum, show_flag_values

Hinzugefügt in Version 3.13: EnumDict

Datentypen¶

class enum.EnumType¶

EnumType ist die Metaklasse für enum-Aufzählungen. Es ist möglich, EnumType zu unterklassen – siehe Beispiele für Unterklassen von EnumType für Details.

EnumType ist verantwortlich für die Festlegung der korrekten Methoden __repr__(), __str__(), __format__() und __reduce__() für die endgültige enum, sowie für die Erstellung der Enum-Mitglieder, die ordnungsgemäße Behandlung von Duplikaten, die Iteration über die Enum-Klasse usw.

Hinzugefügt in Version 3.11: Vor 3.11 hieß EnumType EnumMeta, was immer noch als Alias verfügbar ist.

__call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Diese Methode wird auf zwei verschiedene Arten aufgerufen:

zum Nachschlagen eines vorhandenen Mitglieds

cls:

Die aufgerufene Enum-Klasse.

value:

Der nachzuschlagende Wert.
zur Verwendung der cls-Enum, um eine neue Enum zu erstellen (nur wenn die vorhandene Enum keine Mitglieder hat)

cls:

Die aufgerufene Enum-Klasse.

value:

Der Name der zu erstellenden neuen Enum.

names:

Die Namen/Werte der Mitglieder für die neue Enum.

module:

Der Name des Moduls, in dem die neue Enum erstellt wird.

qualname:

Der tatsächliche Speicherort im Modul, an dem diese Enum zu finden ist.

type:

Ein Mixin-Typ für die neue Enum.

start:

Der erste ganzzahlige Wert für die Enum (verwendet von auto).

boundary:

Wie mit ungültigen Werten aus Bitoperationen umgegangen wird (nur Flag).

__contains__(cls, member)¶

Gibt True zurück, wenn member zu cls gehört.

>>> some_var = Color.RED
>>> some_var in Color
True
>>> Color.RED.value in Color
True

Geändert in Version 3.12: Vor Python 3.12 wird ein TypeError ausgelöst, wenn ein Nicht-Enum-Mitglied in einer Containment-Prüfung verwendet wird.

__dir__(cls)¶

Gibt ['__class__', '__doc__', '__members__', '__module__'] und die Namen der Mitglieder in cls zurück.

>>> dir(Color)
['BLUE', 'GREEN', 'RED', '__class__', '__contains__', '__doc__', '__getitem__', '__init_subclass__', '__iter__', '__len__', '__members__', '__module__', '__name__', '__qualname__']

__getitem__(cls, name)¶

Gibt das Enum-Mitglied in cls zurück, das mit name übereinstimmt, oder löst einen KeyError aus.

>>> Color['BLUE']
<Color.BLUE: 3>

__iter__(cls)¶

Gibt jedes Mitglied in cls in der Definitionsreihenfolge zurück.

>>> list(Color)
[<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>]

__len__(cls)¶

Gibt die Anzahl der Mitglieder in cls zurück.

>>> len(Color)
3

__members__¶: Gibt eine Zuordnung jedes Enum-Namens zu seinem Mitglied zurück, einschließlich Aliase.

__reversed__(cls)¶

Gibt jedes Mitglied in cls in umgekehrter Definitionsreihenfolge zurück.

>>> list(reversed(Color))
[<Color.BLUE: 3>, <Color.GREEN: 2>, <Color.RED: 1>]

class enum.Enum¶

Enum ist die Basisklasse für alle enum-Aufzählungen.

name¶

Der Name, der zur Definition des Enum-Mitglieds verwendet wurde.

>>> Color.BLUE.name
'BLUE'

value¶

Der Wert, der dem Enum-Mitglied zugewiesen wurde.

>>> Color.RED.value
1

Wert des Mitglieds, kann in __new__() gesetzt werden.

Hinweis

Enum-Mitgliedswerte

Mitgliedswerte können alles sein: int, str, etc. Wenn der genaue Wert unwichtig ist, können Sie auto-Instanzen verwenden und ein geeigneter Wert wird für Sie gewählt. Siehe auto für Details.

Obwohl veränderliche/nicht hashbare Werte wie dict, list oder ein veränderliches dataclass verwendet werden können, haben sie während der Erstellung eine quadratische Auswirkung auf die Leistung im Verhältnis zur Gesamtzahl der veränderlichen/nicht hashbaren Werte in der Enum.

_name_¶: Name des Mitglieds.

_value_¶: Wert des Mitglieds, kann in __new__() gesetzt werden.

_order_¶: Wird nicht mehr verwendet, aus Gründen der Abwärtskompatibilität beibehalten. (Klassenattribut, während der Klassenerstellung entfernt).

_ignore_¶

_ignore_ wird nur während der Erstellung verwendet und aus der Aufzählung entfernt, sobald die Erstellung abgeschlossen ist.

_ignore_ ist eine Liste von Namen, die keine Mitglieder werden und deren Namen auch aus der abgeschlossenen Aufzählung entfernt werden. Siehe Zeitraum als Beispiel.

__dir__(self)¶

Gibt ['__class__', '__doc__', '__module__', 'name', 'value'] und alle öffentlichen Methoden zurück, die auf self.__class__ definiert sind.

>>> from enum import Enum
>>> from datetime import date
>>> class Weekday(Enum):
...     MONDAY = 1
...     TUESDAY = 2
...     WEDNESDAY = 3
...     THURSDAY = 4
...     FRIDAY = 5
...     SATURDAY = 6
...     SUNDAY = 7
...     @classmethod
...     def today(cls):
...         print('today is %s' % cls(date.today().isoweekday()).name)
...
>>> dir(Weekday.SATURDAY)
['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'today', 'value']

_generate_next_value_(name, start, count, last_values)¶

name:

Der Name des zu definierenden Mitglieds (z. B. 'RED').

start:

Der Startwert für die Enum; der Standardwert ist 1.

count:

Die Anzahl der aktuell definierten Mitglieder, dieses nicht eingeschlossen.

last_values:

Eine Liste der vorherigen Werte.

Ein staticmethod, der verwendet wird, um den nächsten von auto zurückgegebenen Wert zu bestimmen.

>>> from enum import auto, Enum
>>> class PowersOfThree(Enum):
...     @staticmethod
...     def _generate_next_value_(name, start, count, last_values):
...         return 3 ** (count + 1)
...     FIRST = auto()
...     SECOND = auto()
...
>>> PowersOfThree.SECOND.value
9

__init__(self, *args, **kwds)¶

Standardmäßig tut dies nichts. Wenn mehrere Werte in der Mitgliedszuweisung angegeben werden, werden diese Werte zu separaten Argumenten für __init__; z.B.

>>> from enum import Enum
>>> class Weekday(Enum):
...     MONDAY = 1, 'Mon'

Weekday.__init__() würde als Weekday.__init__(self, 1, 'Mon') aufgerufen.

__init_subclass__(cls, **kwds)¶: Ein classmethod, das zur weiteren Konfiguration nachfolgender Unterklassen verwendet wird. Standardmäßig tut dies nichts.

_missing_(cls, value)¶

Ein classmethod zum Nachschlagen von Werten, die nicht in cls gefunden wurden. Standardmäßig tut es nichts, kann aber überschrieben werden, um benutzerdefiniertes Suchverhalten zu implementieren.

>>> from enum import auto, StrEnum
>>> class Build(StrEnum):
...     DEBUG = auto()
...     OPTIMIZED = auto()
...     @classmethod
...     def _missing_(cls, value):
...         value = value.lower()
...         for member in cls:
...             if member.value == value:
...                 return member
...         return None
...
>>> Build.DEBUG.value
'debug'
>>> Build('deBUG')
<Build.DEBUG: 'debug'>

__new__(cls, *args, **kwds)¶

Standardmäßig existiert dies nicht. Wenn es entweder in der Enum-Klassendefinition oder in einer Mixin-Klasse (wie int) angegeben wird, werden alle Werte, die in der Mitgliedszuweisung angegeben sind, übergeben; z.B.

>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     TWENTYSIX = '1a', 16

führt zu dem Aufruf int('1a', 16) und einem Wert von 26 für das Mitglied.

Hinweis

Beim Schreiben eines benutzerdefinierten __new__, verwenden Sie nicht super().__new__ – rufen Sie stattdessen das entsprechende __new__ auf.

__repr__(self)¶

Gibt die Zeichenkette zurück, die für repr()-Aufrufe verwendet wird. Standardmäßig wird der Enum-Name, der Mitgliedsname und der Wert zurückgegeben, kann aber überschrieben werden.

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __repr__(self):
...         cls_name = self.__class__.__name__
...         return f'{cls_name}.{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(OtherStyle.ALTERNATE, 'OtherStyle.ALTERNATE', 'OtherStyle.ALTERNATE')

__str__(self)¶

Gibt die Zeichenkette zurück, die für str()-Aufrufe verwendet wird. Standardmäßig wird der Enum-Name und der Mitgliedsname zurückgegeben, kann aber überschrieben werden.

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __str__(self):
...         return f'{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(<OtherStyle.ALTERNATE: 1>, 'ALTERNATE', 'ALTERNATE')

__format__(self)¶

Gibt die Zeichenkette zurück, die für format() und f-string-Aufrufe verwendet wird. Standardmäßig wird der Rückgabewert von __str__() zurückgegeben, kann aber überschrieben werden.

>>> from enum import auto, Enum
>>> class OtherStyle(Enum):
...     ALTERNATE = auto()
...     OTHER = auto()
...     SOMETHING_ELSE = auto()
...     def __format__(self, spec):
...         return f'{self.name}'
...
>>> OtherStyle.ALTERNATE, str(OtherStyle.ALTERNATE), f"{OtherStyle.ALTERNATE}"
(<OtherStyle.ALTERNATE: 1>, 'OtherStyle.ALTERNATE', 'ALTERNATE')

Hinweis

Die Verwendung von auto mit Enum führt zu aufsteigenden Ganzzahlen, beginnend mit 1.

Geändert in Version 3.12: Unterstützung für Dataclasses hinzugefügt.

_add_alias_()¶

Fügt einen neuen Namen als Alias zu einem vorhandenen Mitglied hinzu.

>>> Color.RED._add_alias_("ERROR")
>>> Color.ERROR
<Color.RED: 1>

Löst einen NameError aus, wenn der Name bereits einem anderen Mitglied zugewiesen ist.

Hinzugefügt in Version 3.13.

_add_value_alias_()¶

Fügt einen neuen Wert als Alias zu einem vorhandenen Mitglied hinzu.

>>> Color.RED._add_value_alias_(42)
>>> Color(42)
<Color.RED: 1>

Löst einen ValueError aus, wenn der Wert bereits mit einem anderen Mitglied verknüpft ist.

Hinzugefügt in Version 3.13.

class enum.IntEnum¶

IntEnum ist dasselbe wie Enum, aber seine Mitglieder sind auch Ganzzahlen und können überall verwendet werden, wo eine Ganzzahl verwendet werden kann. Wenn eine Ganzzahloperation mit einem IntEnum-Mitglied durchgeführt wird, verliert der resultierende Wert seinen Enumerationsstatus.

>>> from enum import IntEnum
>>> class Number(IntEnum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...
>>> Number.THREE
<Number.THREE: 3>
>>> Number.ONE + Number.TWO
3
>>> Number.THREE + 5
8
>>> Number.THREE == 3
True

Hinweis

Die Verwendung von auto mit IntEnum führt zu aufsteigenden Ganzzahlen, beginnend mit 1.

Geändert in Version 3.11: __str__() ist jetzt int.__str__(), um den Anwendungsfall Ersetzung vorhandener Konstanten besser zu unterstützen. __format__() war bereits int.__format__() aus demselben Grund.

class enum.StrEnum¶

StrEnum ist dasselbe wie Enum, aber seine Mitglieder sind auch Zeichenketten und können an den meisten Stellen verwendet werden, wo eine Zeichenkette verwendet werden kann. Das Ergebnis jeder Zeichenkettenoperation, die auf oder mit einem StrEnum-Mitglied durchgeführt wird, ist nicht Teil der Aufzählung.

>>> from enum import StrEnum, auto
>>> class Color(StrEnum):
...     RED = 'r'
...     GREEN = 'g'
...     BLUE = 'b'
...     UNKNOWN = auto()
...
>>> Color.RED
<Color.RED: 'r'>
>>> Color.UNKNOWN
<Color.UNKNOWN: 'unknown'>
>>> str(Color.UNKNOWN)
'unknown'

Hinweis

Es gibt Stellen in der Standardbibliothek, die auf eine exakte str statt auf eine Unterklasse von str prüfen (d. h. type(unknown) == str statt isinstance(unknown, str)), und an diesen Stellen müssen Sie str(MyStrEnum.MY_MEMBER) verwenden.

Hinweis

Die Verwendung von auto mit StrEnum führt zu der kleingeschriebenen Mitgliedsnamen als Wert.

Hinweis

__str__() ist str.__str__(), um den Anwendungsfall Ersetzung vorhandener Konstanten besser zu unterstützen. __format__() ist ebenfalls str.__format__() aus demselben Grund.

Hinzugefügt in Version 3.11.

class enum.Flag¶

Flag ist dasselbe wie Enum, aber seine Mitglieder unterstützen die bitweisen Operatoren & (AND), | (OR), ^ (XOR) und ~ (INVERT); die Ergebnisse dieser Operationen sind (Aliase von) Mitglieder der Aufzählung.

__contains__(self, value)¶

Gibt True zurück, wenn value in self ist.

>>> from enum import Flag, auto
>>> class Color(Flag):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> purple = Color.RED | Color.BLUE
>>> white = Color.RED | Color.GREEN | Color.BLUE
>>> Color.GREEN in purple
False
>>> Color.GREEN in white
True
>>> purple in white
True
>>> white in purple
False

__iter__(self)

Gibt alle enthaltenen Nicht-Alias-Mitglieder zurück.

>>> list(Color.RED)
[<Color.RED: 1>]
>>> list(purple)
[<Color.RED: 1>, <Color.BLUE: 4>]

Hinzugefügt in Version 3.11.

__len__(self)

Gibt die Anzahl der Mitglieder im Flag zurück.

>>> len(Color.GREEN)
1
>>> len(white)
3

Hinzugefügt in Version 3.11.

__bool__(self)

Gibt True zurück, wenn Mitglieder im Flag vorhanden sind, sonst False.

>>> bool(Color.GREEN)
True
>>> bool(white)
True
>>> black = Color(0)
>>> bool(black)
False

__or__(self, other)¶

Gibt das aktuelle Flag, bitweise ODER mit other, zurück.

>>> Color.RED | Color.GREEN
<Color.RED|GREEN: 3>

__and__(self, other)¶

Gibt das aktuelle Flag, bitweise UND mit other, zurück.

>>> purple & white
<Color.RED|BLUE: 5>
>>> purple & Color.GREEN
<Color: 0>

__xor__(self, other)¶

Gibt das aktuelle Flag, bitweise XOR mit other, zurück.

>>> purple ^ white
<Color.GREEN: 2>
>>> purple ^ Color.GREEN
<Color.RED|GREEN|BLUE: 7>

__invert__(self)

Gibt alle Flags in type(self) zurück, die nicht in self enthalten sind.

>>> ~white
<Color: 0>
>>> ~purple
<Color.GREEN: 2>
>>> ~Color.RED
<Color.GREEN|BLUE: 6>

_numeric_repr_()¶: Funktion zur Formatierung von verbleibenden unbenannten numerischen Werten. Standardmäßig der reprä der Wert; gängige Optionen sind hex() und oct().

Hinweis

Die Verwendung von auto mit Flag ergibt Ganzzahlen, die Zweierpotenzen sind, beginnend mit 1.

Geändert in Version 3.11: Das repr() von Null-wertigen Flags hat sich geändert. Es ist jetzt.

>>> Color(0)
<Color: 0>

class enum.IntFlag¶

IntFlag ist dasselbe wie Flag, aber seine Mitglieder sind auch Ganzzahlen und können überall verwendet werden, wo eine Ganzzahl verwendet werden kann.

>>> from enum import IntFlag, auto
>>> class Color(IntFlag):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> Color.RED & 2
<Color: 0>
>>> Color.RED | 2
<Color.RED|GREEN: 3>

Wenn eine Ganzzahloperation mit einem IntFlag-Mitglied durchgeführt wird, ist das Ergebnis kein IntFlag.

>>> Color.RED + 2
3

Wenn eine Flag-Operation mit einem IntFlag-Mitglied durchgeführt wird und

das Ergebnis ein gültiges IntFlag ist: ein IntFlag wird zurückgegeben.
das Ergebnis ist kein gültiges IntFlag: das Ergebnis hängt von der Einstellung von FlagBoundary ab.

Das repr() von unbenannten Null-wertigen Flags hat sich geändert. Es ist jetzt.

>>> Color(0)
<Color: 0>

Hinweis

Die Verwendung von auto mit IntFlag ergibt Ganzzahlen, die Zweierpotenzen sind, beginnend mit 1.

Geändert in Version 3.11: __str__() ist jetzt int.__str__(), um den Anwendungsfall Ersetzung vorhandener Konstanten besser zu unterstützen. __format__() war bereits int.__format__() aus demselben Grund.

Die Inversion eines IntFlag gibt jetzt einen positiven Wert zurück, der die Vereinigung aller Flags ist, die nicht im gegebenen Flag enthalten sind, anstatt eines negativen Werts. Dies entspricht dem vorhandenen Verhalten von Flag.

class enum.ReprEnum¶

ReprEnum verwendet das repr() von Enum, aber das str() des gemischten Datentyps

int.__str__() für IntEnum und IntFlag
str.__str__() für StrEnum

Erben Sie von ReprEnum, um das str() / format() des gemischten Datentyps beizubehalten, anstatt das Enum-Standard-str() zu verwenden.

Hinzugefügt in Version 3.11.

class enum.EnumCheck¶

EnumCheck enthält die Optionen, die vom Dekorator verify() verwendet werden, um verschiedene Einschränkungen zu überprüfen; fehlgeschlagene Einschränkungen führen zu einem ValueError.

UNIQUE¶

Stellen Sie sicher, dass jeder Wert nur einen Namen hat

>>> from enum import Enum, verify, UNIQUE
>>> @verify(UNIQUE)
... class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 3
...     CRIMSON = 1
Traceback (most recent call last):
...
ValueError: aliases found in <enum 'Color'>: CRIMSON -> RED

CONTINUOUS¶

Stellen Sie sicher, dass zwischen dem niedrigstwertigen und dem höchstwertigen Mitglied keine Werte fehlen

>>> from enum import Enum, verify, CONTINUOUS
>>> @verify(CONTINUOUS)
... class Color(Enum):
...     RED = 1
...     GREEN = 2
...     BLUE = 5
Traceback (most recent call last):
...
ValueError: invalid enum 'Color': missing values 3, 4

NAMED_FLAGS¶

Stellen Sie sicher, dass alle Flag-Gruppen/-Masken nur benannte Flags enthalten – nützlich, wenn Werte angegeben und nicht von auto() generiert werden

>>> from enum import Flag, verify, NAMED_FLAGS
>>> @verify(NAMED_FLAGS)
... class Color(Flag):
...     RED = 1
...     GREEN = 2
...     BLUE = 4
...     WHITE = 15
...     NEON = 31
Traceback (most recent call last):
...
ValueError: invalid Flag 'Color': aliases WHITE and NEON are missing combined values of 0x18 [use enum.show_flag_values(value) for details]

Hinweis

CONTINUOUS und NAMED_FLAGS sind für die Arbeit mit ganzzahligen Mitgliedern konzipiert.

Hinzugefügt in Version 3.11.

class enum.FlagBoundary¶

FlagBoundary steuert, wie Werte außerhalb des Bereichs in Flag und seinen Unterklassen behandelt werden.

STRICT¶

Werte außerhalb des Bereichs führen dazu, dass ein ValueError ausgelöst wird. Dies ist der Standard für Flag

>>> from enum import Flag, STRICT, auto
>>> class StrictFlag(Flag, boundary=STRICT):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> StrictFlag(2**2 + 2**4)
Traceback (most recent call last):
...
ValueError: <flag 'StrictFlag'> invalid value 20
    given 0b0 10100
  allowed 0b0 00111

CONFORM¶

Werte außerhalb des Bereichs werden ungültige Werte entfernt, wodurch ein gültiger Flag-Wert übrig bleibt

>>> from enum import Flag, CONFORM, auto
>>> class ConformFlag(Flag, boundary=CONFORM):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> ConformFlag(2**2 + 2**4)
<ConformFlag.BLUE: 4>

EJECT¶

Werte außerhalb des Bereichs verlieren ihre Flag-Mitgliedschaft und kehren zu int zurück.

>>> from enum import Flag, EJECT, auto
>>> class EjectFlag(Flag, boundary=EJECT):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> EjectFlag(2**2 + 2**4)
20

KEEP¶

Werte außerhalb des Bereichs werden beibehalten, und die Flag-Mitgliedschaft bleibt erhalten. Dies ist der Standard für IntFlag

>>> from enum import Flag, KEEP, auto
>>> class KeepFlag(Flag, boundary=KEEP):
...     RED = auto()
...     GREEN = auto()
...     BLUE = auto()
...
>>> KeepFlag(2**2 + 2**4)
<KeepFlag.BLUE|16: 20>

Hinzugefügt in Version 3.11.

class enum.EnumDict¶

EnumDict ist eine Unterklasse von dict, die als Namensraum für die Definition von Enum-Klassen verwendet wird (siehe Vorbereitung des Klassen-Namensraums). Sie wird freigegeben, um Unterklassen von EnumType mit erweitertem Verhalten, wie z. B. mehreren Werten pro Mitglied, zu ermöglichen. Sie sollte mit dem Namen der zu erstellenden Enum-Klasse aufgerufen werden, andernfalls werden private Namen und interne Klassen nicht korrekt behandelt.

Beachten Sie, dass nur die MutableMapping-Schnittstelle (__setitem__() und update()) überschrieben wird. Es kann möglich sein, die Prüfungen unter Umgehung anderer dict-Operationen wie |= zu umgehen.

member_names¶: Eine Liste von Mitgliedsnamen.

Hinzugefügt in Version 3.13.

Unterstützte `dunder`-Namen¶

__members__ ist eine schreibgeschützte geordnete Abbildung von member_name:member Elementen. Sie ist nur auf der Klasse verfügbar.

__new__(), falls angegeben, muss die Enum-Mitglieder erstellen und zurückgeben; es ist auch sehr ratsam, das _value_ des Mitglieds entsprechend zu setzen. Sobald alle Mitglieder erstellt sind, wird es nicht mehr verwendet.

Unterstützte `_sunder_`-Namen¶

_name_ – Name des Mitglieds
_value_ – Wert des Mitglieds; kann in __new__ gesetzt werden
_missing_() – eine Suchfunktion, die verwendet wird, wenn ein Wert nicht gefunden wird; kann überschrieben werden
_ignore_ – eine Liste von Namen, entweder als list oder als str, die nicht in Mitglieder umgewandelt werden und aus der endgültigen Klasse entfernt werden
_order_ – wird nicht mehr verwendet, aus Gründen der Abwärtskompatibilität beibehalten (Klassenattribut, wird während der Klassenerstellung entfernt)
_generate_next_value_() – wird verwendet, um einen geeigneten Wert für ein Enum-Mitglied zu erhalten; kann überschrieben werden

Hinweis

Für Standard-Enum-Klassen ist der nächste gewählte Wert der höchste gesehene Wert plus eins.

Für Flag-Klassen ist der nächste gewählte Wert die nächsthöhere Zweierpotenz.
_add_alias_() – fügt einen neuen Namen als Alias zu einem bestehenden Mitglied hinzu.
_add_value_alias_() – fügt einen neuen Wert als Alias zu einem bestehenden Mitglied hinzu.
Während _sunder_-Namen im Allgemeinen für die Weiterentwicklung der Enum-Klasse reserviert sind und nicht verwendet werden können, sind einige explizit erlaubt
- _repr_* (z. B. _repr_html_), wie in der Rich-Display von IPython verwendet

Hinzugefügt in Version 3.6: _missing_, _order_, _generate_next_value_

Hinzugefügt in Version 3.7: _ignore_

Hinzugefügt in Version 3.13: _add_alias_, _add_value_alias_, _repr_*

Dienstprogramme und Dekoratoren¶

class enum.auto¶

auto kann anstelle eines Werts verwendet werden. Wenn es verwendet wird, ruft die Enum-Maschinerie die _generate_next_value_() eines Enum auf, um einen geeigneten Wert zu erhalten. Für Enum und IntEnum ist dieser Wert der letzte Wert plus eins; für Flag und IntFlag ist es die erste Zweierpotenz, die größer ist als der höchste Wert; für StrEnum ist es die kleingeschriebene Version des Namens des Mitglieds. Vorsicht ist geboten, wenn auto() mit manuell angegebenen Werten gemischt wird.

auto-Instanzen werden nur aufgelöst, wenn sie sich auf der obersten Ebene einer Zuweisung befinden

FIRST = auto() funktioniert (auto() wird durch 1 ersetzt);
SECOND = auto(), -2 funktioniert (auto wird durch 2 ersetzt, sodass 2, -2 zur Erstellung des SECOND-Enum-Mitglieds verwendet wird;
THREE = [auto(), -3] funktioniert nicht (es wird <auto instance>, -3 zur Erstellung des THREE-Enum-Mitglieds verwendet)

Geändert in Version 3.11.1: In früheren Versionen musste auto() das Einzige auf der Zuweisungszeile sein, um ordnungsgemäß zu funktionieren.

_generate_next_value_ kann überschrieben werden, um die von auto verwendeten Werte anzupassen.

Hinweis

In 3.13 gibt die Standard-_generate_next_value_ immer den höchsten Mitgliedswert plus 1 zurück und schlägt fehl, wenn ein Mitglied inkompatiblen Typs ist.

@enum.property¶: Ein Dekorator ähnlich dem eingebauten property, aber speziell für Aufzählungen. Er ermöglicht es, dass Mitglied-Attribute dieselben Namen wie die Mitglieder selbst haben.

Hinweis

Das property und das Mitglied müssen in separaten Klassen definiert werden; beispielsweise sind die Attribute value und name in der Enum-Klasse definiert, und Enum-Unterklassen können Mitglieder mit den Namen value und name definieren.

Hinzugefügt in Version 3.11.

@enum.unique¶

Ein class-Dekorator speziell für Aufzählungen. Er durchsucht die __members__ einer Aufzählung und sammelt alle gefundenen Aliase. Wenn welche gefunden werden, wird ein ValueError mit den Details ausgelöst

>>> from enum import Enum, unique
>>> @unique
... class Mistake(Enum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...     FOUR = 3
...
Traceback (most recent call last):
...
ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE

@enum.verify¶: Ein class-Dekorator speziell für Aufzählungen. Mitglieder aus EnumCheck werden verwendet, um anzugeben, welche Einschränkungen auf der dekorierten Aufzählung überprüft werden sollen.

Hinzugefügt in Version 3.11.

@enum.member¶: Ein Dekorator zur Verwendung in Enums: Sein Ziel wird ein Mitglied.

Hinzugefügt in Version 3.11.

@enum.nonmember¶: Ein Dekorator zur Verwendung in Enums: Sein Ziel wird kein Mitglied.

Hinzugefügt in Version 3.11.

@enum.global_enum¶: Ein Dekorator, um das str() und repr() eines Enums zu ändern, um seine Mitglieder als zum Modul gehörend anstatt zur Klasse gehörend anzuzeigen. Sollte nur verwendet werden, wenn die Enum-Mitglieder in den globalen Namensraum des Moduls exportiert werden (siehe re.RegexFlag als Beispiel).

Hinzugefügt in Version 3.11.

enum.show_flag_values(value)¶: Gibt eine Liste aller Zweierpotenzen zurück, die in einem Flag-Wert enthalten sind.

Hinzugefügt in Version 3.11.

Hinweise¶

IntEnum, StrEnum und IntFlag

Diese drei Enum-Typen sind als Drop-in-Ersatz für bestehende ganzzahlige und zeichenkettenbasierte Werte konzipiert; daher haben sie zusätzliche Einschränkungen

__str__ verwendet den Wert und nicht den Namen des Enum-Mitglieds

__format__ verwendet, da es __str__ verwendet, ebenfalls den Wert des Enum-Mitglieds anstelle seines Namens

Wenn Sie diese Einschränkungen nicht benötigen/wünschen, können Sie entweder Ihre eigene Basisklasse erstellen, indem Sie den int- oder str-Typ selbst einmischen
>>> from enum import Enum
>>> class MyIntEnum(int, Enum):
...     pass
oder Sie können das entsprechende str() usw. in Ihrem Enum neu zuweisen
>>> from enum import Enum, IntEnum
>>> class MyIntEnum(IntEnum):
...     __str__ = Enum.__str__

`enum` — Unterstützung für Aufzählungen¶

Modulinhalt¶

Datentypen¶

Unterstützte `dunder`-Namen¶

Unterstützte `_sunder_`-Namen¶

Dienstprogramme und Dekoratoren¶

Hinweise¶

Inhaltsverzeichnis

Vorheriges Thema

Nächstes Thema

Diese Seite

enum — Unterstützung für Aufzählungen¶

Modulinhalt¶

Datentypen¶

Unterstützte __dunder__-Namen¶

Unterstützte _sunder_-Namen¶

Dienstprogramme und Dekoratoren¶

Hinweise¶

`enum` — Unterstützung für Aufzählungen¶

Unterstützte `dunder`-Namen¶

Unterstützte `_sunder_`-Namen¶