Python虚拟机类机制之从class对象到instance对象（五）
从class对象到instance对象
现在，我们来看看如何通过class对象，创建instance对象
demo1.py
class A(object):
name = "Python"
def __init__(self):
print("A::__init__")
def f(self):
print("A::f")
def g(self, aValue):
self.value = aValue
print(self.value)
a = A()
a.f()
a.g(10)
在Python虚拟机类机制之自定义class（四）这一章中，我们看到了Python虚拟机是如何执行class A语句的，现在，我们来看看，当我们实例化一个A对象，Python虚拟机又是如何执行的
a = A() //字节码指令 22 LOAD_NAME 1 (A) 25 CALL_FUNCTION 0 28 STORE_NAME 2 (a)
在前面一节Python虚拟机类机制之自定义class（四），我们看到在创建class对象的最后，Python执行引擎通过STORE_NAME指令，将创建好的class对象放入到local名字空间，所以在实例化class A的时候，指令"22 LOAD_NAME 1 (A)"会重新将class A对象取出，压入到运行时栈中。之后，又是通过一个CALL_FUNCTION指令来创建instance对象。在创建完instance对象之后，再次通过STORE_NAME指令将实例对象a放入到local名字空间中。所以，这段字节码指令序列完成之后，local名字空间如图1-1所示
图1-1 创建instance对象后的local名字空间
在CALL_FUNCTION中，Python同样会沿着call_function->do_call->PyObject_Call的调用路径进入到PyObject_Call中。前面说过，所谓“调用”，就是执行对象的type所对应的class对象的tp_call操作。所以，在PyObject_Call中，Python执行引擎会寻找class对象<class A>的type中定义的tp_call操作。<class A>的type为<type 'type'>，所以，最终将调用tp_call，在PyType_Type.tp_call中又调用了A.tp_new是用来创建instance对象
这里需要特别注意，在创建<class A>这个class对象时，Python虚拟机调用PyType_Ready对<class A>进行了初始化，其中的一项动作就是继承基类的操作，所以A.tp_new会继承自object.tp_new。在PyBaseObject_Type中，这个操作被定义为object_new。创建class对象和创建instance对象的不同之处正是在于tp_new不同，创建class对象，Python虚拟机使用的是tp_new，而对于instance对象，Python虚拟机使用的object_new
在object_new中，调用了A.tp_alloc，这个操作也是从object继承而来的，是PyType_GenericAlloc。前面我们提到，PyType_GenericAlloc最终将申请A.tp_basicsize+A.tp_itemsize大小的内存空间。上一节，这两个量的计算结果为A.tp_basicsize=PyBaseObject_Type.tp_basicsize+8=sizeof(PyObject)+8=24;A.tp_itemsize=PyBaseObject_Type.tp_itemsize=0。原来，object_new的所有工作就是申请一个24字节的内存空间
在申请了24字节的内存空间，回到type_call之后，由于创建的不是class对象，而是instance对象，type_call会尝试进行初始化的动作
typeobject.c
static PyObject * type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *obj;
obj = type->tp_new(type, args, kwds);
if (obj != NULL) {
if (type == &PyType_Type &&
PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
(kwds == NULL ||
(PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))
return obj;
if (!PyType_IsSubtype(obj->ob_type, type))
return obj;
type = obj->ob_type;
if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) &&
type->tp_init != NULL &&
type->tp_init(obj, args, kwds) < 0) {
Py_DECREF(obj);
obj = NULL;
}
}
return obj;
}
基于<class A>创建的instance对象obj，其ob_type当然也在PyType_GenericAlloc中被设置为指向<class A>，其tp_init在PyType_Ready时会继承PyBaseObject_Type的object_init操作，因为A的定义中重写了__init__，所以在fix_slot_dispatchers中，tp_init会指向slotdefs中指定的__init__对应的slot_tp_init
typeobject.c
static int slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
{
static PyObject *init_str;
PyObject *meth = lookup_method(self, "__init__", &init_str);
PyObject *res;
if (meth == NULL)
return -1;
res = PyObject_Call(meth, args, kwds);
Py_DECREF(meth);
if (res == NULL)
return -1;
if (res != Py_None) {
PyErr_Format(PyExc_TypeError,
"__init__() should return None, not '%.200s'",
res->ob_type->tp_name);
Py_DECREF(res);
return -1;
}
Py_DECREF(res);
return 0;
}
在执行slot_tp_init时，Python虚拟机会首先通过lookup_method在class对象及其mro列表中搜索属性__init__对应的操作，然后通过PyObject_Call调用该操作。在定义class时，重写__init__操作，那么搜索的结果就是我们写的操作，如果没有重写，那么最终的结果将是调用object._init，在object_init中，Python虚拟机什么也不做，直接返回，所以，当我们用a = A()创建一个instance对象时，实际上没有进行任何初始化的动作
到这里，我们稍微小结一下从class对象到instance对象的两个步骤：
- instance = class.__new__(class, args, kwds)
- class.__init__(instance, args, kwds)
其中，args为一个tupple对象，里面包含着创建instance对象的各个参数，而kwds通常为NULL。需要注意的是，这两个步骤也适用于从metaclass对象创建class对象。从metaclass对象创建class对象的过程也是从一个从class对象创建instance对象
访问instance对象中的属性
在Python中，形如x.y或x.y()形式的表达式称为“属性引用”，其中x为对象，y为对象的属性。这个属性，有可能只是简单的数据，比如字符串或整数，也有可能是成员函数这类比较复杂的东西。在class A中一共有两个函数，一个是不需要参数的成员函数，一个是需要参数的成员函数，这里，我们先来看看，对于不需要参数的成员函数，其调用过程是怎样的
a.f() //字节码指令 31 LOAD_NAME 2 (a) 34 LOAD_ATTR 3 (f) 37 CALL_FUNCTION 0 40 POP_TOP
Python虚拟机通过指令LOAD_NAME会将local名字空间与符号a对应的instance对象压入运行时栈中，随后执行指令"34 LOAD_ATTR 3"是属性访问机制的关键所在，它会从<instance a>中获得与符号f对应的对象，这是个PyFunctionObject对象
ceval.c
case LOAD_ATTR:
w = GETITEM(names, oparg);
v = TOP();
x = PyObject_GetAttr(v, w);
Py_DECREF(v);
SET_TOP(x);
if (x != NULL)
continue;
break;
其中，w为PyStringObject对象f，而v为运行时栈中的那个instance对象<instance a>，从<instance a>中获得f对应对象的关键就在PyObject_GetAttr中
object.c
PyObject * PyObject_GetAttr(PyObject *v, PyObject *name)
{
PyTypeObject *tp = v->ob_type;
//[1]：通过tp_getattro获得属性对应对象
if (tp->tp_getattro != NULL)
return (*tp->tp_getattro)(v, name);
//[2]：通过tp_getattr获得属性对应对象
if (tp->tp_getattr != NULL)
return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
//[3]：属性不存在，抛出异常
PyErr_Format(PyExc_AttributeError,
"'%.50s' object has no attribute '%.400s'",
tp->tp_name, PyString_AS_STRING(name));
return NULL;
}
在Python的class对象中，定义了两个与访问属性相关的操作：tp_getattro和tp_getattr。其中的tp_getattro是首选的属性访问操作，而tp_getattr在Python中已不再推荐使用，它们之间的区别主要是在属性名的使用上，tp_getattro所使用的属性名必须是一个PyStringObject对象，而tp_attr所使用的属性名必须是一个C中的原生字符串。如果某个类型同时定义了tp_getattr和tp_getattro两种属性访问操作，那么PyObject_GetAttr将优先使用tp_getattro操作
在Python虚拟机创建<class A>时，会从PyBaseObject_Type中继承tp_getattro——PyObject_GenericGetAttr，所以Python虚拟机在这里会进入PyObject_GenericGetAttr。在PyObject_GenericGetAttr中，有一套复杂地确定访问属性的算法，下面以a.f为例，我们用伪代码看一下是如何确定这个属性的
# 首先寻找'f'对应的descriptor(descriptor在之后会细致剖析)
# 注意：hasattr会在<class A>的mro列表中寻找符号'f'
if hasattr(A, 'f'):
descriptor = A.f
type = descriptor.__class__
if hasattr(type, '__get__') and (hasattr(type, '__set__') or 'f' not in a.__dict__):
return type.__get__(descriptor, a, A)
# 通过descriptor访问失败，在instance对象自身__dict__中寻找属性
if 'f' in a.__dict__:
return a.__dict__['f']
# instance对象的__dict__中找不到属性，返回a的基类列表中某个基类里定义的函数
# 注意：这里的descriptor实际上指向了一个普通的函数
if descriptor:
return descriptor.__get__(descriptor, a, A)
我们通过一段代码来验证这个伪代码的描述：
class A(object):
def func(self):
pass
a = A()
a.func = 1
print(a.func)
这段代码很直观，最后会输出1，看上去与上面的伪代码描述的不对啊。实际上，上面的伪代码中有一个关键的概念——descriptor。在一个class中，并不是随意定义一个函数就是descriptor了，所以导致输出结果为1。那么，究竟什么才是descriptor呢？这个会在下章解答
