Як знайти останнє входження елемента до списку Python

Скажімо, у мене є цей список:

li = ["a", "b", "a", "c", "x", "d", "a", "6"]

Наскільки мені показала допомога, не існує вбудованої функції, яка повертає останнє входження рядка (наприклад, зворотне значення index). Отже, як я можу знайти останнє входження "a"у наведеному списку?

Якщо ви насправді використовуєте лише окремі літери, як показано у вашому прикладі, це str.rindexбуде працювати зручно. Це піднімає a, ValueErrorякщо такого елемента немає, той самий клас помилки, list.indexщо і підняття. Демо:

>>> li = ["a", "b", "a", "c", "x", "d", "a", "6"]
>>> ''.join(li).rindex('a')
6

Для більш загального випадку ви можете скористатися list.indexв зворотному списку:

>>> len(li) - 1 - li[::-1].index('a')
6

Нарізка тут створює копію всього списку. Це добре для коротких списків, але у випадку, коли liдуже велика, ефективність може бути кращою за допомогою ледачого підходу:

def list_rindex(li, x):
    for i in reversed(range(len(li))):
        if li[i] == x:
            return i
    raise ValueError("{} is not in list".format(x))

Однолінійна версія:

next(i for i in reversed(range(len(li))) if li[i] == 'a')

Однокласний лайнер, подібний до Ігнасіо, за винятком трохи простішого / зрозумілішого

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

Мені здається цілком зрозумілим та пітонічним: ви шукаєте найвищий індекс, що містить відповідне значення. Не потрібні додатки, лямбда, реверси або інструменти.

Багато інших рішень вимагають перегляду всього списку. Це не так.

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

>>> (x for x in reversed([y for y in enumerate(li)]) if x[1] == 'a').next()[0]
6

>>> len(li) - (x for x in (y for y in enumerate(li[::-1])) if x[1] == 'a').next()[0] - 1
6

Мені подобаються як відповіді Віма, так і Ігнасіо . Однак я думаю, що itertoolsце трохи читабельніша альтернатива, незважаючи на лямбду. (Для Python 3; для Python 2 використовуйте xrangeзамість range).

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

Це спричинить StopIterationвиняток, якщо предмет не знайдено; Ви можете схопити це і ValueErrorзамість цього підняти a , щоб зробити це так самоindex .

Визначається як функція, уникаючи lambdaярлика:

def rindex(lst, item):
    def index_ne(x):
        return lst[x] != item
    try:
        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

С dict

Ви можете використовувати той факт, що ключі словника унікальні, і при побудові ключа з кортежами буде використано лише останнє призначення значення для певного ключа. Як зазначено в інших відповідях, це добре для невеликих списків, але створює словник для всіх унікальних значень, і для великих списків може бути неефективним.

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

6

Я прийшов сюди, сподіваючись виявити, що хтось уже виконав роботу над написанням найефективнішої версії list.rindex, яка надає повний інтерфейс list.index(включаючи необов’язкові startта stopпараметри). Я не знайшов цього у відповідях на це питання, ні тут , ні тут , ні тут . Тож я сам це зібрав ... використовуючи пропозиції інших відповідей на це та інші запитання.

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% повільніше.

Використовуйте простий цикл:

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

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

просто так. немає необхідності імпортувати або створювати функцію.

lastIndexOf = lambda array, item: len(array) - (array[::-1].index(item)) - 1

Якщо список невеликий, ви можете обчислити всі індекси і повернути найбільший:

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

def rindex(lst, val):
    try:
        return next(len(lst)-i for i, e in enumerate(reversed(lst), start=1) if e == val)
    except StopIteration:
        raise ValueError('{} is not in list'.format(val))

val = [1,2,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]