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

975

Ich habe ein Befehlszeilenprogramm in Python, dessen Fertigstellung eine Weile dauert. Ich möchte genau wissen, wie lange es dauert, bis der Lauf beendet ist.

Ich habe mir das timeitModul angesehen, aber es scheint nur für kleine Codeausschnitte zu sein. Ich möchte das ganze Programm zeitlich festlegen.

john2x
quelle

Antworten:

1719

Der einfachste Weg in Python:

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

Dies setzt voraus, dass die Ausführung Ihres Programms mindestens eine Zehntelsekunde dauert.

Drucke:

--- 0.764891862869 seconds ---
rogeriopvl
quelle
58
Dies berechnet jedoch die Echtzeit (einschließlich der von anderen Programmen verwendeten Zeit), sodass es anscheinend länger
dauert,
35
Gehen Sie unter Windows genauso vor, verwenden Sie jedoch time.clock () anstelle von time.time (). Sie erhalten eine etwas bessere Genauigkeit.
Corey Goldberg
33
Ich empfehle round(time.time() - start_time, 2)(oder was auch immer Sie wollen), ich habe wissenschaftliche Zahlen wie 1.24e-5 zurückbekommen.
ThorSummoner
16
@ThorSummoner: Du willst wahrscheinlich '%.2f'statt round()hier.
JFS
10
Diese Methode weist einen großen Fehler auf. Wenn sich die Systemzeit ändert, während das Programm ausgeführt wird (wie die Synchronisierung mit dem Zeitserver), funktioniert diese Methode nicht oder kann sogar den Code beschädigen (negative Dauer ...)
Gilad
210

Ich lege dieses timing.pyModul in mein eigenes site-packagesVerzeichnis und füge es einfach import timingoben in mein 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.logaus meinem Programm heraus anrufen , wenn das Programm wichtige Phasen enthält, die ich anzeigen möchte. Durch einfaches Einschließen import timingwerden jedoch die Start- und Endzeiten sowie die insgesamt verstrichene Zeit gedruckt. (Verzeihen Sie meine obskure secondsToStrFunktion, sie formatiert nur eine Gleitkommazahl von Sekunden in das Formular hh: mm: ss.sss.)

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

PaulMcG
quelle
8
Dies ist eine wirklich saubere Lösung, die auch funktioniert, wenn Sie Strg-C drücken, um das Programm zu stoppen.
Sorin
Tolle Lösung Ich werde es auf jeden Fall verwenden und einen Timing-Dekorator erstellen, um Engpassfunktionen zu identifizieren
c24b
9
Fügen Sie für Python 3 from functools import reduceoben hinzu und setzen Sie Klammern um jede print-Anweisung. Funktioniert super!
PowerApp101
2
@ PowerApp101 - Danke - Nicojos Antwort enthält eine Py3-freundliche Version dieses Moduls.
PaulMcG
4
Hinweis: time.clock () ist "Veraltet seit Version 3.3: Das Verhalten dieser Funktion hängt von der Plattform ab: Verwenden Sie stattdessen perf_counter () [mit Zeitschlaf] oder process_time () [ohne Schlafzeit], je nach Ihren Anforderungen ein klar definiertes Verhalten haben. "
Mab
175

Unter Linux oder Unix:

$ time python yourprogram.py

In Windows finden Sie diese StackOverflow-Frage: Wie messe ich die Ausführungszeit eines Befehls in der Windows-Befehlszeile?

Für eine ausführlichere Ausgabe,

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    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): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    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
steveha
quelle
Wenn ich also ein anderes Widget starte, Beispiel in einer QT-Anwendung, wie berechnen wir die Zeit, die dieses Widget benötigt, um angezeigt zu werden?
Ciasto Piekarz
1
Verwenden Sie für den Widget-Fall, wenn Sie von einem Python-Programm aus starten, die akzeptierte Antwort von rogeriopvl.
Steveha
aber das scheint keine Zeit in min: Sekunden zu geben, es endet eine schwebende Zahl !!
Ciasto piekarz
3
Ja, es gibt einige Sekunden. Sie können in min: Sekunden konvertieren, wenn Sie möchten. Schauen Sie sich Paul McGuires Antwort und ihre secondsToStr()Funktion an.
Steveha
68

Ich mag die Antwort von Paul McGuire sehr , aber ich verwende Python 3. Also für diejenigen, die interessiert sind: Hier ist eine Modifikation seiner Antwort, die mit Python 3 auf * nix funktioniert (ich stelle mir vor, unter Windows clock()sollte diese anstelle von verwendet werden time()):

#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 nützlich finden, sollten Sie seine Antwort anstelle dieser Antwort noch abstimmen, da er den größten Teil der Arbeit erledigt hat;).

Nicojo
quelle
1
Ich fand timedelta(seconds=t).total_seconds()hilfreich.
Nu Everest
Können Sie erklären, was diese Funktionen bewirken? Was ist s im Protokollbefehl? Was ist Atexit?
SumNeuron
@SumNeuron, kurz gesagt, diese Funktionen drucken die Ausführungszeit des Programms aus, mit dem Sie es verwenden. s ist das erste zu protokollierende Argument und sollte eine Zeichenfolge sein. log ist eine Funktion, die die Timing-Informationen ausgibt. atexit ist ein Python-Modul, mit dem Sie Funktionen registrieren können, die beim Beenden des Programms aufgerufen werden sollen.
Nicojo
@ Nicojo Sehr hilfreich. Ich habe eine Frage, wie ich diesen Code verwenden kann, um zum Beispiel die Zeit für eine Schleifenausführung zu testen. Angenommen, ich habe eine Funktion, die eine Schleife enthält, und ich möchte die Zeit erhalten, die diese Schleife
verbringt
@moudi Die beste Antwort auf diese Frage ist Ihre beste Wahl. Stellen Sie einfach die Startzeit direkt vor dem Loop ein und berechnen Sie die verstrichene Zeit am Ausgang des Loops.
Nicojo
67
import time

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

time.clock()Gibt die Prozessorzeit zurück, mit der wir nur die von diesem Prozess verwendete Zeit berechnen können (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 werden soll."

newacct
quelle
14
time.time () wird am besten unter * nix verwendet. time.clock () wird am besten unter Windows verwendet.
Corey Goldberg
Ich glaube, dies kann nicht verwendet werden, um "nur die von diesem Prozess verwendete Zeit" zu berechnen, da es die Systemzeit verwendet und von anderen Systemprozessen beeinflusst wird. Korrigieren Sie mich, wenn ich falsch
liege
6
Hinweis: time.clock () ist "Veraltet seit Version 3.3: Das Verhalten dieser Funktion hängt von der Plattform ab: Verwenden Sie stattdessen perf_counter () [mit Zeitschlaf] oder process_time () [ohne Schlafzeit], je nach Ihren Anforderungen ein klar definiertes Verhalten haben. "
Mab
55

Ich mag die Ausgabe des datetimeModuls, bei der Zeitdelta-Objekte Tage, Stunden, Minuten usw. nach Bedarf auf 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

Wie JF Sebastian erwähnte, kann dieser Ansatz mit der Ortszeit auf einige schwierige Fälle stoßen, daher ist es sicherer, Folgendes zu verwenden:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Metakermit
quelle
1
@phansen: Sie könnten timedelta(seconds=time.monotonic()-start)hier verwenden (oder time.time()wenn das Intervall groß ist). Subtrahieren Sie keine naiven Datums- / Uhrzeitobjekte, die die Ortszeit darstellen. Ortszeit ist nicht eintönig
jfs
OK, du meinst wie start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time). Ich vertraue darauf, dass Sie Recht haben, aber dann müssen Sie es auch formatieren, wenn Sie zurückkommen datetime.timedelta(0, 0, 76). Außerdem scheint die monotone Methode nur in Python 3 hinzugefügt worden zu sein.
Metakermit
Ah, OK. Ich sehe, Sie können es weitergeben str(), um es "menschlich" zu machen. Ich werde die Antwort aktualisieren, danke.
Metakermit
53

Sie können den Python-Profiler cProfile verwenden, um die CPU-Zeit zu messen und zusätzlich, wie viel Zeit in jeder Funktion verbracht 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 anfangen sollen. Diese Antwort auf eine andere Frage zum Stapelüberlauf ist ziemlich gut. Es ist immer gut, auch in der Dokumentation nachzuschauen.

Hier ist ein Beispiel für das Profilieren eines Skripts mit cProfile über eine Befehlszeile:

$ 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}
Jacwah
quelle
@jacwah Wie summierst du die Gesamtzeit?
Chuck
@ Chuck Die erste Zeile sagt X function calls in Y CPU seconds. Wenn Sie eine Wanduhrzeit wünschen, verwenden Sie hier eine der anderen Antworten.
Jacwah
28

Noch besser für Linux: time

$ 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
u0b34a0f6ae
quelle
18

Zeit Uhr()

Veraltet seit Version 3.3: Das Verhalten dieser Funktion hängt von der Plattform ab: Verwenden Sie stattdessen perf_counter () oder process_time () , um je nach Ihren Anforderungen ein genau definiertes Verhalten zu erzielen .

time.perf_counter ()

Gibt den Wert (in Sekundenbruchteilen) eines Leistungsindikators zurück, dh eine Uhr mit der höchsten verfügbaren Auflösung, um eine kurze Dauer zu messen. Es enthält die im Schlaf verstrichene Zeit und ist systemweit.

time.process_time ()

Gibt den Wert (in Bruchteilen von Sekunden) der Summe der System- und Benutzer-CPU-Zeit des aktuellen Prozesses zurück. Die im Schlaf verstrichene Zeit ist nicht enthalten.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Ja
quelle
1
Beginnen Sie vielleicht mit der Schlussfolgerung "Use time.process_time ()" (oder ähnlich)?
Peter Mortensen
17

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

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

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

Es kehrt in Sekunden zurück und Sie können Ihre Ausführungszeit haben. Es ist einfach, aber Sie sollten diese in die Hauptfunktion schreiben, die die Programmausführung startet. Wenn Sie die Ausführungszeit auch dann erhalten möchten, wenn Sie einen Fehler erhalten, nehmen Sie Ihren Parameter "Start" und berechnen Sie dort wie folgt:

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + str(execution_time))
Ravi Kumar
quelle
Sollte das nicht Teil für finallyTeil sein?
Alper
12

Das folgende Snippet druckt die verstrichene Zeit in einem für Menschen 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)    
Sandeep
quelle
1
Den ganzen Weg hier unten findet man die vernünftigste Antwort ("vernünftig" bedeutet, sich so weit wie möglich auf eingebaute Elemente zu verlassen und daher am wenigsten zu tippen).
Ijoseph
8
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)
Qina Yan
quelle
8

In IPython "timeit" jedes Skript:

def foo():
    %run bar.py
timeit foo()
B.Kocis
quelle
8

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

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

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

Informationen zum Emulieren /usr/bin/timein Python finden Sie unter Python-Unterprozess mit / usr / bin / time: Wie werden Timing-Informationen erfasst, aber alle anderen Ausgaben ignoriert? .

Um die CPU-Zeit time.sleep()für jede Funktion zu messen (z. B. keine Zeit während ), können Sie das folgende profileModul verwenden ( cProfileunter Python 2):

$ python3 -mprofile your_module.py

Sie können an -pden timeitobigen Befehl übergeben, wenn Sie denselben Timer profileverwenden möchten, den das Modul verwendet.

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

jfs
quelle
7

Ich mochte auch die Antwort von Paul McGuire und fand ein Kontextmanager-Formular, das meinen Bedürfnissen besser entsprach.

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))
Galle
quelle
7

Für die Datenleute, die Jupyter Notebook verwenden

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

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

Ausgabe

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

Dadurch wird nur die Ausführungszeit einer bestimmten Zelle erfasst. Wenn Sie die Ausführungszeit des gesamten Notizbuchs (dh 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 obige Notizbuch 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 (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.
Matt
quelle
5

Es gibt ein timeitModul, mit dem die Ausführungszeiten von Python-Code zeitlich festgelegt werden können.

Es enthält eine detaillierte Dokumentation und Beispiele in der Python-Dokumentation, 26.6. timeit - Misst die Ausführungszeit kleiner Codefragmente .

Alfie
quelle
OP erwähnt ausdrücklich timeitin der Frage. Die Frage ist, wie es hier verwendet werden kann (oder sollte es hier verwendet werden und welche Alternativen es gibt). Hier ist eine mögliche Antwort .
JFS
5

Verwenden Sie line_profiler .

line_profiler gibt die Zeit an, die einzelne Codezeilen für die Ausführung benötigen. Der Profiler wird in C über Cython implementiert , um den Aufwand für die Profilerstellung zu verringern.

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))]
Yu Jiaao
quelle
5

Ich habe eine sehr einfache Funktion verwendet, um einen Teil der Codeausführung zeitlich zu steuern:

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 Code auf, um zu messen, um das Funktions-Timing abzurufen, und rufen Sie dann die Funktion nach dem Code mit Kommentaren auf. Die Uhrzeit 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 folgendermaßen aus:

[9.35s] Loaded 1458644 rows data from 'train'
Tao Wang
quelle
5

Ich hatte an vielen Stellen das gleiche Problem, deshalb habe ich ein Convenience-Paket erstellt horology. Sie können es mit installieren pip install horologyund dann auf elegante Weise ausführen:

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

wird ausgegeben:

Important calculations: 12.43 ms

Oder noch einfacher (wenn Sie eine Funktion haben):

from horology import timed

@timed
def main():
    ...

wird ausgegeben:

main: 7.12 h

Es kümmert sich um Einheiten und Rundungen. Es funktioniert mit Python 3.6 oder neuer.

Hans
quelle
@ DarrenZou überprüfen Sie mehr Dokumente und Quellen hier
hans
Kann ich diese Werte in einer Variablen erhalten?
PepeElMago33
Ja, benutze main.interval.
Hans
3

Dies ist Paul McGuires Antwort , die für mich funktioniert. Nur für den Fall, dass jemand Probleme hat, diesen zu betreiben.

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 timing.main()Sie nach dem Importieren der Datei Ihr Programm auf.

Saurabh Rana
quelle
3

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

Default_timer ist eine Methode in dieser Klasse, mit der das Timing der Wanduhr und nicht die Ausführungszeit der CPU gemessen 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)
Utkarsh Dhawan
quelle
timeitist die bessere Antwort IMO für viele Fälle.
Marc
3

Spätere Antwort, aber ich benutze timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

  • Wickeln Sie Ihren gesamten Code, einschließlich etwaiger Importe, darin ein code_to_test.
  • number Argument gibt an, wie oft der Code wiederholt werden soll.
  • Demo
CONvid19
quelle
Und was ist, wenn Sie einen Abschnitt des Codes zeitlich festlegen möchten, der nicht in eine Zeichenfolge eingefügt werden kann?
Daniel Stracaboško
@ Daniel Sie können eine neue Frage erstellen. Wenn Sie den Link hier posten, kann ich Ihnen möglicherweise helfen.
CONvid19
2

Die Zeit der Ausführungsmaßnahme 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 "Reihenfolge des Wachstums" zu verwenden und die große "O" -Notation zu lernen , um dies richtig zu tun.

Auf jeden Fall können Sie versuchen, die Leistung eines Python-Programms in bestimmten Maschinenzählschritten pro Sekunde mithilfe dieses einfachen Algorithmus zu bewerten : Passen Sie dies an das Programm an, das Sie bewerten möchten

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
Manu
quelle
2

Sie tun dies einfach in Python. Es ist nicht nötig, es kompliziert zu machen.

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)
Mitul Panchal
quelle
2

Ähnlich wie bei der Antwort von @rogeriopvl habe ich eine geringfügige Änderung hinzugefügt, um mit derselben Bibliothek für lange laufende Jobs in Stunden-Minuten-Sekunden zu konvertieren.

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Beispielausgabe

Time Taken: 00:00:08
Benutzer 923227
quelle
2

Installieren Sie zunächst ein menschenfreundliches Paket, indem Sie die Eingabeaufforderung (CMD) als Administrator öffnen und dort Folgendes eingeben : pip install humanfriendly

Code:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Ausgabe:

Geben Sie hier die Bildbeschreibung ein

Amar Kumar
quelle
1

Um die aktualisierte Antwort von metakermit für Python 2.7 verwenden zu können, benötigen Sie die monotone Paket.

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))
H0R5E
quelle
1

Ich habe versucht, Zeitunterschied mit den folgenden Skripten zu finden.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")
Hafez Ahmad
quelle
0

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 - es ist Python 3-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 ==> erstes zu protokollierendes Argument und seine Zeichenfolge zum Markieren des Timings.

atexit ==> Python-Modul zum Registrieren von Funktionen, die Sie beim Beenden des Programms aufrufen können.

Rui Carvalho
quelle