[PYTHON] 목록 독해를 사용하여 튜플의 튜플을 1 차원 목록으로 변환하려면 어떻게해야합니까? [복제]

목록 독해를 사용하여 튜플의 튜플을 1 차원 목록으로 변환하려면 어떻게해야합니까? [복제]

저는 튜플 (tuple) 튜플을 가지고 있습니다 - 예를 들면 :

tupleOfTuples = ((1, 2), (3, 4), (5,))

이 순서로 모든 요소의 평면, 일차원 목록으로 변환하려면 :

[1, 2, 3, 4, 5]

나는 이것을 목록 작성으로 완성하려고 노력해 왔습니다. 그러나 나는 그것을 알아낼 수 없습니다. for-each 루프로이 작업을 수행 할 수있었습니다.

myList = []
for tuple in tupleOfTuples:
   myList = myList + list(tuple)

그러나 목록 이해력으로이를 수행 할 수있는 방법이 있어야하는 것처럼 느껴집니다.

tupleOfTuples의 튜플에 대한 간단한 [list (tuple)]은 개별 요소 대신 목록을 제공합니다. 아마도 다음과 같이 목록을 언팩하기 위해 언 패킹 연산자를 사용하여이를 빌드 할 수 있다고 생각했습니다.

[*list(tuple) for tuple in tupleOfTuples]

또는

[*(list(tuple)) for tuple in tupleOfTuples]

...하지만 그건 효과가 없습니다. 어떤 아이디어? 아니면 그냥 반복해야합니까?

해결법

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

   1.일반적으로 중첩 된 구조 병합이라고합니다.

   일반적으로 중첩 된 구조 병합이라고합니다.

   >>> tupleOfTuples = ((1, 2), (3, 4), (5,))
   >>> [element for tupl in tupleOfTuples for element in tupl]
   [1, 2, 3, 4, 5]
   

   효율성을 입증하기 위해 :

   >>> import timeit
   >>> it = lambda: list(chain(*tupleOfTuples))
   >>> timeit.timeit(it)
   2.1475738355700913
   >>> lc = lambda: [element for tupl in tupleOfTuples for element in tupl]
   >>> timeit.timeit(lc)
   1.5745135182887857
   

   ETA : 튜플을 변수 이름으로 사용하지 마십시오. 그림자가 내장되어 있습니다.

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

   2.튜플이 많지 않은 경우 합계를 사용하십시오.

   튜플이 많지 않은 경우 합계를 사용하십시오.

   >>> tupleOfTuples = ((1, 2), (3, 4), (5,))
   >>> sum(tupleOfTuples, ())
   (1, 2, 3, 4, 5)
   >>> list(sum(tupleOfTuples, ())) # if you really need a list
   [1, 2, 3, 4, 5]
   

   튜플이 많은 경우 list comprehension 또는 chain.from_iterable을 사용하여 sum의 2 차 동작을 방지합니다.

   관측:

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

   3.튜플을 체인으로 연결합니다.

   튜플을 체인으로 연결합니다.

   from itertools import chain
   print list(chain(*listOfTuples))
   

   itertools에 익숙하다면 꽤 읽기 쉬워야하며 명시 적 목록이 없으면 생성자 형식으로 결과를 얻을 수도 있습니다.

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

   4.이러한 답변의 대부분은 단일 수준의 병합에 대해서만 작동합니다. 보다 포괄적 인 해결책을 찾으려면 http://rightfootin.blogspot.com/2006/09/more-on-python-flatten.html에서 다음을 시도하십시오.

   이러한 답변의 대부분은 단일 수준의 병합에 대해서만 작동합니다. 보다 포괄적 인 해결책을 찾으려면 http://rightfootin.blogspot.com/2006/09/more-on-python-flatten.html에서 다음을 시도하십시오.

   def flatten(l, ltypes=(list, tuple)):
       ltype = type(l)
       l = list(l)
       i = 0
       while i < len(l):
           while isinstance(l[i], ltypes):
               if not l[i]:
                   l.pop(i)
                   i -= 1
                   break
               else:
                   l[i:i + 1] = l[i]
           i += 1
       return ltype(l)
   

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

   5.나는이 상황에서 '감소'를 사용하는 것을 좋아한다.

   나는이 상황에서 '감소'를 사용하는 것을 좋아한다.

   lot = ((1, 2), (3, 4), (5,))
   print list(reduce(lambda t1, t2: t1 + t2, lot))
   
    > [1,2,3,4,5]
   

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

   6.다중 레벨 및 읽을 수있는 코드 :

   다중 레벨 및 읽을 수있는 코드 :

   def flatten(bla):
       output = []
       for item in bla:
           output += flatten(item) if hasattr (item, "__iter__") or hasattr (item, "__len__") else [item]
       return output
   

   나는 이것을 한 줄에 맞출 수 없었고 (멀리까지도 읽을 수있게했다)

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

   7.itertools.chain을 사용하는 다른 솔루션

   itertools.chain을 사용하는 다른 솔루션

   >>> tupleOfTuples = ((1, 2), (3, 4), (5,))
   >>> from itertools import chain
   >>> [x for x in chain.from_iterable(tupleOfTuples)]
   [1, 2, 3, 4, 5]
   

from https://stackoverflow.com/questions/3204245/how-do-i-convert-a-tuple-of-tuples-to-a-one-dimensional-list-using-list-comprehe by cc-by-sa and MIT license