Python: obtener el último elemento de la lista

En este tutorial, veremos cómo obtener el último elemento en una lista de Python con ejemplos de código y compararlos para cumplir con las mejores prácticas de codificación.

Introducción

En este tutorial, veremos algunas de las formas más comunes de encontrar el último elemento en una lista en Python. Primero, cubriremos la forma más simple y más Pythonic y luego mostraremos algunas otras soluciones alternativas.

Echemos un vistazo a la lista que usaremos:

1
exampleList = [1, 2, "Three", ["Four", 5], 6]

Nota: Una lista en Python es una colección de elementos que no son necesariamente del mismo tipo. Una lista puede contener elementos que son números, cadenas, listas anidadas, etc.

Cómo obtener el último elemento en una lista de Python

Hay varias formas en que podemos obtener el último elemento de una lista en Python, algunas de las cuales son más intuitivas y prácticas que otras, y algunas de las cuales realmente cambian la lista original en el lugar.

Solución ganadora: uso de indexación negativa

Python admite la noción de indexación negativa como método para acceder a los elementos de la lista. Esto significa que podemos acceder a los elementos en orden inverso usando el operador [].

Es bien sabido cómo funciona la indexación en listas:

1
2
3
firstElement = exampleList[0]
nthElement = exampleList[n-1]
...

El primer elemento tiene el índice 0, el segundo tiene el índice 1 y el nésimo elemento tiene el índice n-1.

La indexación negativa sigue la misma lógica, pero en orden inverso. El último elemento tiene el índice -1, el penúltimo elemento tiene el índice -2, y así sucesivamente:

1
2
3
4
5
6
7
lastElement = exampleList[-1]
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

secondToLast = exampleList[-2]
print("Second to last element: ", secondToLast)

Qué salidas:

1
2
3
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]
Second to last element:  ['Four', 5]

La indexación negativa no cambia la lista original. Es solo una forma de acceder a los elementos sin cambios en la lista original.

Esta es, con mucho, la solución más simple y pythonica, favorecida por la mayoría.

Uso de la indexación

La indexación simple generalmente se usa para acceder a los elementos de una lista en el orden original usando el operador []. Como se describió anteriormente, el primer elemento tiene un índice de ‘0’, el segundo elemento tiene un índice de ‘1’, y así sucesivamente. Sabiendo eso, podemos concluir que el último elemento tiene el índice len(exampleList)-1:

1
2
3
4
5
6
7
lastElement = exampleList[len(exampleList)-1]
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

secondToLast = exampleList[len(exampleList)-2]
print("Second to last element: ", secondToLast)

Qué salidas:

1
2
3
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]
Second to last element:  ['Four', 5]

Además de la indexación negativa, el método de indexación solo se usa para acceder a elementos de la lista sin realizar ningún cambio en la lista original.

Usando el método pop()

En Python, el método pop() se usa para eliminar el último elemento de la lista dada y devolver el elemento eliminado.

El método pop() puede aceptar opcionalmente un argumento entero. Es el índice del elemento que queremos eliminar, por lo que si llamamos a exampleList.pop(0), el primer elemento será eliminado y devuelto.

Si el argumento es el número negativo, se realizará la lógica de la indexación negativa para determinar qué elemento eliminar. Llamar a exampleList.pop(-1) resultará en la eliminación del último elemento de examleList.

Sin embargo, dado que el método pop() de forma predeterminada ya muestra el último elemento, no hay necesidad real de usar la indexación en absoluto:

1
2
3
4
lastElement = exampleList.pop()
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

Qué salidas:

1
2
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5]]

Tenga en cuenta que el método pop(), por definición, cambia la lista original eliminando el elemento reventado.

Usando el corte

En Python, la notación de corte se usa para obtener una sublista de una lista. La notación en sí es bastante simple:

1
exampleList[startIndex:[endIndex[:indexStep]]]

Esto significa que podemos obtener la sublista de exampleList con índices a partir de startIndex, hasta endIndex con el paso de indexStep.

endIndex y indexStep son argumentos opcionales. Si dejamos endIndex en blanco, su valor predeterminado es el final de la lista original. El valor predeterminado para indexStep es 1.

Si tenemos una lista l=['a', 'b', 'c', 'd', 'e'] y la cortamos usando l[1:3] la sublista resultante será [ 'b', 'c', 'd']. Esto significa que estamos eligiendo elementos de los lits l con índices 1, 2 y 3.

l[0:4:2] devolverá una sublista que contiene solo elementos en los índices pares - 0, 2, 4.

La característica clave de la notación de corte que usaremos es que admite la indexación negativa.

Esto significa que l[-1:] puede interpretarse como: obtener todos los elementos de la lista l, desde el último elemento hasta el final de la lista l. La sublista resultante contendrá solo el último elemento de la lista original:

1
2
3
4
5
6
lastElement = exampleList[-1:][0]
# exampleList[-1:] alone will return the sublist - [6]
# exampleList[-1:][0] will return the last element - 6
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

Qué salidas:

1
2
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]

El método de corte solo se usa para acceder a los elementos de la lista y crear una nueva lista usándolos, sin realizar ningún cambio en la lista original.

Uso del iterador inverso

Python tiene dos funciones integradas que usaremos en este método: reversed() y next().

reversed() acepta una lista como argumento y devuelve el iterador invertido para esa lista, lo que significa que la iteración se invierte, comenzando desde el último elemento hasta el primer elemento. next() acepta un iterador y devuelve el siguiente elemento del iterador:

1
2
3
4
reversedIterator = reversed(exampleList)

lastElement = next(reversedIterator)
print("Last element: ", lastElement)

Qué salidas:

1
2
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]

El método de iterador inverso solo se usa para acceder a los elementos de la lista en orden inverso, sin realizar ningún cambio en la lista original.

Usando el método reverse()

El método reverse() se usa para revertir los elementos de la lista. No toma ningún argumento y no devuelve ningún valor, sino que invierte la lista original in situ. Esto significa que podemos invertir la lista y acceder al nuevo primer elemento:

1
2
3
4
5
6
7
8
# Update the original list by reversing its' elements
exampleList.reverse()

# Access the first element of the updated list
lastElement = exampleList[0]
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

Qué salidas:

1
2
Last element:  6
exampleList:  [6, ['Four', 5], 'Three', 2, 1]

El método reverse(), por definición, cambia la lista original invirtiendo el orden de sus elementos. Tenga en cuenta que este enfoque puede ser una exageración realmente ineficiente, ya que se necesita tiempo para invertir una lista.

Usando itemgetter()

El módulo operador proporciona una gran cantidad de métodos eficientes que realizan todas las operaciones fundamentales en Python, como las operaciones matemáticas y lógicas, así como otras operaciones de secuencia y comparación de objetos.

El método itemgetter() es uno de los muchos métodos en el módulo operador. Acepta uno o más enteros como argumento y devuelve un objeto invocable que puede verse como un tipo de función especial.

Cuando llamamos a operator.itemgetter(0), el objeto resultante será una función que obtendrá el primer elemento de una colección. También podemos asignarle un nombre a ese objeto:

1
getFirstElement = operator.itemgetter(0)

Ahora, podemos pasar una lista a getFirstElement(l), que devuelve el primer elemento de la lista l.

El operador itemgetter() admite la indexación negativa, por lo que recuperar el último elemento se reduce a:

1
2
3
4
5
6
7
import operator

getLastElement = operator.itemgetter(-1)
lastElement = getLastElement(exampleList)
print("Last element: ", lastElement)

print("exampleList: ", exampleList)

Qué salidas:

1
2
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]

Este enfoque no modifica la lista original: genera un objeto invocable que accede a él mediante índices.

Uso de bucles

Ahora, un enfoque mucho más manual y rudimentario sería usar bucles. Podemos iterar a través de la lista, usando la longitud de la lista como paso final. Luego, en el paso len(l)-1, simplemente podemos devolver ese elemento:

1
2
3
4
5
for i in range(0, len(exampleList)):
    if i == (len(exampleList)-1) : lastElement = exampleList[i]
        
print("Last element: ", lastElement)
print("exampleList: ", exampleList)

Qué salidas:

1
2
Last element:  6
exampleList:  [1, 2, 'Three', ['Four', 5], 6]

Esto tampoco cambia la lista en absoluto y simplemente accede a un elemento.

Conclusión

Hay muchas formas de obtener el último elemento de una lista en Python. La principal preocupación al elegir la forma correcta para usted es si desea o no que se elimine el último elemento.

Si necesita obtener el último elemento sin realizar ningún cambio en la lista original, entonces el método de indexación negativa es el claro ganador. Es la forma más simple y Pythonic de resolver este problema.

Por otro lado, si necesita eliminar el último elemento, así como acceder a él, entonces probablemente debería utilizar el método pop(), que es el método incorporado para realizar exactamente este comportamiento. .

Licensed under CC BY-NC-SA 4.0