Frage Abrufen des letzten Elements einer Liste in Python


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


1385
2018-05-30 19:28


Ursprung


Antworten:


some_list[-1] ist die kürzeste und am meisten Pythonic.

Tatsächlich können Sie mit dieser Syntax viel mehr tun. Das some_list[-n] Syntax erhält das n-vorletzte Element. Damit some_list[-1] erhält das letzte Element, some_list[-2] bekommt den vorletzten, usw., den ganzen Weg runter some_list[-len(some_list)], die dir das erste Element gibt.

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]

2207
2018-05-30 19:29



Wenn dein str() oder list() Objekte könnten wie folgt leer sein: astr = '' oder alist = [], dann möchtest du vielleicht verwenden alist[-1:] Anstatt von alist[-1] 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

Wenn die Unterscheidung gemacht wird, ist das Zurückgeben eines leeren Listenobjekts oder eines leeren str-Objekts mehr "letztes Element" als ein Ausnahmeobjekt.


182
2017-11-09 23:26



Sie können auch Folgendes tun:

alist.pop()

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


67
2018-05-30 22:21



Die einfachste Möglichkeit, 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 gut zu bedienen.


54
2017-08-20 17:41



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

Um nur das letzte Element zu bekommen,

  • ohne die Liste zu ändern, und
  • vorausgesetzt, Sie kennen die Liste hat ein letztes Element (d. h. es ist nicht leer)

bestehen -1 zur tiefgestellten Notation:

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

Erläuterung

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

Ich habe ein Beispiel geändert aus der Dokumentation um anzugeben, auf welches Element in einer Sequenz jeder Index in diesem Fall in der Zeichenfolge verweist "Python", -1 verweist auf das letzte Element, den Charakter, '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 über iterbares Entpacken

Diese Methode kann unnötigerweise eine zweite Liste materialisieren, um nur das letzte Element zu erhalten, aber der Vollständigkeit halber (und da es jedes iterierbare - nicht nur Listen - unterstützt):

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

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

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

Wenn Sie nichts mit dieser Liste zu tun haben, wäre das passender:

*_, last = a_list

Oder, wenn Sie wissen, dass es eine Liste ist (oder zumindest eine 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 ... es würde viele unnötige Lambda-Funktionen loswerden.

Diese wären ziemlich einfach zu definieren:

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

def first(a_list):
    return a_list[0]

Oder benutzen 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, können Sie es leistungsfähiger finden, das letzte Element auf etwas andere Weise zu erhalten.

Wenn Sie mit der Programmierung noch nicht vertraut sind, sollten Sie diesen Abschnitt vermeiden, da sonst semantisch verschiedene Teile von Algorithmen miteinander gekoppelt werden. Wenn Sie Ihren Algorithmus an einer Stelle ändern, kann dies unbeabsichtigte Auswirkungen auf eine andere Codezeile haben.

Ich versuche, Vorbehalte und Bedingungen so vollständig wie möglich zur Verfügung zu stellen, aber vielleicht habe ich etwas übersehen. Bitte kommentieren Sie, wenn Sie denken, dass ich eine Einschränkung verlasse.

Schneiden

Ein Slice einer Liste gibt eine neue Liste zurück - so 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 die Liste nicht leer ist, wenn die Liste leer ist:

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

Während der Versuch, auf den Index zuzugreifen, eine Erhöhung verursacht IndexError welches behandelt werden müsste:

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

Aber noch einmal, schneiden für diesen Zweck sollte nur getan werden, wenn Sie brauchen:

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

for Schleifen

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

Wenn Sie bereits eine vollständige Iteration über die Liste ausführen, wird auf das letzte Element weiterhin durch den in der Schleife zugewiesenen Variablennamen verwiesen:

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

Dies ist nicht semantisch das letzte Ding in der Liste. Dies ist semantisch das letzte, was der Name, item, war verpflichtet.

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

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

Es bekommen und entfernen

Wir können auch unsere ursprüngliche Liste mutieren, 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, also list.pop kann ohne ein Indexargument verwendet werden):

>>> a_list.pop()
'two'

Tu das nur, wenn

  • Sie wissen, dass die Liste Elemente enthält oder bereit ist, die Ausnahme zu behandeln, wenn sie leer ist und
  • 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.

Speichern Sie den Rest der Rückseite für später:

Ich weiß nicht, warum du es tun würdest, aber der Vollständigkeit halber reversed gibt ein zurück Iterator (die das Iterator-Protokoll unterstützt), an die Sie das Ergebnis übergeben können next:

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

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

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

Aber ich kann mir keinen guten Grund vorstellen, dies zu tun, es sei denn, Sie benötigen später den Rest des Rückwärts-Iterators, 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

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



wenn du nur willst bekommen der letzte Wert der Liste, sollten Sie verwenden:

your_list[-1]

ABER Wenn du möchtest bekommen Wert und auch Löschen es aus der Liste, können Sie verwenden:

your_list.pop()

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

your_list.pop(-1)

5
2017-10-13 12:32



Ok, aber was ist in fast jeder Sprache üblich items[len(items) - 1]? Dies ist IMO der einfachste Weg, um das letzte Element zu bekommen, weil es nichts benötigt pythonisch Wissen.


4
2017-10-07 17:22



einige_liste = [1, 2, 3]

Methode 1:

some_list[-1]

Methode 2:

**some_list.reverse()** 

**some_list[0]**

Methode 3:

some_list.pop() 

4
2018-01-10 12:32



Datum: 2017-12-06

alist.pop()

Ich mache einen ausführlichen Überblick über alle 11 Methoden der Liste als Referenz.

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

3
2017-12-06 12:28