it-swarm.com.de

Wie bekomme ich Zeit für die Ausführung eines Python-Programms?

Ich habe ein Befehlszeilenprogramm in Python, das eine Weile dauert, bis es fertig ist. Ich möchte wissen, wie lange es dauert, bis der Lauf abgeschlossen ist.

Ich habe mir das timeit-Modul angesehen, aber es scheint nur für kleine Codeausschnitte zu sein. Ich möchte das ganze Programm mal aufnehmen.

697
john2x

Der einfachste Weg in Python:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

Dies setzt voraus, dass Ihr Programm mindestens zehn Sekunden dauert.

Drucke:

--- 0.764891862869 seconds ---
1222
rogeriopvl

Ich lege dieses timing.py-Modul in mein eigenes site-packages-Verzeichnis und füge einfach import timing oben in meinem Modul ein:

import atexit
from time import clock

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print line
    print secondsToStr(clock()), '-', s
    if elapsed:
        print "Elapsed time:", elapsed
    print line
    print

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

start = clock()
atexit.register(endlog)
log("Start Program")

Ich kann auch timing.log von meinem Programm aus aufrufen, wenn das Programm, das ich anzeigen möchte, wesentliche Schritte enthält. Wenn Sie jedoch nur import timing angeben, werden die Start- und Endzeiten sowie die gesamte verstrichene Zeit gedruckt. (Verzeihen Sie meine obskure secondsToStr-Funktion, sie formatiert lediglich eine Gleitkommazahl von Sekunden in das Format hh: mm: ss.sss.)

Hinweis: Eine Python 3-Version des obigen Codes finden Sie hier oder hier .

183
PaulMcG

In Linux oder UNIX:

time python yourprogram.py

In Windows finden Sie diese Stackoverflow-Diskussion:  Wie misst man die Ausführungszeit des Befehls in der Windows-Befehlszeile?

137
steveha
import time

start_time = time.clock()
main()
print time.clock() - start_time, "seconds"

time.clock() gibt die Prozessorzeit zurück, sodass nur die von diesem Prozess verwendete Zeit berechnet werden kann (unter Unix sowieso). In der Dokumentation heißt es: "In jedem Fall ist dies die Funktion, die zum Benchmarking von Python- oder Timing-Algorithmen verwendet wird".

54
newacct

Ich mag Paul McGuires Antwort sehr, aber ich benutze Python3. Für diejenigen, die daran interessiert sind: Hier ist eine Modifikation seiner Antwort, die mit Python 3 auf * nix funktioniert (ich stelle mir vor, dass unter Windows Uhr () anstelle von Zeit () verwendet werden sollte):

#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta

def secondsToStr(elapsed=None):
    if elapsed is None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    else:
        return str(timedelta(seconds=elapsed))

def log(s, elapsed=None):
    line = "="*40
    print(line)
    print(secondsToStr(), '-', s)
    if elapsed:
        print("Elapsed time:", elapsed)
    print(line)
    print()

def endlog():
    end = time()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

start = time()
atexit.register(endlog)
log("Start Program")

Wenn Sie dies als nützlich erachten, sollten Sie seine Antwort immer noch höher bewerten, da er die meiste Arbeit gemacht hat;).

51
Nicojo

Sie können den Python-Profiler cProfile verwenden, um CPU-Zeit zu messen, und außerdem, wie viel Zeit in jeder Funktion verbraucht wird und wie oft jede Funktion aufgerufen wird. Dies ist sehr nützlich, wenn Sie die Leistung Ihres Skripts verbessern möchten, ohne zu wissen, wo Sie beginnen sollen. Diese Antwort auf eine andere SO Frage ist ziemlich gut. Es ist immer gut, einen Blick in die Dokumente zu werfen.

Hier ein Beispiel, wie Sie ein Skript mit cProfile von einer Befehlszeile aus profilieren:

$ python -m cProfile euler048.py

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}
42
jacwah

Ich mag die Ausgabe, die das datetime-Modul liefert, wobei Zeit-Delta-Objekte Tage, Stunden, Minuten usw. auf eine für Menschen lesbare Weise anzeigen.

Zum Beispiel:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Beispielausgabe, z.

Duration: 0:00:08.309267

oder

Duration: 1 day, 1:51:24.269711

Update: Wie J. F. Sebastian erwähnte, könnte dieser Ansatz auf einige knifflige Fälle mit Ortszeit stoßen.

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
35
metakermit

Noch besser für Linux: /usr/bin/time

$ /usr/bin/time -v python rhtest2.py

    Command being timed: "python rhtest2.py"
    User time (seconds): 4.13
    System time (seconds): 0.07
    Percent of CPU this job got: 91%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 15
    Minor (reclaiming a frame) page faults: 5095
    Voluntary context switches: 27
    Involuntary context switches: 279
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

Normalerweise ist nur time eine einfachere Shell, die den leistungsfähigeren /usr/bin/time abbildet.

23
u0b34a0f6ae

Die Lösung von rogeriopvl funktioniert gut, aber wenn Sie genauere Informationen wünschen, können Sie den in Python integrierten Profiler verwenden. Überprüfen Sie diese Seite:

http://docs.python.org/library/profile.html

ein Profiler gibt Ihnen viele nützliche Informationen, wie zum Beispiel die Zeit, die Sie mit jeder Funktion verbringen

12
wezzy

Das folgende Snippet druckt die abgelaufene Zeit in einem von Nice lesbaren <HH:MM:SS>-Format.

import time
from datetime import timedelta

start_time = time.time()

#
# Perform lots of computations.
#

elapsed_time_secs = time.time() - start_time

msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

print(msg)    
11
Sandeep
from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)
9
Qina Yan

Zeit Uhr()

Veraltet seit Version 3.3: Das Verhalten dieser Funktion hängt von .__ ab. auf der Plattform: Verwenden Sie stattdessenperf_counter ()oderprocess_time () abhängig von Ihren Anforderungen, um ein klares Verhalten zu haben.

time.perf_counter ()

Gibt den Wert (in Sekundenbruchteilen) eines Leistungsindikators zurück eine Uhr mit der höchsten verfügbaren Auflösung zum Messen eines kurzen Dauer. Esmachtwährend des Schlafes verstrichene Zeit und ist systemweit.

time.process_time ()

Liefert den Wert (in Sekundenbruchteilen) der Summe des Systems und Benutzer-CPU-Zeit des aktuellen Prozesses. Esenthält keineverstrichene Zeit Während dem Schlafen.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)
9
Yas

Ipython "timeit" jedes Skript: 

def foo():
    %run bar.py
timeit foo()
7
ab-user

Ich habe mir das Timeit-Modul angesehen, aber es scheint nur für kleine Codeausschnitte zu sein. Ich möchte das ganze Programm mal aufnehmen.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Sie führt die Funktion your_module.main() einmal aus und gibt die verstrichene Zeit mit der Funktion time.time() als Timer aus.

Um /usr/bin/time in Python zu emulieren, siehe Python-Subprozess mit/usr/bin/time: Wie werden Timing-Informationen erfasst, aber alle anderen Ausgaben ignoriert? .

Zum Messen der CPU-Zeit (z. B. keine Zeit während time.sleep()) für jede Funktion können Sie das Modul profile (cProfile auf Python 2) verwenden:

$ python3 -mprofile your_module.py

Sie können -p an den oben genannten timeit-Befehl übergeben, wenn Sie denselben Timer wie das profile-Modul verwenden möchten.

Siehe Wie können Sie ein Python-Skript profilieren?

7
jfs

Verwenden Sie einfach das Modul timeit. Es funktioniert sowohl mit Python 2 als auch mit Python 3

import timeit

start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+execution_time) #It returns time in sec

Es wird in Sekunden zurückgegeben und Sie können Ihre Ausführungszeit festlegen. Einfach, aber Sie sollten diese in Main Function schreiben, die die Programmausführung startet. Wenn Sie die Ausführungszeit auch bei einem Fehler erhalten wollen, dann nehmen Sie Ihren Parameter "Start" dazu und rechnen dort gerne nach 

def sample_function(start,**kwargs):
     try:
         #your statements
     Except:
         #Except Statements
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program Executed in "+execution_time)
6
Ravi Kumar

Ich mag auch die Antwort von Paul McGuire und habe ein Kontextmanager-Formular entwickelt, das meinen Bedürfnissen mehr entspricht.

import datetime as dt
import timeit

class TimingManager(object):
    """Context Manager used with the statement 'with' to time some execution.

    Example:

    with TimingManager() as t:
       # Code to time
    """

    clock = timeit.default_timer

    def __enter__(self):
        """
        """
        self.start = self.clock()
        self.log('\n=> Start Timing: {}')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        """
        self.endlog()

        return False

    def log(self, s, elapsed=None):
        """Log current time and elapsed time if present.
        :param s: Text to display, use '{}' to format the text with
            the current time.
        :param elapsed: Elapsed time to display. Dafault: None, no display.
        """
        print s.format(self._secondsToStr(self.clock()))

        if(elapsed is not None):
            print 'Elapsed time: {}\n'.format(elapsed)

    def endlog(self):
        """Log time for the end of execution with elapsed time.
        """
        self.log('=> End Timing: {}', self.now())

    def now(self):
        """Return current elapsed time as hh:mm:ss string.
        :return: String.
        """
        return str(dt.timedelta(seconds = self.clock() - self.start))

    def _secondsToStr(self, sec):
        """Convert timestamp to h:mm:ss string.
        :param sec: Timestamp.
        """
        return str(dt.datetime.fromtimestamp(sec))
5
Gall

Es gibt ein timeit-Modul, mit dem die Ausführungszeiten von Python-Codes zeitlich festgelegt werden können . Es enthält detaillierte Dokumentation und Beispiele in Python-Dokumenten ( https://docs.python.org/2/library/timeit.html) )

5
Alfie

Verwenden Sie line_profiler .

line_profiler profiliert die Ausführungszeit einzelner Codezeilen. Der Profiler wird über Cython in C implementiert, um den Aufwand für die Profilerstellung zu reduzieren.

from line_profiler import LineProfiler
import random

def do_stuff(numbers):
    s = sum(numbers)
    l = [numbers[i]/43 for i in range(len(numbers))]
    m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()

Die Ergebnisse werden sein:

Timer unit: 1e-06 s

Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           def do_stuff(numbers):
     5         1           10     10.0      1.5      s = sum(numbers)
     6         1          186    186.0     28.7      l = [numbers[i]/43 for i in range(len(numbers))]
     7         1          453    453.0     69.8      m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
4
Yu Jiaao

Für die Datenleute, die Jupyter Notebooks verwenden

In einer Zelle können Sie den %%time magic-Befehl von Jupyter verwenden, um die Ausführungszeit zu messen:

%%time 
[ x**2 for x in range(10000)] 

Ausgabe
CPU-Zeiten: Benutzer 4,54 ms, Sys: 0 ns, Gesamt: 4,54 ms
Wandzeit: 4,12 ms

Dadurch wird nur die Ausführungszeit einer bestimmten Zelle erfasst. Wenn Sie die Ausführungszeit des gesamten Notizbuchs (d. H. Des Programms) erfassen möchten, können Sie ein neues Notizbuch im selben Verzeichnis erstellen und im neuen Notizbuch alle Zellen ausführen:

Angenommen, das Notizbuch oben heißt example_notebook.ipynb. In einem neuen Notizbuch im selben Verzeichnis: 

# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb

# Run the example_notebook with -t flag for time
%run -t example_notebook

Ausgabe
IPython-CPU-Timings (geschätzt): Benutzer: 0,00 s.
System: 0,00 s.
Wandzeit: 0,00 s.

3
Matt

Dies ist Paul McGuires Antwort, die für mich funktioniert. Nur für den Fall, dass jemand Probleme damit hatte. 

import atexit
from time import clock

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print (line)
    print (secondsToStr(clock()), '-', s)
    if elapsed:
        print ("Elapsed time:", elapsed)
    print (line)

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

def main():
    start = clock()
    atexit.register(endlog)
    log("Start Program")

rufen Sie timing.main() aus Ihrem Programm auf, nachdem Sie die Datei importiert haben.

2
Saurabh Rana

Timeit ist eine Klasse in Python, mit der die Ausführungszeit kleiner Codeblöcke berechnet wird. 

Default_timer ist eine Methode in dieser Klasse, die zum Messen des Wandtakts und nicht der CPU-Ausführungszeit verwendet wird. Daher kann eine andere Prozessausführung dies stören. Daher ist es nützlich für kleine Codeblöcke. 

Ein Beispiel für den Code lautet wie folgt:

from timeit import default_timer as timer

start= timer()

#some logic 

end = timer() 

print("Time taken:", end-start) 
2
Utkarsh Dhawan

Ich habe eine sehr einfache Funktion zum Timing eines Teils der Codeausführung verwendet:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

Um es zu verwenden, rufen Sie es einfach vor dem zu messenden Code auf, um die Timing-Funktion abzurufen, und rufen Sie die Funktion nach dem Code mit Kommentaren auf. Die Zeit wird vor den Kommentaren angezeigt, zum Beispiel:

t = timing()
train = pd.read_csv('train.csv',
                        dtype={
                            'id': str,
                            'vendor_id': str,
                            'pickup_datetime': str,
                            'dropoff_datetime': str,
                            'passenger_count': int,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': str,
                            'trip_duration': int,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Loaded {} rows data from 'train'".format(len(train)))

Dann sieht die Ausgabe so aus:

[9.35s] Loaded 1458644 rows data from 'train'

Ich fühle mich auf diese Weise ein bisschen elegant.

1
Tao Wang

Um metakermits aktualisierte Antwort für Python 2.7 zu verwenden, benötigen Sie das Paket monotonic .

Der Code wäre dann wie folgt:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
1
H0R5E

Die Zeit der Ausführung eines Python= Programms kann inkonsistent sein, abhängig von:

  • Das gleiche Programm kann mit verschiedenen Algorithmen ausgewertet werden
  • Die Laufzeit variiert zwischen den Algorithmen
  • Die Laufzeit variiert zwischen den Implementierungen
  • Die Laufzeit variiert zwischen den Computern
  • Die Laufzeit ist aufgrund kleiner Eingaben nicht vorhersehbar

Dies liegt daran, dass der effektivste Weg darin besteht, die "Ordnung des Wachstums" zu verwenden und die große "O" -Notation zu lernen, um dies richtig zu tun. https://en.wikipedia.org/wiki/Big_O_notation

Wie auch immer, Sie können versuchen, die Leistung eines Python) - Programms in bestimmten Schritten pro Sekunde zu berechnen, indem Sie diesen einfachen Algorithmus verwenden: Passen Sie ihn an das gewünschte Programm an bewerten

import time

now = time.time()
future = now + 10
step = 4 # why 4 steps? because until here already 4 operations executed
while time.time() < future:
    step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement
step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

Hoffe das hilft dir.

0
Manu

sie können einen sehr einfachen Weg in Python erhalten, ohne viel kompliziertes machen zu müssen

import time start = time.localtime() end = time.localtime() """Total execution time in second$ """ print(end.tm_sec - start.tm_sec)

0
Mitul Panchal

Wenn Sie die Zeit in Mikrosekunden messen möchten, können Sie die folgende Version verwenden, die vollständig auf den Antworten von Paul McGuire und Nicojo basiert. Dies ist ein Python3-Code. Ich habe auch etwas Farbe hinzugefügt:

import atexit
from time import time
from datetime import timedelta, datetime


def seconds_to_str(elapsed=None):
    if elapsed is None:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    else:
        return str(timedelta(seconds=elapsed))


def log(txt, elapsed=None):
    colour_cyan = '\033[36m'
    colour_reset = '\033[0;0;39m'
    colour_red = '\033[31m'
    print('\n ' + colour_cyan + '  [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
    if elapsed:
        print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)


def end_log():
    end = time()
    elapsed = end-start
    log("End Program", seconds_to_str(elapsed))


start = time()
atexit.register(end_log)
log("Start Program")

log () => Funktion, die die Timing-Informationen ausgibt. 

txt ==> Das erste zu protokollierende Argument und die Zeichenfolge zum Markieren des Timings.

atexit ==> Python-Modul zum Registrieren von Funktionen, die Sie aufrufen können, wenn das Programm beendet wird.

0
Rui Carvalho

Dies ist der einfachste Weg, um die verstrichene Zeit für das Programm abzurufen:

Schreiben Sie den folgenden Code am Ende Ihres Programms.

import time
print(time.clock())
0
Kushal Ghosh