Bagaimana cara menggabungkan dua daftar dengan Python?


2531

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]

6
Apakah Anda hanya ingin menambahkan , atau Anda ingin menggabungkan kedua daftar dalam urutan yang diurutkan ? Output apa yang Anda harapkan untuk [1,3,6] dan [2,4,5]? Bisakah kita menganggap kedua sublists sudah diurutkan (seperti pada contoh Anda)?
smci

1
... juga bagaimana jika daftar memiliki duplikat misalnya [1,2,5] and [2,4,5,6]? Apakah Anda ingin duplikat disertakan, dikecualikan, atau tidak peduli?
smci

Jawaban:


3905

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]

110
apakah ini membuat salinan listone yang dalam dan menambahkan listtwo?
Daniel F

152
@Daniel itu akan membuat daftar baru dengan salinan item yang dangkal di daftar pertama, diikuti oleh salinan item yang dangkal di daftar kedua. Gunakan copy.deepcopy untuk mendapatkan salinan daftar yang mendalam.
Daniel G

219
detail lain yang bermanfaat di sini: listone += listtwomenghasilkanlistone == [1, 2, 3, 4, 5, 6]
rickcnagy

16
@ br1ckb0t akankah itu mengubah apa yang ditunjuk listone? Jadi: list3 = listone listone+=listtwo Apakah list3 diubah juga?
MikeH

11
itu memang mengubah list3. Namun, jika itu bukan masalah, lebih mudah untuk menambahkan kedua daftar daripada membuat yang baru.
rickcnagy

319

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

4
chainada di sisi yang lebih lambat (tetapi tidak banyak) untuk dua daftar, tetapi merupakan solusi tercepat untuk merantai beberapa daftar (n >> 2).
cs95

@ cs95 lambat dibandingkan dengan apa?
Moberg

@Moberg Dibandingkan dengan cara lain untuk menggabungkan daftar, untuk referensi silakan lihat tolok ukur saya di sini .
cs95

265

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


1
Contoh yang bagus dari pendekatan unpacking yang mengerjakan tipe iterable adalah fungsi yang mengembalikan iterator ke salah satu daftar yang Anda gabungkan. Misalnya, Anda bisa membalikkan salah satu daftar Anda concatenating: res = [*l1, *reversed(l2)]. Karena reversedmengembalikan iterator, res = l1 + reversed(l2)akan menimbulkan kesalahan.
alan

2
Perlu dicatat bahwa ini analog dengan menggabungkan kamus dengan python. dict3 = {** dict1, ** dict2}. Perhatikan bahwa kami menggunakan ** untuk membongkar kamus sedangkan dengan daftar kami menggunakan * untuk membongkar.
Kevin S

213

Anda bisa menggunakan set untuk mendapatkan daftar nilai unik yang digabungkan

mergedlist = list(set(listone + listtwo))

45
Benar, bagaimanapun, itu juga akan menghapus duplikat, jika itu yang Anda tertarik. Daftar tambahan sepanjang tidak akan melakukan itu.
metasoarous

1
Apa cara untuk melakukan itu dan menyimpan informasi pemesanan?
Natim

11
Lebih baik daripadalistone + [x for x in listtwo if x not in listone]
Natim

8
+1 IMHO, ini adalah cara yang benar untuk "menggabungkan" (gabungan) daftar sementara jawaban "disetujui" menjelaskan cara menggabungkan / menambah daftar (multiset)
alfasin

2
Jika Anda peduli tentang mempertahankan urutan input, maka import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo))akan melakukan trik.
SethMMorton

186

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)

82

Bagaimana cara menggabungkan dua daftar dengan Python?

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

masukkan deskripsi gambar di sini

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 1

masukkan deskripsi gambar di sini

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

masukkan deskripsi gambar di sini

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.


jawaban untuk stackoverflow.com/q/36863404/125507 dapat menggunakan plot perfplot (termasuk solusi numba)
endolith

@ endolith sedikit sibuk dengan pekerjaan tetapi saya akan melihat dan melihat apakah saya dapat chip masuk Ty.
cs95

yang merupakan metode terbaik maka kinerja bijaksana, lebih cepat? tolong beritahu.
ganeshdeshmukh

@ganeshdeshmukh TL; DR semuanya bagus dan yang Anda pilih sebagian besar masalah gaya. "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style."Solusi yang tidak tercantum dalam jawaban saya, atau dikritik dalam" Komentar "Saya sarankan untuk tidak menggunakan.
cs95

78

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]

51

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, [])

3
Python 3 note: reducesekarang functoolsjadi Anda harus mengimpornya terlebih dahulu.
Dimitris Fasarakis Hilliard

41

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

Bagian terakhir dapat memesan ulang barang secara sewenang-wenang. Jika Anda ingin mempertahankan pesanan, pada CPython 3.6+ Anda dapat melakukannyalist(dict.fromkeys(a + b))
Boris

27

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

22

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]

Anda dapat menggunakan itertools.chain(yang setara) alih-alih mendefinisikan fungsi Anda sendiri.
Boris

18

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

15

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]

3
meraih dunder umumnya bukan pendekatan terbaik. Jika +tidak aktif, gunakan operator.add.
Dimitris Fasarakis Hilliard

2
Mengapa operator plus tidak tersedia?
cs01

2
Biasanya tidak akan :) tetapi jika Anda melakukan daftar concatenation dengan fungsi map atau ingin menyimpan fungsi add dalam variabel, Anda tidak dapat menggunakan +.
jpihl

13

Sebagai cara yang lebih umum untuk daftar yang lebih banyak, Anda dapat menempatkannya di dalam daftar dan menggunakan fungsi itertools.chain.from_iterable()1 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).


10

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

Atau gunakan saja heapq.merge.
cs95

7

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

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

9
Asal tahu saja, jika ini yang Anda lakukan dalam praktik, ini jauh, jauh lebih lambat daripada metode lain yang diusulkan. lihat stackoverflow.com/questions/17479361/…
Ryan Haining

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

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


6

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.


5

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 .


4

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]

Tolong jangan gunakan list.__add__, gunakan operator.addsaja. Ini adalah padanan sum(list_of_lists, [])yang lebih bertele-tele yang sama buruknya. JANGAN GUNAKAN!
cs95

@ cs95 dapatkah Anda menjelaskan apa masalahnya dengan menggunakan daftar .__ add__
Akash Singh

metode dunder adalah "metode pribadi" dan biasanya tidak boleh digunakan secara langsung (mereka dipanggil oleh fungsi lain). Pengecualian adalah obj.__class__dan obj.__dict__.
cs95

3

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

numpy.concatenate([a,b])

4
Pertanyaannya tidak meminta numpy.
cs95

2

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


2
Bagaimana jika saya perlu menambahkan beberapa daftar, seperti + b + c + d + e?
Tweakimp

2
@Tweakimp Lihat jawaban ini yang memiliki beberapa opsi (saya sarankan chain.from_iterable).
cs95

2

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]

1
Bisakah Anda jelaskan informasi baru apa yang diberikan jawaban ini di atas yang lain?
cs95

Ada beberapa cara untuk menyatukan daftar dalam python - yang semuanya dibahas secara luas dalam jawaban yang jauh lebih tua lainnya. Informasi baru apa yang disediakan oleh ini ??
Tomerikoo

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

-1

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

Bagaimana itu berbeda dari jawaban ini oleh mingxiao?
Tomerikoo

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

4
Baiklah, tolong lakukan beberapa penjelasan
U10-Forward

Apa gunanya argumen fungsi jika Anda menggunakan nama global di dalamnya?
Tomerikoo

-2

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