查找列表中项目的索引

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

参考：Data Structures > More on Lists

警告如下

请注意，虽然这可能是回答问题的最简洁的方法按要求，但 index 是 list API 的一个相当薄弱的组件，我不记得我上次使用它是什么时候了在愤怒中。评论中已向我指出，由于此答案被大量引用，因此应使其更加完整。以下是关于 list.index 的一些注意事项。最初可能值得看一下它的文档：

list.index(x[, start[, end]]) 返回值等于 x 的第一项的列表中从零开始的索引。如果没有此类项目，则引发 ValueError。可选参数 start 和 end 被解释为切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于完整序列的开头而不是 start 参数计算的。

列表长度的线性时间复杂度

index 调用按顺序检查列表的每个元素，直到找到匹配项。如果您的列表很长，并且您不知道它在列表中的大致位置，则此搜索可能会成为瓶颈。在这种情况下，您应该考虑不同的数据结构。请注意，如果您大致知道在哪里可以找到匹配项，您可以给 index 一个提示。例如，在这个片段中，l.index(999_999, 999_990, 1_000_000) 比直接 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

如果该项目可能不在列表中，您应该

首先使用 my_list 中的项目检查它（干净，可读的方法），或者将索引调用包装在捕获 ValueError 的 try/except 块中（可能更快，至少当要搜索的列表很长并且项目通常存在时。 )

---

对学习 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() 的小解决方案（这与 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

---

获取所有索引：

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

---

如果您想要所有索引，则可以使用 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),)

这是清晰易读的解决方案。

---

这里提出的所有功能都重现了固有的语言行为，但掩盖了正在发生的事情。

[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

如果语言提供了执行您想要的方法的方法，为什么还要编写带有异常处理的函数？

---

在 Python 中查找给定包含它的列表的项目的索引对于列表 [“foo”、“bar”、“baz”] 和列表“bar”中的项目，获取其索引的最简洁方法是什么 (1)在 Python 中？

好吧，当然，有 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)

列表中有多个值

如果出现更多次，您将不会通过 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)

使用 pandas 更好地处理数据

如果您有 pandas，您可以使用 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 相当冗长 - 我更愿意避免这种情况。

无论如何，我通常会遍历列表，所以我通常会保留指向任何有趣信息的指针，获取 index with enumerate.

如果您正在处理数据，您可能应该使用 pandas - 它拥有比我展示的纯 Python 解决方法更优雅的工具。

我自己不记得需要list.index。但是，我浏览了 Python 标准库，发现它有一些出色的用途。

在 idlelib 中有很多很多用途，用于 GUI 和文本解析。

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

在 Lib/tarfile.py 中，类似于 distutils 来获得一个项目的切片：

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

在 Lib/pickletools.py 中：

numtopop = before.index(markobject)

这些用法的共同点似乎是它们似乎在限制大小的列表上运行（很重要，因为 list.index 的 O(n) 查找时间），并且它们主要用于解析（以及 UI 在闲置的）。

虽然有它的用例，但它们并不常见。如果您发现自己正在寻找这个答案，请问问自己，您所做的是否是该语言为您的用例提供的工具的最直接使用。

---

获取列表中一个或多个（相同）项目的所有出现和位置

使用 enumerate(alist) 您可以存储第一个元素 (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

---

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

---

简单地你可以去

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

---

me = ["foo", "bar", "baz"]
me.index("bar") 

您可以将此应用于列表的任何成员以获取他们的索引

---

而现在，为了完全不同的东西......

...就像在获取索引之前确认项目的存在。这种方法的好处是该函数总是返回一个索引列表——即使它是一个空列表。它也适用于字符串。

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 在他的 earlier answer 中所建议的。在我最初回答这个问题时，我什至没有看到那个答案，因为我不明白。我希望我更详细的示例将有助于理解。

如果上面的单行代码对您来说仍然没有意义，我强烈建议您谷歌“python 列表理解”并花几分钟时间熟悉一下。它只是使使用 Python 开发代码成为一种乐趣的众多强大功能之一。

---

来自 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 的次数，但不能保证效率。

---

我的朋友，我已经制作了最简单的代码来解决你的问题。当您收到大量代码时，我在这里为您提供两行代码，这一切都归功于 python 中 index() 函数的帮助。

LIST = ['foo' ,'boo', 'shoo']
print(LIST.index('boo'))

输出：

1

我希望我给了你最好和最简单的答案，这可能会对你有很大帮助。

---

查找列表 L 中项目 x 的索引：

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

---

此解决方案不如其他解决方案强大，但如果您是初学者并且只了解for循环，仍然可以在避免 ValueError 的同时找到项目的第一个索引：

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

---

有可能该值可能不存在，因此为了避免此 ValueError，我们可以检查该值是否确实存在于 list 中。

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 中使用函数 { 2}）。

fruits = ['apple', 'banana', 'cherry']

try:
  pos = fruits.index("mango")
except:
  pos = -1

在这种情况下，列表 fruits 中不存在“mango”，因此 pos 变量为 -1，如果我搜索“cherry”，pos 变量将为 2。

---

对此有一个更实用的答案。

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() 方法会引发错误。因此，您可以使其类似于 JavaScript 的 indexOf() 函数，如果未找到该项目，则返回 -1：

try:
    index = array.index('search_keyword')
except ValueError:
    index = -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)

这说明字符串是否也在列表中，如果它不在列表中，则 location = -1

---

对于一个可比的

# 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()]

---

列表理解将是在查找列表中项目的索引时获得紧凑实现的最佳选择。

a_list = ["a", "b", "a"]
print([index for (index , item) in enumerate(a_list) if item == "a"])

---

由于 Python 列表是从零开始的，我们可以使用 zip 内置函数，如下所示：

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

其中“haystack”是有问题的列表，“needle”是要查找的项目。

（注意：这里我们使用 i 进行迭代以获取索引，但如果我们需要专注于项目，我们可以切换到 j。）

---

如果关注性能：

在许多答案中都提到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]

---