c++双向列表释放_Python进阶之列表底层实现

Python进阶之列表底层实现

在python中底层是c语言编写，列表是一个线性的集合，它允许用户在任何位置插入、删除、访问和替换元素。列表实现是基于数组或基于链表结构的。当使用列表迭代器的时候，双链表结构比单链表结构更快。有序的列表是元素总是按照升序或者降序排列的元素。

因为列表不是储存在栈中的，所以编写程序的时候有时会出现一定的问题(比如局部变量，当函数执行完毕时应该释放)，我们举个例子：

例子1：

>>> def liyou(a=[],b=0):

...  if not a:

...   a.append(b)

...  return a

...

>>> liyou(100)

100

>>> liyou(50)

50

>>> liyou(b=100)

[100]

>>> liyou(b=50)

[100]

>>> liyou(b=60)

[100]

这个例子是在cmd交互式环境下运行的，这里发现一个问题，当b=100的时候，无论之后怎么复制b，得到的a都是第一次赋值的100，说明列表在函数中没有被初始化，也就是说不同于局部变量在函数结束时销毁。

我们再看这个改进的例子，更加明显：

>>>def liyou(a=[],b=0,c=1):

    a.append(b)

    c=c+1

    return a,c

>>>print("第一次:{}".format(liyou(b=10)))

第一次:([10], 2)

>>>print("第二次:{}".format(liyou(b=100)))

第二次:([10, 100], 2)

这次我们用了一个c作为参考，发现c在每次函数结束后释放，每次运行时初始化。

这是什么原因造成的呢？其实这个和python底层实现有关。

内存空间在逻辑上分为三部分：代码区、静态数据区和动态数据区，动态数据区又分为栈区和堆区。

代码区：存储方法体的二进制代码。高级调度(作业调度)、中级调度(内存调度)、低级调度(进程调度)控制代码区执行代码的切换。
静态数据区：存储全局变量、静态变量、常量。系统自动分配和回收。
栈区：存储运行方法的形参、局部变量、返回值。由系统自动分配和回收。
堆区：new一个对象的引用或地址存储在栈区，指向该对象存储在堆区中的真实数据。由程序员分配和回收。

• 栈(操作系统)：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。

• 堆(操作系统)： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定(并不是一旦成为孤儿对象就能被回收)。所以调用这些对象的速度要相对来得低一些。

python中的列表的英文名是list，因此很容易和其它语言(C++, Java等)标准库中常见的链表混淆。事实上CPython的列表根本不是列表(可能换成英文理解起来容易些：python中的list不是list)。在CPython中，列表被实现为长度可变的数组。

从细节上看，Python中的列表是由对其它对象的引用组成的连续数组。指向这个数组的指针及其长度被保存在一个列表头结构中。这意味着，每次添加或删除一个元素时，由引用组成的数组需要该标大小(重新分配)。幸运的是，Python在创建这些数组时采用了指数过分配，所以并不是每次操作都需要改变数组的大小。

看一下python的 cpython 实现(cpython就是python的c实现版本)

l = []
l.append(1)
l.append(2)
l.append(3)

列表对象的c语言结构体

---

Cpython 中的列表实现类似于下面的 C 结构体。ob_item 是指向列表对象的指针数组。allocated 是申请内存的槽的个数。

列表初始化

---

看看初始化一个空列表的时候发生了什么，例如：l = []。

arguments: size of the list = 0returns: list object = []PyListNew:
    nbytes = size * size of global Python object = 0
    allocate new list object
    allocate list of pointers (ob_item) of size nbytes = 0
    clear ob_item
    set list's allocated var to 0 = 0 slots    
    return list object

要分清列表大小和分配的槽大小，这很重要。列表的大小和 len(l) 的大小相同。分配槽的大小是指已经在内存中分配了的槽空间数。通常分配的槽的大小要大于列表大小，这是为了避免每次列表添加元素的时候都调用分配内存的函数。下面会具体介绍。

append操作

---

向列表添加一个整数：l.append(1) 时发生了什么？调用了底层的 C 函数 app1()。

arguments: list object, new element
returns: 0 if OK, -1 if notapp1:
    n = size of list
    call list_resize() to resize the list to size n+1 = 0 + 1 = 1
    list[n] = list[0] = new element    
    return 0

下面是 list_resize() 函数。它会多申请一些内存，避免频繁调用 list_resize() 函数。列表的增长模式为：0，4，8，16，25，35，46，58，72，88……

python的这个值是怎么来的呢
So just checking very quickly, Ruby (1.9.1-p129) appears to use 1.5x when appending to an array, and Python (2.6.2) uses 1.125x plus a constant: (in Objects/listobject.c):
换个说法，每当来了一个新要求的大小(比如插入操作中的原大小+1,或删除操作中原大小-1)：newsize，这时python并不直接对list的空间进行调整。而是作个比较，若新要求的大小在总容量之下，总容量的一半之上则，不进行调整。

/* This over-allocates proportional to the list size, making room
* for additional growth.  The over-allocation is mild, but is
* enough to give linear-time amortized behavior over a long
* sequence of appends() in the presence of a poorly-performing
* system realloc().
* The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
*/new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);/* check for integer overflow */
if (new_allocated > PY_SIZE_MAX - newsize) {
 PyErr_NoMemory();
     return -1;
     } else {
          new_allocated += newsize;
          }
 arguments: list object, new size
returns: 0 if OK, -1 if notlist_resize:
    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) = 3
    new_allocated += newsize = 3 + 1 = 4
    resize ob_item (list of pointers) to size new_allocated
    return 0
    现在分配了 4 个用来装列表元素的槽空间，并且第一个空间中为整数 1。