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

append: Menambahkan objek di 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]

appendmenambahkan elemen ke daftar, dan extendmenyatukan daftar pertama dengan daftar lain (atau iterable 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.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

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

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

Apa perbedaan antara metode daftar yang ditambahkan dan diperluas?

• appendmenambahkan argumennya sebagai elemen tunggal pada akhir daftar. Panjang daftar itu sendiri akan bertambah satu.
• extenditerates atas argumennya menambahkan setiap elemen ke daftar, memperluas daftar. Panjang daftar akan bertambah dengan banyaknya elemen dalam argumen iterable.

append

The list.appendMetode menambahkan objek ke akhir daftar.

my_list.append(object) 

Apa pun objeknya, apakah sebuah angka, string, daftar lain, atau sesuatu yang lain, itu ditambahkan ke bagian akhir my_listsebagai satu entri pada 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 at the end of the list.

extend

The list.extendMetode meluas daftar dengan menambahkan unsur-unsur dari iterable:

my_list.extend(iterable)

Jadi dengan perluasan, setiap elemen 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]

Ingatlah bahwa string adalah iterable, jadi jika Anda memperpanjang daftar dengan string, Anda akan menambahkan setiap karakter saat Anda mengulangi string tersebut (yang mungkin bukan yang Anda inginkan):

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

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

Kedua +dan +=operator yang ditetapkan untuk list. Mereka secara semantik mirip dengan memperpanjang.

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

my_list += another_listmemodifikasi daftar di tempat (ini adalah operator di tempat, dan daftar adalah objek yang bisa berubah, seperti yang telah kita lihat) sehingga tidak membuat daftar baru. Ini juga berfungsi seperti extended, dalam iterable kedua dapat berupa apapun yang dapat diubah.

Jangan bingung - my_list = my_list + another_listtidak setara dengan+= - itu memberi Anda daftar baru yang ditugaskan ke my_list.

Kompleksitas Waktu

Tambah memiliki kompleksitas waktu yang konstan , O (1).

Memperpanjang memiliki kompleksitas waktu, O (k).

Iterasi melalui beberapa panggilan untuk appendmenambah kompleksitas, menjadikannya setara dengan perluasan, dan karena iterasi ekstensi diimplementasikan dalam C, itu akan selalu lebih cepat jika Anda berniat untuk menambahkan item yang berurutan dari yang dapat diubah ke daftar.

Performa

Anda mungkin bertanya-tanya apa yang lebih performan, karena append dapat digunakan untuk mencapai hasil yang sama dengan memperpanjang. 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 mengatur waktu mereka:

import timeit

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

Mengatasi komentar pada waktu

Seorang komentator berkata:

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

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

Oke, jadi mari kita buat eksperimen untuk melihat bagaimana ini bekerja 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 kita melihat bahwa keluar dari cara kita untuk membuat iterable hanya menggunakan perpanjangan adalah buang-buang waktu (kecil):

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

Kami belajar dari ini bahwa tidak ada yang diperoleh dari penggunaan extendsaat kami hanya memiliki satu elemen untuk ditambahkan.

Juga, timing ini tidak begitu penting. Saya hanya menunjukkan kepada mereka untuk menegaskan bahwa, dengan Python, melakukan hal yang benar secara semantis adalah melakukan hal-hal dengan Right Way ™.

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

Kesimpulan

Kami melihat bahwa extendsecara semantik lebih jelas, dan itu dapat berjalan lebih cepat daripada append, ketika Anda bermaksud untuk menambahkan setiap elemen dalam iterable ke daftar.

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

append menambahkan satu elemen. extendmenambahkan 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]]

Tambahkan vs Perpanjang

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

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

Jika Anda ingin memperluas lebih dari satu elemen, Anda harus menggunakan extended, karena Anda hanya dapat menambahkan satu elemen atau satu daftar elemen:

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

Sehingga Anda mendapatkan daftar bersarang

Alih-alih dengan extended, Anda dapat memperluas satu elemen seperti ini

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

Atau, berbeda, dari append, perluas lebih banyak elemen dalam satu waktu tanpa menyarangkan daftar ke yang asli (itulah alasan perluasan nama)

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

Menambahkan satu elemen dengan kedua metode

Baik append dan extended dapat menambahkan satu elemen ke akhir daftar, meskipun append lebih sederhana.

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]

Menambahkan lebih banyak elemen ... dengan hasil yang berbeda

Jika Anda menggunakan append 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]]

Sebaliknya dengan extended, Anda meneruskan daftar sebagai argumen, tetapi Anda akan mendapatkan daftar dengan elemen baru yang tidak bersarang di yang lama.

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

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

Dua cuplikan berikut ini setara secara semantik:

for item in iterator:
    a_list.append(item)

dan

a_list.extend(iterator)

Yang terakhir mungkin lebih cepat karena loop diimplementasikan dalam C.

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

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

The extend()Metode mengambil satu argumen, daftar, dan menambahkan masing-masing item dari argumen untuk daftar asli. (Daftar diimplementasikan sebagai kelas. "Membuat" daftar benar-benar instantiating kelas. Dengan demikian, daftar memiliki metode yang beroperasi di dalamnya.)

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 .

Anda dapat menggunakan "+" untuk mengembalikan perluasan, alih-alih memperluas 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 +=untuk perilaku di tempat, tetapi dengan sedikit perbedaan dari append& extend. Salah satu perbedaan terbesar +=dari appenddan extendketika digunakan dalam lingkup fungsi, lihat posting blog ini .

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) - Pada dasarnya 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]

extend()dapat digunakan dengan argumen iterator. Berikut ini sebuah contoh. 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 menggunakannya 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 orang yang dicari.

Inilah cara yang setara 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]

Ini setara dengan appenddan extendmenggunakan +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]]

append () : Pada dasarnya digunakan dengan Python untuk menambahkan satu elemen.

Contoh 1:

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

Contoh 2:

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

extended () : Where extended (), digunakan untuk menggabungkan dua daftar atau menyisipkan beberapa elemen dalam satu daftar.

Contoh 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Contoh 2:

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

Suatu hal menarik yang telah diisyaratkan, tetapi tidak dijelaskan, adalah bahwa perpanjangan lebih cepat daripada menambahkan. Untuk setiap loop yang telah ditambahkan di dalamnya harus dianggap diganti oleh list.extend (diproses_elemen).

Ingatlah bahwa menambahkan elemen baru dapat mengakibatkan realloaction dari seluruh daftar ke lokasi yang lebih baik dalam memori. Jika ini dilakukan beberapa kali karena kami menambahkan 1 elemen pada satu waktu, kinerja keseluruhan akan terganggu. Dalam pengertian ini, list.extend dianalogikan dengan "" .join (stringlist).

Tambah menambahkan seluruh data sekaligus. Seluruh data akan ditambahkan ke indeks yang baru dibuat. Di samping itu,extend ,, seperti namanya, memperluas array saat ini.

Sebagai contoh

list1 = [123, 456, 678]
list2 = [111, 222]

Dengan appendkita dapatkan:

result = [123, 456, 678, [111, 222]]

Saat extendkita dapatkan:

result = [123, 456, 678, 111, 222]

Kamus bahasa Inggris mendefinisikan kata-kata appenddan extendsebagai:

tambahkan : tambahkan (sesuatu) ke akhir dokumen tertulis.
memperpanjang : membuat lebih besar. Memperbesar atau memperluas

Dengan pengetahuan itu, sekarang mari kita mengerti

1) Perbedaan antara appenddanextend

append:

• Menambahkan objek Python apa adanya ke akhir daftar (yaitu sebagai elemen terakhir dalam daftar).
• Daftar yang dihasilkan dapat bersarang dan mengandung elemen heterogen (yaitu daftar, string, tuple, kamus, set, dll.)

extend:

• Terima setiap iterable sebagai argumennya dan buat daftar lebih besar .
• Daftar yang dihasilkan selalu daftar satu dimensi (yaitu tidak ada sarang) dan mungkin berisi elemen heterogen di dalamnya (misalnya karakter, bilangan bulat, float) sebagai hasil penerapan list(iterable).

2) Kesamaan antara appenddanextend

• Keduanya mengambil satu argumen.
• Keduanya memodifikasi daftar di tempat .
• Akibatnya, keduanya kembali None.

Contoh

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

Saya harap saya bisa membuat suplemen yang bermanfaat untuk pertanyaan ini. Jika daftar Anda menyimpan objek jenis tertentu, misalnya Info, ini adalah situasi yang extendmetode tidak cocok: Dalam satu forlingkaran dan dan menghasilkan Infoobjek setiap kali dan menggunakan extenduntuk menyimpannya ke dalam daftar Anda, itu akan gagal. Pengecualiannya adalah seperti di bawah ini:

TypeError: Objek 'Info' tidak dapat diubah

Tetapi jika Anda menggunakan appendmetode ini, hasilnya OK. Karena setiap kali menggunakan extendmetode ini, ia akan selalu memperlakukannya sebagai daftar atau jenis koleksi lainnya, beralih, dan letakkan setelah daftar sebelumnya. Objek tertentu tidak dapat diulang, jelas.

Untuk membedakannya secara intuitif

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Ini seperti l1mereproduksi tubuh di dalam tubuhnya (bersarang).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

Seperti dua orang yang terpisah menikah dan membangun keluarga yang bersatu.

Selain itu saya membuat cheatsheet lengkap dari semua metode daftar untuk referensi Anda.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

extend(L)memperpanjang daftar dengan menambahkan semua item dalam daftar yang diberikan L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

append"memperpanjang" daftar (di tempat) dengan hanya satu item , objek tunggal berlalu (sebagai argumen).

extend"extends" daftar (di tempat) oleh item sebanyak objek dilewati (sebagai argumen) mengandung.

Ini mungkin sedikit membingungkan untuk strobjek.

1. Jika Anda melewatkan string sebagai argumen: appendakan menambahkan item string tunggal di akhir tetapi extend akan menambahkan "tunggal" 'str' sebanyak panjang string itu.
2. Jika Anda meneruskan daftar string sebagai argumen: appendmasih akan menambahkan item 'daftar' tunggal di akhir dan extendakan menambahkan item 'daftar' sebanyak panjang daftar yang diteruskan.

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

menghasilkan:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Menambahkan dan memperluas adalah salah satu mekanisme ekstensibilitas dalam python.

Tambah: Menambahkan elemen ke akhir daftar.

my_list = [1,2,3,4]

Untuk menambahkan elemen baru ke daftar, kita dapat menggunakan metode append dengan cara berikut.

my_list.append(5)

Lokasi default yang akan ditambahkan elemen baru selalu di posisi (panjang + 1).

Sisipan: Metode penyisipan digunakan untuk mengatasi batasan append. Dengan menyisipkan, kita dapat secara eksplisit menentukan posisi persis yang kita inginkan untuk memasukkan elemen baru kita.

Deskriptor metode penyisipan (indeks, objek). Dibutuhkan dua argumen, pertama adalah indeks yang ingin kita masukkan elemen kita dan kedua elemen itu sendiri.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Extend: Ini sangat berguna ketika kita ingin menggabungkan dua atau lebih daftar menjadi satu daftar. Tanpa memperpanjang, jika kita ingin bergabung dengan dua daftar, objek yang dihasilkan akan berisi daftar daftar.

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

Jika kita mencoba mengakses elemen di pos 2, kita mendapatkan daftar ([3]), bukan elemen. Untuk bergabung dengan dua daftar, kita harus menggunakan append.

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

Untuk bergabung dengan banyak daftar

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]