Pregunta Obteniendo el último elemento de una lista en Python


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


1385
2018-05-30 19:28


origen


Respuestas:


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

De hecho, puede hacer mucho más con esta sintaxis. los some_list[-n] la sintaxis obtiene el enésimo elemento. Asi 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 te da 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]

2207
2018-05-30 19:29



Si tu str() o list() los objetos pueden terminar vacíos de esta forma: astr = '' o alist = [], entonces es posible que desee utilizar alist[-1:] en lugar de alist[-1] para el objeto "sameness".

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.


182
2017-11-09 23:26



También puedes hacer:

alist.pop()

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


67
2018-05-30 22:21



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.


54
2017-08-20 17:41



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

Para obtener el último elemento,

  • sin modificar la lista, y
  • asumiendo que conoces 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 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 hace referencia al último elemento, el personaje, '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 mediante desempaquetado iterable

Este método puede materializar innecesariamente una segunda lista con el único fin de obtener el último elemento, pero en aras de la integridad (y dado que admite cualquier lista iterable, no solo):

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

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

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

Si tiene la intención de no 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 del subíndice):

last = a_list[-1]

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 usar 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 plantea una IndexError que necesitaría ser manejado:

>>> 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 una for lazo.

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 lo último que el nombre, item, estaba obligado a.

>>> 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 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, ya que reversed devuelve un iterador (que admite el protocolo de iterador) puede pasar su resultado a 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

20
2018-06-23 22:05



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

6
2018-02-21 09:06



si quieres solo obtener el último valor de la lista, debe usar:

your_list[-1]

PERO si quieres obtener valor y también retirar de la lista, puede usar:

your_list.pop()

O: También puedes mostrar el índice ...

your_list.pop(-1)

5
2017-10-13 12:32