Python의 목록 분류

Question

목록을 파이썬으로 분류하는 가장 좋은 방법은 무엇입니까? 예를 들어

:

totalist is below 

totalist[1] = ['A','B','C','D','E'] 
totalist[2] = ['A','B','X','Y','Z'] 
totalist[3] = ['A','F','T','U','V'] 
totalist[4] = ['A','F','M','N','O'] 

처음 두 항목 ['A','B'], 기본적으로 list[1] 및 list[2]을 어디에 나는 목록을 얻을하고 싶은 말은. 한 번에 하나의 항목을 반복하지 않고도 이들을 쉽게 얻을 수 있습니까? 이런 식으로?

if ['A','B'] in totalist 

나는 작동하지 않습니다.

Answer 1

각 목록의 처음 두 요소를 확인할 수 있습니다.

for totalist in all_lists: 
    if totalist[:2] == ['A', 'B']: 
     # Do something. 

참고 : Kasramvd 제안 한 - 라이너 솔루션도 아주 좋은입니다. 내 솔루션을 더 읽기 쉽게 발견했습니다. 비록 내포가 보통의 for 루프보다 약간 빠르다는 것을 말해야하지만. (어느 것이 나 자신을 테스트했는지)

Answer 2

기본적으로 파이썬에서는 중첩 목록을 사용하여이 작업을 수행 할 수 없습니다. 당신이 인덱스 원하는 경우

>>> [sub for sub in totalist if sub[:2] == ['A', 'B']] 
[['A', 'B', 'C', 'D', 'E'], ['A', 'B', 'X', 'Y', 'Z']] 

: 하위 목록의 처음 두 항목으로 구성 목록을 비교하여

를 사용하여 간단한 지능형리스트 : 당신은 최적화 된 방법을 찾고 있다면 그러나 여기에 몇 가지 방법입니다

>>> [ind for ind, sub in enumerate(totalist) if sub[:2] == ['A', 'B']] 
[0, 1] 

을 그리고 여기에 용량이 큰 데이터 세트를 처리 할 때 꽤 많이 최적화 NumPy와의 접근 방식 : enumerate 사용

는

또한 당신이 당신이 기능적인 방법을 찾고 루프를 사용하지 않으려면 파이썬의 이해를 나열하는 대신, 당신은 지능형리스트로 최적화되지 않는 filter 기능을 사용할 수 있습니다

를

>>> list(filter(lambda x: x[:2]==['A', 'B'], totalist)) 
[['A', 'B', 'C', 'D', 'E'], ['A', 'B', 'X', 'Y', 'Z']] 

Answer 3

이렇게 할 수 있습니다.

>>> for i in totalist: 
...  if ['A','B']==i[:2]: 
...    print i 

Answer 4

귀하는 성능 (비용)에 대해 염려하고 있다는 것을 의미합니다. 이 작업을 수행해야하는 경우 성능에 대해 걱정할 경우 다른 데이터 구조가 필요합니다. 이렇게하면 목록을 만들 때 약간의 "비용"이 추가되지만 필터링 할 때 시간을 절약 할 수 있습니다.

첫 번째 두 요소를 기반으로 필터링해야 할 필요가있는 경우 (첫 번째 n 요소로 일반화되지 않음) 해당 목록이 추가 될 때 해당 키가 터플 인 사전에 추가됩니다 처음 두 요소 중 하나이며 항목은 목록의 목록입니다.

당신은 단순히 dict 조회를하여 목록을 검색 할 수 있습니다. 이것은 쉽게 수행 할 수 있으며 목록을 만드는 동안 메모리와 시간을 거의 들지 않으면 서 잠재적으로 큰 속도 향상을 가져올 것입니다.

Answer 5

그냥 재미를 위해, itertools 솔루션은 C 층에 당 요소 작업을 밀어 :

from future_builtins import map # Py2 only; not needed on Py3 
from itertools import compress 
from operator import itemgetter 

# Generator 
prefixes = map(itemgetter(slice(2)), totalist) 
selectors = map(['A','B'].__eq__, prefixes) 

# If you need them one at a time, just skip list wrapping and iterate 
# compress output directly 
matches = list(compress(totalist, selectors)) 

이 모든 수에 1을 늘어선 :

matches = list(compress(totalist, map(['A','B'].__eq__, map(itemgetter(slice(2)), totalist)))) 

그러나 나는 권하고 싶지 않다 그것. totalist가 발생하지 재 반복 가능한 순서있을 경우 부수적으로, 당신은 추가를 두 배로 itertools.tee을 사용할 것 :

totalist, forselection = itertools.tee(totalist, 2) 

및 forselection 이상 map에 prefixes의 정의를 변경하지 totalist; compress은 두 개의 반복자를 병렬로 반복하므로, tee은 의미있는 메모리 오버 헤드를 가지지 않습니다.

물론 다른 사람들도 언급했듯이 C로 이동하더라도 이것은 선형 알고리즘입니다. 이상적으로는 collections.defaultdict(list)과 같은 것을 사용하여 각 list (tuple으로 변환하여 dict 키로 변환)의 두 요소 접두사에서 list 인 list (해당 접두사가있는 문자)으로 매핑하는 것이 좋습니다. 그런 다음 N list을 선형 검색하는 대신 일치하는 접두사가있는 항목을 찾으려면 totaldict['A', 'B']을 입력하고 O(1) 검색 (결과는 고정 된 작업이 아닌 고정 된 슬라이스가 아님)으로 결과를 얻습니다.

예 미리 계산 작업 :

from collections import defaultdict 

totaldict = defaultdict(list) 
for x in totalist: 
    totaldict[tuple(x[:2])].append(x) 

# Optionally, to prevent autovivification later: 
totaldict = dict(totaldict) 

그럼 당신은 단지 어떤 두 요소 접두어 효과적으로 즉시 matches를 얻을 수 있습니다 :

matches = totaldict['A', 'B']