Detaillierte Analyse des Quellcodes des Enum-Moduls in Python (Codebeispiel)

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'

Sehen Sie sich die spezifische Implementierung des Enum-Moduls an:

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):
    ...

Das _EnumDict im Modul erstellt eine _member_names-Liste zum Speichern von Mitgliedsnamen. Dies liegt daran, dass nicht alle Mitglieder im Namespace ein sind Mitglied der Aufzählung. Bei __str__, __new__ und anderen magischen Methoden ist dies beispielsweise nicht der Fall, daher muss das __setitem__ hier etwas gefiltert werden: Das

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)

-Modul berücksichtigt es umfassender.

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

Schauen wir uns die nächste ausführbare Demo an:

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)  # 1

Das Enum-Modul ermöglicht es jedem Mitglied, einen Namen und einen Wert zu haben. Die Implementierungsidee von Attributen ist dieselbe (ich werde den Code nicht veröffentlichen). EnumMeta.__new__ steht im Mittelpunkt dieses Moduls und fast alle Aufzählungsfunktionen sind in dieser Funktion implementiert.

Wenn 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

Daraus können wir erkennen, dass rot und _red dasselbe Objekt sind. Wie erreicht man das?

Die Metaklasse erstellt ein _member_map_-Attribut für die Aufzählungsklasse, um die Zuordnungsbeziehung zwischen Mitgliedsnamen und Mitgliedern zu speichern. Wenn festgestellt wird, dass sich der Wert des erstellten Mitglieds bereits in der Zuordnungsbeziehung befindet, wird das Objekt in der Es wird eine Mapping-Tabelle verwendet. Ersetzt:

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
            ...

Aus Code-Sicht werden zunächst für alle Mitglieder Objekte erstellt, die erstellten Objekte jedoch Bald wird Müll gesammelt (ich denke, es gibt hier eine räumliche Optimierung). Durch den Vergleich mit der Zuordnungstabelle _member_map_ ersetzt das zum Erstellen des Mitgliedswerts verwendete Mitglied die nachfolgenden, aber beide Mitgliedsnamen befinden sich in der _member_map_. Beispielsweise sind red und _red im Beispiel beide im Wörterbuch enthalten, verweisen jedoch auf das gleiche ein Objekt.

Das Attribut _member_names_ zeichnet nur das erste auf, das sich auf die Iteration der Aufzählung bezieht.

Mitglieder können über Mitgliedswerte abgerufen werden

print(Color['red'])  # Color.red  通过成员名来获取成员
print(Color(1))      # Color.red  通过成员值来获取成员

Die Mitglieder in der Aufzählungsklasse sind im Singleton-Modus und die Werte werden auch in der Aufzählungsklasse verwaltet erstellt durch die Metaklasse Mapping-Beziehung zu member_value2member_map_:

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
            ...

Dann geben Sie den Singleton in Enums __new__ zurück:

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!