python - 什么时候应该将EnumMeta子类化为Enum？

在this article中，Nick Coghlan谈到了进入PEP 435 Enum type的一些设计决策，以及如何将EnumMeta子类化以提供不同的Enum体验。
然而，关于使用元类，我给出的建议（我是主要的stdlibEnum作者）是，在没有真正好的理由的情况下，不应该这样做——比如不能用类修饰器完成您需要的工作，或者用一个专门的函数来隐藏任何丑陋之处；在我自己的工作中，我已经创建__new__类时，只需使用__init__、Enum和/或普通类/实例方法即可执行所需的操作：
Enum with attributes
Handling missing members
class constants that are not Enum members
此外，还有一个值得注意的故事，即在深入研究包含和不包含元类子类的Enum时要小心：
Is it possible to override __new__ in an enum to parse strings to an instance?
考虑到这些，我什么时候需要摆弄EnumMeta本身呢？

最佳答案

迄今为止，我所看到的最好（也是唯一）的子类化案例来自这三个问题：
A more pythonic way to define an enum with dynamic members
Python enum prevent invalid attribute assignment
Create an abstract Enum class
我们将在这里进一步研究动态成员案例。
首先，看一下不进行子类化时所需的代码：
stdlib方式

from enum import Enum
import json

class BaseCountry(Enum):
    def __new__(cls, record):
        member = object.__new__(cls)
        member.country_name = record['name']
        member.code = int(record['country-code'])
        member.abbr = record['alpha-2']
        member._value_ = member.abbr, member.code, member.country_name
        if not hasattr(cls, '_choices'):
            cls._choices = {}
        cls._choices[member.code] = member.country_name
        cls._choices[member.abbr] = member.country_name
        return member
    def __str__(self):
        return self.country_name

Country = BaseCountry(
        'Country',
        [(rec['alpha-2'], rec) for rec in json.load(open('slim-2.json'))],
        )

EnumMeta路12

from aenum import Enum, MultiValue
import json

class Country(Enum, init='abbr code country_name', settings=MultiValue):
    _ignore_ = 'country this'  # do not add these names as members
    # create members
    this = vars()
    for country in json.load(open('slim-2.json')):
        this[country['alpha-2']] = (
                country['alpha-2'],
                int(country['country-code']),
                country['name'],
                )
    # have str() print just the country name
    def __str__(self):
        return self.country_name

上面的代码对于一次性枚举来说很好——但是如果从JSON文件创建枚举对您来说很常见呢？想象一下，如果你可以这样做：

class Country(JSONEnum):
    _init_ = 'abbr code country_name'  # remove if not using aenum
    _file = 'some_file.json'
    _name = 'alpha-2'
    _value = {
            1: ('alpha-2', None),
            2: ('country-code', lambda c: int(c)),
            3: ('name', None),
            }

如你所见：
EnumMeta是要使用的JSON文件的名称
aenum是应该用于名称的路径
_file是将路径映射到值的字典3
_name指定不同值组件的属性名称（如果使用_value）
JSON数据取自https://github.com/lukes/ISO-3166-Countries-with-Regional-Codes——以下是一个简短的摘录：
[“name”：“阿富汗”，“alpha-2”：“af”，“country code”：“004”，
“name”：“_land islands”，“alpha-2”：“ax”，“country code”：“248”，
“name”：“阿尔巴尼亚”，“alpha-2”：“al”，“country code”：“008”，
“name”：“阿尔及利亚”，“alpha-2”：“dz”，“country code”：“012”]
以下是_init_类：

class JSONEnumMeta(EnumMeta):

    @classmethod
    def __prepare__(metacls, cls, bases, **kwds):
        # return a standard dictionary for the initial processing
        return {}

    def __init__(cls, *args , **kwds):
        super(JSONEnumMeta, cls).__init__(*args)

    def __new__(metacls, cls, bases, clsdict, **kwds):
        import json
        members = []
        missing = [
               name
               for name in ('_file', '_name', '_value')
               if name not in clsdict
               ]
        if len(missing) in (1, 2):
            # all three must be present or absent
            raise TypeError('missing required settings: %r' % (missing, ))
        if not missing:
            # process
            name_spec = clsdict.pop('_name')
            if not isinstance(name_spec, (tuple, list)):
                name_spec = (name_spec, )
            value_spec = clsdict.pop('_value')
            file = clsdict.pop('_file')
            with open(file) as f:
                json_data = json.load(f)
            for data in json_data:
                values = []
                name = data[name_spec[0]]
                for piece in name_spec[1:]:
                    name = name[piece]
                for order, (value_path, func) in sorted(value_spec.items()):
                    if not isinstance(value_path, (list, tuple)):
                        value_path = (value_path, )
                    value = data[value_path[0]]
                    for piece in value_path[1:]:
                        value = value[piece]
                    if func is not None:
                        value = func(value)
                    values.append(value)
                values = tuple(values)
                members.append(
                    (name, values)
                    )
        # get the real EnumDict
        enum_dict = super(JSONEnumMeta, metacls).__prepare__(cls, bases, **kwds)
        # transfer the original dict content, _items first
        items = list(clsdict.items())
        items.sort(key=lambda p: (0 if p[0][0] == '_' else 1, p))
        for name, value in items:
            enum_dict[name] = value
        # add the members
        for name, value in members:
            enum_dict[name] = value
        return super(JSONEnumMeta, metacls).__new__(metacls, cls, bases, enum_dict, **kwds)

# for use with both Python 2/3
JSONEnum = JSONEnumMeta('JsonEnum', (Enum, ), {})

几点注意事项
aenum返回正常值
JSONEnumMeta用于获取JSONEnumMeta.__prepare__的实例--这是获取实例的正确方法
带有前导下划线的键首先传递给realdict，因为在处理枚举成员时可能需要它们。
枚举成员的顺序与它们在文件中的顺序相同
1披露：我是Python stdlib EnumMeta.__prepare__库、_EnumDict backport库和Advanced Enumeration (_EnumDict)库的作者。
2这需要Enum。
3如果您的enum34需要多个值，则键是数字以保持多个值的顺序。