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'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)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
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) # 1Lorsque 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
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 ...
Les membres peuvent être obtenus via les valeurs des membres
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__))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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
