tamaño - sacar elementos de una lista python

Cómo encontrar la última aparición de un elemento en una lista de Python

Question

Digamos que tengo esta lista:

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

En cuanto a la ayuda que me mostró, no hay una función incorporada que devuelva la última aparición de una cadena (como el reverso del index ). Entonces, básicamente, ¿cómo puedo encontrar la última aparición de "a" en la lista dada?

Answer 1

Aquí hay una pequeña línea para obtener el último índice, usando enumerate y una lista de comprensión:

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

Answer 2

Me gustan las wim''s tanto de wim''s como de Ignacio''s . Sin embargo, creo que itertools proporciona una alternativa ligeramente más legible, a pesar de lambda. (Para Python 3; para Python 2, use xrange lugar de range ).

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

Esto generará una excepción StopIteration si el elemento no se encuentra; podría atraparlo y generar un ValueError en ValueError lugar, para que esto se comporte como el index .

Definido como una función, evitando el atajo 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")

Funciona también para no caracteres. Probado:

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

Answer 3

Muchas de las otras soluciones requieren iteración en toda la lista. Esto no lo hace.

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

Editar: En retrospectiva, esto parece una brujería innecesaria. Haría algo como esto en su lugar:

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

Answer 4

Puede utilizar el hecho de que las claves de diccionario son únicas y cuando construya una con tuplas, solo se usará la última asignación de un valor para una clave en particular. Como se indica en otras respuestas, esto está bien para listas pequeñas pero crea un diccionario para todos los valores únicos y puede no ser eficiente para listas grandes.

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

6

Answer 5

Si realmente está usando solo letras individuales como se muestra en su ejemplo, entonces str.rindex funcionaría cómodamente. Esto genera un ValueError si no existe dicho elemento, la misma clase de error que list.index generaría. Manifestación:

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

Para el caso más general, podría usar list.index en la lista invertida:

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

El corte aquí crea una copia de la lista completa. Eso está bien para listas cortas, pero para el caso donde li es muy grande, la eficiencia puede ser mejor con un enfoque lento:

# Python 3 version
next(i for i, val in zip(range(len(li)-1, -1, -1), reversed(li)) if val == ''a'')

# Python 2 version
from itertools import izip
indices = xrange(len(li)-1, -1, -1)
gen = izip(indices, reversed(li))
next(i for i, val in gen if val == ''a'')

Answer 6

Un trazador de líneas que es como el de Ignacio, excepto un poco más simple / más claro sería

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

Parece muy claro y paradójico para mí: estás buscando el índice más alto que contiene un valor coincidente. No se requieren nexts, lambdas, reverseds o itertools.

Answer 7

Use un bucle simple:

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

Answer 8

Vine aquí con la esperanza de encontrar que alguien ya había hecho el trabajo de escribir la versión más eficiente de list.rindex , que proporcionaba la interfaz completa de list.index (incluidos los parámetros de start y stop opcionales). No lo encontré en las respuestas a esta pregunta, ni here , ni here , ni here . Así que armé esto yo mismo ... haciendo uso de las sugerencias de otras respuestas a esta y otras preguntas.

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)

La técnica que usa len(seq) - 1 - next(i for i,v in enumerate(reversed(seq)) if v == value) , sugerida en varias otras respuestas, puede ser más eficiente en el uso del espacio: no necesita crear una copia revertida de la lista completa. Pero en mi (informal, casual) prueba, es aproximadamente un 50% más lento.

Answer 9

val = [1,2,2,2,2,2,4,5].

Si necesita encontrar la última ocurrencia de 2

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

Answer 10

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

Answer 11

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

Answer 12

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

tan fácil como eso. No es necesario importar o crear una función.