İki özdeş listenin neden farklı bellek alanı var?

İki liste oluşturdum l1ve l2her biri farklı bir oluşturma yöntemiyle:

import sys

l1 = [None] * 10
l2 = [None for _ in range(10)]

print('Size of l1 =', sys.getsizeof(l1))
print('Size of l2 =', sys.getsizeof(l2))

Ama çıktı beni şaşırttı:

Size of l1 = 144
Size of l2 = 192

Liste kavrayışı ile oluşturulan liste bellekte daha büyüktür, ancak iki liste Python'da aynıdır.

Neden? Bu bazı CPython içsel bir şey mi, yoksa başka bir açıklama mı?

Yazarken [None] * 10, Python tam olarak 10 nesneden oluşan bir listeye ihtiyacı olacağını bilir, bu yüzden tam olarak bunu tahsis eder.

Bir liste kavrayışı kullandığınızda, Python ne kadarına ihtiyaç duyacağını bilmiyor. Böylece elementler eklendikçe liste yavaş yavaş büyür. Her yeniden tahsis için hemen ihtiyaç duyulandan daha fazla yer ayırır, böylece her eleman için yeniden tahsis etmek zorunda kalmaz. Sonuçta ortaya çıkan listenin gerekenden biraz daha büyük olması muhtemeldir.

Benzer boyutlarda oluşturulan listeleri karşılaştırırken bu davranışı görebilirsiniz:

>>> sys.getsizeof([None]*15)
184
>>> sys.getsizeof([None]*16)
192
>>> sys.getsizeof([None for _ in range(15)])
192
>>> sys.getsizeof([None for _ in range(16)])
192
>>> sys.getsizeof([None for _ in range(17)])
264

İlk yöntemin sadece gerekli olanı tahsis ettiğini, ikincisinin ise periyodik olarak büyüdüğünü görebilirsiniz. Bu örnekte, 16 öğe için yeterli ayırma yapar ve 17. öğeye ulaştığında yeniden ayrılması gerekiyordu.

Bu soruda belirtildiği gibi , liste kavraması list.appendkaputun altında kullanır , bu nedenle aşırı konumlandırılan liste yeniden boyutlandırma yöntemini çağırır.

Bunu kendinize göstermek için aslında disdissasembler'ı kullanabilirsiniz :

>>> code = compile('[x for x in iterable]', '', 'eval')
>>> import dis
>>> dis.dis(code)
  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x10560b810, file "", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_NAME                0 (iterable)
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x10560b810, file "", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 8 (to 14)
              6 STORE_FAST               1 (x)
              8 LOAD_FAST                1 (x)
             10 LIST_APPEND              2
             12 JUMP_ABSOLUTE            4
        >>   14 RETURN_VALUE
>>>

Kod nesnesinin LIST_APPENDsökülmesinde opcode dikkat edin <listcomp>. Gönderen docs :

LIST_APPEND: (i)

Aramalar list.append(TOS[-i], TOS). Liste kavrayışlarını uygulamak için kullanılır.

Şimdi, liste tekrarlama işlemi için aşağıdakileri göz önüne alırsak neler olup bittiğine dair bir ipucumuz var:

>>> import sys
>>> sys.getsizeof([])
64
>>> 8*10
80
>>> 64 + 80
144
>>> sys.getsizeof([None]*10)
144

Yani, boyutu tam olarak tahsis edebiliyor gibi görünüyor . Kaynak koduna baktığımızda, bunun tam olarak ne olduğunu görüyoruz:

static PyObject *
list_repeat(PyListObject *a, Py_ssize_t n)
{
    Py_ssize_t i, j;
    Py_ssize_t size;
    PyListObject *np;
    PyObject **p, **items;
    PyObject *elem;
    if (n < 0)
        n = 0;
    if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)
        return PyErr_NoMemory();
    size = Py_SIZE(a) * n;
    if (size == 0)
        return PyList_New(0);
    np = (PyListObject *) PyList_New(size);

Yani, burada: size = Py_SIZE(a) * n;. İşlevlerin geri kalanı diziyi doldurur.

Hiçbiri bir bellek bloğu değildir, ancak önceden belirlenmiş bir boyut değildir. Buna ek olarak, bir dizi içinde dizi öğeleri arasında fazladan boşluk vardır. Bunu çalıştırarak kendiniz görebilirsiniz:

for ele in l2:
    print(sys.getsizeof(ele))

>>>>16
16
16
16
16
16
16
16
16
16

Hangi toplamı l2 değil, daha azdır.

print(sys.getsizeof([None]))
72

Ve bu, boyutunun onda birinden çok daha büyük l1.

Sayılarınız hem işletim sisteminizin ayrıntılarına hem de işletim sisteminizdeki geçerli bellek kullanımının ayrıntılarına bağlı olarak değişmelidir. [Hiçbiri] boyutu hiçbir zaman değişkenin saklanacağı bitişik bellekten daha büyük olamaz ve değişkenin daha sonra dinamik olarak daha büyük olarak ayrılması durumunda değişkenin taşınması gerekebilir.