[PYTHON] 파이썬에서 많은리스트의 연결

파이썬에서 많은리스트의 연결

다음과 같은 함수가 있다고 가정 해보십시오.

def getNeighbors(vertex)

지정된 정점의 이웃 인 정점 목록을 반환합니다. 이제 저는 이웃 사람들의 이웃들과 함께리스트를 만들고 싶습니다. 나는 이렇게 해.

listOfNeighborsNeighbors = []
for neighborVertex in getNeighbors(vertex):
    listOfNeighborsNeighbors.append(getNeighbors(neighborsVertex))

거기에 더 파이썬 적 방법이 있습니까?

해결법

1. ==============================

   1.

   [x for n in getNeighbors(vertex) for x in getNeighbors(n)]
   

   또는

   sum(getNeighbors(n) for n in getNeighbors(vertex), [])
   

2. ==============================

   2.보통 itertools 모듈에는 솔루션이 포함되어 있습니다.

   보통 itertools 모듈에는 솔루션이 포함되어 있습니다.

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

3. ==============================

   3.추가 목록은 + 및 sum ()을 사용하여 수행 할 수 있습니다.

   추가 목록은 + 및 sum ()을 사용하여 수행 할 수 있습니다.

   >>> c = [[1, 2], [3, 4]]
   >>> sum(c, [])
   [1, 2, 3, 4]
   

4. ==============================

   4.속도가 중요한 경우 다음을 사용하는 것이 좋습니다.

   속도가 중요한 경우 다음을 사용하는 것이 좋습니다.

   from operator import iadd
   reduce(iadd, (getNeighbors(n) for n in getNeighbors(vertex)))
   

   이 코드의 요점은 전체 목록을 list.extend로 연결하는 것입니다. 여기서 list comprehension은 list.append를 호출하는 것처럼 항목을 하나씩 추가합니다. 그 결과 오버 헤드가 약간 줄어들어 이전 (내 측정에 따르면) 속도가 약 3 배 빨라졌습니다. (iadd 연산자는 보통 + =로 쓰여지고 list.extend와 같은 일을합니다.)

   List comprehensions (이그나시오의 첫 번째 해결책)를 사용하는 것이 일반적으로 여전히 올바른 방법이며, 읽기 쉽습니다.

   하지만 sum (..., [])은 2 차 시간에 실행되기 때문에 사용하지 않는 것이 좋습니다. 많은 목록 (100여 가지가 넘는)에 대해서는 매우 비실용적입니다.

5. ==============================

   5.속도별로 정렬 :

   속도별로 정렬 :

   list_of_lists = [[x,1] for x in xrange(1000)]
   
   %timeit list(itertools.chain(*list_of_lists))
   100000 loops, best of 3: 14.6 µs per loop
   
   %timeit list(itertools.chain.from_iterable(list_of_lists))
   10000 loops, best of 3: 60.2 µs per loop
   
   min(timeit.repeat("ll=[];\nfor l in list_of_lists:\n ll.extend(l)", "list_of_lists=[[x,1] for x in xrange(1000)]",repeat=3, number=100))/100.0
   9.620904922485351e-05
   
   %timeit [y for z in list_of_lists for y in z]
   10000 loops, best of 3: 108 µs per loop
   
   %timeit sum(list_of_lists, [])
   100 loops, best of 3: 3.7 ms per loop
   

6. ==============================

   6.선형 시간 (합계 (...)가 2 차 시간에서 실행되기 때문에) itertools.chain 접근법이 좋지만 @Jochen은 동적 길이 목록을 처리하는 방법을 보여주지 않았습니다. 여기에 OP의 질문에 대한 해결책이 있습니다.

   선형 시간 (합계 (...)가 2 차 시간에서 실행되기 때문에) itertools.chain 접근법이 좋지만 @Jochen은 동적 길이 목록을 처리하는 방법을 보여주지 않았습니다. 여기에 OP의 질문에 대한 해결책이 있습니다.

   import itertools
   list(itertools.chain(*[getNeighbors(n) for n in getNeighbors(vertex)]))
   

   iterable이 충분하면 목록 (...) 호출을 제거 할 수 있습니다.

7. ==============================

   7.sum () (매번 새로운 객체) 대신 reduce와 결합 된 .extend () (place in update)를 사용하는 것이 더 효율적입니다. 그러나 나는 그것을 테스트하기에는 너무 게을 름입니다. :)

   sum () (매번 새로운 객체) 대신 reduce와 결합 된 .extend () (place in update)를 사용하는 것이 더 효율적입니다. 그러나 나는 그것을 테스트하기에는 너무 게을 름입니다. :)

   mylist = [[1,2], [3,4], [5,6]] 
   reduce(lambda acc_l, sl: acc_l.extend(sl) or acc_l, mylist)
   

from https://stackoverflow.com/questions/3021641/concatenation-of-many-lists-in-python by cc-by-sa and MIT license