timeit en Python | Introducción a la biblioteca timeit

Introducción

El propósito de este artículo es presentarnos el cronométralo Biblioteca.

Suponga que desea medir el tiempo de ejecución de un fragmento de código. ¿A qué te dedicas? Hasta ahora, me gusta que la mayoría de la gente haga algo como esto:

import time
start_time = time.time()
"""Some Code"""
end_time = time.time()
print(f"The execution time is: {end_time-start_time}")

Ahora digamos que queremos comparar los tiempos de ejecución de dos funciones diferentes, luego:

import time
def function_1(*parameters):
 #do something
 # return value
def function_2(*parameters):
 #do something
 #return value
 
#measuring time taken by function_1
start_of_f1 = time.time()
value1 = function_1(*parameters)
end_of_f1 = time.time()
print(f”The time taken by function_1 is:{start_of_f1-end_of_f1}”)#measuring time teaken by function_2
start_of_f2 = time.time()
value2 = function_1(*parameters)
end_of_f2 = time.time()print(f”The time taken by function_1 is:{start_of_f2-end_of_f2}”)

Esta es la forma en que la mayoría de las personas miden los tiempos de ejecución y comparan dos funciones.

Sin embargo, si tenemos que medir el tiempo que tarda un fragmento de código muy pequeño, este método no produce resultados precisos. Incluso, al comparar las funciones, todos los demás procesos y tareas que ocurren en el sistema operativo están jugando con el tiempo tiempo() ejemplo. Por lo tanto, no es preciso al comparar funciones.

Para abordar este problema, Python tiene una cronométralo módulo que está destinado a medir los tiempos de ejecución de fragmentos de código pequeños y grandes. Aquí, en este artículo, primero echamos un vistazo a cronométralo biblioteca en python usando algunos ejemplos.

Primero, veamos su descripción general tal como se proporciona en el documentación.

timeit en Python

Este módulo proporciona una forma sencilla de cronometrar pequeños fragmentos de código Python. Tiene tanto un Interfaz de línea de comandos así como un invocable uno. Evita una serie de trampas comunes para medir los tiempos de ejecución.

Este módulo tiene una función, timeit.timeit (stmt = pasar, configuración = pasar, temporizador = , número = 1000000) .Esta función toma cuatro argumentos:

1. stmt: El fragmento de código cuyos tiempos de ejecución se van a medir.
2. configuración: El código a ejecutar antes de ejecutar stmt. Generalmente, se usa para importar algunos módulos o declarar algunas variables necesarias. Se hará más claro con los ejemplos.
3. Temporizador: Es un objeto timeit.Timer predeterminado. Tiene un valor predeterminado razonable, por lo que no tenemos que hacer mucho al respecto.
4. número: Especifica el número de veces stmt será ejecutado.

Devolverá el tiempo necesario (en segundos) para ejecutar el stmt, el especificado número de veces.

Veamos algunos ejemplos para entenderlo mejor.

import timeit

#This code will be executed only once, before stmt.
setup_code = "from math import sqrt"

#This code will be executed as specified by the parameter 'number'
stmt_code = "sum(sqrt(x) for x in range(1,10000))"
iterations = 10000
time = timeit.timeit(stmt = stmt_code, setup = setup_code, number = iterations)

print(time)

#17.9 seconds
#THIS OUTPUT IS FOR 10000 ITERATIONS OF THE CODE SNIPPET AND NOT A SINGLE ITERATION.

print(f"The time for single iteration is {time/iterations}")

Todo lo que hicimos fue pasar el código como una cadena y especificar el número de iteraciones al timeit.timeit función.

Ahora veamos una forma de usar esta increíble biblioteca para comparar dos funciones.

Para este ejemplo, comparemos dos funciones de ordenación, una es una ordenación de burbujas simple y la otra es la función incorporada de Python ordenado () función. Aquí también veremos otro cronométralo función llamada repetir().

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(0, len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr


def make_random_array():
    from random import randint

    return [randint(-100, 100) for i in range(20)]


test_array = make_random_array()
'''
Since we want to make sure that we test our functions on the same array, we are declaring an array
here and will later call it in compare_functions().
'''

def compare_functions():
    import timeit

    setup_code1 = """
from __main__ import bubble_sort
from __main__ import test_array
"""
    setup_code2 = """
from __main__ import test_array
"""
    stmt_code1 = "bubble_sort(test_array)"
    stmt_code2 = "sorted(test_array)"

    times1 = timeit.repeat(stmt=stmt_code1, setup=setup_code1, number=10000, repeat=5)
    times2 = timeit.repeat(stmt=stmt_code2, setup=setup_code2, number=10000, repeat=5)
    print(f"Time taken by bubble sort is {min(times1)}")
    print(f"Time taken by built in sort is {min(times2)}")

if __name__ == "__main__":
    compare_functions()
"""
Time taken by bubble sort is 0.2646727000001192
Time taken by built in sort is 0.0031973000000107277
"""

Aquí, la salida es el valor mínimo en la lista. veces1 y veces 2.

En el código de configuración, teníamos,

from __main__ import bubble sort
from __main__ import arrThis imports the bubble_sort function already defined in our program and also import the array 'test_array' which we declared in the program earlier.
This will make sure that both the functions are tested on the same array, 'test_array'.

timeit.repeat () toma un parámetro adicional, repetir (valor predeterminado = 5). Esto devuelve una lista de tiempos de ejecución del fragmento de código repetido varias veces.

Como era de esperar, el tiempo que tarda la clasificación de burbujas es mucho mayor que el tiempo ordenado () función.

Ahora, para terminar, veamos cómo podemos usar la interfaz de línea de comandos en esta biblioteca.

Cuando se llama como un programa desde la línea de comandos, se utiliza el siguiente formulario:

python -m timeit [-n N] [-r N] [-u U] [-s S][statement ...]

Aquí,

1. -n N, cuántas veces se ejecutará la ‘instrucción’.
2. -r N, cuantas veces repetir
3. -ss, declaración de configuración
4. -uu, unidad de salida del temporizador, (nano, micro, mil, seg)

Algunos ejemplos como son:

$ python -m timeit -s 'text = "sample string"; char = "g"'  'char in text'
5000000 loops, best of 5: 0.0877 usec per loop
$ python -m timeit -s 'text = "sample string"; char = "g"'  'text.find(char)'
1000000 loops, best of 5: 0.342 usec per loop

Esto concluye la introducción del módulo timeit. Traté de cubrir todo lo que uno necesita saber para comenzar a usar este módulo a partir de ahora.

Aquí está el documentación oficial del módulo. Échale un vistazo para saber más sobre este módulo. También te animo a que eches un vistazo al código fuente de este módulo. aquí.

Espero que hayas aprendido algo de este artículo y, a partir de ahora, puedas usar la funcionalidad de este módulo en tu código. Paz.

Sobre el Autor

Kushagra Bansal

Soy un estudiante de pregrado con especialización en Matemáticas y soy un aprendiz apasionado con un gran interés en Ciencias de la Computación y Astrofísica. Me identifico como un aprendiz rápido y creo en aprender practicando. Las nuevas tecnologías como el aprendizaje automático, el aprendizaje profundo y la visión por computadora, etc., me impresionan mucho. También me gusta mucho leer.

Relacionado