Comprensione delle liste in Python 3

Introduzione

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

Le liste sono ottime da utilizzare quando si desidera lavorare con molti valori correlati. Ti consentono di mantenere insieme i dati che appartengono insieme, di condensare il tuo codice e di eseguire contemporaneamente gli stessi metodi e operazioni su più valori.

Quando si pensa alle liste di Python e ad altre strutture dati che sono tipi di collezioni, è utile considerare tutte le diverse raccolte che si hanno sul proprio computer: la tua serie di file, le tue playlist musicali, i tuoi segnalibri del browser, le tue email, la raccolta di video a cui puoi accedere su un servizio di streaming e altro ancora.

Prerequisiti

Dovresti avere Python 3 installato e un ambiente di sviluppo configurato sul tuo computer o server. Se non hai un ambiente di sviluppo configurato, puoi fare riferimento alle guide di installazione e configurazione per un ambiente di sviluppo locale o per un ambiente di sviluppo sul tuo server appropriato per il tuo sistema operativo (Ubuntu, CentOS, Debian, ecc.).

Liste di stringhe

Per iniziare, creiamo una lista che contiene elementi del tipo di dati stringa:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Quando stampiamo la lista, l’output risponde esattamente come la lista che abbiamo creato:

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Come una sequenza ordinata di elementi, ogni elemento in una lista può essere chiamato individualmente, tramite l’indicizzazione. Le liste sono un tipo di dato composto da parti più piccole e sono molto flessibili perché è possibile aggiungere, rimuovere e modificare i valori. Quando è necessario memorizzare molti valori o iterare su valori e si desidera poter modificare facilmente quei valori, probabilmente si vorrà lavorare con tipi di dati di lista.

In questo tutorial, esamineremo alcuni modi per lavorare con le liste in Python.

Indicizzazione delle liste

Ogni elemento in una lista corrisponde a un numero di indice, che è un valore intero, a partire dal numero di indice 0.

Per la lista creature_marine, la suddivisione dell’indice appare così:

Il primo elemento, la stringa 'squalo' inizia all’indice 0, e la lista termina all’indice 4 con l’elemento 'anemone'.

Poiché ogni elemento in una lista Python ha un numero di indice corrispondente, siamo in grado di accedere e manipolare le liste nello stesso modo in cui possiamo farlo con altri tipi di dati sequenziali.

Ora possiamo chiamare un singolo elemento della lista facendo riferimento al suo numero di indice:

print(sea_creatures[1])

Output
cuttlefish

I numeri di indice per questa lista vanno da 0 a 4, come mostrato nella tabella sopra. Quindi, per chiamare individualmente qualsiasi degli elementi, faremmo riferimento ai numeri di indice in questo modo:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Se chiamiamo la lista creature_marine con un numero di indice maggiore di 4, sarà fuori dall’intervallo poiché non sarà valido:

print(sea_creatures[18])

Output
IndexError: list index out of range

Oltre ai numeri di indice positivi, possiamo anche accedere agli elementi della lista con un numero di indice negativo, contando all’indietro dalla fine della lista, partendo da -1. Questo è particolarmente utile se abbiamo una lista lunga e vogliamo individuare un elemento verso la fine di una lista.

Per la stessa lista creature_marine, lo scomposizione degli indici negativi appare così:

Quindi, se volessimo stampare l’elemento 'calamaro' utilizzando il suo numero di indice negativo, possiamo farlo in questo modo:

print(sea_creatures[-3])

Output
squid

Possiamo concatenare gli elementi di stringa in una lista con altre stringhe usando l’operatore +:

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

Siamo stati in grado di concatenare l’elemento stringa all’indice numero 0 con la stringa 'Sammy è un '. Possiamo anche utilizzare l’operatore + per concatenare 2 o più liste insieme.

Con i numeri di indice che corrispondono agli elementi all’interno di una lista, siamo in grado di accedere a ciascun elemento di una lista discretamente e lavorare con quegli elementi.

Modifica degli Elementi nelle Liste

Possiamo utilizzare l’indicizzazione per cambiare gli elementi all’interno della lista, impostando un numero di indice uguale a un valore diverso. Ciò ci dà un maggiore controllo sulle liste poiché siamo in grado di modificare e aggiornare gli elementi che contengono.

Se vogliamo cambiare il valore della stringa dell’elemento all’indice 1 da 'seppia' a 'polpo', possiamo farlo così:

sea_creatures[1] = 'octopus'

Ora, quando stampiamo creature_marine, la lista sarà diversa:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

Possiamo anche cambiare il valore di un elemento utilizzando un numero di indice negativo invece:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Adesso 'pesce blob' ha sostituito 'calamaro' al numero di indice negativo di -3 (che corrisponde al numero di indice positivo di 2).

Avere la possibilità di modificare gli elementi nelle liste ci consente di cambiare e aggiornare le liste in modo efficiente.

Taglio delle liste

Possiamo anche estrarre alcuni elementi dalla lista. Diciamo che vogliamo stampare solo gli elementi centrali di sea_creatures, possiamo farlo creando uno slice. Con gli slice, possiamo chiamare più valori creando un intervallo di numeri di indice separati da due punti [x:y]:

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

Nel creare uno slice, come in [1:4], il primo numero di indice è dove lo slice inizia (inclusivo), e il secondo numero di indice è dove lo slice finisce (esclusivo), ecco perché nel nostro esempio sopra gli elementi alla posizione 1, 2 e 3 sono gli elementi che vengono stampati.

Se vogliamo includere uno dei due estremi della lista, possiamo omettere uno dei numeri nella sintassi list[x:y]. Ad esempio, se vogliamo stampare i primi 3 elementi della lista sea_creatures — che sarebbero 'squalo', 'polpo', 'blobfish' — possiamo farlo digitando:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Questo ha stampato l’inizio della lista, fermandosi proprio prima dell’indice 3.

Per includere tutti gli elementi alla fine di una lista, invertiamo la sintassi:

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

Possiamo anche usare numeri di indice negativi quando facciamo slice delle liste, simili ai numeri di indice positivi:

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

Un ultimo parametro che possiamo utilizzare con lo slicing è chiamato stride, che si riferisce a quanti elementi avanzare dopo che il primo elemento è stato recuperato dalla lista. Finora abbiamo omesso il parametro di stride, e Python predefinisce il valore di stride a 1, in modo che ogni elemento tra due numeri di indice venga recuperato.

La sintassi per questa costruzione è lista[x:y:z], con z che si riferisce al valore di stride. Facciamo una lista più grande, quindi la affettiamo e diamo al valore di stride un valore di 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

La nostra costruzione numeri[1:11:2] stampa i valori tra i numeri di indice inclusivo di 1 ed esclusivo di 11, quindi il valore di stride di 2 dice al programma di stampare solo ogni altro elemento.

Possiamo omettere i primi due parametri e utilizzare solo il valore di stride come parametro con la sintassi lista[::z]:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

Stampando la lista numeri con lo stride impostato su 3, vengono stampati solo ogni terzo elemento:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Affettare liste con numeri di indice positivi e negativi e indicare lo stride ci consente di controllare le liste e ottenere l’output che stiamo cercando di ottenere.

Modifica delle liste con operatori

Gli operatori possono essere utilizzati per apportare modifiche alle liste. Esamineremo l’utilizzo degli operatori + e * e le loro forme composte += e *=.

L’operatore + può essere utilizzato per concatenare due o più liste insieme:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Poiché l’operatore + può concatenare, può essere utilizzato per aggiungere un elemento (o più) in forma di lista alla fine di un’altra lista. Ricordati di inserire l’elemento tra parentesi quadre:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

L’operatore * può essere utilizzato per moltiplicare liste. Forse è necessario fare copie di tutti i file in una directory su un server, o condividere una playlist con gli amici – in questi casi sarebbe necessario moltiplicare le raccolte di dati.

Moltiplichiamo la lista sea_creatures per 2 e la lista oceans per 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Utilizzando l’operatore * possiamo replicare le nostre liste il numero di volte specificato.

Possiamo anche utilizzare forme composte degli operatori + e * con l’operatore di assegnazione =. Gli operatori composti += e *= possono essere utilizzati per popolare liste in modo rapido e automatizzato. È possibile utilizzare questi operatori per riempire le liste con segnaposto che è possibile modificare successivamente con input forniti dall’utente, ad esempio.

Aggiungiamo un elemento in forma di lista alla lista sea_creatures. Questo elemento fungerà da segnaposto, e vorremmo aggiungere questo elemento segnaposto diverse volte. Per fare ciò, utilizzeremo l’operatore += con un ciclo for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

Per ogni iterazione del ciclo for, viene aggiunto un ulteriore elemento di lista di 'pesce' alla lista originale creature marine.

L’operatore *= si comporta in modo simile:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Gli operatori + e * possono essere utilizzati per concatenare liste e moltiplicare liste. Gli operatori composti += e *= possono concatenare liste e moltiplicare liste e passare la nuova identità alla lista originale.

Rimozione di un elemento da una lista

Gli elementi possono essere rimossi dalle liste utilizzando l’istruzione del. Questo eliminerà il valore al numero di indice che specificate all’interno di una lista.

Dalla lista creature marine, rimuoviamo l’elemento 'polpo'. Questo elemento si trova nella posizione dell’indice di 1. Per rimuovere l’elemento, utilizzeremo l’istruzione del e quindi richiameremo la variabile di lista e il numero di indice di quell’elemento:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Ora l’elemento alla posizione dell’indice 1, la stringa 'polpo', non è più nella nostra lista creature marine.

Possiamo anche specificare un intervallo con l’istruzione del. Supponiamo volessimo rimuovere non solo l’elemento 'polpo', ma anche 'pesce blob' e 'mantis gamberi' anche. Possiamo chiamare un intervallo in creature marine con l’istruzione del per realizzare questo:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

Utilizzando un intervallo con l’istruzione del, siamo stati in grado di rimuovere gli elementi compresi tra l’indice 1 (incluso) e l’indice 4 (escluso), lasciandoci con una lista di 3 elementi dopo la rimozione di 3 elementi.

L’istruzione del ci consente di rimuovere elementi specifici dal tipo di dati lista.

Costruzione di una lista con elementi di lista

Le liste possono essere definite con elementi composti da liste, con ogni lista tra parentesi quadre racchiusa all’interno delle parentesi quadre più grandi della lista genitore:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Queste liste all’interno di liste sono chiamate liste nidificate.

Per accedere a un elemento all’interno di questa lista, dovremo usare più indici:

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

La prima lista, poiché è uguale a un elemento, avrà l’indice numero 0, che sarà il primo numero nella costruzione, e la seconda lista avrà l’indice numero 1. All’interno di ciascuna lista nidificata ci saranno indici separati, che chiameremo nel secondo numero di indice:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Quando si lavora con liste di liste, è importante tenere presente che sarà necessario fare riferimento a più di un numero di indice per accedere a elementi specifici all’interno della relativa lista nidificata.

Conclusione

Il tipo di dati lista è un tipo di dato flessibile che può essere modificato nel corso del programma. Questo tutorial ha coperto le caratteristiche di base delle liste, tra cui l’indicizzazione, il taglio, la modifica e la concatenazione delle liste.

Da qui, puoi scoprire di più su come lavorare con le liste in Python leggendo “Come utilizzare i metodi delle liste”, e su le comprensioni di lista per creare liste basate su liste esistenti. Per saperne di più sui tipi di dati in generale, puoi leggere il nostro tutorial “Comprensione dei tipi di dati”.