programing

목록 이해를 사용하여 중첩된 목록을 처리하려면 어떻게 해야 합니까?

megabox 2023. 5. 29. 10:29
반응형

목록 이해를 사용하여 중첩된 목록을 처리하려면 어떻게 해야 합니까?

다음과 같은 중첩된 목록이 있습니다.

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

각 요소를 변환합니다.l로.float다음 코드가 있습니다.

newList = []
for x in l:
    for y in x:
        newList.append(float(y))

대신 중첩된 목록 이해로 문제를 해결하려면 어떻게 해야 합니까?


참고 항목:중첩된 목록 대신 목록 이해에서 플랫 결과를 얻으려면 어떻게 해야 합니까?

중첩 목록 이해를 사용하여 이 작업을 수행하는 방법은 다음과 같습니다.

[[float(y) for y in x] for x in l]

이렇게 하면 문자열 대신 플로트를 사용하는 것을 제외하고는 시작한 것과 유사한 목록이 표시됩니다.

하나의 플랫 리스트를 원한다면 다음을 사용할 것입니다.

[float(y) for x in l for y in x]

루프 순서를 기록합니다.for x in l이번 건은 1등입니다.

루프에 대한 중첩된 목록 이해를 중첩된 목록 이해로 변환하는 방법은 다음과 같습니다.

여기에 이미지 설명 입력

중첩된 목록 이해가 작동하는 방법은 다음과 같습니다.

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

당신의 경우, 만약 당신이 플랫 리스트를 원한다면, 이것과 같은 것이 될 것입니다.

In [4]: new_list = [float(y) for x in l for y in x]

원하는 출력이 무엇인지 확실하지 않지만 목록 이해를 사용하는 경우에는 순서가 중첩된 루프의 순서를 따릅니다.그래서 당신이 원하는 것을 얻었습니다.

[float(y) for x in l for y in x]

원칙은 루프에 대해 중첩된 순서로 작성할 때 사용하는 것과 동일한 순서를 사용하는 것입니다.

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

목록 이해가 실제로 어떻게 작동하는지, 특히 중첩된 목록 이해에 대해 공유하고자 했습니다.

new_list= [float(x) for x in l]

는 실제로 다음과 같습니다.

new_list=[]
for x in l:
    new_list.append(float(x))

이제 중첩된 목록 이해에 대해 설명하겠습니다.

[[float(y) for y in x] for x in l]

다음과 같습니다.

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

출력:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

저도 비슷한 문제가 있어서 이런 질문을 하게 되었습니다.저는 앤드류 클라크의 답변과 나라얀의 답변을 성능 비교하여 공유하고자 합니다.

두 답변의 주요 차이점은 내부 목록을 반복하는 방식입니다.그들 중 하나는 내장된 지도를 사용하는 반면, 다른 하나는 목록 이해를 사용합니다.지도 기능은 람다를 사용할 필요가 없다면 동등한 목록 이해력에 약간의 성능 이점이 있습니다.그래서 이 질문의 맥락에서.map리스트 이해보다 약간 더 잘 수행되어야 합니다.

성능 벤치마크를 수행하여 실제로 사실인지 확인해 보겠습니다.저는 이 모든 테스트를 수행하기 위해 python 버전 3.5.0을 사용했습니다.첫 번째 테스트 세트에서 목록당 요소를 10개로 유지하고 목록의 를 10-100,000개로 변경합니다.

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

여기에 이미지 설명 입력

다음 일련의 테스트에서 목록당 요소 수를 100개로 늘리고 싶습니다.

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

여기에 이미지 설명 입력

용감한 단계를 밟아 목록의 요소 수를 1000개로 수정합니다.

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

여기에 이미지 설명 입력

이 테스트를 통해 우리는 다음과 같은 결론을 내릴 수 있습니다.map이 경우 목록 이해보다 성능 이점이 있습니다.이는 다음 중 하나에 캐스팅하려는 경우에도 적용됩니다.int또는str리스트당 요소 수가 적은 리스트 수가 적을 경우 차이는 무시해도 됩니다. 수가 더큰에는 목당요수더가많큰은목경수있다사습니용할우를 사용할 수 .map목록 이해 대신에, 그러나 그것은 전적으로 응용 프로그램의 필요에 달려 있습니다.

저는 가 하만저는개으로목록이더해가생다각니합고관라용이적쉽지고읽보다 더 읽기 쉽고 이라고 생각합니다.map이것은 파이썬의 사실상 표준입니다.보통 사람들은 목록 이해력을 사용하는 것이 더 능숙하고 편합니다.map.

중첩된 목록 이해가 싫다면 지도 기능도 활용할 수 있습니다.

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

이 문제는 루프를 사용하지 않고도 해결할 수 있습니다.이를 위해서는 라인 코드 한 개로 충분합니다.람다 함수와 함께 내포된 지도를 사용하는 것도 여기서 작동합니다.

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

출력 목록은 다음과 같습니다.

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

예, 다음과 같은 코드로 수행할 수 있습니다.

l = [[float(y) for y in x] for x in l]

플랫 리스트가 필요한 경우:

[y for x in l for y in x]

중첩 목록(목록 내 목록)이 필요한 경우:

[[float(y) for y in x] for x in l]

▁python의'▁▁to▁use썬▁to이▁is▁in▁this▁best▁opinion▁way은법방을 사용하는 것입니다.itertools꾸러미

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]
    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

이는 목록 이해를 사용하여 달성할 수 있습니다.

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

예, 다음을 수행할 수 있습니다.

[[float(y) for y in x] for x in l]

언급URL : https://stackoverflow.com/questions/18072759/how-can-i-use-list-comprehensions-to-process-a-nested-list

반응형