Linter para auditar el rendimiento de Python

Los analizadores estáticos de código, o linter, permiten buscar problemas en el código de una forma automática, facilitando de esta forma la auditoría de este. Uno de los más populares para Python es pylint, el cual hemos visto recientemente. Quizás uno de los problemas que puede tener este linter es que no cuenta con reglas para identificar problemas de rendimiento en el código, aunque esto es algo que se puede solucionar agregando nuevas reglas mediante plugins. Un complemento para pylint que se centra especialmente en identificar anti-patrones de rendimiento es perflint con el que es posible auditar el rendimiento de Python.

Instalación de perflint

Antes de instalar perflint es necesario tener instalado pylint en la distribución de Python. Ambos paquetes se pueden instalar, como es habitual el Python mediante, mediante el uso del comando pip. Para instalar pylint tendremos que abrir la terminal y escribir.

pip install pylint

Una vez hecho esto, para instalar perflint se debe escribir

pip install perflint

Ahora ya se puede usar ambos paquetes para auditar el código Python en busca de posibles problemas.

Código de ejemplo auditado con pylint

El código que se muestra a continuación implementa tres funciones que no hacen nada en especial. Solamente son unos ejemplos para ver los anti-patrones que afectan al rendimiento de un programa Python y son identificados por perflint, pero no lo hace pylint por sí solo.

"""Funciones básicas para evaluar perflint"""

def sumar():
    """Suma los elementos de una lista"""
    lista = [1, 2, 3, 4]
    suma = 0

    for item in list(lista):
        suma += item

    print(f'La sunma es {suma}')


def enumerar(lista):
    """Enumera los elementos de una lista"""
    for idx, item in enumerate(lista):
        print(f'El elemento {idx} de {len(lista)} es {item}')


def potencia(lista):
    """Calcula la potencia de los elementos de una lista"""
    for item in list(lista):
        print(f'{item} elevado a {POWER} es {item**POWER}')


if __name__ == "__main__":
    POWER = 2
    data = [1, 2, 3, 4]

    sumar()
    enumerar(data)
    potencia(data)

Ahora, se puede guardar este ejemplo en un archivo llamado performance.py y evaluar la calidad de este.

% pylint performance.py                         

--------------------------------------------------------------------
Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)

La puntuación que ofrece pylint para este archivo es 10, esto es, no identifica ningún posible error en el mismo. El archivo tiene documentación, al igual que todas las funciones, así mismo los nombres de variable y función cumplen todos con los estándares. Pero, si le indicamos a pylint que use las reglas de perflint veremos que existen unos problemas que pueden afectar al rendimiento del programa.

% pylint --load-plugins perflint performance.py 
************* Module performance
performance.py:8:16: W8101: Unnecessary using of list() on an already iterable type. (unnecessary-list-cast)
performance.py:5:12: W8301: Use tuple instead of list for a non-mutated sequence (use-tuple-over-list)
performance.py:23:34: W8202: Lookups of global names within a loop is inefficient, copy to a local variable outside of the loop first. (loop-global-usage)
performance.py:23:51: W8202: Lookups of global names within a loop is inefficient, copy to a local variable outside of the loop first. (loop-global-usage)
performance.py:28:11: W8301: Use tuple instead of list for a non-mutated sequence (use-tuple-over-list)

-------------------------------------------------------------------
Your code has been rated at 7.22/10 (previous run: 10.00/10, -2.78)

En concreto se puede ver cinco problemas que son de tres tipos diferentes, los cuales se pueden ver más en detalle a continuación.

Unnecessary using of list() on an already iterable type

Este error nos dice que no debemos convertir en una lista un objeto que ya es iterable, ya que esto hará que se itere dos veces sobre los elementos llevando a una reducción del rendimiento. Problema que se da en la línea 8.

Se podría pensar que el programa debería dar este error también en la línea 22, pero no es así porque en este segundo caso, al ser la variable un parámetro de entrada no está asegurado que sea iterable. Lo que sí sucede en la línea 8 dado que ahí la variable es una constante dentro de la función.

Use tuple instead of list for a non-mutated sequence

Cuando los datos de un vector no van a mutar durante la ejecución del código, es una mejor opción usar una dupla en lugar de una lista. Al ser la lista un objeto no mutable, Python lo almacenará en memoria de una forma más eficiente, lo que se traduce en un mejor rendimiento.

*Lookups of global names within a loop is inefficient, copy to a local variable outside of the loop first”

Usar una variable global dentro de un bucle no es eficiente, es mejor copiar el valor a una variable local. Este es un problema fácil de solucionar ya que solamente se tiene que copiar el dato.

Resultado después de las recomendaciones de perflint

Siguiendo las recomendaciones de perflint, he reescrito el programa anterior tal como se muestra a continuación.

"""Funciones básicas para evaluar perflint"""

def sumar():
    """Suma los elementos de una lista"""
    lista = (1, 2, 3, 4)
    suma = 0

    for item in lista:
        suma += item

    print(f'La sunma es {suma}')


def enumerar(lista):
    """Enumera los elementos de una lista"""
    for idx, item in enumerate(lista):
        print(f'El elemento {idx} de {len(lista)} es {item}')


def potencia(lista):
    """Calcula la potencia de los elementos de una lista"""
    power = POWER
    for item in list(lista):
        print(f'{item} elevado a {power} es {item**power}')


if __name__ == "__main__":
    POWER = 2
    data = (1, 2, 3, 4)

    sumar()
    enumerar(data)
    potencia(data)

Ahora la puntuación del código, incluyendo las reglas de perflint, es de 10.

% pylint --load-plugins perflint performance.py

-------------------------------------------------------------------
Your code has been rated at 10.00/10 (previous run: 7.22/10, +2.78)

Conclusiones

En esta entrada se ha visto un plugin para pylint donde se incluyen nuevas reglas que permite a este programa identificar anti-patrones que afectan al rendimiento de los programas en Python. Haciendo una auditoría más robusta que sin estas reglas. Perdiendo de esta manera auditar el rendimiento de Python, algo que puede ser realmente importante para algunas aplicaciones, no solamente el estilo del código.

Los plugins de pylint, como es el caso de perflint, permiten identificar otros problemas habituales en nuestros programas. Por lo que es aconsejable usar algunos con los que revisar la existencia de anti-patrones.

Imagen de Mikes-Photography en Pixabay