목록 ["foo", "bar", "baz"]과 목록 에 항목이 주어지면 파이썬에서 "bar"색인 ( 1)을 어떻게 얻 습니까?

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

참조 : 데이터 구조> 목록에 대한 추가 정보

주의 사항

참고이 아마도 질문에 대답 할 수있는 가장 깨끗한 방법입니다 동안 것을 요청하면서 , index의 다소 약한 구성 요소 listAPI, 그리고 내가 분노를 마지막으로 사용한 시간을 기억할 수 없습니다. 이 답변이 많이 언급 되었기 때문에 더 완벽하게 작성해야한다는 의견에서 나에게 지적되었습니다. list.index다음과 같은 몇 가지주의 사항이 있습니다. 처음에는 문서를 살펴볼 가치가 있습니다.

list.index(x[, start[, end]])

값이 x 인 첫 번째 항목의 목록에서 0부터 시작하는 인덱스를 반환합니다 . ValueError해당 항목이 없으면 a를 발생시킵니다.

선택적 인수 start 및 end 는 슬라이스 표기법에서 와 같이 해석되며 검색을 목록의 특정 하위 시퀀스로 제한하는 데 사용됩니다. 반환 된 인덱스는 시작 인수가 아닌 전체 시퀀스의 시작을 기준으로 계산됩니다.

리스트 길이의 선형 시간 복잡성

index이 일치하는 항목을 찾을 때까지 호출 순서대로 목록의 모든 요소를 확인합니다. 목록이 길고 목록의 대략적인 위치를 모르면이 검색에 병목 현상이 발생할 수 있습니다. 이 경우 다른 데이터 구조를 고려해야합니다. 일치하는 위치를 대략 알면 index힌트를 줄 수 있습니다 . 예를 들어,이 스 니펫에서는 l.index(999_999, 999_990, 1_000_000)straight보다 약 5 배 빠릅니다 l.index(999_999). 전자는 10 개의 항목 만 검색하고 후자는 백만을 검색하기 때문입니다.

>>> import timeit
>>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000)
9.356267921015387
>>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000)
0.0004404920036904514

인수 와 일치 하는 첫 번째 색인 만 리턴합니다.

index일치하는 항목을 찾을 때까지 목록을 순서대로 검색하여 호출합니다 . 일치하는 인덱스가 더 필요할 것으로 예상되는 경우 목록 이해 또는 생성기 표현식을 사용해야합니다.

>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2

한 번 사용했던 대부분의 장소는 index이제 더 포괄적이기 때문에 목록 이해 또는 생성기 표현을 사용합니다. 에 도달하는 것을 고려하고 있다면 index이러한 훌륭한 Python 기능을 살펴보십시오.

요소가리스트에없는 경우 발생

항목이없는 경우 호출하면 index결과가 ValueError나타납니다.

>>> [1, 1].index(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 2 is not in list

항목이 목록에 없을 수 있으면

1. item in my_list(깨끗하고 읽기 쉬운 접근 방식)으로 먼저 확인 하거나
2. 잡는 블록으로 index통화를 감싸십시오 (적어도 검색 할 목록이 길고 항목이있는 경우 더 빠름).try/exceptValueError

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

>>> 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()첫 번째 인덱스 값을 반환합니다 !

| 색인 (...)
| L.index (value, [start, [stop]])-> integer-첫 번째 인덱스 값을 반환

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없음을 확인할 수 있다는 것입니다 .

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

목록에서 둘 이상의 값

더 많은 항목이있을 수있는 경우 다음을 통해 완전한 정보를 얻을 수 없습니다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')

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

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

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

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

이것은 XY 문제 입니까?

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

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

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

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

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

데이터를 녹이는 경우 팬더를 사용해야 할 것입니다. 팬더는 내가 보여준 순수한 Python 해결 방법보다 훨씬 더 우아한 도구를 가지고 있습니다.

나는 list.index나 자신이 필요하다는 것을 기억하지 못한다 . 그러나 나는 파이썬 표준 라이브러리를 살펴 보았고 그것을 훌륭하게 사용하는 것을 보았습니다.

idlelibGUI 및 텍스트 구문 분석 에는 여러 가지 용도가 있습니다 .

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함수 가있는 모든 인덱스 :

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

간단히 당신은 함께 갈 수 있습니다

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

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

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

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

최신 정보

또 다른 해의 헤드 다운 파이썬 개발 후, 나는 원래의 대답에 약간 당황 스럽습니다. 그래서 레코드를 똑바로 설정하려면 위의 코드를 확실히 사용할 수 있습니다. 그러나 동일한 동작을 얻는 훨씬 더 관용적 인 방법은 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 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'을 강력히 추천하고 몇 분 동안 익숙해 지십시오. 파이썬을 사용하여 코드를 개발하는 것을 즐겁게 만드는 많은 강력한 기능 중 하나 일뿐입니다.

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

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

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

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

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

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

idx = L.index(x) if (x in L) else -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

index()항목을 찾지 못하면 Python 메소드에서 오류가 발생합니다. 따라서 대신 항목을 찾을 수없는 경우 indexOf()반환 -1되는 JavaScript 함수 와 유사하게 만들 수 있습니다 .

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

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

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

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

나와 같은 다른 언어를 사용하는 사람들은 간단한 루프를 사용하여 이해하고 사용하기가 더 쉽습니다.

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

감사합니다. 열거 형은 정확히 무엇을합니까? . 그것은 내가 이해하는 데 도움이되었다.

인덱스를 한 번 찾으려면 "index"방법을 사용하는 것이 좋습니다. 그러나 데이터를 두 번 이상 검색하려면 bisect 모듈을 사용하는 것이 좋습니다 . bisect 모듈 데이터를 사용하여 정렬해야합니다. 따라서 데이터를 한 번 정렬하면 bisect를 사용할 수 있습니다. 사용 양분 내 컴퓨터에서 모듈은 빠른 인덱스 방법을 사용하는 것보다 20 배에 관한 것입니다.

다음은 Python 3.8 이상의 구문을 사용하는 코드의 예입니다.

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      index 
      if (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value else -1
    )

data = list(range(1000))
# value to search
value = 666

# times to test
ttt = 1000

t1 = timeit(lambda: data.index(value), number=ttt)
t2 = timeit(lambda: bisect_search(data, value), number=ttt)

print(f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

산출:

t1=0.0400, t2=0.0020, diffs t1/t2=19.60

성능이 우려되는 경우 :

내장 된 메소드 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]

@TerryA에서 알 수 있듯이 많은 답변에서 하나의 색인 을 찾는 방법에 대해 논의합니다 .

more_itertoolsiterable 내에서 여러 인덱스 를 찾는 도구가있는 써드 파티 라이브러리입니다 .

주어진

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.

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

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]

내 생각에 ["foo", "bar", "baz"].index("bar")"bar"가 사전에 ValueError없으면 제기 되어 있기 때문에 충분하지만 충분하지 않습니다! 이 기능을 사용할 수 있습니다.

def find_index(arr, name):
    try:
        return arr.index(name)
    except ValueError:
        return -1

if __name__ == '__main__':
    print(find_index(["foo", "bar", "baz"], "bar"))

결과는 다음과 같습니다.

1

이름이 arr에 없으면 함수는 -1을 반환합니다.

print (find_index ([ "foo", "bar", "baz"], "fooo"))

-1