Apa's perbedaan antara daftar metode append()
dan memperpanjang()
?
menambahkan
: Menambahkan objek pada akhir.
x = [1, 2, 3]
x.append([4, 5])
print (x)
memberikan anda: [1, 2, 3, [4, 5]]
memperpanjang
: Memperpanjang daftar dengan menambahkan unsur-unsur dari iterable.
x = [1, 2, 3]
x.extend([4, 5])
print (x)
memberikan anda: [1, 2, 3, 4, 5]
menambahkan
menambahkan sebuah elemen ke daftar, dan memperpanjang
merangkai pertama daftar dengan daftar lain (atau yang lain iterable, tidak perlu 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 daftar metode append dan memperpanjang?
menambahkan
menambahkan argumen sebagai elemen tunggal untuk akhir daftar. Panjang daftar itu sendiri akan meningkat per satu.memperpanjang
iterates atas argumen menambahkan masing-masing elemen untuk daftar, memperluas daftar. Panjang daftar akan meningkat namun banyak unsur-unsur yang berada di iterable argumen.menambahkan
Daftar.menambahkan
metode menambahkan objek ke akhir daftar.
my_list.append(object)
Apapun objek, apakah nomor, string, daftar lain, atau sesuatu yang lain, itu akan ditambahkan ke akhir dari my_list
sebagai satu entri pada daftar.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Jadi perlu diingat bahwa daftar ini adalah sebuah objek. Jika anda menambahkan daftar lain ke daftar, daftar pertama akan menjadi objek tunggal pada akhir dari list (yang mungkin tidak akan apa 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.
memperpanjang
Daftar.memperpanjang
metode memperpanjang daftar dengan menambahkan unsur-unsur dari sebuah iterable:
my_list.extend(iterable)
Jadi dengan memperpanjang, setiap elemen dari iterable akan ditambahkan ke daftar. Misalnya:
>>> 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 sebuah iterable, jadi jika anda memperpanjang daftar dengan string, you'll menambahkan karakter masing-masing seperti yang anda iterate atas string (yang mungkin tidak akan apa yang anda inginkan):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
__add__
(+
) dan __iadd__
(+=
)Kedua +
dan +=
operator yang didefinisikan untuk daftar
. Mereka semantik yang sama untuk memperpanjang.
my_list + another_list
menciptakan daftar ketiga dalam memori, sehingga anda dapat mengembalikan hasil itu, tapi hal ini membutuhkan bahwa kedua iterable menjadi daftar.
my_list += another_list
memodifikasi daftar di tempat (ini adalah ** di tempat operator, dan daftar benda-benda yang bisa berubah, seperti yang kita've melihat) sehingga tidak membuat daftar baru. Ia juga bekerja seperti memperpanjang, di yang kedua iterable dapat setiap jenis iterable.
Don't bingung - my_list = my_list + another_list
tidak sama dengan +=
- memberikan anda sebuah merek baru daftar ditugaskan untuk my_list.
Append telah konstan kompleksitas waktu, O(1).
Memperpanjang memiliki kompleksitas waktu O(k).
Iterasi melalui beberapa panggilan untuk menambahkan
menambah kompleksitas, sehingga setara dengan memperpanjang, dan sejak memperpanjang's iterasi diimplementasikan dalam C, itu akan selalu menjadi lebih cepat jika anda berniat untuk menambahkan item berturut-turut dari iterable ke daftar.
Anda mungkin bertanya-tanya apa yang lebih tampak, sejak append dapat digunakan untuk mencapai hasil yang sama seperti yang memperpanjang. Berikut fungsi-fungsi yang melakukan hal yang sama:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Jadi let's waktu mereka:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Commenter berkata:
jawaban yang Sempurna, aku hanya melewatkan waktu membandingkan menambahkan hanya satu elemen
Melakukan semantik hal yang benar. Jika anda ingin menambahkan semua elemen dalam sebuah iterable, gunakan memperpanjang
. Jika anda're hanya menambahkan satu elemen, gunakan tambahkan
.
Ok, jadi let's membuat sebuah eksperimen untuk melihat bagaimana ini bekerja dalam 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 pergi keluar dari cara kami untuk membuat iterable hanya menggunakan memperpanjang adalah (minor) buang-buang waktu:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Kita belajar dari yang ada's apa-apa yang diperoleh dari menggunakan memperpanjang
ketika kita hanya memiliki satu elemen untuk menambahkan.
Juga, ini adalah waktu yang tidak begitu penting. Saya hanya menampilkan mereka untuk membuat titik bahwa, dalam Python, melakukan semantik benar-benar melakukan hal-hal yang Benar Cara™.
It's dibayangkan bahwa anda mungkin menguji timing pada dua sebanding operasi dan mendapatkan ambigu atau invers hasil. Hanya fokus pada melakukan semantik hal yang benar.
Kita melihat bahwa memperpanjang
semantik yang lebih jelas, dan bahwa hal itu dapat berjalan jauh lebih cepat dari menambahkan
, ketika anda berniat untuk menambahkan masing-masing elemen dalam sebuah iterable untuk daftar.
Jika anda hanya memiliki sebuah elemen tunggal (tidak di iterable) untuk menambahkan ke daftar, gunakan tambahkan
.
menambahkan
menambahkan sebuah elemen tunggal. memperpanjang
menambahkan daftar dari unsur-unsur.
Perhatikan bahwa jika anda lulus daftar untuk menambahkan, hal itu masih menambahkan satu elemen:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
Append vs Memperpanjang
[![enter image description here][1]][1] --- 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 memperpanjang, karena anda hanya dapat menambahkan satu elment atau satu daftar dari unsur:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Sehingga anda mendapatkan bersarang daftar
Bukan 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 elemen-elemen dalam satu waktu tanpa bersarang daftar ke yang asli (yang's alasan nama memperpanjang)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
Menambahkan lebih banyak elemen... dengan hasil yang berbeda
Jika anda gunakan untuk menambahkan lebih dari satu elemen, anda harus melewati sebuah daftar dari unsur-unsur sebagai argumen dan anda akan mendapatkan daftar BERSARANG!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Dengan memperpanjang, sebaliknya, anda melewati daftar argumen, tetapi anda akan mendapatkan daftar dengan elemen baru yang tidak bersarang di old satu.
>>> z = [1,2]
>>> z.extend([3,4])
>>> z
[1,2,3,4]
Jadi, dengan unsur-unsur yang lebih, anda akan menggunakan memperpanjang untuk mendapatkan daftar dengan item yang lebih banyak. Anda akan menggunakan append untuk menambahkan tidak lebih elemen ke dalam daftar, tetapi salah satu unsur yang bersarang daftar seperti yang anda dapat dengan jelas melihat pada output dari kode.
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 memperpanjang()
metode mengambil satu argumen, daftar, dan menambahkan masing-masing item dari argumen untuk daftar asli. (Daftar diimplementasikan sebagai kelas. "Menciptakan" sebuah daftar adalah benar-benar instantiating kelas. Dengan demikian, daftar ini 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.
Anda dapat menggunakan "+" untuk kembali memperpanjang, alih-alih memperpanjang 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 di tempatkan perilaku, tetapi dengan sedikit perbedaan dari menambahkan
& memperpanjang
. Salah satu perbedaan terbesar dari +=
dari menambahkan
dan memperpanjang
adalah ketika hal ini digunakan dalam lingkup fungsi, lihat posting blog ini.
append(objek)
- Update daftar dengan menambahkan objek ke dalam 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]]
memperpanjang(daftar)
- pada Dasarnya merangkai 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]
memperpanjang()
dapat digunakan dengan iterator argumen. Berikut ini adalah contoh. Anda ingin membuat sebuah daftar dari daftar list seperti ini:
Dari
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
anda ingin
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Anda dapat menggunakan itertools.rantai.from_iterable()
untuk melakukannya. Metode ini's output adalah sebuah iterator. Pelaksanaannya adalah 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, kita dapat melakukan
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.
Berikut ini adalah cara ekuivalen memperpanjang()
dapat digunakan dengan iterator argumen:
merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
append(): Hal ini pada dasarnya digunakan dalam 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]]
memperpanjang(): Mana memperpanjang(), 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]
Menambahkan menambahkan seluruh data sekaligus. Seluruh data akan ditambahkan ke yang baru dibuat indeks. Di sisi lain, memperpanjang
, sebagai nama menyarankan, memperluas array saat ini.
Misalnya
list1 = [123, 456, 678]
list2 = [111, 222]
Dengan menambahkan
kita mendapatkan:
result = [123, 456, 678, [111, 222]]
Sementara pada memperpanjang
kita mendapatkan:
result = [123, 456, 678, 111, 222]
Yang menarik bahwa telah mengisyaratkan, tapi tidak dijelaskan, adalah bahwa memperpanjang lebih cepat daripada menambahkan. Untuk setiap lingkaran yang telah menambahkan di dalam harus dipertimbangkan untuk diganti dengan daftar.memperpanjang(processed_elements).
Ingatlah bahwa apprending unsur-unsur baru yang mungkin mengakibatkan realloaction dari seluruh daftar ke lokasi yang lebih baik dalam memori. Jika hal ini dilakukan beberapa kali karena kita menambahkan 1 elemen pada suatu waktu, secara keseluruhan kinerja menderita. Dalam pengertian ini, klik disini.memperpanjang analog dengan "".bergabung(stringlist).
Bahasa inggris dictionary mendefinisikan kata-kata menambahkan
dan memperpanjang
sebagai:
menambahkan: tambahkan (sesuatu) ke akhir dokumen tertulis.
memperpanjang: membuat yang lebih besar. Memperbesar atau memperluas
Dengan pengetahuan itu, sekarang mari's memahami
menambahkan
dan memperpanjang
menambahkan
:
memperpanjang
:
daftar(iterable)
.menambahkan
dan memperpanjang
Tidak ada
.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 dapat membuat suplemen yang berguna untuk pertanyaan ini. Jika anda daftar toko-toko tertentu jenis objek, misalnya Info
, di sini adalah situasi yang memperpanjang
metode ini tidak cocok: Dalam untuk
loop dan dan menghasilkan sebuah Info
objek setiap saat dan menggunakan memperpanjang
untuk menyimpannya ke daftar anda, itu akan gagal. Pengecualian adalah seperti di bawah ini:
TypeError: 'Info' objek tidak iterable
Tapi jika anda menggunakan menambahkan
metode, hasilnya OK. Karena setiap kali menggunakan memperpanjang
metode, itu akan selalu memperlakukannya sebagai daftar atau lain jenis koleksi, iterate itu, dan tempat itu setelah sebelumnya klik disini. Objek tertentu tidak dapat mengulangi, jelas.
Untuk membedakan mereka secara intuitif
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
It's seperti l1
mereproduksi tubuh dalam tubuhnya(bersarang).
# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']
It's seperti yang dipisahkan dua individu yang menikah dan membangun sebuah keluarga amerika.
Selain itu saya membuat aplikasi yang lengkap cheatsheet dari semua daftar's metode untuk referensi anda.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
memperpanjang(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]
menambahkan
"meluas" daftar (di tempat) dengan hanya satu item, yang satu objek diteruskan (sebagai argumen).
memperpanjang
"meluas" daftar (di tempat) dengan barang-barang sebanyak objek diteruskan (sebagai argumen) berisi.
Ini mungkin akan sedikit membingungkan bagi str
benda-benda.
menambahkan
akan menambah satu string item di akhir tapi
memperpanjang
akan menambahkan banyak "single", 'str' item sebagai panjang dari string tersebut.menambahkan
masih akan menambah satu 'daftar' item di akhir dan
memperpanjang
akan menambahkan sebanyak 'daftar' item yang panjang berlalu daftar.def append_o(a_list, elemen): a_list.append(elemen) print('append:', end = ' ') untuk item di a_list: print(item, end = ',') print()
def extend_o(a_list, elemen): a_list.memperpanjang(elemen) print('memperpanjang:', end = ' ') untuk item di 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,
Menambah dan memperpanjang adalah salah satu diperpanjang mekanisme di python.
Append: Menambahkan sebuah elemen ke akhir daftar.
my_list = [1,2,3,4]
Untuk menambahkan sebuah elemen baru ke dalam daftar, kita dapat menggunakan append metode dengan cara sebagai berikut.
my_list.append(5)
Lokasi default bahwa unsur baru yang akan ditambahkan adalah selalu dalam (panjang+1) posisi.
Insert: menyisipkan metode yang digunakan untuk mengatasi keterbatasan menambahkan. Dengan menyisipkan, kita dapat secara eksplisit menentukan posisi yang tepat kami ingin elemen baru yang akan dimasukkan pada.
Metode kata kunci insert(indeks, objek). Dibutuhkan dua argumen, yang pertama indeks kita ingin menyisipkan elemen kami dan kedua unsur itu sendiri.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Memperpanjang: hal Ini sangat berguna ketika kita ingin bergabung dengan dua atau lebih daftar menjadi satu daftar. Tanpa memperpanjang, jika kita ingin bergabung dengan dua daftar, objek yang dihasilkan akan berisi daftar dari 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, we'll harus menggunakan append.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Untuk bergabung beberapa daftar
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]