목록에서 항목의 인덱스 찾기

질문자 :Eugene M

["foo", "bar", "baz"] "bar" 의 항목이 주어지면 Python에서 인덱스( 1

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

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

주의 사항은 다음과 같습니다.

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

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

값이 x 와 같은 첫 번째 항목의 목록에서 0부터 시작하는 인덱스를 반환합니다. 그러한 항목이 없으면 ValueError

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

목록 길이의 선형 시간 복잡도

index 호출은 일치하는 항목을 찾을 때까지 목록의 모든 요소를 순서대로 확인합니다. 목록이 길고 목록의 어디에서 발생하는지 대략 모르는 경우 이 검색이 병목 현상이 될 수 있습니다. 이 경우 다른 데이터 구조를 고려해야 합니다. 일치 항목을 찾을 위치를 대략적으로 알고 있다면 index 에 힌트를 줄 수 있습니다. 예를 들어, 이 스니펫에서 l.index(999_999, 999_990, 1_000_000) l.index(999_999) 보다 대략 5배 더 빠릅니다. 왜냐하면 전자는 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 기능을 살펴보십시오.

요소가 목록에 없으면 throw

항목이 없는 경우 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. ValueError 를 포착 try/except index 호출을 래핑합니다(적어도 검색할 목록이 길고 항목이 일반적으로 존재할 때 더 빠를 것입니다.)

Alex Coventry

Python 학습에 정말 도움이 되는 한 가지는 대화형 도움말 기능을 사용하는 것입니다.

 >>> help(["foo", "bar", "baz"]) Help on list object: class list(object) ... | | index(...) | L.index(value, [start, [stop]]) -> integer -- return first index of value |

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

davidavr

대부분의 답변은 단일 인덱스 를 찾는 방법을 설명하지만 항목이 목록에 여러 번 있는 경우 해당 메서드는 여러 인덱스를 반환하지 않습니다. 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() 사용하는 또 다른 작은 솔루션입니다(enumerate와 거의 동일한 접근 방식).

 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

TerryA

모든 인덱스를 가져오려면:

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

FMc

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

HongboZhu

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

 # 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

tanzil

a = ["foo","bar","baz",'bar','any','much'] indexes = [index for index in range(len(a)) if a[index] == 'bar']

savinson

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

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

user3670684

모든 인덱스를 원하면 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),)

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

rbrisuda

여기에 제안된 모든 기능은 고유한 언어 동작을 재현하지만 무슨 일이 일어나고 있는지 모호합니다.

 [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

언어가 스스로 원하는 것을 수행할 수 있는 메서드를 제공하는 경우 예외 처리 기능을 사용하여 함수를 작성하는 이유는 무엇입니까?

Graham Giller

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

목록 ["foo", "bar", "baz"] 및 목록 "bar" 항목의 경우 Python에서 인덱스(1)를 얻는 가장 깔끔한 방법은 무엇입니까?

음, 물론 첫 번째 항목의 인덱스를 반환하는 인덱스 메서드가 있습니다.

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

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

 >>> 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 해결 방법보다 훨씬 더 우아한 도구가 있는 pandas를 사용해야 할 것입니다.

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)

이러한 사용법의 공통점은 제한된 크기의 목록에서 작동하는 것으로 보이며( list.index 대한 O(n) 조회 시간 때문에 중요), 대부분 구문 분석(및 UI의 경우 UI)에 사용됩니다. 게으른).

사용 사례가 있지만 상당히 드뭅니다. 이 답변을 찾고 있다면 현재 하고 있는 작업이 사용 사례에 대해 해당 언어에서 제공하는 도구를 가장 직접적으로 사용하는 것인지 자문해 보십시오.

Aaron Hall

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

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

PythonProgrammi

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

Arnaldo P. Figueira Figueira

단순히 당신과 함께 갈 수 있습니다

 a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']] b = ['phone', 'lost'] res = [[x[0] for x in a].index(y) for y in b]

kiriloff

다른 옵션

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

Mathitis2Software

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

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

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

업데이트

또 다른 1년 동안의 파이썬 개발이 끝난 후, 저는 제 원래의 대답에 약간 당황했습니다. 그래서 기록을 바로 세우려면 위의 코드를 확실히 사용할 수 있습니다. 그러나 동일한 동작을 얻는 훨씬 관용적인 방법은 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'을 적극 권장하고 몇 분 정도 시간을 내어 익숙해질 수 있습니다. Python을 사용하여 코드를 개발하는 것을 즐겁게 만드는 많은 강력한 기능 중 하나일 뿐입니다.

MrWonderful

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

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

bvanlew

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

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

Ketan

이 솔루션은 다른 솔루션만큼 강력하지는 않지만 초보자이고 for 루프만 알고 있다면 ValueError를 피하면서 항목의 첫 번째 인덱스를 찾는 것이 여전히 가능합니다.

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

dylankb

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

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

Hamed Baatour

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

Coder123

해당 값이 존재하지 않을 가능성이 있으므로 이 ValueError를 피하기 위해 목록에 실제로 존재하는지 확인할 수 있습니다.

 list = ["foo", "bar", "baz"] item_to_find = "foo" if item_to_find in list: index = list.index(item_to_find) print("Index of the item is " + str(index)) else: print("That word does not exist")

Badri Paudel

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

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

Ankit Gupta

Python 목록은 0부터 시작하므로 다음과 같이 zip 내장 함수를 사용할 수 있습니다.

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

여기서 "haystack"은 해당 목록이고 "needle"은 찾을 항목입니다.

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

jihed gasmi

하나의 비교 대상에 대해

 # Throws ValueError if nothing is found some_list = ['foo', 'bar', 'baz'].index('baz') # some_list == 2

사용자 정의 술어

 some_list = [item1, item2, item3] # Throws StopIteration if nothing is found # *unless* you provide a second parameter to `next` index_of_value_you_like = next( i for i, item in enumerate(some_list) if item.matches_your_criteria())

술어로 모든 항목의 색인 찾기

 index_of_staff_members = [ i for i, user in enumerate(users) if user.is_staff()]

Caveman

인덱스를 한 번 찾으려면 "색인" 방법을 사용하는 것이 좋습니다. 그러나 데이터를 두 번 이상 검색하려면 bisect 모듈을 사용하는 것이 좋습니다. 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

Vlad Bezden

저와 같은 다른 언어에서 온 사람들의 경우 간단한 루프로 이해하고 사용하는 것이 더 쉽습니다.

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

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

mpoletto

가지고 있는 목록에 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

Siddharth Satpathy

그것은 단지 python 함수 array.index() 를 사용하고 간단한 Try/except와 함께 목록에서 발견되면 레코드의 위치를 반환하고 목록에서 찾을 수 없으면 -1을 반환합니다(예: JavaScript에서 함수 indexOf() ).

 fruits = ['apple', 'banana', 'cherry'] try: pos = fruits.index("mango") except: pos = -1

이 경우 "mango"는 목록 fruits 없으므로 pos 변수는 -1입니다. "cherry"를 검색한 경우 pos 변수는 2가 됩니다.

Giacomo Casadei

성능이 우려되는 경우:

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]

FatihAkici

출처 : http:www.stackoverflow.com/questions/176918/finding-the-index-of-an-item-in-a-list