it-swarm.com.de

Das letzte Element einer Liste abrufen

Wie erhält man in Python das letzte Element einer Liste?

1777
Janusz

some_list[-1] ist die kürzeste und pythonischste.

Tatsächlich können Sie mit dieser Syntax noch viel mehr tun. Die some_list[-n] -Syntax ruft das vorletzte Element ab. So erhält some_list[-1] das letzte Element, some_list[-2] das vorletzte usw. bis hinunter zu some_list[-len(some_list)], wodurch Sie das erste Element erhalten.

Sie können auf diese Weise auch Listenelemente festlegen. Zum Beispiel:

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

Beachten Sie, dass beim Abrufen eines Listenelements nach Index ein IndexError ausgelöst wird, wenn das erwartete Element nicht vorhanden ist. Dies bedeutet, dass some_list[-1] eine Ausnahme auslöst, wenn some_list leer ist, da eine leere Liste kein letztes Element enthalten kann.

2737
Sasha Chedygov

Wenn Ihre Objekte str() oder list() möglicherweise leer sind: astr = '' oder alist = [], möchten Sie möglicherweise alist[-1:] anstelle von alist[-1] verwenden ] _ für Objekt "Gleichheit".

Die Bedeutung davon ist:

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

Dabei wird unterschieden, dass das Zurückgeben eines leeren Listenobjekts oder eines leeren str-Objekts eher "letztes Element" ist als ein Ausnahmeobjekt.

223
DevPlayer

Sie können auch tun:

alist.pop()

Dies hängt davon ab, was Sie mit Ihrer Liste tun möchten, da die Methode pop() das letzte Element löscht.

86
Taurus Olson

Der einfachste Weg, um das letzte Element in python anzuzeigen, ist

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

es gibt viele andere Methoden, um ein solches Ziel zu erreichen, aber diese sind kurz und bündig anzuwenden.

63
Atul Arvind

Wie erhält man in Python das letzte Element einer Liste?

Um nur das letzte Element zu erhalten,

  • ohne die Liste zu ändern, und
  • angenommen, Sie wissen, dass die Liste ein letztes Element enthält (d. h., es ist nicht leer).

übergeben Sie -1 an die tiefgestellte Schreibweise:

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

Erläuterung

Indizes und Slices können negative Ganzzahlen als Argumente verwenden.

Ich habe ein Beispiel geändert aus der Dokumentation um anzugeben, auf welches Element in einer Sequenz jeder Index verweist. In diesem Fall verweist "Python", -1 auf das letzte Element, das Zeichen, 'n':

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

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

Zuordnung durch iteratives Auspacken

Diese Methode materialisiert möglicherweise unnötigerweise eine zweite Liste, um nur das letzte Element abzurufen, aber der Vollständigkeit halber (und weil sie alle iterierbaren unterstützt - nicht nur Listen):

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

Der Variablenname head ist an die unnötig neu erstellte Liste gebunden:

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

Wenn Sie mit dieser Liste nichts anfangen möchten, ist dies eher angebracht:

*_, last = a_list

Oder wirklich, wenn Sie wissen, dass es sich um eine Liste handelt (oder zumindest die tiefgestellte Notation akzeptiert):

last = a_list[-1]

In einer Funktion

Ein Kommentator sagte:

Ich wünschte, Python hätte eine Funktion für first () und last () wie LISP ... sie würde viele unnötige Lambda-Funktionen beseitigen.

Diese wären recht einfach zu definieren:

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

def first(a_list):
    return a_list[0]

Oder benutze operator.itemgetter:

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

In beiden Fällen:

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

Sonderfälle

Wenn Sie etwas Komplizierteres tun, ist es möglicherweise performanter, das letzte Element auf etwas andere Weise abzurufen.

Wenn Sie neu in der Programmierung sind, sollten Sie diesen Abschnitt vermeiden, da er ansonsten semantisch unterschiedliche Teile von Algorithmen miteinander verbindet. Wenn Sie Ihren Algorithmus an einer Stelle ändern, hat dies möglicherweise unbeabsichtigte Auswirkungen auf eine andere Codezeile.

Ich versuche, Vorbehalte und Bedingungen so vollständig wie möglich vorzusehen, aber möglicherweise habe ich etwas verpasst. Bitte kommentieren Sie, wenn Sie denken, ich lasse eine Einschränkung aus.

Schneiden

Ein Teil einer Liste gibt eine neue Liste zurück - also können wir von -1 bis zum Ende schneiden, wenn wir das Element in einer neuen Liste haben wollen:

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

Dies hat den Vorteil, dass es nicht scheitert, wenn die Liste leer ist:

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

Während der Versuch, über einen Index zuzugreifen, ein IndexError ergibt, das behandelt werden müsste:

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

Das Schneiden zu diesem Zweck sollte jedoch nur durchgeführt werden, wenn Sie Folgendes benötigen:

  • eine neue Liste erstellt
  • und die neue Liste muss leer sein, wenn die vorherige Liste leer war.

for Schleifen

Als ein Merkmal von Python gibt es in einer for -Schleife kein inneres Scoping.

Wenn Sie bereits eine vollständige Iteration der Liste durchführen, wird das letzte Element weiterhin durch den in der Schleife zugewiesenen Variablennamen referenziert:

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

Dies ist semantisch nicht das Letzte in der Liste. Dies ist semantisch das Letzte, an das der Name item gebunden war.

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

Daher sollte dies nur verwendet werden, um das letzte Element zu erhalten, wenn Sie

  • werden bereits wiederholt und
  • sie wissen, dass die Schleife beendet wird (nicht aufgrund von Fehlern unterbrochen oder beendet wird), andernfalls verweist sie auf das letzte Element, auf das die Schleife verweist.

Abrufen und Entfernen

Wir können unsere ursprüngliche Liste auch ändern, indem wir das letzte Element entfernen und zurückgeben:

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

Aber jetzt ist die ursprüngliche Liste geändert.

(-1 ist eigentlich das Standardargument, daher kann list.pop ohne Indexargument verwendet werden):

>>> a_list.pop()
'two'

Tun Sie dies nur, wenn

  • sie wissen, dass die Liste Elemente enthält, oder Sie sind bereit, die Ausnahme zu behandeln, wenn sie leer ist
  • sie beabsichtigen, das letzte Element aus der Liste zu entfernen und es wie einen Stapel zu behandeln.

Dies sind gültige Anwendungsfälle, aber nicht sehr häufig.

Den Rest der Rückseite für später speichern:

Ich weiß nicht warum, aber der Vollständigkeit halber, da reversed einen Iterator (der das Iterator-Protokoll unterstützt) zurückgibt ) können Sie das Ergebnis an next übergeben:

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

Es ist also so, als würde man das Gegenteil tun:

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

Aber ich kann mir keinen guten Grund dafür vorstellen, es sei denn, Sie benötigen den Rest des Reverse-Iterators später, der wahrscheinlich eher so aussehen würde:

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

use_later = list(reverse_iterator)

und nun:

>>> use_later
[2, 1]
>>> last_element
3
41
Aaron Hall
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())
11
Fuji Komalan

wenn Sie nur get den letzten Wert der Liste wollen, sollten Sie verwenden:

your_list[-1]

BUT Wenn Sie get value und auch remove it from list möchten, können Sie Folgendes verwenden:

your_list.pop()

ODER: Sie können auch mit Index Pop ...

your_list.pop(-1)
10
a_m_dev

Eine andere Methode:

some_list.reverse() 
some_list[0]
8
Sanjay Pradeep

_lst[-1]_ ist der beste Ansatz, aber bei allgemeinen Iterables berücksichtigen Sie more_itertools.last :

Code

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

list[-1] ruft das letzte Element der Liste ab, ohne die Liste zu ändern. list.pop() ruft das letzte Element der Liste ab, ändert jedoch die ursprüngliche Liste. Normalerweise wird das Mutieren der ursprünglichen Liste nicht empfohlen.

Wenn Sie aus irgendeinem Grund nach etwas weniger Pythonic suchen, können Sie alternativ list[len(list)-1] verwenden, vorausgesetzt, die Liste ist nicht leer.

Ok, aber was ist mit der in fast jeder Sprache üblichen Art, items[len(items) - 1]? Dies ist IMO der einfachste Weg, um das letzte Element zu erhalten, da es keine Pythonic Kenntnisse erfordert.

5

Verwenden Sie diese Syntax, um IndexError: list index out of range zu verhindern:

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

Sie können auch den folgenden Code verwenden, wenn Sie IndexError nicht erhalten möchten, wenn die Liste leer ist.

next(reversed(some_list), None)
2
Yavuz Mester