Apa yang menyebabkan [* a] secara keseluruhan?

Tampaknya list(a)tidak secara keseluruhan, [x for x in a]keseluruhan di beberapa titik, dan [*a]keseluruhan sepanjang waktu ?

Berikut adalah ukuran n dari 0 hingga 12 dan ukuran yang dihasilkan dalam byte untuk tiga metode:

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

Dihitung seperti ini, dapat direproduksi di repl.it , menggunakan 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]))

Jadi: Bagaimana cara kerjanya? Bagaimana secara [*a]keseluruhan? Sebenarnya, mekanisme apa yang digunakannya untuk membuat daftar hasil dari input yang diberikan? Apakah itu menggunakan iterator adan menggunakan sesuatu seperti list.append? Di mana kode sumbernya?

( Colab dengan data dan kode yang menghasilkan gambar.)

Memperbesar menjadi lebih kecil n:

Perkecil hingga lebih besar n:

[*a] secara internal melakukan C yang setara dengan :

1. Buat yang baru, kosongkan list
2. Panggilan newlist.extend(a)
3. Pengembalian list.

Jadi, jika Anda memperluas tes Anda ke:

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

Cobalah online!

Anda akan melihat hasilnya getsizeof([*a])dan l = []; l.extend(a); getsizeof(l)sama.

Ini biasanya hal yang benar untuk dilakukan; Ketika extendAnda biasanya berharap untuk menambahkan lebih banyak nanti, dan juga untuk pembongkaran umum, diasumsikan bahwa banyak hal akan ditambahkan satu demi satu. [*a]bukan kasus normal; Python mengasumsikan ada beberapa item atau iterables yang ditambahkan ke list( [*a, b, c, *d]), jadi keseluruhan lokasi menyimpan pekerjaan dalam kasus umum.

Sebaliknya, yang listdikonstruksi dari satu, yang dapat diubah (dengan list()) tidak boleh tumbuh atau menyusut selama penggunaan, dan keseluruhan penempatan prematur sampai terbukti sebaliknya; Python baru-baru ini memperbaiki bug yang membuat konstruktor secara keseluruhan bahkan untuk input dengan ukuran yang diketahui .

Adapun listpemahaman, mereka secara efektif setara dengan appends berulang , sehingga Anda melihat hasil akhir dari pola pertumbuhan keseluruhan penempatan normal saat menambahkan elemen pada suatu waktu.

Agar jelas, semua ini bukan jaminan bahasa. Hanya bagaimana CPython mengimplementasikannya. Spesifikasi bahasa Python pada umumnya tidak peduli dengan pola pertumbuhan spesifik list(selain menjamin amortisasi O(1) appenddan pops dari akhir). Seperti disebutkan dalam komentar, implementasi spesifik berubah lagi di 3,9; sementara itu tidak akan mempengaruhi [*a], itu bisa mempengaruhi kasus-kasus lain di mana apa yang dulunya "membangun sementara tupleitem individual dan kemudian extenddengan tuple" sekarang menjadi beberapa aplikasi LIST_APPEND, yang dapat berubah ketika keseluruhan lokasi terjadi dan angka apa yang masuk ke dalam perhitungan.

Gambaran lengkap tentang apa yang terjadi, membangun jawaban dan komentar lain (terutama jawaban ShadowRanger , yang juga menjelaskan mengapa itu dilakukan seperti itu).

Membongkar acara yang BUILD_LIST_UNPACKdigunakan:

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

Itu ditangani diceval.c , yang membangun daftar kosong dan meluas (dengan a):

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

_PyList_Extend menggunakan list_extend :

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

Yang memanggil list_resizedengan jumlah ukuran :

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

Dan itu secara keseluruhan menempatkan sebagai berikut:

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

Mari kita periksa. Hitung jumlah tempat yang diharapkan dengan rumus di atas, dan hitung ukuran byte yang diharapkan dengan mengalikannya dengan 8 (karena saya menggunakan Python 64-bit di sini) dan menambahkan ukuran byte daftar kosong (yaitu, overhead konstan objek daftar) :

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)

Keluaran:

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

Cocok kecuali untuk n = 0, yang list_extendsebenarnya pintasan , jadi benar-benar cocok juga:

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

Ini akan menjadi detail implementasi dari juru bahasa CPython, dan karenanya mungkin tidak konsisten antar penerjemah lain.

Yang mengatakan, Anda bisa melihat di mana pemahaman dan list(a)perilaku muncul di sini:

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

Khusus untuk pemahaman:

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

Tepat di bawah garis itu, ada list_preallocate_exactyang digunakan saat menelepon list(a).