Apa perbedaan antara metode daftar Python yang ditambahkan dan diperluas?


Jawaban:


5255

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]


122
Apa perbedaan antara extenddan hanya menggunakan operator tambahan - dalam contoh di atas x = x + [4, 5],?
Rohan

303
Sebenarnya ada perbedaan besar - x + [4, 5]memberi Anda daftar baru yang ditugaskan untuk x - x.extend()mengubah daftar asli. Saya menguraikan jawaban saya di sini di bawah ini.
Aaron Hall

@ AaronHall @Rohan tetapi sama dengan x += [4,5].
Astitva Srivastava

1
@AstitvaSrivastava Sebenarnya, saya pikir memperpanjang lebih cepat dalam hal bytecode
MilkyWay90

1
Kata kunci saat menggunakan appendadalah Object . Jika Anda mencoba menggunakan extenddan memasukkan kamus , kamus akan menambahkan kunci , dan bukan keseluruhan hash ke akhir array.
Anthony

640

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']

490

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.


1
@ Harun Hall Satu komentar kecil dalam algoritma untuk penentuan waktu. "extended_one" dapat mengembalikan waktu "sedikit salah" karena pembuatan daftar juga terlibat. Mungkin yang lebih baik adalah membuat item sebagai variabel ( ex1 = 0dan ex2 = [0]) dan meneruskan variabel-variabel ini, jika Anda ingin lebih ketat.
ilias iliadis

19
Memang jawaban yang sempurna. Bagaimana dengan kinerja l1 += l2vs l1.extend(l2)?
Jean-Francois T.

6
@ Jean-FrancoisT .: l1 += l2dan l1.extend(l2)akhirnya menjalankan kode yang sama ( list_extendfungsi dalam listobject.c). Satu-satunya perbedaan adalah: 1. +=menugaskan kembali l1(untuk dirinya sendiri untuk lists, tetapi penugasan kembali mendukung tipe tidak berubah yang bukan objek yang sama setelah), yang menjadikannya ilegal jika l1sebenarnya merupakan atribut dari objek yang tidak dapat diubah; misalnya, t = ([],), t[0] += lstakan gagal, sementara t[0].extend(lst)akan bekerja. 2. l1 += l2menggunakan bytecode khusus, sementara l1.extend(l2)menggunakan metode pengiriman umum; ini membuat +=lebih cepat dari extend.
ShadowRanger

3
Fakta yang +=harus dipindahkan bukan l1berarti bahwa dalam beberapa kasus, pengiriman yang lambat dari extendsebagian atau seluruhnya dibuat untuk dengan tidak menetapkan kembali ke sisi kiri. Sebagai contoh, jika listatribut dari sebuah objek, self.l1 += l2dan self.l1.extend(l2)memiliki kinerja yang identik pada Python 3.6 saya instal, hanya karena operasi yang sebenarnya lebih seperti self.l1 = self.l1.__iadd__(l2), yang berarti harus melakukan yang cukup mahal STORE_ATTRyang self.l1.extend(l2)tidak harus.
ShadowRanger

2
Perbandingan sederhana dalam tes lokal: Untuk variabel lokal (jadi +=hanya menggunakan STORE_FAST, yang super murah), di mana nilai yang ditambahkan adalah yang sudah ada listdengan satu item di dalamnya, dengan operasi yang diulang 1000 kali, +=butuh sekitar 33 ns rata-rata , saat extendmengambil 78 ns, perbedaan 45 ns. Jika l1global (membutuhkan lebih mahal STORE_GLOBAL), perbedaannya menyempit menjadi 17 ns. Jika l1sebenarnya local.l1(membutuhkan lebih mahal STORE_ATTR), tidak ada perbedaan yang berarti antara +=dan extend(timing kira-kira identik; extendkadang-kadang menang).
ShadowRanger

121

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

62

Tambahkan vs Perpanjang

masukkan deskripsi gambar di sini

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

masukkan deskripsi gambar di sini

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.

masukkan deskripsi gambar di sini

masukkan deskripsi gambar di sini


61

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.


20
Perpanjangan ~ 4x lebih cepat pada mesin saya daripada menambahkan dalam satu lingkaran (16us vs 4us untuk 100 loop nol)
Alex L

6
extend()mungkin preallocates, sementara append()kemungkinan tidak.
Fisikawan Gila

@MadPhysicist: Demi kelengkapan, akan ada saat-saat di mana extend() tidak dapat melakukan realokasi secara masuk akal karena beberapa iterables tidak diterapkan __len__(), tetapi seperti Anda, saya akan terkejut jika tidak mencoba. Beberapa keuntungan kinerja juga berasal dari melakukan bagian iterasi dalam C murni alih-alih dalam Python, seperti yang ditunjukkan dalam jawaban Harun .
Soren Bjornstad

44

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 tidak dapat memperpanjang hanya dengan 6 karena itu tidak bisa diubah. Dan output kedua dalam contoh Anda salah. 'abc' ditambahkan sebagai satu elemen sejak Anda menyerahkannya extendsebagai daftar dengan satu elemen ['abc']: [1, 2, 3, 4, 5, 'abc']. Untuk membuat contoh output yang benar, mengubah baris abc ke: x.extend('abc'). Dan hapus x.extend(6)atau ubah ke x.extend([6]).
aneroid

37

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 .


Apakah menggunakan '+' untuk memperpanjang ekstensi berpengaruh pada kompleksitas waktu?
franklin

5
@ Franklin, lihat jawaban ini untuk detail: stackoverflow.com/a/28119966/2230844
denfromufa

1
Saya tidak melihat bagaimana ini menjawab pertanyaan
pppery

22

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]

20

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]

2
Jawaban ini tidak kontras dengan append dan oleh karena itu tidak menjawab pertanyaan
pppery

19

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

Kenapa tidak = +?! Lebih ringkas
denfromufa

16

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]

12

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


12

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]

8

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)

5

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.


4

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'},
                }

2

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]

0

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,

0

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]

2
Mengapa Anda menjawab pertanyaan yang sudah dijawab berkali-kali? Pertanyaan ini berumur 10 tahun ...
Mike - SMT
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.