Respostas:
A maneira mais simples em Python:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
Isso pressupõe que seu programa leva pelo menos um décimo de segundo para ser executado.
Impressões:
--- 0.764891862869 seconds ---
round(time.time() - start_time, 2)
(ou qualquer decimal que você quiser), eu estava recebendo números científicos de volta como 1,24e-5.
'%.2f'
vez de round()
aqui.
Coloquei este timing.py
módulo no meu próprio site-packages
diretório e apenas insira import timing
na parte superior do meu módulo:
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")
Também posso ligar timing.log
de dentro do meu programa se houver etapas significativas dentro do programa que eu queira mostrar. Mas apenas incluir import timing
imprimirá os horários de início e término e o tempo decorrido geral. (Perdoe minha secondsToStr
função obscura , ela apenas formata um número de ponto flutuante de segundos no formato hh: mm: ss.sss.)
Nota: Uma versão Python 3 do código acima pode ser encontrada aqui ou aqui .
from functools import reduce
no topo e coloque colchetes em cada declaração de impressão. Funciona bem!
No Linux ou Unix:
$ time python yourprogram.py
No Windows, consulte esta pergunta do StackOverflow: Como faço para medir o tempo de execução de um comando na linha de comando do Windows?
Para uma saída mais detalhada,
$ 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
secondsToStr()
função.
Eu realmente gosto da resposta de Paul McGuire , mas uso o Python 3. Então, para aqueles que estão interessados: aqui está uma modificação de sua resposta que funciona com o Python 3 no * nix (imagino, no Windows, que clock()
deve ser usado em vez de 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")
Se você achar isso útil, você deve votar novamente a resposta dele em vez desta, como ele fez a maior parte do trabalho;).
timedelta(seconds=t).total_seconds()
útil.
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
time.clock()
retorna o tempo do processador, o que nos permite calcular apenas o tempo usado por esse processo (no Unix de qualquer maneira). A documentação diz "em qualquer caso, esta é a função a ser usada para comparar Python ou algoritmos de tempo"
Gosto da saída que o datetime
módulo fornece, onde objetos de tempo delta mostram dias, horas, minutos etc., conforme necessário, de maneira legível por humanos.
Por exemplo:
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
Saída de amostra, por exemplo
Duration: 0:00:08.309267
ou
Duration: 1 day, 1:51:24.269711
Como JF Sebastian mencionou, essa abordagem pode encontrar alguns casos complicados com a hora local, portanto, é mais seguro usar:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
timedelta(seconds=time.monotonic()-start)
aqui (ou time.time()
se o intervalo for grande). Não subtraia objetos de data e hora ingênuos que representam a hora local; a hora local não é monótona
start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time)
. Confio que você está certo, mas também é necessário formatá-lo quando voltar datetime.timedelta(0, 0, 76)
. Além disso, parece que o método monótona só foi adicionado em Python 3.
str()
para torná-lo "humano". Vou atualizar a resposta, obrigado.
Você pode usar o profiler do Python cProfile para medir o tempo da CPU e, adicionalmente, quanto tempo é gasto dentro de cada função e quantas vezes cada função é chamada. Isso é muito útil se você deseja melhorar o desempenho do seu script sem saber por onde começar. Essa resposta para outra pergunta do Stack Overflow é muito boa. É sempre bom dar uma olhada na documentação também .
Aqui está um exemplo de como criar um perfil de script usando cProfile em uma linha de comando:
$ 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}
X function calls in Y CPU seconds
. Se você quiser a hora do relógio de parede, use uma das outras respostas aqui.
Ainda melhor para 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
Rélogio de ponto()
Descontinuado desde a versão 3.3: O comportamento desta função depende da plataforma: use perf_counter () ou process_time () em vez disso, dependendo de seus requisitos, para ter um comportamento bem definido.
time.perf_counter ()
Retorne o valor (em segundos fracionários) de um contador de desempenho, ou seja, um relógio com a maior resolução disponível para medir uma curta duração. Inclui o tempo decorrido durante o sono e abrange todo o sistema.
time.process_time ()
Retorne o valor (em segundos fracionários) da soma do tempo do sistema e da CPU do usuário do processo atual. Ele não inclui o tempo decorrido durante o sono.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Basta usar o timeit
módulo. Funciona com o Python 2 e o 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
Ele retorna em segundos e você pode ter seu tempo de execução. É simples, mas você deve escrevê-los na função principal que inicia a execução do programa. Se você deseja obter o tempo de execução mesmo quando receber um erro, leve o parâmetro "Iniciar" para ele e calcule como:
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))
finally
parte?
O trecho a seguir imprime o tempo decorrido em um bom <HH:MM:SS>
formato legível por humanos .
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)
Eu olhei para o módulo timeit, mas parece que é apenas para pequenos trechos de código. Eu quero cronometrar o programa inteiro.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
Ele executa a your_module.main()
função uma vez e imprime o tempo decorrido usando a time.time()
função como um temporizador.
Para emular /usr/bin/time
no Python, consulte o subprocesso do Python com / usr / bin / time: como capturar informações de tempo, mas ignorar todas as outras saídas? .
Para medir o tempo da CPU (por exemplo, não inclua o tempo durante time.sleep()
) para cada função, você pode usar o profile
módulo ( cProfile
no Python 2):
$ python3 -mprofile your_module.py
Você pode passar -p
para o timeit
comando acima se quiser usar o mesmo timer queprofile
módulo usa.
Consulte Como você pode criar um perfil de um script Python?
Também gostei da resposta de Paul McGuire e criei um formulário de gerenciamento de contexto que se adequava mais às minhas necessidades.
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))
Em uma célula, você pode usar o %%time
comando mágico do Jupyter para medir o tempo de execução:
%%time
[ x**2 for x in range(10000)]
CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms
Isso capturará apenas o tempo de execução de uma célula específica. Se você deseja capturar o tempo de execução de todo o notebook (ou seja, programa), é possível criar um novo notebook no mesmo diretório e, no novo notebook, executar todas as células:
Suponha que o notebook acima seja chamado example_notebook.ipynb
. Em um novo notebook no mesmo diretório:
# 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
IPython CPU timings (estimated):
User : 0.00 s.
System : 0.00 s.
Wall time: 0.00 s.
Existe um timeit
módulo que pode ser usado para cronometrar os tempos de execução do código Python.
Possui documentação e exemplos detalhados na documentação do Python, 26.6. timeit - Mede o tempo de execução de pequenos trechos de código .
timeit
na pergunta. A questão é como ela pode ser usada aqui (ou deve ser usada aqui e quais são as alternativas). Aqui está a resposta possível .
Use line_profiler .
line_profiler analisará o tempo que as linhas de código individuais levam para serem executadas. O criador de perfil é implementado em C via Cython , a fim de reduzir a sobrecarga da criação de perfil.
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()
Os resultados serão:
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))]
Eu usei uma função muito simples para cronometrar uma parte da execução do código:
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
E, para usá-lo, basta chamá-lo antes do código para medir a recuperação do tempo da função e depois chamar a função após o código com comentários. A hora aparecerá na frente dos comentários. Por exemplo:
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)))
Então a saída ficará assim:
[9.35s] Loaded 1458644 rows data from 'train'
Eu estava tendo o mesmo problema em muitos lugares, então criei um pacote de conveniência horology
. Você pode instalá-lo pip install horology
e fazê-lo da maneira elegante:
from horology import Timing
with Timing(name='Important calculations: '):
prepare()
do_your_stuff()
finish_sth()
irá produzir:
Important calculations: 12.43 ms
Ou ainda mais simples (se você tiver uma função):
from horology import timed
@timed
def main():
...
irá produzir:
main: 7.12 h
Ele cuida de unidades e arredondamentos. Funciona com python 3.6 ou mais recente.
main.interval
.
Esta é a resposta de Paul McGuire que funciona para mim. Apenas no caso de alguém estar tendo problemas para executar esse.
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")
Ligue timing.main()
do seu programa depois de importar o arquivo.
Timeit é uma classe em Python usada para calcular o tempo de execução de pequenos blocos de código.
Default_timer é um método nesta classe que é usado para medir o tempo do relógio de parede, não o tempo de execução da CPU. Portanto, outra execução de processo pode interferir nisso. Portanto, é útil para pequenos blocos de código.
Uma amostra do código é a seguinte:
from timeit import default_timer as timer
start= timer()
# Some logic
end = timer()
print("Time taken:", end-start)
timeit
é a melhor resposta da IMO para muitas instâncias.
Resposta mais tarde, mas eu uso 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
code_to_test
.number
O argumento especifica a quantidade de vezes que o código deve repetir.O tempo da medida de execução de um programa Python pode ser inconsistente, dependendo de:
Isso ocorre porque a maneira mais eficaz é usar a "Ordem de crescimento" e aprender a notação "O" grande para fazê-lo corretamente.
De qualquer forma, você pode tentar avaliar o desempenho de qualquer programa Python em etapas específicas de contagem de máquinas por segundo usando este algoritmo simples: adapte isso ao programa que deseja avaliar
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")
Você faz isso simplesmente em Python. Não há necessidade de complicar.
import time
start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)
Semelhante à resposta do @rogeriopvl, adicionei uma pequena modificação para converter em hora minuto segundos usando a mesma biblioteca para trabalhos de longa execução.
import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))
Saída de amostra
Time Taken: 00:00:08
Primeiro, instale humanamente pacote , abrindo o prompt de comando (CMD) como administrador e digite lá -
pip install humanfriendly
Código:
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))
Resultado:
Para usar a resposta atualizada do metakermit para o Python 2.7, você precisará do código monotônico pacote .
O código seria então o seguinte:
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
Tentei e encontrei a diferença de horário usando os seguintes scripts.
import time
start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")
Se você deseja medir o tempo em microssegundos, pode usar a seguinte versão, baseada completamente nas respostas de Paul McGuire e Nicojo - é o código Python 3. Também adicionei um pouco de cor:
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 () => função que imprime as informações de tempo.
txt ==> primeiro argumento a ser registrado e sua string para marcar o tempo.
atexit ==> módulo Python para registrar funções que você pode chamar quando o programa sair.