Comprensione delle Comprehensioni di Lista in Python 3

Introduzione

Le comprensioni di lista offrono un modo conciso per creare liste basate su liste esistenti. Quando si utilizzano le comprensioni di lista, le liste possono essere costruite sfruttando qualsiasi iterabile, inclusi stringhe e tuple.

Sintatticamente, le comprensioni di lista consistono in un iterabile contenente un’espressione seguita da una clausola for. Questa può essere seguita da ulteriori clausole for o if, quindi la familiarità con i cicli for e istruzioni condizionali ti aiuterà a comprendere meglio le comprensioni di lista.

Le comprehension delle liste forniscono una sintassi alternativa per la creazione di liste e altri tipi di dati sequenziali. Mentre altri metodi di iterazione, come i cicli for, possono essere utilizzati per creare liste, le comprensioni delle liste possono essere preferite perché possono limitare il numero di righe utilizzate nel programma.

Prerequisiti

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

Comprensioni delle Liste

In Python, le comprensioni delle liste sono costruite in questo modo:

list_variable = [x for x in iterable]

A list, or other iterable, is assigned to a variable. Additional variables that stand for items within the iterable are constructed around a for clause. The in keyword is used as it is in for loops, to iterate over the iterable.

Diamo un’occhiata a un esempio che crea una lista basata su una stringa:

shark_letters = [letter for letter in 'shark']
print(shark_letters)

Qui, la nuova lista viene assegnata alla variabile shark_letters, e letter viene usata per rappresentare gli elementi contenuti nella stringa iterabile 'shark'.

Per confermare come appare la nuova lista shark_letters, richiamiamola con print() e otteniamo il seguente output:

Output
['s', 'h', 'a', 'r', 'k']

La lista che abbiamo creato con la list comprehension è composta dagli elementi della stringa 'shark', cioè una stringa per ogni lettera.

Le list comprehension possono essere riscritte come cicli for, anche se non ogni ciclo for può essere riscritto come list comprehension.

Utilizzando la nostra list comprehension che ha creato la lista shark_letters sopra, riscriviamola come un ciclo for. Questo potrebbe aiutarci a capire meglio come funziona la list comprehension.

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

Quando si crea una lista con un ciclo for, la variabile assegnata alla lista deve essere inizializzata con una lista vuota, come nella prima riga del nostro blocco di codice. Il ciclo for itera quindi sull’elemento, utilizzando la variabile lettera nella stringa iterabile 'squalo'. All’interno del ciclo for, ogni elemento della stringa viene aggiunto alla lista con il metodo list.append(x).

Riscrivendo la comprensione della lista come un ciclo for otteniamo lo stesso risultato:

Output
['s', 'h', 'a', 'r', 'k']

Le comprensioni delle liste possono essere riscritte come cicli for, e alcuni cicli for possono essere riscritti come comprensioni delle liste per rendere il codice più sintetico.

Utilizzo delle Condizioni con le Comprensioni delle Liste

Le comprensioni delle liste possono utilizzare istruzioni condizionali per modificare liste esistenti o altri tipi di dati sequenziali durante la creazione di nuove liste.

Guardiamo un esempio di un’istruzione if utilizzata in una comprensione della lista:

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

La comprensione della lista utilizza la tupla fish_tuple come base per la nuova lista chiamata fish_list. Le parole chiave for e in sono utilizzate, come sono state nella sezione sopra, e ora viene aggiunta un’affermazione if. L’affermazione if dice di aggiungere solo gli elementi che non sono equivalenti alla stringa 'polpo', quindi la nuova lista prende solo gli elementi dalla tupla che non corrispondono a 'polpo'.

Quando eseguiamo questo, noteremo che fish_list contiene gli stessi elementi di stringa di fish_tuple tranne per il fatto che la stringa 'polpo' è stata omessa:

Output
['blowfish', 'clownfish', 'catfish']

Quindi, la nostra nuova lista ha ogni elemento della tupla originale tranne la stringa esclusa dalla dichiarazione condizionale.

Creeremo un altro esempio che utilizza operatori matematici, interi, e il tipo di sequenza range().La lista che viene creata, number_list, sarà popolata con i valori al quadrato di ogni elemento nell’intervallo da 0 a 9 se il valore dell’elemento è divisibile per 2. L’output è il seguente:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

La lista che viene creata, number_list, verrà popolata con i valori al quadrato di ogni elemento nell’intervallo da 0 a 9 se il valore dell’elemento è divisibile per 2. L’output è il seguente:

Output
[0, 4, 16, 36, 64]

Per scomporre un po’ di più ciò che fa la comprensione della lista, pensiamo a cosa verrebbe stampato se stessimo chiamando solo x per x nell'intervallo (10). Il nostro piccolo programma e l’output sarebbero allora simili al seguente:

number_list = [x for x in range(10)]
print(number_list)

Output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Ora, aggiungiamo la clausola condizionale:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

Output
[0, 2, 4, 6, 8]

La clausola if ha limitato gli elementi nella lista finale solo agli elementi che sono divisibili per 2, escludendo tutti i numeri dispari.

Infine, possiamo aggiungere l’operatore per avere ogni x al quadrato:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

Quindi ognuno dei numeri nella lista precedente di [0, 2, 4, 6, 8] sono ora al quadrato:

Output
[0, 4, 16, 36, 64]

Puoi anche replicare istruzioni if nidificate con una comprensione della lista:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

Qui, la comprensione della lista controllerà prima se il numero x è divisibile per 3, e poi controllerà se x è divisibile per 5. Se x soddisfa entrambi i requisiti verrà stampato, e l’output è:

Output
[0, 15, 30, 45, 60, 75, 90]

Le clausole condizionali if possono essere utilizzate per controllare quali elementi da una sequenza esistente sono inclusi nella creazione di una nuova lista.

Cicli Nidificati in una Comprehension di Lista

Cicli nidificati possono essere utilizzati per eseguire più iterazioni nei nostri programmi.

Questa volta, rivedremo una costruzione di ciclo for nidificato esistente e lavoreremo verso una comprehension di lista.

Il nostro codice creerà una nuova lista che itera su 2 liste e esegue operazioni matematiche basate su di esse. Ecco il nostro blocco di codice di ciclo for nidificato:

my_list = []

for x in [20, 40, 60]:
	for y in [2, 4, 6]:
		my_list.append(x * y)

print(my_list)

Quando eseguiamo questo codice, otteniamo il seguente output:

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

Questo codice sta moltiplicando gli elementi della prima lista per gli elementi della seconda lista in ogni iterazione.

Per trasformarlo in una comprehension di lista, condenseremo ogni riga di codice in una riga, iniziando con l’operazione x * y. Ciò sarà seguito dal ciclo for esterno, quindi dal ciclo for interno. Aggiungeremo una dichiarazione print() sotto la nostra comprehension di lista per confermare che la nuova lista corrisponde alla lista che abbiamo creato con il nostro blocco di ciclo for nidificato sopra:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

La nostra comprehension di lista prende i cicli for nidificati e li appiattisce in una riga di codice mentre crea ancora la stessa lista esatta da assegnare alla variabile my_list.

Le list comprehension ci forniscono un modo conciso di creare liste, consentendoci di condensare diverse righe di codice in una sola riga. Tuttavia, è importante tenere a mente che la leggibilità del nostro codice dovrebbe sempre avere la priorità, quindi quando una riga di list comprehension diventa troppo lunga o ingombrante, potrebbe essere meglio dividerla in loop.

Conclusione

Le list comprehension ci consentono di trasformare una lista o un altro tipo di sequenza in una nuova lista. Offrono una sintassi concisa per completare questa attività, limitando il numero di righe di codice.

Le list comprehension seguono la forma matematica della notazione costruttiva di insiemi o della comprensione degli insiemi, quindi potrebbero risultare particolarmente intuitive per i programmatori con una formazione matematica.

Anche se le list comprehension possono rendere il nostro codice più conciso, è importante assicurarci che il nostro codice finale sia il più leggibile possibile, quindi le righe di codice molto lunghe dovrebbero essere evitate per garantire che il nostro codice sia user friendly.