Una comprensione dell'elenco Python è costituita da parentesi contenenti l'espressione, che viene eseguita per ciascun elemento insieme al ciclo for per scorrere ogni elemento nell'elenco Python.
Esempio:
Pitone
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Produzione
[24, 26, 28]>
Sintassi di comprensione dell'elenco Python
Sintassi: newList = [ espressione(elemento) per elemento In oldList Se condizione ]
Parametro:
espressione: rappresenta l'operazione che desideri eseguire su ogni elemento all'interno dell'iterabile. elemento: il termine variabile si riferisce a ciascun valore preso dall'iterabile. iterable: specifica la sequenza di elementi su cui vuoi scorrere (ad esempio, una lista, una tupla o una stringa). condizione: (facoltativo) un filtro aiuta a decidere se un elemento deve essere aggiunto o meno al nuovo elenco.
Ritorno: Il valore restituito da una lista di comprensione è una nuova lista contenente gli elementi modificati che soddisfano i criteri specificati.
La comprensione dell'elenco Python fornisce una sintassi molto più breve per creare un nuovo elenco basato sui valori di un elenco esistente.
Elenco di comprensione nell'esempio di Python
Ecco un esempio di utilizzo della comprensione delle liste per trovare il quadrato del numero in Python.
Pitone
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Produzione
[1, 4, 9, 16, 25]>
Iterazione con la comprensione delle liste
In questo esempio, stiamo assegnando 1, 2 e 3 all'elenco e stiamo stampando l'elenco utilizzando la comprensione dell'elenco.
Pitone
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Produzione
[1, 2, 3]>
Anche elencare utilizzando la comprensione delle liste
In questo esempio, stiamo stampando i numeri pari da 0 a 10 utilizzando la comprensione delle liste.
Pitone
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Produzione
[0, 2, 4, 6, 8, 10]>
Matrice utilizzando la comprensione delle liste
In questo esempio, stiamo assegnando numeri interi da 0 a 2 o 3 righe della matrice e stampandoli utilizzando la comprensione delle liste.
Pitone
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Produzione
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Elenco comprensioni vs ciclo For
Esistono vari modi per scorrere un elenco. Tuttavia, l'approccio più comune è utilizzare il file per ciclo continuo . Consideriamo l’esempio seguente:
Pitone
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Produzione
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Sopra c'è l'implementazione dell'approccio tradizionale per scorrere una lista, una stringa, una tupla, ecc. Ora, la comprensione delle liste in Python svolge lo stesso compito e rende anche il programma più semplice.
Le comprensioni delle liste traducono il tradizionale approccio di iterazione utilizzando per ciclo in una formula semplice, rendendoli quindi facili da usare. Di seguito è riportato l'approccio per scorrere una lista, una stringa, una tupla, ecc. utilizzando la comprensione delle liste in Python.
Pitone
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Produzione
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Analisi del tempo nella comprensione delle liste e nel loop
Le comprensioni delle liste in Python sono più efficienti sia dal punto di vista computazionale che in termini di codifica di spazio e tempo rispetto a un ciclo for. In genere, sono scritti in un'unica riga di codice. Il programma seguente illustra la differenza tra loop e comprensione dell'elenco in base alle prestazioni.
Pitone
a capo automatico delle parole CSS
# Import required module> import> time> > > # define function to implement for loop> def> for_loop(n):> >result>=> []> >for> i>in> range>(n):> >result.append(i>*>*>2>)> >return> result> > > # define function to implement list comprehension> def> list_comprehension(n):> >return> [i>*>*>2> for> i>in> range>(n)]> > > # Driver Code> > # Calculate time taken by for_loop()> begin>=> time.time()> for_loop(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for_loop:'>,>round>(end>->begin,>2>))> > # Calculate time takens by list_comprehension()> begin>=> time.time()> list_comprehension(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for list_comprehension:'>,>round>(end>->begin,>2>))> |
>
>
Produzione
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Dal programma sopra, possiamo vedere che la comprensione delle liste è molto più veloce del ciclo for.
Comprensioni degli elenchi nidificati
Comprensioni degli elenchi nidificati non sono altro che una comprensione di lista all'interno di un'altra comprensione di lista che è abbastanza simile ai cicli for nidificati. Di seguito è riportato il programma che implementa il ciclo annidato:
Pitone
matrix>=> []> > for> i>in> range>(>3>):> > ># Append an empty sublist inside the list> >matrix.append([])> > >for> j>in> range>(>5>):> >matrix[i].append(j)> > print>(matrix)> |
>
>
Produzione
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Ora, utilizzando le comprensioni degli elenchi annidati, lo stesso output può essere generato in meno righe di codice.
Pitone
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Produzione
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Elenco comprensioni e Lambda
Espressioni Lambda non sono altro che rappresentazioni abbreviate di funzioni Python. L'uso delle comprensioni delle liste con lambda crea una combinazione efficiente. Consideriamo gli esempi seguenti:
In questo esempio, stiamo inserendo i numeri da 10 a 50 nell'elenco e stampandolo.
Pitone
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Produzione
[10, 20, 30, 40, 50]>
Qui abbiamo utilizzato il ciclo for per stampare una tabella di 10.
Pitone
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Produzione
[10, 20, 30, 40, 50]>
Ora qui abbiamo utilizzato solo la comprensione delle liste per visualizzare una tabella di 10.
Pitone
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Produzione
[10, 20, 30, 40, 50]>
Infine, utilizziamo lambda + list comprehension per visualizzare la tabella da 10. Questa combinazione è molto utile per ottenere soluzioni efficienti in meno righe di codice per problemi complessi.
Condizionali nella comprensione delle liste
Possiamo anche aggiungere istruzioni condizionali alla comprensione della lista. Possiamo creare un elenco utilizzando allineare(), operatori , ecc. e cal applicano anche alcune condizioni all'elenco utilizzando il comando se dichiarazione .
Punti chiave
- La comprensione dell'elenco è un mezzo efficace per descrivere e costruire elenchi basati su elenchi attuali.
- In generale, la comprensione delle liste è leggera e più semplice delle funzioni e dei cicli di formazione delle liste standard.
- Non dovremmo scrivere codici lunghi per la comprensione delle liste per garantire un codice user-friendly.
- Ogni comprensione della lista può essere riscritta nel ciclo for, ma nel contesto dell'interpretazione della lista, ogni ciclo for non può essere riscritto.
Di seguito sono riportati alcuni esempi che descrivono l'uso delle comprensioni delle liste piuttosto che l'approccio tradizionale all'iterazione attraverso iterable:
Comprensione dell'elenco Python utilizzando If-else.
Nell'esempio, stiamo controllando da 0 a 7 se il numero è pari, quindi inserirlo Numero pari all'elenco altrimenti inserisci Numero dispari alla lista.
Pitone
come eseguire lo script in Linux
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Produzione
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
IF nidificato con comprensione dell'elenco
In questo esempio, stiamo inserendo nell'elenco numeri che sono multipli da 10 a 100 e stampandoli.
Pitone
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Produzione
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Visualizza un quadrato di numeri da 1 a 10
In questo esempio, stiamo inserendo un quadrato da 1 a 10 nell'elenco e stamperemo l'elenco.
Pitone
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Produzione
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Visualizza la trasposizione della matrice 2D
In questo esempio, stiamo effettuando una trasposizione della matrice utilizzando la comprensione delle liste.
Pitone
# Assign matrix> twoDMatrix>=> [[>10>,>20>,>30>],> >[>40>,>50>,>60>],> >[>70>,>80>,>90>]]> > # Generate transpose> trans>=> [[i[j]>for> i>in> twoDMatrix]>for> j>in> range>(>len>(twoDMatrix[>0>]))]> > print>(trans)> |
>
>
Produzione
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Attiva/disattiva il caso di ciascun carattere in una stringa
In questo esempio, invertiamo il caso di ciascun carattere in una determinata stringa utilizzando l'operatore XOR con 32 e memorizziamo il risultato in un elenco.
Pitone
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Produzione
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Invertire ogni stringa in una tupla
In questo esempio, invertiamo le stringhe nel ciclo for, le inseriamo nell'elenco e stampiamo l'elenco.
inizializzatore di dizionario C#
Pitone
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Produzione
['skeeG', 'rof', 'skeeG']>
Creazione di un elenco di tuple da due elenchi separati
In questo esempio, abbiamo creato due elenchi di nomi ed età. Stiamo usando cerniera lampo() nella comprensione delle liste e stiamo inserendo il nome e l'età come tupla nella lista. Infine, stiamo stampando l'elenco delle tuple.
Pitone
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Produzione:
[('G', 25), ('G', 30), ('g', 35)]> Visualizza la somma delle cifre di tutti gli elementi dispari in un elenco.
In questo esempio, abbiamo creato un elenco e stiamo trovando la somma delle cifre di ogni elemento dispari nell'elenco.
Pitone
# Explicit function> def> digitSum(n):> >dsum>=> 0> >for> ele>in> str>(n):> >dsum>+>=> int>(ele)> >return> dsum> > > # Initializing list> List> => [>367>,>111>,>562>,>945>,>6726>,>873>]> > # Using the function on odd elements of the list> newList>=> [digitSum(i)>for> i>in> List> if> i &>1>]> > # Displaying new list> print>(newList)> |
>
>
Produzione
[16, 3, 18, 18]>
Vantaggi della comprensione delle liste
- Più efficiente in termini di tempo e spazio rispetto ai loop.
- Richiede meno righe di codice.
- Trasforma l'istruzione iterativa in una formula.
Domande sugli esercizi di comprensione dell'elenco Python
Di seguito sono riportate due domande di esercizio sulla comprensione dell'elenco Python. Abbiamo trattato il codice base di comprensione delle liste per trovare il cubo di numeri e il codice per trovare la lunghezza di una parola utilizzando la comprensione delle liste e la funzione len().
Q1. Domanda di esercizio sul cubo di numeri utilizzando la comprensione delle liste
Pitone
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Produzione
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Trovare la domanda sull'esercizio sulla lunghezza delle parole utilizzando la comprensione dell'elenco
Pitone
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Produzione
[5, 6, 6, 6]>