Una lista de comprensión de Python consta de corchetes que contienen la expresión, que se ejecuta para cada elemento junto con el bucle for para iterar sobre cada elemento de la lista de Python.
Ejemplo:
Pitón
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Producción
[24, 26, 28]>
Sintaxis de comprensión de listas de Python
Sintaxis: lista nueva = [ expresión (elemento) para elemento en lista antigua si condición ]
Parámetro:
expresión: representa la operación que desea ejecutar en cada elemento dentro del iterable. elemento: El término variable se refiere a cada valor tomado del iterable. iterable: especifique la secuencia de elementos que desea iterar (por ejemplo, una lista, tupla o cadena). condición: (Opcional) Un filtro ayuda a decidir si un elemento debe agregarse o no a la nueva lista.
Devolver: El valor de retorno de una lista por comprensión es una nueva lista que contiene los elementos modificados que satisfacen los criterios dados.
La comprensión de listas de Python proporciona una sintaxis mucho más corta para crear una nueva lista basada en los valores de una lista existente.
Ejemplo de comprensión de listas en Python
A continuación se muestra un ejemplo del uso de la comprensión de listas para encontrar el cuadrado de un número en Python.
Pitón
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Producción
[1, 4, 9, 16, 25]>
Iteración con comprensión de listas
En este ejemplo, asignamos 1, 2 y 3 a la lista y la imprimimos usando Comprensión de lista.
Pitón
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Producción
[1, 2, 3]>
Lista par usando comprensión de lista
En este ejemplo, imprimimos los números pares del 0 al 10 usando la comprensión de listas.
Pitón
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Producción
[0, 2, 4, 6, 8, 10]>
Matriz usando comprensión de listas
En este ejemplo, asignamos números enteros del 0 al 2 o 3 de las filas de la matriz y la imprimimos usando la comprensión de listas.
Pitón
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Producción
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Lista por comprensión frente a bucle For
Hay varias formas de iterar a través de una lista. Sin embargo, el enfoque más común es utilizar el para bucle . Veamos el siguiente ejemplo:
Pitón
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Producción
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Arriba está la implementación del enfoque tradicional para iterar a través de una lista, cadena, tupla, etc. Ahora, la comprensión de listas en Python hace la misma tarea y también hace que el programa sea más simple.
Las comprensiones de listas traducen el enfoque de iteración tradicional utilizando en bucle en una fórmula simple, lo que los hace fáciles de usar. A continuación se muestra el enfoque para iterar a través de una lista, cadena, tupla, etc. utilizando la comprensión de listas en Python.
Pitón
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Producción
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Análisis de tiempo en listas por comprensión y bucles
Las listas por comprensión en Python son más eficientes tanto computacionalmente como en términos de espacio y tiempo de codificación que un bucle for. Normalmente, están escritos en una sola línea de código. El siguiente programa muestra la diferencia entre bucles y comprensión de listas según el rendimiento.
Pitón
comentario xml
# 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>))> |
>
>
Producción
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
En el programa anterior, podemos ver que la comprensión de listas es bastante más rápida que el bucle for.
Comprensiones de listas anidadas
Comprensiones de listas anidadas no son más que una lista por comprensión dentro de otra lista por comprensión que es bastante similar a los bucles for anidados. A continuación se muestra el programa que implementa el bucle anidado:
Pitón
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)> |
>
>
Producción
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Ahora, al utilizar listas por comprensión anidadas, se puede generar el mismo resultado en menos líneas de código.
Pitón
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Producción
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Listas por comprensión y Lambda
Expresiones lambda no son más que representaciones abreviadas de funciones de Python. El uso de listas por comprensión con lambda crea una combinación eficiente. Veamos los siguientes ejemplos:
En este ejemplo, insertamos números del 10 al 50 en la lista y la imprimimos.
Pitón
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Producción
[10, 20, 30, 40, 50]>
Aquí hemos utilizado el bucle for para imprimir una tabla de 10.
Pitón
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Producción
[10, 20, 30, 40, 50]>
Ahora aquí, hemos usado solo la comprensión de listas para mostrar una tabla de 10.
Pitón
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Producción
[10, 20, 30, 40, 50]>
Finalmente, usamos lambda + comprensión de listas para mostrar la tabla de 10. Esta combinación es muy útil para obtener soluciones eficientes en menos líneas de código para problemas complejos.
Condicionales en comprensión de listas
También podemos agregar declaraciones condicionales a la lista de comprensión. Podemos crear una lista usando rango(), operadores , etc. y cal también aplican algunas condiciones a la lista usando el si declaración .
Puntos clave
cómo obtener emojis de manzana en Android
- La comprensión de la lista es un medio eficaz para describir y construir listas basadas en listas actuales.
- Generalmente, la comprensión de listas es liviana y más simple que las funciones y bucles de formación de listas estándar.
- No debemos escribir códigos largos para la comprensión de listas para garantizar un código fácil de usar.
- Cada comprensión de la lista se puede reescribir en un bucle for, pero en el contexto de la interpretación de la lista, no se puede reescribir cada bucle for.
A continuación se muestran algunos ejemplos que describen el uso de listas por comprensión en lugar del enfoque tradicional de iteración a través de iterable:
Comprensión de listas de Python usando If-else.
En el ejemplo, estamos comprobando que del 0 al 7, si el número es par, inserte Número par a la lista más insertar Número impar a la lista.
Pitón
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Producción
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
IF anidado con comprensión de lista
En este ejemplo, insertamos números en la lista que son múltiplos de 10 a 100 y los imprimimos.
Pitón
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Producción
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Mostrar un cuadrado de números del 1 al 10
En este ejemplo, insertaremos un cuadrado del 1 al 10 en la lista e imprimiremos la lista.
Pitón
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Producción
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Mostrar transposición de matriz 2D
En este ejemplo, estamos haciendo una transposición de la matriz mediante comprensión de listas.
Pitón
# 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)> |
>
>
Producción
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Alternar entre mayúsculas y minúsculas de cada carácter en una cadena
En este ejemplo, alternamos entre mayúsculas y minúsculas de cada carácter en una cadena determinada usando el operador XOR con 32 y almacenamos el resultado en una lista.
Pitón
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Producción
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Invertir cada cadena en una tupla
En este ejemplo, invertimos cadenas en un bucle for, las insertamos en la lista e imprimimos la lista.
Pitón
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Producción
['skeeG', 'rof', 'skeeG']>
Crear una lista de tuplas a partir de dos listas separadas
En este ejemplo, hemos creado dos listas de nombres y edades. Estamos usando cremallera() en comprensión de listas y estamos insertando el nombre y la edad como una tupla para enumerar. Finalmente, estamos imprimiendo la lista de tuplas.
Pitón
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Producción:
[('G', 25), ('G', 30), ('g', 35)]> Muestra la suma de dígitos de todos los elementos impares de una lista.
En este ejemplo, hemos creado una lista y encontramos la suma de dígitos de cada elemento impar en la lista.
Pitón
# 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)> |
árbol de búsqueda binario vs árbol binario
>
>
Producción
[16, 3, 18, 18]>
Ventajas de la comprensión de listas
- Más eficiente en tiempo y espacio que los bucles.
- Requiere menos líneas de código.
- Transforma una declaración iterativa en una fórmula.
Preguntas del ejercicio de comprensión de listas de Python
A continuación se muestran dos preguntas de ejercicio sobre comprensión de listas de Python. Hemos cubierto el código básico de comprensión de listas para encontrar el cubo de números y el código para encontrar la longitud de una palabra usando la comprensión de listas y la función len().
P1. Pregunta de ejercicio de cubo de números usando lista de comprensión
Pitón
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Producción
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
P2. Pregunta de ejercicio de búsqueda de longitud de palabra mediante comprensión de listas
Pitón
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Producción
[5, 6, 6, 6]>