动态添加带或不带元类的方法

Question

更新 - 2012/12/13

只是为了澄清 - 我对如何向课程添加方法并不感兴趣 - 正如你在我的问题和人们的答案中可以看到的那样,有不止一种方法可以做到这一点(舌头在脸颊和帽子尖端到我的Perl自我).

我感兴趣的是学习使用不同方法向类添加方法的根本区别,而大问题是为什么我需要使用元类.例如,Python Metaclass Programming的Primer声明:

也许最常见的使用元类[...]:为生成的类中定义的方法添加,删除,重命名或替换方法.

而且由于有更多方法可以做到这一点,我很困惑并寻找解释.

谢谢!

原创 - 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对'types'(类对象)进行操作肯定不是一个不常见的操作,你可能希望它们尽可能保持一致,当然对于这种情况(在运行时方法不是真正动态的,只是在声明时)时间).

跳到脑海的一个应用是文档.如果你要添加一个文档字符串来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__在之前的某个地方被调用.

Answer 2

如果问题是动态添加方法，Python 确实会以非常简单的方式处理它。其过程如下：

#!/usr/bin/python
class Alpha():

    def __init__(self):
        self.a = 10
        self.b = 100

alpha = Alpha()
print alpha.a
print alpha.b

def foo(self):
    print self.a * self.b * self.c

Alpha.c = 1000
Alpha.d = foo

beta = Alpha()
beta.d()

输出：

$ python script.py 
10
100
1000000

问候！

PS：我认为这里没有黑魔法的相似之处（：

编辑：

考虑到马蒂诺的评论，我添加的是data attributes，而不是method function attributes。我真的看不出Alpha.d = foo和之间没有什么区别Alpha.d = lambda self: foo(self)，除了我使用 lambda 函数作为foo添加的函数的包装器。

方法的添加是相同的，并且python本身命名两个添加相同：

#!/usr/bin/python
class Alpha():

    def __init__(self):
        self.a = 10
        self.b = 100

alpha = Alpha()
print alpha.a
print alpha.b

def foo(self):
    print self.a * self.b * self.c

Alpha.c = 1000

Alpha.d = lambda self: foo(self)
Alpha.e = foo

print Alpha.d
print Alpha.e

a = Alpha()
a.d()
a.e()

输出：

10
100
<unbound method Alpha.<lambda>>
<unbound method Alpha.foo>
1000000
1000000

如图所示，Python 本身将这两个结果添加都命名为方法——唯一的区别是，一个是对 function 的引用foo，另一个是对foo在其定义主体中使用该函数的 lambda 函数的引用。

如果我说错了，请纠正我。

问候！