Wie ermittle ich den Zeitpunkt der Ausführung eines Python-Programms?

Question

Ich habe ein Kommandozeilenprogramm in Python, das eine Weile braucht, bis es fertig ist. Ich möchte die genaue Zeit wissen, die es braucht, um die Ausführung zu beenden.

Ich habe mir die timeit Modul, aber es scheint nur für kleine Codeschnipsel geeignet zu sein. Ich möchte die Zeit für das gesamte Programm messen.

Answer 1

Ich habe mir das timeit-Modul angeschaut, aber es scheint nur für kleine Codeschnipsel geeignet zu sein. Ich möchte das gesamte Programm timen.

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

Es läuft your_module.main() und drucken Sie die verstrichene Zeit mit der Funktion time.time() Funktion als Zeitschaltuhr.

Nachahmen /usr/bin/time in Python siehe Python-Subprozess mit /usr/bin/time: Wie kann man Zeitinformationen erfassen, aber alle anderen Ausgaben ignorieren? .

Zur Messung der CPU-Zeit (z. B. ohne Berücksichtigung der Zeit während time.sleep() ) für jede Funktion zu verwenden, könnten Sie profile Modul ( cProfile auf Python 2):

$ python3 -mprofile your_module.py

Sie könnten die -p a timeit wenn Sie denselben Timer verwenden wollen wie profile Modul verwendet.

Siehe Wie kann man ein Python-Skript profilieren?

Answer 2

Ich hatte das gleiche Problem an vielen Stellen, also habe ich ein Komfortpaket erstellt horology . Sie können es installieren mit pip install horology und dann auf elegante Art und Weise zu tun:

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.

Answer 3

Ich mochte Paul McGuire's Antwort Ich habe auch ein Formular für den Kontextmanager entwickelt, das meinen Bedürfnissen besser 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))

Answer 4

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

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

Und um sie zu verwenden, rufen Sie sie einfach vor dem zu messenden Code auf, um das Timing der Funktion abzurufen, und rufen Sie dann 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 wie folgt aus:

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

Answer 5

Utilisez Linien-Profiler .

line_profiler erstellt ein Profil der Zeit, die einzelne Codezeilen zur Ausführung benötigen. Der Profiler ist in C implementiert über Cython um den Overhead der 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))]