65

Python 的列表类型有一个 index() 方法，该方法接受一个参数并返回列表中与该参数匹配的第一项的索引。例如：

>>> some_list = ["apple", "pear", "banana", "grape"]
>>> some_list.index("pear")
1
>>> some_list.index("grape")
3

有没有一种优雅的（惯用的）方法可以将其扩展到复杂对象的列表，比如元组？理想情况下，我希望能够做这样的事情：

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> some_list.getIndexOfTuple(1, 7)
1
>>> some_list.getIndexOfTuple(0, "kumquat")
2

getIndexOfTuple() 只是一个假设的方法，它接受一个子索引和一个值，然后返回具有该子索引处给定值的列表项的索引。我希望

是否有某种方法可以使用列表推导或lambas 或类似的“内联”方法来实现该一般结果？我想我可以编写自己的类和方法，但如果 Python 已经有办法做到这一点，我不想重新发明轮子。

4

12 回答 12

77

这个怎么样？

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> [x for x, y in enumerate(tuple_list) if y[1] == 7]
[1]
>>> [x for x, y in enumerate(tuple_list) if y[0] == 'kumquat']
[2]

正如评论中指出的那样，这将获得所有匹配项。要获得第一个，您可以执行以下操作：

>>> [y[0] for y in tuple_list].index('kumquat')
2

评论中对发布的所有解决方案之间的速度差异进行了很好的讨论。我可能有点偏见，但我个人会坚持单线，因为我们谈论的速度与为这个问题创建函数和导入模块相比是微不足道的，但如果你打算这样做到非常大的数量您可能想要查看提供的其他答案的元素，因为它们比我提供的更快。

于 2009-06-03T20:07:23.743 回答
28

一段时间后，这些列表理解变得混乱。

我喜欢这种 Pythonic 方法：

from operator import itemgetter

def collect(l, index):
   return map(itemgetter(index), l)

# And now you can write this:
collect(tuple_list,0).index("cherry")   # = 1
collect(tuple_list,1).index("3")        # = 2

如果您需要您的代码都具有超级性能：

# Stops iterating through the list as soon as it finds the value
def getIndexOfTuple(l, index, value):
    for pos,t in enumerate(l):
        if t[index] == value:
            return pos

    # Matches behavior of list.index
    raise ValueError("list.index(x): x not in list")

getIndexOfTuple(tuple_list, 0, "cherry")   # = 1
于 2009-06-03T20:54:10.513 回答
11

一种可能性是使用模块中的itemgetter函数operator：

import operator

f = operator.itemgetter(0)
print map(f, tuple_list).index("cherry") # yields 1

调用返回一个函数，该函数将对传递给它的任何内容itemgetter执行等效的操作。foo[0]使用map，然后将该函数应用于每个元组，将信息提取到一个新列表中，然后您index可以正常调用该列表。

map(f, tuple_list)

相当于：

[f(tuple_list[0]), f(tuple_list[1]), ...etc]

这又相当于：

[tuple_list[0][0], tuple_list[1][0], tuple_list[2][0]]

这使：

["pineapple", "cherry", ...etc]
于 2009-06-03T20:12:28.133 回答
8

您可以使用列表理解和 index() 来做到这一点

tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
[x[0] for x in tuple_list].index("kumquat")
2
[x[1] for x in tuple_list].index(7)
1
于 2009-06-03T20:50:48.290 回答
6

受这个问题的启发，我发现这很优雅：

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> next(i for i, t in enumerate(tuple_list) if t[1] == 7)
1
>>> next(i for i, t in enumerate(tuple_list) if t[0] == "kumquat")
2
于 2016-02-17T01:49:51.797 回答
2

我会把它作为对 Triptych 的评论，但由于缺乏评级，我还不能发表评论：

使用枚举器方法匹配元组列表中的子索引。例如

li = [(1,2,3,4), (11,22,33,44), (111,222,333,444), ('a','b','c','d'),
        ('aa','bb','cc','dd'), ('aaa','bbb','ccc','ddd')]

# want pos of item having [22,44] in positions 1 and 3:

def getIndexOfTupleWithIndices(li, indices, vals):

    # if index is a tuple of subindices to match against:
    for pos,k in enumerate(li):
        match = True
        for i in indices:
            if k[i] != vals[i]:
                match = False
                break;
        if (match):
            return pos

    # Matches behavior of list.index
    raise ValueError("list.index(x): x not in list")

idx = [1,3]
vals = [22,44]
print getIndexOfTupleWithIndices(li,idx,vals)    # = 1
idx = [0,1]
vals = ['a','b']
print getIndexOfTupleWithIndices(li,idx,vals)    # = 3
idx = [2,1]
vals = ['cc','bb']
print getIndexOfTupleWithIndices(li,idx,vals)    # = 4
于 2011-07-27T20:02:43.993 回答
1

好的，这可能是一个错误vals(j)，更正是：

def getIndex(li,indices,vals):
for pos,k in enumerate(lista):
    match = True
    for i in indices:
        if k[i] != vals[indices.index(i)]:
            match = False
            break
    if(match):
        return pos
于 2012-06-19T17:38:27.873 回答
1 
z = list(zip(*tuple_list))
z[1][z[0].index('persimon')]
于 2013-01-16T17:19:20.830 回答
0 
tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]

def eachtuple(tupple, pos1, val):
    for e in tupple:
        if e == val:
            return True

for e in tuple_list:
    if eachtuple(e, 1, 7) is True:
        print tuple_list.index(e)

for e in tuple_list:
    if eachtuple(e, 0, "kumquat") is True:
        print tuple_list.index(e)
于 2012-10-16T16:44:44.717 回答
0

这也可以使用 Lambda 表达式：

l = [('rana', 1, 1), ('pato', 1, 1), ('perro', 1, 1)]
map(lambda x:x[0], l).index("pato") # returns 1
编辑以添加示例：
l=[['rana', 1, 1], ['pato', 2, 1], ['perro', 1, 1], ['pato', 2, 2], ['pato', 2, 2]]

按条件提取所有项目：

filter(lambda x:x[0]=="pato", l) #[['pato', 2, 1], ['pato', 2, 2], ['pato', 2, 2]]

使用索引按条件提取所有项目：

>>> filter(lambda x:x[1][0]=="pato", enumerate(l))
[(1, ['pato', 2, 1]), (3, ['pato', 2, 2]), (4, ['pato', 2, 2])]
>>> map(lambda x:x[1],_)
[['pato', 2, 1], ['pato', 2, 2], ['pato', 2, 2]]

注意：该_变量仅在交互式解释器中有效。更一般地，必须明确分配_，即_=filter(lambda x:x[1][0]=="pato", enumerate(l))。

于 2016-05-04T08:21:41.610 回答
0

Python 的 list.index(x) 返回列表中第一次出现 x 的索引。所以我们可以通过列表压缩返回的对象来获取它们的索引。

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> [tuple_list.index(t) for t in tuple_list if t[1] == 7]
[1]
>>> [tuple_list.index(t) for t in tuple_list if t[0] == 'kumquat']
[2]

使用同一行，我们还可以在有多个匹配元素的情况下获取索引列表。

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11), ("banana", 7)]
>>> [tuple_list.index(t) for t in tuple_list if t[1] == 7]
[1, 4]
于 2017-06-09T01:54:40.320 回答
0

我想以下不是最好的方法（速度和优雅问题），但它可能会有所帮助：

from collections import OrderedDict as od
t = [('pineapple', 5), ('cherry', 7), ('kumquat', 3), ('plum', 11)]
list(od(t).keys()).index('kumquat')
2
list(od(t).values()).index(7)
7
# bonus :
od(t)['kumquat']
3

有 2 个成员的元组列表可以直接转换为有序 dict，数据结构实际上是相同的，所以我们可以即时使用 dict 方法。

于 2018-07-23T01:45:12.433 回答