파이썬에서 두 목록을 어떻게 연결합니까?

예:

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

예상되는 결과:

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

+연산자를 사용하여 다음 을 결합 할 수 있습니다.

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

joinedlist = listone + listtwo

산출:

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

를 사용하여 두 목록의 항목을 단순히 반복하는 생성기를 만들 수도 있습니다 itertools.chain(). 이를 통해 항목을 새 목록에 복사하지 않고 처리를 위해 목록 (또는 반복 가능 항목)을 함께 연결할 수 있습니다.

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

파이썬 >= 3.5대안 :[*l1, *l2]

PEP 448언급 할 가치가있는 다른 대안이 채택되었습니다 .

Additional Unpacking Generalizations 이라는 제목의 PEP는 일반적으로 *Python 에서 별표 표시된 표현식을 사용할 때 일부 구문 제한을 줄였습니다 . 그것으로, 두리스트를 결합하는 것 (모든 iterable에 적용)은 이제 다음과 같이 할 수 있습니다 :

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

이 기능 은 Python 용으로 정의3.5 되었으며 3.x제품군의 이전 버전으로 백 포트되지 않았습니다 . 지원되지 않는 버전에서는 a SyntaxError가 올라갑니다.

다른 접근 방식과 마찬가지로 이것도 해당 목록의 요소 를 얕게 복사 합니다.

상승 이 방법은 당신이 정말로 그것을 수행하기 위해, 반복 가능 할 것입니다 아무것도하지 않아도 목록을 할 것입니다. PEP에 명시된 바와 같이 :

또한 이터 러블을 목록으로 합칠 수있는 읽기 쉬운 방법으로 유용합니다. 예를 들어 my_list + list(my_tuple) + list(my_range)just과 같습니다 [*my_list, *my_tuple, *my_range].

와 또한이 동안 그래서 +인상 것 TypeError불일치를 입력 인해를 :

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

다음은 그렇지 않습니다.

res = [*l, *r]

iterables의 내용을 먼저 풀고 내용에서 간단히 list내용을 작성하기 때문 입니다.

집합을 사용하여 고유 한 값의 병합 된 목록을 얻을 수 있습니다.

mergedlist = list(set(listone + listtwo))

다른 list.extend()방법 list의 끝에 a 를 추가하기 위해이 방법을 사용할 수도 있습니다 .

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

listone.extend(listtwo)

원본 목록을 그대로 유지하려면 새 list객체를 만들고 extend두 목록을 모두 만들 수 있습니다 .

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

파이썬에서 두 목록을 어떻게 연결합니까?

3.7부터는 파이썬에서 두 개 이상의 목록을 연결하는 가장 일반적인 stdlib 방법입니다.

각주

1. 간결함 때문에 매끄러운 솔루션입니다. 그러나 sum한 쌍의 방식으로 연결을 수행합니다. 이는 각 단계마다 메모리를 할당해야하기 때문에 2 차 연산임을 의미합니다. 목록이 큰 경우 사용하지 마십시오.

2. 참조 chain 및 chain.from_iterable 워드 프로세서에서. import itertools먼저 해야합니다 . 연결은 메모리에서 선형이므로 성능 및 버전 호환성 측면에서 최고입니다. chain.from_iterable2.6에서 소개되었습니다.

3. 이 방법은 추가 포장 풀기 일반화 (PEP 448) 를 사용하지만 직접 포장을 풀지 않으면 N 목록으로 일반화 할 수 없습니다.

4. a += b그리고 a.extend(b)더 많거나 적은 상응하는 모든 실제적인 목적을 위해입니다. +=목록에서 호출되면 내부적으로를 호출 list.__iadd__하여 첫 번째 목록을 두 번째 목록으로 확장합니다.

공연

2- 목록 연결 ¹

이 방법들 사이에는 큰 차이가 없지만 모두 동일한 순서의 복잡성 (선형)을 갖는 것이 의미가 있습니다. 스타일 문제를 제외하고는 다른 것을 선호 할 특별한 이유가 없습니다.

N- 목록 연결

플롯은 perfplot 모듈을 사용하여 생성되었습니다 . 참고로 코드입니다.

_{1. iadd( +=) 및 extend방법은 제자리에서 작동하므로 테스트 전에 매번 사본을 생성해야합니다. 일을 공정하게 유지하기 위해 모든 방법에는 왼쪽 목록에 대한 사전 복사 단계가 있으며 무시할 수 있습니다.}

다른 솔루션에 대한 의견

• list.__add__어떤 방식, 모양 또는 형태로도 던저 방법을 직접 사용하지 마십시오 . 실제로, Dunder 메소드를 피하고 operator설계된 것과 같은 연산자와 함수를 사용하십시오 . 파이썬은 신중한 의미론을 가지고 있는데, 이것들은 단지 던전을 직접 호출하는 것보다 복잡한 것입니다. 여기 예가 있습니다. 요약하면 a.__add__(b)=> BAD; a + b=> 좋아.

• 여기에 일부 답변 reduce(operator.add, [a, b])은 페어 단위 연결을 제공 합니다. 이것은 sum([a, b], [])더 장황한 것과 같습니다 .

• 사용하는 모든 방법은 set중복을 제거하고 순서를 잃습니다. 주의해서 사용하십시오.

• for i in b: a.append(i)a.extend(b)단일 함수 호출과 관용적 인보 다 더 장황하고 느립니다 . append목록에 메모리가 할당되고 성장되는 의미론으로 인해 속도가 느려집니다. 비슷한 토론에 대해서는 여기 를 참조 하십시오 .

• heapq.merge작동하지만 사용 사례는 정렬 된 목록을 선형 시간으로 병합하는 것입니다. 다른 상황에서 사용하는 것은 안티 패턴입니다.

• yield함수에서 list 요소를 사용하는 것은 허용 가능한 방법이지만 chain더 빠르고 더 잘 수행합니다 (C에 코드 경로가 있으므로 빠릅니다).

• operator.add(a, b)허용 가능한 기능은 a + b입니다. 유스 케이스는 주로 동적 메소드 디스패치에 사용됩니다. 그렇지 않으면 내 의견으로a + b 는 더 짧고 읽기 쉬운 것을 선호합니다 . YMMV.

이것은 매우 간단 하며 튜토리얼 에도 나와 있다고 생각합니다 .

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

이 질문은 두 목록에 가입하는 것에 대해 직접 묻습니다. 그러나 많은 목록에 참여하는 방법을 찾을 때도 검색이 매우 높습니다 (제로 목록에 참여하는 경우 포함).

가장 좋은 옵션은 목록 이해를 사용하는 것입니다.

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

생성기를 만들 수도 있습니다.

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

기존 답변

이보다 일반적인 접근 방식을 고려하십시오.

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

출력합니다 :

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

ais []또는 인 경우에도 올바르게 작동합니다 [[1,2,3]].

그러나 이것은 다음을 사용하여보다 효율적으로 수행 할 수 있습니다 itertools.

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

을 필요로하지 않고 list반복 가능하면 생략하십시오 list().

최신 정보

패트릭 콜린스 (Patrick Collins)의 의견에서 제안 된 대안은 당신에게도 도움이 될 수 있습니다.

sum(a, [])

다음과 같이 +or +=연산자를 간단히 사용할 수 있습니다.

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

c = a + b

또는:

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

c += (a + b)

또한 병합 된 목록의 값을 고유하게하려면 다음을 수행하십시오.

c = list(set(a + b))

이 itertools.chain함수는 가변 개수의 인수를 허용합니다.

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

iterable (tuple, list, generator 등)이 입력 인 경우 from_iterable클래스 메소드를 사용할 수 있습니다.

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

Python 3.3 이상에서는 다음 에서 yield를 사용할 수 있습니다 .

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]

또는 임의의 수의 반복자를 지원하려는 경우 :

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]

두 목록을 정렬 된 형식으로 병합 merge하려면 heapq라이브러리 에서 함수를 사용할 수 있습니다 .

from heapq import merge

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

print list(merge(a, b))

더하기 연산자 ( +)를 사용할 수없는 경우 operator가져 오기를 사용할 수 있습니다 .

import operator

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

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

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

또는 __add__ dunder 기능을 사용할 수도 있습니다 .

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

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

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

더 목록에 대한보다 일반적인 방법으로 당신은 목록 내를 넣고 사용할 수있는 itertools.chain.from_iterable()^{1 개} 을 기반으로하는 기능 이 대답은 중첩 된 목록을 납작하게하기위한 가장 좋은 방법은 :

>>> 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. chain.from_iterable()파이썬 2.6 이상에서 사용할 수 있습니다. 다른 버전에서는을 사용하십시오 chain(*l).}

복잡한 정렬 규칙을 사용하여 두 개의 정렬 된 목록을 병합해야하는 경우 다음 코드와 같이 직접 읽을 수 있어야합니다 (가독성을 위해 간단한 정렬 규칙 사용 :-)).

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

객체에 append()정의 된 방법을 사용할 수 있습니다 list.

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

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

위의 코드는 순서를 유지하지 않고 각 목록에서 중복을 제거하지만 연결 목록에서는 제거하지 않습니다.

많은 사람들이 이미 지적했듯이 두 목록에 똑같은 치료법 을 itertools.chain()적용 해야하는 경우 갈 수있는 방법 입니다. 필자의 경우 레이블과 플래그가 하나의 목록과 다른 목록이 있으므로 약간 더 복잡한 것이 필요했습니다. 결과적으로, 배후에서 간단히 다음을 수행합니다.itertools.chain()

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

( https://docs.python.org/2/library/itertools.html 참조 ) 여기에서 영감을 얻어 다음 줄을 따라 뭔가를 썼습니다.

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

여기서 이해해야 할 요점은리스트가 다른 반복 가능한 객체 일 뿐이라는 점입니다. 것을 for ... in이 동시에 여러 변수에 대한 루프에 대한 간단한 그래서 파이썬에서 루프는 튜플 변수로 작업 할 수 있습니다.

간단한 목록 이해를 사용하십시오.

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

추가 압축 풀기 일반화 를 사용하는 최신 접근 방식의 모든 장점을 가지고 있습니다. 즉, 목록, 튜플, 범위 및 생성기와 같은 임의의 수의 다른 반복 가능 항목을 연결할 수 있습니다-파이썬 3.5 이상으로 제한되지 않습니다. .

목록 목록을 결합하는 정말 간결한 방법은

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

우리에게주는

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

파이썬에서는이 명령으로 호환 가능한 차원의 두 배열을 연결할 수 있습니다

numpy.concatenate([a,b])

따라서 두 가지 쉬운 방법이 있습니다.

1. 사용+ : 제공된 목록에서 새 목록을 만듭니다.

예:

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. extend 사용 : 기존리스트에 새로운리스트를 추가합니다. 즉, 별도의 목록을 만들지 않습니다.

예:

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

따라서 가장 널리 사용되는 두 가지 방법 중 하나 extend가 효율적이라는 것을 알 수 있습니다.

파이썬에서리스트를 연결하는 방법은 여러 가지가 있습니다.

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

1. new_list = l1.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))

산출:

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]

두 개의 이전 목록을 유지하면서 새 목록을 원할 경우 :

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]

당신은 코드를 따를 수 있습니다

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

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

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