Consigue tictac temporizador en Python

Question

Sólo estoy tratando de cronometrar un trozo de código. El pseudocódigo parece:

start = get_ticks()
do_long_code()
print "It took " + (get_ticks() - start) + " seconds."

¿Cómo se ve esto en Python?

Más específicamente, ¿cómo obtengo el número de ticks desde la medianoche (o, sin embargo, Python organiza ese tiempo)?

Answer 1

En el módulo time , hay dos funciones de temporización: time y clock . time te da " muro " tiempo, si esto es lo que te importa.

Sin embargo, los docs de pyth dicen que clock debe ser utilizado para la evaluación comparativa. Tenga en cuenta que clock se comporta de manera diferente en sistemas separados:

• en MS Windows, usa la función Win32 QueryPerformanceCounter (), con una resolución que generalmente es mejor que un microsegundo. No tiene un significado especial, es solo un número (comienza a contar la primera vez que llama a clock en su proceso).

    # ms windows
    t0= time.clock()
    do_something()
    t= time.clock() - t0 # t is wall seconds elapsed (floating point)

• en * nix, clock informa el tiempo de CPU. Ahora, esto es diferente, y muy probablemente el valor que desea, ya que su programa casi nunca es el único proceso que solicita el tiempo de CPU (incluso si no tiene otros procesos, el kernel usa el tiempo de CPU de vez en cuando). Entonces, este número, que generalmente es más pequeño & # 185; que el tiempo en la pared (es decir, time.time () - t0), es más significativo cuando se hace referencia al código:

    # linux
    t0= time.clock()
    do_something()
    t= time.clock() - t0 # t is CPU seconds elapsed (floating point)

Aparte de todo eso, el módulo timeit tiene el temporizador clase que se supone que usa lo mejor para la evaluación comparativa de la funcionalidad disponible.

& # 185; a menos que el subproceso se interponga en la forma & # 8230;

& # 178; Python & # 8805; 3.3: hay time.perf_counter () y time.process_time () . perf_counter está siendo utilizado por el módulo timeit .

Answer 2

Lo que necesita es la función time () del módulo time :

import time
start = time.time()
do_long_code()
print "it took", time.time() - start, "seconds."

Puedes usar el módulo timeit para más opciones, sin embargo.

Answer 3

Aquí hay una solución que comencé a usar recientemente:

class Timer:
    def __enter__(self):
        self.begin = now()

    def __exit__(self, type, value, traceback):
        print(format_delta(self.begin, now()))

Lo usas así (necesitas al menos Python 2.5):

with Timer():
    do_long_code()

Cuando su código termina, el temporizador imprime automáticamente el tiempo de ejecución. ¡Dulce! Si estoy intentando acomodar rápidamente algo en el intérprete de Python, esta es la forma más fácil de hacerlo.

Y aquí hay una implementación de ejemplo de 'ahora' y 'formato_delta', aunque siéntase libre de usar su método preferido de tiempo y formato.

import datetime

def now():
    return datetime.datetime.now()

# Prints one of the following formats*:
# 1.58 days
# 2.98 hours
# 9.28 minutes # Not actually added yet, oops.
# 5.60 seconds
# 790 milliseconds
# *Except I prefer abbreviated formats, so I print d,h,m,s, or ms. 
def format_delta(start,end):

    # Time in microseconds
    one_day = 86400000000
    one_hour = 3600000000
    one_second = 1000000
    one_millisecond = 1000

    delta = end - start

    build_time_us = delta.microseconds + delta.seconds * one_second + delta.days * one_day

    days = 0
    while build_time_us > one_day:
        build_time_us -= one_day
        days += 1

    if days > 0:
        time_str = "%.2fd" % ( days + build_time_us / float(one_day) )
    else:
        hours = 0
        while build_time_us > one_hour:
            build_time_us -= one_hour
            hours += 1
        if hours > 0:
            time_str = "%.2fh" % ( hours + build_time_us / float(one_hour) )
        else:
            seconds = 0
            while build_time_us > one_second:
                build_time_us -= one_second
                seconds += 1
            if seconds > 0:
                time_str = "%.2fs" % ( seconds + build_time_us / float(one_second) )
            else:
                ms = 0
                while build_time_us > one_millisecond:
                    build_time_us -= one_millisecond
                    ms += 1
                time_str = "%.2fms" % ( ms + build_time_us / float(one_millisecond) )
    return time_str

Por favor, avíseme si tiene un método de formato preferido o si hay una forma más fácil de hacer todo esto.

Answer 4

El módulo de tiempo en python le da acceso al reloj () función, que devuelve el tiempo en segundos como punto flotante.

Los diferentes sistemas tendrán una precisión diferente según la configuración del reloj interno (tics por segundo), pero generalmente es de al menos 20 milisegundos, y en algunos casos es mejor que unos pocos microsegundos.

-Adam

Answer 5

import datetime

start = datetime.datetime.now()
do_long_code()
finish = datetime.datetime.now()
delta = finish - start
print delta.seconds

Desde la medianoche:

import datetime

midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
now = datetime.datetime.now()
delta = now - midnight
print delta.seconds

Answer 6

Si tiene muchas afirmaciones que desea programar, podría usar algo como esto:

class Ticker:
    def __init__(self):
        self.t = clock()

    def __call__(self):
        dt = clock() - self.t
        self.t = clock()
        return 1000 * dt

Entonces tu código podría verse como:

tick = Ticker()
# first command
print('first took {}ms'.format(tick())
# second group of commands
print('second took {}ms'.format(tick())
# third group of commands
print('third took {}ms'.format(tick())

De esa manera, no necesita escribir t = time () antes de cada bloque y 1000 * (time () - t) después de él, mientras sigue control sobre el formato (aunque también podría ponerlo fácilmente en Ticket ).

Es una ganancia mínima, pero creo que es algo conveniente.