Módulo timeit em Python

O módulo timeit é utilizado para medir o tempo de execução de trechos de código. Sua função principal é timeit.timeit(), que calcula o tempo necessário para executar uma determinada operação ou função:

timeit.timeit(stmt='pass', setup='pass', timer=<default timer>, number=1000000, globals=None)

Essa função aceita os seguintes parâmetros:

stmt: código cuja execução será medida. O valor padrão é pass.
setup: código executado antes de stmt. O valor padrão também é pass. Normalmente, é usado para importar módulos necessários para a execução do código a ser medido.
timer: temporizador utilizado, representado por um objeto timeit.Timer. Em geral, o valor padrão já é adequado para a plataforma.
number: número de vezes que stmt será executado. O valor padrão é 1000000.
globals: define o espaço de nomes onde o código será executado.

A função retorna o tempo de execução em segundos.

O exemplo a seguir mede o tempo necessário para executar uma função que calcula a soma dos números de 1 a 10000:

import timeit

def sum():
    result = 0
    for i in range(10000):
        result += i
    return result

execution_time = timeit.timeit(lambda: sum(), number=100)

print("Tempo de execução da função sum:", execution_time)

Aqui, a função sum é chamada dentro de uma expressão lambda para ser executada pelo timeit.timeit(). O parâmetro number foi definido como 100, o que significa que a função será executada 100 vezes para a medição.

A saída será algo como:

Tempo de execução da função sum: 0.01668926700222073

Definição do Código a Ser Medido

No exemplo anterior, a execução foi medida chamando uma função definida no código. No entanto, também é possível especificar o código diretamente como uma string:

import timeit

action = "10+12"

print(timeit.timeit(action))

Aqui, o tempo de execução da expressão 10+12 será medido. Como o parâmetro number não foi definido, a execução ocorrerá 1 milhão de vezes por padrão.

Se o código contiver várias instruções, elas podem ser separadas por ponto e vírgula:

import timeit

action = "a=10; b=12; a+b"

print(timeit.timeit(action))

Quando o código a ser medido for mais extenso, incluindo estruturas condicionais ou laços, pode ser útil defini-lo dentro de uma string com aspas triplas:

import timeit

action = '''
def sum():
    result = 0
    for n in range(100):
        result += n
    return result
'''

print(timeit.timeit(action))

Esse método permite medir a execução de funções completas. Como alternativa, é possível definir a função separadamente e chamá-la dentro do timeit.timeit(), como feito no primeiro exemplo.

Importação de Funções Externas

Se a função que será medida estiver em outro módulo, ela precisa ser importada. O parâmetro setup pode ser utilizado para isso. Suponha que a função sum_test() esteja no módulo test. O código para medi-la ficaria assim:

import timeit

my_action = "sum_test()"
my_setup = "from test import sum_test"

print(timeit.timeit(my_action, setup=my_setup))

Uso de Temporizadores

A função timeit.timeit() usa um temporizador interno, representado por um objeto da classe timeit.Timer:

class timeit.Timer(stmt='pass', setup='pass', timer=<default timer>, number=1000000, globals=None)

O construtor dessa classe aceita os mesmos parâmetros da função timeit.timeit(). Além disso, timeit fornece a função timeit.default_timer(), que retorna o temporizador padrão da plataforma. Esse temporizador pode ser usado para medições manuais:

import timeit

def sum():
    result = 0
    for n in range(100):
        result += n
    return result

start = timeit.default_timer()
print("Start time:", start)

sum()

print("Execution time:", timeit.default_timer() - start)

Aqui, timeit.default_timer() é chamado antes e depois da execução da função sum(), permitindo calcular seu tempo de execução manualmente.

Documentação:

timeit