Obtenir le dernier élément d'une liste en Python

si vos objets str() ou list() peuvent finir par être vides comme ceci: astr = '' ou alist = [] , alors vous pouvez utiliser alist[-1:] au lieu de alist[-1] pour l'objet"sameness".

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

où la distinction est faite que retourner un objet de liste vide ou un objet str vide est plus un"dernier élément" -comme un objet d'exception.

vous pouvez aussi faire:

alist.pop()

Cela dépend de ce que vous voulez faire avec votre liste, car la pop() méthode supprime 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 celles-ci sont courtes et douces à utiliser.

en Python, comment obtenir le dernier élément d'une liste?

Pour obtenir juste le dernier élément,

• sans modifier la liste, et
• si vous connaissez la liste a un dernier élément (c'est-à-dire qu'il n'est pas vide)

pass -1 à l'indice de notation:

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

Explication

Index et tranches peuvent prendre des entiers négatifs comme arguments.

j'ai modifié un exemple de la documentation pour indiquer quel élément dans une séquence chaque index renvoie, dans ce cas, dans la chaîne de caractères "Python" , -1 renvoie le 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 itérable déballage

This la méthode peut inutilement matérialiser une deuxième liste dans le seul but d'obtenir le dernier élément, mais par souci d'exhaustivité (et puisqu'elle prend en charge n'importe quelle liste itérable - pas seulement des listes):

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

la variable name, head est liée à la nouvelle liste inutile créée:

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

si vous n'avez pas l'intention de faire usage de cette liste, ce serait plus approprié:

*_, last = a_list

Ou, vraiment, si vous savez que c'est un liste (ou au moins accepte indice de notation):

last = a_list[-1]

dans une fonction

un commentateur a dit:

j'aimerais que Python ait une fonction pour first() et last() comme Lisp... il serait se débarrasser de beaucoup de fonctions lambda inutiles.

ceux - ci seraient tout à fait simple à définir:

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

def first(a_list):
    return a_list[0]

ou utiliser operator.itemgetter :

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

dans les deux cas:

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

cas particuliers

si vous faites quelque chose de plus compliqué, vous pouvez trouver plus performant d'obtenir le dernier élément de manière légèrement différente.

si vous êtes nouveau à la programmation, vous devriez éviter cette section, parce qu'il couple autrement sémantiquement différentes parties d'algorithmes ensemble. Si vous changez votre algorithme en un seul endroit, il peut avoir une impact inattendu 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 retourne une nouvelle liste - donc nous pouvons trancher de -1 à la fin si nous voulons l'élément dans une nouvelle liste:

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

Cela a l'avantage de ne pas défaut si la liste est vide:

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

attendu que le fait de tenter d'accéder par index soulève un IndexError qui devrait être manipulé:

>>> 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 tranchage à cette fin ne doit être fait que si vous avez besoin:

• création d'une nouvelle liste
• et la nouvelle liste vide si l'état de la liste était vide.

"1519260920 des" boucles "de 1519900920"

en tant que caractéristique de Python, il n'y a pas de cadrage interne dans une boucle for .

si vous effectuez déjà une itération complète sur la liste, le dernier élément sera encore référencé par le nom de la variable assignée 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, ceci ne doit ê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 il pointera vers le dernier élément référencé par la boucle.

Obtention et de retrait

nous pouvons également muter notre liste originale en enlevant et en retournant 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, donc list.pop peut être utilisé sans argument index):

>>> a_list.pop()
'two'

seulement si

• vous savez la liste a des éléments qui le composent, ou sont préparés à gérer l'exception, si elle est vide, et
• vous avez l'intention de supprimer le dernier élément de la liste, le traitant comme un pile.

ce sont des cas d'utilisation valides, mais pas très courants.

Sauver le reste de l'arrière pour plus tard:

Je ne sais pas pourquoi vous le feriez, mais par souci d'exhaustivité, puisque reversed renvoie un iterator (qui supporte le protocole iterator) vous pouvez passer son résultat à next :

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

donc c'est comme faire au verso:

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

mais je ne vois pas de bonne raison pour faire cela, à moins que vous ayez 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

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 get la dernière valeur de liste, vous devez utiliser :

your_list[-1]

mais si vous voulez obtenir valeur et aussi supprimer il de la liste, vous pouvez utiliser:

your_list.pop()

OU: vous pouvez pop avec un indice de trop...

your_list.pop(-1)

D'accord, mais qu'en est-il de commun dans presque toutes les langues items[len(items) - 1] ? C'est IMO la façon la plus facile d'obtenir le dernier élément, parce qu'il ne nécessite rien pythonic connaissance.

some_list = [1, 2, 3]

Méthode 1:

some_list[-1]

Méthode 2:

**some_list.reverse()** 

**some_list[0]**

Méthode 3:

some_list.pop() 

Date: 2017-12-06

alist.pop()

je fais un cheatsheet exhaustif de toutes les 11 méthodes de la liste pour votre référence.

{'list_methods': {'Add': {'extend', 'append', 'insert'},
                  'Entire': {'clear', 'copy'},
                  'Search': {'count', 'index'},
                  'Sort': {'reverse', 'sort'},
                  'Subtract': {'remove', 'pop'}}}

list[-1] va récupérer le dernier élément de la liste sans changer la liste. list.pop() va récupérer le dernier élément de la liste, mais il va muter/changer la liste originale. Habituellement, la mutation de la liste originale n'est pas recommandée.

alternativement, si, pour une raison quelconque, vous cherchez 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 voulez pas d'obtenir IndexError lorsque la liste est vide.

next(reversed(some_list), None)

lst[-1] est la meilleure approche, mais avec le général iterables, envisager de 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'

liste Python supporte les index négatifs.

a = [1, 2, 3]

a[-1] # gives the last elements with negative indexes

ou

a[len(a) - 1] # gives the last elements len function