从元类设置实例变量

Question

给定一个元类，或更简单的type()，最后一个参数代表类字典，它负责类变量。我想知道，有没有办法从元类中设置 instance 变量？

我使用元类的原因是我需要收集一些在创建类时定义的变量并处理它们。但是，此处理的结果需要附加到类的每个实例，而不是类本身，因为结果将是一个列表，该列表会因类的一个实例与另一个实例不同。

我将提供一个示例，以便更容易关注我。

---

我有一个Model 类，定义如下：

class Model(object):
    __metaclass__ = ModelType

    has_many = None

    def __init__(self, **kwargs):
        self._fields = kwargs

has_many class 变量将在类定义中由某人认为需要的任何模型填充。在__init__() 中，我只是将模型实例化时提供的关键字分配给instance 变量_fields。

然后我有 ModelType 元类：

class ModelType(type):
    def __new__(cls, name, bases, dct):
        if 'has_many' in dct:
            dct['_restricted_fields'].append([has-many-model-name])

我需要在这里做的很简单。我检查是否有人在他的自定义模型类上定义了has_many class 变量，然后将该变量的内容添加到受限字段列表中。

现在是重要的部分。实例化模型时，我需要 _fields 由 both 用于实例化模型的 keyword 参数和 restricted fields 组成，如在元类中处理。如果 _fields 是 Model 类中的 class 变量，这将非常容易，但由于它是 instance 变量，我不知道我该怎么做还将限制字段添加到其中。

---

说了这么多，有什么方法可以实现吗？或者有没有更好的方法来处理这个？ （我想过只使用一个元类并在模型上设置一个_restricted_fields类变量，然后在类__init__()中使用这个变量将受限字段添加到普通字段中，但是很快模型类就会变得杂乱无章在我看来，代码应该放在代码的另一部分）。

Answer 1

为此使用元类不是正确的方法。 元类修改类创建行为而不是实例创建行为。您应该使用__init__或__new__函数来修改实例创建行为。想要为此类事情使用元类是使用锤子而不是螺丝刀将螺丝钉在墙上。 ;-)

我建议您使用__new__ 来实现您想要的。来自Python docs：

__new__() 主要用于允许不可变类型的子类（如int、str 或tuple）自定义实例创建。它通常在自定义元类中被覆盖以自定义类创建。

class MetaModel(type):
    def __new__(cls, name, bases, attrs):
        attrs['_restricted_fields'] = [attrs.get('has_many')]
        return type.__new__(cls, name, bases, attrs)

class Model(object):
    __metaclass__ = MetaModel
    has_many = None
    def __new__(cls, *args, **kwargs):
        instance = object.__new__(cls, *args, **kwargs)
        instance.instance_var = ['spam']
        return instance

class SubModel(Model):
    has_many = True
    def __init__(self):
        # No super call here.
        self.attr = 'eggs'

s = SubModel()
assert s._restricted_fields == [True]  # Added by MetaModel
assert s.instance_var == ['spam']  # Added by Model.__new__
assert s.attr == 'eggs'  # Added by __init__

# instance_var is added per instance.
assert SubModel().instance_var is not SubModel().instance_var

MetaModel 负责创建Model 类。它将_restricted_fields 类变量添加到由它创建的任何Model 类（值是包含has_many 类变量的列表）。

Model 类定义了一个默认的has_many 类变量。它还修改了实例创建行为，为每个创建的实例添加了instance_var 属性。

SubModel 是由您的代码的用户创建的。它定义了一个__init__ 函数来修改实例创建。请注意，它不调用任何超类函数，这不是必需的。 __init__ 为每个 SubClass 实例添加一个 attr 属性。

Answer 2

设置实例变量的地方在类的__init__方法中。但是，如果您不想让使用元类的每个类都包含相同的代码，为什么不让元类为该类提供自己的 __init__ 方法，围绕现有的 __init__ 方法：

class MyMetaclass(type):
    def __new__(mcs, name, bases, dct):
        if 'has_many' in dct:
            dct['_restricted_fields'].append(["something"])

        orig_init = dct.get("__init__") # will be None if there was no __init__

        def init_wrapper(self, *args, **kwargs):
            if orig_init:
                orig_init(self, *args, **kwargs)          # call original __init__
            self._fields = getattr(self, "_fields", [])   # make sure _fields exists
            self._fields.extend(["whatever"])             # make our own additions

        dct["__init__"] = init_wrapper   # replace original __init__ with our wrapper

        return type.__new__(mcs, name, bases, dct)

我不完全理解您想要实现的实际逻辑是什么，但您可以将包装函数中的self._fields.extend(["whatever"]) 替换为您真正想要做的任何事情。 self 在这种情况下是实例，而不是类或元类！包装函数是一个闭包，因此您可以访问mcs 中的元类和dct 中的类字典（如果需要）。

Answer 3

如果需要为每个实例设置，则放置代码以计算它的位置在__init__ 中。

但是，请注意，类变量可通过实例使用，除非被实例变量遮蔽。

Answer 4

您可以使用工厂而不是元类来完成这一切。

工厂可以创建类型，然后也可以创建这些类型的实例 - 但是在初始化时而不是在类创建时这样做。将相关知识保存在一个地方（工厂），但不会试图将两种不同的工作硬塞到一个操作中。

OTOH，您还可以使用您在类创建时通过闭包获得的信息，在每个实例的初始化时动态组合一个函数

class ExMeta(type):

        def __new__(cls, name, parents, kwargs):
            kwargs['ADDED_DYNAMICALLY'] = True

            secret_knowledge = 42
            def fake_init(*args, **kwargs):
                print "hello world... my args are:",  args, kwargs
                print "the meaning of the universe is ", secret_knowledge
            kwargs['_post_init'] = fake_init
            return super(ExMeta, cls).__new__(cls, name, parents, kwargs)

class Example(object):
    SOME_ATTR = 1
    SOME_OTHER = 2
    __metaclass__ = ExMeta       

    def __init__(self):
        self._post_init()


bob = Example()
> hello world... my args are: (<__main__.Example object at 0x0000000002425BA8>,) {}
> the meaning of the universe is  42

Answer 5

更新可能会显示我的想法：

class MetaKlass(object):
    def __new__(cls, *args, **kwargs):
        class_methods = {'foo'}
        _ins = super(MetaKlass, cls).__new__(cls)
        for k, v in kwargs.iteritems():
            if k in class_methods:
                _do = _ins.__getattribute__(k)
                setattr(_ins, k, _do(v)) # self monkey patching:
                                        # classmethod is replaced by its output
            else:
                setattr(_ins, k, v)
        return _ins

    def __init__(self, arg1, arg2, *args, **kwargs):
        self.a = arg1
        self.b = arg2

    @classmethod
    def foo(cls, x):
        return 42

所以我们得到：

>>> from overflow_responses import MetaKlass
>>> klass_dict = {'foo': 1, 'angel': 2}
>>> k = MetaKlass(3, 7, **klass_dict)
>>> k.foo, k.angel, k.a, k.b
(42, 2, 3, 7)

您是否正在寻找这样的东西：

>>> kwd = {'a': 2}  # the 'class variables dict'
>>> class MetaKlass(object):
...     def __new__(cls, kwd):
...             _ins = super(MetaKlass, cls).__new__(cls)
...             for k, v in kwd.iteritems():
...                     setattr(_ins, k, v)
...             return _ins
...
>>> mk = MetaKlass(kwd)
>>> mk.a
2
>>>

代码应该相当简单。当我将一组方法组织到一个类中时，其中许多方法都依赖于一组类值和特定的实例值。