| 方法名 | 返回值 | 描述 |
|---|---|---|
| count() | integer | 返回數據項在T中出現的次數 |
| index() | integer | 返回第一個數據項在T中出現位置的索引，若值不存在，則拋出ValueError |
基礎公用函數：
| 函數名 | 返回值 | 描述 |
|---|---|---|
| len() | integer | 返回容器中的項目數 |
| enumerate() | iterator for index, value of iterable | 返回一個可迭代對象，其中以小元組的形式包裹數據項與正向索引的對應關系 |
| reversed() | ... | 詳情參見函數章節 |
| sorted() | ... | 詳情參見函數章節 |
使用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值相等，證明引用同一個元組
官網參考：點我跳轉
源碼一覽：點我跳轉
以下是截取了一些關鍵性源代碼，并且做上了中文注釋，方便查閱。
每一個元組都有幾個關鍵性的屬性：
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)
}
以上就是老Python帶你從淺入深探究Tuple的詳細內容，更多關于Python Tuple的資料請關注腳本之家其它相關文章！
