Python에서 두 목록을 연결하려면 어떻게 해야 하나요?
Python에서 두 목록을 연결하려면 어떻게 해야 하나요?
예:
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]
Python 이 python >= 3.5 체::[*l1, *l2]
언급할 가치가 있는 또 다른 대안이 수용을 통해 도입되었다.
「Additional Unpacking Generalizations」라는 제목의 PEP에서는, 통상, 별표를 사용할 때의 통사상의 제약이 몇개인가 경감되고 있습니다.*Python 。 이를 통해 두 개의 목록(모든 반복 가능한 항목에 적용됨)을 결합할 수도 있습니다.
>>> 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용으로 정의되어 있습니다.이 기능은 Python의 이전 버전에는 백포트되지 않았습니다.3.x되지 않는 에서는, 「」가 됩니다.SyntaxError올라간다고 합니다.
다른 접근법과 마찬가지로, 이 접근법도 대응하는 리스트의 요소의 얕은 카피를 작성합니다.
이 접근법의 장점은 이 작업을 수행하기 위해 목록이 정말로 필요하지 않다는 것입니다. 반복할 수 있는 모든 작업을 수행할 수 있습니다.PEP에 기재된 바와 같이:
방법은 반복 하는 더 쉬운 합니다. 것은은 this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this this 。
my_list + list(my_tuple) + list(my_range)이것은 이제 단지 이 모든 것에 해당하는 것이다.[*my_list, *my_tuple, *my_range].
그를 붙이는 동안 가를 붙이는 거예요.+ TypeError「 」의 「 」의 「 」
l = [1, 2, 3]
r = range(4, 7)
res = l + r
다음 항목은 지원되지 않습니다.
res = [*l, *r]
, 그 '반복적인'을 이기 때문입니다.list그 내용에서.
를 사용하여 두 목록의 항목을 반복하는 생성기를 만들 수도 있습니다.이를 통해 항목을 새 목록에 복사하지 않고 목록(또는 반복 가능)을 함께 연결하여 처리할 수 있습니다.
import itertools
for item in itertools.chain(listone, listtwo):
# Do something with each list item
이 메서드를 사용하여 다음 명령어를 추가할 수도 있습니다.list다음과 같이 합니다.
listone = [1,2,3]
listtwo = [4,5,6]
listone.extend(listtwo)
을 그대로하려면 새 수 .list 및 " " " "extend둘 다 목록에 있습니다.
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
집합을 사용하여 고유한 값의 병합 목록을 가져올 수 있습니다.
mergedlist = list(set(listone + listtwo))
Python에서 두 목록을 연결하려면 어떻게 해야 하나요?
3.9 현재 이것들은 파이썬에서 두 개 이상의 목록을 연결하는 가장 일반적인 stdlib 메서드입니다.
각주
이것은 간결하기 때문에 매끄러운 해결책이다. ★★★★★★★★★★★★★★★★★.
sumare는 use차 do 、 차 、 차 、 차 、 차 、 。★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★문서를 참조해 주세요.할 필요가 있다
import itertools첫째, 연결은 메모리에서 선형이기 때문에 성능 및 버전 호환성이 가장 우수합니다.chain.from_iterable6에 되었습니다.이 방법에서는 Additional Unpacking Generalizations(PEP 448)를 사용하지만 각 목록을 수동으로 풀지 않으면 N개의 목록으로 일반화할 수 없습니다.
a += b★★★★★★★★★★★★★★★★★」a.extend(b)모든 실질적인 목적에 대해 거의 동등합니다.+=으로 호출됩니다.list.__iadd__첫 번째 목록을 두 번째 확장합니다.
성능
2-리스트 연결1
이 방법들 사이에 큰 차이는 없지만, 모두 같은 복잡도 순서(선형)를 가지고 있다는 것을 고려하면 이는 타당합니다.스타일 문제 말고는 둘 중 하나를 선호할 특별한 이유가 없다.
N-리스트 연결
성능도 모듈을 사용하여 그림이 생성되었습니다.참고로 코드입니다.
. 1. »iadd )+= 및 )의 개요extend메서드는 즉석에서 작동하므로 테스트 전에 매번 복사본을 생성해야 합니다.공정성을 유지하기 위해 모든 메서드에는 왼쪽 목록에 대해 무시해도 되는 사전 복사 단계가 있습니다.
기타 솔루션에 대한 코멘트
Method를 하지 .
list.__add__어떤 식으로든, 형태나, 형태에 상관없이 직접.메서드는 및 를 사용합니다.operator설계한 것과 같은 기능을 합니다.Python은 단지 Dunder를 직접 호출하는 것보다 더 복잡한 의미론들을 가지고 있다.여기 예가 있습니다.그래서 요약하자면a.__add__(b)> => 불량;a + b=> 좋좋다다다.몇 가지 답변은 다음과 같습니다.
reduce(operator.add, [a, b])-- 은 pairwise concatination의 경우와 .sum([a, b], [])말이 많아질 뿐이지「」를 사용하는 .
set중복이 삭제되어 순서가 없어집니다.의하주for i in b: a.append(i)a.extend(b)이것은 단일 함수 호출이며 보다 관용적입니다.append는 목록에 메모리를 할당하고 확장하는 의미론 때문에 속도가 느립니다.유사한 내용은 여기를 참조하십시오.heapq.merge는 동작하지만, 그 사용 사례는 정렬된 목록을 선형 시간 내에 병합하기 위한 것입니다.다른 상황에서 사용하는 것은 안티 패턴입니다.yield방식이지만, "는 " "입니다.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]
은 또, 이 때, 이 때, 이렇게 하면 .a[] ★★★★★★★★★★★★★★★★★」[[1,2,3]].
이렇게 더 으로 할 수요.itertools:
a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))
가 필요 없는 경우list, '은 하고 '반복'은 생략합니다list().
갱신하다
Patrick Collins가 코멘트에서 제안한 대안도 도움이 될 수 있습니다.
sum(a, [])
.+ ★★★★★★★★★★★★★★★★★」+=츠키다
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
또는 다음 중 하나를 선택합니다.
c = []
a = [1, 2, 3]
b = [4, 5, 6]
c += (a + b)
또한 Marge된 목록의 값을 원하는 경우 다음을 수행할 수 있습니다.
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']
가능, 이 입력은 다음과 같습니다.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.5+에서 사용 가능)을 사용할 수 있습니다.
In [1]: listone = [1, 2, 3]
...: listtwo = [4, 5, 6]
In [2]: listone + listtwo
Out[2]: [1, 2, 3, 4, 5, 6]
In [3]: [*listone, *listtwo]
Out[3]: [1, 2, 3, 4, 5, 6]
가 많은 으로 「하다」를 사용할 수 .chain.from_iterable()1 에서 기능하다itertools모듈.또한 이 답변에 따르면 이 함수가 가장 좋거나 적어도 중첩 목록을 평준화하는 데 매우 좋은 방법입니다.
>>> 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_itable()'은 Python 2.6 이후에 사용할 수 있습니다.다른 버전에서는 chain(*l)을 사용합니다.
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]
를 정렬된 경우는, 「」를 할 수 .mergeheapq★★★★★★★★★★★★★★★★★★.
from heapq import merge
a = [1, 2, 4]
b = [2, 4, 6, 7]
print list(merge(a, b))
연산자 「」 「」 「」)를 할 수 .+을수 있습니다.operatorImport:
import operator
listone = [1,2,3]
listtwo = [4,5,6]
result = operator.add(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]
외에 '먹다'를 할 수도 있습니다.__add__ 던더 함수:
listone = [1,2,3]
listtwo = [4,5,6]
result = list.__add__(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]
복잡한 정렬 규칙을 가진 2개의 순서 목록을 병합해야 할 경우 다음 코드와 같이 직접 롤링해야 할 수 있습니다(가독성을 위해 단순 정렬 규칙을 사용).
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])
NumPy를 사용하는 경우 다음 명령을 사용하여 호환되는 치수의 두 배열을 연결할 수 있습니다.
numpy.concatenate([a,b])
간단한 목록 이해를 사용합니다.
joined_list = [item for list_ in [list_one, list_two] for item in list_]
이것은 Additional Unpacking Generalizations를 사용하는 최신 접근법의 모든 장점을 가지고 있습니다.즉, 임의의 수의 다른 반복 가능(예를 들어 목록, 튜플, 범위, 생성기)을 그러한 방식으로 연결할 수 있습니다.또한 Python 3.5 이후에만 국한되지 않습니다.
다른 방법:
>>> listone = [1, 2, 3]
>>> listtwo = [4, 5, 6]
>>> joinedlist = [*listone, *listtwo]
>>> joinedlist
[1, 2, 3, 4, 5, 6]
>>>
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 ... inpython의 loops는 태플 변수와 함께 작동할 수 있으므로 여러 변수를 동시에 루프하는 것이 간단합니다.
해서 '아까불까불까불까불까불까불까불까불까불까불까불까불까불까불까불까요?append()에서 list: " " " :
mergedlist =[]
for elem in listone:
mergedlist.append(elem)
for elem in listtwo:
mergedlist.append(elem)
목록을 연결하려면 세 가지 방법을 권장합니다만, 첫 번째 방법이 가장 좋습니다.
# easiest and least complexity method <= recommended
listone = [1, 2, 3]
listtwo = [4, 5, 6]
newlist = listone + listtwo
print(newlist)
# 2nd easiest method
newlist = listone.copy()
newlist.extend(listtwo)
print(newlist)
에서는 '어울리다', '어울리다', '어울리다'를 배정을 합니다.newlist of of listone 않기 listone.
# 3rd method
newlist = listone.copy()
for j in listtwo:
newlist.append(j)
print(newlist)
목록을 연결하기 위해 루프를 사용하기 때문에 목록을 연결하는 방법은 좋지 않습니다.따라서 다른 두 가지 방법보다 시간이 훨씬 더 복잡합니다.
목록 연결에 사용되는 가장 일반적인 방법은 더하기 연산자와 삽입 메서드 추가입니다. 예를 들어 다음과 같습니다.
list = [1,2]
list = list + [3]
# list = [1,2,3]
list.append(3)
# list = [1,2,3]
list.append([3,4])
# list = [1,2,[3,4]]
대부분의 경우 이 기능은 작동하지만 목록이 추가되어도 추가 기능은 확장되지 않습니다.이는 예상되지 않기 때문에 확장이라는 다른 방법을 사용할 수 있습니다. 구조물에 대해 작동해야 합니다.
list = [1,2]
list.extend([3,4])
# list = [1,2,3,4]
목록 목록을 조합하는 정말 간결한 방법은
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]
그래서 두 가지 쉬운 방법이 있다.
- Using : 제공된 목록에서 새 목록을 만듭니다.
예:
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
- 확장 사용:기존 목록에 새 목록이 추가됩니다.즉, 별도의 목록이 생성되지 않습니다.
예:
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율적입입니니다
'하다'로 써도 요.sum.
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> sum([a, b], [])
[1, 2, 3, 4, 5, 6]
>>>
이것은, 임의의 길이와 임의의 요소 타입의 리스트에 대해서 기능합니다.
>>> a = ['a', 'b', 'c', 'd']
>>> b = [1, 2, 3, 4]
>>> c = [1, 2]
>>> sum([a, b, c], [])
['a', 'b', 'c', 'd', 1, 2, 3, 4, 1, 2]
>>>
붙이는유 하는 이유[]는, 「 」가, 「 」에 근거하고 있습니다.start가 「인수」로 되어 있습니다.0해, 「이러다」, 「이러다」에 됩니다.start0 + [1, 2, 3]에, 「」을 「이러면」으로 했을 경우, 「이러면」이 됩니다.start로로 합니다.[] , 에요.[],[] + [1, 2, 3]예상대로 동작합니다.
a=[1,2,3]
b=[4,5,6]
c=a+b
print(c)
출력:
>>> [1, 2, 3, 4, 5, 6]
위의 코드에서는 "+" 연산자를 사용하여 두 목록을 하나의 목록으로 연결합니다.
다른 솔루션:
a=[1,2,3]
b=[4,5,6]
c=[] #Empty list in which we are going to append the values of list (a) and (b)
for i in a:
c.append(i)
for j in b:
c.append(j)
print(c)
출력:
>>> [1, 2, 3, 4, 5, 6]
다음 두 가지 방법 중 하나를 원할 것입니다.
중복 요소 유지
스트링처럼 연결하기만 하면 됩니다.
def concat_list(l1,l2):
l3 = l1+l2
return l3
중복 요소를 제거하려면 다음
def concat_list(l1,l2):
l3 = []
for i in [l1,l2]:
for j in i:
if j not in l3:
#Check if element exists in final list, if no then add element to list
l3.append(j)
return l3
제공되는 솔루션은 단일 목록에 대한 것입니다.리스트 내에 리스트가 있어 대응하는 리스트의 Marge가 필요한 경우."+" 연산은 for loop을 통과합니다.
a=[[1,2,3],[4,5,6]]
b=[[0,1,2],[7,8,9]]
for i in range(len(a)):
cc.append(a[i]+b[i])
출력: [[1, 2, 3, 0, 1, 2], [4, 5, 6, 7, 8, 9]
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]
언급URL : https://stackoverflow.com/questions/1720421/how-do-i-concatenate-two-lists-in-python
'programing' 카테고리의 다른 글
| TypeScript / Angular에서 인터페이스 및 모델을 사용하는 경우 (0) | 2023.02.10 |
|---|---|
| Java 바이트 버퍼에서 문자열로 (0) | 2023.02.06 |
| MySQL RESTRICT와 No ACTION (0) | 2023.02.06 |
| timedelta를 총 초수로 변환 (0) | 2023.02.06 |
| 팬더 DataFrame에서 열의 값이 최대인 행을 찾습니다. (0) | 2023.02.06 |