Obteniendo el último elemento de una lista en Python


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



Answers


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

De hecho, puede hacer mucho más con esta sintaxis. La some_list[-n] obtiene el enésimo elemento. Así que some_list[-1] obtiene el último elemento, some_list[-2] obtiene el penúltimo, etc., hasta llegar a some_list[-len(some_list)] , que le proporciona el primer elemento.

También puede establecer elementos de 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]



Si tus objetos str () o list () pueden terminar vacíos como así: astr = '' o alist = [] , entonces quizás quieras usar alist[-1:] lugar de alist[-1] para el objeto " igualdad".

La importancia 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

La distinción que se hace es que devolver un objeto de lista vacío 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

hay muchos otros métodos para lograr ese objetivo, pero estos son cortos y agradables de usar.




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



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



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




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 alguna razón, está buscando algo menos pitónico, podría usar list[len(list)-1] , suponiendo que la lista no está vacía.




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

Para obtener el último elemento,

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

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

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

Explicación

Los índices y las divisiones pueden tomar enteros negativos como argumentos.

He modificado un ejemplo de la documentación para indicar qué elemento en una secuencia hace referencia a cada índice, 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'

En una función

Un comentarista dijo:

Ojalá Python tuviera una función para first () y last () como Lisp lo hace ... 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 use 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 encontrarlo más eficaz para obtener el último elemento de maneras ligeramente diferentes.

Si es nuevo en la programación, debe evitar esta sección, ya que combina partes de algoritmos que de otra manera serían semánticamente diferentes. Si cambia su algoritmo en un lugar, puede tener un impacto involuntario en otra línea de código.

Trato de proporcionar advertencias y condiciones lo más completo que puedo, pero es posible que me haya perdido algo. Por favor comente si cree 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 incluir el elemento en una nueva lista:

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

Esto tiene el lado positivo 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 manejarse:

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

Pero, nuevamente, rebanar para este propósito solo debe hacerse si necesita:

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

for bucles

Como una característica de Python, no hay un alcance interno en un bucle for .

Si ya está realizando una iteración completa sobre la lista, el último nombre seguirá siendo referenciado por el nombre de la variable asignada en el ciclo:

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

Esto no es semánticamente la última cosa en la lista. Esto es semánticamente la última cosa a la que estaba obligado el nombre, item .

>>> def do_something(arg): raise Exception
>>> for item in a_list:
...     do_something(item)
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", 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
  • usted sabe que el ciclo terminará (no se interrumpirá o saldrá debido a errores), de lo contrario señalará el último elemento al que hace referencia el ciclo.

Obtener y eliminarlo

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

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

Pero ahora la lista original está modificada.

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

>>> a_list.pop()
'two'

Solo haz esto si

  • usted 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 pila.

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

Guardando el resto del reverso para más tarde:

No sé por qué lo harías, pero para completar, dado que el reversed devuelve un iterador (que admite el protocolo del iterador), puedes pasar su resultado al next :

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

Entonces 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 necesites el resto del iterador inverso más adelante, que probablemente se parecería más a 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



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

next(reversed(some_list), None)



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



popes = ['john paul II', 'benedict XIV', 'francis I']
current_pope = []
for pope in popes:
     current_pope = pope

después del ciclo for obtendrá el último elemento en la variable current_pope.