목록에서 요소의 모든 항목을 찾는 방법

목록에서 요소의 모든 항목을 찾는 방법

index() 목록의 첫 번째 항목이 나타납니다.요소의 목록에 있는 모든 인덱스를 반환하는 깔끔한 트릭이 있습니까?

목록 이해는 다음과 같이 사용할 수 있습니다.

indices = [i for i, x in enumerate(my_list) if x == "whatever"]

★★★enumerate(my_list)이 생성됩니다.(index, item)★★★★★★★★★★★★★★★★★」「」를 사용합니다.i, x variable target은 합니다.i 항목 ★★★★★★★★★★★★★★★★★★★★★」x.x지수를 합니다.i이 요소들의.

, 「 」는 「 」를 해 주세요.numpy이런 면에서 정말 빛나죠.

import numpy as np
values = np.array([1,2,3,1,2,4,5,6,3,2,1])
searchval = 3
ii = np.where(values == searchval)[0]

반환:

ii ==>array([2, 8])

이것은 다른 솔루션보다 요소가 많은 목록(어레이)에서 훨씬 더 빠를 수 있습니다.

★★★★★★★★★를 사용한 list.index:

def indices(lst, element):
    result = []
    offset = -1
    while True:
        try:
            offset = lst.index(element, offset+1)
        except ValueError:
            return result
        result.append(offset)

enumerate(일본어판/영어: ,, 작, 작, 작 보다 .numpy어레이가 이미 있는 경우 변환 비용이 속도 게인(100, 1000 및 10000 요소가 있는 정수 목록에 포함됨)보다 커집니다.

메모: Chris_Rands의 코멘트에 근거한 주의사항: 이 솔루션은 결과가 충분히 희박한 경우 목록 이해보다 빠르지만, 목록에 검색 중인 요소의 인스턴스가 많을 경우(정수 1000개의 테스트에서 목록의 15% 이상) 목록 이해 속도가 빨라집니다.

그럼 어떻게 해?

In [1]: l=[1,2,3,4,3,2,5,6,7]

In [2]: [i for i,val in enumerate(l) if val==3]
Out[2]: [2, 4]

more_itertools.locate 조건을 충족하는 모든 항목의 인덱스를 찾습니다.

from more_itertools import locate


list(locate([0, 1, 1, 0, 1, 0, 0]))
# [1, 2, 4]

list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
# [1, 3]

more_itertools 라이브러리입니다.> pip install more_itertools.

occurrences = lambda s, lst: (i for i,e in enumerate(lst) if e == s)
list(occurrences(1, [1,2,3,1])) # = [0, 3]

「」를 사용합니다.range 3마지막 3):

l=[i for i in range(len(lst)) if lst[i]=='something...']

(피톤 2)의 경우:

l=[i for i in xrange(len(lst)) if lst[i]=='something...']

그리고 (두 경우 모두)

print(l)

역시.

목록에서 하나 이상의 항목(동일)의 모든 항목 및 위치 가져오기

enumerate(alist)를 사용하면 x 요소가 원하는 것과 같을 때 목록의 색인인 첫 번째 요소 n을 저장할 수 있습니다.

>>> alist = ['foo', 'spam', 'egg', 'foo']
>>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo']
>>> foo_indexes
[0, 3]
>>>

함수 findindindex를 만듭니다.

이 함수는 항목과 목록을 인수로 사용하여 이전에 살펴본 것처럼 목록 내 항목의 위치를 반환합니다.

def indexlist(item2find, list_or_string):
  "Returns all indexes of an item in a list or a string"
  return [n for n,item in enumerate(list_or_string) if item==item2find]

print(indexlist("1", "010101010"))

---

산출량

---

[1, 3, 5, 7]

간단하죠.

for n, i in enumerate([1, 2, 3, 4, 1]):
    if i == 1:
        print(n)

출력:

0
4

• 다음 방법으로 답이 있습니다.np.where 않은 합니다.
• 의 .numpy입니다.list a까지numpy.array 아아이 probably probably probably probably probably probably probably를 사용하여 만들 것이다numpy대부분의 경우 효율이 낮은 옵션입니다.신중한 타이밍 분석이 필요합니다.
  • 로 복수의 이나 조작을 .listlist array 을 사용합니다.numpy이데올로기 때문에
• 이 솔루션에서는 및 를 사용하여 목록 내의 모든 고유 요소의 인덱스를 찾습니다.
  • 「」를 사용합니다.np.where(목록을 배열로 변환하는 시간을 포함)는 모든 고유 요소의 모든 인덱스를 검색하기 위해 목록 이해보다 약간 더 빠릅니다.
  • 이는 4개의 고유한 값을 가진 2M 요소 목록에서 테스트되었으며 목록/배열 크기 및 고유한 요소 수에 영향을 미칩니다.
• 「 」를 사용하고 있는 :numpy배열에 대한 자세한 내용은 numpy 배열에서 반복되는 요소의 모든 인덱스 목록 가져오기

import numpy as np
import random  # to create test list

# create sample list
random.seed(365)
l = [random.choice(['s1', 's2', 's3', 's4']) for _ in range(20)]

# convert the list to an array for use with these numpy methods
a = np.array(l)

# create a dict of each unique entry and the associated indices
idx = {v: np.where(a == v)[0].tolist() for v in np.unique(a)}

# print(idx)
{'s1': [7, 9, 10, 11, 17],
 's2': [1, 3, 6, 8, 14, 18, 19],
 's3': [0, 2, 13, 16],
 's4': [4, 5, 12, 15]}

%timeit

# create 2M element list
random.seed(365)
l = [random.choice(['s1', 's2', 's3', 's4']) for _ in range(2000000)]

한 값의 인덱스 찾기

• 4개의 고유한 요소가 포함된 2M 요소 목록에서 단일 요소의 인덱스 찾기

# np.where: convert list to array
%%timeit
a = np.array(l)
np.where(a == 's1')
[out]:
409 ms ± 41.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# list-comprehension: on list l
%timeit [i for i, x in enumerate(l) if x == "s1"]
[out]:
201 ms ± 24 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# filter: on list l
%timeit list(filter(lambda i: l[i]=="s1", range(len(l))))
[out]:
344 ms ± 36.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

모든 값의 인덱스 찾기

• 4개의 고유 요소가 포함된 2M 요소 목록에서 모든 고유 요소의 색인을 찾습니다.

# use np.where and np.unique: convert list to array
%%timeit
a = np.array(l)
{v: np.where(a == v)[0].tolist() for v in np.unique(a)}
[out]:
682 ms ± 28 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# list comprehension inside dict comprehension: on list l
%timeit {req_word: [idx for idx, word in enumerate(l) if word == req_word] for req_word in set(l)}
[out]:
713 ms ± 16.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

모든 경우에 대해 한 가지 해결 방법(복제된 경우 죄송합니다):

values = [1,2,3,1,2,4,5,6,3,2,1]
map(lambda val: (val, [i for i in xrange(len(values)) if values[i] == val]), values)

python2에서 filter()를 사용합니다.

>>> q = ['Yeehaw', 'Yeehaw', 'Googol', 'B9', 'Googol', 'NSM', 'B9', 'NSM', 'Dont Ask', 'Googol']
>>> filter(lambda i: q[i]=="Googol", range(len(q)))
[2, 4, 9]

동적 목록 이해 기반 솔루션. 어떤 요소가 있는지 미리 알 수 없습니다.

lst = ['to', 'be', 'or', 'not', 'to', 'be']
{req_word: [idx for idx, word in enumerate(lst) if word == req_word] for req_word in set(lst)}

결과는 다음과 같습니다.

{'be': [1, 5], 'or': [2], 'to': [0, 4], 'not': [3]}

으로 생각할 수 .index()발생 번호를 직접 설정할 수 있지만 인덱스는 하나만 찾을 수 있습니다.

「」의 for-loop:

• 회:로:enumerate목록 이해는 더 비단어적인 것이지만 반드시 빠르지는 않다.그러나 이 답변은 이러한 기본 제공 기능 중 일부를 사용할 수 없는 학생들을 대상으로 합니다.
• 을 indices
• 를 for i in range(len(x)):으로 인덱스 위치 [0, 1, 2, 3, ..., len(x)-1]
• 의 「」를 합니다.i서, snowledge.x[i]에 필적한다.value , 에, 에, 에.indices
  • x[i] 인덱스로 목록에 액세스하다

def get_indices(x: list, value: int) -> list:
    indices = list()
    for i in range(len(x)):
        if x[i] == value:
            indices.append(i)
    return indices

n = [1, 2, 3, -50, -60, 0, 6, 9, -60, -60]
print(get_indices(n, -60))

>>> [4, 8, 9]

• 는요, 능, 기, 기,get_indices는 타입 힌트를 사용하여 구현됩니다.이 경우, 리스트는n, 다발, 다발, 다발, 다발, 다발, 다발, 다발.int 그래서 를 찾습니다.value 정의됩니다.int.

---

「」의 while-loop ★★★★★★★★★★★★★★★★★」.index:

• ★★★★★★★★★★★★★★★★ .index하다, 사용하다try-except에러 처리를 위해서,ValueErrorvalue에 없습니다.list.

def get_indices(x: list, value: int) -> list:
    indices = list()
    i = 0
    while True:
        try:
            # find an occurrence of value and update i to that index
            i = x.index(value, i)
            # add i to the list
            indices.append(i)
            # advance i by 1
            i += 1
        except ValueError as e:
            break
    return indices

print(get_indices(n, -60))
>>> [4, 8, 9]

특정 인덱스 간에 모든 요소의 위치를 검색해야 하는 경우 다음과 같이 지정할 수 있습니다.

[i for i,x in enumerate([1,2,3,2]) if x==2 & 2<= i <=3] # -> [3]

defaultdict를 생성할 수 있습니다.

from collections import defaultdict
d1 = defaultdict(int)      # defaults to 0 values for keys
unq = set(lst1)              # lst1 = [1, 2, 2, 3, 4, 1, 2, 7]
for each in unq:
      d1[each] = lst1.count(each)
else:
      print(d1)

Python 2 를 사용하고 있는 경우는, 다음과 같은 기능을 사용할 수 있습니다.

f = lambda my_list, value:filter(lambda x: my_list[x] == value, range(len(my_list)))

어디에my_list인덱스를 취득하는 리스트입니다.value검색된 값입니다.사용방법:

f(some_list, some_element)

생성기 생성

제너레이터는 고속이며 메모리 사용 면적이 작습니다.결과를 유연하게 사용할 수 있습니다.

def indices(iter, val):
    """Generator: Returns all indices of val in iter
    Raises a ValueError if no val does not occur in iter
    Passes on the AttributeError if iter does not have an index method (e.g. is a set)
    """
    i = -1
    NotFound = False
    while not NotFound:
        try:
            i = iter.index(val, i+1)
        except ValueError:
            NotFound = True
        else:
            yield i
    if i == -1:
        raise ValueError("No occurrences of {v} in {i}".format(v = val, i = iter))

위의 코드를 사용하여 인덱스 목록을 만들 수 있습니다.list(indices(input,value)); 사전 키로 사용합니다.dict(indices(input,value)); 요약:sum(indices(input,value)); for 루프로for index_ in indices(input,value):;...등...중간 목록/태플 등을 작성하지 않습니다.

for 루프에서는 다른 모든 인덱스가 먼저 계산될 때까지 기다리지 않고 호출 시 다음 인덱스를 반환합니다.즉, 어떤 이유로 루프를 벗어나면 불필요한 인덱스를 찾는 데 필요한 시간을 절약할 수 있습니다.

구조

• 불러.index입력으로iter다음에 일어날 일을 발견하다val
• 두 번째 파라미터를 사용하여.index(마지막 발견 후)
• 지수를 산출하다
• 까지 반복합니다.index를 올리다ValueError

대체 버전

플로우 제어용으로 4가지 버전을 시험했습니다.2개의 EAFP (사용)try - except2개의 TBIL(로직 테스트 포함)과 2개의 TBIL(로직 테스트 포함)while스테이트먼트):

1. "WhileTrueBreak" :while True:...except ValueError: break의외로, 이것은 보통 옵션2보다 터치가 느리고 (IMV)가 읽기 어렵다.
2. "WhileErrFalse" :Bool 변수 사용err특정하다ValueError인스톨 됩니다.이것은 일반적으로 1보다 빠르고 읽기 쉽다.
3. "Remaining Slice" :슬라이싱을 사용하여 입력의 나머지 부분에 val이 있는지 확인합니다.while val in iter[i:]당연히 확장성이 좋지 않습니다.
4. "마지막 발생":먼저 마지막 발생 위치를 확인하고 계속 진행하십시오.while i < last

1, 2, 4의 전체적인 성능 차이는 무시할 수 있기 때문에 결국 개인 스타일과 취향에 따라 달라집니다.그 때문에.index사용하다ValueError아무것도 찾지 못했다는 걸 알려드리기 위해서입니다. 예를 들어, 되돌아오는 것 보다는요.NoneEAFP 어프로치가 적합하다고 생각합니다.

다음은 4가지 코드 종류와 결과입니다.timeit(밀리초 단위) 다른 길이의 입력 및 희소성 일치에 대해

@version("WhileTrueBreak", versions)
def indices2(iter, val):
    i = -1
    while True:
        try:
            i = iter.index(val, i+1)
        except ValueError:
            break
        else:
            yield i

@version("WhileErrFalse", versions)
def indices5(iter, val):
    i = -1
    err = False
    while not err:
        try:
            i = iter.index(val, i+1)
        except ValueError:
            err = True
        else:
            yield i

@version("RemainingSlice", versions)
def indices1(iter, val):
    i = 0
    while val in iter[i:]:
        i = iter.index(val, i)
        yield i
        i += 1

@version("LastOccurrence", versions)
def indices4(iter,val):
    i = 0
    last = len(iter) - tuple(reversed(iter)).index(val)
    while i < last:
        i = iter.index(val, i)
        yield i
        i += 1

Length: 100, Ocurrences: 4.0%
{'WhileTrueBreak': 0.0074799987487494946, 'WhileErrFalse': 0.006440002471208572, 'RemainingSlice': 0.01221001148223877, 'LastOccurrence': 0.00801000278443098}
Length: 1000, Ocurrences: 1.2%
{'WhileTrueBreak': 0.03101000329479575, 'WhileErrFalse': 0.0278000021353364, 'RemainingSlice': 0.08278000168502331, 'LastOccurrence': 0.03986000083386898}
Length: 10000, Ocurrences: 2.05%
{'WhileTrueBreak': 0.18062000162899494, 'WhileErrFalse': 0.1810499932616949, 'RemainingSlice': 2.9145700042136014, 'LastOccurrence': 0.2049500006251037}
Length: 100000, Ocurrences: 1.977%
{'WhileTrueBreak': 1.9361200043931603, 'WhileErrFalse': 1.7280600033700466, 'RemainingSlice': 254.4725100044161, 'LastOccurrence': 1.9101499929092824}
Length: 100000, Ocurrences: 9.873%
{'WhileTrueBreak': 2.832529996521771, 'WhileErrFalse': 2.9984100023284554, 'RemainingSlice': 1132.4922299943864, 'LastOccurrence': 2.6660699979402125}
Length: 100000, Ocurrences: 25.058%
{'WhileTrueBreak': 5.119729996658862, 'WhileErrFalse': 5.2082200068980455, 'RemainingSlice': 2443.0577100021765, 'LastOccurrence': 4.75954000139609}
Length: 100000, Ocurrences: 49.698%
{'WhileTrueBreak': 9.372120001353323, 'WhileErrFalse': 8.447749994229525, 'RemainingSlice': 5042.717969999649, 'LastOccurrence': 8.050809998530895}

다음은 를 사용하는 경우의 시간 성능 비교입니다.np.where »list_comprehension★★★★★★★★★★★★★★★★★★★★★★★★★.np.where평균 속도가 더 빠릅니다.

# np.where
start_times = []
end_times = []
for i in range(10000):
    start = time.time()
    start_times.append(start)
    temp_list = np.array([1,2,3,3,5])
    ixs = np.where(temp_list==3)[0].tolist()
    end = time.time()
    end_times.append(end)
print("Took on average {} seconds".format(
    np.mean(end_times)-np.mean(start_times)))

Took on average 3.81469726562e-06 seconds

# list_comprehension
start_times = []
end_times = []
for i in range(10000):
    start = time.time()
    start_times.append(start)
    temp_list = np.array([1,2,3,3,5])
    ixs = [i for i in range(len(temp_list)) if temp_list[i]==3]
    end = time.time()
    end_times.append(end)
print("Took on average {} seconds".format(
    np.mean(end_times)-np.mean(start_times)))

Took on average 4.05311584473e-06 seconds

언급URL : https://stackoverflow.com/questions/6294179/how-to-find-all-occurrences-of-an-element-in-a-list