函数,未绑定方法和绑定方法有什么区别?

我正在问这个问题,因为这个答案的评论线程的讨论。 我是90%的方法来让我的头。

In [1]: class A(object): # class named 'A' ...: def f1(self): pass ...: In [2]: a = A() # an instance 

f1以三种不同的forms存在:

 In [3]: a.f1 # a bound method Out[3]: <bound method a.f1 of <__main__.A object at 0x039BE870>> In [4]: A.f1 # an unbound method Out[4]: <unbound method A.f1> In [5]: a.__dict__['f1'] # doesn't exist KeyError: 'f1' In [6]: A.__dict__['f1'] # a function Out[6]: <function __main__.f1> 

bound方法unbound方法函数对象之间有什么区别,所有这些都由f1来描述? 如何称呼这三个对象? 他们怎么能相互转化? 关于这个东西的文档是很难理解的。

一个函数是由def语句或lambda 。 在Python 2下,当一个函数出现在一个class语句的主体中(或者被传递给一个type构造调用)时,它被转换成一个未绑定的方法 。 (Python 3没有未绑定的方法;见下文)。当一个函数在一个类实例上被访问时,它被转换成一个绑定的方法 ,自动将实例作为第一个self参数提供给方法。

 def f1(self): pass 

这里f1是一个函数

 class C(object): f1 = f1 

现在C.f1是一个未绑定的方法。

 >>> C.f1 <unbound method C.f1> >>> C.f1.im_func is f1 True 

我们也可以使用类的构造函数:

 >>> C2 = type('C2', (object,), {'f1': f1}) >>> C2.f1 <unbound method C2.f1> 

我们可以手动将f1转换为一个未绑定的方法:

 >>> import types >>> types.MethodType(f1, None, C) <unbound method C.f1> 

未绑定的方法被类实例的访问绑定:

 >>> C().f1 <bound method C.f1 of <__main__.C object at 0x2abeecf87250>> 

通过描述符协议将访问转换为调用:

 >>> C.f1.__get__(C(), C) <bound method C.f1 of <__main__.C object at 0x2abeecf871d0>> 

结合这些:

 >>> types.MethodType(f1, None, C).__get__(C(), C) <bound method C.f1 of <__main__.C object at 0x2abeecf87310>> 

或直接:

 >>> types.MethodType(f1, C(), C) <bound method C.f1 of <__main__.C object at 0x2abeecf871d0>> 

函数和非绑定方法的主要区别在于后者知道绑定哪个类; 调用或绑定一个未绑定的方法需要一个类types的实例:

 >>> f1(None) >>> C.f1(None) TypeError: unbound method f1() must be called with C instance as first argument (got NoneType instance instead) >>> class D(object): pass >>> f1.__get__(D(), D) <bound method D.f1 of <__main__.D object at 0x7f6c98cfe290>> >>> C.f1.__get__(D(), D) <unbound method C.f1> 

由于函数和非绑定方法之间的区别非常小,Python 3摆脱了区别; 在Python 3下访问类实例的函数只是给你自己的函数:

 >>> C.f1 <function f1 at 0x7fdd06c4cd40> >>> C.f1 is f1 True 

在Python 2和Python 3中,这三者是等价的:

 f1(C()) C.f1(C()) C().f1() 

将一个函数绑定到一个实例会将其第一个参数(通常称为self )固定到该实例。 因此,绑定方法C().f1等价于以下任一项:

 (lamdba *args, **kwargs: f1(C(), *args, **kwargs)) functools.partial(f1, C()) 

很难理解

那么,这是一个相当困难的话题,它与描述符有关。

让我们从函数开始。 在这里一切都很清楚 – 你只需要调用它,所有提供的参数在执行时都会被传递:

 >>> f = A.__dict__['f1'] >>> f(1) 1 

在参数数量有问题的情况下会引发Regular TypeError

 >>> f() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: f1() takes exactly 1 argument (0 given) 

现在,方法。 方法是一些香料的function。 描述符进来游戏在这里。 如数据模型中所述 , A.f1A().f1被翻译成A.__dict__['f1'].__get__(None, A) and type(a).__dict__['f1'].__get__(a, type(a)) 。 这些__get__的结果与原始f1函数不同。 这些对象是围绕原始f1包装,并包含一些额外的逻辑。

unbound method情况下,这个逻辑包括检查第一个参数是否是A一个实例:

 >>> f = A.f1 >>> f() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unbound method f1() must be called with A instance as first argument (got nothing instead) >>> f(1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unbound method f1() must be called with A instance as first argument (got int instance instead) 

如果此检查成功,则将该实例作为第一个参数执行原始f1

 >>> f(A()) <__main__.A object at 0x800f238d0> 

请注意, im_self属性是None

 >>> f.im_self is None True 

bound method情况下,这个逻辑立即为原始的f1提供一个它创build的实例(这个实例实际存储在im_self属性中):

 >>> f = A().f1 >>> f.im_self <__main__.A object at 0x800f23950> >>> f() <__main__.A object at 0x800f23950> 

所以, bound意味着底层函数绑定到某个实例。 unbound意味着它仍然是有约束力的,但只限于一个阶级。

函数对象是由函数定义创build的可调用对象。 绑定和未绑定的方法都是可调用的对象,由dot二元运算符调用的描述符创build。

绑定和未绑定的方法对象有三个主要属性: im_func是在类中定义的函数对象, im_class是类, im_self是类实例。 对于未绑定的方法, im_selfNone

当一个绑定方法被调用时,它调用im_self作为第一个参数跟在它的调用参数。 未绑定方法只调用其调用参数的底层函数。

我今天看到的一个有趣的事情是,当我给一个类成员分配一个函数时,它变成了一个未绑定的方法。 如:

 class Test(object): @classmethod def initialize_class(cls): def print_string(self, str): print(str) # Here if I do print(print_string), I see a function cls.print_proc = print_string # Here if I do print(cls.print_proc), I see an unbound method; so if I # get a Test object o, I can call o.print_proc("Hello")