Una comprensió de llista de Python consta de claudàtors que contenen l'expressió, que s'executa per a cada element juntament amb el bucle for per iterar sobre cada element de la llista de Python.
Exemple:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Sortida
[24, 26, 28]>
Sintaxi de comprensió de llista de Python
Sintaxi: novaLlista = [ expressió (element) per element en llista antiga si condició ]
Paràmetre:
expressió : representa l'operació que voleu executar en cada element de l'iterable. element : el terme variable es refereix a cada valor extret de l'iterable. iterable: especifiqueu la seqüència d'elements que voleu iterar (per exemple, una llista, una tupla o una cadena). condició : (Opcional) Un filtre ajuda a decidir si s'ha d'afegir o no un element a la llista nova.
Tornada: El valor de retorn d'una comprensió de llista és una llista nova que conté els elements modificats que compleixen els criteris donats.
La comprensió de la llista de Python proporciona una sintaxi molt més curta per crear una llista nova basada en els valors d'una llista existent.
Exemple de comprensió de llista en Python
Aquí teniu un exemple d'ús de la comprensió de llistes per trobar el quadrat del nombre a Python.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Sortida
[1, 4, 9, 16, 25]>
Iteració amb comprensió de llistes
En aquest exemple, estem assignant 1, 2 i 3 a la llista i estem imprimint la llista mitjançant la Comprensió de llistes.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Sortida
[1, 2, 3]>
Llista fins i tot utilitzant la comprensió de llistes
En aquest exemple, estem imprimint els nombres parells del 0 al 10 mitjançant la comprensió de llistes.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Sortida
[0, 2, 4, 6, 8, 10]>
Matriu utilitzant la comprensió de llistes
En aquest exemple, estem assignant nombres enters de 0 a 2 a 3 files de la matriu i l'estem imprimint mitjançant la comprensió de llistes.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Sortida
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Llista Comprehensions vs For Loop
Hi ha diverses maneres d'iterar una llista. Tanmateix, l'enfocament més comú és utilitzar el per bucle . Vegem l'exemple següent:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Sortida
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
A dalt hi ha la implementació de l'enfocament tradicional per iterar a través d'una llista, una cadena, una tupla, etc. Ara, la comprensió de llistes en Python fa la mateixa tasca i també fa que el programa sigui més senzill.
Llista Comprehensions tradueix l'enfocament tradicional d'iteració utilitzant per bucle en una fórmula senzilla, per tant, fàcil d'utilitzar. A continuació es mostra l'enfocament per iterar a través d'una llista, una cadena, una tupla, etc. utilitzant la comprensió de llista en Python.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Sortida
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Anàlisi de temps en Comprensions de llista i bucle
Les llistes de comprensió a Python són més eficients tant computacionalment com en termes d'espai i temps de codificació que un bucle for. Normalment, s'escriuen en una única línia de codi. El programa següent mostra la diferència entre els bucles i la comprensió de la llista en funció del rendiment.
Python
tipus de proves de programari
# 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>))> |
>
>
Sortida
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Des del programa anterior, podem veure que la comprensió de la llista és bastant més ràpida que la del bucle.
Comprensió de llistes niuades
Comprensió de llistes niuades no són més que una comprensió de llista dins d'una altra comprensió de llista que és força semblant a bucles for imbricats. A continuació es mostra el programa que implementa el bucle imbricat:
Python
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)> |
>
>
Sortida
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Ara, utilitzant comprensió de llistes imbricades, es pot generar la mateixa sortida en menys línies de codi.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Sortida
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Llista Comprensions i Lambda
Expressions Lambda no són més que representacions abreujades de les funcions de Python. L'ús de llistes de comprensió amb lambda crea una combinació eficient. Vegem els exemples següents:
En aquest exemple, estem inserint números del 10 al 50 a la llista i la imprimim.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Sortida
[10, 20, 30, 40, 50]>
Aquí, hem utilitzat for loop per imprimir una taula de 10.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Sortida
[10, 20, 30, 40, 50]>
Ara aquí, només hem utilitzat la comprensió de llista per mostrar una taula de 10.
Python
caca
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Sortida
[10, 20, 30, 40, 50]>
Finalment, utilitzem lambda + comprensió de llista per mostrar la taula de 10. Aquesta combinació és molt útil per obtenir solucions eficients en menys línies de codi per a problemes complexos.
Condicionals en la comprensió de llistes
També podem afegir enunciats condicionals a la comprensió de la llista. Podem crear una llista utilitzant rang(), operadors , etc. i cal també apliquen algunes condicions a la llista utilitzant el declaració si .
Punts clau
- La comprensió de la llista és un mitjà eficaç per descriure i construir llistes basades en llistes actuals.
- En general, la comprensió de llistes és lleugera i més senzilla que les funcions i bucles estàndard de formació de llistes.
- No hem d'escriure codis llargs per a la comprensió de llistes per tal de garantir un codi fàcil d'utilitzar.
- Cada comprensió de la llista es pot reescriure en bucle for, però en el context de la interpretació de la llista, cada bucle for no es pot reescriure.
A continuació es mostren alguns exemples que representen l'ús de la comprensió de llistes en lloc de l'enfocament tradicional d'iterar a través d'iterables:
Comprensió de la llista de Python utilitzant If-else.
A l'exemple, estem comprovant que del 0 al 7 si el nombre és parell, llavors inseriu-lo Número parell a la llista sinó inseriu-lo Nombre senar a la llista.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Sortida
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
IF nidat amb comprensió de llista
En aquest exemple, estem inserint números a la llista que és un múltiple de 10 a 100 i l'imprimem.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Sortida
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Mostra un quadrat de nombres de l'1 al 10
En aquest exemple, estem inserint un quadrat de l'1 al 10 a la llista i imprimint la llista.
Python
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Sortida
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Mostra la transposició de la matriu 2D
En aquest exemple, estem fent una transposició de la matriu mitjançant la comprensió de llista.
Python
# 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)> |
>
>
Sortida
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Commuteu les majúscules i minúscules de cada caràcter d'una cadena
En aquest exemple, canviem el cas de cada caràcter d'una cadena determinada utilitzant l'operador XOR amb 32 i emmagatzemem el resultat en una llista.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Sortida
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Inverteix cada corda en una tupla
En aquest exemple, estem invertint les cadenes en el bucle for i inserint-les a la llista i imprimint la llista.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Sortida
['skeeG', 'rof', 'skeeG']>
Creació d'una llista de tuples a partir de dues llistes separades
En aquest exemple, hem creat dues llistes de noms i edats. Estem utilitzant zip() en la comprensió de la llista i estem inserint el nom i l'edat com a tupla a la llista. Finalment, estem imprimint la llista de tuples.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Sortida:
[('G', 25), ('G', 30), ('g', 35)]> Mostra la suma de dígits de tots els elements senars d'una llista.
En aquest exemple, hem creat una llista i estem trobant la suma de dígits de cada element senar de la llista.
Python
# 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)> |
>
>
Sortida
[16, 3, 18, 18]>
Avantatges de la comprensió de llistes
- Més eficient en temps i espai que els bucles.
- Requereix menys línies de codi.
- Transforma l'enunciat iteratiu en una fórmula.
Preguntes d'exercicis de comprensió de la llista Python
A continuació es mostren dues preguntes d'exercici sobre la comprensió de la llista de Python. Hem tractat el codi bàsic de comprensió de llista per trobar el cub de nombres i el codi per trobar la longitud d'una paraula mitjançant la comprensió de llista i la funció len().
Q1. Pregunta d'exercici de cub de números utilitzant la comprensió de llistes
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Sortida
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
P2. Trobar una pregunta d'exercici de longitud de paraules utilitzant la comprensió de llistes
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
com obrir un fitxer json
>
>
Sortida
[5, 6, 6, 6]>