(1) 可使用constant /61/3/a。

    >>> from dis import dis

    >>> dis(compile("(10,  abc )",   ,  eval ))
      1           0 LOAD_CONST               2 ((10,  abc ))
                  3 RETURN_VALUE   

    >>> dis(compile("[10,  abc ]",   ,  eval ))
      1           0 LOAD_CONST               0 (10)
                  3 LOAD_CONST               1 ( abc )
                  6 BUILD_LIST               2
                  9 RETURN_VALUE 

>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True

>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False

>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200

/* 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, ...
 * Note: new_allocated won t overflow because the largest possible value
 *       is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
 */

$ python3.6 -m timeit -s  a = (10, 20, 30)   a[1] 
10000000 loops, best of 3: 0.0304 usec per loop
$ python3.6 -m timeit -s  a = [10, 20, 30]   a[1] 
10000000 loops, best of 3: 0.0309 usec per loop

$ python3.6 -m timeit -s  a = (10, 20, 30)   x, y, z = a 
10000000 loops, best of 3: 0.0249 usec per loop
$ python3.6 -m timeit -s  a = [10, 20, 30]   x, y, z = a 
10000000 loops, best of 3: 0.0251 usec per loop

https://github.com/python/cpython/blob/master/Include/tupleobject.h” rel=“noreferer”>Here 储存了<代码>(10,20):

    typedef struct {
        Py_ssize_t ob_refcnt;
        struct _typeobject *ob_type;
        Py_ssize_t ob_size;
        PyObject *ob_item[2];     /* store a pointer to 10 and a pointer to 20 */
    } PyTupleObject;

Here:该名单是如何储存的。

    PyObject arr[2];              /* store a pointer to 10 and a pointer to 20 */

    typedef struct {
        Py_ssize_t ob_refcnt;
        struct _typeobject *ob_type;
        Py_ssize_t ob_size;
        PyObject **ob_item = arr; /* store a pointer to the two-pointer array */
        Py_ssize_t allocated;
    } PyListObject;

请注意,图标直接包含两个数据点,而清单标的外围阵的间接层则有两个数据点。

亚历克作出了巨大的回答,但我会试图扩大我认为值得提及的几点内容。 任何绩效差异一般都是很小的,具体实施是具体的:因此,不给农场主。

在CPython,陶器储存在一个单独的记忆库中,因此,在最坏的单一呼吁中,形成一种新的记忆。 清单分两个区:固定区块,所有灰色物体信息,以及数据可变区块。 之所以能够更快地制定教学大纲,这部分原因可能也解释了指数速度的微小差别,因为要紧跟这一点。

CPython也选择了减少记忆分配的办法:在一份免费清单中节省了未分配清单的物体,以便能够再使用,但分配不豁免清单仍需要为数据划拨记忆。 在20个免费名单上为不同规模的拖车节省了图象,因此,分配小图往往不需要任何记忆分配电话。

这种优化在实践中是有用的,但也可能使依赖时间结果的风险太大,当然,如果你转向像“铁Python”这样的内容,即记忆分配工作差别很大的话,这种做法完全不同。

有了<代码> 时间模块,你往往可以解决与业绩有关的问题:

$ python2.6 -mtimeit -s  a = tuple(range(10000))   for i in a: pass 
10000 loops, best of 3: 189 usec per loop
$ python2.6 -mtimeit -s  a = list(range(10000))   for i in a: pass  
10000 loops, best of 3: 191 usec per loop

这表明,学生的体格率比消化人数要快。 我在指数化方面取得了类似结果,但在建筑、图形销毁清单方面:

$ python2.6 -mtimeit  (1, 2, 3, 4)    
10000000 loops, best of 3: 0.0266 usec per loop
$ python2.6 -mtimeit  [1, 2, 3, 4] 
10000000 loops, best of 3: 0.163 usec per loop

因此,如果循环速度或指数化速度是唯一的因素,那么实际上就没有变化,而是建筑,拖车获胜。

In python, we have two types of objects. 1. Mutable, 2. Immutable.
In python, lists come under mutable objects and tuples comes under immutable objects.

• Tuples are stored in a single block of memory. Tuples are immutable so, It doesn t require extra space to store new objects.

• Lists are allocated in two blocks: the fixed one with all the Python object information and a variable-sized block for the data.

• 造成图形的原因比清单要快。

• It also explains the slight difference in indexing speed is faster than lists, because in tuples for indexing it follows fewer pointers.

Advantages of using tuples:

• 遗嘱是,在清单使用更多的记忆时,它们使用较少的记忆。

• We can use tuples in a dictionary as a key but it s not possible with lists.

• 我们可以查阅标记和清单中的指数。

Disadvantages of tuples:

• 我们不能在图表中增加一个内容,但我们可以在清单中增加一个内容。

• We can t sort a tuple but in a list, we can sort by calling list.sort() method.

• We can t remove an element in tuple but in a list, we can remove an element.

• 我们可以替代图中的内容,但可以列入清单。

<