是否可以在不更改同一类的所有其他实例的情况下更改实例的方法实现？ [复制]

Question

我不太了解python（以前从未使用过它：D），但我似乎无法在网上找到任何东西。也许我只是没有用谷歌搜索正确的问题，但我走了：

我想更改实例对特定方法的实现。当我搜索它时，我发现你可以做到，但它改变了同一类的所有其他实例的实现，例如：

def showyImp(self):
    print self.y

class Foo:
    def __init__(self):
        self.x = "x = 25"
        self.y = "y = 4"

    def showx(self):
        print self.x

    def showy(self):
         print "y = woohoo"

class Bar:
    def __init__(self):
        Foo.showy = showyImp
        self.foo = Foo()

    def show(self):
        self.foo.showx()
        self.foo.showy()

if __name__ == '__main__':
    b = Bar()
    b.show()
    f = Foo()
    f.showx()
    f.showy()

这没有按预期工作，因为输出如下：

x = 25

y = 4

x = 25

y = 4

我希望它是：

x = 25

y = 4

x = 25

y = 呜呜

我试图用这个来改变 Bar 的 init 方法：

def __init__(self):
    self.foo = Foo()
    self.foo.showy = showyImp

但我收到以下错误消息：

showyImp() 只接受 1 个参数（给定 0）

是的...我尝试使用setattr()，但似乎与self.foo.showy = showyImp 相同。

有什么线索吗？ :)

Answer 1

从 Python 2.6 开始，您应该使用 types 模块的 MethodType 类：

from types import MethodType

class A(object):
    def m(self):
        print 'aaa'

a = A()

def new_m(self):
    print 'bbb'

a.m = MethodType(new_m, a)

然而，正如另一个答案所指出的，这不适用于新型类的“魔术”方法，例如__str__()。

Answer 2

这个答案已经过时了； the answer below 适用于现代 Python

你想知道的关于Python Attributes and Methods的一切。

是的，这是一个间接的答案，但它展示了许多技术并解释了一些更复杂的细节和“魔法”。

要获得“更直接”的答案，请考虑python's new module。特别是，查看允许将方法“绑定”到实例的 instancemethod 函数——在这种情况下，这将允许您在方法中使用“self”。

import new
class Z(object):
  pass
z = Z() 
def method(self):
  return self
z.q = new.instancemethod(method, z, None)
z is z.q()  # true

Answer 3

如果您需要为 special 方法执行此操作（对于新样式的类 - 这是您应该始终使用的并且是 Python 3 中唯一的类型 - 是查找类，而不是实例），您可以只创建一个每个实例的类，例如...：

self.foo = Foo()
meths = {'__str__': lambda self: 'peekaboo!'}
self.foo.__class__ = type('yFoo', (Foo,), meths)

编辑：有人要求我在 new.instancemethod... 中阐明这种方法的优势...：

>>> class X(object): 
...   def __str__(self): return 'baah'
... 
>>> x=X()
>>> y=X()
>>> print x, y
baah baah
>>> x.__str__ = new.instancemethod(lambda self: 'boo!', x)
>>> print x, y
baah baah

如您所见，new.instance 方法在这种情况下完全没用。哦...：

>>> x.__class__=type('X',(X,),{'__str__':lambda self:'boo!'})
>>> print x, y
boo! baah

...分配一个新班级对于这种情况和其他情况都非常有用。顺便说一句，我希望很清楚，一旦您对给定实例执行此操作，您就可以稍后将更多方法和其他类属性添加到其 x.__class__ 并且本质上只影响那个实例！

Answer 4

如果您要绑定到实例，则不应包含 self 参数：

>>> class Foo(object):
...     pass
... 
>>> def donothing():
...     pass
... 
>>> f = Foo()
>>> f.x = donothing
>>> f.x()
>>> 

如果你绑定到一个类，你确实需要 self 参数：

>>> def class_donothing(self):
...     pass
... 
>>> foo.y = class_donothing
>>> f.y()
>>> 

Answer 5

你的例子有点扭曲和复杂，我不太明白它与你的问题有什么关系。如果您愿意，请随时澄清。

但是，假设我没看错你的问题，那么做你想做的事情就很容易了。

class Foo(object):
    def bar(self):
        print('bar')

def baz():
    print('baz')

在解释器中 ...

>>> f = Foo()
>>> f.bar()
bar
>>> f.bar = baz
>>> f.bar()
baz
>>> g = Foo()
>>> g.bar()
bar
>>> f.bar()
baz

Answer 6

不要这样做。

改变一个实例的方法是错误的。

这是面向对象设计的规则。

1. 避免魔法。

2. 如果不能使用继承，请使用委托。

这意味着每次你认为你需要一些神奇的东西时，你应该在对象周围编写一个“包装器”或 Facade 来添加你想要的功能。

只写一个包装器。