如何从类的实例恢复类

class UnderWater:
    def __init__(self):
        self.net = 'underwater'

marine = UnderWater() # Instantiate the class

# Recover the class from the instance and add attributes to it.
class SubMarine(marine.__class__):  
    def __init__(self):
        super().__init__()
            self.sound = 'Sonar'
    
print(SubMarine, SubMarine.__name__, SubMarine().net, SubMarine().sound)

# Output
# (__main__.SubMarine,'SubMarine', 'underwater', 'Sonar')

杰森·普拉特发布的内容是正确的。

>>> class Test(object):
...   def a(self):
...     pass
... 
>>> def b(self):
...   pass
... 
>>> Test.b = b
>>> type(b)
<type 'function'>
>>> type(Test.a)
<type 'instancemethod'>
>>> type(Test.b)
<type 'instancemethod'>

如您所见，Python认为b（）与a（）没有任何不同。在Python中，所有方法都只是恰好是函数的变量。

由于这个问题是针对非Python版本提出的，这里是JavaScript：

a.methodname = function () { console.log("Yay, a new method!") }

我认为上述答案没有抓住重点。

让我们用一个方法来上课：

class A(object):
    def m(self):
        pass

现在，让我们在ipython中玩一下：

In [2]: A.m
Out[2]: <unbound method A.m>

好的，所以m（）在某种程度上变成了A的非绑定方法，但它真的是这样吗？

In [5]: A.__dict__['m']
Out[5]: <function m at 0xa66b8b4>

事实证明，m（）只是一个函数，对它的引用被添加到a类字典中——这没有什么魔力。那为什么A.m会给我们一个未绑定的方法？这是因为点没有被翻译成简单的字典查找。这实际上是对a.__class__.__getattribute__（a，'m'）的调用：

In [11]: class MetaA(type):
   ....:     def __getattribute__(self, attr_name):
   ....:         print str(self), '-', attr_name

In [12]: class A(object):
   ....:     __metaclass__ = MetaA

In [23]: A.m
<class '__main__.A'> - m
<class '__main__.A'> - m

现在，我不清楚为什么最后一行要打印两次，但仍然很清楚是怎么回事。

现在，默认__getattribute__所做的是检查属性是否是所谓的描述符，即它是否实现了一个特殊的__get__方法。如果它实现了该方法，那么返回的是调用__get__方法的结果。回到我们A类的第一个版本，这是我们拥有的：

In [28]: A.__dict__['m'].__get__(None, A)
Out[28]: <unbound method A.m>

因为Python函数实现了描述符协议，所以如果代表对象调用它们，它们会在__get__方法中将自己绑定到该对象。

好的，那么如何向现有对象添加方法呢？假设您不介意修补类，那么简单如下：

B.m = m

然后，由于描述符的魔力，B.m“成为”一个未绑定的方法。

如果你想将一个方法添加到一个对象中，那么你必须自己使用types.MethodType来模拟机器：

b.m = types.MethodType(m, b)

顺便说一句：

In [2]: A.m
Out[2]: <unbound method A.m>

In [59]: type(A.m)
Out[59]: <type 'instancemethod'>

In [60]: type(b.m)
Out[60]: <type 'instancemethod'>

In [61]: types.MethodType
Out[61]: <type 'instancemethod'>

在Python中，函数和绑定方法之间存在差异。

>>> def foo():
...     print "foo"
...
>>> class A:
...     def bar( self ):
...         print "bar"
...
>>> a = A()
>>> foo
<function foo at 0x00A98D70>
>>> a.bar
<bound method A.bar of <__main__.A instance at 0x00A9BC88>>
>>>

绑定方法已“绑定”到一个实例（如何描述），每当调用该方法时，该实例将作为第一个参数传递。

但是，作为类（与实例相反）属性的可调用项仍然是未绑定的，因此您可以随时修改类定义：

>>> def fooFighters( self ):
...     print "fooFighters"
...
>>> A.fooFighters = fooFighters
>>> a2 = A()
>>> a2.fooFighters
<bound method A.fooFighters of <__main__.A instance at 0x00A9BEB8>>
>>> a2.fooFighters()
fooFighters

以前定义的实例也会更新（只要它们没有覆盖属性本身）：

>>> a.fooFighters()
fooFighters

当您想将方法附加到单个实例时，问题就出现了：

>>> def barFighters( self ):
...     print "barFighters"
...
>>> a.barFighters = barFighters
>>> a.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: barFighters() takes exactly 1 argument (0 given)

函数直接附加到实例时不会自动绑定：

>>> a.barFighters
<function barFighters at 0x00A98EF0>

要绑定它，我们可以在类型模块中使用MethodType函数：

>>> import types
>>> a.barFighters = types.MethodType( barFighters, a )
>>> a.barFighters
<bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>>
>>> a.barFighters()
barFighters

这次该类的其他实例没有受到影响：

>>> a2.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: A instance has no attribute 'barFighters'

通过阅读描述符和元类编程可以找到更多信息。

在Python中，猴痘通常通过用自己的签名覆盖类或函数的签名来工作。以下是Zope Wiki的示例：

from SomeOtherProduct.SomeModule import SomeClass
def speak(self):
   return "ook ook eee eee eee!"
SomeClass.speak = speak

此代码将覆盖/创建类中名为speak的方法。在Jeff Atwood最近发表的关于猴子修补的文章中，他展示了一个C#3.0的例子，这是我当前工作中使用的语言。