Shulou(Shulou.com)06/02 Report--

Python in the principle of integer objects, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain in detail for you, people with this need can come to learn, I hope you can gain something.

Integer objects are represented by PyIntObject structures inside the Python:

Typedef struct {PyObject_HEAD long ob_ival;} PyIntObject

The two properties defined in the PyObject_HEAD macro are:

Int ob_refcnt; struct _ typeobject * ob_type

These two properties are inherent to all Python objects:

Ob_refcnt: reference counting of objects, related to Python's memory management mechanism, which implements a garbage collection mechanism based on reference counting

Ob_type: used to describe type information for Python objects.

In view of this, PyIntObject is an extension of values of type long in C language. For performance reasons, for small integers, Python uses a small integer object pool small_ints to cache integers between [- 5257), which are shared in Python systems.

# define NSMALLPOSINTS 257#define NSMALLNEGINTS 5static PyIntObject * small_ ints [NSMALLNEGINTS + NSMALLPOSINTS]

Even if the integers beyond this range have the same value, the object is not necessarily the same, as follows: the values of an and b are both 10000, but they are not the same object, the values are both 1, and they belong to the same object.

> a = 10000 > b = 10000 > > print an is bFalse > a = 1 > > b = 1 > print an is bTrue

For other integers beyond [- 5257), Python also provides a special buffer pool for these so-called large integers to avoid the efficiency loss caused by constant malloc allocating memory each time it is used. This piece of memory space is PyIntBlock.

Struct _ intblock {struct _ intblock * next; PyIntObject objects [N _ INTOBJECTS];}; typedef struct _ intblock PyIntBlock;static PyIntBlock * block_list = NULL;static PyIntObject * free_list = NULL

These blocks are represented by an one-way linked list, and the header is that block_list,block_list always points to the newly created PyIntBlock object. The next pointer points to the next PyIntBlock object, and objects is an PyIntObject array (which eventually turns into an one-way linked list), which is the real memory space for storing cached PyIntObjet objects. The free_list unidirectional linked list is the free memory in the objects of all block. The advantage of organizing all free memory through a linked list is that when Python needs new memory to store new PyIntObject objects, it can quickly get the required memory through free_list.

When creating an integer object, if it is within the range of small integers, it is returned directly from the small integer buffer pool, and if not, open up a large integer buffer pool memory space:

[intobject.c] PyObject* PyInt_FromLong (long ival) {register PyIntObject * v; # if NSMALLNEGINTS + NSMALLPOSINTS > 0 / / [1]: try using a small integer object pool if (- NSMALLNEGINTS ob_type; PyObject_INIT (v, & PyInt_Type); v-> ob_ival = ival; return (PyObject*) v;}

Fill_free_list is the logic for creating memory space in a large integer buffer pool. This function returns a linked list of free_list. When the integer object ival is created, the free_list header points to v-> ob_type,ob_type, which is not a field representing type information in all Python objects. How to use it as a connection pointer here? This is Python's middle ground between performance and code elegance, abusing the name and abandoning the insistence on type safety. Just think of it as a pointer to the next PyIntObject.

[intobject.c] static PyIntObject* fill_free_list (void) {PyIntObject* p, * Q; / / request memory space with the size of sizeof (PyIntBlock), and link to the existing block list / / block list use the newly created PyIntBlock p = (PyIntObject*) PyMem_MALLOC (sizeof (PyIntBlock)); ((PyIntBlock *) p)-> next = block_list; block_list = (PyIntBlock *) p / /: convert the PyIntObject array-objects-- in PyIntBlock into an one-way linked list p = & ((PyIntBlock *) p)-> objects [0]; Q = p + objects events; while (- Q > p) / / ob_type points to the next unused PyIntObject. Q-> ob_type = (struct _ typeobject *) (qmer1); Q-> ob_type = NULL; return p + N_INTOBJECTS-1;}

How is the free memory in different PyIntBlock connected to form a free_list? The secret is when the integer object is garbage collected, as you can see in the tp_dealloc operation of the PyIntObject object:

[intobject.c] static void int_dealloc (PyIntObject * v) {if (PyInt_CheckExact (v)) {v-> ob_type = (struct _ typeobject *) free_list; free_list = v;} else v-> ob_type- > tp_free ((PyObject *) v);}

When the original PyIntObject object is destroyed, the memory it occupies is not freed, but continues to be used by Python, thus pointing the free_list header to the object to be destroyed.

Summary

The int object in Python is an extension of the numerical value of long type in c language.

Small integer objects [- 5,257] are shared in python

Integer objects are obtained from the buffer pool.

When an integer object is reclaimed, the memory is not returned to the system, but the obtype of its object is pointed to freelist for use by the newly created integer object

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.