在 Python 中，是否可以使用元类来添加和删除许多类属性？

Question

具体来说，使用类属性创建更多类属性，然后删除原始属性是否可以接受/良好做法？

假设我有一个超类。由此，我派生了许多子类，但所有这些都需要定义一些类属性。如果我正常执行此操作，它看起来像：

class Bar(Foo):
    someval = 0
    someotherval = ('a', 'b', 'c')
    importantval = [1, 2, 3]
    thisval = 'this'
    names = ['John', 'Joe']

每个子类都需要定义所有这些属性。但是，如果我们以某种方式使用一个变量来创建所有这些变量，它会看起来像：

class Bar(Foo):
    classvars = (0, ('a', 'b', 'c'), [1, 2, 3], 'this', ['John', 'Joe'])

然后，在创建类之后，它在内部看起来与我们分别定义所有属性的类的版本相同。

看，我之前尝试过只使用没有元类的超类来做到这一点，例如：

class Foo:
    @classmethod
    def __init__(cls, val):
        cls.val = val

class Bar(Foo):
    Foo.__init__(5)

但是如果你知道@classmethod 是如何工作的，那么你就会知道cls 最终会成为一个类Foo 引用，而不是一个类Bar 引用（在Bar 的创建过程中调用时，并且cls 仅在 Bar 实例创建期间成为 Bar 引用）。然后我也尝试改用@staticmethod，但是据我所知，在创建类时，您不能引用在方法定义之外创建的类。

即

class Bar(Foo):
    Foo.__init__(Bar, 5)

这会引发 NameError（如果 Foo 的 __init__ 方法是静态方法）。

最终，我了解了元类，并发现我可以做到这一点：

class MetaFoo(type):
    def __init__(cls, name, bases, namespace):
        super(MetaFoo, cls).__init__(name, bases, namespace)
        if '_superclass' not in namespace:  # A special attribute to distinguish between classes that we want to affect and those that we don't
            attrnames = ('someval', 'someotherval', 'importantval', 'thisval', 'names')
            if 'classvars' in namespace:
                for attr, attrname in zip(getattr(cls, 'classvars'), attrnames):
                    setattr(cls, attrname, attr)
                    namespace[attrname] = attr
                delattr(cls, 'classvars')
            else:  # Allow the definitions to be separate, instead of through "classvars", but also make sure that all the required attributes are defined
                for attrname in attrnames:
                    if attrname not in namespace:
                        raise AttributeError('"%s" not found.' % attrname)


class Foo(metaclass=MetaFoo):
    _superclass = True  # The value of this attribute doesn't matter

    def __init__(self, value):
        self.value = value

    def dosomething(self):
        return self.value * self.someval  # Can use type(self).someval for the class attribute, as long as the class itself is never passed as self


class Bar(Foo):
    classvars = (5, ('c', 'b', 'a'), [3, 2, 1], 'This', ['Jimmy', 'Bob'])

简而言之，如果它找到一个名为classvars 的类属性，它会使用它来创建其他类属性，然后删除classvars。在这个例子中，做：

class Bar(Foo):
    classvars = (5, ('c', 'b', 'a'), [3, 2, 1], 'This', ['Jimmy', 'Bob'])

给你一个相同的结果：

class Bar(Foo):
    someval = 5
    someotherval = ('c', 'b', 'a')
    importantval = [3, 2, 1]
    thisval = 'This'
    names = ['Jimmy', 'Bob']

我的主要问题是：以这种方式使用元类是否可以接受（或者由于某种原因通常会避免），尤其是如果您已经出于充分的理由使用元类？

附带的问题是：没有元类有没有办法做到这一点？

Answer 1

是的，你可以这样做。但我不知道这是否比复制+粘贴所有需要的属性更好。

如果您这样做，为了让查看您的某个子类的代码的人（包括从现在起一周后的您）保持最低限度的可读性，您至少应该使用字典而不是序列。这样，在查看子类时，您将始终知道哪个值映射到每个属性。

另外，请记住，如果至少某些属性具有对许多子类有效的良好默认值，那么继承机制可以很好地保留这些默认值，同时允许您仅显式声明您指定的属性每个子类确实需要有所不同（并且键入的内容比使用字典要少，字典至少需要在名称周围加上额外的引号）。

否则，就语言而言，没关系。您宁愿在基类上有一个特殊的属性名称，允许您在基类主体上输入所需/所需的属性名称，而不是将它们硬编码在元类上：这看起来真的很“不文明”。通过在基类上拥有一个属性，元类可以针对不同的对象层次结构重用。

（只需使用for 迭代元类的bases 参数来检查是否存在具有属性名称的参数）

啊，因为它是问题的一部分：关于使用元类删除在类创建后无用的类属性 - 完全可以。