Messen Sie die Zeit in Python?

Was ich will, ist, die Zeit zu beginnen, irgendwo in meinem Code zu zählen und dann die vergangene Zeit zu bekommen, um die Zeit zu messen, die es braucht, um einige Funktion auszuführen. Ich denke, ich benutze das Timim-Modul falsch, aber die Docs sind nur verwirrend für mich.

import timeit start = timeit.timeit() print "hello" end = timeit.timeit() print end - start 

  • Was ist schneller in Python: x **. 5 oder math.sqrt (x)?
  • Finden Sie Cumsum von Subarrays aufgeteilt durch Indizes für numpy Array effizient
  • Schneller Python MySQL
  • Übergeben von Iteratoren zu jedem für die Ausführung für Geschwindigkeit und Warum?
  • Effiziente Mathe ops auf kleinen Arrays in Python mit Zython
  • Geschwindigkeit der Rechenleistung (in Python)
  • 16 Solutions collect form web for “Messen Sie die Zeit in Python?”

    Wenn du nur die verstrichene Wanduhr zwischen zwei Punkten messen willst, kannst du time.time() :

     import time start = time.time() print("hello") end = time.time() print(end - start) 

    Dies gibt die Ausführungszeit in Sekunden.

    Eine weitere Option seit 3.3 könnte sein, perf_counter oder process_time , je nach Ihren Anforderungen. Vor 3.3 wurde empfohlen, use time.clock (Dank @Amber) zu verwenden. Allerdings ist es derzeit abgelehnt:

    Bei Unix die aktuelle Prozessorzeit als Gleitkommazahl in Sekunden zurückgeben. Die Präzision und in der Tat die Definition der Bedeutung der "Prozessorzeit" hängt von der der gleichnamigen C-Funktion ab.

    Unter Windows kehrt diese Funktion seit dem ersten Aufruf dieser Funktion als Floating-Point-Nummer auf Basis der Win32-Funktion QueryPerformanceCounter() . Die Auflösung ist typischerweise besser als eine Mikrosekunde.

    Seit Version 3.3 veraltet : Das Verhalten dieser Funktion hängt von der Plattform ab: Verwenden Sie perf_counter() oder process_time() stattdessen je nach Ihren Anforderungen ein process_time() definiertes Verhalten.

    Benutze timeit.default_timer anstelle von timeit.timeit . Die ehemalige bietet die beste Uhr auf Ihrer Plattform und Version von Python automatisch:

     from timeit import default_timer as timer start = timer() # ... end = timer() print(end - start) 

    Timeit.default_timer wird time.time () oder time.clock () abhängig von OS zugewiesen. Auf Python 3.3+ default_timer ist time.perf_counter () auf allen Plattformen. Siehe Python – time.clock () vs. time.time () – Genauigkeit?

    Siehe auch:

    • Code optimieren
    • Wie für Geschwindigkeit zu optimieren

    Angesichts einer Funktion, die Sie gerne Zeit haben,

    Test.py:

     def foo(): # print "hello" return "hello" 

    Der einfachste Weg, um timeit zu verwenden, ist, es von der Kommandozeile aus zu nennen:

     % python -mtimeit -s'import test' 'test.foo()' 1000000 loops, best of 3: 0.254 usec per loop 

    Versuchen Sie nicht, time.time oder time.clock (naiv) zu verwenden, um die Geschwindigkeit der Funktionen zu vergleichen. Sie können irreführende Ergebnisse geben .

    PS Setzen Sie keine Druckaussagen in eine Funktion, die Sie Zeit haben möchten. Andernfalls hängt die gemessene Zeit von der Geschwindigkeit des Terminals ab .

    Nur Python 3:

    Da time.clock () ab Python 3.3 veraltet ist , solltest du time.perf_counter() für systemweites Timing oder time.process_time() für time.process_time() Timing verwenden, genau wie du Zeit benutzt hast time.clock() :

     import time t = time.process_time() #do some stuff elapsed_time = time.process_time() - t 

    Die neue Funktion process_time keine Zeit, die während des Schlafes verstrichen ist.

    Es macht Spaß, dies mit einem Kontext-Manager zu tun, der sich automatisch an die Startzeit beim Einstieg an einen Block erinnert, dann die Endzeit with Blockausgang einfriert. Mit einem kleinen Trick, können Sie sogar eine laufende verstrichene Zeit innerhalb des Blocks aus der gleichen Kontext-Manager-Funktion.

    Die Kernbibliothek hat das nicht (aber wahrscheinlich sollte). Einmal an Ort und Stelle können Sie Dinge wie:

     with elapsed_timer() as elapsed: # some lengthy code print( "midpoint at %.2f seconds" % elapsed() ) # time so far # other lengthy code print( "all done at %.2f seconds" % elapsed() ) 

    Hier ist Contextmanager- Code ausreichend, um den Trick zu machen:

     from contextlib import contextmanager from timeit import default_timer @contextmanager def elapsed_timer(): start = default_timer() elapser = lambda: default_timer() - start yield lambda: elapser() end = default_timer() elapser = lambda: end-start 

    Und einige runnable Demo-Code:

     import time with elapsed_timer() as elapsed: time.sleep(1) print(elapsed()) time.sleep(2) print(elapsed()) time.sleep(3) 

    Beachten Sie, dass bei der Auslegung dieser Funktion der Rückgabewert von elapsed() bei Blockausgang eingefroren ist und weitere Anrufe die gleiche Dauer (von etwa 6 Sekunden in diesem Spielzeugbeispiel) zurückgeben.

    Mit time.time , um die Ausführung zu messen, gibt Ihnen die Gesamtausführungszeit Ihrer Befehle einschließlich der Laufzeit, die von anderen Prozessen auf Ihrem Computer verbracht wird. Es ist die Zeit, die der Benutzer bemerkt, aber ist nicht gut, wenn man verschiedene Code-Snippets / Algorithmen / Funktionen / … vergleichen möchte …

    Weitere Informationen über timeit :

    • Mit dem timeit Modul
    • Timeit – Zeit die Ausführung von kleinen Bits von Python-Code

    Wenn Sie einen tieferen Einblick in das Profilieren wünschen:

    Update : Ich habe http://pythonhosted.org/line_profiler/ eine Menge während des letzten Jahres und finde es sehr hilfreich und empfehlen, es anstelle von Pythons Profil-Modul verwenden.

    Die python cProfile- und pstats-Module bieten eine große Unterstützung für die Messung der Zeit, die in bestimmten Funktionen vergangen ist, ohne einen Code um die vorhandenen Funktionen hinzuzufügen.

    Zum Beispiel, wenn Sie ein Python-Skript haben timeFunctions.py:

     import time def hello(): print "Hello :)" time.sleep(0.1) def thankyou(): print "Thank you!" time.sleep(0.05) for idx in range(10): hello() for idx in range(100): thankyou() 

    Um den Profiler auszuführen und Stats für die Datei zu generieren, kannst du einfach laufen:

     python -m cProfile -o timeStats.profile timeFunctions.py 

    Was das tut, ist das cProfile-Modul, um alle Funktionen in timeFunctions.py zu profilieren und die Stats in der Datei timeStats.profile zu sammeln. Beachten Sie, dass wir dem bestehenden Modul (timeFunctions.py) keinen Code hinzufügen mussten, und dies kann mit jedem Modul erfolgen.

    Sobald Sie die Statistik-Datei haben, können Sie das pstats-Modul wie folgt ausführen:

     python -m pstats timeStats.profile 

    Dies führt die interaktive Statistik-Browser, die Ihnen eine Menge schöne Funktionalität gibt. Für Ihren speziellen Gebrauch Fall können Sie gerade die Statistiken für Ihre Funktion überprüfen. In unserem Beispiel prüft die Statistik für beide Funktionen:

     Welcome to the profile statistics browser. timeStats.profile% stats hello <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'hello'> ncalls tottime percall cumtime percall filename:lineno(function) 10 0.000 0.000 1.001 0.100 timeFunctions.py:3(hello) timeStats.profile% stats thankyou <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'thankyou'> ncalls tottime percall cumtime percall filename:lineno(function) 100 0.002 0.000 5.012 0.050 timeFunctions.py:7(thankyou) 

    Das Dummy-Beispiel macht nicht viel, aber geben Sie eine Vorstellung davon, was getan werden kann. Der beste Teil über diesen Ansatz ist, dass ich nicht irgendwelche meiner vorhandenen Code zu bearbeiten, um diese Zahlen zu bekommen und offensichtlich helfen mit Profiling.

    Hier ist eine kleine Timer-Klasse, die "hh: mm: ss" String zurückgibt:

     class Timer: def __init__(self): self.start = time.time() def restart(self): self.start = time.time() def get_time_hhmmss(self): end = time.time() m, s = divmod(end - self.start, 60) h, m = divmod(m, 60) time_str = "%02d:%02d:%02d" % (h, m, s) return time_str 

    Verwendung:

     # Start timer my_timer = Timer() # ... do something # Get time string: time_hhmmss = my_timer.get_time_hhmmss() print("Time elapsed: %s" % time_hhmmss ) # ... use the timer again my_timer.restart() # ... do something # Get time: time_hhmmss = my_timer.get_time_hhmmss() # ... etc 

    Hier ist ein weiterer Kontext-Manager für Timing-Code –

    Verwendung:

     from benchmark import benchmark with benchmark("Test 1+1"): 1+1 => Test 1+1 : 1.41e-06 seconds 

    Oder, wenn Sie den Zeitwert benötigen

     with benchmark("Test 1+1") as b: 1+1 print(b.time) => Test 1+1 : 7.05e-07 seconds 7.05233786763e-07 

    Benchmark.py :

     from timeit import default_timer as timer class benchmark(object): def __init__(self, msg, fmt="%0.3g"): self.msg = msg self.fmt = fmt def __enter__(self): self.start = timer() return self def __exit__(self, *args): t = timer() - self.start print(("%s : " + self.fmt + " seconds") % (self.msg, t)) self.time = t 

    Angepasst von http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

    (Nur mit Ipython) kannst du % timeit verwenden , um die durchschnittliche Bearbeitungszeit zu messen:

     def foo(): print "hello" 

    und dann:

     %timeit foo() 

    Das Ergebnis ist so etwas wie:

     10000 loops, best of 3: 27 µs per loop 

    Auf python3:

     from time import sleep, perf_counter as pc t0 = pc() sleep(1) print(pc()-t0) 

    Elegant und kurz

    Ich habe dafür eine Bibliothek gemacht, wenn du eine Funktion messen willst, kannst du es einfach so machen

     from pythonbenchmark import compare, measure import time a,b,c,d,e = 10,10,10,10,10 something = [a,b,c,d,e] @measure def myFunction(something): time.sleep(0.4) @measure def myOptimizedFunction(something): time.sleep(0.2) myFunction(input) myOptimizedFunction(input) 

    https://github.com/Karlheinzniebuhr/pythonbenchmark

    Wir können auch Zeit in menschlich lesbare Zeit umwandeln.

     import time, datetime start = time.clock() def num_multi1(max): result = 0 for num in range(0, 1000): if (num % 3 == 0 or num % 5 == 0): result += num print "Sum is %d " % result num_multi1(1000) end = time.clock() value = end - start timestamp = datetime.datetime.fromtimestamp(value) print timestamp.strftime('%Y-%m-%d %H:%M:%S') 

    Ein weiterer Weg, um Zeit zu verwenden:

     from timeit import timeit def func(): return 1 + 1 time = timeit(func, number=1) print(time) 

    Profilmodul verwenden. Es gibt ein sehr detailliertes Profil.

     import profile profile.run('main()') 

    Es gibt so etwas wie:

      5 function calls in 0.047 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.000 0.000 :0(exec) 1 0.047 0.047 0.047 0.047 :0(setprofile) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 0 0.000 0.000 profile:0(profiler) 1 0.000 0.000 0.047 0.047 profile:0(main()) 1 0.000 0.000 0.000 0.000 two_sum.py:2(twoSum) 

    Ich habe es sehr informativ gefunden.

    Du kannst Timeit benutzen.

    Hier ist ein Beispiel, wie man naive_func testet, das Parameter mit Python REPL übernimmt:

     >>> import timeit >>> def naive_func(x): ... a = 0 ... for i in range(a): ... a += i ... return a >>> def wrapper(func, *args, **kwargs): ... def wrapper(): ... return func(*args, **kwargs) ... return wrapper >>> wrapped = wrapper(naive_func, 1_000) >>> timeit.timeit(wrapped, number=1_000_000) 0.4458435332577161 

    Sie brauchen keine Wrapper-Funktion, wenn Funktion keine Parameter hat.

    Python ist die beste Programmiersprache der Welt.