Python描述符

一个问题

class A:
    name = 'A'
    def __init__(self):
        self.name = 'a'
    def get_name(self):
        return self.name
a = A()
print(a.get_name())   
# a  
print(A.get_name())  
# 报错:
# TypeError: get_name() missing 1 required positional argument: 'self'
print(A.get_name(a))
# a

在上面的例子中，我们发现，使用实例a去访问get_name方法的时候是不用显式传入参数self(也就是实例自身a)，而使用类访问相同方法的时候需要显式传入实例a，否则会报错，这个究竟用的是什么黑魔法呢？

在源码里面它是怎么实现的...

def fun():
    a.get_name()

def gun():
    A.get_name()

import dis
# 我们看看他们编译后的字节码是什么
dis.dis(fun)
  2           0 LOAD_GLOBAL              0 (a)
              2 LOAD_ATTR                1 (get_name)
              4 CALL_FUNCTION            0
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
dis.dis(gun)
  2           0 LOAD_GLOBAL              0 (A)
              2 LOAD_ATTR                1 (get_name)
              4 CALL_FUNCTION            0
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

从编译后的字节码来看，这两种调用方法，也只有在0行是不同的，其余的都相同，还未能解析到我们的困惑，在深入一点去看一下...
先看看LOAD_ATTR：

// python2.7/objects/ceval.c
        TARGET(LOAD_ATTR)
        {
            w = GETITEM(names, oparg);  // 从co_name 取出 get_name函数
            v = TOP();                  // 将刚才压入栈的 A/a 取出来
            // 调用python里面属性/方法获取的函数
            x = PyObject_GetAttr(v, w); 
            Py_DECREF(v);
            SET_TOP(x);
            if (x != NULL) DISPATCH();
            break;
        }

再看CALL_FUNCTION:

//python2.7/objects/ceval.c
TARGET(CALL_FUNCTION)
        {
            PyObject **sp;
            PCALL(PCALL_ALL);
            sp = stack_pointer;
#ifdef WITH_TSC
            x = call_function(&sp, oparg, &intr0, &intr1);
#else
            x = call_function(&sp, oparg);  // 这里调用
#endif
            stack_pointer = sp;
            PUSH(x);
            if (x != NULL) DISPATCH();
            break;
        }
       
static PyObject *
call_function(PyObject ***pp_stack, int oparg)     
{
    int na = oparg & 0xff;                // 位置参数个数
    int nk = (oparg>>8) & 0xff;           // 关键位置参数的个数
    int n = na + 2 * nk;                  // 总的个数和
    PyObject **pfunc = (*pp_stack) - n - 1;  // 当前栈位置-参数个数,得到函数对象
    PyObject *func = *pfunc;  
    PyObject *x, *w;
    ... 
    // 这里检测func的类型，分水岭就在这里
    // 先检测func是不是PyMethodObject和调出实例self
    if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
            /* optimize access to bound methods */
            PyObject *self = PyMethod_GET_SELF(func);
            PCALL(PCALL_METHOD);
            PCALL(PCALL_BOUND_METHOD);
            Py_INCREF(self);
            func = PyMethod_GET_FUNCTION(func);
            Py_INCREF(func);
            //  self对象替换pfunc指向的对象(用于后续传入self参数)
            Py_SETREF(*pfunc, self);
            na++;
            n++;
        } else
            Py_INCREF(func);
        READ_TIMESTAMP(*pintr0);
        // 在这里检测func是不是PyFunctionObject
        if (PyFunction_Check(func))
            // 是的话原样调用该func
            x = fast_function(func, pp_stack, n, na, nk);
        else
            // 否则执行do_call，也就是我们调用的实例方法
            x = do_call(func, pp_stack, na, nk);
        READ_TIMESTAMP(*pintr1);
        Py_DECREF(func);
}

不深入到do_call和fast_function里面，从执行流程看，我们传入的func是分类型的，分有PyFunction_Type和PyMethod_Type，不知道是什么玩意，在python官网的C API查一下:

PyMethod_Type.png
PyFunction_Type.png

这两个就是我们想要的，也就是在我们调用CALL_FUNCTION的时候，解析器已经根据我们用的是a.get_name还是A.get_name获取到的函数对象进行处理，它怎么处理呢？
如果用的是a.get_name，调用上面图片的PyMethod_New方法，把函数get_name和实例self(也就是a)绑定在一起形成新函数，类似我们的闭包操作:

# 把函数跟参数绑定到一个新函数里面
# 用的是闭包
def get_new_fun(old_fun, arg):
    def new_fun():
        return old_fun(arg)
    return new_fun

def fun(arg):
    return arg
# 这里就类似我们调用的a.get_name，已经把a绑定到新函数中
f = get_new_fun(fun, 'hello')
# 故此不用再传入参数('hello')
print(f())
# hello

而用的是A.get_name则只返回原函数get_name，并不做任何绑定操作，所以调用的时候需要显式传入self参数

在python中，PyMethod和PyFunction称为bound method和Unbound method，也就是绑定方法与未绑定方法。

print(a.get_name)
# <bound method A.get_name of <__main__.A object at 0x00000000077F4358>>
print(A.get_name)
# <function A.get_name at 0x00000000077F1F28>

现在已经理解了实例方法调用的流程了，那么.....

究竟跟描述符有什么关系呢？？

其实，描述符完整来说应该叫描述符协议，为什么要有这样的一个东西呢，为什么前面需要铺垫实例方法调用的流程呢？

因为...我们在实例方法调用的时候，实例self与其对应类的方法绑定在了一个新函数中，并且该新函数可以使用有关self的任何东西，那么，这样的一个流程，可不可以也能应用到类中的属性上呢，也就是当我们用实例去访问类属性的时候，可以对self进行修改或者对其属性访问或者赋值行为进行控制呢？python自带的就有现成的供你使用

一个例子

python里面有一个property可以控制属性的访问、赋值等功能:

class A:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        print('getting my name...')
        return self._name
    @name.setter
    def name(self, new_name):
        print('setting my name...')
        self._name = new_name

a = A('a')
print(a.name)
# getting my name...
# a
a.name = 'b'
# setting my name...
print(a.name)
# getting my name...
# b
print(A.name)
# <property object at 0x00000000077EDC28>

由此可见，我们在访问name这个类属性的时候，通过实例a和类A去访问得到的结果是不同的，这不正跟我们的绑定方法与非绑定方法类似么，python也定了这个协议给开发者使用，经过property修饰符实例化出来了一个property object，正是实现了这样一个叫做'描述符'协议的对象。
那怎样的一个对象才是实现了'描述符'协议呢？

官方定义: 如果_get_(), _set_(), 和_delete_()方法中的任何一个被定义在一个对象中，这个对象就是一个描述符。

# 自定义一个描述符类
class my_property:
    def __get__(self, instance, owner):
        ...
    def __set__(self, instance, value):
        ...
    def __delete__(self, instance):
        ...

那自定义完之后怎么应用呢？

class A:
    # 在类中把自定义的描述符类进行实例化
    name = my_property()

a = A()
print(a.name)   # 触发描述符的__get__方法
a.name = 'a'     # 触发描述符的__set__方法
del a.name       # 触发描述符的__delete__方法

问题来了为什么一定只能在类中实例化描述符呢？我在实例a中赋值进去不行吗？就像这样子:a.name = my_property()
不可以的，因为协议这东西，它说怎样就得怎样，那么它是怎么触发那3个方法呢？
流程是这样的：
当使用a.name访问时，因为a没有实例属性name，就会往类A中找，找到了name这个属性之后，检查name这个属性是否有_get_方法，如果有的话，则将类自身和实例自身作为参数传进描述符对象的_get_方法中，整个调用链就是:

a.name ----> type(a).name.__get__(a, type(a))  
# a和type(a)对应了__get__方法中的instance、owner参数填入

_set_和_delete_同理...
如果是在实例a中赋值了一个描述符对象的话(a.name = my_property())，在访问a.name的时候就直接在a的实例属性中找到my_proterty对象，但并不会触发任何东西...
这样就实现了控制属性访问、赋值的过程。。能用在什么地方呢？
其实，python里面很多地方都用到了描述符协议，例如几个修饰符:property、classmethod、staticmethod.......在这里简单地自己实现一下

# 实现自定义的property
class my_property:
    def __init__(self, get_fun):
        self.get_fun = get_fun
    def __get__(self, instance, owner):
        if instance:
            print('调用__get__')
            return self.get_fun(instance)
        else:
            return self
    def setter(self, set_fun):
        self.set_fun  = set_fun
        # 此处return回自身是因为xxx.setter()之后后续需要继续用此对象
        return self
    def __set__(self, instance, value):
        print('调用__set__')
        self.set_fun(instance, value)

class A:
    def __init__(self, name):
        self._name = name
    @my_property
    def name(self):
        return self._name
    @name.setter
    def name(self, new_name):
        self._name = new_name

a = A('a')
print(a.name)
# 调用__get__
# a
a.name = 'b'
# 调用__set__
print(a.name)
# 调用__get__
# b

# 自定义classmethod
class my_classmethod:
    def __init__(self, func):
        self._func = func
    def __get__(self, instance, owner):
        def new_func(*args, **kwargs):
            return self._func(owner, *args, **kwargs)
        return new_func
# 自定义boundmethod
class my_bound:
    def __init__(self, func):
        self._func = func
    def __get__(self, instance, owner):
        if instance:
            def new_fun(*args, **kwargs):
                return self._func(instance, *args, **kwargs)
            return new_fun
        else:
            return self._func
# 自定义staticmethod
class my_staticmethod:
    def __init__(self, func):
        self._func = func
    def __get__(self, instance, owner):
        return self._func

class A:
    name = 'A'
    def __init__(self):
        self.name = 'a'
    @my_staticmethod
    def speak(sth):
        return sth
    @my_bound
    def hello(self):
        return self.name
    @my_classmethod
    def bye(cls):
        return cls.name

a = A()
print(a.speak('abc'))
# abc
print(A.speak('cba'))
# cba
print(a.hello())
# a
print(a.bye())
# A
print(A.bye())
# A

至此已经能够理解什么是描述符协议和怎样应用描述符协议去做开发