Introducción

Como desarrolladores de Python, a menudo nos concentramos en hacer que nuestro código funcione antes de preocuparnos por optimizarlo. Sin embargo, cuando se trata de aplicaciones a gran escala o código de rendimiento crítico, la optimización se vuelve crucial. En esta publicación, cubriremos dos poderosas herramientas que puedes usar para optimizar tu código Python: el módulo cProfile y el intérprete PyPy.

Al final de esta publicación, aprenderás:

1. Cómo identificar cuellos de botella en el rendimiento utilizando el módulo cProfile.
2. Cómo optimizar la velocidad de tu código.
3. Cómo usar PyPy para acelerar aún más tus programas Python con compilación Just-in-Time (JIT).

Por qué es importante la optimización del rendimiento

Python es conocido por su facilidad de uso, legibilidad y su vasto ecosistema de bibliotecas. Pero también es más lento que otros lenguajes como C o Java debido a su naturaleza interpretada. Por lo tanto, saber cómo optimizar su código Python puede ser fundamental en aplicaciones sensibles al rendimiento, como modelos de aprendizaje automático, sistemas en tiempo real o sistemas comerciales de alta frecuencia.

La optimización normalmente sigue estos pasos:

1. Perfila tu código para comprender dónde están los cuellos de botella.
2. Optimizar el código en áreas que son ineficientes.
3. Ejecute el código optimizado en un intérprete más rápido, como PyPy, para lograr el máximo rendimiento.

Ahora, comencemos por perfilar tu código.

Paso 1: perfilar su código con cProfile

¿Qué es cProfile?

cProfile es un módulo Python integrado para crear perfiles de rendimiento. Realiza un seguimiento de cuánto tiempo tarda en ejecutarse cada función de tu código, lo que puede ayudarte a identificar las funciones o secciones de código que están provocando ralentizaciones.

Usando cProfile desde la línea de comando

La forma más sencilla de crear un perfil de un script es ejecutando cProfile desde la línea de comandos. Por ejemplo, digamos que tiene un script llamado my_script.py:

python -m cProfile -s cumulative my_script.py

Explicación:

• -m cProfile: ejecuta el módulo cProfile como parte de la biblioteca estándar de Python.
• -s acumulativo: ordena los resultados de la generación de perfiles por tiempo acumulado invertido en cada función.
• my_script.py: tu secuencia de comandos de Python.

Esto generará un desglose detallado de dónde invierte su tiempo su código.

Ejemplo: creación de perfiles de un script de Python

Veamos un script básico de Python que calcula los números de Fibonacci de forma recursiva:

def fibonacci(n):
    if n 



Ejecutando este script con cProfile:


python -m cProfile -s cumulative fibonacci_script.py





  
  
  Comprender la salida de cProfile


Una vez que ejecutes cProfile, verás algo como esto:


   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     8320    0.050    0.000    0.124    0.000 fibonacci_script.py:3(fibonacci)




Cada columna proporciona datos clave de rendimiento:

• ncalls: Número de veces que se llamó a la función.
• tottime: Tiempo total dedicado a la función (excluyendo subfunciones).
• cumtime: Tiempo acumulado dedicado a la función (incluidas las subfunciones).
• percall: Tiempo por llamada.

Si su función de Fibonacci requiere demasiado tiempo, este resultado le mostrará dónde enfocar sus esfuerzos de optimización.

Perfilar partes específicas de su código

También puedes usar cProfile mediante programación dentro de tu código si solo deseas crear perfiles de secciones específicas.

import cProfile

def fibonacci(n):
    if n 




  
  
  Paso 2: Optimización de su código Python


Una vez que hayas identificado los cuellos de botella en tu código usando cProfile, es hora de optimizar.


  
  
  Técnicas comunes de optimización de Python



Usar funciones integradas: Las funciones integradas como sum(), min() y max() están altamente optimizadas en Python y suelen ser más rápidas que los bucles implementados manualmente.
Ejemplo:


   # Before: Custom sum loop
   total = 0
   for i in range(1000000):
       total  = i

   # After: Using built-in sum
   total = sum(range(1000000))





Evite llamadas a funciones innecesarias: las llamadas a funciones tienen gastos generales, especialmente bucles internos. Intente reducir las llamadas redundantes.
Ejemplo:


   # Before: Unnecessary repeated calculations
   for i in range(1000):
       print(len(my_list))  # len() is called 1000 times

   # After: Compute once and reuse
   list_len = len(my_list)
   for i in range(1000):
       print(list_len)





Memorización: Para funciones recursivas, puedes usar la memorización para almacenar resultados de cálculos costosos y evitar el trabajo repetido.
Ejemplo:


   from functools import lru_cache

   @lru_cache(maxsize=None)
   def fibonacci(n):
       if n 



Esto acelera enormemente el cálculo de Fibonacci al almacenar los resultados de cada llamada recursiva.


  
  
  Paso 3: usar PyPy para la compilación justo a tiempo



  
  
  ¿Qué es PyPy?


PyPy es un intérprete de Python alternativo que utiliza la compilación Just-in-Time (JIT) para acelerar su código Python. PyPy compila rutas de código ejecutadas con frecuencia en código de máquina, lo que lo hace mucho más rápido que el intérprete estándar de CPython para ciertas tareas.


  
  
  Instalación de PyPy


Puedes instalar PyPy usando un administrador de paquetes como apt en Linux o brew en macOS:


# On Ubuntu
sudo apt-get install pypy3

# On macOS (using Homebrew)
brew install pypy3





  
  
  Ejecutando código Python con PyPy


Una vez instalado PyPy, puedes ejecutar tu script con él en lugar de CPython:


pypy3 my_script.py





  
  
  ¿Por qué utilizar PyPy?

• PyPy es ideal para tareas vinculadas a la CPU donde el programa dedica la mayor parte de su tiempo a la computación (por ejemplo, bucles, funciones recursivas, procesamiento de números).
• El compilador JIT de PyPy optimiza las rutas de código que se ejecutan con mayor frecuencia, lo que puede generar aceleraciones significativas sin ningún cambio de código.

Paso 4: Combinar cProfile y PyPy para una máxima optimización

Ahora, combinemos estas herramientas para optimizar completamente su código Python.

Flujo de trabajo de ejemplo

1. Perfila tu código usando cProfile para identificar cuellos de botella.
2. Optimiza tu código usando las técnicas que analizamos (integraciones, memorización, evitar llamadas a funciones innecesarias).
3. Ejecute su código optimizado con PyPy para lograr mejoras de rendimiento adicionales.

Revisemos nuestro ejemplo de Fibonacci y juntemos todo.

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n 



Después de optimizar el código con memorización, ejecútelo usando PyPy para obtener más mejoras de rendimiento:


pypy3 fibonacci_script.py





  
  
  Conclusión


Al aprovechar cProfile y PyPy, puedes optimizar enormemente tu código Python. Utilice cProfile para identificar y abordar cuellos de botella de rendimiento en su código. Luego, usa PyPy para aumentar aún más la velocidad de ejecución de tu programa mediante la compilación JIT.

En resumen:

Perfile su código con cProfile para comprender los cuellos de botella en el rendimiento.
Aplicar técnicas de optimización de Python, como el uso de funciones integradas y memorización.
Ejecute el código optimizado en PyPy para lograr un rendimiento aún mejor.
Con este enfoque, puedes hacer que tus programas Python se ejecuten más rápido y más eficientemente, especialmente para tareas vinculadas a la CPU.

Conéctate conmigo:

Github

Linkedin