Obteniendo el último elemento de una lista en Python

En Python, ¿cómo se obtiene el último elemento de una lista?

some_list[-1] es el más corto y más pythonico.

De hecho, puedes hacer mucho más con esta syntax. La some_list[-n] obtiene el elemento nth-to-last. Entonces some_list[-1] obtiene el último elemento, some_list[-2] obtiene el segundo para durar, etc, hasta llegar a some_list[-len(some_list)] , que le da el primer elemento.

También puede configurar los elementos de la lista de esta manera. Por ejemplo:

 >>> some_list = [1, 2, 3] >>> some_list[-1] = 5 # Set the last element >>> some_list[-2] = 3 # Set the second to last element >>> some_list [1, 3, 5] 

Tenga en cuenta que obtener un elemento de la lista por índice generará un IndexError si el elemento esperado no existe. Esto significa que some_list[-1] generará una excepción si some_list está vacía, porque una lista vacía no puede tener un último elemento.

Si sus objetos str() o list() pueden terminar vacíos, así: astr = '' o alist = [] , entonces es posible que desee usar alist[-1:] lugar de alist[-1] para el objeto ” igualdad”.

El significado de esto es:

 alist = [] alist[-1] # will generate an IndexError exception whereas alist[-1:] # will return an empty list astr = '' astr[-1] # will generate an IndexError exception whereas astr[-1:] # will return an empty str 

Donde la distinción que se hace es que devolver un objeto de lista vacía o un objeto str vacío es más un “último elemento”, como un objeto de excepción.

También puedes hacer:

 alist.pop() 

Depende de lo que quieras hacer con tu lista porque el método pop() eliminará el último elemento.

La forma más sencilla de mostrar el último elemento en python es

 >>> list[-1:] # returns indexed value [3] >>> list[-1] # returns value 3 

Existen muchos otros métodos para lograr ese objective, pero son cortos y fáciles de usar.

En Python, ¿cómo se obtiene el último elemento de una lista?

Para obtener el último elemento,

  • sin modificar la lista, y
  • Suponiendo que sepa que la lista tiene un último elemento (es decir, no está vacío)

pasar -1 a la notación del subíndice:

 >>> a_list = ['zero', 'one', 'two', 'three'] >>> a_list[-1] 'three' 

Explicación

Los índices y los segmentos pueden tomar enteros negativos como argumentos.

He modificado un ejemplo de la documentación para indicar qué elemento en una secuencia cada índice hace referencia, en este caso, en la cadena "Python" , -1 referencia al último elemento, el carácter, 'n' :

  +---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 -6 -5 -4 -3 -2 -1 >>> p = 'Python' >>> p[-1] 'n' 

Asignación a través de desembalaje iterable

Este método puede materializar innecesariamente una segunda lista con el fin de obtener el último elemento, pero para completar (y dado que admite cualquier iterable, no solo listas):

 >>> *head, last = a_list >>> last 'three' 

El nombre de la variable, cabecera está vinculado a la lista recién creada innecesaria:

 >>> head ['zero', 'one', 'two'] 

Si no desea hacer nada con esa lista, esto sería más apropiado:

 *_, last = a_list 

O, realmente, si sabes que es una lista (o al menos acepta la notación de subíndices):

 last = a_list[-1] 

En una funcion

Un comentarista dijo:

Desearía que Python tuviera una función para el primero () y el último () como lo hace Lisp … eliminaría muchas funciones lambda innecesarias.

Estos serían bastante simples de definir:

 def last(a_list): return a_list[-1] def first(a_list): return a_list[0] 

O utilice operator.itemgetter :

 >>> import operator >>> last = operator.itemgetter(-1) >>> first = operator.itemgetter(0) 

En cualquier caso:

 >>> last(a_list) 'three' >>> first(a_list) 'zero' 

Casos especiales

Si está haciendo algo más complicado, puede que le resulte más eficaz obtener el último elemento de formas ligeramente diferentes.

Si no está familiarizado con la progtwigción, debe evitar esta sección, ya que, de otro modo, combina partes de algoritmos semánticamente diferentes. Si cambia su algoritmo en un lugar, puede tener un impacto no deseado en otra línea de código.

Intento proporcionar advertencias y condiciones tan completas como puedo, pero es posible que haya pasado algo por alto. Por favor comenta si crees que estoy dejando una advertencia.

Rebanar

Una porción de una lista devuelve una nueva lista, por lo que podemos dividir desde -1 hasta el final si queremos que el elemento esté en una nueva lista:

 >>> a_slice = a_list[-1:] >>> a_slice ['three'] 

Esto tiene la ventaja de no fallar si la lista está vacía:

 >>> empty_list = [] >>> tail = empty_list[-1:] >>> if tail: ... do_something(tail) 

Mientras que intentar acceder por índice genera un IndexError que debería ser manejado:

 >>> empty_list[-1] Traceback (most recent call last): File "", line 1, in  IndexError: list index out of range 

Pero una vez más, el corte para este propósito solo debe hacerse si necesita:

  • una nueva lista creada
  • y la nueva lista estará vacía si la lista anterior estaba vacía.

for bucles

Como característica de Python, no hay un ámbito interno en un bucle for .

Si ya está realizando una iteración completa sobre la lista, el nombre de la variable asignada en el bucle seguirá haciendo referencia al último elemento:

 >>> def do_something(arg): pass >>> for item in a_list: ... do_something(item) ... >>> item 'three' 

Esto no es semánticamente lo último en la lista. Esto es semánticamente la última cosa a la que se vinculó el nombre, el item .

 >>> def do_something(arg): raise Exception >>> for item in a_list: ... do_something(item) ... Traceback (most recent call last): File "", line 2, in  File "", line 1, in do_something Exception >>> item 'zero' 

Por lo tanto, esto solo debe usarse para obtener el último elemento si

  • ya están en bucle, y
  • sabe que el bucle finalizará (no se romperá ni saldrá debido a errores), de lo contrario, apuntará al último elemento al que hace referencia el bucle.

Conseguir y quitarlo

También podemos mutar nuestra lista original eliminando y devolviendo el último elemento:

 >>> a_list.pop(-1) 'three' >>> a_list ['zero', 'one', 'two'] 

Pero ahora se modifica la lista original.

( -1 es el argumento predeterminado, por lo que list.pop se puede usar sin un argumento de índice):

 >>> a_list.pop() 'two' 

Solo haz esto si

  • sabe que la lista tiene elementos o está preparada para manejar la excepción si está vacía, y
  • tiene la intención de eliminar el último elemento de la lista, tratándolo como una stack.

Estos son casos de uso válidos, pero no muy comunes.

Guardando el rest del reverso para más tarde:

No sé por qué lo haría, pero si está completo, dado que la reversed devuelve un iterador (que admite el protocolo del iterador), puede pasar su resultado al next :

 >>> next(reversed([1,2,3])) 3 

Así que es como hacer lo contrario de esto:

 >>> next(iter([1,2,3])) 1 

Pero no puedo pensar en una buena razón para hacer esto, a menos que necesite el rest del iterador inverso más adelante, que probablemente se vería más como esto:

 reverse_iterator = reversed([1,2,3]) last_element = next(reverse_iterator) use_later = list(reverse_iterator) 

y ahora:

 >>> use_later [2, 1] >>> last_element 3 
 mylist = [ 1 , 2 , 3 , 4 , 5] #------------------------------------ # Method-1 : Last index #------------------------------------ print(mylist[-1]) #------------------------------------ # Method-2 : Using len #------------------------------------ print(mylist[len(mylist) - 1]) #------------------------------------ # Method-3 : Using pop, pop will remove the last # element from the list. #------------------------------------ print(mylist.pop()) 

Si solo desea obtener el último valor de la lista, debe usar:

 your_list[-1] 

PERO si desea obtener valor y también eliminarlo de la lista, puede usar:

 your_list.pop() 

O: puedes hacer pop con índice también …

 your_list.pop(-1) 

some_list = [1, 2, 3]

Método 1:

 some_list[-1] 

Método 2:

 **some_list.reverse()** **some_list[0]** 

Método 3:

 some_list.pop() 

lst[-1] es el mejor enfoque, pero con iterables generales, considere more_itertools.last :

Código

 import more_itertools as mit mit.last([0, 1, 2, 3]) # 3 mit.last(iter([1, 2, 3])) # 3 mit.last([], "some default") # 'some default' 

Ok, pero ¿qué hay de común en casi todos los items[len(items) - 1] manera de lenguaje items[len(items) - 1] ? Esta es la forma más fácil de obtener el último elemento, ya que no requiere ningún conocimiento de Pythonic .

list[-1] recuperará el último elemento de la lista sin cambiar la lista. list.pop() recuperará el último elemento de la lista, pero mutará / cambiará la lista original. Por lo general, no se recomienda mutar la lista original.

Alternativamente, si, por algún motivo, está buscando algo menos pythonico, puede usar la list[len(list)-1] , suponiendo que la lista no está vacía.

También puede usar el código a continuación, si no desea obtener IndexError cuando la lista está vacía.

 next(reversed(some_list), None) 

Para evitar que IndexError: list index out of range , use esta syntax:

 mylist = [1, 2, 3, 4] # With None as default value: value = mylist and mylist[-1] # With specified default value (option 1): value = mylist and mylist[-1] or 'default' # With specified default value (option 2): value = mylist[-1] if mylist else 'default'