some_list[-1]es el más corto y más pitónico.

De hecho, puede hacer mucho más con esta sintaxis. La some_list[-n]sintaxis obtiene del enésimo al último elemento. Obtiene some_list[-1]el último elemento, some_list[-2]obtiene el penúltimo, etc., todo el camino hasta some_list[-len(some_list)], lo 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 IndexErrorsi el elemento esperado no existe. Esto significa que some_list[-1]generará una excepción si some_listestá vacío, porque una lista vacía no puede tener un último elemento.

Si sus objetos str()o list()pueden terminar vacíos como: astr = ''o alist = [], entonces es posible que desee usar alist[-1:]en 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ío o un objeto str vacío es más como un "último elemento" que un objeto de excepción.

También puedes hacer:

last_elem = alist.pop()

Depende de lo que quieras hacer con tu lista porque el pop()método 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.

In Python, how do you get the last element of a list?

Para obtener el último elemento,

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

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

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

Explicación

Los índices y las porciones pueden aceptar números enteros negativos como argumentos.

He modificado un ejemplo de la documentación para indicar a qué elemento de una secuencia hace referencia cada índice, en este caso, en la cadena "Python", -1hace 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 mediante desempaquetado iterable

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

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

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

>>> 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 sabe que es una lista (o al menos acepta la notación de subíndice):

last = a_list[-1]

en una funcion

Un comentarista dijo:

I wish Python had a function for first() and last() like Lisp does... it would get rid of a lot of unnecessary lambda functions.

Estos serían bastante simples de definir:

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

def first(a_list):
    return a_list[0]

O usa 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 maneras ligeramente diferentes.

Si es nuevo en la programación, debe evitar esta sección, ya que acopla 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.

Trato de proporcionar advertencias y condiciones tan completas como 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 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 problema IndexErrorque 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, 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.

forbucles

Como característica de Python, no hay alcance interno en un forciclo.

Si ya está realizando una iteración completa sobre la lista, el nombre de la variable asignado 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 lo último a lo que itemestaba ligado el nombre.

>>> 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
• sabe que el ciclo terminará (no se romperá ni saldrá debido a errores); de lo contrario, apuntará al último elemento al que hace referencia el ciclo.

Conseguirlo y eliminarlo

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.

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

>>> a_list.pop()
'two'

Solo haz esto si

• sabe que la lista tiene elementos o está preparado 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ía, pero para completar, dado que reverseddevuelve un iterador (que admite el protocolo iterador), puede pasar su resultado a 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 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

Para prevenir IndexError: list index out of range, use esta sintaxis:

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'

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'

Otro método:

some_list.reverse() 
some_list[0]

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, puede usar list[len(list)-1], asumiendo 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)

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

Aquí está la solución a su consulta.

a=["first","second from last","last"] # A sample list
print(a[0]) #prints the first item in the list because the index of the list always starts from 0.
print(a[-1]) #prints the last item in the list.
print(a[-2]) #prints the last second item in the list.

Producción:

>>> first
>>> last
>>> second from last

Es extraño que nadie haya publicado esto todavía:

>>> l = [1, 2, 3]
>>> *x, last_elem = l
>>> last_elem
3
>>> 

Solo desempaca.

Vía pitónica

Entonces, consideremos que tenemos una lista a = [1,2,3,4], en Python List se puede manipular para darnos una parte o un elemento de ella, usando el siguiente comando se puede obtener fácilmente el último elemento.

print(a[-1])

Accediendo al último elemento de la lista en Python:

1: Accede al último elemento con indexación negativa -1

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']
>> data[-1]
'w'

2. Accede al último elemento con el método pop()

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']
>> data.pop()
'w'

Sin embargo, el método pop eliminará el último elemento de la lista.

Para evitar "IndexError: índice de lista fuera de rango", puede usar este código.

list_values = [12, 112, 443]

def getLastElement(lst):
    if len(lst) == 0:
        return 0
    else:
        return lst[-1]

print(getLastElement(list_values))

Si lo hace, my_list[-1]devuelve el último elemento de la lista. Los índices de secuencia negativa representan posiciones desde el final de la matriz. La indexación negativa significa comenzar desde el final, -1 se refiere al último elemento, -2 se refiere al penúltimo elemento, etc.

Solo tendrá que tomar el índice y poner [-1]. Por ejemplo:

list=[0,1,2]
last_index=list[-1]
print(last_index)

Obtendrá 2 como salida.

También puede usar la longitud para obtener el último elemento:

last_elem = arr[len(arr) - 1]

Si la lista está vacía, obtendrá una IndexErrorexcepción, pero también la obtiene con arr[-1].

No pude encontrar ninguna respuesta mencionando esto. Entonces sumando.

Podrías intentarlo some_list[~0]también.

Ese es el símbolo de la tilde

Podrías usarlo con nexty itercon [::-1]:

>>> a = [1, 2, 3]
>>> next(iter(a[::-1]))
3
>>> 

array=[1,2,3,4,5,6,7]
last_element= array[len(array)-1]
last_element

Otra solución sencilla