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


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


1385
2018-05-30 19:28


origine


Réponses:


some_list[-1] est le plus court et le plus pythonique.

En fait, vous pouvez faire beaucoup plus avec cette syntaxe. le some_list[-n] la syntaxe obtient l'élément nth-to-last. Alors some_list[-1] obtient le dernier élément, some_list[-2] obtient l'avant-dernier, etc, tout le chemin 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]

2207
2018-05-30 19:29



Si ton str() ou list() les objets peuvent finir par être vides comme suit: astr = '' ou alist = [], alors vous pourriez vouloir utiliser alist[-1:] au lieu de alist[-1] pour l'objet "identité".

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

Lorsque la distinction est faite, retourner un objet liste vide ou un objet str vide est plus un "dernier élément" - comme un objet d'exception.


182
2017-11-09 23:26



Vous pouvez aussi faire:

alist.pop()

Cela dépend de ce que vous voulez faire avec votre liste parce que le pop() La méthode supprimera le dernier élément.


67
2018-05-30 22:21



Le moyen le 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 douces à utiliser.


54
2017-08-20 17:41



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 connaissez la liste a un dernier élément (c'est-à-dire qu'il n'est pas vide)

passer -1 à la notation d'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 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 dans le seul but d'obtenir le dernier élément, mais à des fins d'exhaustivité (et parce qu'elle prend en charge tous les itérables - pas seulement les listes):

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

Le nom de la variable, head est lié à la nouvelle liste inutile:

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

Si vous avez 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 d'indice):

last = a_list[-1]

Dans une fonction

Un commentateur a dit:

Je souhaite que Python ait une fonction pour first () et last () comme Lisp ... cela éliminerait 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 utiliser 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 novice en programmation, vous devriez éviter cette section, car elle associe des parties d'algorithmes sémantiquement différentes. Si vous modifiez votre algorithme à un endroit, cela peut avoir un 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. S'il vous plaît commenter si vous pensez que je laisse un avertissement.

Trancher

Une tranche de liste renvoie une nouvelle liste - donc nous pouvons découper de -1 jusqu'à 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)

Alors que 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, tranchage à cet effet ne devrait être fait que si vous avez besoin:

  • une nouvelle liste créée
  • et la nouvelle liste à vide si la liste précédente était vide.

for boucles

En tant que caractéristique de Python, il n'y a pas de portée interne dans un 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 affecté 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 que 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 si vous

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

Obtenir et supprimer

Nous pouvons également muter notre liste d'origine en supprimant 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 d'index):

>>> a_list.pop()
'two'

Seulement faire ceci si

  • vous savez que la liste comporte des éléments ou est prête à gérer l'exception si elle est vide, et
  • vous avez l'intention d'enlever le dernier élément de la liste, en le traitant comme une pile.

Ce sont des cas d'utilisation valides, mais pas très communs.

Sauvegarde du reste de l'inverse pour plus tard:

Je ne sais pas pourquoi tu le ferais, mais pour être complet, puisque reversed retourne un itérateur (qui prend en charge 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 le faire, à moins que vous ayez besoin du reste de l'itérateur inverse plus tard, ce 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

20
2018-06-23 22:05



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())

6
2018-02-21 09:06



si tu veux juste obtenir la dernière valeur de la liste, vous devez utiliser:

your_list[-1]

MAIS si tu veux obtenir valeur et aussi retirer à partir de la liste, vous pouvez utiliser:

your_list.pop()

OU: vous pouvez aussi sauter avec l'index ...

your_list.pop(-1)

5
2017-10-13 12:32