给定一个列表[“foo”、“bar”、“baz”]和列表“bar”中的一个项，如何获取其索引1？
>>> ["foo", "bar", "baz"].index("bar")
1
有关列表的内置.index（）方法，请参阅文档：
list.index（x[，start[，end]]）返回值等于x的第一项列表中从零开始的索引。如果没有该项，则引发ValueError。可选参数start和end被解释为切片符号，用于将搜索限制在列表的特定子序列。返回的索引是相对于完整序列的开头而不是start参数计算的。
注意事项
列表长度的线性时间复杂性
索引调用按顺序检查列表中的每个元素，直到找到匹配项。如果列表很长，并且不能保证值会接近开始，这会降低代码的速度。
只有使用不同的数据结构才能完全避免这个问题。但是，如果已知元素在列表的某个部分内，则可以使用start和end参数来缩小搜索范围。
例如：
>>> 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
第二次调用速度快了几个数量级，因为它只需要搜索10个元素，而不是全部100万个元素。
仅返回第一个匹配项的索引
对索引的调用按顺序搜索列表，直到找到匹配项，然后停止。如果该值可能出现多次，并且需要所有索引，则索引无法解决问题：
>>> [1, 1].index(1) # the `1` index is not found.
0
相反，使用列表理解或生成器表达式进行搜索，使用enumerate获取索引：
>>> # A list comprehension gives a list of indices directly:
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> # A generator comprehension gives us an iterable object...
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> # which can be used in a `for` loop, or manually iterated with `next`:
>>> next(g)
0
>>> next(g)
2
如果只有一个匹配项，列表理解和生成器表达式技术仍然有效，并且更具通用性。
如果不匹配，则引发异常
如以上文档中所述，如果搜索的值不在列表中，则使用.index将引发异常：
>>> [1, 1].index(2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 2 is not in list
如果这是一个问题，请首先使用my_list中的项显式检查，或者根据需要使用try/except处理异常。
显式检查简单易读，但它必须再次迭代列表。参见Python中的EAFP原理是什么？以获取有关此选择的更多指导。
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"])
a = ["foo","bar","baz",'bar','any','much']
indexes = [index for index in range(len(a)) if a[index] == 'bar']
如果元素不在列表中，则会出现问题。此函数处理以下问题：
# 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
这里提出的所有函数都再现了固有的语言行为，但掩盖了正在发生的事情。
[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
如果语言提供了自己想要的方法，为什么要编写带有异常处理的函数？
简单地说，你可以
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]
>>>
大多数答案解释了如何找到一个索引，但如果项目多次出现在列表中，它们的方法不会返回多个索引。使用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
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）来减少lambda的调用次数，但并不能保证效率。
您必须设置一个条件，以检查正在搜索的元素是否在列表中
if 'your_element' in mylist:
print mylist.index('your_element')
else:
print None
现在，对于完全不同的事情。。。
……比如在获取索引之前确认项目的存在。这种方法的好处是，函数总是返回一个索引列表——即使它是一个空列表。它也适用于字符串。
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在其先前的回答中所建议的。在我最初回答这个问题的时候，我甚至没有看到这个答案，因为我不理解它。
如果上面的一行代码对您仍然没有意义，我强烈建议您使用谷歌“python列表理解”，并花几分钟时间熟悉一下。它只是众多强大功能中的一个，让使用Python开发代码成为一件乐事。
此解决方案不如其他解决方案强大，但如果您是初学者，只知道forloops，则仍有可能找到项目的第一个索引，同时避免ValueError：
def find_element(p,t):
i = 0
for e in p:
if e == t:
return i
else:
i +=1
return -1
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)
这说明了如果字符串不在列表中，如果它不在列表，则位置=-1
所有具有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')
如果需要所有索引，则可以使用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),)
这是一个清晰易读的解决方案。
获取列表中一个或多个（相同）项的所有出现次数和位置
使用enumerate（list），您可以存储第一个元素（n），当元素x等于您查找的值时，该元素是列表的索引。
>>> 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
由于Python列表是基于零的，我们可以使用zip内置函数，如下所示：
>>> [i for i,j in zip(range(len(haystack)), haystack) if j == 'needle' ]
其中“干草堆”是问题列表，“针”是要查找的项目。
（注意：这里我们使用i进行迭代以获取索引，但如果我们需要关注项，我们可以切换到j。）
在Python中查找给定列表中包含项的索引对于列表[“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
这样做的缺点是，您可能需要检查返回的值是否为None：
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]
是的，你也可以将列表理解与enumerate一起使用，但在我看来，这并不是那么优雅——你在Python中进行等式测试，而不是让用C编写的内置代码来处理：
>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]
这是XY问题吗？
XY问题是询问您尝试的解决方案，而不是实际问题。
为什么您认为需要列表中给定元素的索引？
如果你已经知道它的价值，为什么你会在意它在列表中的位置？
如果值不存在，则捕获ValueError相当冗长，我更希望避免这种情况。
无论如何，我通常都会遍历列表，所以我通常会保留一个指向任何有趣信息的指针，用enumerate获取索引。
如果你在处理数据，你可能应该使用panda，它的工具比我展示的纯Python解决方案要优雅得多。
我不记得自己需要list.index。然而，我已经浏览了Python标准库，并看到了它的一些优秀用途。
它在idlelib中有很多用途，用于GUI和文本解析。
关键字模块使用它在模块中查找注释标记，以通过元编程自动重新生成其中的关键字列表。
在Lib/mailbox.py中，它似乎像有序映射一样使用它：
key_list[key_list.index(old)] = new
and
del key_list[key_list.index(key)]
在Lib/html/cookiejar.py中，似乎用于获取下一个月：
mon = MONTHS_LOWER.index(mon.lower())+1
在Lib/tarfile.py中，类似于distutils，获取一个项目的切片：
members = members[:members.index(tarinfo)]
在Lib/pickletools.py中：
numtopop = before.index(markobject)
这些用法的共同点是，它们似乎对大小受限的列表进行操作（这一点很重要，因为list.index的查找时间为O（n）），并且它们主要用于解析（在Idle的情况下为UI）。
虽然有它的用例，但它们相当罕见。如果您发现自己正在寻找这个答案，请问问自己，您所做的是否是该语言为您的用例提供的工具的最直接使用。
对于像我这样来自另一种语言的人来说，也许通过一个简单的循环，更容易理解和使用它：
mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
if item == "bar":
print(index, item)
我很感激，所以枚举到底做什么？。这帮助我理解了。
如果找不到项，Python index（）方法将抛出错误。因此，您可以将其设置为类似于JavaScript的indexOf（）函数，如果未找到项，则返回-1：
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))))))
如果性能令人担忧：
在许多答案中都提到，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所指出的，许多答案讨论了如何找到一个索引。
moreintertools是一个第三方库，它提供了在可迭代文件中查找多个索引的工具。
鉴于
import more_itertools as mit
iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]
Code
查找多个观测值的索引：
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安装。
让我们给你的名单起个名字。可以将列表lst转换为numpy数组。然后，使用numpy.where获取列表中所选项目的索引。以下是您将实施它的方式。
import numpy as np
lst = ["foo", "bar", "baz"] #lst: : 'list' data type
print np.where( np.array(lst) == 'bar')[0][0]
>>> 1
使用字典，首先处理列表，然后将索引添加到其中
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]
如果你想找到一个索引，那么使用“index”方法就可以了。然而，如果您要多次搜索数据，那么我建议使用平分模块。请记住，使用平分模块数据必须进行排序。因此，您对数据进行一次排序，然后可以使用二等分。在我的机器上使用平分模块比使用索引方法快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
对于一个可比的
# 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()]
该值可能不存在，因此为了避免此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")
它只使用python函数array.index（）和简单的Try/Except，如果在列表中找到记录，则返回该记录的位置，如果没有在列表中发现，则返回-1（就像在JavaScript中使用函数indexOf（））。
fruits = ['apple', 'banana', 'cherry']
try:
pos = fruits.index("mango")
except:
pos = -1
在这种情况下，“mango”不在列表水果中，因此pos变量为-1，如果我搜索了“cherry”，pos变量将为2。
简单选项：
a = ["foo", "bar", "baz"]
[i for i in range(len(a)) if a[i].find("bar") != -1]
我发现这两种解决方案更好，我自己尝试过
>>> expences = [2200, 2350, 2600, 2130, 2190]
>>> 2000 in expences
False
>>> expences.index(2200)
0
>>> expences.index(2350)
1
>>> index = expences.index(2350)
>>> expences[index]
2350
>>> try:
... print(expences.index(2100))
... except ValueError as e:
... print(e)
...
2100 is not in list
>>>
Python方式将使用enumerate，但您也可以使用来自运算符模块的indexOf。请注意，如果b不在a中，这将引发ValueError。
>>> from operator import indexOf
>>>
>>>
>>> help(indexOf)
Help on built-in function indexOf in module _operator:
indexOf(a, b, /)
Return the first index of b in a.
>>>
>>>
>>> indexOf(("foo", "bar", "baz"), "bar") # with tuple
1
>>> indexOf(["foo", "bar", "baz"], "bar") # with list
1
python中的某些结构包含一个索引方法，可以很好地解决这个问题。
'oi tchau'.index('oi') # 0
['oi','tchau'].index('oi') # 0
('oi','tchau').index('oi') # 0
参考文献：
在列表中
在元组中
字符串中
text = ["foo", "bar", "baz"]
target = "bar"
[index for index, value in enumerate(text) if value == target]
对于一个小的元素列表，这会很好。但是，如果列表包含大量元素，最好应用二进制运行时复杂度为O（logn）的搜索.
下面是使用Python的index（）函数的两行代码：
LIST = ['foo' ,'boo', 'shoo']
print(LIST.index('boo'))
输出：1
在查找列表中项目的索引时，列表理解将是获得紧凑实现的最佳选择。
a_list = ["a", "b", "a"]
print([index for (index , item) in enumerate(a_list) if item == "a"])
可以使用zip（）函数获取列表中值的索引。代码可以是：；
list1 = ["foo","bar","baz"]
for index,value in zip(range(0,len(list1)),list1):
if value == "bar":
print(index)
请尝试以下代码：
["foo", "bar", "baz"].index("bar")
参考：https://www.programiz.com/python-programming/methods/list/index
不要。如果您确实需要，请使用列表中的.index（item…）方法。然而，这需要线性的时间，如果你发现自己正在努力，你可能会滥用列表来做一些你不应该做的事情。
最有可能的是，您关心1）整数和项目之间的双向映射，或2）在已排序的项目列表中查找项目。
对于第一个，使用一对字典。如果您需要一个库来实现这一点，请使用双向库。
对于第二个，使用可以正确利用列表排序这一事实的方法。使用python中内置的平分模块。
如果您希望在排序列表中插入项目，也不应使用排序列表。使用内置的heapq模块或使用sortedcontainers库将已排序的需求弱化为堆。
使用一个不是为你想做的事情而设计的数据结构是不好的做法。使用一个与你给它的任务相匹配的数据结构，既会向读者传达你想做特定的事情，也会使你的解决方案在实践中更快/更具可扩展性。
python中的一个简单解决方案：
li1=["foo","bar","baz"]
for i in range(len(li1)):
if li1[i]=="bar":
print(i)
列表元素的数据类型无关紧要。只需将“bar”替换为您要查找的元素。我们还可以为此编写一个函数：
def indexfinder(element,lis):
for i in range(len(lis)):
if lis[i]==element:
return i
