对Python中的整数对象的理解

a616652325

                    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”就对应着一个表示的对象，这个对象实际上就是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所维护的内存上的。