Réponses:
some_list[-1]
est le plus court et le plus Pythonic.
En fait, vous pouvez faire beaucoup plus avec cette syntaxe. La some_list[-n]
syntaxe obtient le nième au dernier élément. Obtient donc some_list[-1]
le dernier élément, some_list[-2]
obtient l'avant-dernier, etc., jusqu'à some_list[-len(some_list)]
ce qui vous donne le premier élément.
Vous pouvez également définir des éléments de liste de cette manière. Par exemple:
>>> 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]
Notez que l'obtention d'un élément de liste par index soulèvera un IndexError
élément si l'élément attendu n'existe pas. Cela signifie que some_list[-1]
déclenchera une exception si some_list
est vide, car une liste vide ne peut pas avoir de dernier élément.
Si vos objets str()
ou list()
peuvent finir par être vides comme ceci: astr = ''
ou alist = []
, alors vous voudrez peut-être utiliser à la alist[-1:]
place de l' alist[-1]
objet "similitude".
La signification de ceci est:
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
Là où la distinction est faite, le retour d'un objet de liste vide ou d'un objet str vide est plus un "dernier élément" que un objet d'exception.
if len(my_vector) == 0 or my_vector[-1] != update_val
est un modèle réalisable. mais ce n'est certainement pas une solution globale - ce serait bien d'avoir une forme de syntaxe où None était le résultat
xs[-1] if xs else None
Vous pouvez également faire:
alist.pop()
Cela dépend de ce que vous voulez faire avec votre liste car la pop()
méthode supprimera le dernier élément.
La façon la plus simple d'afficher le dernier élément en python est
>>> list[-1:] # returns indexed value
[3]
>>> list[-1] # returns value
3
il existe de nombreuses autres méthodes pour atteindre un tel objectif, mais elles sont courtes et faciles à utiliser.
list[-1]
l'erreur se produit.
a[-1:][0]
du tout ? Il fournit de a[-1]
toute façon aussi. Explication s'il vous plait?
En Python, comment obtenez-vous le dernier élément d'une liste?
Pour obtenir simplement le dernier élément,
passer -1
à la notation en indice:
>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'
Les index et les tranches peuvent prendre des entiers négatifs comme arguments.
J'ai modifié un exemple de la documentation pour indiquer à quel élément d'une séquence chaque index fait référence, dans ce cas, dans la chaîne "Python"
, fait -1
référence au dernier élément, le caractère 'n'
,:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'
Cette méthode peut matérialiser inutilement une deuxième liste dans le seul but d'obtenir le dernier élément, mais dans un souci d'exhaustivité (et puisqu'elle prend en charge tout itérable - pas seulement les listes):
>>> *head, last = a_list
>>> last
'three'
Le nom de la variable, head est lié à la liste nouvellement créée inutile:
>>> head
['zero', 'one', 'two']
Si vous avez l'intention de ne rien faire avec cette liste, ce serait plus approprié:
*_, last = a_list
Ou, vraiment, si vous savez que c'est une liste (ou du moins accepte la notation en indice):
last = a_list[-1]
Un intervenant a déclaré:
J'aimerais que Python ait une fonction pour first () et last () comme Lisp le fait ... il se débarrasserait de beaucoup de fonctions lambda inutiles.
Ceux-ci seraient assez simples à définir:
def last(a_list):
return a_list[-1]
def first(a_list):
return a_list[0]
Ou utilisez operator.itemgetter
:
>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)
Dans tous les cas:
>>> last(a_list)
'three'
>>> first(a_list)
'zero'
Si vous faites quelque chose de plus compliqué, vous trouverez peut-être plus performant d'obtenir le dernier élément de manière légèrement différente.
Si vous êtes nouveau dans la programmation, vous devriez éviter cette section, car elle associe des parties d'algorithmes sémantiquement différentes. Si vous modifiez votre algorithme à un endroit, il peut avoir un impact involontaire sur une autre ligne de code.
J'essaie de fournir des mises en garde et des conditions aussi complètement que possible, mais j'ai peut-être manqué quelque chose. Veuillez commenter si vous pensez que je laisse une mise en garde.
Une tranche d'une liste renvoie une nouvelle liste - donc nous pouvons couper de -1 à la fin si nous voulons vouloir l'élément dans une nouvelle liste:
>>> a_slice = a_list[-1:]
>>> a_slice
['three']
Cela a l'avantage de ne pas échouer si la liste est vide:
>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
... do_something(tail)
Alors que la tentative d'accès par index soulève un problème IndexError
qui devrait être traité:
>>> empty_list[-1]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Mais encore une fois, le découpage à cette fin ne doit être effectué que si vous avez besoin:
for
bouclesEn tant que fonctionnalité de Python, il n'y a pas de portée interne dans une for
boucle.
Si vous effectuez déjà une itération complète sur la liste, le dernier élément sera toujours référencé par le nom de variable attribué dans la boucle:
>>> def do_something(arg): pass
>>> for item in a_list:
... do_something(item)
...
>>> item
'three'
Ce n'est pas sémantiquement la dernière chose de la liste. C'est sémantiquement la dernière chose à laquelle le nom item
était lié.
>>> 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'
Ainsi, cela ne devrait être utilisé pour obtenir le dernier élément que si vous
Nous pouvons également muter notre liste d'origine en supprimant et en renvoyant le dernier élément:
>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']
Mais maintenant, la liste d'origine est modifiée.
( -1
est en fait l'argument par défaut, il list.pop
peut donc être utilisé sans argument d'index):
>>> a_list.pop()
'two'
Ne faites cela que si
Ce sont des cas d'utilisation valides, mais pas très courants.
Je ne sais pas pourquoi vous le feriez, mais pour être complet, car reversed
retourne un itérateur (qui prend en charge le protocole d'itérateur), vous pouvez transmettre son résultat à next
:
>>> next(reversed([1,2,3]))
3
C'est comme faire l'inverse:
>>> next(iter([1,2,3]))
1
Mais je ne peux pas penser à une bonne raison de le faire, sauf si vous aurez besoin du reste de l'itérateur inversé plus tard, qui ressemblerait probablement plus à ceci:
reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)
use_later = list(reverse_iterator)
et maintenant:
>>> use_later
[2, 1]
>>> last_element
3
Pour éviter IndexError: list index out of range
, utilisez cette syntaxe:
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'
Une autre méthode:
some_list.reverse()
some_list[0]
lst[-1]
est la meilleure approche, mais avec des itérables généraux, considérez 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'
list[-1]
récupérera le dernier élément de la liste sans modifier la liste.
list.pop()
récupérera le dernier élément de la liste, mais il mutera / modifiera la liste d'origine. Habituellement, la mutation de la liste d'origine n'est pas recommandée.
Alternativement, si, pour une raison quelconque, vous recherchez quelque chose de moins pythonique, vous pouvez utiliser list[len(list)-1]
, en supposant que la liste n'est pas vide.
Vous pouvez également utiliser le code ci-dessous, si vous ne souhaitez pas obtenir IndexError lorsque la liste est vide.
next(reversed(some_list), None)
Ok, mais qu'en est-il de commun dans presque toutes les langues items[len(items) - 1]
? C'est l'OMI le moyen le plus simple d'obtenir le dernier élément, car il ne nécessite aucune connaissance pythonique .
some_list[-1]
approche parce que c'est plus logique et montre ce qu'il fait réellement mieux qu'à some_list[-1]
mon avis.
some_list.last
- ce serait une belle ligne de code