comment passer des paramètres d'une fonction lors de l'utilisation de timeit.Timer()

Les fonctions peuvent utiliser des arguments en timeit si ceux-ci sont créés en utilisant les fermetures, nous pouvons ajouter ces comportements en les enveloppant dans une autre fonction.

def foo(num1, num2):
    def _foo():
        # do something to num1 and num2
        pass
    return _foo

A = 1
B = 2

import timeit
t = timeit.Timer(foo(A,B))  
print t.timeit(5)

ou plus court, on peut utiliser functools.partielle plutôt explicite fermetures déclaration

def foo(num1, num2):
    # do something to num1 and num2
    pass

A = 1
B = 2

import timeit, functools
t = timeit.Timer(functools.partial(foo, A, B)) 
print t.timeit(5)

Votre fonction doit être définie dans la configuration de la chaîne. Une bonne façon de le faire est par la mise en place de votre code dans un module simple de sorte que vous avez à faire

t = timeit.Timer("foo(num1, num2)", "from myfile import foo")
t.timeit(5)

Sinon, vous aurez à définir l'ensemble de l'installation d'une chaîne à l'intérieur de l'installation de déclaration.

setup = """
 # some pre-defined constants
A = 1
B = 2

# function that does something critical
def foo(num1, num2):
    # do something

# main program.... do something to A and B
for i in range(20):
    # do something to A and B
    # and update A and B during each iteration
"""

t = timeit.Timer("foo(num1, num2)", setup)
t.timeit(5)

Quelque chose de génial, je viens de découvrir sur est un raccourci pour iPython qui utilise cProfile.

def foo(x, y):
    print x*y

%prun foo("foo", 100)

Voici un exemple de la façon de compartimenter le calendrier de routine, sans appel globals

def foo(a, b):
    '''Do something to `a` and `b`'''
    return a + b

def time_foo():
    '''Create timer object simply without using global variables'''
    import timeit

    _foo = foo
    a = 1
    b = 2

    # Get `Timer` oject, alternatively just get time with `timeit.timeit()`
    t = timeit.Timer('_foo(a, b)', globals=locals())

    return t

On pourrait même généraliser cette option si vous voulez utiliser la même timeit fonction du temps d'autres fonctions. Voici un exemple avec votre exemple main() routine:

def foo1(a, b):
    '''Add `a` and `b`'''
    return a + b

def foo2(a, b):
    '''More math on `a` and `b`'''
    return (a**2 * b)**2

def time_foo(func, **kwargs):
    '''Create timer object simply without using global variables'''
    import timeit
    return timeit.timeit('func(**kwargs)', globals=locals())

def run():
    '''Modify inputs to foo and see affect on execution time'''

    a = 1
    b = 2
    for i in range(10):
        # Update `a` and `b`
        a += 1
        b += 2
        # Pass args to foo as **kwargs dict
        print('foo1 time: ', time_foo(foo1, **{'a':a, 'b':b}))
        print('foo2 time: ', time_foo(foo2, **{'a':a, 'b':b}))

    return None

Je préfère la création d'un static de classe avec toutes les Données prêtes à être récupérées avant de l'exécution de la minuterie.

Une autre note, il est préférable de faire le test s'exécute en fonction plutôt que dans l'espace mondial, comme l'espace mondial n'est pas de prendre avantage de FAST_LOAD Pourquoi ne code Python courir plus vite dans une fonction?

class Data(object):
    """Data Creation"""
    x = [i for i in range(0, 10000)]
    y = tuple([i for i in range(0, 10000)])
    def __init__(self):
        pass

import timeit

def testIterator(x):
    for i in range(10000):
        z = i


print timeit.timeit("testIterator(Data.x)", setup="from __main__ import testIterator, Data", number=50)
print timeit.timeit("testIterator(Data.y)", setup="from __main__ import testIterator, Data", number=50)

J'ai été jouer avec le timing en Python 3.7 aujourd'hui et essayer de passer de variables et de fonctions dans la minuterie. C'est ce que je suis venu avec.

import re

text = "This         is      a  test of the      emergency broadcast       system"

def regex(text):
    return re.sub(r"(\s){1,}", r"", text)

def loop_while(text):
    if "  " in text:
        while "  " in text:
            text = text.replace("  ", " ")

    return text

if __name__ == "__main__":
    import timeit

    callable_functions = [item for item in locals().items() if callable(item[1])]

    for func_name, func in callable_functions:
        elapsed_time = timeit.timeit(f"{func_name}(text)", globals=globals(), number=100000)
        print(f"{func_name}: {elapsed_time} \n{func(text)}\n")

Ce sorties:

regex: 1.378352418

Ceci est un test du système de diffusion d'urgence

loop_while: 0.15858950299999997

Ceci est un test de l'urgence
système de diffusion

Tout ce qu'il faut pour tester une nouvelle version est l'ajout d'une nouvelle fonction. Quelque chose comme:

def split_join(text):
    return " ".join(text.split())

Maintenant, c'sorties:

regex: 1.378352418

Ceci est un test du système de diffusion d'urgence

loop_while: 0.15858950299999997

Ceci est un test du système de diffusion d'urgence

split_join: 0.05700970800000005

Ceci est un test du système de diffusion d'urgence