Categorías
Python

Django y AJAX envíos de formularios – Más de práctica

 

Tabla de Contenidos

  • cómo crear listas de PythonUsing para LoopsUsing del mapa () ObjectsUsing Lista ComprehensionsBenefits del uso de las listas por comprensión
  • Utilización de bucles
  • El uso del mapa () Objetos
  • Utilizando Beneficios listas por comprensión
  • del uso de las listas por comprensión
  • Cómo sobrealimentar su ComprehensionsUsing condicional LogicUsing Conjunto y Diccionario ComprehensionsUsing la morsa del operador
  • Utilizando lógica condicional
  • Utilizando el montaje y el Diccionario de comprensión
  • uso de la morsa del operador
  • Cuando no utilizar una lista de comprensión PythonWatch fuera para Generadores anidada ComprehensionsChoose para DatasetsProfile grande para optimizar el rendimiento
  • Cuidado con anidado de comprensión
  • Elige Generadores para grandes conjuntos de datos
  • perfil para optimizar el rendimiento
  • Conclusión
  • Utilización de bucles
  • El uso del mapa () Objetos TG_0 20
  • Utilizando Beneficios listas por comprensión
  • del uso de las listas por comprensión
  • Utilizando lógica condicional
  • Utilizando el montaje y el Diccionario de comprensión
  • Uso de la morsa del operador
  • Cuidado con anidado de comprensión
  • Elige Generadores para grandes conjuntos de datos
  • perfil para optimizar el rendimiento

Python es famoso por lo que le permite escribir código que es elegante, fácil de escribir, y casi tan fácil de leer como la llanura Inglés. Una de las características más distintivas de la lengua es la lista por comprensión , que se puede utilizar para crear una potente funcionalidad dentro de una sola línea de código. Sin embargo, muchos desarrolladores se esfuerzan por aprovechar al máximo las características más avanzadas de una lista por comprensión en Python. Algunos programadores utilizan incluso demasiado, lo que puede dar lugar a código que es menos eficiente y más difícil de leer.

Al final de este tutorial, vas a entender toda la potencia de Python lista por comprensión y el uso de sus funciones cómodamente. También obtendrá una comprensión de las ventajas y desventajas que vienen con su uso para que pueda determinar cuando otros enfoques son más preferibles.

En este tutorial, aprenderá a: bucles y el mapa () llamadas como una lista de comprensión Python

    • reescritura Elige entre comprensiones, bucles, y el mapa () llama
    • impulsar el potencial de sus comprensiones con condicionales lógicas
    • Use comprensiones para cambiar el filtro ()
    • perfil de su código para resolver cuestiones de rendimiento

    Bono

    gratuito: Haga clic aquí para obtener acceso a un capítulo de trucos Python: El libro que le muestra las mejores prácticas de Python con sencillo ejemplos puede aplicar instantáneamente a escribir código más bonito + Pythonic.

    cómo crear listas en Python

    Hay algunas maneras diferentes que se pueden crear listas en Python. Para entender mejor las ventajas y desventajas de usar una lista de comprensión de Python, primero vamos a ver cómo crear listas con estos enfoques.

    Utilización de bucles

    El tipo más común de bucle es el bucle. Puede utilizar un bucle para crear una lista de elementos en tres pasos:

    Si desea crear una lista que contiene los primeros cuadrados perfectos diez, entonces se puede completar estos pasos en tres líneas de código:

    >>> squares = []
    >>> for i in range(10):
    ... squares.append(i * i)
    >>> squares
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    Aquí, instancia de una lista vacía, cuadrados. A continuación, utiliza un bucle for para iterar sobre rango (10). Por último, se multiplica cada número por sí mismo y añadir el resultado al final de la lista.

    El uso del mapa () Objetos mapa

    () proporciona un enfoque alternativo que se basa en la programación funcional. Se pasa de una función y un iterable, y MAP () se creará un objeto. Este objeto contiene la salida que se obtiene de correr cada elemento iterable través de la función suministrado.

    Como ejemplo, considere una situación en la que es necesario calcular el precio después de impuestos para obtener una lista de las transacciones:

    >>> txns = [1.09, 23.56, 57.84, 4.56, 6.78]
    >>> TAX_RATE = .08
    >>> def get_price_with_tax(txn):
    ... return txn * (1 + TAX_RATE)
    >>> final_prices = map(get_price_with_tax, txns)
    >>> list(final_prices)
    [1.1772000000000002, 25.4448, 62.467200000000005, 4.9248, 7.322400000000001]

    Aquí, usted tiene un txns iterables y un get_price_with_tax función (). Se pasa estos dos argumentos a map () y almacene el objeto resultante en final_prices. Usted puede convertir fácilmente este objeto de mapa en una lista utilizando la lista ().

    Usando las listas por comprensión

    Lista

    comprensiones son una tercera manera de hacer listas. Con este enfoque elegante, se puede volver a escribir el bucle del primer ejemplo en tan sólo una sola línea de código:

    >>> squares = [i * i for i in range(10)]
    >>> squares
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    En lugar de crear una lista vacía y la adición de cada elemento al final, sólo tiene que definir la lista y su contenido en el mismo tiempo siguiendo este formato:

    new_list = [expression for member in iterable]

    Cada lista por comprensión en Python incluye tres elementos:

    Debido a que la expresión requisito es tan flexible, una lista de comprensión de Python funciona bien en muchos lugares donde se utilizaría mapa (). Puede volver a escribir el ejemplo precios con su propia lista por comprensión:

    >>> txns = [1.09, 23.56, 57.84, 4.56, 6.78]
    >>> TAX_RATE = .08
    >>> def get_price_with_tax(txn):
    ... return txn * (1 + TAX_RATE)
    >>> final_prices = [get_price_with_tax(i) for i in txns]
    >>> final_prices
    [1.1772000000000002, 25.4448, 62.467200000000005, 4.9248, 7.322400000000001]

    La única diferencia entre esta aplicación y el mapa () es que la lista de comprensión Python devuelve una lista, no un objeto de mapa.

    Ventajas del uso de las listas por comprensión

    Lista

    por comprensión a menudo se describen como más Pythonic de bucles o mapa (). Pero en lugar de aceptar ciegamente que la evaluación, vale la pena para entender los beneficios de utilizar una lista de comprensión de Python en comparación con las alternativas. Más tarde, usted aprenderá acerca de una serie de escenarios donde las alternativas son una mejor opción.

    Una ventaja principal de utilizar una lista de comprensión de Python es que es una única herramienta que se puede utilizar en muchas situaciones diferentes. Además de creación de la lista estándar, listas por comprensión también se pueden usar para el mapeo y filtrar. Usted no tiene que utilizar un enfoque diferente para cada escenario.

    Esta es la razón principal por la lista por comprensión se consideran Pythonic , como Python, abraza poderosas herramientas sencillas que se pueden utilizar en una amplia variedad de situaciones. Como beneficio secundario adicional, siempre que utilice una lista de comprensión de Python, no tendrá que recordar el orden correcto de argumentos, como lo haría cuando se le llame mapa ().

    Lista

    comprensiones son también más declarativa de bucles, lo que significa que son más fáciles de leer y entender. Bucles requieren que se centrará en cómo se crea la lista. Usted tiene que crear manualmente una lista vacía, el lazo sobre los elementos, y añadir cada uno de ellos al final de la lista. Con una lista de comprensión de Python, en su lugar puede centrarse en lo que usted quiere ir en la lista y la confianza de que Python se hará cargo de la construcción cómo la lista se lleva a cabo.

    Cómo sobrealimentar su fin de comprensión

    para comprender todo el valor que las listas por comprensión pueden proporcionar, es útil para entender su gama de funcionalidad posible. También querrá entender los cambios que se aproximan a la comprensión de lista en Python 3.8.

    Utilizando lógica condicional

    Anteriormente, se vio esta fórmula de cómo crear listas por comprensión:

    new_list = [expression for member in iterable]

    Si bien esta fórmula es exacta, es también un poco incompleta. Una descripción más completa de la fórmula comprensión añade soporte para los condicionales opcionales . La forma más común para agregar lógica condicional a una lista por comprensión es añadir un condicional al final de la expresión:

    new_list = [expression for member in iterable (if conditional)]

    Aquí, su sentencia condicional se produce justo antes del paréntesis de cierre.

    Los condicionales son importantes porque permiten que las listas por comprensión para filtrar los valores deseados, que normalmente requieren una llamada al filtro ():

    >>> sentence = 'the rocket came back from mars'
    >>> vowels = [i for i in sentence if i in 'aeiou']
    >>> vowels
    ['e', 'o', 'e', 'a', 'e', 'a', 'o', 'a']

    En este bloque de código, los filtros sentencia condicional fuera de cualquier carácter en pena que no son una vocal .

    El condicional puede probar cualquier expresión válida. Si necesita un filtro más complejo, después, se puede mover la lógica condicional a una función separada:

    >>> sentence = 'The rocket, who was named Ted, came back \
    ... from Mars because he missed his friends.'
    >>> def is_consonant(letter):
    ... vowels = 'aeiou'
    ... return letter.isalpha() and letter.lower() not in vowels
    >>> consonants = [i for i in sentence if is_consonant(i)]
    ['T', 'h', 'r', 'c', 'k', 't', 'w', 'h', 'w', 's', 'n', 'm', 'd', \
    'T', 'd', 'c', 'm', 'b', 'c', 'k', 'f', 'r', 'm', 'M', 'r', 's', 'b', \
    'c', 's', 'h', 'm', 's', 's', 'd', 'h', 's', 'f', 'r', 'n', 'd', 's']

    Aquí, se crea un filtro complejo is_consonant () y pasar esta función que la sentencia condicional para su lista por comprensión. Tenga en cuenta que el valor de miembro i también se pasa como argumento a su función.

    Puede colocar el condicional al final de la declaración para el filtrado simple, pero lo que si quieres cambio un valor de miembro en lugar de filtrar hacia fuera? En este caso, es útil colocar el condicional cerca de la comenzando de la expresión:

    new_list = [expression (if conditional) for member in iterable]

    Con esta fórmula, se puede utilizar la lógica condicional para seleccionar entre múltiples opciones de salida posibles. Por ejemplo, si usted tiene una lista de precios, entonces es posible que desee reemplazar a precios negativos con 0 y dejar sin cambios los valores positivos:

    >>> original_prices = [1.25, -9.45, 10.22, 3.78, -5.92, 1.16]
    >>> prices = [i if i > 0 else 0 for i in original_prices]
    >>> prices
    [1.25, 0, 10.22, 3.78, 0, 1.16]

    Aquí, su expresión que contiene una sentencia condicional, si > 0 0. Esto le dice a los demás Python para dar salida al valor de i si el número es positivo, pero para cambiar i a 0 si el número es negativo. Si esto parece abrumadora, entonces puede ser muy útil para ver la lógica condicional como su propia función:

    >>> def get_price(price):
    ... return price if price > 0 else 0
    >>> prices = [get_price(i) for i in original_prices]
    >>> prices
    [1.25, 0, 10.22, 3.78, 0, 1.16]

    Ahora, su sentencia condicional está contenida dentro de get_price (), y se puede usar como parte de su expresión lista por comprensión.

    Utilizando el montaje y el Diccionario de comprensión

    Mientras que la lista de comprensión de Python es una herramienta común, aunque también puede crear set y comprensiones del diccionario. Un conjunto comprensión es casi exactamente lo mismo que una lista de comprensión de Python. La diferencia es que la comprensión conjunto s Asegúrese de que la salida no contiene duplicados. Puede crear un conjunto comprensión mediante el uso de llaves en lugar de soportes:

    >>> quote = "life, uh, finds a way"
    >>> unique_vowels = {i for i in quote if i in 'aeiou'}
    >>> unique_vowels
    {'a', 'e', 'u', 'i'}

    su conjunto da salida a la comprensión de todas las vocales únicas que se ha encontrado en la cita. A diferencia de las listas, conjuntos no garantizan que los artículos serán guardados en ningún orden en particular. Es por esto que el primer miembro del conjunto es una, a pesar de que la primera vocal en la cita es i.

    diccionario por comprensión son similares, con el requisito adicional de definir una clave:

    >>> squares = {i: i * i for i in range(10)}
    >>> squares
    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

    Para crear el diccionario de las plazas, que utiliza las llaves ({}), así como un par clave-valor (i: i * i) en su expresión.

    Uso de la morsa operador

    Python 3.8 introducirá la expresión de asignación, también conocido como el morsa operador . Para entender cómo se puede usar, consideremos el siguiente ejemplo.

    que usted necesita para hacer peticiones de diez a una API que devolverá los datos de temperatura. Sólo desea devolver resultados que son más de 100 grados Fahrenheit. Supongamos que cada solicitud devolverá datos diferentes. En este caso, no hay manera de utilizar una lista de comprensión de Python para resolver el problema. La expresión de la fórmula para el miembro en iterable (si condicional) no proporciona ninguna manera para el condicional a los datos asignar a una variable que la expresión puede tener acceso.

    El operador morsa resuelve este problema. Se le permite ejecutar una expresión mientras que asigna al mismo tiempo el valor de salida a una variable. El siguiente ejemplo muestra cómo esto es posible, utilizando get_weather_data () para generar datos meteorológicos falsos:

    >>> import random
    >>> def get_weather_data():
    ... return random.randrange(90, 110)
    >>> hot_temps = [temp for _ in range(20) if (temp := get_weather_data()) >= 100]
    >>> hot_temps
    [107, 102, 109, 104, 107, 109, 108, 101, 104]

    A menudo no tendrá que utilizar el interior expresión de asignación de una lista por comprensión en Python, pero es una herramienta útil para tener a su disposición cuando sea necesario.

    Cuando no utilizar una lista por comprensión en Python

    Lista

    comprensiones son útiles y pueden ayudarle a escribir código elegante que es fácil de leer y depurar, pero no son la mejor opción para todas las circunstancias. Ellos podrían hacer que el código funcione más lentamente o usar más memoria. Si el código es menos eficiente o más difícil de entender, entonces es probablemente mejor elegir una alternativa.

    Cuidado con anidadas Comprensiones

    de comprensión puede ser anidada para crear combinaciones de listas, diccionarios y conjuntos dentro de una colección. Por ejemplo, digamos que un laboratorio climático es el seguimiento de la temperatura alta en cinco ciudades diferentes para la primera semana de junio. La estructura de datos perfecta para el almacenamiento de estos datos podría ser una lista por comprensión Python anidado dentro de un diccionario por comprensión:

    >>> cities = ['Austin', 'Tacoma', 'Topeka', 'Sacramento', 'Charlotte']
    >>> temps = {city: [0 for _ in range(7)] for city in cities}
    >>> temps
    {
    'Austin': [0, 0, 0, 0, 0, 0, 0],
    'Tacoma': [0, 0, 0, 0, 0, 0, 0],
    'Topeka': [0, 0, 0, 0, 0, 0, 0],
    'Sacramento': [0, 0, 0, 0, 0, 0, 0],
    'Charlotte': [0, 0, 0, 0, 0, 0, 0]
    }

    se crean las temperaturas exteriores de recogida con un diccionario por comprensión. La expresión es un par clave-valor, que contiene otra comprensión. Este código generará rápidamente una lista de datos para cada ciudad en las ciudades. listas

    anidados son una forma común de crear matrices , que a menudo se utiliza para fines matemáticos. Echar un vistazo al bloque de código a continuación:

    >>> matrix = [[i for i in range(5)] for _ in range(6)]
    >>> matrix
    [
    [0, 1, 2, 3, 4],
    [0, 1, 2, 3, 4],
    [0, 1, 2, 3, 4],
    [0, 1, 2, 3, 4],
    [0, 1, 2, 3, 4],
    [0, 1, 2, 3, 4]
    ]

    La lista por comprensión externa [… por _ en el rango (6)] crea seis filas, mientras que la lista de comprensión interior [i para i in range (5)] llena cada una de estas filas con valores.

    Hasta el momento, el propósito de cada una comprensión anidada es bastante intuitiva. Sin embargo, hay otras situaciones, tales como aplastamiento listas anidadas, donde la lógica podría decirse que hace que el código sea más confuso. Tome este ejemplo, que utiliza una lista por comprensión anidada para aplanar una matriz:

    matrix = [
    ... [0, 0, 0],
    ... [1, 1, 1],
    ... [2, 2, 2],
    ... ]
    >>> flat = [num for row in matrix for num in row]
    >>> flat
    [0, 0, 0, 1, 1, 1, 2, 2, 2]

    El código para aplanar la matriz es concisa, pero puede que no sea tan intuitivo para entender cómo funciona. Por otro lado, si se va a utilizar para los bucles para aplanar la misma matriz, a continuación, el código será mucho más sencillo:

    >>> matrix = [
    ... [0, 0, 0],
    ... [1, 1, 1],
    ... [2, 2, 2],
    ... ]
    >>> flat = []
    >>> for row in matrix:
    ... for num in row:
    ... flat.append(num)
    ...
    >>> flat
    [0, 0, 0, 1, 1, 1, 2, 2, 2]

    ya se puede ver que el código atraviesa una fila de la matriz a la vez, sacando todo los elementos de esa fila antes de pasar a la siguiente.

    Mientras que el de una sola línea anidada lista por comprensión podría parecer más Pythonic, lo que es más importante es escribir código que su equipo puede entender y modificar fácilmente. Al elegir su enfoque, que tendrá que hacer un juicio basado en si usted piensa que la comprensión de ayuda o perjudica la legibilidad.

    Elige Generadores para grandes conjuntos de datos

    Una lista por comprensión en Python funciona mediante la carga de la lista de salida entero en la memoria. Para pequeñas o incluso listas de tamaño medio, esto es generalmente bien. Si desea sumar los cuadrados de los primeros un millar de números enteros, a continuación, una lista por comprensión va a resolver este problema admirablemente:

    >>> sum([i * i for i in range(1000)])
    332833500

    Pero lo que si se quería sumar los cuadrados de los primeros mil millones enteros? Si se trató a continuación en su máquina, entonces usted puede notar que su ordenador se convierte en no responde. Eso es porque Python está tratando de crear una lista con uno mil millones enteros, que consume más memoria que su computadora le gustaría. Su equipo no tenga los recursos que necesita para generar una enorme lista y almacenarlo en la memoria. Si intenta hacerlo de todos modos, a continuación, la máquina podría ralentizar o incluso caída.

    Cuando el tamaño de una lista convierte en un problema, a menudo es útil usar un generador en lugar de una lista por comprensión en Python. Un generador de no crea una estructura única, datos de gran tamaño en la memoria, sino que devuelve un iterable. El código puede pedir el siguiente valor de la iterables tantas veces como sea necesario o hasta que haya alcanzado el final de su secuencia, mientras que sólo el almacenamiento de un valor único a la vez.

    Si se va a sumar los primeros mil millones de plazas con un generador, a continuación, su programa es probable que funcione durante un tiempo, pero no debe hacer que el equipo se congele. El siguiente ejemplo utiliza un generador:

    >>> sum(i * i for i in range(1000000000))
    333333332833333333500000000

    Se puede decir que esto es un generador porque la expresión no está rodeado de corchetes o llaves. Opcionalmente, los generadores pueden estar rodeadas por paréntesis.

    El ejemplo anterior todavía requiere mucho trabajo, pero realiza las operaciones perezosamente . Debido a la evaluación perezosa, los valores se calculan solamente cuando son solicitados explícitamente. Después de que el generador se obtiene un valor (por ejemplo, 567 * 567), se puede añadir que el valor a la suma en ejecución, a continuación, descartar ese valor y generar el siguiente valor de (568 * 568). Cuando la función de suma solicita al siguiente valor, el ciclo comienza de nuevo. Este proceso mantiene la pequeña huella de memoria.

    mapa

    () también funciona con pereza, es decir, la memoria no será un problema si decide utilizarlo en este caso:

    >>> sum(map(lambda i: i*i, range(1000000000)))
    333333332833333333500000000

    Es hasta usted si usted prefiere la expresión generador o del mapa ().

    perfil para optimizar el rendimiento

    Por lo tanto, cuál es el enfoque más rápido? En caso de utilizar listas por comprensión o una de sus alternativas? En lugar de adherirse a una sola regla que es cierto en todos los casos, es más útil que preguntarse si el desempeño o no importa en sus circunstancias específicas. Si no, entonces por lo general es mejor elegir cualquier enfoque conduce a un código más limpio!

    Si estás en un escenario en el que el rendimiento es importante, entonces es generalmente mejor al perfil enfoques diferentes y escuchar a los datos. timeit es una biblioteca útil para medir el tiempo el tiempo que tarda trozos de código se ejecute. Puede utilizar timeit para comparar el tiempo de ejecución del mapa (), para los bucles y las listas por comprensión:

    >>> import random
    >>> import timeit
    >>> TAX_RATE = .08
    >>> txns = [random.randrange(100) for _ in range(100000)]
    >>> def get_price(txn):
    ... return txn * (1 + TAX_RATE)
    ...
    >>> def get_prices_with_map():
    ... return list(map(get_price, txns))
    ...
    >>> def get_prices_with_comprehension():
    ... return [get_price(txn) for txn in txns]
    ...
    >>> def get_prices_with_loop():
    ... prices = []
    ... for txn in txns:
    ... prices.append(get_price(txn))
    ... return prices
    ...
    >>> timeit.timeit(get_prices_with_map, number=100)
    2.0554370979998566
    >>> timeit.timeit(get_prices_with_comprehension, number=100)
    2.3982384680002724
    >>> timeit.timeit(get_prices_with_loop, number=100)
    3.0531821520007725

    Aquí, definen tres métodos que cada utilizar un enfoque diferente para la creación de una lista. A continuación, le dice timeit para ejecutar cada una de esas funciones 100 veces cada uno. timeit devuelve el tiempo total que se tardó en ejecutar esas 100 ejecuciones.

    A medida que el código se muestra, la mayor diferencia es entre el enfoque basado en el bucle y del mapa (), con el bucle teniendo un 50% más en ejecutarse. Sea o no esto es importante, depende de las necesidades de su aplicación.

    Conclusión

    En este tutorial, aprendió a usar una lista por comprensión en Python para realizar tareas complejas sin hacer que su código excesivamente complicado.

    Ahora usted puede: bucles

    • Simplificar y el mapa () llama a la lista declarativas comprensiones
    • el potencial de su comprensiones con lógica condicional
    • Crear conjunto y comprensiones del diccionario
    • Determinar cuando la claridad del código o dictados de rendimiento de un enfoque alternativo

    Cada vez que usted tiene que elegir un método de creación de la lista, trate de múltiples implementaciones y considerar lo que es más fácil de leer y entender en su situación específica. Si el rendimiento es importante, entonces usted puede utilizar las herramientas para darle datos procesables en lugar de confiar en corazonadas o suposiciones acerca de lo que funciona mejor perfilado.

    Recuerde que mientras Python listas por comprensión reciben mucha atención, su intuición y capacidad de uso de los datos cuando se cuenta le ayudarán a escribir código limpio que sirve a la tarea en cuestión. Esto, en última instancia, es la clave para hacer que su código Pythonic!

  • Deja un comentario

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *