Obtenir le dernier élément d'une liste
En Python, comment obtenez-vous le dernier élément d'une liste?
some_list[-1] est le plus court et le plus pythonique.
En fait, vous pouvez faire beaucoup plus avec cette syntaxe. La syntaxe some_list[-n] récupère le dernier élément. Donc, some_list[-1] obtient le dernier élément, some_list[-2] obtient l'avant-dernière, etc., jusqu'à some_list[-len(some_list)], 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 génère un IndexError si l'élément attendu n'existe pas. Cela signifie que some_list[-1] lève une exception si some_list est vide, car une liste vide ne peut contenir aucun dernier élément.
Si vos objets str() ou list() risquent d'être vides de la manière suivante: astr = '' ou alist = [], vous pouvez utiliser alist[-1:] au lieu de alist[-1] pour 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
La distinction est que renvoyer un objet de liste vide ou un objet vide de str est plus semblable à un "dernier élément" qu’un objet d’exception.
Vous pouvez aussi faire:
alist.pop()
Cela dépend de ce que vous voulez faire avec votre liste car la méthode pop() supprimera le dernier élément.
Le moyen le plus simple d’afficher le dernier élément de 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.
En Python, comment obtenez-vous le dernier élément d'une liste?
Pour obtenir le dernier élément,
- sans modifier la liste, et
- en supposant que vous connaissiez la liste a un dernier élément (c’est-à-dire qu’il n’est pas vide)
passez -1 à la notation en indice:
>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'
Explication
Les index et les tranches peuvent prendre des nombres entiers négatifs comme arguments.
J'ai modifié un exemple de la documentation pour indiquer l'élément de la séquence auquel chaque index fait référence, dans ce cas, dans la chaîne "Python", -1 fait 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'
Affectation via un déballage itérable
Cette méthode peut inutilement matérialiser une deuxième liste uniquement pour obtenir le dernier élément, mais dans un souci d'exhaustivité (et puisqu'elle prend en charge tout élément itérable - pas seulement les listes):
>>> *head, last = a_list
>>> last
'three'
Le nom de la variable, head est lié à la liste inutile nouvellement créée:
>>> head
['zero', 'one', 'two']
Si vous n’avez pas l’intention de ne rien faire avec cette liste, ce serait plus à propos:
*_, last = a_list
Ou, vraiment, si vous savez que c'est une liste (ou au moins accepte la notation en indice):
last = a_list[-1]
Dans une fonction
Un commentateur a déclaré:
J'aimerais que Python ait une fonction pour first () et last () comme le fait LISP ... cela éliminerait beaucoup de fonctions lambda inutiles.
Celles-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'
Cas spéciaux
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 débutez en programmation, évitez cette section, car elle associe par ailleurs des parties d'algorithmes sémantiquement différentes. Si vous modifiez votre algorithme à un endroit donné, cela peut avoir un impact imprévu 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.
Tranchage
Une tranche de liste renvoie une nouvelle liste - nous pouvons donc couper de -1 à la fin si nous voulons que l'élément soit 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)
Considérant que la tentative d'accès par index soulève une IndexError qui devrait être traitée:
>>> 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 à cet effet ne devrait être effectué que si vous avez besoin de:
- une nouvelle liste créée
- et que la nouvelle liste soit vide si la liste précédente était vide.
for boucles
En tant que fonctionnalité de Python, il n'y a pas de portée interne dans une boucle for.
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 dans 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é que pour obtenir le dernier élément si vous
- sont déjà en boucle, et
- vous savez que la boucle se terminera (pas de rupture ni de sortie en raison d'erreurs), sinon elle pointera vers le dernier élément référencé par la boucle.
Obtenir et enlever
Nous pouvons également modifier 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 originale est modifiée.
(-1 est en fait l'argument par défaut. Par conséquent, list.pop peut être utilisé sans argument d'index.):
>>> a_list.pop()
'two'
Ne faites cela que si
- vous savez que la liste contient des éléments ou êtes prête à gérer l'exception si elle est vide, et
- vous avez l'intention de supprimer le dernier élément de la liste, en le traitant comme une pile.
Ce sont des cas d'utilisation valables, mais peu communs.
Enregistrer le reste de l’inverse pour plus tard:
Je ne sais pas pourquoi vous le feriez, mais pour être complet, puisque reversed renvoie un itérateur (qui supporte le protocole itérateur), vous pouvez transmettre son résultat à next:
>>> next(reversed([1,2,3]))
3
Donc, c'est comme faire l'inverse de ceci:
>>> next(iter([1,2,3]))
1
Mais je ne peux pas penser à une bonne raison de faire cela, à moins que vous ayez besoin du reste de l'itérateur inverse plus tard, ce qui ressemblerait probablement davantage à 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
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())
si vous voulez juste obtenir la dernière valeur de la liste, vous devez utiliser:
your_list[-1]
MAIS si vous voulez obtenir valeur et aussi supprimer de la liste, vous pouvez utiliser:
your_list.pop()
OR: vous pouvez aussi afficher l'index ...
your_list.pop(-1)
Une autre méthode:
some_list.reverse()
some_list[0]
_lst[-1]_ est la meilleure approche, mais avec les 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] va récupérer le dernier élément de la liste sans changer de liste. list.pop() récupérera le dernier élément de la liste, mais il mutera/modifiera la liste d'origine. Généralement, la mutation de la liste d'origine n'est pas recommandée.
Sinon, 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.
Ok, mais qu'en est-il des communes dans presque toutes les langues items[len(items) - 1]? C’est le moyen le plus simple d’obtenir le dernier élément, car il n’exige rien Pythonic connaissance.
Pour empêcher 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'
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)