5 consejos para mejorar la velocidad de ejecución de Python
pre{overflow-x: auto}
Python es uno de los lenguajes de programación más utilizados en el mundo. Es un lenguaje de programación interpretado, de alto nivel y de propósito general que es tan versátil que puedes usarlo para casi todo. Es famoso por su sintaxis simple, código elegante y ricas bibliotecas de terceros. Además de sus muchas ventajas, Python también tiene una gran desventaja en términos de velocidad.
Aunque el código Python se ejecuta lentamente, puedes mejorar la velocidad de ejecución de Python mediante los 5 consejos que se comparten a continuación.
Primero, defina una función de sincronización timeshow. Mediante una decoración simple, se puede imprimir el tiempo de ejecución de la función especificada.
Esta función se utilizará varias veces en los siguientes ejemplos. def?timeshow(func)： from?time?import?time def?newfunc(*arg，?**kw)： t1?=?time() res?=?func(*arg，?**kw) t2? =?time() print(f"{func.__name__:?gt;10}?:?{t2-t1:.6f}?sec") return?res return?newfunc @timeshow def?test_it(): print( "hello?pytip") test_it() 1. Elija la estructura de datos adecuada
Usar la estructura de datos correcta tiene un impacto significativo en el tiempo de ejecución del script de Python. Python tiene cuatro estructuras de datos integradas:
Lista: Lista
Tupla: Tupla
Colección: Conjunto
Diccionario: Diccionario
Sin embargo, la mayoría de los desarrolladores utilizan listas en todas las situaciones. Esto es incorrecto y debe utilizar la estructura de datos adecuada para la tarea.
Al ejecutar el código siguiente, puede ver que las tuplas realizan operaciones de recuperación simples más rápido que las listas. El módulo dis desensambla el código de bytes de una función, lo cual es útil para ver la diferencia entre listas y tuplas.
importar?dis def?a(): datos?=? x?=datos[5] retorno?x def?b(): datos?=?(1,?2,?3,?4,?5,6, 7, 8, 9, 10) x?=datos[5] return?x print("-----: Código de máquina usando lista: ------") dis.dis(a) print(" - ----: Código de máquina usando tuplas: ------") dis.dis(b)
Ejecutar salida:
-----: Código de máquina para usando lista: ------
3 0 LOAD_CONST 1 (1)
2 LOAD_CONST 2 (2)
4 LOAD_CONST 3 ( 3)
6 LOAD_CONST 4 (4)
8 LOAD_CONST 5 (5)
10 LOAD_CONST 6 (6)
12 LOAD_CONST 7 (7 )
14 LOAD_CONST 8 (8)
16 LOAD_CONST 9 (9)
18 LOAD_CONST 10 (10)
20 BUILD_LIST 10
22 STORE_FAST 0 (datos)
4 24 LOAD_FAST 0 (datos)
26 LOAD_CONST 5 (5)
28 BINARY_SUBSCR
30 STORE_FAST 1 (x)
5 32 LOAD_FAST 1 (x)
34 RETURN_VALUE
----- : Código máquina usando tuplas: ------
7 0 LOAD_CONST 1 ((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
2 STORE_FAST 0 (datos)
8 4 LOAD_FAST 0 (datos)
6 LOAD_CONST 2 (5)
8 BINARY_SUBSCR
10 STORE_FAST 1 (x)
9 12 LOAD_FAST 1 (x)
14 RETURN_VALUE
Mire el código de máquina en la siguiente tabla, es largo y redundante ! 2. Haga un buen uso de las potentes funciones integradas y bibliotecas de terceros.
Si está utilizando Python y todavía escribe algunas funciones comunes (como suma y resta), está insultando a Python. Python tiene una gran cantidad de bibliotecas y funciones integradas para ayudarlo a evitar escribir estas funciones. Si investiga un poco, se sorprenderá al descubrir que casi el 90% de los problemas se resuelven mediante paquetes de terceros o funciones integradas.
Puedes ver todas las funciones integradas visitando la documentación oficial. También puede encontrar más escenarios utilizando funciones integradas en wiki python.
Por ejemplo, ahora queremos fusionar todas las palabras de la lista en una oración. Compare la diferencia entre escribirla usted mismo y llamar a la función de la biblioteca: #Métodos en los que la gente normal puede pensar @timeshow def. f1(lista): s ?="" para?subcadena?en?lista: s? =?subcadena return?s #pythonic? método @timeshow def?f2(lista): s?=?".join(lista) return?s l?= ?["I",?"Love",?"Python"]?*?1000?#?Para ver la diferencia, ampliamos la lista f1(l) f2(l)
Ejecutar salida:
f1: 0,000227 s
f2: 0,000031 s
3. Utilice menos bucles
Utilice listas por comprensión en su lugar de bucles
Utilice iteradores en lugar de bucles
Utilice filter() en lugar de bucles
Reduzca el número de bucles, controle con precisión y no desperdicie CPU ## ? Los rendimientos dentro de n pueden ser Todos los números divisibles por 7. #Métodos que se le ocurren a la gente normal: @timeshow def?f_loop(n):? L=[] for?i?in?range(n): if?i??7?==0: L.append(i) ) return?L #Derivación de lista @timeshow def?f_list(n): L?=?[i?for?i?in?range(n)?if?i??7?==?0] return?L # Iterador @timeshow def?f_iter(n): L?=?(i?for?i?in?range(n)?if?i??7?==?0) return?L #Filter? f_filter(n): L?=?filter(lambda?x:?x??7?==?0,?range(n)) return?L # ¿Controlar con precisión el número de bucles @timeshow def?f_mind(n? ): L?=?(i*7?for?i?in?range(n//7)) return?L n?=?1_000_000 f_loop(n) f_list(n) f_iter(n) f_filter(n) f_mind (n)
La salida es:
f_loop: 0,083017 s
f_list: 0,056110 s
f_iter: 0,000015 s
f_filter: 0.000003 seg
f_mind: 0.000002 seg
¡Puedes saber quién es más rápido y quién más lento de un vistazo!
¡El filtro combinado con lambda es increíble! ! ! 4. Evite cálculos repetidos en bucles
Si tiene un iterador, debe usar sus elementos para realizar algunos cálculos que requieren mucho tiempo, como hacer coincidir expresiones regulares. Debes definir el patrón de expresiones regulares fuera del bucle porque es mejor compilar el patrón sólo una vez en lugar de compilarlo una y otra vez en cada iteración del bucle.
Siempre que sea posible, debe intentar realizar tantas operaciones como sea posible fuera del bucle, como asignar cálculos de funciones a variables locales y luego usarlos en la función. #Métodos que deben cambiarse y evitarse: @timeshow def?f_more(s): import?re for?i?in?s: m?=?re.search(r'a*[a-z]?c',?i ) # Mejor manera: @timeshow def?f_less(s): import?re regex?=?re.compile(r'a*[a-z]?c') for?i?in?s: m?=?regex. search(i) s?=?["abctestabc"]?*?1_000 f_more(s) f_less(s)
La salida es:
f_more: 0,001068 seg
f_less: 0.000365 seg 5. Utilice menos memoria y menos variables globales
El uso de memoria se refiere a la cantidad de memoria utilizada cuando el programa se está ejecutando. Para hacer que el código Python se ejecute más rápido, debe reducir el uso de memoria de su programa, es decir, minimizar la cantidad de variables u objetos.
Python accede a las variables locales de manera más eficiente que a las variables globales. Siempre debes intentar ignorar la declaración de variables globales hasta que sea necesario. Una variable global definida en el programa existirá hasta que se compile todo el programa, por lo que siempre ocupa espacio de memoria. Por otro lado, es más rápido acceder a las variables locales y se pueden reciclar una vez completada la función. Por lo tanto, utilizar múltiples variables locales es mejor que utilizar variables globales. #¿Cómo evitar: mensaje?=?"Line1\n" mensaje? =?"Line2\n" mensaje? =?"Line3\n" #Mejor manera: l?=?["Line1","Line2 ", " Line3"] mensaje?=?'\n'.join(l) #Cómo evitar: x?=?5 y?=?6? def?add(): return?x y add() #Más Buena manera: def ?add(): x?=?5 y?=?6 return?x y add()
Resumen
Este artículo termina aquí, espero que pueda ayudarte y yo ¡Espero que puedas prestar más atención a más contenido!