Introducción a la comprensión de la lista de Python
La comprensión de la lista de Python es otra forma de crear listas mediante una operación de iteración. Funciona de la misma manera que funciona un bucle, pero LC se usa específicamente para devolver listas. Las comprensiones de listas tienen expresiones entre paréntesis, como crear una lista normal, la expresión se ejecutará para todos los elementos.
Las comprensiones de listas son muy útiles en la ciencia de datos, donde uno lee listas / filtra nombres de columnas / elimina elementos de listas, etc. Aunque podemos usar bucles y funciones lambda para realizar alguna acción, la comprensión de listas proporciona una manera elegante y sencilla de representar lo mismo.
Las comprensiones de listas se pueden usar para sustituir los métodos map (), reduce () y filter ().
La comprensión de la lista es como la teoría de conjuntos de las clases de secundaria.
Ejemplo:
( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )
Creemos una lista de comprensión para las dos afirmaciones anteriores.
(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))
Salida:
(16, 17, 18, 19) ('a', 'a', 'i', 'e', 'e')Las comprensiones de listas son fáciles de entender e implementar. Básicamente, estos se crean en tablas. Hay tres cosas a tener en cuenta al escribir la sintaxis para las listas de comprensión.
- Parámetro para salida
- El iterable
- Condiciones
La sintaxis puede tener dos de los anteriores o 3 de los anteriores como una sintaxis para la comprensión de la lista.
Sintaxis:
(output parameter | The Iterable)(output Parameter | The Iterable | Condition )
Ejemplos de comprensión de la lista de Python
Aquí discutiremos cómo usar la comprensión de listas usando python. Veremos los ejemplos de una manera diferente ya que lo ejecutaremos usando for loop y luego crearemos lo mismo usando comprensiones de listas.
Ejemplo # 1: Encontrar los cuadrados perfectos
Aquí hay ejemplos de cuadrados perfectos con diferentes condiciones a continuación:
1. Con for Loop
for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)
2. Uso de comprensiones de listas
(x for x in range(1, 30) if int(x**0.5)==x**0.5)
Salida:
Ejemplo # 2: Obtenga solo consonantes de una oración
Aquí tomaremos una oración arbitraria e intentaremos obtener consonantes en la oración como nuestra salida.
1. Usando For Loop
def consonants_for(sentence):
vowels = 'aeiou'
consonants = () for x in sentence:
if x not in vowels:
consonants.append(x)
return ''.join(consonants)
sentence = 'we are studying list comprehensions'
print("With For Loop : " + consonants_for(sentence))
Salida:
Con For Loop: wr stdyng lst cmprhnsns
2. Uso de la comprensión de la lista
def consonants_lc(sentence):
vowels = 'aeiou'
return ''.join(( x for x in sentence if x not in vowels))
sentence = 'we are studying list comprehensions'
print("Using List Compr: " + consonants_lc(sentence))
Salida:
Usando List Compr: wr stdyng lst cmprhnsns
Ejemplo # 3: Crear un diccionario a partir de dos, a diferencia de las listas
Aquí hay ejemplos de diccionario con diferentes condiciones que se dan a continuación:
1. Usando For Loop
def dict_for(keys, values):
dictionary = ()
for i in range(len(keys)):
dictionary(keys(i)) = values(i) return dictionary
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("FOR-loop result: " + str(dict_for(Movie, Actor)))
Salida:
Resultado del bucle FOR: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
2. Uso de la comprensión de la lista
def dict_lc(keys, values):
return ( keys(i) : values(i) for i in range(len(keys)) )
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("LC result : " + str(dict_lc(Movie, Actor)))
Salida:
Resultado de LC: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
Beneficios de la comprensión de la lista de Python
¡Las comprensiones de listas realizan la misma tarea, pero de una manera diferente!
La comprensión de la lista tiene muchas ventajas sobre el ciclo y otros métodos. Algunos de los beneficios son los siguientes:
- Las comprensiones de listas son fáciles de entender y hacen que el código sea elegante. Podemos escribir el programa con expresiones simples.
- Las comprensiones de listas son mucho más rápidas que para el bucle y otros métodos como un mapa. (Lo mismo se explica en el siguiente ejemplo:
Tomaremos el ejemplo 1 como referencia y calcularemos el tiempo empleado por diferentes métodos para ejecutar la misma función. Primero, veremos el tiempo que toma el “ciclo for” y luego el tiempo lo toma el método map () y finalmente veremos el tiempo que toman las comprensiones de listas.
Una tabla muestra el tiempo que tardan las diferentes técnicas.
1. Para Loop
Ejemplo usando el bucle dado a continuación:
Código:
def perf_square(x):
output = () for i in x:
if int(i**0.5)==i**0.5:
output.append(i)
return output
%timeit perf_square(range(1, 30))
2. Método de mapa
Ejemplo usando el método de mapa dado a continuación:
Código:
def perf_square_map(x):
return map(lambda i: i**0.5==i**0.5, x)
%timeit perf_square_map(range(1, 30))
3. Lista de comprensiones
Ejemplo usando la lista de comprensión dada a continuación:
Código:
def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))
Salida:
| Método | Hora |
| En bucle | 787 ns |
| Método Map () | 518 ns |
| Lista de comprensiones | 276 ns |
Claramente, el tiempo de ejecución de la comprensión de la lista es 2, 85 veces más rápido que para el bucle y 1, 87 veces más rápido que el método de mapa. Las comprensiones de listas dejan atrás otros métodos con un gran margen. Podría haber especulaciones, ¿por qué no usamos LC en todos los lugares y no bucles? LC es más rápido en la mayoría de los casos y puede reemplazar bucles en casi el 80% de los casos. Pero no podemos reemplazar los bucles, hay algunos casos en los que tenemos un buen número de condiciones y las clases están anidadas en un bucle. En estos casos, usar LC podría ser bastante engorroso y no factible también. Es mejor ir a bucles en tales situaciones. Aunque uno puede usar la comprensión de listas en bucles for para reemplazar a otros bucles for. Disminuirá el tiempo de ejecución y mantendrá la facilidad de uso del código.
- Podemos anidar múltiples condiciones en una lista de comprensión.
- LC puede realizar manipulación de múltiples variables.
- No es necesario proporcionar un comando separado para obtener la salida.
- Las comprensiones de listas reducen la complejidad del código.
- Las comprensiones de listas son eficientes.
Conclusión
Las comprensiones de listas se utilizan para crear listas a partir del proceso iterativo. Las comprensiones de listas son fáciles de entender / implementar y hacen que el código sea elegante. Las comprensiones de listas son compactas y fáciles de usar.
Hemos discutido la sintaxis para la comprensión de listas junto con algunos buenos ejemplos reveladores. Por fin, escribimos un programa para obtener el tiempo de cada método. Llegamos a la conclusión de que el LC es 2, 85 veces más rápido que para el bucle y 1, 87 veces más rápido que el método map ().
Artículos recomendados
Esta es una guía para la comprensión de la lista de Python. Aquí discutimos los beneficios de la comprensión de la lista de Python junto con la sintaxis y ejemplos con diferentes condiciones. También puede consultar los siguientes artículos para obtener más información.
- Constructor en Java
- Ordenar en Java
- Constructor en Java
- JCheckBox en Java
- Guía para ordenar en C # con ejemplos
- Función de clasificación en Python con ejemplos
- Bucles en VBScript con ejemplos
- Ejemplos para implementar la casilla de verificación en Bootstrap