[* A] 'nın aşırı yer değiştirmesine neden olan nedir?

Görünüşe göre list(a)değil, overallocate does [x for x in a]bazı noktalarda overallocates ve [*a]overallocates her zaman ?

Burada, n'den 0'a kadar olan boyutlar ve üç yöntem için elde edilen boyutlar bayt cinsinden verilmiştir:

0 56 56 56
1 64 88 88
2 72 88 96
3 80 88 104
4 88 88 112
5 96 120 120
6 104 120 128
7 112 120 136
8 120 120 152
9 128 184 184
10 136 184 192
11 144 184 200
12 152 184 208

Böyle Bilgisayarlı, repl.it de reproducable Python 3. kullanarak, 8 :

from sys import getsizeof

for n in range(13):
    a = [None] * n
    print(n, getsizeof(list(a)),
             getsizeof([x for x in a]),
             getsizeof([*a]))

Peki: Bu nasıl çalışıyor? [*a]Aşırı nasıl konumlanır? Aslında, verilen girdiden sonuç listesi oluşturmak için hangi mekanizmayı kullanıyor? Üzerinde bir yineleyici ave benzeri bir şey kullanıyor list.appendmu? Kaynak kodu nerede?

( Görüntüleri üreten veri ve kodlarla birlikte çalışın .)

Daha küçük n'ye yakınlaştırma:

Daha büyük n'ye yakınlaştırma:

[*a] dahili olarak C eşdeğerini yapıyor :

1. Yeni, boş bir hale getirin list
2. Aramak newlist.extend(a)
3. İade list.

Testinizi şu şekilde genişletirseniz:

from sys import getsizeof

for n in range(13):
    a = [None] * n
    l = []
    l.extend(a)
    print(n, getsizeof(list(a)),
             getsizeof([x for x in a]),
             getsizeof([*a]),
             getsizeof(l))

Çevrimiçi deneyin!

için sonuçları görürsünüz getsizeof([*a])ve l = []; l.extend(a); getsizeof(l)aynıdır.

Bu genellikle yapılacak doğru şeydir; ne zaman extendgenelleştirilmiş açma için benzer genellikle daha sonra eklemeyi bekliyoruz ing ve, birden şeyler birbiri ardına eklenecektir olduğu varsayılır. [*a]normal durum değildir; Python, list( [*a, b, c, *d]) öğesine birden fazla öğe veya yinelenebilir öğe eklendiğini varsayar ; bu nedenle genel konum belirleme, genel durumda iş tasarrufu sağlar.

Aksine, listtek, önceden belirlenmiş bir tekrarlanabilir (ile list()) bir yapı, kullanım sırasında büyüyemez veya küçülemez ve aksi kanıtlanana kadar aşırı konum belirleme erken olur; Python kısa süre önce yapıcıyı bilinen boyuttaki girdiler için bile aşırı konumlandırmaya neden olan bir hatayı düzeltti .

Anlamalara gelince list, bunlar tekrarlanan appends'lere etkili bir şekilde eşdeğerdir , bu nedenle bir seferde bir öğe eklerken normal aşırı büyüme büyüme paterninin nihai sonucunu görüyorsunuz.

Açık olmak gerekirse, bunların hiçbiri bir dil garantisi değildir. CPython bunu böyle uygular. Python dil spesifikasyonu genel olarak belirli büyüme örüntüleri ile ilgisizdir list(amortismanları O(1) appendve sonları garanti popetmenin yanı sıra). Yorumlarda belirtildiği gibi, spesifik uygulama 3.9'da tekrar değişir; etkilemezken [*a], eskiden " tuplemünferit eşyaların geçici olarak inşa edilmesi ve daha sonra " extendile tuplebirden fazla uygulama haline geldiği diğer durumları etkileyebilir LIST_APPEND.

Ne olduğunu tam olarak gösteren resim , diğer cevaplar ve yorumlara dayanarak (özellikle ShadowRanger'ın cevabı , bunun neden böyle yapıldığını açıklar ).

BUILD_LIST_UNPACKKullanılan şovların sökülmesi :

>>> import dis
>>> dis.dis('[*a]')
  1           0 LOAD_NAME                0 (a)
              2 BUILD_LIST_UNPACK        1
              4 RETURN_VALUE

Yani işlenir oldu içindeceval.c boş bir liste oluşturur ve (bunu uzandığı, a):

        case TARGET(BUILD_LIST_UNPACK): {
            ...
            PyObject *sum = PyList_New(0);
              ...
                none_val = _PyList_Extend((PyListObject *)sum, PEEK(i));

_PyList_Extend kullanır list_extend :

_PyList_Extend(PyListObject *self, PyObject *iterable)
{
    return list_extend(self, iterable);
}

Hangi çağrılar list_resizeölçülerinin toplamından ile :

list_extend(PyListObject *self, PyObject *iterable)
    ...
        n = PySequence_Fast_GET_SIZE(iterable);
        ...
        m = Py_SIZE(self);
        ...
        if (list_resize(self, m + n) < 0) {

Ve bu genel olarak şu şekilde konumlanır :

list_resize(PyListObject *self, Py_ssize_t newsize)
{
  ...
    new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6);

Hadi kontrol edelim. Beklenen nokta sayısını yukarıdaki formülle hesaplayın ve beklenen bayt boyutunu 8 ile çarparak hesaplayın (burada 64 bit Python kullanıyorum) ve boş bir listenin bayt boyutunu (yani, bir liste nesnesinin sabit yükü) :

from sys import getsizeof
for n in range(13):
    a = [None] * n
    expected_spots = n + (n >> 3) + (3 if n < 9 else 6)
    expected_bytesize = getsizeof([]) + expected_spots * 8
    real_bytesize = getsizeof([*a])
    print(n,
          expected_bytesize,
          real_bytesize,
          real_bytesize == expected_bytesize)

Çıktı:

0 80 56 False
1 88 88 True
2 96 96 True
3 104 104 True
4 112 112 True
5 120 120 True
6 128 128 True
7 136 136 True
8 152 152 True
9 184 184 True
10 192 192 True
11 200 200 True
12 208 208 True

Hariç Maçlar n = 0hangi list_extendaslında kısayolları bu maçları da öyle aslında:

        if (n == 0) {
            ...
            Py_RETURN_NONE;
        }
        ...
        if (list_resize(self, m + n) < 0) {

Bunlar CPython yorumlayıcısının uygulama ayrıntıları olacaktır ve bu nedenle diğer tercümanlar arasında tutarlı olmayabilir.

Bununla birlikte, anlama ve list(a)davranışların buraya nereden geldiğini görebilirsiniz:

https://github.com/python/cpython/blob/master/Objects/listobject.c#L36

Özellikle anlama için:

 * The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
...

new_allocated = (size_t)newsize + (newsize >> 3) + (newsize < 9 ? 3 : 6);

Bu hatların hemen altında, list_preallocate_exactarama yaparken kullanılanlar vardır list(a).