Bagaimana cara menggabungkan dua daftar dengan Python?

Contoh:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

Hasil yang diharapkan:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

Anda dapat menggunakan +operator untuk menggabungkan mereka:

listone = [1,2,3]
listtwo = [4,5,6]

joinedlist = listone + listtwo

Keluaran:

>>> joinedlist
[1,2,3,4,5,6]

Anda juga dapat membuat generator yang hanya mengulang item di kedua daftar menggunakan itertools.chain(). Ini memungkinkan Anda untuk membuat daftar rantai (atau iterable) bersama untuk diproses tanpa menyalin item ke daftar baru:

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item

>= 3.5Alternatif Python :[*l1, *l2]

Alternatif lain telah diperkenalkan melalui penerimaan PEP 448yang layak disebutkan.

PEP, berjudul Generalisasi Unpacking Tambahan , umumnya mengurangi beberapa batasan sintaksis saat menggunakan *ekspresi berbintang dalam Python; dengan itu, bergabung dengan dua daftar (berlaku untuk semua iterable) sekarang juga dapat dilakukan dengan:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]
>>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
>>> print(joined_list)
[1, 2, 3, 4, 5, 6]

Fungsi ini didefinisikan untuk Python3.5 yang belum di-backport ke versi sebelumnya dalam 3.xkeluarga. Dalam versi yang tidak didukung, a SyntaxErrorakan dinaikkan.

Seperti dengan pendekatan lain, ini juga menciptakan salinan elemen yang dangkal dalam daftar yang sesuai.

The upside untuk pendekatan ini adalah bahwa Anda benar-benar melakukan daftar tidak perlu untuk melakukan itu, apa pun yang iterable akan melakukan. Sebagaimana dinyatakan dalam PEP:

Ini juga berguna sebagai cara yang lebih mudah dibaca untuk menjumlahkan iterables ke dalam daftar, seperti my_list + list(my_tuple) + list(my_range)yang sekarang setara dengan adil [*my_list, *my_tuple, *my_range].

Jadi, sementara penambahan dengan +akan meningkatkan TypeErrorkarena ketidakcocokan jenis:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

Berikut ini tidak akan:

res = [*l, *r]

karena pertama-tama akan membongkar isi iterables dan kemudian hanya membuat listdari isinya.

Anda bisa menggunakan set untuk mendapatkan daftar nilai unik yang digabungkan

mergedlist = list(set(listone + listtwo))

Anda juga bisa menggunakan list.extend()metode ini untuk menambahkan a listke akhir yang lain:

listone = [1,2,3]
listtwo = [4,5,6]

listone.extend(listtwo)

Jika Anda ingin mempertahankan daftar asli, Anda dapat membuat listobjek baru , dan extendkeduanya daftar di dalamnya:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Bagaimana cara menggabungkan dua daftar dengan Python?

Pada 3.7, ini adalah metode stdlib paling populer untuk menggabungkan dua (atau lebih) daftar dengan python.

Catatan kaki

1. Ini adalah solusi yang apik karena ringkasnya. Tetapi summelakukan penggabungan secara berpasangan, yang berarti ini adalah operasi kuadratik karena memori harus dialokasikan untuk setiap langkah. JANGAN GUNAKAN jika daftar Anda besar.

2. Lihat chain dan chain.from_iterable dari dokumen. Anda harus import itertoolsterlebih dahulu. Concatenation linear dalam memori, jadi ini yang terbaik dalam hal kinerja dan kompatibilitas versi. chain.from_iterablediperkenalkan pada 2.6.

3. Metode ini menggunakan Generalisasi Unpacking Tambahan (PEP 448) , tetapi tidak dapat digeneralisasi ke daftar N kecuali Anda secara manual membongkar masing-masing sendiri.

4. a += bdan a.extend(b)kurang lebih setara untuk semua tujuan praktis. +=ketika dipanggil daftar akan secara internal memanggil list.__iadd__, yang memperpanjang daftar pertama dengan yang kedua.

Performa

Rangkuman 2-Daftar ¹

Tidak ada banyak perbedaan antara metode ini tetapi itu masuk akal mengingat mereka semua memiliki urutan kompleksitas yang sama (linier). Tidak ada alasan khusus untuk lebih memilih satu daripada yang lain kecuali sebagai masalah gaya.

Rangkaian N-List

Plot telah dibuat menggunakan modul perfplot . Kode, untuk referensi Anda.

_{1. iadd( +=) dan extendmetode beroperasi di tempat, sehingga salinan harus dibuat setiap kali sebelum pengujian. Agar semuanya adil, semua metode memiliki langkah pra-salin untuk daftar sebelah kiri yang dapat diabaikan.}

Komentar untuk Solusi Lain

• JANGAN GUNAKAN METODE DUNDER list.__add__secara langsung dengan cara, bentuk atau bentuk apa pun. Bahkan, jauhi metode-metode gelap, dan gunakan operator dan operatorfungsi seperti yang dirancang untuknya. Python memiliki semantik yang matang yang dimasukkan ke dalam ini yang lebih rumit daripada hanya memanggil dunder secara langsung. Berikut ini sebuah contoh . Jadi, untuk meringkas, a.__add__(b)=> BAD; a + b=> BAIK.

• Beberapa jawaban di sini menawarkan reduce(operator.add, [a, b])untuk pasangan berpasangan - ini sama dengan sum([a, b], [])hanya lebih bertele-tele.

• Metode apa pun yang menggunakan setakan menjatuhkan duplikat dan kehilangan pemesanan. Gunakan dengan hati-hati.

• for i in b: a.append(i)lebih bertele-tele, dan lebih lambat daripada a.extend(b), yang merupakan panggilan fungsi tunggal dan lebih idiomatis. appendlebih lambat karena semantik dengan mana memori dialokasikan dan dikembangkan untuk daftar. Lihat di sini untuk diskusi serupa.

• heapq.mergeakan berfungsi, tetapi kasus penggunaannya adalah untuk menggabungkan daftar yang diurutkan dalam waktu linier. Menggunakannya dalam situasi lain adalah anti-pola.

• yielding elemen daftar dari suatu fungsi adalah metode yang dapat diterima, tetapi chainapakah ini lebih cepat dan lebih baik (memiliki jalur kode dalam C, jadi itu cepat).

• operator.add(a, b)adalah fungsional yang setara dengan a + b. Ini menggunakan kasus terutama untuk pengiriman metode dinamis. Kalau tidak, lebih suka a + byang lebih pendek dan lebih mudah dibaca, menurut saya . YMMV.

Ini cukup sederhana, dan saya pikir itu bahkan ditampilkan dalam tutorial :

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

Pertanyaan ini langsung bertanya tentang bergabung dengan dua daftar. Namun itu cukup tinggi dalam pencarian bahkan ketika Anda mencari cara untuk bergabung dengan banyak daftar (termasuk kasus ketika Anda bergabung dengan daftar nol).

Saya pikir pilihan terbaik adalah menggunakan daftar pemahaman:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Anda juga dapat membuat generator:

>>> map(str, (x for xs in a for x in xs))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

Jawaban Lama

Pertimbangkan pendekatan yang lebih umum ini:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

Akan menghasilkan:

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

Catatan, ini juga bekerja dengan benar saat aini []atau [[1,2,3]].

Namun, ini dapat dilakukan dengan lebih efisien dengan itertools:

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

Jika Anda tidak membutuhkan list, tetapi hanya iterable, hilangkan list().

Memperbarui

Alternatif yang disarankan oleh Patrick Collins dalam komentar juga dapat bekerja untuk Anda:

sum(a, [])

Anda cukup menggunakan operator +atau +=sebagai berikut:

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

Atau:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

Juga, jika Anda ingin nilai dalam daftar yang digabungkan menjadi unik, Anda dapat melakukannya:

c = list(set(a + b))

Perlu dicatat bahwa itertools.chainfungsi menerima jumlah variabel argumen:

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

Jika input (tuple, daftar, generator, dll.) Adalah input, from_iterablemetode kelas dapat digunakan:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']

Dengan Python 3.3+ Anda dapat menggunakan hasil dari :

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

Atau, jika Anda ingin mendukung sejumlah iterator yang sewenang-wenang:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

Jika Anda ingin menggabungkan dua daftar dalam bentuk yang diurutkan, Anda dapat menggunakan mergefungsi dari heapqperpustakaan.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

Jika Anda tidak dapat menggunakan operator plus ( +), Anda dapat menggunakan operatorimpor:

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Atau, Anda juga bisa menggunakan fungsi __add__ dunder :

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Sebagai cara yang lebih umum untuk daftar yang lebih banyak, Anda dapat menempatkannya di dalam daftar dan menggunakan fungsi itertools.chain.from_iterable()¹ yang berdasarkan jawaban ini adalah cara terbaik untuk mengepakkan daftar bertingkat:

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

_{1. Perhatikan bahwa chain.from_iterable()tersedia dalam Python 2.6 dan yang lebih baru. Di versi lain, gunakan chain(*l).}

Jika Anda perlu menggabungkan dua daftar berurutan dengan aturan penyortiran yang rumit, Anda mungkin harus menggulungnya sendiri seperti dalam kode berikut (menggunakan aturan penyortiran sederhana untuk keterbacaan :-)).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

Anda bisa menggunakan append()metode yang didefinisikan pada listobjek:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

list(set(listone) | set(listtwo))

Kode di atas, tidak mempertahankan pesanan, menghapus duplikat dari setiap daftar (tetapi tidak dari daftar yang digabungkan)

Seperti yang telah ditunjukkan oleh banyak orang, itertools.chain()adalah cara untuk pergi jika seseorang perlu menerapkan perlakuan yang sama persis untuk kedua daftar. Dalam kasus saya, saya memiliki label dan bendera yang berbeda dari satu daftar ke yang lain, jadi saya perlu sesuatu yang sedikit lebih kompleks. Ternyata, di balik layar itertools.chain()cukup lakukan hal berikut:

for it in iterables:
    for element in it:
        yield element

(lihat https://docs.python.org/2/library/itertools.html ), jadi saya mengambil inspirasi dari sini dan menulis sesuatu di sepanjang baris ini:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

Poin utama yang perlu dipahami di sini adalah bahwa daftar hanyalah kasus khusus dari iterable, yang merupakan objek seperti yang lainnya; dan bahwa for ... inloop dalam python dapat bekerja dengan variabel tuple, sehingga mudah untuk mengulang pada beberapa variabel secara bersamaan.

Gunakan pemahaman daftar sederhana:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

Ini memiliki semua keuntungan dari pendekatan terbaru menggunakan Generalisasi Unpacking Tambahan - yaitu Anda dapat menggabungkan jumlah acak berbagai iterables (misalnya, daftar, tuple, rentang, dan generator) dengan cara itu - dan itu tidak terbatas pada Python 3.5 atau lebih baru .

Cara yang sangat ringkas untuk menggabungkan daftar adalah

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

yang memberi kita

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

Dengan Python Anda dapat menggabungkan dua array dimensi yang kompatibel dengan perintah ini

numpy.concatenate([a,b])

Jadi ada dua cara mudah.

1. Menggunakan+ : Ini membuat daftar baru dari daftar yang disediakan

Contoh:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop

2. Menggunakan extended : Ini menambahkan daftar baru ke daftar yang ada. Itu artinya tidak membuat daftar terpisah.

Contoh:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

Jadi kita melihat bahwa dari dua metode paling populer, extendadalah efisien.

Ada beberapa cara untuk menggabungkan daftar dalam python.

l1 = [1,2,3,4]
l2 = [3,4,5,6]

 1. new_list = l1.copy()
    new_list = new_list.extend(l2)
 2. new_list = l1 + l2
 3. new_list = [*l1, *l2]

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

Keluaran:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

Jika Anda menginginkan daftar baru sambil menyimpan dua daftar lama:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]

Anda dapat mengikuti kode tersebut

listone = [1, 2, 3]
listtwo = [4, 5, 6]

for i in listone:
    listtwo.append(i)
print(listtwo)

[1,2,3,4,5,6]