indexing ad - Ottenere l'ultimo elemento di una lista in Python




del for (13)

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


Answers

lst[-1] è l'approccio migliore, ma con iterables generali, considera more_itertools.last :

Codice

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'

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 .


È inoltre possibile utilizzare il codice riportato di seguito, se non si desidera ottenere IndexError quando l'elenco è vuoto.

next(reversed(some_list), None)

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.


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

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

L'elenco Python supporta gli indici negativi.

a = [1, 2, 3]

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

O

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


some_list = [1, 2, 3]

Metodo 1:

some_list[-1]

Metodo 2:

**some_list.reverse()** 

**some_list[0]**

Metodo 3:

some_list.pop() 

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.


Questo potrebbe non essere il modo più efficiente, ma ho pensato di mettere un solo liner (in realtà un doppio rivestimento). Entrambe le versioni funzionano su liste annidate di gerarchia arbitraria e sfruttano le funzionalità del linguaggio (Python3.5) e la ricorsione.

def make_list_flat (l):
    flist = []
    flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]
    return flist

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = make_list_flat(a)
print (flist)

L'output è

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

Questo funziona in modo approfondito prima. La ricorsione scende fino a quando non trova un elemento non di listino, quindi estende la variabile locale fliste la riporta al genitore. Ogni volta che flistviene restituito, viene esteso ai genitori flistnella comprensione della lista. Pertanto, nella radice, viene restituito un elenco semplice.

Quella precedente crea diverse liste locali e le restituisce utilizzate per estendere l'elenco dei genitori. Penso che il modo per aggirare questo possa creare un gloabl flist, come di seguito.

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = []
def make_list_flat (l):
    flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]

make_list_flat(a)
print (flist)

L'output è di nuovo

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

Anche se in questo momento non sono sicuro dell'efficienza.





python list indexing