python - 动态添加有或没有元类的方法

Question

更新 - 2012/12/13

澄清一下——我对如何向类添加方法不太感兴趣——正如你在下面我的问题和人们的回答中看到的那样，有不止一种方法可以做到这一点(开玩笑和向我的 Perl self 致敬)。

我感兴趣的是了解使用不同方法向类添加方法的根本区别是什么，真正的大问题是为什么我需要使用元类。例如A Primer on Python Metaclass Programming指出:

Perhaps the most common use of metaclasses [...]: adding, deleting, renaming, or substituting methods for those defined in the produced class.

由于有更多方法可以做到这一点，我很困惑并正在寻找解释。

谢谢!

原始 - 2012/12/12

我需要动态地向一个类添加方法(以及基于该类新生成的类)。我想出了两种方法，一种涉及元类，另一种不涉及元类。除了后者不涉及“黑魔法”元类之外，我看不出这两种方法给我带来的任何区别；)

方法#1使用元类:

class Meta(type):
        def __init__(cls, *args, **kwargs):
                setattr(cls, "foo", lambda self: "foo@%s(class %s)" % (self,
                        cls.__name__))

class Y(object):
        __metaclass__ = Meta

y = Y()
y.foo() # Gives 'foo@<__main__.Y object at 0x10e4afd10>(class Y)'

方法#2没有元类:

class Z(object):
        def __init__(self):
                setattr(self.__class__, "foo",
                        lambda self: "foo@%s(class %s)" %
                        (self, self.__class__.__name__))

z = Z()
z.foo() # Gives 'foo@<__main__.Z object at 0x10c865dd0>(class Z)'

据我所知，这两种方法都给我相同的结果和“表现力”。即使我尝试使用 type("NewClassY", (Y, ), {}) 或 type("NewClassZ", (Z, ), {}) 我得到了相同的预期结果，这两种方法之间没有区别。

所以，我想知道这些方法是否真的存在任何“潜在”差异，或者如果我使用 #1 或 之后是否有任何东西会“咬住”我#2 还是它只是一个语法糖？

PS:是的，我确实阅读了这里讨论 Python 和 Pythonic 数据模型中的元类的其他线程。

Answer 1

使用元类的明显原因是因为一旦知道类，它们就会真正提供有关类的元数据，与对象是否存在无关。微不足道，对吧？好吧，让我们展示一些我在您的原始 Z 和 Y 类上执行的命令，看看这意味着什么:

In [287]: hasattr(Y,'foo')
Out[287]: True

In [288]: hasattr(Z,'foo')
Out[288]: False

In [289]: Y.__dict__
Out[289]:
<dictproxy {..., 'foo': <function __main__.<lambda>>}>

In [290]: Z.__dict__
Out[290]:
<dictproxy {...}>

In [291]: z= Z()

In [292]: hasattr(Z,'foo')
Out[292]: True

In [293]: Z.__dict__
Out[293]:
<dictproxy {..., 'foo': <function __main__.<lambda>>}>

In [294]: y = Y()

In [295]: hasattr(Y,'foo')
Out[295]: True

In [296]: Y.__dict__
Out[296]:
<dictproxy {..., 'foo': <function __main__.<lambda>>}>

如您所见，第二个版本实际上在声明类 Z 后对其进行了显着更改，您通常希望避免这种情况。 python 对“类型”(类对象)进行操作当然不是一个不常见的操作，您可能希望它们尽可能一致，当然对于这种情况(方法在运行时不是真正动态的，只是在声明时时间)。

一个突然想到的应用程序是文档。如果您使用元类将文档字符串添加到 foo，文档可能会通过 __init__ 方法获取它，这是不太可能的。

它也可能导致难以发现的错误。考虑一段使用类元信息的代码。可能在 99.99% 的情况下，这是在 Z 的实例已创建后执行的，但 0.01% 可能会导致奇怪的行为，如果不是崩溃的话。

它在层次结构链中也可能变得棘手，在这种情况下，您必须非常小心在哪里调用父级的构造函数。例如，像这样的类可能会产生问题:

class Zd(Z):
    def __init__(self):
        self.foo()
        Z.__init__(self)
a = Zd()
...
AttributeError: 'Zd' object has no attribute 'foo'

虽然这工作正常:

class Yd(Y):
    def __init__(self):
        self.foo()
        Y.__init__(self)
a = Yd()

在没有使用相关的 __init__ 的情况下调用方法可能看起来很愚蠢，但如果您不小心就会发生这种情况，当然在 MRO 不是很明显的更复杂的层次结构中。并且很难发现此错误，因为大多数情况下 Zd() 会在之前某处调用 Z.__init__ 时成功。