Est-il un moyen simple de référence de script python?

Ont un coup d'oeil à timeit, le python profiler et pycallgraph.

timeit

def test():
    """Stupid test function"""
    lst = []
    for i in range(100):
        lst.append(i)

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

Essentiellement, vous pouvez passer le code python comme un paramètre de chaîne, et il sera exécuté dans le laps de temps et imprime le temps d'exécution. Les choses importantes à partir de la documentation:

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

Créer un Timer exemple avec la déclaration donnée, installation
code et minuterie fonction et d'exécuter ses timeit méthode avec
nombre exécutions.

... et:

Timer.timeit(number=1000000)

Temps nombre exécutions de la principale déclaration. Ceci exécute le programme d'installation
déclaration une fois, puis retourne le temps qu'il faut pour exécuter le principal
déclaration d'un certain nombre de fois, mesurée en secondes comme un float.
L'argument est le nombre de fois dans la boucle, la valeur par défaut d'un
millions de dollars. La principale déclaration, la déclaration et le programme d'installation de la fonction de minuterie
être utilisés sont transmis au constructeur.

Note

Par défaut, timeit permet de désactiver temporairement garbage
collection pendant le chronométrage. L'avantage de cette approche est qu'
il prend en toute indépendance des timings plus comparables. Cet inconvénient est
que la GC peut être une composante importante de la performance de l'
la fonction de mesure. Si oui, GC peut être activé de nouveau comme la première
déclaration dans le installation chaîne. Par exemple:

timeit.Timer('for i in xrange(10): oct(i)', 'gc.enable()').timeit()

Profilage

De profilage de vous donner un beaucoup plus détaillée idée de ce qui se passe. Voici la "instantanée exemple" de les docs officielles:

import cProfile
import re
cProfile.run('re.compile("foo|bar")')

Qui vous donnera:

      197 function calls (192 primitive calls) in 0.002 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.000    0.000    0.001    0.001 <string>:1(<module>)
     1    0.000    0.000    0.001    0.001 re.py:212(compile)
     1    0.000    0.000    0.001    0.001 re.py:268(_compile)
     1    0.000    0.000    0.000    0.000 sre_compile.py:172(_compile_charset)
     1    0.000    0.000    0.000    0.000 sre_compile.py:201(_optimize_charset)
     4    0.000    0.000    0.000    0.000 sre_compile.py:25(_identityfunction)
   3/1    0.000    0.000    0.000    0.000 sre_compile.py:33(_compile)

Deux de ces modules devraient vous donner une idée de où chercher pour les goulets d'étranglement.

Aussi, de se familiariser avec la sortie de profile, jetez un oeil à ce post

pycallgraph

Ce module utilise graphviz pour créer callgraphs comme suit:

Vous pouvez facilement voir quels chemins utilisés la plupart du temps par la couleur. Vous pouvez les créer à l'aide de la pycallgraph API, ou à l'aide d'un emballés script:

pycallgraph graphviz -- ./mypythonscript.py

La surcharge est tout à fait considérable si. Donc, déjà, le long processus en cours d'exécution, la création du graphique peut prendre un certain temps.

La timeit module a été lente et bizarre, j'ai donc écrit ceci:

def timereps(reps, func):
    from time import time
    start = time()
    for i in range(0, reps):
        func()
    end = time()
    return (end - start) / reps

Exemple:

import os
listdir_time = timereps(10000, lambda: os.listdir('/'))
print "python can do %d os.listdir('/') per second" % (1 / listdir_time)

Pour moi, il dit:

python can do 40925 os.listdir('/') per second

C'est un type primitif de l'analyse comparative, mais il est assez bon.

Ont un coup d'oeil à nez et à l'un de ses plugins, cette une en particulier.

Une fois installé, le nez est un script sur votre chemin, et que vous pouvez appeler dans un répertoire qui contient des scripts python:

$: nosetests

Cela va chercher dans tous les fichiers python dans le répertoire courant et va exécuter une fonction qu'il reconnaît comme un test: il reconnaît par exemple une fonction avec le mot test_ en son nom comme un test.

De sorte que vous pouvez simplement créer un script python appelé test_yourfunction.py et d'écrire quelque chose comme ça:

$: cat > test_yourfunction.py

def test_smallinput():
    yourfunction(smallinput)

def test_mediuminput():
    yourfunction(mediuminput)

def test_largeinput():
    yourfunction(largeinput)

Alors vous devez exécuter

$: nosetest --with-profile --profile-stats-file yourstatsprofile.prof testyourfunction.py

et de lire le fichier de profil, utilisez ce python ligne:

python -c "import hotshot.stats ; stats = hotshot.stats.load('yourstatsprofile.prof') ; stats.sort_stats('time', 'calls') ; stats.print_stats(200)"

Attention timeit est très lent, il faudra 12 seconde sur mon support de processeur pour initialiser (ou peut-être l'exécution de la fonction). vous pouvez tester ce accepté de répondre à

def test():
    lst = []
    for i in range(100):
        lst.append(i)

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test")) # 12 second

pour la simple chose que je vais utiliser time au lieu de cela, sur mon PC, il retournera le résultat 0.0

import time

def test():
    lst = []
    for i in range(100):
        lst.append(i)

t1 = time.time()

test()

result = time.time() - t1
print(result) # 0.000000xxxx

Si vous ne voulez pas écrire du code réutilisable pour timeit et obtenir facile à analyser les résultats, prendre un coup d'oeil à benchmarkit. Aussi il permet d'économiser de l'histoire des courses précédentes, de sorte qu'il est facile de comparer la même fonction au cours du développement.

# pip install benchmarkit

from benchmarkit import benchmark, benchmark_run

N = 10000
seq_list = list(range(N))
seq_set = set(range(N))

SAVE_PATH = '/tmp/benchmark_time.jsonl'

@benchmark(num_iters=100, save_params=True)
def search_in_list(num_items=N):
    return num_items - 1 in seq_list

@benchmark(num_iters=100, save_params=True)
def search_in_set(num_items=N):
    return num_items - 1 in seq_set

benchmark_results = benchmark_run(
   [search_in_list, search_in_set],
   SAVE_PATH,
   comment='initial benchmark search',
)  

Imprime à la borne et retourne la liste de dictionnaires avec les données de la dernière exécution. Ligne de commande entrypoints également disponibles.

Si vous modifiez N=1000000 et exécutez à nouveau