Làm cách nào để nối hai danh sách trong Python?

Thí dụ:

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

Kết quả dự kiến:

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

Bạn có thể sử dụng +toán tử để kết hợp chúng:

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

joinedlist = listone + listtwo

Đầu ra:

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

Cũng có thể tạo một trình tạo chỉ đơn giản lặp lại các mục trong cả hai danh sách bằng cách sử dụng itertools.chain(). Điều này cho phép bạn kết hợp các danh sách chuỗi (hoặc bất kỳ lần lặp lại nào) để xử lý mà không cần sao chép các mục vào danh sách mới:

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

Python >= 3.5thay thế:[*l1, *l2]

Một lựa chọn khác đã được giới thiệu thông qua sự chấp nhận PEP 448mà đáng được đề cập.

PEP, có tiêu đề Tổng quát hóa giải nén bổ sung , thường giảm một số hạn chế cú pháp khi sử dụng *biểu thức được gắn dấu sao trong Python; với nó, việc tham gia hai danh sách (áp dụng cho bất kỳ lần lặp nào) giờ đây cũng có thể được thực hiện với:

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

Chức năng này được xác định cho Python,3.5 nó chưa được nhập vào các phiên bản trước trong 3.xgia đình. Trong các phiên bản không được hỗ trợ, SyntaxErrornó sẽ được nâng lên.

Cũng như các cách tiếp cận khác, điều này cũng tạo ra bản sao nông của các yếu tố trong danh sách tương ứng.

Các lộn ngược để phương pháp này là bạn thực sự làm danh sách không cần để thực hiện nó, bất cứ điều gì đó là iterable sẽ làm. Như đã nêu trong PEP:

Điều này cũng hữu ích như một cách dễ dàng hơn để tổng hợp các lần lặp vào một danh sách, chẳng hạn như my_list + list(my_tuple) + list(my_range)bây giờ tương đương với chỉ [*my_list, *my_tuple, *my_range].

Vì vậy, trong khi bổ sung +sẽ tăng một loại TypeErrordo không phù hợp:

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

Sau đây sẽ không:

res = [*l, *r]

bởi vì trước tiên nó sẽ giải nén nội dung của các iterables và sau đó chỉ cần tạo một listtừ nội dung.

Bạn có thể sử dụng các bộ để có được danh sách hợp nhất các giá trị duy nhất

mergedlist = list(set(listone + listtwo))

Bạn cũng có thể sử dụng list.extend()phương thức để thêm listphần cuối vào phần khác:

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

listone.extend(listtwo)

Nếu bạn muốn giữ nguyên danh sách gốc, bạn có thể tạo một listđối tượng mới và extendcả hai danh sách cho nó:

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

Làm cách nào để nối hai danh sách trong Python?

Kể từ 3.7, đây là những phương pháp stdlib phổ biến nhất để ghép hai danh sách (hoặc nhiều hơn) trong python.

Chú thích

1. Đây là một giải pháp khéo léo vì sự cô đọng của nó. Nhưng sumthực hiện nối ghép theo kiểu cặp đôi, có nghĩa đây là thao tác bậc hai vì bộ nhớ phải được phân bổ cho mỗi bước. KHÔNG SỬ DỤNG nếu danh sách của bạn lớn.

2. Xem chain và chain.from_iterable từ các tài liệu. Bạn sẽ cần import itertoolsđầu tiên. Sự kết hợp là tuyến tính trong bộ nhớ, vì vậy đây là điểm tốt nhất về hiệu năng và khả năng tương thích phiên bản. chain.from_iterableđược giới thiệu vào 2.6.

3. Phương pháp này sử dụng Tổng quát hóa giải nén bổ sung (PEP 448) , nhưng không thể khái quát hóa thành danh sách N trừ khi bạn tự giải nén từng cái một.

4. a += bvà a.extend(b)ít nhiều tương đương cho tất cả các mục đích thực tế. +=khi được gọi trong danh sách sẽ gọi nội bộ list.__iadd__, mở rộng danh sách đầu tiên bằng danh sách thứ hai.

Hiệu suất

Ghép nối 2 danh sách ¹

Không có nhiều sự khác biệt giữa các phương thức này nhưng điều đó có nghĩa là tất cả chúng đều có cùng một thứ tự phức tạp (tuyến tính). Không có lý do đặc biệt nào để thích cái này hơn cái kia ngoại trừ vấn đề phong cách.

N-List concatenation

Các ô đã được tạo bằng mô-đun perfplot . Mã, để bạn tham khảo.

_{1. iadd( +=) và extendcác phương thức hoạt động tại chỗ, do đó, một bản sao phải được tạo ra mỗi lần trước khi thử nghiệm. Để giữ mọi thứ công bằng, tất cả các phương pháp đều có bước sao chép trước cho danh sách bên trái có thể bỏ qua.}

Nhận xét về các giải pháp khác

• KHÔNG SỬ DỤNG PHƯƠNG PHÁP DUNDER list.__add__trực tiếp dưới bất kỳ hình thức, hình dạng hoặc hình thức nào. Trong thực tế, tránh xa các phương thức dunder, và sử dụng các toán tử và các operatorchức năng như chúng được thiết kế cho. Python có ngữ nghĩa cẩn thận được đưa vào những thứ phức tạp hơn là chỉ gọi trực tiếp. Đây là một ví dụ . Vì vậy, để tóm tắt, a.__add__(b)=> BAD; a + b=> TỐT.

• Một số câu trả lời ở đây cung cấp reduce(operator.add, [a, b])cho ghép nối đôi - điều này giống như sum([a, b], [])chỉ nhiều từ.

• Bất kỳ phương pháp sử dụng setsẽ giảm trùng lặp và mất thứ tự. Sử dụng cẩn thận.

• for i in b: a.append(i)dài dòng hơn và chậm hơn a.extend(b), đó là chức năng gọi đơn và thành ngữ nhiều hơn. appendchậm hơn vì ngữ nghĩa mà bộ nhớ được phân bổ và phát triển cho các danh sách. Xem ở đây để thảo luận tương tự.

• heapq.mergesẽ hoạt động, nhưng trường hợp sử dụng của nó là để hợp nhất các danh sách được sắp xếp theo thời gian tuyến tính. Sử dụng nó trong bất kỳ tình huống nào khác là một mô hình chống.

• yielding liệt kê các phần tử từ một hàm là một phương thức có thể chấp nhận, nhưng chainthực hiện việc này nhanh hơn và tốt hơn (nó có đường dẫn mã trong C, vì vậy nó rất nhanh).

• operator.add(a, b)là một chức năng có thể chấp nhận tương đương với a + b. Đó là trường hợp sử dụng chủ yếu cho công văn phương pháp động. Mặt khác, thích a + bcái nào ngắn hơn và dễ đọc hơn, theo ý kiến ​​của tôi . YMMV.

Điều này khá đơn giản và tôi nghĩ nó thậm chí còn được hiển thị trong hướng dẫn :

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

Câu hỏi này trực tiếp hỏi về việc tham gia hai danh sách. Tuy nhiên, nó khá cao trong tìm kiếm ngay cả khi bạn đang tìm cách tham gia nhiều danh sách (bao gồm cả trường hợp khi bạn tham gia danh sách không).

Tôi nghĩ rằng lựa chọn tốt nhất là sử dụng danh sách hiểu:

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

Bạn cũng có thể tạo máy phát điện:

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

Câu trả lời cũ

Xem xét cách tiếp cận chung chung hơn này:

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

Sẽ xuất:

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

Lưu ý, điều này cũng hoạt động chính xác khi alà []hoặc [[1,2,3]].

Tuy nhiên, điều này có thể được thực hiện hiệu quả hơn với itertools:

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

Nếu bạn không cần list, nhưng chỉ cần lặp đi lặp lại, bỏ qua list().

Cập nhật

Đề xuất thay thế của Patrick Collins trong các ý kiến ​​cũng có thể làm việc cho bạn:

sum(a, [])

Bạn chỉ có thể sử dụng toán tử +hoặc +=toán tử như sau:

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

c = a + b

Hoặc là:

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

c += (a + b)

Ngoài ra, nếu bạn muốn các giá trị trong danh sách được hợp nhất là duy nhất, bạn có thể thực hiện:

c = list(set(a + b))

Cần lưu ý rằng itertools.chainhàm chấp nhận số lượng đối số biến:

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

Nếu một iterable (tuple, list, tạo, v.v.) là đầu vào, from_iterablephương thức lớp có thể được sử dụng:

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

Với Python 3.3+, bạn có thể sử dụng sản lượng từ :

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]

Hoặc, nếu bạn muốn hỗ trợ một số lượng vòng lặp tùy ý:

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]

Nếu bạn muốn hợp nhất hai danh sách ở dạng đã sắp xếp, bạn có thể sử dụng mergehàm từ heapqthư viện.

from heapq import merge

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

print list(merge(a, b))

Nếu bạn không thể sử dụng toán tử cộng ( +), bạn có thể sử dụng operatornhập:

import operator

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

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

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

Ngoài ra, bạn cũng có thể sử dụng chức năng __add__ dunder :

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

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

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

Như một cách tổng quát hơn cho các danh sách hơn bạn có thể đặt chúng trong một danh sách và sử dụng itertools.chain.from_iterable()¹ chức năng mà dựa trên này câu trả lời là cách tốt nhất cho bằng phẳng một danh sách lồng nhau:

>>> 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. Lưu ý rằng chain.from_iterable()có sẵn trong Python 2.6 trở lên. Trong các phiên bản khác, sử dụng chain(*l).}

Nếu bạn cần hợp nhất hai danh sách được sắp xếp với các quy tắc sắp xếp phức tạp, bạn có thể phải tự cuộn nó như trong đoạn mã sau (sử dụng quy tắc sắp xếp đơn giản để dễ đọc :-)).

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

Bạn có thể sử dụng append()phương thức được xác định trên listcác đối tượng:

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

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

Đoạn mã trên, không bảo toàn thứ tự, loại bỏ trùng lặp khỏi mỗi danh sách (nhưng không phải từ danh sách được nối)

Như đã được chỉ ra bởi nhiều người, itertools.chain()là cách để đi nếu một người cần áp dụng chính xác cùng một điều trị cho cả hai danh sách. Trong trường hợp của tôi, tôi có một nhãn và một cờ khác với danh sách này, vì vậy tôi cần một cái gì đó phức tạp hơn một chút. Hóa ra, đằng sau hậu trường itertools.chain()chỉ đơn giản là làm như sau:

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

(xem https://docs.python.org/2/l Library / itemools.html ), vì vậy tôi đã lấy cảm hứng từ đây và viết một cái gì đó dọc theo những dòng này:

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

Những điểm chính cần hiểu ở đây là các danh sách chỉ là một trường hợp đặc biệt của iterable, là các đối tượng như bất kỳ đối tượng nào khác; và for ... incác vòng lặp trong python có thể hoạt động với các biến tuple, vì vậy thật đơn giản để lặp trên nhiều biến cùng một lúc.

Sử dụng một danh sách hiểu đơn giản:

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

Nó có tất cả các ưu điểm của cách tiếp cận mới nhất là sử dụng Tổng quát hóa giải nén bổ sung - tức là bạn có thể ghép một số lượng lặp khác nhau tùy ý (ví dụ: danh sách, bộ dữ liệu, phạm vi và trình tạo) theo cách đó - và nó không bị giới hạn trong Python 3.5 trở lên .

Một cách thực sự ngắn gọn để kết hợp một danh sách các danh sách là

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

mang lại cho chúng ta

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

Trong Python, bạn có thể nối hai mảng có kích thước tương thích với lệnh này

numpy.concatenate([a,b])

Vì vậy, có hai cách dễ dàng.

1. Sử dụng+ : Nó tạo ra một danh sách mới từ danh sách được cung cấp

Thí dụ:

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. Sử dụng phần mở rộng : Nó nối thêm danh sách mới vào danh sách hiện có. Điều đó có nghĩa là nó không tạo ra một danh sách riêng.

Thí dụ:

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

Vì vậy, chúng tôi thấy rằng trong số hai phương pháp phổ biến nhất, extendlà hiệu quả.

Có nhiều cách để ghép các danh sách trong 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))

Đầu ra:

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]

Nếu bạn muốn có một danh sách mới trong khi vẫn giữ hai danh sách cũ:

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]

Bạn có thể làm theo mã

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

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

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