Pobieranie ostatniego elementu listy w Pythonie

Jeśli Twoje str() lub list() obiekty mogą być puste w ten sposób: astr = '' lub alist = [], możesz użyć alist[-1:] zamiast alist[-1] dla obiektu "identyczność".

Znaczenie tego jest następujące:

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

Gdzie rozróżnia się, że zwracanie pustego obiektu list lub pustego obiektu str jest bardziej "ostatnim elementem" - jak obiekt wyjątku.

Możesz również zrobić:

alist.pop()

To zależy od tego, co chcesz zrobić z listą, ponieważ metoda pop() usunie ostatni element.

Najprostszym sposobem wyświetlenia ostatniego elementu w Pythonie jest

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

Istnieje wiele innych metod, aby osiągnąć taki cel, ale są one krótkie i słodkie w użyciu.

W Pythonie, jak uzyskać ostatni element listy?

Aby uzyskać ostatni element,

• bez modyfikowania listy, oraz
• zakładając, że znasz listę ma ostatni element (tzn. jest nieempty)

Przekazać -1 do zapisu dolnego:

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

Wyjaśnienie

Indeksy i plasterki mogą przyjmować ujemne liczby całkowite jako argumenty.

Zmodyfikowałem przykład z dokumentacja aby wskazać, który element w sekwencji odwołuje się do każdego indeksu, w tym przypadku w ciągu "Python", -1 odwołuje się do ostatniego elementu, znaku, 'n':

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'n'

Przypisanie przez iterowalne rozpakowywanie

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

Nazwa zmiennej, head jest związana z niepotrzebna nowo utworzona lista:

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

*_, last = a_list

last = a_list[-1]

W funkcji

Komentator powiedział:

Szkoda, że Python nie ma funkcji first () I last (), tak jak robi to Lisp... pozbyłoby się wielu niepotrzebnych funkcji lambda.

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

def first(a_list):
    return a_list[0]

Lub operator.itemgetter:

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

W obu przypadkach:

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

Przypadki specjalne

Jeśli robisz coś bardziej skomplikowanego, może okazać się bardziej wydajne, aby uzyskać ostatni element w nieco inny sposób.

Jeśli jesteś nowy w programowaniu, powinieneś unikać tej sekcji, ponieważ łączy ona różne semantycznie części algorytmów. Jeśli zmienisz algorytm w jednym miejscu, może to mieć niezamierzony wpływ na inny linia kodu.

Staram się zapewnić zastrzeżenia i warunki tak całkowicie, Jak mogę, ale mogłem coś przeoczyć. Proszę skomentować, jeśli uważasz, że zostawiam zastrzeżenie.

Krojenie

Wycinek listy zwraca nową listę - więc możemy wycinać od -1 do końca, jeśli chcemy, aby element znajdował się na nowej liście:

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

To ma zaletę, że nie zawodzi, jeśli lista jest pusta:

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

Podczas gdy próba dostępu przez indeks podnosi IndexError, który musiałby być obsługiwany:

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

Ale znowu, krojenie w tym celu powinno być wykonywane tylko wtedy, gdy potrzebujesz:

• utworzono nową listę
• i nowa lista ma być pusta, jeśli poprzednia lista była pusta.

for pętle

Jako cecha Pythona, nie ma wewnętrznego zakresu w pętli for.

Jeśli wykonujesz już pełną iterację nad listą, ostatni element będzie nadal odwoływał się do nazwy zmiennej przypisanej w pętla:

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

To nie jest semantycznie ostatnia rzecz na liście. To jest semantycznie ostatnia rzecz, do której nazwa, {28]}, była związana.

>>> 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'

Dlatego powinno być użyte tylko do uzyskania ostatniego elementu, jeśli

• są już zapętlone, a
• wiesz, że pętla zakończy się (nie zostanie przerwana lub zamknięta z powodu błędów), w przeciwnym razie wskaże ostatni element, do którego odwołuje się pętla.

Uzyskiwanie i usuwanie go

Możemy również zmutuj naszą oryginalną listę, usuwając i zwracając ostatni element:

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

Ale teraz oryginalna lista została zmodyfikowana.

(-1 jest domyślnym argumentem, więc list.pop może być używany bez argumentu indeksu):

>>> a_list.pop()
'two'

Rób to tylko wtedy, gdy

• wiesz, że lista zawiera elementy, lub jesteś przygotowany do obsługi wyjątku, jeśli jest pusty, i
• zamierzasz usunąć ostatni element z listy, traktując go jak stos.

Są to ważne przypadki użycia, ale niezbyt częste.

Zapisanie reszty rewersu na później:

Nie wiem dlaczego to robisz, ale dla kompletności, ponieważ reversed zwraca iterator (który obsługuje protokół iteratora) można przekazać jego wynik do next:

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

Więc to tak, jakby robić to na odwrót:

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

Ale nie mogę wymyślić dobrego powodu, aby to zrobić, chyba że będziesz potrzebował reszty odwrotnej iterator później, który prawdopodobnie wyglądałby bardziej tak:

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

use_later = list(reverse_iterator)

A teraz:

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

Jeśli chcesz po prostu uzyskać ostatnią wartość listy, powinieneś użyć :

your_list[-1]

Ale jeśli chcesz uzyskać wartość, a także usunąć z listy, możesz użyć :

your_list.pop()

Albo: możesz też pop z indeksem...

your_list.pop(-1)

Ok, ale co z powszechnością w prawie każdym języku items[len(items) - 1]? Jest to IMO najprostszy sposób na uzyskanie ostatniego elementu, ponieważ nie wymaga on niczego wiedzy.

Some_list = [1, 2, 3]

Metoda 1:

some_list[-1]

Metoda 2:

**some_list.reverse()** 

**some_list[0]**

Metoda 3:

some_list.pop() 

Data: 2017-12-06

alist.pop()

Robię wyczerpujący arkusz cheatsheet wszystkich 11 metod listy w celach informacyjnych.

{'list_methods': {'Add': {'extend', 'append', 'insert'},
                  'Entire': {'clear', 'copy'},
                  'Search': {'count', 'index'},
                  'Sort': {'reverse', 'sort'},
                  'Subtract': {'remove', 'pop'}}}

list[-1] pobierze ostatni element listy bez zmiany listy. list.pop() pobierze ostatni element listy, ale zmutuje / zmieni oryginalną listę. Zwykle nie zaleca się mutowania oryginalnej listy.

Alternatywnie, jeśli z jakiegoś powodu szukasz czegoś mniej pythonicznego, możesz użyć list[len(list)-1], zakładając, że lista nie jest pusta.

Możesz również użyć poniższego kodu, jeśli nie chcesz uzyskać IndexError, gdy lista jest pusta.

next(reversed(some_list), None)

lst[-1] jest najlepszym podejściem, ale z ogólnymi iteracjami, rozważ more_itertools.last:

Kod

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'

Lista Pythona obsługuje indeksy ujemne.

a = [1, 2, 3]

a[-1] # gives the last elements with negative indexes

Lub

a[len(a) - 1] # gives the last elements len function