Python에서 목록을 포함하는 항목의 색인 찾기

파이썬을 배우는 데 정말로 도움이되는 한 가지는 대화식 도움말 함수를 사용하는 것입니다.

>>> help(["foo", "bar", "baz"])
Help on list object:

class list(object)
 ...

 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value
 |

이것은 종종 당신이 찾고있는 방법으로 당신을이 끕니다.

대다수의 답변은 단일 색인을 (를) 찾는 방법을 설명하지만 항목이 목록에 여러 번있는 경우 여러 색인을 반환하지 않습니다. enumerate() 를 사용하십시오.

for i, j in enumerate(['foo', 'bar', 'baz']):
    if j == 'bar':
        print(i)

index() 함수는 첫 번째 항목 만 반환하고 enumerate()은 모든 항목을 반환합니다.

목록 이해로서 :

[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']

itertools.count() (이것은 열거 형과 거의 같은 접근법)과 함께 또 다른 작은 해결책이 있습니다.

from itertools import izip as Zip, count # izip for maximum efficiency
[i for i, j in Zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']

이것은 enumerate()을 사용하는 것보다 큰 목록에 더 효율적입니다.

$ python -m timeit -s "from itertools import izip as Zip, count" "[i for i, j in Zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 174 usec per loop
$ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 196 usec per loop

모든 색인을 얻으려면 :

 indexes = [i for i,x in enumerate(xs) if x == 'foo']

index()은 값의 first index를 반환합니다!

| 색인(...)
| L.index (value, [start, [stop]]) -> 정수 - 값의 첫 번째 인덱스를 반환합니다.

def all_indices(value, qlist):
    indices = []
    idx = -1
    while True:
        try:
            idx = qlist.index(value, idx+1)
            indices.append(idx)
        except ValueError:
            break
    return indices

all_indices("foo", ["foo","bar","baz","foo"])

요소가 목록에 없으면 문제가 발생합니다. 이 함수는이 문제를 처리합니다.

# if element is found it returns index of element else returns None

def find_element_in_list(element, list_element):
    try:
        index_element = list_element.index(element)
        return index_element
    except ValueError:
        return None

a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']

검색중인 요소가 목록에 있는지 확인하기위한 조건을 설정해야합니다.

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None

여기에 제안 된 모든 기능은 고유 한 언어 동작을 재현하지만 현재 진행중인 작업을 모호하게 만듭니다.

[i for i in range(len(mylist)) if mylist[i]==myterm]  # get the indices

[each for each in mylist if each==myterm]             # get the items

mylist.index(myterm) if myterm in mylist else None    # get the first index and fail quietly

언어가 당신이 원하는 것을하기위한 방법을 제공한다면 왜 예외 처리 기능을 작성해야합니까?

모든 색인을 원할 경우 NumPy :를 사용할 수 있습니다.

import numpy as np

array = [1, 2, 1, 3, 4, 5, 1]
item = 1
np_array = np.array(array)
item_index = np.where(np_array==item)
print item_index
# Out: (array([0, 2, 6], dtype=int64),)

명확하고 읽기 쉬운 솔루션입니다.

파이썬에서 그것을 포함하는 목록이 주어진 항목의 색인 찾기

["foo", "bar", "baz"] 목록과 "bar" 목록에있는 항목의 경우 Python에서 색인 (1)을 얻는 가장 확실한 방법은 무엇입니까?

음, 첫 번째 색인을 반환하는 index 메소드가 있습니다.

>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1

이 방법에는 몇 가지 문제가 있습니다.

• 값이 목록에 없으면 ValueError
• 하나 이상의 값이 목록에 있으면 첫 번째 값에 대해서만 색인을 얻습니다.

값이 없습니다

값이 누락 된 경우 ValueError을 잡아야합니다.

다음과 같이 재사용 가능한 정의로 그렇게 할 수 있습니다.

def index(a_list, value):
    try:
        return a_list.index(value)
    except ValueError:
        return None

그리고 이것을 다음과 같이 사용하십시오 :

>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1

그리고 이것의 단점은 반환 된 값 is 또는 is not None이 있는지 확인해야한다는 것입니다.

result = index(a_list, value)
if result is not None:
    do_something(result)

목록에서 둘 이상의 값

더 많은 경우가 발생하면 not ​​list.index를 사용하여 완전한 정보를 얻습니다.

>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar')              # nothing at index 3?
1

인덱스를 목록 이해로 열거 할 수 있습니다.

>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]

발생이 없으면 결과의 부울 검사로이를 확인하거나 결과를 반복하면 아무것도 수행하지 않을 수 있습니다.

indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
    do_something(index)

팬더로 더 나은 데이터 녹기

팬더가있는 경우 Series 객체를 사용 하여이 정보를 쉽게 얻을 수 있습니다.

>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0    foo
1    bar
2    baz
3    bar
dtype: object

비교 검사는 일련의 부울을 리턴합니다.

>>> series == 'bar'
0    False
1     True
2    False
3     True
dtype: bool

첨자 표기법을 통해 일련의 부울을 시리즈에 전달하면 일치하는 멤버 만 얻을 수 있습니다.

>>> series[series == 'bar']
1    bar
3    bar
dtype: object

인덱스 만 원하는 경우 index 속성은 일련의 정수를 리턴합니다.

>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')

그리고 목록이나 Tuple에 원하는 경우 생성자에게 전달하십시오.

>>> list(series[series == 'bar'].index)
[1, 3]

예, 열거 형과 함께 목록 이해를 사용할 수는 있지만 제 생각에는 우아하지 않습니다 .C로 작성된 내장 코드가 처리하도록하는 대신 Python에서 평등에 대한 테스트를하고 있습니다.

>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]

이것이 XY 문제 입니까?

XY 문제는 실제 문제가 아니라 시도한 솔루션에 대한 질문입니다.

왜 목록에 요소가 주어진 색인이 필요하다고 생각합니까?

이미 그 가치를 알고 있다면, 왜 그 가치가 목록에 있는가?

값이 없으면 ValueError 잡기가 다소 장황합니다. 피하는 것이 좋습니다.

나는 일반적으로 어쨌든 목록을 반복하고 있으므로 일반적으로 흥미로운 정보에 대한 포인터를 유지하고 열거 형으로 색인을 가져옵니다.

데이터를 녹이는 경우 아마도 내가 보여준 순수한 pandas 해결 방법보다 훨씬 더 훌륭한 도구가있는 Python를 사용해야합니다.

list.index, 나 자신이 필요하다는 것을 기억하지 않습니다. 그러나, 나는 Python 표준 라이브러리를 살펴 보았고, 그것에 대한 훌륭한 사용법을 보았습니다.

GUI 및 텍스트 구문 분석을 위해 idlelib에는 그 용도가 많이 있습니다.

keyword 모듈은이 모듈을 사용하여 모듈에서 주석 마커를 찾아 메타 프로그래밍을 통해 키워드 목록을 자동으로 재생성합니다.

Lib/mailbox.py에서는 정렬 된 매핑처럼 사용하는 것 같습니다.

key_list[key_list.index(old)] = new

과

del key_list[key_list.index(key)]

Lib/http/cookiejar.py에서 다음 달을 얻는 데 사용되는 것 같습니다.

mon = MONTHS_LOWER.index(mon.lower())+1

Distutils와 비슷한 Lib/tarfile.py에서 항목까지 슬라이스를 가져옵니다.

members = members[:members.index(tarinfo)]

Lib/pickletools.py에서 :

numtopop = before.index(markobject)

이러한 사용법이 공통적으로 보이는 것은 제한된 크기의 목록에서 작동하는 것 같습니다 (O(n) list.index의 조회 시간으로 인해 중요 함). 파싱 ​​(및 유휴의 경우 UI).

유스 케이스가 있지만 매우 드문 경우입니다. 이 답변을 찾고 있다면 자신이 사용하고있는 것이 사용 사례에 맞는 언어로 제공되는 도구를 가장 직접적으로 사용하는지 자문 해보십시오.

Zip function이있는 모든 색인 :

get_indexes = lambda x, xs: [i for (y, i) in Zip(xs, range(len(xs))) if x == y]

print get_indexes(2, [1, 2, 3, 4, 5, 6, 3, 2, 3, 2])
print get_indexes('f', 'xsfhhttytffsafweef')

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

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]
>>>

Findindex 함수를 만들어 보자.

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

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

그리고 지금, 완전히 다른 무언가를 위해 ...

... 색인을 얻기 전에 품목의 존재를 확인하는 것과 같습니다. 이 방법의 좋은 점은 함수가 빈 목록 인 경우에도 항상 인덱스 목록을 반환한다는 것입니다. 문자열에서도 작동합니다.

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    retval = []
    last = 0
    while val in l[last:]:
            i = l[last:].index(val)
            retval.append(last + i)
            last += i + 1   
    return retval

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

대화 형 python 창에 붙여 넣은 경우 :

Python 2.7.6 (v2.7.6:3a1db0d2747e, Nov 10 2013, 00:42:54) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(the_list, val):
...     """Always returns a list containing the indices of val in the_list"""
...     retval = []
...     last = 0
...     while val in the_list[last:]:
...             i = the_list[last:].index(val)
...             retval.append(last + i)
...             last += i + 1   
...     return retval
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

최신 정보

또 다른 해의 헤드 다운 python 개발 후, 나는 원래의 대답에 약간 당황하여 레코드를 똑바로 설정하려면 위의 코드를 확실히 사용할 수 있습니다. 그러나 같은 동작을 얻는 많은 더 관용적 인 방법은 enumerate () 함수와 함께 목록 이해를 사용하는 것입니다.

이 같은:

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    return [index for index, value in enumerate(l) if value == val]

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

대화식 python 창에 붙여 넣으면 다음과 같은 결과가 나타납니다.

Python 2.7.14 |Anaconda, Inc.| (default, Dec  7 2017, 11:07:58) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(l, val):
...     """Always returns a list containing the indices of val in the_list"""
...     return [index for index, value in enumerate(l) if value == val]
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

그리고 이제이 질문과 모든 답변을 검토 한 후 이것이 FMc 자신의 이전 답변 에서 제안한 것과 정확히 일치한다는 것을 알았습니다. 처음 에이 질문에 대답했을 때, 나는 그것을 이해하지 못했기 때문에 그 대답조차 보지 못했습니다 . 좀 더 장황한 예가 이해를 돕기를 바랍니다.

위의 한 줄의 코드가 여전히 의미가 없다면 말이 안된다면 Google 'python list comprehension'을 추천하고 몇 분이 소요됩니다. 익숙해 지십시오. Python을 사용하여 코드를 개발하는 것을 즐겁게하는 많은 강력한 기능 중 하나 일뿐입니다.

간단히 갈 수 있습니다.

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']

res = [[x[0] for x in a].index(y) for y in b]

다른 옵션

>>> a = ['red', 'blue', 'green', 'red']
>>> b = 'red'
>>> offset = 0;
>>> indices = list()
>>> for i in range(a.count(b)):
...     indices.append(a.index(b,offset))
...     offset = indices[-1]+1
... 
>>> indices
[0, 3]
>>> 

FMc와 user7177의 답변에 대한 변형은 모든 항목에 대한 모든 색인을 반환 할 수있는 사전을 제공합니다.

>>> a = ['foo','bar','baz','bar','any', 'foo', 'much']
>>> l = dict(Zip(set(a), map(lambda y: [i for i,z in enumerate(a) if z is y ], set(a))))
>>> l['foo']
[0, 5]
>>> l ['much']
[6]
>>> l
{'baz': [2], 'foo': [0, 5], 'bar': [1, 3], 'any': [4], 'much': [6]}
>>> 

또한 하나의 항목에 대한 모든 인덱스를 얻기 위해 이것을 하나의 라이너로 사용할 수도 있습니다. lambda가 호출 된 횟수를 줄이기 위해 set (a)을 사용했지만 효율은 보장 할 수 없습니다.

이 솔루션은 다른 것만큼 강력하지는 않지만 초보자이고 forloops에 대해서만 알고 있다면 ValueError를 피하면서 항목의 첫 번째 인덱스를 찾을 수 있습니다.

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1

파이썬리스트는 0부터 시작하므로, 다음과 같이 Zip 내장 함수를 사용할 수 있습니다 :

>>> [i for i,j in Zip(range(len(haystack)), haystack) if j == 'needle' ]

여기서 "haystack"은 문제의 목록이고 "needle"은 찾을 항목입니다.

(참고 : 여기에서는 인덱스를 얻기 위해 i를 사용하여 반복하지만 항목으로 집중할 필요가있을 경우 j로 전환 할 수 있습니다.)

name ="bar"
list = [["foo", 1], ["bar", 2], ["baz", 3]]
new_list=[]
for item in list:
    new_list.append(item[0])
print(new_list)
try:
    location= new_list.index(name)
except:
    location=-1
print (location)

문자열이 목록에도없는 경우 목록에없는 경우 location = -1

목록에서 항목 x의 색인 찾기 L :

idx = L.index(x) if (x in L) else -1

목록에 색인을 확인해야하는 반복 항목이없는 경우 두 가지 가능성이 있습니다.

 eg: li=[10,20,30] # here need to get index of 20 means
     li.index(20) # will work properly because 20 is not repeated

그것의 반복되는 경우에 당신에게 첫번째 색인 만 줄 것이다

항목이있는 모든 색인을 가져와야하는 경우

eg: li=[10,20,30,20,40, 50, 10] # here need to get index of 20 means its have 2 index (1,3) 

당신이 그것을 할 필요가 있다는 것을 얻으려면

 li=[10,20,30,20,40, 50, 10]
 [i for i, e in enumerate(li) if e == 20]

그러면 [1,3]과 같은 o/p 인덱스 목록을 얻을 수 있습니다.

이것에 대한 더 기능적인 대답이 있습니다.

list(filter(lambda x: x[1]=="bar",enumerate(["foo", "bar", "baz", "bar", "baz", "bar", "a", "b", "c"])))

보다 일반적인 형식 :

def get_index_of(lst, element):
    return list(map(lambda x: x[0],\
       (list(filter(lambda x: x[1]==element, enumerate(lst))))))

항목을 찾지 못하면 Python index() 메서드가 오류를 발생시킵니다.

따라서 대신 항목을 찾을 수없는 경우 -1를 반환하는 JavaScript의 indexOf() 함수와 유사하게 만들 수 있습니다.

    try:
        index = array.index('search_keyword')
    except ValueError:
        index = -1

당신이 갖고있는 목록에 lst이라는 이름을 붙이자. 목록 lst을 numpy array로 변환 할 수 있습니다. 그런 다음 numpy.where 를 사용하여 목록에서 선택한 항목의 색인을 가져옵니다. 다음은이를 구현하는 방법입니다.

import numpy as np

lst = ["foo", "bar", "baz"]  #lst: : 'list' data type
print np.where( np.array(lst) == 'bar')[0][0]

>>> 1

@TerryA에 표시된 바와 같이, 많은 답변이 one index를 찾는 방법을 논의합니다.

more_itertools 는 반복 가능 코드 내에서 여러 인덱스를 찾을 수있는 도구가 포함 된 타사 라이브러리입니다.

주어진

import more_itertools as mit


iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]

코드

여러 관측의 색인을 찾으십시오.

list(mit.locate(iterable, lambda x: x == "bar"))
# [1, 5]

여러 항목 테스트 :

list(mit.locate(iterable, lambda x: x in {"bar", "ham"}))
# [1, 3, 5]

more_itertools.locate 옵션을 더 참조하십시오. > pip install more_itertools 를 통해 설치하십시오.

나 같은 다른 언어에서 오는 사람들을 위해, 아마도 간단한 루프를 사용하여 그것을 이해하고 사용하는 것이 더 쉽습니다.

mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
  if item == "bar":
    print(index, item)

나는감사합니다. 그래서 정확하게 열거합니까?. 그것은 나를 이해하는 것을 도왔다.

성능에 문제가있는 경우 :

수많은 답변에서 list.index(item) 메서드의 내장 메서드는 O(n)알고리즘이라고 언급되어 있습니다. 이 작업을 한 번 수행해야한다면 괜찮습니다. 그러나 요소 인덱스를 여러 번 액세스해야하는 경우 먼저 항목 - 인덱스 쌍의 사전 (O (n))을 만든 다음 O(1) 필요할 때마다.

목록의 항목이 반복되지 않는다고 확신하는 경우 다음을 쉽게 수행 할 수 있습니다.

myList = ["foo", "bar", "baz"]

# Create the dictionary
myDict = dict((e,i) for i,e in enumerate(myList))

# Lookup
myDict["bar"] # Returns 1
# myDict.get("blah") if you don't want an error to be raised if element not found.

요소가 중복되어 있고 모든 색인을 반환해야하는 경우 :

from collections import defaultdict as dd
myList = ["foo", "bar", "bar", "baz", "foo"]

# Create the dictionary
myDict = dd(list)
for i,e in enumerate(myList):
    myDict[e].append(i)

# Lookup
myDict["foo"] # Returns [0, 4]

사전을 사용하여 목록을 먼저 처리 한 다음 색인을 추가하십시오

from collections import defaultdict

index_dict = defaultdict(list)    
Word_list =  ['foo','bar','baz','bar','any', 'foo', 'much']

for Word_index in range(len(Word_list)) :
    index_dict[Word_list[Word_index]].append(Word_index)

Word_index_to_find = 'foo'       
print(index_dict[Word_index_to_find])

# output :  [0, 5]