Obter pulsos do timer em Python

Question

Eu estou apenas tentando vez que um pedaço de código. Os olhares pseudocódigo como:

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

Como é que este olhar em Python?

Mais especificamente, como faço para obter o número de tiques desde a meia-noite (ou no entanto Python organiza que o timing)?

Answer 1

No módulo time, existem duas funções de temporização: time e clock. time lhe dá tempo "parede", se é isso que você se preocupa.

No entanto, o python docs dizer que clock deve ser utilizado para aferir. Note-se que clock se comporta diferente em sistemas separados:

• em MS Windows, ele usa a função QueryPerformanceCounter Win32 (), com "resolução normalmente melhor do que um microssegundo". Não tem nenhum significado especial, é apenas um número (que começa a contar a primeira vez que você chamar clock em seu processo).

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

• no * nix, clock relata tempo de CPU. Agora, isso é diferente, e muito provavelmente o valor que quiser, desde que seu programa quase nunca é o único processo solicitando tempo de CPU (mesmo se você não tem outros processos, o kernel usa tempo de CPU agora e então). Assim, este número, que normalmente é smaller¹ do que o tempo de parede (ou seja time.time () - t0), é mais significativo quando aferição código:

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

Além de tudo isso, o timeit módulo tem a classe Timer que é deveria usar o que é melhor para aferir da funcionalidade disponível.

¹ menos rosca fica no caminho ...

² Python =3.3: há time.perf_counter() e time.process_time() . perf_counter está sendo usado pelo módulo timeit.

Answer 2

O que você precisa é função time() do módulo time:

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

Você pode usar timeit módulo para mais opções embora.

Answer 3

Aqui está uma solução que eu comecei a usar recentemente:

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

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

Você usá-lo como este (Você precisa de pelo menos Python 2.5):

with Timer():
    do_long_code()

Quando seus acabamentos de código, Temporizador imprime automaticamente o tempo de execução. Doce! Se eu estou tentando banco rapidamente algo no Python Interpreter, esta é a maneira mais fácil de ir.

E aqui está um exemplo de implementação de 'agora' e 'format_delta', apesar de sentir-se livre para usar seu tempo preferido e método de formatação.

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, deixe-me saber se você tem um método de formatação preferido, ou se há uma maneira mais fácil de fazer tudo isso!

Answer 4

O tempo módulo em python dá acesso ao relógio () função, que retorna o tempo em segundos como um ponto flutuante.

Diferentes sistemas terão precisão diferente com base na sua configuração de relógio interno (carrapatos por segundo), mas é geralmente pelo menos sob 20milliseconds e, em alguns casos, melhor do que alguns microssegundos.

-Adam

Answer 5

import datetime

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

A partir da meia-noite:

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

Se você tem muitas declarações que você deseja tempo, você poderia usar algo como isto:

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

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

Em seguida, o código poderia ser semelhante a:

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())

Dessa forma, você não precisa digitar t = time() antes de cada bloco e 1000 * (time() - t) depois, enquanto ainda mantém o controle sobre a formatação (embora você poderia facilmente colocar isso em Ticket também).

É um ganho mínimo, mas eu acho que é tipo de conveniente.