Cosa causa la sovrallocazione di [* a]?

Apparentemente list(a)non sovrallocare, [x for x in a]sovrallocare in alcuni punti e [*a]sovrallocare continuamente ?

Ecco le dimensioni n da 0 a 12 e le dimensioni risultanti in byte per i tre metodi:

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

Calcolato in questo modo, riproducibile su repl.it , usando Python 3. 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]))

Quindi: come funziona? Come si [*a]sovrallocano? In realtà, quale meccanismo utilizza per creare l'elenco dei risultati dall'input specificato? Usa un iteratore sopra ae usa qualcosa di simile list.append? Dov'è il codice sorgente?

( Colab con dati e codice che ha prodotto le immagini.)

Zoom su n più piccolo:

Zoom indietro su n più grande:

[*a] sta facendo internamente l'equivalente C di :

1. Crea un nuovo, vuoto list
2. Chiamata newlist.extend(a)
3. Ritorni list.

Quindi se estendi il test a:

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))

Provalo online!

vedrai i risultati per getsizeof([*a])e l = []; l.extend(a); getsizeof(l)sono gli stessi.

Questa è di solito la cosa giusta da fare; quando extendin genere ti aspetti di aggiungerne altri in un secondo momento, e in modo simile per il disimballaggio generalizzato, si presume che verranno aggiunte più cose una dopo l'altra. [*a]non è il caso normale; Python presuppone che ci siano più elementi o iterabili aggiunti a list( [*a, b, c, *d]), quindi la sovrallocazione salva il lavoro nel caso comune.

Al contrario, un listcostruito da un unico, presumibile iterabile (con list()) potrebbe non crescere o ridursi durante l'uso e la sovrallocazione è prematura fino a prova contraria; Python ha recentemente corretto un bug che rendeva il costruttore sovrallocato anche per input con dimensioni note .

Per quanto riguarda le listcomprensioni, sono effettivamente equivalenti a appends ripetute , quindi stai vedendo il risultato finale del normale modello di crescita di sovrallocazione quando aggiungi un elemento alla volta.

Per essere chiari, nulla di tutto ciò è una garanzia linguistica. È proprio come CPython lo implementa. Le specifiche del linguaggio Python sono generalmente indifferenti a specifici modelli di crescita in list(oltre a garantire la O(1) appends e la pops ammortizzate dalla fine). Come notato nei commenti, l'implementazione specifica cambia di nuovo in 3.9; mentre non influirà [*a], potrebbe interessare altri casi in cui quello che era "costruire un temporaneo tupledi singoli elementi e poi extendcon tuple" diventa ora più applicazioni di LIST_APPEND, che possono cambiare quando si verifica la sovrallocazione e quali numeri vanno nel calcolo.

Quadro completo di ciò che accade, basandosi sulle altre risposte e commenti (in particolare la risposta di ShadowRanger , che spiega anche perché è stato fatto così).

Disassemblaggio degli spettacoli che BUILD_LIST_UNPACKvengono utilizzati:

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

Questo è gestito inceval.c , che costruisce un elenco vuoto e la estende (con a):

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

_PyList_Extend utilizza list_extend :

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

Che chiama list_resizecon la somma delle dimensioni :

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

E questo si sovrascrive come segue:

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

Controlliamo quello. Calcola il numero atteso di punti con la formula sopra, e calcola la dimensione in byte prevista moltiplicandola per 8 (dato che sto usando Python a 64 bit qui) e aggiungendo una dimensione in byte di un elenco vuoto (ovvero, un overhead costante di un oggetto elenco) :

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)

Produzione:

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

Partite ad eccezione di n = 0, che in list_extendrealtà scorciatoie , quindi in realtà anche quelle corrispondenti:

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

Questi saranno i dettagli di implementazione dell'interprete CPython e quindi potrebbero non essere coerenti con altri interpreti.

Detto questo, puoi vedere dove list(a)arrivano la comprensione e i comportamenti:

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

In particolare per la comprensione:

 * 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);

Appena sotto quelle linee, c'è list_preallocate_exactquale viene usato quando si chiama list(a).