Pertanyaan Perbedaan antara append vs memperpanjang metode daftar dengan Python


Apa perbedaan antara metode daftar append() dan extend()?


2682
2017-10-31 05:55


asal


Jawaban:


append: Menambahkan objek di bagian akhir.

x = [1, 2, 3]
x.append([4, 5])
print (x)

Memberi anda: [1, 2, 3, [4, 5]]


extend: Memperpanjang daftar dengan menambahkan elemen dari iterable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

Memberi anda: [1, 2, 3, 4, 5]


4073
2017-10-31 06:02



append menambahkan elemen ke daftar, dan extend gabungkan daftar pertama dengan daftar lain (atau daftar lain, belum tentu daftar.)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

Dari Selami Python.


525
2017-10-31 05:57



Apa perbedaan antara metode daftar yang ditambahkan dan diperluas?

  • append menambahkan argumennya sebagai elemen tunggal ke akhir daftar. Panjang daftar itu sendiri akan bertambah satu.
  • extend mengulangi argumennya menambahkan setiap elemen ke daftar, memperluas daftar. Panjang daftar akan meningkat namun banyak elemen dalam argumen iterable.

append

Itu list.append metode menambahkan objek ke akhir daftar.

my_list.append(object) 

Apa pun objeknya, apakah nomor, string, daftar lain, atau sesuatu yang lain, itu akan ditambahkan ke akhir my_list sebagai satu entri dalam daftar.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Jadi perlu diingat bahwa daftar adalah objek. Jika Anda menambahkan daftar lain ke daftar, daftar pertama akan menjadi objek tunggal di akhir daftar (yang mungkin bukan yang Anda inginkan):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item on end of list.

extend

Itu list.extend metode memperluas daftar dengan menambahkan elemen dari sebuah iterable:

my_list.extend(iterable)

Jadi dengan memperpanjang, setiap elemen dari iterable akan ditambahkan ke daftar. Sebagai contoh:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Perlu diingat bahwa string adalah iterable, jadi jika Anda memperpanjang daftar dengan string, Anda akan menambahkan setiap karakter saat Anda melakukan iterasi melalui string (yang mungkin bukan yang Anda inginkan):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Kelebihan Operator, __add__, (+) dan __iadd__ (+=)

Kedua + dan += operator didefinisikan untuk list. Mereka semantik mirip dengan memperpanjang.

my_list + another_list membuat daftar ketiga di memori, sehingga Anda dapat mengembalikan hasilnya, tetapi itu mengharuskan iterable kedua menjadi daftar.

my_list += another_list memodifikasi daftar di tempat (itu aku s operator di tempat, dan daftar adalah objek yang bisa berubah, seperti yang telah kita lihat) sehingga tidak membuat daftar baru. Ini juga berfungsi seperti memperpanjang, bahwa iterable kedua dapat berupa jenis iterable.

Jangan bingung - my_list = my_list + another_list tidak setara dengan += - Ini memberi Anda daftar baru yang ditugaskan ke my_list.

Kompleksitas waktu

Tambahkan telah kompleksitas waktu yang konstan, O (1).

Memperpanjang memiliki kompleksitas waktu, O (k).

Iterasi melalui beberapa panggilan ke append menambah kompleksitas, membuatnya setara dengan perpanjangan, dan karena iterasi perpanjangan diimplementasikan dalam C, itu akan selalu lebih cepat jika Anda ingin menambahkan item yang berurutan dari iterable ke daftar.

Kinerja

Anda mungkin bertanya-tanya apa yang lebih berkinerja, karena append dapat digunakan untuk mencapai hasil yang sama sebagai perpanjangan. Fungsi-fungsi berikut melakukan hal yang sama:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Jadi mari kita beri mereka waktu:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Mengatasi komentar tentang pengaturan waktu

Seorang komentator berkata:

Jawaban sempurna, saya hanya melewatkan waktu membandingkan hanya menambahkan satu elemen

Lakukan hal semantik yang benar. Jika Anda ingin menambahkan semua elemen dalam iterable, gunakan extend. Jika Anda hanya menambahkan satu elemen, gunakan append.

Ok, jadi mari kita buat eksperimen untuk melihat bagaimana ini berjalan tepat waktu:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

Dan kami melihat bahwa keluar dari cara kami untuk membuat iterable hanya untuk menggunakan perpanjangan adalah (kecil) buang waktu:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Kami belajar dari hal ini bahwa tidak ada manfaat dari penggunaan extend ketika kita hanya punya satu elemen untuk ditambahkan.

Juga, pengaturan waktu ini tidak begitu penting. Saya hanya menunjukkan kepada mereka untuk menyatakan bahwa, dalam Python, melakukan hal semantik yang benar adalah melakukan hal-hal Kanan Cara.

Bisa dibayangkan bahwa Anda mungkin menguji timing pada dua operasi yang sebanding dan mendapatkan hasil yang ambigu atau terbalik. Fokus saja pada melakukan hal semantik yang benar.

Kesimpulan

Kami melihatnya extend secara semantik lebih jelas, dan dapat berjalan lebih cepat daripada append, ketika Anda ingin menambahkan setiap elemen dalam sebuah iterable ke daftar. 

Jika Anda hanya memiliki satu elemen (tidak dalam iterable) untuk ditambahkan ke daftar, gunakan append.


265
2018-01-23 22:44



append menambahkan satu elemen. extend menambahkan daftar elemen.

Perhatikan bahwa jika Anda meneruskan daftar untuk ditambahkan, itu masih menambahkan satu elemen:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

92
2017-10-31 05:57



Dua cuplikan berikut secara semantis setara:

for item in iterator:
    a_list.append(item)

dan

a_list.extend(iterator)

Yang terakhir mungkin lebih cepat karena loop diimplementasikan dalam C.


42
2017-08-20 21:11



Anda dapat menggunakan "+" untuk kembali memperpanjang, alih-alih memanjang di tempat.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Demikian pula += karena dalam perilaku tempat, tetapi dengan sedikit perbedaan dari append & extend. Salah satu perbedaan terbesar += dari append dan extend adalah ketika digunakan dalam lingkup fungsi, lihat posting blog ini.


29
2017-08-26 11:21



Metode append () menambahkan satu item ke bagian akhir daftar.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Metode extend () mengambil satu argumen, daftar, dan menambahkan masing-masing item argumen ke daftar awal. (Daftar diimplementasikan sebagai kelas. "Membuat" daftar adalah benar-benar instantiating kelas. Dengan demikian, daftar memiliki metode yang beroperasi di atasnya.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Dari Dive Into Python.


29
2017-10-31 13:12



 Tambahkan vs Perpanjang

enter image description here

Dengan menambahkan, Anda dapat menambahkan satu elemen yang akan memperpanjang daftar:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

Jika Anda ingin memperpanjang lebih dari satu elemen yang harus Anda gunakan, karena Anda hanya dapat menambahkan satu elment atau satu daftar elemen:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Sehingga Anda mendapatkan daftar bertingkat

Sebaliknya dengan memperpanjang Anda dapat memperpanjang satu elemen seperti ini

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Atau, berbeda dari menambahkan, memperpanjang lebih banyak elemen dalam satu waktu tanpa menyusun daftar ke dalam yang asli (itulah alasan dari nama memperpanjang)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

 Menambahkan satu elemen dengan kedua metode

enter image description here

 tambahkan 1 elemen

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

 memperpanjang satu elemen

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]

 Menambahkan lebih banyak elemen ... dengan hasil yang berbeda

Jika Anda menggunakan tambahan untuk lebih dari satu elemen, Anda harus melewati daftar elemen sebagai argumen dan Anda akan mendapatkan daftar NESTED!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

Dengan meluas, sebagai gantinya, Anda menyampaikan daftar sebagai argumen, tetapi Anda akan memperoleh daftar dengan elemen baru yang tidak disarangkan di yang lama.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Jadi, dengan lebih banyak elemen, Anda akan menggunakan perpanjangan untuk mendapatkan daftar dengan lebih banyak item. Anda akan menggunakan append, untuk menambahkan tidak lebih banyak elemen ke daftar, tetapi satu elemen yang merupakan daftar bersarang seperti yang dapat Anda lihat dengan jelas dalam output kode.

enter image description here

enter image description here


17
2017-10-18 07:33



append(object) - Memperbarui daftar dengan menambahkan objek ke daftar.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - Intinya menggabungkan dua daftar.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

16
2018-05-12 19:51



extend() dapat digunakan dengan argumen iterator. Berikut ini contohnya. Anda ingin membuat daftar dari daftar daftar dengan cara ini:

Dari

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

kamu ingin

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Anda dapat menggunakan itertools.chain.from_iterable() untuk melakukannya. Output metode ini adalah iterator. Implementasinya setara dengan

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Kembali ke contoh kita, bisa kita lakukan

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

dan dapatkan daftar yang diinginkan.

Beginilah caranya extend() dapat digunakan dengan argumen iterator:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

15
2018-05-12 18:21



Ini setara dengan append dan extend menggunakan + operator:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

13
2017-07-08 12:42