元组

Python中的元组容器序列（tuple）与列表容器序列（list）具有极大的相似之处，因此也常被称为不可变的列表。

但是两者之间也有很多的差距，元组侧重于数据的展示，而列表侧重于数据的存储与操作。

它们非常相似，虽然都可以存储任意类型的数据，但是一个元组定义好之后就不能够再进行修改。

元组特性

元组的特点：

• 元组属于容器序列
• 元组属于不可变类型
• 元组底层由顺序存储组成，而顺序存储是线性结构的一种

基本声明

以下是使用类实例化的形式进行对象声明：

tup = tuple((1, 2, 3, 4, 5))
print("值:%r,类型：%r" % (tup, type(tup)))

# 值:(1, 2, 3, 4, 5),类型：<class 'tuple'>

也可以选择使用更方便的字面量形式进行对象声明，使用逗号对数据项之间进行分割：

tup = 1, 2, 3, 4, 5
print("值:%r,类型：%r" % (tup, type(tup)))

# 值:(1, 2, 3, 4, 5),类型：<class 'tuple'>

为了美观，我们一般会在两侧加上()，但是要确定一点，元组定义是逗号分隔的数据项，而并非是()包裹的数据项：

tup = (1, 2, 3, 4, 5)
print("值:%r,类型：%r" % (tup, type(tup)))

# 值:(1, 2, 3, 4, 5),类型：<class 'tuple'>

多维元组

当一个元组中嵌套另一个元组，该元组就可以称为多维元组。

如下，定义一个2维元组：

tup = (1, 2, 3, 4, 5)
print("值:%r,类型：%r" % (tup, type(tup)))

# 值:(1, 2, 3, 4, 5),类型：<class 'tuple'>

续行操作

在Python中，元组中的数据项如果过多，可能会导致整个元组太长，太长的元组是不符合PEP8规范的。

每行最大的字符数不可超过79，文档字符或者注释每行不可超过72

Python虽然提供了续行符\，但是在元组中可以忽略续行符，如下所示：

tup = (1, 2, ("三", "四"))
print("值:%r,类型：%r" % (tup, type(tup)))

# 值:(1, 2, ('三', '四')),类型：<class 'tuple'>

类型转换

元组支持与布尔型、字符串、列表、以及集合类型进行类型转换：

tup = (1, 2, 3)
bTup = bool(tup)    # 布尔类型
strTup = str(tup)   # 字符串类型
liTup = list(tup)   # 列表类型
setTup = set(tup)   # 集合类型

print("值:%r,类型：%r" % (bTup, type(bTup)))
print("值:%r,类型：%r" % (strTup, type(strTup)))
print("值:%r,类型：%r" % (liTup, type(liTup)))
print("值:%r,类型：%r" % (setTup, type(setTup)))

# 值:True,类型：<class 'bool'>
# 值:'(1, 2, 3)',类型：<class 'str'>
# 值:[1, 2, 3],类型：<class 'list'>
# 值:{1, 2, 3},类型：<class 'set'>

如果一个2维元组遵循一定的规律，那么也可以将其转换为字典类型：

tup = (("k1", "v1"), ("k2", "v2"), ("k3", "v3"))
dictTuple = dict(tup)

print("值:%r,类型：%r" % (dictTuple, type(dictTuple)))

# 值:{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'},类型：<class 'dict'>

索引操作

元组的索引操作仅支持获取数据项。

其他的任意索引操作均不被支持。

使用方法参照列表的索引切片一节。

绝对引用

元组拥有绝对引用的特性，无论是深拷贝还是浅拷贝，都不会获得其副本，而是直接对源对象进行引用。

但是列表没有绝对引用的特性，代码验证如下：

>>> import copy
>>> # 列表的深浅拷贝均创建新列表...
>>> oldLi = [1, 2, 3]
>>> id(oldLi)
4542649096
>>> li1 = copy.copy(oldLi)
>>> id(li1)
4542648840
>>> li2 = copy.deepcopy(oldLi)
>>> id(li2)
4542651208
>>> # 元组的深浅拷贝始终引用老元组
>>> oldTup = (1, 2, 3)
>>> id(oldTup)
4542652920
>>> tup1 = copy.copy(oldTup)
>>> id(tup1)
4542652920
>>> tup2 = copy.deepcopy(oldTup)
>>> id(tup2)
4542652920

Python为何要这样设计？其实仔细想想不难发现，元组不能对其进行操作，仅能获取数据项。

那么也就没有生成多个副本提供给开发人员操作的必要了，因为你修改不了元组，索性直接使用绝对引用策略。

值得注意的一点：[:]也是浅拷贝，故对元组来说属于绝对引用范畴。

元组的陷阱

Leonardo Rochael在2013年的Python巴西会议提出了一个非常具有思考意义的问题。

我们先来看一下：

>>> t = (1, 2, [30, 40])
>>> t[-1] += [50, 60]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

现在，t到底会发生下面4种情况中的哪一种？

1. t 变成 (1, 2, [30, 40, 50, 60])。
2. 因为 tuple 不支持对它的数据项赋值，所以会抛出 TypeError 异常。
3. 以上两个都不是。a 和 b 都是对的。

正确答案是4，t确实会变成 (1, 2, [30, 40, 50, 60])，但同时元组是不可变类型故会引发TypeError异常的出现。

>>> t
(1, 2, [30, 40, 50, 60])

如果是使用extend()对t[-1]的列表进行数据项的增加，则答案会变成1。

我当初在看了这个问题后，暗自告诉自己了2件事情：

• list的数据项增加尽量不要使用+=，而应该使用append()或者extend()

Ps：我也不知道自己为什么会产生这样的想法，但这个想法确实伴随我很长时间，直至现在

• tuple中不要存放可变类型的数据，如list、set、dict等..

元组更多的作用是展示数据，而不是操作数据。

举个例子，当用户根据某个操作获取到了众多数据项之后，你可以将这些数据项做出元组并返回。

用户对被返回的原对象只能看，不能修改，若想修改则必须创建新其他类型对象。

解构方法

元组的解构方法与列表使用相同。

使用方法参照列表的解构方法一节。

常用方法

方法一览

常用的list方法一览表：

基础公用函数：

获取长度

使用len()方法来获取元组的长度。

返回int类型的值。

tup = ("A", "B", "C", "D", "E", "F", "G")

print(len(tup))

# 7

Python在对内置的数据类型使用len()方法时，实际上是会直接的从PyVarObject结构体中获取ob_size属性，这是一种非常高效的策略。

PyVarObject是表示内存中长度可变的内置对象的C语言结构体。

直接读取这个值比调用一个方法要快很多。

统计次数

使用count()方法统计数据项在该元组中出现的次数。

返回int：

tup = ("A", "B", "C", "D", "E", "F", "G", "A")

aInTupCount = tup.count("A")

print(aInTupCount)

# 2

查找位置

使用index()方法找到数据项在当前元组中首次出现的位置索引值，如数据项不存在则抛出异常。

返回int。

tup = ("A", "B", "C", "D", "E", "F", "G", "A")

aInTupIndex = tup.index("A")

print(aInTupIndex)

# 0

底层探究

内存开辟

Python内部实现中，列表和元组还是有一定的差别的。

元组在创建对象申请内存的时候，内存空间大小便进行了固定，后续不可更改（如果是传入了一个可迭代对象，例如tupe(range(100))，这种情况会进行扩容与缩容，下面的章节将进行探讨研究）。

而列表在创建对象申请内存的时候，内存空间大小不是固定的，如果后续对其新增或删除数据项，列表会进行扩容或者缩容机制。

元组创建

空元组

若创建一个空元组，会直接进行创建，然后将这个空元组丢到缓存free_list中。

元组的free_list最多能缓存 20 * 2000 个元组，这个在下面会进行讲解。

如图所示：

元组转元组

这样的代码会进行元组转元组：

tup = tuple((1, 2, 3))

首先内部本身就是一个元组（1， 2， 3），所以会直接将内部的这个元组拿出来并返回引用，并不会再次创建。

代码验证：

>>> oldTup = (1, 2, 3)
>>> id(oldTup)
4384908128
>>> newTup = tuple(oldTup)
>>> id(newTup)
4384908128
>>>

列表转元组

列表转元组会将列表中的每一个数据项都拿出来，然后放入至元组中：

tup = tuple([1, 2, 3])

所以你会发现，列表和元组中的数据项引用都是相同的：

>>> li1 = ["A", "B", "C"]
>>> tup = tuple(li1)
>>> print(id(li1[0]))
4383760656
>>> print(id(tup[0]))
4383760656
>>>

可迭代对象转元组

可迭代对象是没有长度这一概念的，如果是可迭代对象转换为元组，会先对可迭代对象的长度做一个猜想。

并且根据这个猜想，为元组开辟一片内存空间，用于存放可迭代对象的数据项。

然后内部会获取可迭代对象的迭代器，对其进行遍历操作，拿出数据项后放至元组中。

如果猜想的长度太小，会导致元组内部的内存不够存放下所有的迭代器数据项，此时该元组会进行内部的扩容机制，直至可迭代对象中的数据项全部被添加至元组中。

rangeObject = range(1, 101)
tup = tuple(rangeObject)

// 假如猜想的是9
// 第一步：+ 10 
// 第二步：+ (原长度+10) * 0.25
// 其实，就是增加【原长度*0.25 + 2.5】

如果猜想的长度太大，而实际上迭代器中的数据量偏少，则需要对该元组进行缩容。

切片取值

对元组进行切片取值的时候，会开辟一个新元组用于存放切片后得到的数据项。

tup = (1, 2, 3)
newSliceTup = tup[0:2]

当然，如果是[:]的操作，则参照绝对引用，直接返回被切片的元组引用。

代码验证：

>>> id(tup)
4384908416
>>> newSliceTup = tup[0:2]
>>> id(newSliceTup)
4384904392

缓存机制

free_list缓存

元组的缓存机制和列表的缓存机制不同。

元组的free_list会缓存0 - 19长度的共20种元组，其中每一种长度的元组通过单向链表横向扩展缓存至2000个，如下图所示：

当每一次的del操作有数据项的元组时，都会将该元组数据项清空并挂载至free_list单向链表的头部的位置。

del 元组1
del 元组2
del 元组3

如下图所示：

当要创建一个元组时，会通过创建元组的长度，从free_list单向链表的头部取出一个元组，然后将数据项存放进去。

前提是free_list单向链表中缓存的有该长度的元组。

tup = (1, 2, 3)

空元组与非空元组的缓存

空元组的缓存是一经创建就缓存到free_list单向链表中。

而非空元组的缓存必须是del操作后才缓存到free_list单向链表中。

空元组的创建

第一次创建空元组后，空元组会缓存至free_list单向链表中。

以后的每一次空元组创建，返回的其实都是同一个引用，也就是说空元组在free_list单向链表中即使被引用了也不会被销毁。

>>> t1 = ()
>>> id(t1)
4511088712
>>> t2 = ()
>>> id(t2)
4511088712

非空元组的创建

当free_list单向链表中有相同长度的元组时，会进行引用并删除。

这个在上图中已经示例过了，就是这个：

代码示例：

$ python3

Python 3.6.8 (v3.6.8:3c6b436a57, Dec 24 2018, 02:04:31)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> v1 = (None, None, None)
>>> id(v1)
4384907696
>>> v2 = (None, None, None)
>>> id(v2)
4384908056
>>> del v1
>>> del v2   # ①
>>> v3 = (None, None, None)
>>> id(v3)   # ②
4384908056
>>> v4 = (None, None, None)
>>> id(v4)   # ③
4384907696
>>>

①：free_list num_free=3 单向链表结构：v2 ―> v1

②：创建了v3，拿出v2的空元组，填入v3数据项，故v2和v3的id值相等，证明引用同一个元组，此时free_list num_free=3 单向链表结构为：―> v1

③：创建了v4，拿出v1的空元组，填入v4数据项，故v1和v4的id值相等，证明引用同一个元组

tupleobject.c源码

官网参考：点我跳转

源码一览：点我跳转

以下是截取了一些关键性源代码，并且做上了中文注释，方便查阅。

每一个元组都有几个关键性的属性：

Py_ssize_t ob_refcnt;     // 引用计数器
Py_ssize_t ob_size;       // 数据项个数，即元组大小
PyObject *ob_item[1];     // 存储元组中的数据项 [指针, ]

关于缓存free_list的属性：

PyTuple_MAXSAVESIZE     // 相当于图中的 free_num ，最大20，即纵向扩展的缓存元组长度
PyTuple_MAXFREELIST     // 图中 free_list 的横向扩展缓存列表个数，最大2000

创建元组

空元组

PyObject *
PyTuple_New(Py_ssize_t size)
{
    PyTupleObject *op;
    // 缓存相关
    Py_ssize_t i;
    
    // 元组的大小不能小于0
    if (size < 0) {
        PyErr_BadInternalCall();
        return NULL;
    }
#if PyTuple_MAXSAVESIZE > 0

    // 创建空元组，优先从缓存中获取
    // size = 0 表示这是一个空元组，从free_list[0]中获取空元组
    if (size == 0 && free_list[0]) {
        // op就是空元组
        op = free_list[0];
        // 新增空元组引用计数器 + 1
        Py_INCREF(op);
#ifdef COUNT_ALLOCS
        tuple_zero_allocs++;
#endif
        // 返回空元组的指针
        return (PyObject *) op;
    }
    
    // 如果创建的不是空元组，且这个创建的元组数据项个数小于20，并且free_list[size]不等于空，表示有缓存
    // 则从缓存中去获取，不再重新开辟内存
    if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
        // 拿出元组
        free_list[size] = (PyTupleObject *) op->ob_item[0];
        // num_free减1
        numfree[size]--;
#ifdef COUNT_ALLOCS
        fast_tuple_allocs++;
#endif
        /* Inline PyObject_InitVar */
        // 初始化，定义这个元组的长度为数据项个数
#ifdef Py_TRACE_REFS
        Py_SIZE(op) = size;
        // 定义类型为 tuple
        Py_TYPE(op) = &PyTuple_Type;
#endif
        // 增加一次新的引用
        _Py_NewReference((PyObject *)op);
    }
    
    // 如果是空元组
    else
#endif
    {
        // 检查内存情况，是否充足
        /* Check for overflow */
        if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - sizeof(PyTupleObject) -
                    sizeof(PyObject *)) / sizeof(PyObject *)) {
            return PyErr_NoMemory();
        }
        // 开辟内存，并获得一个元组：op
        op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
        if (op == NULL)
            return NULL;
    }
    
    // 空元组的每一个槽位都是NULL
    for (i=0; i < size; i++)
        op->ob_item[i] = NULL;
        
#if PyTuple_MAXSAVESIZE > 0
   // 缓存空元组
    if (size == 0) {
        free_list[0] = op;
        ++numfree[0];
        Py_INCREF(op);          /* extra INCREF so that this is never freed */
    }
#endif
#ifdef SHOW_TRACK_COUNT
    count_tracked++;
#endif

    // 将元组加入到GC机制中，用于内存管理
    _PyObject_GC_TRACK(op);
    return (PyObject *) op;
}

可迭代对象转元组

这个不在tupleobject.c源码中，而是在abstract.c源码中。

官网参考：点我跳转

源码一览：点我跳转

PyObject *
PySequence_Tuple(PyObject *v)
{
    PyObject *it;  /* iter(v) */
    Py_ssize_t n;             /* guess for result tuple size */
    PyObject *result = NULL;
    Py_ssize_t j;

    if (v == NULL) {
        return null_error();
    }

    /* Special-case the common tuple and list cases, for efficiency. */
    // 如果是元组转换元组，如 tup = (1, 2, 3) 或者 tup = ((1, 2, 3))直接返回内存地址
    if (PyTuple_CheckExact(v)) {
        Py_INCREF(v);
        return v;
    }
    
    // 如果是列表转换元组，则执行PyList_AsTuple()，将列表转换为元组
    // 如 tup = ([1, 2, 3])
    if (PyList_CheckExact(v))
        return PyList_AsTuple(v);

    /* Get iterator. */
    // 获取迭代器， tup = (range(1, 4).__iter__())
 
    it = PyObject_GetIter(v);
    if (it == NULL)
        return NULL;

    /* Guess result size and allocate space. */
    // 猜想迭代器长度，也就是猜一下有多少个数据项
    n = PyObject_LengthHint(v, 10);
    if (n == -1)
        goto Fail;
        
    // 根据猜想的迭代器长度，进行元组的内存开辟
    result = PyTuple_New(n);
    if (result == NULL)
        goto Fail;

    /* Fill the tuple. */
    // 将迭代器中每个数据项添加至元组中
    for (j = 0; ; ++j) {
        PyObject *item = PyIter_Next(it);
        if (item == NULL) {
            if (PyErr_Occurred())
                goto Fail;
            break;
        }
        
        //如果迭代器中数据项比猜想的多，则证明开辟内存不足需要需要进行扩容
        if (j >= n) {
            size_t newn = (size_t)n;
            /* The over-allocation strategy can grow a bit faster
               than for lists because unlike lists the
               over-allocation isn't permanent -- we reclaim
               the excess before the end of this routine.
               So, grow by ten and then add 25%.
            */
            
            // 假如猜想的是9
            // 第一步：+ 10 
            // 第二步：+ (原长度+10) * 0.25
            // 其实，就是增加【原长度*0.25 + 2.5】
            
            newn += 10u;
            newn += newn >> 2;
            
            // 判断是否超过了元组的数据项个数限制（sys.maxsize）
            if (newn > PY_SSIZE_T_MAX) {
                /* Check for overflow */
                PyErr_NoMemory();
                Py_DECREF(item);
                goto Fail;
            }
            n = (Py_ssize_t)newn;
            // 扩容机制
            if (_PyTuple_Resize(&result, n) != 0) {
                Py_DECREF(item);
                goto Fail;
            }
        }
        
        // 将数据项放入元组之中
        PyTuple_SET_ITEM(result, j, item);
    }

    /* Cut tuple back if guess was too large. */
    
    // 如果猜想的数据项太多，而实际上迭代器中的数据量偏少
    // 则需要对该元组进行缩容
    if (j < n &&
        _PyTuple_Resize(&result, j) != 0)
        goto Fail;

    Py_DECREF(it);
    return result;

Fail:
    Py_XDECREF(result);
    Py_DECREF(it);
    return NULL;
}

列表转元组

这个不在tupleobject.c源码中，而是在listobject.c源码中。

官网参考：点我跳转

源码一览：点我跳转

PyObject *
PyList_AsTuple(PyObject *v)
{
    PyObject *w;
    PyObject **p, **q;
    Py_ssize_t n;
    // 例如：tup = ([1, 2, 3])
    
    // 进行列表的验证
    if (v == NULL || !PyList_Check(v)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    
    // 获取大小，即数据项个数
    n = Py_SIZE(v);
    // 开辟内存
    w = PyTuple_New(n);
    
    // 如果是空元组
    if (w == NULL)
        return NULL;
        
    // 执行迁徙操作
    p = ((PyTupleObject *)w)->ob_item;
    q = ((PyListObject *)v)->ob_item;
    
    // 将列表中数据项的引用，也给元组进行引用
    // 这样列表中数据项和元组中的数据项都引用同1个对象
    while (--n >= 0) {
        // 数据项引用计数 + 1
        Py_INCREF(*q);
        *p = *q;
        p++;
        q++;
    }
    
    // 返回元组
    return w;
}

切片取值

PyObject *
PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
// 切片会触发该方法
{
    // 如果对空元组进行切片，则会抛出异常
    if (op == NULL || !PyTuple_Check(op)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    // 内部的具体实现方法
    return tupleslice((PyTupleObject *)op, i, j);
}

static PyObject *
tupleslice(PyTupleObject *a, Py_ssize_t ilow,
           Py_ssize_t ihigh)
{
    PyTupleObject *np;
    PyObject **src, **dest;
    Py_ssize_t i;
    Py_ssize_t len;
    
    // 计算索引位置
    if (ilow < 0)
        ilow = 0;
    if (ihigh > Py_SIZE(a))
        ihigh = Py_SIZE(a);
    if (ihigh < ilow)
        ihigh = ilow;
        
    // 如果是[:]的操作，则直接返回源元组对象a的指针，即绝对引用
    if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
        Py_INCREF(a);
        return (PyObject *)a;
    }
    
    // 初始化新的切片对象元组长度
    len = ihigh - ilow;
    
    // 开始切片，创建了一个新元组np
    np = (PyTupleObject *)PyTuple_New(len);
    if (np == NULL)
        return NULL;
    src = a->ob_item + ilow;
    dest = np->ob_item;
    
    // 对源元组中的数据项的引用计数+1
    for (i = 0; i < len; i++) {
        PyObject *v = src[i];
        Py_INCREF(v);
        dest[i] = v;
    }
    
    // 返回切片对象新元组np的引用
    return (PyObject *)np;
}

缓存相关

static void
tupledealloc(PyTupleObject *op)
{
    Py_ssize_t i;
    Py_ssize_t len =  Py_SIZE(op);
    PyObject_GC_UnTrack(op);
    Py_TRASHCAN_SAFE_BEGIN(op)
    
    // 如果元组的长度大于0，则不是一个非空元组
    if (len > 0) {
        i = len;
        // 将内部的数据项引用计数都 - 1
        while (--i >= 0)
            Py_XDECREF(op->ob_item[i]);
#if PyTuple_MAXSAVESIZE > 0
        
        // 准备缓存，判断num_free是否小于20，并且单向链表中的已缓存元组个数小于2000
        if (len < PyTuple_MAXSAVESIZE &&
            numfree[len] < PyTuple_MAXFREELIST &&
            Py_TYPE(op) == &PyTuple_Type)
        {
            // 添加至链表头部
            op->ob_item[0] = (PyObject *) free_list[len];
            // 将num_free + 1
            numfree[len]++;
            free_list[len] = op;
            goto done; /* return */
        }
#endif
    }
    // 内存中进行销毁
    Py_TYPE(op)->tp_free((PyObject *)op);
done:
    Py_TRASHCAN_SAFE_END(op)
}

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：mmqy2019@163.com进行举报，并提供相关证据，查实之后，将立刻删除涉嫌侵权内容。

猜你喜欢

• 如何利用pyecharts控件绘制图表，代码是什么

  这篇文章介绍了Python使用pyecharts控件绘制图表的方法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

• Python中一维和二维数据怎么存储和读取的

  程序中与数据相关的操作分为数据的存储与读写。下面将对如何存储与读写不同维度的数据进行讲解。1.数据存储数据通常存储在文件之中，为了方便后续的读写操作，数据通常需要按照约定的组织方式进行存储。一维数据呈线性排列，一般用特殊字符分隔，具体示例如下。

• 基于Python实现层次分析法的思路及方法是什么

  这篇文章主要介绍了Python实现层次分析法及自调节层次分析法的示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

• 用pytorch怎样实现自动编码器，方法是什么

  这篇文章主要介绍了pytorch 实现变分自动编码器的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

• Python中实现浮点数取整的几种方式是什么

  这篇文章主要介绍了Python浮点数取整、格式化和NaN处理的操作方法,本文较详细介绍了取整的三种方法，格式化浮点数输出的示例代码详解，感兴趣的朋友跟随小编一起看看吧