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

Question

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

假设我有一个父类(super class)。由此，我派生了许多子类，但所有这些子类都需要定义一些类属性。如果我正常这样做，它会看起来像:

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'])

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

看，我之前尝试通过仅使用没有元类的父类(super class)来做到这一点，例如:

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 参数来检查带有属性名称的参数是否存在)

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