考虑以下(损坏的)代码:

import functools                                                            
class Foo(object):                                                          
  def __init__(self):                                                 
    def f(a,self,b):                                            
      print a+b                                           
    self.g = functools.partial(f,1)                             
x=Foo()                                                                     
x.g(2)

我想做的是获取函数 f 并部分应用它，从而生成函数 g(self,b)。我想将此函数用作一种方法，但是目前这不起作用，而是出现错误

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    x.g(2)
TypeError: f() takes exactly 3 arguments (2 given)

执行 x.g(x,2) 是可行的，所以看起来问题是 g 被认为是“普通”函数而不是类的方法。有没有办法让 x.g 表现得像一个方法(即隐式传递 self 参数)而不是一个函数？

最佳答案

这里有两个问题。首先，要将函数转换为方法，它必须存储在类 中，而不是实例中。演示:

class Foo(object):
    def a(*args):
        print 'a', args

def b(*args):
    print 'b', args

Foo.b = b

x = Foo()

def c(*args):
    print 'c', args

x.c = c

所以a是类定义中定义的函数，b是之后赋值给类的函数，c是函数分配给实例。看看我们调用它们时会发生什么:

>>> x.a('a will have "self"')
a (<__main__.Foo object at 0x100425ed0>, 'a will have "self"')
>>> x.b('as will b')
b (<__main__.Foo object at 0x100425ed0>, 'as will b')
>>> x.c('c will only recieve this string')
c ('c will only recieve this string',)

如您所见，与类一起定义的函数与稍后分配给它的函数之间几乎没有区别。我相信只要不涉及元类，实际上就没有区别，但那是另一回事了。

第二个问题首先是一个函数实际上是如何变成一个方法的；函数类型实现描述符协议(protocol)。 ( See the docs for details. ) 简而言之，函数类型有一个特殊的 __get__ 方法，当您对类本身执行属性查找时调用该方法。不是获取函数对象，而是调用该函数对象的 __get__ 方法，并返回一个绑定(bind)方法对象(它提供了 self 参数)。

为什么这是个问题？因为 functools.partial 对象不是描述符!

>>> import functools
>>> def f(*args):
...     print 'f', args
... 
>>> g = functools.partial(f, 1, 2, 3)
>>> g
<functools.partial object at 0x10042f2b8>
>>> g.__get__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'functools.partial' object has no attribute '__get__'

此时您有多种选择。您可以显式地向部分提供 self 参数:

import functools
class Foo(object):                                                          
    def __init__(self):
        def f(self, a, b):                                            
            print a + b                                           
        self.g = functools.partial(f, self, 1)

x = Foo()
x.g(2)

...或者你会在闭包中嵌入 self 和 a 的值:

class Foo(object):                                                          
    def __init__(self):                                                 
        a = 1
        def f(b):                                            
            print a + b                                           
        self.g = f

x = Foo()
x.g(2)

这些解决方案当然假设有一个尚未指定的原因在构造函数中为类分配一个方法，就像这样，因为您可以很容易地直接在类上定义一个方法来完成您在这里所做的事情.

编辑:这里有一个解决方案的想法，假设可以为类而不是实例创建函数:

class Foo(object):
    pass

def make_binding(name):
    def f(self, *args):
        print 'Do %s with %s given %r.' % (name, self, args)
    return f

for name in 'foo', 'bar', 'baz':
    setattr(Foo, name, make_binding(name))

f = Foo()
f.foo(1, 2, 3)
f.bar('some input')
f.baz()

给你:

Do foo with <__main__.Foo object at 0x10053e3d0> given (1, 2, 3).
Do bar with <__main__.Foo object at 0x10053e3d0> given ('some input',).
Do baz with <__main__.Foo object at 0x10053e3d0> given ().

关于python - 将部分函数转换为python中的方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3803517/