Python Timeit

1. Ventajas de timeit:
2. Utilice el módulo timeit para comparar el tiempo de ejecución de dos fragmentos
3. Utilice la interfaz de línea de comandos del módulo timeit

El módulo timeit es uno de los más simples y fáciles de implementar entre todas las herramientas de la categoría que perfilan la ejecución del código Python. El tutorial analiza el uso y la implementación del módulo timeit en Python.

Python contiene una biblioteca integrada timeit que puede calcular el tiempo de ejecución de pequeños fragmentos del código de Python. El módulo funciona ejecutando el código Python dado millones de veces y predice el menor tiempo transcurrido durante la ejecución de ese código de todos los resultados posibles.

Ventajas de timeit:

• Proporciona un resultado eficiente con precisión. La precisión del tiempo de ejecución representado a través de esta función es simplemente mayor que utilizando el simple módulo time.
• Ejecuta el fragmento de código dado más de un millón de veces, lo que ofrece lecturas mucho más relevantes del tiempo transcurrido durante su tiempo de ejecución.
• Además, tiene una interfaz de línea de comandos adicional además de la interfaz de llamada genérica, que es fácil de entender y aplicar.

Continuando, describamos y concentrémonos en la sintaxis de la función timeit() del módulo timeit.

timeit.timeit(stmt, setup, timer, number)

La función timeit.timeit() toma cuatro parámetros, todos los cuales se han explicado brevemente para facilitar la comprensión de la función a continuación:

• stmt: como su nombre lo indica, es la declaración que necesita ser medida. El valor por defecto es pasar en este caso.
• setup: Significa el código que debe ejecutarse antes de abordar la stmt. Una vez más, tiene un valor predeterminado como pass.
• timer: Un objeto básico timeit.Timer. Ya tiene asignado un valor predeterminado decente, que generalmente no necesita un cambio.
• number: Significa el número de ejecuciones del fragmento de código dado que el programador desea ejecutar.

Veremos diferentes ejemplos de cómo se puede implementar la función timeit.timeit() del módulo timeit.

Utilice el módulo timeit para calcular el tiempo de ejecución de un fragmento de código simple

Este método define un fragmento de código en una variable entre comillas triples (''').

El siguiente código utiliza el módulo timeit para calcular el tiempo de ejecución de un fragmento de código simple.

import timeit

setup1 = "from math import sqrt"
code1 = """
def a():
    list1 = []
    for i in range(50):
        list1.append(sqrt(i))
"""
print(timeit.timeit(setup=setup1, stmt=code1, number=10000))

El programa anterior proporciona la salida como el tiempo de ejecución tomado en segundos. Este tiempo de ejecución resulta de un millón de iteraciones del fragmento de código dado.

También debemos tener en cuenta que es bueno incluir todas las declaraciones de importación esenciales en el argumento de configuración.

Utilice el módulo timeit para comparar el tiempo de ejecución de dos fragmentos

El módulo timeit también se puede utilizar para comparar el tiempo de ejecución de dos fragmentos de código dados. Aquí, tomaremos dos funciones utilizadas para Búsqueda binaria y Búsqueda lineal respectivamente y compararemos sus tiempos de ejecución.

El siguiente código usa el módulo timeit para comparar el tiempo de ejecución de dos fragmentos.

import timeit

# function for binary search


def b_s(mylist, find):
    while len(mylist) > 0:
        mid = (len(mylist)) // 2
        if mylist[mid] == find:
            return True
        elif mylist[mid] < find:
            mylist = mylist[:mid]
        else:
            mylist = mylist[mid + 1 :]
    return False


# function for linear search
def l_s(mylist, find):
    for x in mylist:
        if x == find:
            return True
    return False


def b_time():
    SETUP_CODE = """
from __main__ import b_s
from random import randint"""
    TEST_CODE = """
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
b_s(mylist, find)"""
    times = timeit.repeat(setup=SETUP_CODE, stmt=TEST_CODE, repeat=3, number=10000)
    print("Binary search time: {}".format(min(times)))


def l_time():
    SETUP_CODE = """
from __main__ import l_s
from random import randint"""
    TEST_CODE = """
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
l_s(mylist, find)
    """
    times = timeit.repeat(setup=SETUP_CODE, stmt=TEST_CODE, repeat=3, number=10000)
    print("Linear search time: {}".format(min(times)))


if __name__ == "__main__":
    l_time()
    b_time()

Utilice la interfaz de línea de comandos del módulo timeit

Tomemos un código de función simple y su sintaxis en la interfaz de línea de comandos y abordemos todos los argumentos uno a la vez.

El siguiente código utiliza la interfaz de línea de comandos del módulo timeit.

C:\Windows\System32>python3 -m timeit -s "from math import sqrt" -n 10000 -r 5 'a = sqrt(34532)'

Aquí, hemos tomado la misma función que el primer ejemplo en el artículo.

Continuando, consideremos todos los argumentos utilizados aquí en la interfaz de línea de comandos.

• timeit: Argumento posicional simple que especifica la existencia y uso del módulo timeit.
• -s: El argumento de configuración.
• -n: El argumento del número.
• -r: El argumento repetido (opcional).
• 'fragmento de código': el fragmento de código se escribe directamente entre comillas simples en la interfaz de línea de comandos.