Analyse détaillée du code source du module enum en Python (exemple de code)

Ce que cet article vous apporte est une analyse détaillée (exemple de code) du code source du module enum en Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Article précédent "Explication détaillée des types d'énumération en Python (exemples de code) " À la fin de l'article, il est dit que si vous en avez l'occasion, vous pouvez jeter un oeil à son code source. Ensuite, lisez-le et voyez comment plusieurs fonctionnalités importantes du dénombrement sont mises en œuvre.

Pour lire cette partie, vous devez avoir une certaine compréhension de la programmation des métaclasses.

La duplication des noms de membres n'est pas autorisée

Ma première idée pour cette partie est de contrôler la clé dans __dict__. Mais cette méthode n'est pas bonne, __dict__ a une grande portée, elle contient tous les attributs et méthodes de la classe. Pas seulement l’espace de noms d’énumération. J'ai trouvé dans le code source que l'énumération utilise une autre méthode. Une instance de type dictionnaire peut être renvoyée via la méthode magique __prepare__. Dans ce cas, la méthode magique __prepare__ est utilisée pour personnaliser l'espace de noms, et les noms de membres répétés ne sont pas autorisés dans cet espace.

# 自己实现
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'

Regardez l'implémentation spécifique du module Enum :

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

_EnumDict dans le module crée une liste _member_names pour stocker les noms des membres. En effet, tous les espaces de noms ne sont pas les membres à l'intérieur. sont tous membres du recensement. Par exemple, __str__, __new__ et d'autres méthodes magiques ne le sont pas, donc le __setitem__ ici doit effectuer un filtrage : le module

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)

le considérera de manière plus complète.

Chaque membre a un attribut name et un attribut value

Dans le code ci-dessus, la valeur obtenue par Color.red est 1. Dans le module eumu, chaque membre de la classe d'énumération définie a un nom et une valeur d'attribut et si vous faites attention, vous constaterez que Color.red est un exemple de Color ; Comment cette situation est-elle réalisée ?

Cela est toujours fait avec des métaclasses et implémenté dans __new__ de métaclasses. L'idée spécifique est de créer d'abord la classe cible, puis de créer la même classe pour chaque membre, puis d'utiliser setattr pour ajouter la classe suivante. en tant qu'attribut de la classe cible. Le pseudo-code est le suivant :

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

Regardons la prochaine démo exécutable :

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

Le module enum permet à chaque membre d'avoir The. les idées d'implémentation pour les attributs name et value sont les mêmes (je ne publierai pas le code). EnumMeta.__new__ est au centre de ce module, et presque toutes les fonctionnalités d'énumération sont implémentées dans cette fonction.

Lorsque les valeurs des membres sont les mêmes, le deuxième membre est un alias du premier membre

A partir de cette section, vous n'utiliserez plus la description de votre propre classe implémentée. , mais illustre son implémentation en démontant le code du module enum, nous pouvons savoir que si les valeurs des membres sont les mêmes, ce dernier sera un alias. du premier :

from enum import Enum
class Color(Enum):
    red = 1
    _red = 1

print(Color.red is Color._red)  # True

D'ici on peut savoir que rouge et _red sont le même objet. Comment y parvenir ?

La métaclasse créera un attribut _member_map_ pour la classe d'énumération afin de stocker la relation de mappage entre les noms de membres et les membres. S'il s'avère que la valeur du membre créé est déjà dans la relation de mappage, l'objet dans le. La table de mappage sera utilisée. Remplacer :

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

D'un point de vue code, même si les valeurs des membres sont les mêmes, les objets seront toujours créés pour eux tous en premier, mais ceux créés plus tard. sera bientôt collecté (je pense que c'est là qu'il y a place à l'optimisation). En comparant avec la table de mappage _member_map_, le membre utilisé pour créer la valeur de membre remplace les suivants, mais les deux noms de membre seront dans _member_map_. Par exemple, red et _red dans l'exemple sont tous deux dans le dictionnaire, mais ils pointent vers. le même objet.

L'attribut _member_names_ n'enregistrera que le premier, qui sera lié à l'itération de l'énumération.

Les membres peuvent être obtenus via les valeurs des membres

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

Les membres de la classe d'énumération sont en mode singleton et la classe d'énumération créée par la métaclasse est également maintenue _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
            ...

Ensuite, renvoyez le singleton dans le __new__ d'Enum :

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__))

Parcourez les membres de manière itérative

La classe d'énumération prend en charge le parcours itératif de membres dans l’ordre défini. S’il y a des membres avec des valeurs en double, seul le premier membre en double sera obtenu. Pour les valeurs de membre en double, seul le premier membre est obtenu et l'attribut _member_names_ n'enregistrera que le premier :

class Enum(metaclass=EnumMeta):
    def __iter__(cls):
        return (cls._member_map_[name] for name in cls._member_names_)

Résumé

Les principales fonctionnalités du module enum C'est l'idée d'implémentation, dont presque toutes sont réalisées grâce à la magie noire des métaclasses. Les membres ne peuvent pas être comparés en taille mais peuvent être comparés en valeur égale. Il n'est pas nécessaire d'en parler. Ceci est en fait hérité de l'objet. Il a des "fonctionnalités" sans rien faire de plus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!