print([1, 2, 3] + [4, 5])  
"""
[1, 2, 3, 4, 5]
"""

// Objects/listobject.c
static PyObject *
list_concat(PyListObject *a, PyObject *bb)
{   
    // 兩個(gè)列表相加之后的新列表的長(zhǎng)度
    Py_ssize_t size;
    Py_ssize_t i;
    PyObject **src, **dest;
    PyListObject *np;
    // 如果 bb 不是列表，拋出 TypeError
    if (!PyList_Check(bb)) {
        PyErr_Format(PyExc_TypeError,
                  "can only concatenate list (not \"%.200s\") to list",
                  Py_TYPE(bb)->tp_name);
        return NULL;
    }
#define b ((PyListObject *)bb)
    // 兩個(gè)列表的長(zhǎng)度相加一定小于 PY_SSIZE_T_MAX
    assert((size_t)Py_SIZE(a) + (size_t)Py_SIZE(b) < PY_SSIZE_T_MAX);
    // 新列表的長(zhǎng)度，等于相加的兩個(gè)列表的長(zhǎng)度之和
    size = Py_SIZE(a) + Py_SIZE(b);
    // 如果長(zhǎng)度為 0，那么創(chuàng)建一個(gè)空列表，然后返回即可
    if (size == 0) {
        return PyList_New(0);
    }
    // 為 PyListObject 和底層數(shù)組申請(qǐng)空間（空間大小為 8 * size）
    np = (PyListObject *) list_new_prealloc(size);
    if (np == NULL) {
        return NULL;
    }
    // 將第一個(gè)列表的元素增加引用計(jì)數(shù)之后，拷貝到新列表中
    src = a->ob_item;
    dest = np->ob_item;
    for (i = 0; i < Py_SIZE(a); i++) {
        PyObject *v = src[i];
        dest[i] = Py_NewRef(v);
    }
    // 將第二個(gè)列表的元素增加引用計(jì)數(shù)之后，拷貝到新列表中
    src = b->ob_item;
    dest = np->ob_item + Py_SIZE(a);
    for (i = 0; i < Py_SIZE(b); i++) {
        PyObject *v = src[i];
        dest[i] = Py_NewRef(v);
    }
    // 將新列表的 ob_size 設(shè)置為 size
    Py_SET_SIZE(np, size);
    // 轉(zhuǎn)成泛型指針之后返回
    return (PyObject *)np;
#undef b
}

print([1, 2, 3] * 3)
"""
[1, 2, 3, 1, 2, 3, 1, 2, 3]
"""

// Objects/listobject.c
static PyObject *
list_repeat(PyListObject *a, Py_ssize_t n)
{
    // 獲取 a 指向的列表的長(zhǎng)度
    const Py_ssize_t input_size = Py_SIZE(a);
    // 如果列表長(zhǎng)度為 0，或者乘上一個(gè)小于等于 0 的數(shù)
    // 那么創(chuàng)建的新列表的長(zhǎng)度依舊是 0，因此直接返回空列表即可
    if (input_size == 0 || n <= 0)
        return PyList_New(0);
    assert(n > 0);
    // 長(zhǎng)度有限制，不能超過(guò) PY_SSIZE_T_MAX
    if (input_size > PY_SSIZE_T_MAX / n)
        return PyErr_NoMemory();
    // 新列表的長(zhǎng)度
    Py_ssize_t output_size = input_size * n;
    // 為新列表和底層數(shù)組申請(qǐng)空間，底層數(shù)組的長(zhǎng)度為 output_size
    PyListObject *np = (PyListObject *) list_new_prealloc(output_size);
    if (np == NULL)
        return NULL;
    // 指向新列表的底層數(shù)組的首元素
    PyObject **dest = np->ob_item;
    // 如果原始列表的長(zhǎng)度為 1，比如 a = [1]，n = 3
    // 那么新列表就是 [1, 1, 1]
    if (input_size == 1) {
        // 拿到第一個(gè)元素
        PyObject *elem = a->ob_item[0];
        // 因?yàn)橐貜?fù) n 次，所以引用計(jì)數(shù)增加 n
        _Py_RefcntAdd(elem, n);
        PyObject **dest_end = dest + output_size;
        // 將新列表的底層數(shù)組的元素全部設(shè)置為 elem
        while (dest < dest_end) {
            *dest++ = elem;
        }
    }
    // 如果原始列表的長(zhǎng)度不為 1
    else {
        PyObject **src = a->ob_item;
        PyObject **src_end = src + input_size;
        // 將原始列表的元素依次拷貝到新列表中，但此時(shí)只拷貝了 1 次
        while (src < src_end) {
            _Py_RefcntAdd(*src, n);
            *dest++ = *src++;
        }
        // 將新列表里面的元素再重復(fù) output_size / input_size - 1  次
        // 說(shuō)白了就是再重復(fù) n - 1 次
        _Py_memory_repeat((char *)np->ob_item, 
                          sizeof(PyObject *)*output_size,
                          sizeof(PyObject *)*input_size);
    }
    // 將新列表的 ob_size 設(shè)置為 output_size
    Py_SET_SIZE(np, output_size);
    return (PyObject *) np;
}

data = [1, 2, 3, 4, 5]
print(data[1])  # 2
print(data[1: 4])  # [2, 3, 4]

// Objects/listobject.c
static PyObject *
list_subscript(PyListObject* self, PyObject* item)
{   
    // 在基于索引和切片截取時(shí)，所有序列型對(duì)象的邏輯都差不多
    if (_PyIndex_Check(item)) {
        // 如果 item 是索引，那么轉(zhuǎn)成 Py_ssize_t 整數(shù)
        Py_ssize_t i;
        i = PyNumber_AsSsize_t(item, PyExc_IndexError);
        if (i == -1 && PyErr_Occurred())
            return NULL;
        // 如果 i 小于 0，那么加上列表長(zhǎng)度，轉(zhuǎn)成正數(shù)索引
        if (i < 0)
            i += PyList_GET_SIZE(self);
        // 調(diào)用 list_item 獲取 ob_item 中索引為 i 的元素
        return list_item(self, i);
    }
    // 如果 item 是切片
    else if (PySlice_Check(item)) {
        // start, stop, step 分別表示起始位置、終止位置、步長(zhǎng)
        // slicelength 表示切片截取的長(zhǎng)度，也就是要截取多少個(gè)元素
        Py_ssize_t start, stop, step, slicelength, i;
        size_t cur;
        PyObject* result;
        PyObject* it;
        PyObject **src, **dest;
        // 獲取切片的 start、stop、step
        if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
            return NULL;
        }
        // 傳入原始列表的長(zhǎng)度，對(duì) start 和 stop 進(jìn)行調(diào)整，并返回 slicelength
        slicelength = PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
                                            step);
        // 如果 slicelength <= 0，說(shuō)明截取不到任何元素
        // 比如 data[5: 1] 或者 data[1: 5: -1]，那么直接返回空列表
        if (slicelength <= 0) {
            return PyList_New(0);
        }
        // 如果步長(zhǎng)為 1，那么直接將列表中 start 到 stop 之間的元素拷過(guò)去即可
        else if (step == 1) {
            return list_slice(self, start, stop);
        }
        // 否則說(shuō)明步長(zhǎng)不為 1
        else {
            // 為創(chuàng)建的新列表和底層數(shù)組申請(qǐng)空間
            result = list_new_prealloc(slicelength);
            if (!result) return NULL;
            src = self->ob_item;
            dest = ((PyListObject *)result)->ob_item;
            // 從 start 處開(kāi)始遍歷，將元素拷貝過(guò)去
            // 然后 cur 每次增加 step，遍歷次數(shù)為 slicelength
            for (cur = start, i = 0; i < slicelength;
                cur += (size_t)step, i++) {
                it = Py_NewRef(src[cur]);
                dest[i] = it;
            }
            // 將新列表的 ob_size 設(shè)置為 slicelength
            Py_SET_SIZE(result, slicelength);
            return result;
        }
    }
    // 否則說(shuō)明 item 既不是索引也不是切片，那么報(bào)錯(cuò)
    else {
        PyErr_Format(PyExc_TypeError,
                     "list indices must be integers or slices, not %.200s",
                     Py_TYPE(item)->tp_name);
        return NULL;
    }
}

data = [1, 2, 3, 4, 5, 6, 7, 8]

# 通過(guò)切片設(shè)置元素，右值一定是一個(gè)可迭代對(duì)象
data[0: 3] = [11, 22, 33]
# 會(huì)將 data[0] 設(shè)置為 11，將 data[1] 設(shè)置為 22，將 data[2] 設(shè)置為 33
print(data)
"""
[11, 22, 33, 4, 5, 6, 7, 8]
"""

# 而且它們的長(zhǎng)度是可以不相等的，這里表示將 [0: 3] 的元素設(shè)置為 [1, 2]
# 即 data[0] 設(shè)置成 1，data[1] 設(shè)置成 2，那么問(wèn)題來(lái)了，data[2] 咋辦？
# 由于右值中已經(jīng)沒(méi)有元素與之匹配了，那么 data[2] 就會(huì)被刪掉
data[0: 3] = [1, 2]
print(data)
"""
[1, 2, 4, 5, 6, 7, 8]
"""

# 所以如果想刪除 [0: 3] 的元素，那么只需要執(zhí)行 data[0: 3] = [] 即可
# 因?yàn)?[] 里面沒(méi)有元素能與之匹配，所以 data 中 [0: 3] 的位置由于匹配不到
# 那么相當(dāng)于執(zhí)行了刪除操作，當(dāng)然由于 Python 的動(dòng)態(tài)特性，還可以像下面這么做
# data[0: 3] = []、data[0: 3] = ()、data[0: 3] = "" 等等也是沒(méi)問(wèn)題的
data[0: 3] = ""
print(data)
"""
[5, 6, 7, 8]
"""
# 實(shí)際上執(zhí)行 del data[0] 的時(shí)候，就是執(zhí)行了 data[0: 1] = []
# 當(dāng)然，如果右值元素多的話也是可以的，相當(dāng)于插入
# 比如這里的 data[0] 匹配 1，然后左邊就結(jié)束了
# 于是右側(cè)剩余的元素會(huì)依次插在后面
data[0: 1] = [1, 2, 3, 4]
print(data)
"""
[1, 2, 3, 4, 6, 7, 8]
"""
# 重點(diǎn)來(lái)了，如果切片的步長(zhǎng)不等于 1 的話，那么兩邊一定要匹配
# 由于 data[:: 2] 會(huì)得到 4 個(gè)元素，那么右邊的可迭代對(duì)象的長(zhǎng)度就必須也是 4
data[:: 2] = ['a', 'b', 'c', 'd']
print(data)
"""
['a', 2, 'b', 4, 'c', 7, 'd']
"""

# 但如果長(zhǎng)度不一致，那么會(huì)報(bào)錯(cuò)
try:
    data[:: 2] = ['a', 'b', 'c']
except Exception as e:
    # 顯然會(huì)報(bào)錯(cuò)
    print(e)  
"""
attempt to assign sequence of size 3 to extended slice of size 4
"""