稍微不那么简单，看看Python 中的 List 和 Tuple

以你之姓@ 2021-11-29 15:58 277阅读 0赞

[简单看看 Python 中的 List 和 Tuple][Python _ List _ Tuple]

#### List ####

l = []
    print(l,l.__sizeof__())
    # l 初始化40字节
    l.append(1)
    # 增加一个元素后，(注意，这里是append之后，)预分配了 4个 元素的32 个字节
    print(l,l.__sizeof__())
    # 72
    l += ([2, 3, 4])
    print(l,l.__sizeof__())
    l.append(5)
    print(l,l.__sizeof__())
    # 104
    l += ([6, 7, 8])
    print(l,l.__sizeof__())
    # 104
    l.append(9)
    print(l,l.__sizeof__())
    l +=[10, 11, 12 ,13 ,14, 15, 16]
    print(l,l.__sizeof__())
    l.append(17)
    print(l,l.__sizeof__())

打印结果是这样的

[] 40
    [1] 72
    [1, 2, 3, 4] 72
    [1, 2, 3, 4, 5] 104
    [1, 2, 3, 4, 5, 6, 7, 8] 104
    [1, 2, 3, 4, 5, 6, 7, 8, 9] 168
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] 168
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] 240

List 是一个 预分配内存的 线性表，数据结构如下：

![List-Python数据结构][List-Python]  
从白框可以看到，预分配内存 一般大于等于 `List`的实际空间，实际空间 `（Len(list))`等于 `ob_size`

当 allocate 小于 list.len 时，就会重新申请内存空间，并拷贝 List 元素，新分配的内存字节如下设定。

0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...

举个例子

*  append 1 ，allocated `4`个字节， 40 + 32 = 72 ，allocated > LEN(size)
 *  append 1, 2, 3 之后，allocated > LEN(size)
 *  append 4 之后，allocated = LEN(size)
 *  append 5 之后，重新分配 `4`个字节，72 + 32 = 104
 *  append 6, 7, 8, 9 重新分配 `8` 个字节，104 + 64= 168
 *  append 10, 11, 12, 13, 14, 15, 16, 17 重新分配 `16`个字节，168+ 72= 240

#### Tuple ####

/*
    Another generally useful object type is a tuple of object pointers.
    另外一个有用的数据类型是 元组
    For Python, this is an immutable type.  C code can change the tuple items
    在 Python 中，这是一个 不可改变的 类型。 C 代码可以改变 元组元素，甚至使用元组作为通用数组
    (but not their number), and even use tuples as general-purpose arrays of
    object references, 
    但总的来说只能突变,全新的元组
    but in general only brand new tuples should be mutated,
    而不是那些可能已经暴露在Python代码中的。
    not ones that might already have been exposed to Python code.
    */
    
    #ifndef Py_LIMITED_API
    typedef struct { 
        PyObject_VAR_HEAD
        PyObject *ob_item[1];
    
        /* ob_item contains space for 'ob_size' elements.
         * Items must normally not be NULL, except during construction when
         * the tuple is not yet visible outside the function that builds it.
         */
    } PyTupleObject;
    #endif

可以看到，tuple 是一个定长 线性表，tuple 的缓存机制，使得相同的 tuple 创建变得高效。

[Python _ List _ Tuple]: https://blog.csdn.net/qq_28018283/article/details/95201574
[List-Python]: /images/20211129/87251c7c29a14c609ca9dea6db803dae.png