Metodi delle liste in

Informazioni su Metodi delle liste

Un list è una raccolta mutabile di elementi in sequenza. Come la maggior parte delle collezioni (vedi i tipi incorporati tuple, dict e set), gli array possono contenere riferimenti a qualsiasi tipo di dato (o a più tipi), compresi altri array. In Python sono considerati una sequenza e possono essere copiati in tutto o in parte tramite la notazione slice. Come ogni sequenza, gli elementi all'interno di lists possono essere referenziati tramite un 0-based index da sinistra, o un -1-based index da destra.

Gli array supportano sia le operazioni di sequenza comuni sia quelle mutabili, come min(<list>)/max(<list>), <list>.index(), <list>.append() e <list>.reverse(). Gli elementi possono essere iterati con il costrutto for item in <list>, e con for index, item in enumerate(<list>) quando servono sia l'elemento che il suo indice.

Python offre molti metodi utili per lavorare con gli array.

Poiché gli array sono mutabili, i metodi degli array modificano l'oggetto array originale passato al metodo. Se la mutazione non è desiderabile, è necessario creare una shallow copy (come minimo) dell'oggetto list originale tramite slice o <list>.copy().

Aggiungere elementi

Per aggiungere elementi alla fine di un array esistente si può usare <list>.append(<item>):

>>> numbers = [1, 2, 3]
>>> numbers.append(9)

>>> numbers
[1, 2, 3, 9]

Invece di accodare, <list>.insert(<index>, <item>) aggiunge l'elemento in un indice specifico all'interno dell'array. <index> è l'indice dell'elemento prima del quale vuoi che compaia il nuovo elemento. <item> è l'elemento da inserire.

Nota: se <index> è 0, l'elemento viene aggiunto all'inizio dell'array. Se <index> è maggiore dell'ultimo indice dell'array, l'elemento viene aggiunto in ultima posizione, l'equivalente di usare <list>.append(<item>).

>>> numbers = [1, 2, 3]
>>> numbers.insert(0, -2)

>>> numbers
[-2, 1, 2, 3]

>>> numbers.insert(1, 0)

>>> numbers
[-2, 0, 1, 2, 3]

Un iterable può essere combinato con un array esistente (concatenando i due) tramite <list>.extend(<iterable>). <list>.extend(<iterable>) scompatta l'iterable fornito, aggiungendo i suoi elementi nello stesso ordine alla fine dell'array di destinazione. Usare <list>.append(<item>) in questo caso aggiungerebbe l'intero iterable come singolo elemento.

>>> numbers = [1, 2, 3]
>>> other_numbers = [5, 6, 7]

>>> numbers.extend(other_numbers)

>>> numbers
[1, 2, 3, 5, 6, 7]

>>> numbers.extend([8, 9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9]

Rimuovere elementi

Si può usare <list>.remove(<item>) per rimuovere un elemento dall'array. <list>.remove(<item>) solleva un ValueError se l'elemento non è presente nell'array.

>>> numbers = [1, 2, 3]
>>> numbers.remove(2)

>>> numbers
[1, 3]

# Trying to remove a value that is not in the list throws a ValueError.
>>> numbers.remove(0)
ValueError: list.remove(x): x not in list

In alternativa, il metodo <list>.pop(<index>) rimuove e return un elemento da usare.

<list>.pop(<index>) accetta un parametro opzionale: l'index dell'elemento da rimuovere e restituire. Se l'argomento opzionale <index> non è specificato, viene rimosso e restituito l'ultimo elemento dell'array. Se <index> è un numero maggiore dell'ultimo indice dell'array, viene sollevato un IndexError.

>>> numbers = [1, 2, 3]
>>> numbers.pop(0)
1

>>> numbers
[2, 3]
>>> numbers.pop()
3

>>> numbers
[2]

# This will throw an error because there is only index 0.
>>> numbers.pop(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

Tutti gli elementi possono essere rimossi da un list tramite <list>.clear(). Non accetta alcun parametro.

>>> numbers = [1, 2, 3]
>>> numbers.clear()

>>> numbers
[]

Invertire e riordinare

L'ordine degli elementi dell'array può essere invertito sul posto con <list>.reverse(). Questo modifica l'array originale.

>>> numbers = [1, 2, 3]
>>> numbers.reverse()

>>> numbers
[3, 2, 1]

Un array può essere riordinato sul posto con l'aiuto di <list>.sort(). L'ordine di ordinamento predefinito è crescente da sinistra. La documentazione di Python offre ulteriori consigli e tecniche per l'ordinamento.

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

# The default sort order is *ascending*.
>>> names.sort()

>>> names
["Bruce", "Natasha", "Thor", "Tony"]

Per ordinare un array in ordine decrescente, passa un argomento reverse=True al metodo:

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]
>>> names.sort(reverse=True)

>>> names
["Tony", "Thor", "Natasha", "Bruce"]

Nei casi in cui modificare l'oggetto list originale non è desiderabile, si possono usare le funzioni incorporate sorted() e reversed(). sorted(<list>) restituisce una copia ordinata e accetta gli stessi parametri di <list>.sort(). reversed(<list>) restituisce un iteratore che produce gli elementi dell'array in ordine inverso. Gli Iterators saranno trattati in dettaglio in un altro esercizio.

Occorrenze di un elemento in un array

Per trovare il numero di occorrenze di un elemento in un array si può usare <list>.count(<item>). Restituisce il numero totale di volte in cui <item> compare come elemento nell'array.

>>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]

>>> items.count(1)
3

Trovare l'indice degli elementi

<list>.index(<item>) restituisce il numero di indice della prima occorrenza di un elemento passato. Se non ci sono occorrenze, viene sollevato un ValueError. L'indicizzazione è 0-based da sinistra, cioè la posizione del primo elemento è l'indice 0. È supportata anche l'indicizzazione da destra, che parte dall'indice -1.

>>> items = [7, 4, 1, 0, 2, 5]
>>> items.index(4)
1

>>> items.index(10)
ValueError: 10 is not in list

Fornendo gli indici start ed end la ricerca avviene all'interno di una sezione specifica dell'array:

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
>>> names.index("Tina")
0

>>> names.index("Tina", 2, 5)
3

Se non serve la posizione esatta di un elemento, l'operatore in incorporato è più efficiente per verificare l'appartenenza.

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]

>>> "Thomas" in names
True

Fare copie

Ricorda che in Python le variabili sono nomi che puntano a oggetti sottostanti. I nomi possono essere legati o rilegati a oggetti diversi nel corso della vita di un programma. Assegnare un oggetto list a un nuovo nome di variabile non copia l'oggetto né i dati a cui fa riferimento. Il nuovo nome e quello vecchio punteranno entrambi allo stesso oggetto list. Inoltre, gli array sono oggetti di tipo contenitore: per risparmiare spazio, i contenitori conservano solo riferimenti agli elementi che contengono, non gli elementi stessi. Questa «ottimizzazione» può avere conseguenze indesiderate per chi non sta attento.

<list>.copy() crea un nuovo oggetto list, ma non crea nuovi oggetti per gli elementi dell'array a cui fa riferimento: la copia è «superficiale». Una shallow copy di solito basta quando vuoi aggiungere o rimuovere elementi da uno degli oggetti list senza modificare l'altro. Ma se c'è anche solo la possibilità che gli elementi sottostanti di un list vengano modificati per errore (modificando così tutte le copie superficiali collegate), si dovrebbe usare copy.deepcopy() nel modulo copy per creare una copia completa o «profonda» di tutti i riferimenti e gli oggetti.

Per una spiegazione dettagliata del comportamento di nomi, valori, array e array annidati, dai un'occhiata a questo ottimo post sul blog di Ned Batchelder: Names and values: making a game board. Anche Shallow vs Deep Copying of Python Objects offre una buona panoramica sulle considerazioni da fare quando si copia.