Object对象
(1)
PyObject是python中所有对象的基石。
typedef struct _object
{
int ob_refcnt ; //引用计数
struct _typeobject *ob_type ; //指向对象的类型对象
}PyObject ;
我们用PyObject可以表示整数对象这类定长对象，但是像字符串这类非定长对象，就不能用PyOject结构体。于是我们引入了表示这类对象的结构体—PyVarObject
typetdef struct
{
int ob_refcnt ;
struct _typeobject * ob_type ;
int ob_size ;
}PyVarObject ;
ob_size 表示变长对象中容纳的元素个数。
由上我们看到PyVarObject只是对PyObject的扩展，在Python内部所有对象都有相同的头部，即PyObject。故在Python内部我们只需要用一个PyObject *指针就可以引用任何一个对象。而不论该对象是定长对象还是变成对象。
(2)
Python中任何对象都对应着一个类型对象。类型对象也是对象也对应着一个类型对象。
整数对象的类型对象是PyIntObject。在Python完成运行环境的初始化后，符号“int”就对应着一个表示<tpye ‘int’>的对象，这个对象实际上就是Python内部的PyInt_Type 。
Python中用户自定义对象和类型对象的类型对象是PyType_Type。
下面看一下运行时整数对象及其类型对象的关系：
Python中的引用计数
# define _Py_NewReference(op) ((op)->ob_refcnt = 1) //引用计数初始化
# define _Py_Dealloc(op) ((*(op)->ob_type->ob_dealloc)((PyObject *)(op)))
//类似如C++中的析构函数
# define Py_INCREF(op) ((op)->refcnt ++ ) //引用计数+1
# define Py_DECREF(op) \
If( --(op)->refcnt) != 0 ) \
;
Else
_Py_Dealloc((PyObject *)(op))
# define Py_XINCREF(op) if( (op)==NULL);else Py_INCREF(op)
# define Py_XDECREF(op) if( (op)==NULL);else Py_DECREF(op)
整数对象
看一段python中加法操作源码：
static PyObject * int_add(PyIntObject * v , PyIntObject * w)
{
Register long a,b,x ;
CONVERT_TO_LONG(v,a) ; // a=v->ob_ival
CONVERT_TO_LONG(w,b) ; // b=w->ob_ival
x = a+b ;
if( a^x>=0 || b^x>=0 ) //检查结果是否溢出
return PyInt_FromLong(x);
return PyLong_Type.tp_as_number->nb_add((PyObject*)v,(PyObject*)w) ;
//如果结果溢出，那么结果就不是一个PyIntObject，而是一个PyLongObject对象。
}
# define PyInt_AS_LONG(op) (((PyIntObject*)(op))->ob_ival)
# define CONVERT_TO_LONG(obj,lng) \
if( PyInt_Check(obj)){
//判断该对象是否是整数对象，及obj->ob_ival是否等于PyInt_Type
lng = PyInt_AS_LONG(obj) ;
}
Else{
Py_INCREF(Py_NotImplemented);
Return Py_NotImplemented ; \
}
（1） 小整数
在实际的编程中我们会经常用到一些小整数，这样就会频繁的开辟和释放内存，造成运行效率的降低，而且会在系统堆上造成大量的碎片，严重影响Python的整体性能。
为解决这个问题，Python引入了小整数对象池，让这些整数对应的PyIntObject对象常驻内存，并且将其指针放到small_ints中。
看下源码：
# ifndef NSMALLPOSITIONS
# define NSMALLPOSITIONS 257
# endif //
# ifndef NSMALLNEGINTS
# define NSMALLNEGINTS 5
# endif //
# if NSMALLPOSITIONS+NSMALLPOSITIONS>0
Static PyIntObject *small_ints[NSMALLPOSITIONS+NSMALLNEGINTS];
# endif
在Python 2.5中，将小整数定义为[-5,257)
(2) 大整数
对于小整数，Python用小整数对象池完全其对应的Object对象。对于大整数，
Python提供了一块内存区供这些大整数轮流使用，也就是谁需要时谁使用。
Python用两个指针来维护整数对象池：
PyIntBlock * block_list = NULL ; //指向为整数对象分配的缓冲区
PyIntObject * free_list = NULL ; //指向空闲缓冲区
看下源码：
# define BLOCK_SIZE 1000
# define BHEAD_SIZE 8
# define N_INTOBJECTS ((BLOCK_SIZE-BHEAD_SIZE)/sizeof(PyIntObject))//=32
// sizeof(PyIntObject)) = 8
Struct _intBlock
{
Struct _intBlock * next;
PyIntObject object[N_INTOBJECTS] ;
}
Typedef struct _intblock PyIntBlock ;
Static PyIntBlock * block_list = NULL ;
Static PyIntObject * free_list = NULL ;
下面来看下Python中如何创建一个整数对象：
PyObject * PyInt_FromLong(long ival)
{
Register PyIntObject * v ;
# If NSMALLPOSITIONS + NSMALLPOSITIONS>0//小整数对象池被激活
If( ival>=-NSMALLPOSITIONS && ival< NSMALLPOSINTS ) //是小整数
{
v = small_ints[ival+ NSMALLPOSITIONS] ;
Py_INCREF(v) ; //引用计数++，在小整数对象创建时,引用计数初始化为0
Return (PyObject *)v ;
}
# endif //
//如果是创建大整数对象
if( free_list = NULL )
{
if( (free_list = fill_free_list())==NULL )
return NULL ;
/* fill_free_list()函数会在三种情况下使用：
1，在python运行环境初始化过程中，调用_PyInt_init(void),在这个函数中调用fill_free_list()函数为小整数对象申请内存空间。
2，Python程序运行时，第一次创建大整数对象，可能会用到此函数。
3，当free_list = NULL时。*/
V = free_list ;
free_list = (PyInt_Object*)free_list->ob_type ;
PyObject_INIT(v,&PyInt_Type) ;
//这是一个宏，主要完成两个任务
（1） v->ob_type = &PyInt_Type ;
（2） _Py_NewReference(v) ; //引用计数初始化为0
v->ival = ival ;
return (PyObject*)v ;
}
下面来看下fill_free_list()函数，这是一个很重要的函数
Static PyIntObject * fill_free_list(void)
{
PyIntObject *p,*q ;
P = (PyIntObject*)PyMem_MALLOC(sizeof(PyIntBlock)) ;
If( p == NULL )
Return (PyIntObject*)PyErr_NoMemony();
//采用头插法，将新申请的内存块插入由block_list维护的内存块链表中
((PyIntBlock *)p)->next = block_list ;
Block_list = (PyIntBlock *)p ;
//将PyIntBlock中的objects数组转换为单向链表
q = p+ N_INTOBJECTS ;
while( --q > p )
q->ob_type = (struct _typeobject *)(q-1) ;
p->ob_type = NULL ;
return p+ N_INTOBJECTS-1 ;
}
使用头插法插入一个PyIntBlock块见下图：
将PyIntBlock中的数组转换为单向链表见下图：
删除对象
当删除一个大整数对象时，该对象幷不是直接被系统回收，而是插入到free_list所维护的空闲链表中。见下图示：
看下源码：
Static void int_dealloc( PyIntObject *v)
{
If( PyInt_CheckExact(v)) //检查是不是整数对象
{
// 将该系统占用的内存空间插入到free_list所维护的空闲链表中
v->ob_type = (struct _typeobject *)free_list ;
free_list = v ;
}
Else
v->ob_type->tp_free( (PyObject*)v ) ;
}
有一个问题：del一个大整数对象后，该大整数对象所占用的内存空间会被对象池回收，但是如果删除一个小整数对象呢？
现在我们就剩下最后一个问题了，我们看到在small_ints中，它维护的只是PyIntObject的指针，那么这些小整数对象是在什么对方被创建和初始化的呢。完成它的是_PyInt_Init。在Python初始化的时候，_PyInt_Init被调用，内存被申请，小整数对象被调用。
我们看下源码：
int _PyInt_Init(void)
{
PyIntObject *v ;
Int ival ;
# if NSMALLNEGINTS + NSMALLPOSINTS > 0
for( ival = - NSMALLNEGINTS;ival< NSMALLPOSINTS; i++ )
{
if（！free_list && (free_list = fill_free_list（）)==NULL）
return 0;
v = free_list ;
free_list = (PyIntObject*)v->ob_type ;
PyObject_INIT(v,&PyInt_Type);
v->ob_ival = ival ;
small_int[ival+ NSMALLNEGINTS] = v ;
}
# endif
Return 1 ;
}
从小整数的创建过程中可以看出，这些永生不灭的小整数对象也是生存在有block_list所维护的内存上的。
