我喜欢 wim's 和 Ignacio's answers。然而，我认为 itertools 提供了一个稍微更具可读性的替代方案，尽管是lambda。(对于Python3；对于Python2，使用 xrange 而不是 range )。

>>> from itertools import dropwhile
>>> l = list('apples')
>>> l.index('p')
>>> next(dropwhile(lambda x: l[x] != 'p', reversed(range(len(l)))))
2

如果未找到该项，这将引发 StopIteration 异常；您可以捕获该异常并引发 ValueError ，以使其行为为 just like index 。

定义为函数，避免使用 lambda 快捷方式：

def rindex(lst, item):
    def index_ne(x):
        return lst[x] != item
        return next(dropwhile(index_ne, reversed(range(len(lst)))))
    except StopIteration:
        raise ValueError("rindex(lst, item): item not in list")

它也适用于非字符。测试结果：

>>> rindex(['apples', 'oranges', 'bananas', 'apples'], 'apples')
3

许多其他的解决方案都需要遍历整个列表。这不是问题。

def find_last(lst, elm):
  gen = (len(lst) - 1 - i for i, v in enumerate(reversed(lst)) if v == elm)
  return next(gen, None)

编辑:事后看来，这似乎是不必要的魔法。我会做一些类似这样的事情：

def find_last(lst, sought_elt):
    for r_idx, elt in enumerate(reversed(lst)):
        if elt == sought_elt:
            return len(lst) - 1 - r_idx

类似于Ignacio的一行代码，除了更简单/更清晰之外，应该是

max(loc for loc, val in enumerate(li) if val == 'a')

对我来说，这似乎是非常明确和Pythonic式的:您正在寻找包含匹配值的最高索引。不需要nexts、lambdas、reverseds或itertools。

使用一个简单的循环：

def reversed_index(items, value):
    for pos, curr in enumerate(reversed(items)):
        if curr == value:
            return len(items) - pos - 1
    raise ValueError("{0!r} is not in list".format(value))

我来到这里，希望有人已经完成了编写最有效版本的 list.rindex 的工作，它提供了 list.index 的完整接口(包括可选的 start 和 stop 参数)。我没有在这个问题的答案中找到，或者 here ，或者 here ，或者 here 。所以我自己拼凑了这些...利用其他答案中的建议来回答这个问题和其他问题。

def rindex(seq, value, start=None, stop=None):
  """L.rindex(value, [start, [stop]]) -> integer -- return last index of value.
  Raises ValueError if the value is not present."""
  start, stop, _ = slice(start, stop).indices(len(seq))
  if stop == 0:
    # start = 0
    raise ValueError('{!r} is not in list'.format(value))
  else:
    stop -= 1
    start = None if start == 0 else start - 1
  return stop - seq[stop:start:-1].index(value)

在其他几个答案中建议的使用 len(seq) - 1 - next(i for i,v in enumerate(reversed(seq)) if v == value) 的技术可以更有效地利用空间:它不需要创建完整列表的反向副本。但在我的(随意的)测试中，它慢了大约50%。

val =1，2，2，2，2，4，5。

如果需要查找2的最后一次出现

last_occurence = (len(val) -1) - list(reversed(val)).index(2)

下面是使用 enumerate 和列表理解获取最后一个索引的一小段代码：

li = ["a", "b", "a", "c", "x", "d", "a", "6"]
[l[0] for l in enumerate(li) if l[1] == "a"][-1]

last_occurence=len(yourlist)-yourlist[::-1].index(element)-1

就像that.no需要导入或创建函数一样简单。

使用 dict

您可以利用字典键是唯一的这一事实，并且当使用元组构建字典键时，将只使用特定键的最后一个赋值。正如在其他答案中所述，这对于小列表来说很好，但它为所有唯一值创建了一个字典，对于大列表可能效率不高。

dict(map(reversed, enumerate(li)))["a"]
6

如果列表很小，您可以计算所有索引并返回最大的索引：

index = max(i for i, x in enumerate(elements) if x == 'foo')

下面是一个函数，用于查找列表中元素的最后一个匹配项。一个列表和一个元素被传递给函数。

li = ["a", "b", "a", "c", "x", "d", "a", "6"]
element = "a"
def last_occurrence(li,element):
    for i in range(len(li)-1,0,-1):
        if li[i] == element:
            return i
    return -1