una - tuple python




Ottenere l'ultimo elemento di una lista in Python (10)

In Python, come si ottiene l'ultimo elemento di una lista?

Per ottenere solo l'ultimo elemento,

  • senza modificare la lista, e
  • supponendo che tu sappia che l'elenco ha un ultimo elemento (cioè non è vuoto)

passare -1 alla notazione del pedice:

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

Spiegazione

Gli indici e le sezioni possono assumere interi negativi come argomenti.

Ho modificato un esempio dalla documentazione per indicare quale elemento in una sequenza fa riferimento a ciascun indice, in questo caso, nella stringa "Python" , -1 riferimento all'ultimo elemento, il carattere, 'n' :

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'n'

Assegnazione tramite disimballaggio iterabile

Questo metodo può materializzare inutilmente un secondo elenco allo scopo di ottenere solo l'ultimo elemento, ma per completezza (e poiché supporta qualsiasi iterabile - non solo liste):

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

Il nome della variabile, head è associato all'elenco non appena creato:

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

Se hai intenzione di non fare nulla con quella lista, questo sarebbe più a proposito:

*_, last = a_list

O, in realtà, se sai che è una lista (o almeno accetta la notazione degli abbonati):

last = a_list[-1]

In una funzione

Un commentatore ha detto:

Vorrei che Python avesse una funzione per first () e last () come Lisp fa ... si sbarazzerebbe di molte funzioni lambda non necessarie.

Questi sarebbero abbastanza semplici da definire:

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

def first(a_list):
    return a_list[0]

Oppure usa operator.itemgetter :

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

In ogni caso:

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

Casi speciali

Se stai facendo qualcosa di più complicato, potresti trovarlo più performante per ottenere l'ultimo elemento in modi leggermente diversi.

Se sei nuovo alla programmazione, dovresti evitare questa sezione, perché mette insieme parti di algoritmi altrimenti semanticamente diverse. Se si modifica l'algoritmo in un unico punto, potrebbe avere un impatto non intenzionale su un'altra riga di codice.

Cerco di fornire caveat e condizioni nel modo più completo possibile, ma potrei aver perso qualcosa. Si prega di commentare se pensate che sto lasciando un caveat fuori.

Affettare

Una porzione di una lista restituisce un nuovo elenco, quindi possiamo tagliare da -1 alla fine se vogliamo che l'elemento si trovi in ​​una nuova lista:

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

Questo ha il vantaggio di non fallire se la lista è vuota:

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

Mentre il tentativo di accedere per indice solleva un IndexError che dovrebbe essere gestito:

>>> empty_list[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Ma ancora una volta, affettare per questo scopo dovrebbe essere fatto solo se hai bisogno di:

  • una nuova lista creata
  • e la nuova lista deve essere vuota se la lista precedente era vuota.

for loops

Come caratteristica di Python, non esiste un ambito interno in un ciclo for .

Se stai già eseguendo un'iterazione completa sulla lista, l'ultimo elemento sarà ancora referenziato dal nome della variabile assegnata nel ciclo:

>>> def do_something(arg): pass
>>> for item in a_list:
...     do_something(item)
...     
>>> item
'three'

Questo non è semanticamente l'ultima cosa nella lista. Questo è semanticamente l'ultima cosa a cui è stato associato il nome, l' item .

>>> 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'

Quindi questo dovrebbe essere usato solo per ottenere l'ultimo elemento, se tu

  • sono già in loop, e
  • sai che il ciclo finirà (non si interromperà o si spegnerà a causa di errori), altrimenti punterà all'ultimo elemento referenziato dal ciclo.

Ottenere e rimuoverlo

Possiamo anche modificare il nostro elenco originale rimuovendo e restituendo l'ultimo elemento:

>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']

Ma ora l'elenco originale viene modificato.

( -1 è in realtà l'argomento predefinito, quindi list.pop può essere utilizzato senza un argomento index):

>>> a_list.pop()
'two'

Fallo solo se

  • sai che la lista contiene elementi o sono pronti a gestire l'eccezione se è vuota, e
  • hai intenzione di rimuovere l'ultimo elemento dalla lista, trattandolo come una pila.

Questi sono casi d'uso validi, ma non molto comuni.

Salvare il resto del retro per dopo:

Non so perché lo faresti, ma per completezza, dal momento che i ritorni reversed restituiscono un iteratore (che supporta il protocollo iteratore) puoi passare il risultato a next :

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

Quindi è come fare il contrario di questo:

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

Ma non riesco a pensare a una buona ragione per farlo, a meno che non avrai più bisogno del resto dell'iter iteratore successivo, che probabilmente assomiglierebbe più a questo:

reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)

use_later = list(reverse_iterator)

e adesso:

>>> use_later
[2, 1]
>>> last_element
3

In Python, come si ottiene l'ultimo elemento di una lista?


some_list = [1, 2, 3]

Metodo 1:

some_list[-1]

Metodo 2:

**some_list.reverse()** 

**some_list[0]**

Metodo 3:

some_list.pop() 

Data: 2017-12-06

alist.pop()

Faccio un cheatsheet esaustivo di tutti gli 11 metodi della lista come riferimento.

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

Il modo più semplice per visualizzare l'ultimo elemento in Python è

>>> list[-1:] # returns indexed value
    [3]
>>> list[-1]  # returns value
    3

ci sono molti altri metodi per raggiungere tale obiettivo, ma questi sono brevi e dolci da usare.


Ok, ma che dire di comune in quasi tutti gli items[len(items) - 1] linguaggio items[len(items) - 1] ? Questo è IMO il modo più semplice per ottenere l'ultimo elemento, perché non richiede alcuna conoscenza pitonica .


Puoi anche fare:

alist.pop()

Dipende da cosa vuoi fare con la tua lista perché il metodo pop() cancellerà l'ultimo elemento.


se vuoi ottenere solo l'ultimo valore della lista, dovresti usare:

your_list[-1]

MA se vuoi ottenere un valore e anche rimuoverlo dalla lista, puoi usare:

your_list.pop()

OR: puoi anche fare un pop con indice ...

your_list.pop(-1)

list[-1] recupererà l'ultimo elemento della lista senza cambiare la lista. list.pop() recupererà l'ultimo elemento della lista, ma cambierà / cambierà l'elenco originale. Di solito, la modifica dell'elenco originale non è consigliata.

In alternativa, se, per qualche ragione, stai cercando qualcosa di meno pitone, puoi usare list[len(list)-1] , assumendo che la lista non sia vuota.


some_list[-1] è il più corto e il più Pythonic.

In effetti, puoi fare molto di più con questa sintassi. La some_list[-n] ottiene l'elemento nth-to-last. Quindi some_list[-1] ottiene l'ultimo elemento, some_list[-2] ottiene il penultimo, ecc, fino a some_list[-len(some_list)] , che ti dà il primo elemento.

Puoi anche impostare gli elementi della lista in questo modo. Per esempio:

>>> 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]

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




indexing