[Python] Zeitmessung mit timeit

[Nemesis]

Hi,
ich würde gerne messen, wieviel ms eine Funkion in anspruch nimmt.
an sich sollte das, wie hier beschrieben mit timeit funktionieren.

ich habe die funktion die aufgerufen wird wie folgt definiert:

     def dotime(self):
          t = timeit.Timer("draw()","from __main__ import *")
          time = t.timeit(1)
          print "took %fs\n" % (time,)

wobei draw() dann die funktion ist, bei der die zeit gemessen werden soll.

aber ich bekomme dann folgenden error:

Traceback (most recent call last):
  File "/usr/lib/python2.5/lib-tk/Tkinter.py", line 1417, in __call__
    return self.func(*args)
  File "~/Projects/python-foobar/src/python_foobar.py", line 31, in dotime
    time = t.timeit(1)
  File "/usr/lib/python2.5/timeit.py", line 161, in timeit
    timing = self.inner(it, self.timer)
  File "<timeit-src>", line 6, in inner
NameError: name 'draw' is not defined

kennt sich jemand mit Zeitmessung aus?

danke !

 

[bytepool]

Hi,

Wie war das doch gleich mit 'from foo import *'?
Probier es mal mit 'from __main__ import draw'; wenn draw existiert, sollte das funktionieren.
Ansonsten benutze ich persoenlich auch immer gern das Unix Programm time, wenn ich schnell ein paar Codeschnipsel auf Performance testen will ('$ time python foo.py').

mfg,
bytepool

 

[Nemesis]

ich habs auch schon mit t = timeit.Timer("draw()","from __main__ import draw") probiert, aber das ging auch net.
draw() ist eine methode der klasse Butterfly, genau wie dotime(), ist das dann so schon korrekt ?

 

[bytepool]

Hi,

draw() ist eine methode der klasse Butterfly, genau wie dotime(), ist das dann so schon korrekt ?

Dann kann das natuerlich nicht funktionieren, was du mit timeit ausfuehren willst muss schon funktionierender Code sein... Wenn draw eine Methode einer Klasse ist, wirst du draw() so direkt ja auch nicht ausfuehren koennen, nicht wahr?

Kleines Beispiel:

>>> import timeit
>>> class Foo(object):
...       def foo(self): print "a",
...
>>> t = timeit.Timer("Foo().foo()", "from __main__ import Foo")
>>> t.timeit(1)
a
2.193450927734375e-05

Edit:
Die imports muessen natuerlich auch stimmen, d.h. wenn du nicht direkt im Interpreter arbeitest, wirst du hoechstwahrscheinlich nicht von __main__ importieren...

mfg,
bytepool

 

[Nemesis]

also gibts keine möglichkeit die zeit zu messen die eine methode benötigt und diese dann einer variablen zu übergeben um sie weiter zu verwenden ?

 

[bytepool]

Ehm, ich hab doch extra ein Beispiel ausgetippt, was ist daran nicht verstaendlich?

Edit:
Vielleicht wird es noch deutlicher, wenn es so geschrieben steht?

t = timeit.Timer("foo = Foo(); foo.foo()", "from __main__ import Foo")

 

[Nemesis]

naja, so hab ichs gemacht, aber jetzt öffnet er mir jedesmal das fenster neu, wenn ich die methode ausführe.

     def dotime(self):
          t = timeit.Timer("Butterfly().draw()","from __main__ import Butterfly")
          time = t.timeit()
          print "took %fs\n" % (time,)

 

[bytepool]

Ich weiss nicht was du genau erreichen willst, aber das klingt doch so weit logisch. Wenn du einfach irgendwo im Code kurz eine Zeitmessung machen willst, wieso schreibst du das nicht einfach auf die schnelle?

import time
t1 = time.time()
Foo().foo()
t2 = time.time()
diff = t2 - t1

Im Interpreter macht das keinen Sinn da die Zeitmessung dann davon abhaengig ist wie schnell du tippst, aber in nem Modul funktioniert das prima. Und wenn du das haeufiger fuer Funktionen brauchst, kannst du dir da auch noch ne eigene Funktion zu schreiben, z.B.

def measure(callable):
...     t1 = time.time()
...     callable()
...     t2 = time.time()
...     print "Time it took to call", callable, ": ", t2 - t1
...
>>> measure(Foo().foo)

mfg,
bytepool

 

[Nemesis]

hm, ok, das is auch nen methode ... danke !

edit:
warum variiert eigentlich die zeit, die er für die berechnungen benötigt so umfangreich ? müsste er nicht immer die selbe zeit für die berechnungen benötigen ?