Dieser Artikel bietet Ihnen eine detaillierte Analyse (Codebeispiel) des Quellcodes des Enum-Moduls in Python. Ich hoffe, dass er Ihnen als Referenz dienen wird.
Vorheriger Artikel „Detaillierte Erläuterung der Aufzählungstypen in Python (Codebeispiele) “ Am Ende des Artikels heißt es, dass Sie bei Gelegenheit einen Blick darauf werfen können seinen Quellcode. Dann lesen Sie es und sehen Sie, wie mehrere wichtige Funktionen der Aufzählung implementiert werden.
Um diesen Teil lesen zu können, müssen Sie über ein gewisses Verständnis der Metaklassenprogrammierung verfügen.
Das Duplizieren von Mitgliedsnamen ist nicht erlaubt
Meine erste Idee für diesen Teil ist, den Schlüssel in __dict__ zu steuern. Aber dieser Weg ist nicht gut, __dict__ hat einen großen Umfang und enthält alle Attribute und Methoden der Klasse. Nicht nur der Enumerations-Namespace. Ich habe im Quellcode festgestellt, dass enum eine andere Methode verwendet. Eine wörterbuchähnliche Instanz kann über die Magic-Methode __prepare__ zurückgegeben werden. In diesem Fall wird die Magic-Methode __prepare__ zum Anpassen des Namespace verwendet, und wiederholte Mitgliedsnamen sind in diesem Bereich nicht zulässig.
# 自己实现
class _Dict(dict):
def __setitem__(self, key, value):
if key in self:
raise TypeError('Attempted to reuse key: %r' % key)
super().__setitem__(key, value)
class MyMeta(type):
@classmethod
def __prepare__(metacls, name, bases):
d = _Dict()
return d
class Enum(metaclass=MyMeta):
pass
class Color(Enum):
red = 1
red = 1 # TypeError: Attempted to reuse key: 'red'class _EnumDict(dict):
def __init__(self):
super().__init__()
self._member_names = []
...
def __setitem__(self, key, value):
...
elif key in self._member_names:
# descriptor overwriting an enum?
raise TypeError('Attempted to reuse key: %r' % key)
...
self._member_names.append(key)
super().__setitem__(key, value)
class EnumMeta(type):
@classmethod
def __prepare__(metacls, cls, bases):
enum_dict = _EnumDict()
...
return enum_dict
class Enum(metaclass=EnumMeta):
...def __setitem__(self, key, value):
if _is_sunder(key): # 下划线开头和结尾的，如 _order__
raise ValueError('_names_ are reserved for future Enum use')
elif _is_dunder(key): # 双下划线结尾的, 如 __new__
if key == '__order__':
key = '_order_'
elif key in self._member_names: # 重复定义的 key
raise TypeError('Attempted to reuse key: %r' % key)
elif not _is_descriptor(value): # value得不是描述符
self._member_names.append(key)
self._last_values.append(value)
super().__setitem__(key, value)Jedes Mitglied hat ein Namensattribut und ein Wertattribut
Im obigen Code ist der von Color.red erhaltene Wert 1. Im eumu-Modul hat jedes Mitglied der definierten Aufzählungsklasse einen Namen und einen Attributwert. Wenn Sie vorsichtig sind, werden Sie feststellen, dass Color.red ein Beispiel für Color ist. Wie wird diese Situation erreicht? Es wird immer noch mit Metaklassen durchgeführt und in __new__ von Metaklassen implementiert. Die spezifische Idee besteht darin, zuerst die Zielklasse zu erstellen, dann für jedes Mitglied dieselbe Klasse zu erstellen und dann setattr zum Hinzufügen weiterer Klassen zu verwenden Als Attribut für die Zielklasse lautet der Pseudocode wie folgt:def __new__(metacls, cls, bases, classdict): __new__ = cls.__new__ # 创建枚举类 enum_class = super().__new__() # 每个成员都是cls的示例，通过setattr注入到目标类中 for name, value in cls.members.items(): member = super().__new__() member.name = name member.value = value setattr(enum_class, name, member) return enum_class
class _Dict(dict):
def __init__(self):
super().__init__()
self._member_names = []
def __setitem__(self, key, value):
if key in self:
raise TypeError('Attempted to reuse key: %r' % key)
if not key.startswith("_"):
self._member_names.append(key)
super().__setitem__(key, value)
class MyMeta(type):
@classmethod
def __prepare__(metacls, name, bases):
d = _Dict()
return d
def __new__(metacls, cls, bases, classdict):
__new__ = bases[0].__new__ if bases else object.__new__
# 创建枚举类
enum_class = super().__new__(metacls, cls, bases, classdict)
# 创建成员
for member_name in classdict._member_names:
value = classdict[member_name]
enum_member = __new__(enum_class)
enum_member.name = member_name
enum_member.value = value
setattr(enum_class, member_name, enum_member)
return enum_class
class MyEnum(metaclass=MyMeta):
pass
class Color(MyEnum):
red = 1
blue = 2
def __str__(self):
return "%s.%s" % (self.__class__.__name__, self.name)
print(Color.red) # Color.red
print(Color.red.name) # red
print(Color.red.value) # 1Wenn die Mitgliedswerte gleich sind, ist das zweite Mitglied ein Alias des ersten Mitglieds
Ab diesem Abschnitt verwenden Sie die Beschreibung nicht mehr Ihrer eigenen implementierten Klasse, veranschaulicht jedoch deren Implementierung durch Zerlegen des Codes des Enum-Moduls. Aus den Verwendungsmerkmalen des Moduls können wir erkennen, dass letzteres ein Alias ist, wenn die Mitgliedswerte gleich sind des ersteren:from enum import Enum class Color(Enum): red = 1 _red = 1 print(Color.red is Color._red) # True
class EnumMeta(type): def __new__(metacls, cls, bases, classdict): ... # create our new Enum type enum_class = super().__new__(metacls, cls, bases, classdict) enum_class._member_names_ = [] # names in definition order enum_class._member_map_ = OrderedDict() # name->value map for member_name in classdict._member_names: enum_member = __new__(enum_class) # If another member with the same value was already defined, the # new member becomes an alias to the existing one. for name, canonical_member in enum_class._member_map_.items(): if canonical_member._value_ == enum_member._value_: enum_member = canonical_member # 取代 break else: # Aliases don't appear in member names (only in __members__). enum_class._member_names_.append(member_name) # 新成员，添加到_member_names_中 enum_class._member_map_[member_name] = enum_member ...
Mitglieder können über Mitgliedswerte abgerufen werden
print(Color['red']) # Color.red 通过成员名来获取成员 print(Color(1)) # Color.red 通过成员值来获取成员
class EnumMeta(type):
def __new__(metacls, cls, bases, classdict):
...
# create our new Enum type
enum_class = super().__new__(metacls, cls, bases, classdict)
enum_class._value2member_map_ = {}
for member_name in classdict._member_names:
value = enum_members[member_name]
enum_member = __new__(enum_class)
enum_class._value2member_map_[value] = enum_member
...class Enum(metaclass=EnumMeta):
def __new__(cls, value):
if type(value) is cls:
return value
# 尝试从 _value2member_map_ 获取
try:
if value in cls._value2member_map_:
return cls._value2member_map_[value]
except TypeError:
# 从 _member_map_ 映射获取
for member in cls._member_map_.values():
if member._value_ == value:
return member
raise ValueError("%r is not a valid %s" % (value, cls.__name__))Iterativ die Mitglieder durchlaufen
Die Aufzählungsklasse unterstützt das iterative Durchlaufen von Mitgliedern in der definierten Reihenfolge. Wenn Mitglieder mit doppelten Werten vorhanden sind, wird nur das erste doppelte Mitglied erhalten. Bei doppelten Mitgliedswerten wird nur das erste Mitglied abgerufen und das Attribut _member_names_ zeichnet nur das erste auf:class Enum(metaclass=EnumMeta): def __iter__(cls): return (cls._member_map_[name] for name in cls._member_names_)
Zusammenfassung
Implementierung der Kernfunktionen des Enum-Modul Dies ist die Idee, die fast vollständig durch schwarze Magie der Metaklasse erreicht wird. Die Mitglieder können nicht in ihrer Größe verglichen werden, wohl aber in ihrem gleichen Wert. Es besteht kein Grund, darüber zu sprechen. Dies wird tatsächlich vom Objekt geerbt. Es verfügt über „Funktionen“, ohne etwas Besonderes zu tun.Das obige ist der detaillierte Inhalt vonDetaillierte Analyse des Quellcodes des Enum-Moduls in Python (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
