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

>>> 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中，函数和绑定方法之间存在差异。

>>> 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'

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

可以使用lambda将方法绑定到实例：

def run(self):
    print self._instanceString

class A(object):
    def __init__(self):
        self._instanceString = "This is instance string"

a = A()
a.run = lambda: run(a)
a.run()

输出：

This is instance string

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

>>> 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中，所有方法都只是恰好是函数的变量。

这个问题早在几年前就提出了，但嘿，有一种简单的方法可以使用decorator模拟函数与类实例的绑定：

def binder (function, instance):
  copy_of_function = type (function) (function.func_code, {})
  copy_of_function.__bind_to__ = instance
  def bound_function (*args, **kwargs):
    return copy_of_function (copy_of_function.__bind_to__, *args, **kwargs)
  return bound_function


class SupaClass (object):
  def __init__ (self):
    self.supaAttribute = 42


def new_method (self):
  print self.supaAttribute


supaInstance = SupaClass ()
supaInstance.supMethod = binder (new_method, supaInstance)

otherInstance = SupaClass ()
otherInstance.supaAttribute = 72
otherInstance.supMethod = binder (new_method, otherInstance)

otherInstance.supMethod ()
supaInstance.supMethod ()

在那里，当您将函数和实例传递给绑定器装饰器时，它将创建一个新函数，其代码对象与第一个相同。然后，类的给定实例存储在新创建的函数的属性中。装饰器返回一个（第三个）函数，自动调用复制的函数，将实例作为第一个参数。最后，您将得到一个函数，模拟它与类实例的绑定。保持原始函数不变。

自python 2.6以来，模块new已弃用，并在3.0中删除，请使用类型

看见http://docs.python.org/library/new.html

在下面的示例中，我故意从patch_me（）函数中删除了返回值。我认为，给出返回值可能会让人相信补丁会返回一个新对象，这是不正确的——它会修改传入的对象。这可能有助于更严格地使用猴痘。

import types

class A(object):#but seems to work for old style objects too
    pass

def patch_me(target):
    def method(target,x):
        print "x=",x
        print "called from", target
    target.method = types.MethodType(method,target)
    #add more if needed

a = A()
print a
#out: <__main__.A object at 0x2b73ac88bfd0>  
patch_me(a)    #patch instance
a.method(5)
#out: x= 5
#out: called from <__main__.A object at 0x2b73ac88bfd0>
patch_me(A)
A.method(6)        #can patch class too
#out: x= 6
#out: called from <class '__main__.A'>