Python虚拟机类机制之绑定方法和非绑定方法（七）

Bound Method和Unbound Method

在Python中，当对作为属性的函数进行引用时，会有两种形式，一种称为Bound Method，这种形式是通过类的实例对象进行属性引用，而另一种则是通过类进行属性引用，称为Unbound Method。当然，对Bound Method和Unbound Method的调用形式是不同的，其原因可以追溯到LOAD_ATTR中

demo2.py

class A(object):

    def g(self, value):

        self.value = value

        print(self.value)

a = A()

A.g(a, 10)

其对应的字节码指令序列：

>>> source = open("demo2.py").read()

>>> co = compile(source, "demo2.py", "exec")

>>> import dis

>>> dis.dis(co)

  1           0 LOAD_CONST               0 ('A')

              3 LOAD_NAME                0 (object)

              6 BUILD_TUPLE              1

              9 LOAD_CONST               1 (<code object A at 0x7f3e67870d50, file "demo2.py", line 1>)

             12 MAKE_FUNCTION            0

             15 CALL_FUNCTION            0

             18 BUILD_CLASS

             19 STORE_NAME               1 (A)

  7          22 LOAD_NAME                1 (A)

             25 CALL_FUNCTION            0

             28 STORE_NAME               2 (a)

  8          31 LOAD_NAME                1 (A)

             34 LOAD_ATTR                3 (g)

             37 LOAD_NAME                2 (a)

             40 LOAD_CONST               2 (10)

             43 CALL_FUNCTION            2

             46 POP_TOP

             47 LOAD_CONST               3 (None)

             50 RETURN_VALUE

其中的关键就在于"34 LOAD_ATTR 3 (g)"指令，之前我们已经解释过，这里的LOAD_ATTR指令最终会调用type_getattro。在type_getattro中，会在<class A>的tp_dict中发现"g"对应的PyFunctionObject，同样，因为它是一个descriptor，因此也会调用其__get__函数进行转变。在Python虚拟机类机制之从class对象到instance对象（五）这一章剖析a.f时，我们看到这个转变是通过func_descr_get(A.f, a, A)完成的，这里对"g"的转变则是通过func_descr_get(A.g, NULL, A)完成。因此，虽然A.g也得到一个PyMethodObject，但是其中的im_self确实NULL

在Python中，在对Unbound Method尽心调用时，我们必须显示地提供一个instance对象作为函数的第一个位置参数，因为g无论如何都需要一个self参数。所以才会有A.g(a, 10)这样的形式。而无论是对Unbound Method进行调用，还是对bound Method进行调用，Python虚拟机的动作在本质上都是一样的，都是调用带位置参数的一般函数，区别只在于：当调用Bound Method时，Python虚拟机帮我们完成了PyFunctionObject对象和instance对象的绑定，instance对象将自动成为self参数，而调用Unbound Method时，则没有这个绑定，需要我们自己传入self参数

下面的代码展示出Bound Method和Unbound Method的不同

>>> class A(object):

...     def f(self):

...         pass

...

>>> a = A()

>>> bound = a.f

>>> unbound = A.f

>>>

>>> bound

<bound method A.f of <__main__.A object at 0x7f3e677c7310>>

>>> unbound

<unbound method A.f>

>>>

>>> bound.im_self

<__main__.A object at 0x7f3e677c7310>

>>> unbound.im_self

>>>

在输出Unbound method对象的im_self域时，没有任何东西输出，因为这个域本身就是NULL

对于成员函数的调用，或者说对于成员函数的绑定过程，有一点值的注意的是，每一次函数调用都会激发一次绑定过程。其原因在于，每次进行属性引用时，都会重新获得属性对应的PyFunctionObject(descritpro)，进而创建新的PyMethodObject对象，这一点的开销实在是有些大，下面两段代码展示了不同函数调用方式的绑定次数

class A(object):

    def f(self):

        pass

a = A()

# 函数绑定100次

for i in range(100):

    a.f()

class A(object):

    def f(self):

        pass

a = A()

func = a.f

# 函数绑定1次

for i in range(100):

    func()

千变万化的descriptor

当我们调用instance对象的函数时，最关键的一个动作就是从PyFunctionObject对象向PyMethodObject对象的转变，而这个关键的转变被Python中descriptor概念很自然地融入到Python的类机制中。当我们访问对象中的属性时，由于descriptor的存在，这种转换自然而然地发生了。将这种descriptor的思想推而广之，其实在访问属性时，我们不光能实现从PyFunctionObject到PyMethodObject对象的转变，实际上我们可以做任何事情。在Python内部，也存在着各式各样的descriptor，这些descriptor的存在给Python的类机制赋予了更多的能力。现在，我们来看看Python是如何使用descriptor实现static method的

demo3.py

class A(object):

    def g(value):

        print(value)

    g = staticmethod(g)

demo3.py对应字节码指令序列：

>>> source = open("demo3.py").read()

>>> co = compile(source, "demo3.py", "exec")

>>> co.co_consts

('A', <code object A at 0x7f3e677c9198, file "demo3.py", line 1>, None)

>>> A_co = co.co_consts[1]

>>> import dis

>>> dis.dis(A_co)

  1           0 LOAD_NAME                0 (__name__)

              3 STORE_NAME               1 (__module__)

  2           6 LOAD_CONST               0 (<code object g at 0x7f3e677c90a8, file "demo3.py", line 2>)

              9 MAKE_FUNCTION            0

             12 STORE_NAME               2 (g)

  4          15 LOAD_NAME                3 (staticmethod)

             18 LOAD_NAME                2 (g)

             21 CALL_FUNCTION            1

             24 STORE_NAME               2 (g)

             27 LOAD_LOCALS

             28 RETURN_VALUE

在为A创建动态元信息的过程中，Python虚拟机首先会执行一个def语句，将符号"g"和一个PyFunctionObject对象关联起来，但随后的g = staticmethod(g)则会将"g"与一个staticmethod对象关联起来，从而将属性"g"改造为一个static method

Python虚拟机在执行"15 LOAD_NAME 3 (staticmethod)"指令时，会从builtin名字空间中获得一个与符号"staticmethod"对应的对象，这个对象在Python启动并初始化时设置，它其实是一个class对象

>>> staticmethod

<type 'staticmethod'>

所以，执行staticmethod(g)的过程就是一个从class对象创建instance对象的过程，最终将调用PyObject_GenericAlloc申请一段内存，内存空间的大小由staticmethod结构体决定：

typedef struct {

	PyObject_HEAD

	PyObject *sm_callable;

} staticmethod;

申请完内存之后，Python虚拟机还会调用__init__进行初始化操作，<type 'staticmethod'>在Python内部对应的是PyStaticMethod_Type，而其中的tp_init设置为sm_init：

static int

sm_init(PyObject *self, PyObject *args, PyObject *kwds)

{

	staticmethod *sm = (staticmethod *)self;

	PyObject *callable;

	if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))

		return -1;

	if (!_PyArg_NoKeywords("staticmethod", kwds))

		return -1;

	Py_INCREF(callable);

	sm->sm_callable = callable;

	return 0;

}

在初始化时，原来的参数"g"对应的PyFunctionObject被赋给staticmethod对象中的sm_callable。最后，Python虚拟机通过指令"24 STORE_NAME 2 (g)"将符号"g"和这个staticmethod对象关联起来

在仔细考察PyStaticMethod_Type，发现这里创建的staticmethod对象实际上也是个descriptor，因为在PyStaticMethod_Type中，tp_descr_get指向了sm_descr_get

static PyObject * sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)

{

	staticmethod *sm = (staticmethod *)self;

	if (sm->sm_callable == NULL) {

		PyErr_SetString(PyExc_RuntimeError,

				"uninitialized staticmethod object");

		return NULL;

	}

	Py_INCREF(sm->sm_callable);

	return sm->sm_callable;

}

当我们访问属性"g"时，不论是通过instance对象访问a.g，还是通过class对象访问A.g，由于"g"是一个位于class对象<class A>的tp_dict中的descriptor，所以会调用其__get__操作（sm_descr_get），直接了当地返回其中保存的最开始与"g"对应的PyFunctionObject对象

巴特西

Python虚拟机类机制之绑定方法和非绑定方法（七）

最新文章

热门文章