Obtention du 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 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_listest 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.

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.

En Python, comment obtenez-vous le dernier élément d'une liste?

Pour obtenir simplement le dernier élément,

• sans modifier la liste, et
• en supposant que vous savez que la liste a un dernier élément (c'est-à-dire qu'elle n'est pas vide)

passer -1à la notation en indice:

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

Explication

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 -1ré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 le déballage itérable

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]

Dans une fonction

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'

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

Tranchage

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

• une nouvelle liste créée
• et la nouvelle liste doit être 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 forboucle.

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

• sont déjà en boucle, et
• vous savez que la boucle se terminera (pas de rupture ou de sortie en raison d'erreurs), sinon elle pointera vers le dernier élément référencé par la boucle.

Obtention et suppression

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.

( -1est en fait l'argument par défaut, il list.poppeut donc ê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êt à 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 valides, mais pas très courants.

Sauvegarde du reste de l'inverse pour plus tard:

Je ne sais pas pourquoi vous le feriez, mais pour être complet, car reversedretourne 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 .