Vraag Het laatste element van een lijst ophalen in Python


Hoe krijg je in Python het laatste element van een lijst?


1385
2018-05-30 19:28


oorsprong


antwoorden:


some_list[-1] is de kortste en meest pythonische.

In feite kunt u veel meer doen met deze syntaxis. De some_list[-n] syntaxis krijgt het n-de-laatste-element. Zo some_list[-1] krijgt het laatste element, some_list[-2] krijgt de voorlaatste, etc, helemaal naar beneden some_list[-len(some_list)], wat je het eerste element geeft.

U kunt ook op deze manier lijstelementen instellen. Bijvoorbeeld:

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



Als jouw str() of list() objecten kunnen als volgt leeg zijn: astr = '' of alist = [], dan wil je misschien gebruiken alist[-1:] in plaats van alist[-1] voor object "gelijkheid".

De betekenis hiervan is:

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

Waar het onderscheid wordt gemaakt is dat het retourneren van een leeg lijstobject of leeg str-object meer "laatste element" is, zoals dan een uitzonderingsobject.


182
2017-11-09 23:26



Je kunt ook doen:

alist.pop()

Het hangt af van wat je wilt doen met je lijst omdat het pop() methode zal het laatste element verwijderen.


67
2018-05-30 22:21



De eenvoudigste manier om het laatste element in python weer te geven is

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

er zijn veel andere methoden om een ​​dergelijk doel te bereiken, maar deze zijn kort en zoet om te gebruiken.


54
2017-08-20 17:41



Hoe krijg je in Python het laatste element van een lijst?

Om alleen het laatste element te krijgen,

  • zonder de lijst te wijzigen, en
  • ervan uitgaande dat u de lijst kent heeft een laatste element (dat wil zeggen, het is niet-leeg)

slagen voor -1 naar de subscript-notatie:

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

Uitleg

Indexen en segmenten kunnen negatieve gehele getallen als argumenten gebruiken.

Ik heb een voorbeeld aangepast van de documentatie om aan te geven welk item in een reeks elke index verwijst, in dit geval, in de tekenreeks "Python", -1 verwijst naar het laatste element, het personage, 'n':

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

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

Toewijzing via herhaald uitpakken

Deze methode kan een tweede lijst onnodig materialiseren om alleen het laatste element te krijgen, maar voor de volledigheid (en omdat het een iterabele - niet alleen maar lijsten) ondersteunt:

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

De naam van de variabele, hoofd is gebonden aan de onnodige nieuw gemaakte lijst:

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

Als u van plan bent om niets met die lijst te doen, zou dit meer geschikt zijn:

*_, last = a_list

Of, echt, als u weet dat het een lijst is (of in ieder geval accepteer de subscript-notatie):

last = a_list[-1]

In een functie

Een commenter zei:

Ik wou dat Python een functie had voor first () en last () zoals Lisp dat doet ... het zou veel onnodige lambda-functies verwijderen.

Deze zouden vrij eenvoudig te definiëren zijn:

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

def first(a_list):
    return a_list[0]

Of gebruik operator.itemgetter:

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

In elk geval:

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

Speciale gevallen

Als je iets ingewikkelder doet, vind je het misschien meer performant om het laatste element op enigszins verschillende manieren te krijgen.

Als je nieuw bent bij het programmeren, moet je dit gedeelte vermijden, omdat het anders semantisch verschillende delen van algoritmes bij elkaar koppelt. Als u uw algoritme op één plaats wijzigt, kan dit een onbedoelde invloed hebben op een andere coderegel.

Ik probeer de restricties en voorwaarden zo volledig mogelijk te geven, maar misschien heb ik iets gemist. Geef alsjeblieft commentaar als je denkt dat ik een waarschuwing verlaat.

snijden

Een deel van een lijst retourneert een nieuwe lijst - dus we kunnen van -1 tot het einde snijden als we het element in een nieuwe lijst willen hebben:

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

Dit heeft het voordeel van niet falen als de lijst leeg is:

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

Terwijl een poging om toegang te krijgen via index verhoogt een IndexError welke zou moeten worden behandeld:

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

Maar nogmaals, het snijden voor dit doel zou alleen gedaan moeten worden als u:

  • een nieuwe lijst gemaakt
  • en de nieuwe lijst moet leeg zijn als de vorige lijst leeg was.

for loops

Als een kenmerk van Python is er geen innerlijke scoping in a for lus.

Als u al een volledige iteratie uitvoert over de lijst, wordt er naar het laatste element nog steeds verwezen door de variabelenaam die in de lus is toegewezen:

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

Dit is niet semantisch het laatste in de lijst. Dit is semantisch het laatste dat de naam, item, was gebonden aan.

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

Dus dit zou alleen moeten worden gebruikt om het laatste element te krijgen als je

  • zijn al aan het lussen, en
  • je weet dat de lus zal eindigen (niet breken of afsluiten vanwege fouten), anders wijst het naar het laatste element waarnaar wordt verwezen door de lus.

Verkrijgen en verwijderen

We kunnen onze oorspronkelijke lijst ook muteren door het laatste element te verwijderen en terug te sturen:

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

Maar nu is de oorspronkelijke lijst aangepast.

(-1 is eigenlijk het standaardargument, dus list.pop kan zonder indexargument worden gebruikt):

>>> a_list.pop()
'two'

Doe dit alleen als

  • u weet dat de lijst elementen bevat, of u bent bereid om de uitzondering af te handelen als deze leeg is, en
  • je bent van plan om het laatste element uit de lijst te verwijderen, het als een stapel te behandelen.

Dit zijn geldige use-cases, maar niet erg gebruikelijk.

De rest van het omgekeerde bewaren voor later:

Ik weet niet waarom je het zou doen, maar voor de volledigheid, sinds reversed retourneert een iterator (die het iterator-protocol ondersteunt), kunt u het resultaat doorgeven aan next:

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

Dus het is net als het omgekeerde hiervan:

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

Maar ik kan geen goede reden bedenken om dit te doen, tenzij je later de rest van de reverse iterator nodig hebt, die er waarschijnlijk meer als volgt uitziet:

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

use_later = list(reverse_iterator)

en nu:

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



als je het gewoon wilt krijgen de laatste waarde van de lijst, gebruik dan:

your_list[-1]

MAAR als je wilt krijgen waarde en ook verwijderen het uit de lijst kunt u gebruiken:

your_list.pop()

OF: je kunt ook poppen met index ...

your_list.pop(-1)

5
2017-10-13 12:32