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

Antwoord 1, autoriteit 100%

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

In feite kunt u veel meer doen met deze syntaxis. De syntaxis some_list[-n]krijgt het op één na laatste element. Dus some_list[-1]krijgt het laatste element, some_list[-2]krijgt het een-na-laatste, enzovoort, helemaal tot aan some_list[-len(some_list)], waarmee je het eerste element krijgt.

Je kunt op deze manier ook 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]

Houd er rekening mee dat het verkrijgen van een lijstitem per index een IndexErrorals het verwachte item niet bestaat. Dit betekent dat some_list[-1]een uitzondering maakt als some_listleeg is, omdat een lege lijst geen laatste element kan hebben.

Antwoord 2, autoriteit 8%

Als uw str()– of list()-objecten als volgt leeg zouden kunnen zijn: astr = ''of alist = [], dan wilt u misschien alist[-1:]gebruiken 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”-achtig is dan een uitzonderingsobject.

Antwoord 3, autoriteit 3%

U kunt ook het volgende doen:

last_elem = alist.pop()

Het hangt af van wat u met uw lijst wilt doen, omdat de methode pop()het laatste element verwijdert.

Antwoord 4, autoriteit 2%

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 krachtig om te gebruiken.

Antwoord 5, autoriteit 2%

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 weet dat de lijst heefteen laatste element (d.w.z. het is niet leeg)

geef -1door aan de subscriptnotatie:

>>> 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 uit de documentatieaangepast om aan te geven welk item in een volgorde waarin elke index verwijst, in dit geval in de tekenreeks "Python", -1verwijst naar het laatste element, het teken, 'n':

+---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1
>>> p = 'Python'
>>> p[-1]
'n'

Opdracht via iterable uitpakken

Deze methode kan onnodig een tweede lijst maken om alleen het laatste element te krijgen, maar voor de volledigheid (en aangezien het elke itereerbare – niet alleen lijsten ondersteunt):

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

De variabelenaam, head is gebonden aan de onnodige nieuw aangemaakte lijst:

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

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

*_, last = a_list

Of eigenlijk, als je weet dat het een lijst is (of in ieder geval subscriptnotatie accepteert):

last = a_list[-1]

In een functie

Een commentator zei:

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

Deze zijn vrij eenvoudig te definiëren:

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 beide gevallen:

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

Speciale gevallen

Als je iets ingewikkelders doet, vind je het misschien beter presteren om het laatste element op iets andere manieren te krijgen.

Als je nieuw bent met programmeren, moet je dit gedeelte vermijden, omdat het anders semantisch verschillende delen van algoritmen aan elkaar koppelt. Als u uw algoritme op de ene plaats wijzigt, kan dit een onbedoelde impact hebben op een andere regel code.

Ik probeer zo volledig mogelijk voorbehoud en voorwaarden te geven, maar misschien heb ik iets gemist. Geef een reactie als je denkt dat ik een waarschuwing achterlaat.

Snijden

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

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

Dit heeft het voordeel dat het niet faalt als de lijst leeg is:

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

Terwijl een poging tot toegang via index een IndexErroroplevert die moet worden afgehandeld:

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

Maar nogmaals, voor dit doel moet je alleen snijden als je het volgende nodig hebt:

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

forloops

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

Als u al een volledige iteratie over de lijst uitvoert, wordt nog steeds naar het laatste element 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 semantisch niet het laatste in de lijst. Dit is semantisch het laatste waar de naam, item, aan gebonden was.

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

Dit zou dus alleen moeten worden gebruikt om het laatste element te krijgen als u

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

Het ophalen en verwijderen

We kunnen onze originele 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 originele lijst gewijzigd.

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

>>> a_list.pop()
'two'

Doe dit alleen als

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

Dit zijn geldige use-cases, maar komen niet vaak voor.

De rest van de achterkant bewaren voor later:

Ik weet niet waarom je het zou doen, maar voor de volledigheid, aangezien reversedeen iteratorretourneert (die de iterator ondersteunt protocol) kunt u het resultaat doorgeven aan next:

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

Dus het is alsof je het omgekeerde doet:

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

Maar ik kan geen goede reden bedenken om dit te doen, tenzij je de rest van de omgekeerde iterator later 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

Antwoord 6

Gebruik deze syntaxis om IndexError: list index out of rangete voorkomen:

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'

Antwoord 7

lst[-1]is de beste aanpak, maar met algemene iterables, overweeg 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'

Antwoord 8

Een andere methode:

some_list.reverse() 
some_list[0]

Antwoord 9

list[-1]haalt het laatste element van de lijst op zonder de lijst te wijzigen.
list.pop()zal het laatste element van de lijst ophalen, maar het zal de originele lijst muteren/wijzigen. Gewoonlijk wordt het niet aanbevolen om de originele lijst te muteren.

Als u om de een of andere reden op zoek bent naar iets minder pythisch, kunt u ook list[len(list)-1]gebruiken, ervan uitgaande dat de lijst niet leeg is.

>

Antwoord 10

U kunt ook de onderstaande code gebruiken als u IndexError niet wilt krijgen wanneer de lijst leeg is.

next(reversed(some_list), None)

Antwoord 11

Ok, maar hoe zit het met gemeenschappelijk in bijna alle talen items[len(items) - 1]? Dit is IMO de gemakkelijkste manier om het laatste element te krijgen, omdat het geen pythonischekennis vereist.

Antwoord 12

Pythonische manier

Laten we dus bedenken dat we een lijst hebben a = [1,2,3,4], in Python List kan worden gemanipuleerd om ons een deel ervan of een element ervan te geven, met behulp van de door het volgende commando te volgen, kan men gemakkelijk het laatste element krijgen.

print(a[-1])

Antwoord 13

Hier is de oplossing voor uw vraag.

a=["first","middle","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.

Uitvoer:

>>> first
>>> last
>>> middle

Antwoord 14

Om “IndexError: lijst index buiten bereik” te voorkomen, kun je dit stukje code gebruiken.

list_values = [12, 112, 443]
def getLastElement(lst):
    if len(lst) == 0:
        return 0
    else:
        return lst[-1]
print(getLastElement(list_values))

Antwoord 15

Je hoeft alleen maar de index te nemen en [-1] te plaatsen. Bijvoorbeeld:

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

Je krijgt er 2 als uitvoer.

Antwoord 16

Toegang tot het laatste element uit de lijst in Python:

1: toegang tot het laatste element met negatieve indexering -1

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

2. Toegang tot het laatste element met de methode pop()

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

De pop-methode verwijdert echter het laatste element uit de lijst.

Antwoord 17

Als je my_list[-1]doet, wordt het laatste element van de lijst geretourneerd. Negatieve sequentie-indexen vertegenwoordigen posities vanaf het einde van de array. Negatieve indexering betekent vanaf het einde beginnen, -1 verwijst naar het laatste item, -2 verwijst naar het voorlaatste item, enz.

Antwoord 18

Kon hier geen antwoord op vinden. Dus toevoegen.

Je zou ook some_list[~0]kunnen proberen.

Dat is het tilde-symbool