Python CPU-Zeit auf Windows

Question

Ich bin auf der Suche nach einer Möglichkeit, die CPU-Zeit des Teils meines Python-Programms zu messen. Ich schaute mich um und es scheint, dass alle Zeitmessfunktionen, die ich finden konnte, die Wanduhrzeit unter Windows messen. Gibt es eine Möglichkeit, die CPU-Zeit unter Windows für Python zu messen? Vielen Dank.

Answer 1

time.process_time()

https://www.python.org/dev/peps/pep-0418/

Die neue time.process_time() Funktion fungiert als tragbare Zähler dass CPU-Zeit immer misst (Zeit während des Schlafes verstrichen ohne) und hat die beste verfügbare Auflösung.

Früher für jedermann beantworten wollen timeit() verwenden, um Durchschnitt:

Ich schrieb dieses, während vor kurzem Python zu lernen. Es ist eine timeit.Timer Klasse, die timeit() über Funktionen für die Mittelung iteriert; in meiner Forschung schien das Timing leicht zu durcheinander zu sein und zeit() scheinbar knifflig zu sein, um funktionieren zu können (obwohl es einfacher war, an der Kommandozeile zu arbeiten). Das funktioniert.

Beachten Sie auch diese Antwort schlägt die beste Wette time.process_time() für Python ist 3.3+ und erinnert daran, dass .default_timer() Wand Zeit:

https://stackoverflow.com/a/15176730/3981745

""" Sum a range with timing/comparisons. 

    - Manually summing from low..high : a beginner's loop with no algorithms experience 
    - Python's sum() - does the same thing for an "efficient" programmer 
    - Fast sum - a programmer with math focus 
    - Timing calls (easy to do wrong) 

    This is a trivial formula to demonstrate what a little math can do; for games this type of optimization is critical. It could probably be even more optimized. 
""" 

def slow_way(lo, hi): 
    s=0 
    for i in range(lo, hi+1): 
     s+=i 
    return s 

def fast_way(lo, hi): 
    lph=lo+hi  # lo plus hi 
    hmlpo=hi-lo+1 # hi minus lo plus one 
    pairs=hmlpo//2 

    #print("-", lo,hi,pairs, pairs*lph, (lo+pairs)*(hmlpo%2)) 

    return (pairs*lph + (lo+pairs)*(hmlpo%2)) 

import timeit 
# 'builtin' hack doesn't seem to work 
#import __builtin__ 
#__builtin__.__dict__.update(locals()) 

ranges=[] 
ranges.append((1,10,)) 
ranges.append((2,10,)) 
ranges.append((3,10,)) 
ranges.append((4,10,)) 
ranges.append((5,10,)) 
ranges.append((32,10032,)) 

print("Calculation check...") 
print("slow : sum : fast : should all match") 
for tupl in ranges: 
    l=tupl[0]; h=tupl[1] 
    print("{} : {} : {}".format(slow_way(l,h), sum(range(l, h+1)), fast_way(l,h))) 

iters=100000 
print("-"*20 +"\nTime compare ({} iterations) : lower is better".format(iters)) 
slow=timeit.Timer("slow_way(1,101)", "from __main__ import slow_way") 
print("slow: {0:.6f}".format(slow.timeit(number=iters))) 

# functions include last number, range should be +1 
s=timeit.Timer("sum(range(1,102))", "") 
print(" sum: {0:.6f}".format(s.timeit(number=iters))) 

fast=timeit.Timer("fast_way(1,101)", "from __main__ import fast_way") 
print(" fast: {0:.6f}".format(fast.timeit(number=iters))) 

Ausgabe

Calculation check... 
slow : sum : fast : should all match 
55 : 55 : 55 
54 : 54 : 54 
52 : 52 : 52 
49 : 49 : 49 
45 : 45 : 45 
50325032 : 50325032 : 50325032 
-------------------- 
Time compare (100000 iterations) : lower is better 
slow: 4.719885 
sum: 0.963886 
    fast: 0.343524 

Answer 2

time.clock()

Unter Windows können Sie time.clock() verwenden, die im Grunde QueryPerformanceCounter() von der Windows-API verwendet.

Queryperformancecounter():

Ermittelt den aktuellen Wert des Leistungsindikatoren, der eine hohe Auflösung (< 1 us) Zeitstempel ist, der für die Zeitintervallmessungen verwendet werden kann.

Hier ist eine detaillierte Erklärung für time.clock aus dem Python docs:

auf Unix, kehren die aktuelle Prozessorzeit als eine Gleitkommazahl in Sekunden ausgedrückt. Die Genauigkeit und eigentlich die Definition der Bedeutung von "Prozessorzeit" hängt von der gleichnamigen C-Funktion ab, aber in jedem Fall ist dies die Funktion, die zum Benchmarking von Python- oder Timing-Algorithmen verwendet wird. Unter Windows gibt diese Funktion seit dem ersten Aufruf dieser Funktion verstrichene Wanduhr-Sekunden als Fließkommazahl zurück, basierend auf der Win32-Funktion QueryPerformanceCounter(). Die Auflösung ist typischerweise besser als eine Mikrosekunde.

timeit

Wenn Sie etwas noch genauer braucht, ist da timeit. Diese Antwort erklärt die Vorteile von timeit: https://stackoverflow.com/a/17579466/2394967