Como tempo da execução de um programa Python?

977

Eu tenho um programa de linha de comando em Python que demora um pouco para terminar. Quero saber o tempo exato que leva para terminar a corrida.

Eu olhei para o timeitmódulo, mas parece que é apenas para pequenos trechos de código. Eu quero cronometrar o programa inteiro.

john2x
fonte

Respostas:

1720

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 ---
rogeriopvl
fonte
58
Isso calcula o tempo real embora (incluindo o tempo usado por outros programas), por isso parece que vai demorar mais tempo quando o computador está ocupado fazendo outras coisas
newacct
35
no Windows, faça o mesmo, mas use time.clock () em vez de time.time (). Você terá uma precisão um pouco melhor.
Corey Goldberg
33
Eu recomendo fazer 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.
ThorSummoner
16
@ ThorSummoner: você provavelmente quer, em '%.2f'vez de round()aqui.
JFS
10
Há uma grande falha neste método. Se a hora do sistema muda enquanto o programa está em execução (como sincronização com servidor de tempo), então este método não vai funcionar ou pode até mesmo quebrar o código (duração negativa ...)
Gilad
210

Coloquei este timing.pymódulo no meu próprio site-packagesdiretório e apenas insira import timingna 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.logde dentro do meu programa se houver etapas significativas dentro do programa que eu queira mostrar. Mas apenas incluir import timingimprimirá os horários de início e término e o tempo decorrido geral. (Perdoe minha secondsToStrfunçã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 .

PaulMcG
fonte
8
Esta é uma solução realmente limpa que também funciona se você pressionar Ctrl-C para interromper o programa.
sorin
grande solução com certeza vou usá-lo e criar um decorador tempo para identificar as funções de estrangulamento
c24b
9
Para o Python 3, adicione from functools import reduceno topo e coloque colchetes em cada declaração de impressão. Funciona bem!
precisa saber é o seguinte
2
@ PowerApp101 - Obrigado - A resposta do Nicojo fornece uma versão compatível com Py3 deste módulo.
PaulMcG
4
Nota: time.clock () é "Descontinuado desde a versão 3.3: O comportamento desta função depende da plataforma: use perf_counter () [com tempo de espera] ou process_time () [sem tempo de espera], dependendo de seus requisitos, para tenha um comportamento bem definido ".
mab
175

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
steveha
fonte
portanto, se estou lançando outro widget, por exemplo, no aplicativo QT, como calculamos o tempo gasto por esse widget para aparecer?
Ciasto piekarz
1
Para o caso do widget, se você estiver iniciando a partir de um programa Python, use a resposta aceita por rogeriopvl.
Steveha
mas isso não parece dar tempo em min: segundos, acaba sendo um número flutuante !!
ciasto Piekarz
3
Sim, fornece alguns segundos. Você pode converter para min: segundos se desejar. Veja a resposta de Paul McGuire e sua secondsToStr()função.
Steveha
68

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;).

Nicojo
fonte
1
Eu achei timedelta(seconds=t).total_seconds()útil.
Nu everest
Você pode explicar o que essas funções fazem? o que está s no comando log? o que é atexit?
SumNeuron
@ SumNeuron, em resumo, essas funções imprimem o tempo de execução do programa com o qual você o usa. s é o primeiro argumento a ser registrado e deve ser uma string. log é uma função que imprime as informações de tempo. atexit é um módulo python que permite registrar funções a serem chamadas na saída do programa.
Nicojo
@ Nicojo Muito útil. Eu tenho uma pergunta sobre como posso usar esse código para testar, por exemplo, o tempo para uma execução de loop. suponha que eu tenho uma função incuding um loop, e eu quero pegar o tempo gasto por este circuito
Moudi
@moudi A melhor resposta para esta pergunta é sua melhor aposta. Basta definir a hora de início imediatamente antes do loop e calcular o tempo decorrido na saída do loop.
Nicojo 14/06/19
67
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"

newacct
fonte
14
time.time () é melhor usado em * nix. time.clock () é melhor usado no Windows.
Corey Goldberg
Eu acredito que isso não pode ser usado para calcular "apenas o tempo usado por esse processo" porque usa a hora do sistema e será afetado por outros processos do sistema? Corrija-me se eu estiver errado sobre isso :)
AnnanFay
6
Nota: time.clock () é "Descontinuado desde a versão 3.3: O comportamento desta função depende da plataforma: use perf_counter () [com tempo de espera] ou process_time () [sem tempo de espera], dependendo de seus requisitos, para tenha um comportamento bem definido ".
mab
55

Gosto da saída que o datetimemó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))
metakermit
fonte
1
@phansen: você pode usar 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
jfs 03/03
OK, você quer dizer 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.
metakermit
Ah ok. Vejo que você pode passá-lo str()para torná-lo "humano". Vou atualizar a resposta, obrigado.
Metakermit 04/03
53

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}
jacwah
fonte
@jacwah Como você soma o tempo total?
Chuck #
@ Chuck A primeira linha diz X function calls in Y CPU seconds. Se você quiser a hora do relógio de parede, use uma das outras respostas aqui.
jacwah
28

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
u0b34a0f6ae
fonte
18

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)
Yas
fonte
1
Talvez comece com a conclusão, "Use time.process_time ()" (ou similar)?
Peter Mortensen
17

Basta usar o timeitmó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))
Ravi Kumar
fonte
Não deveria ser essa parte em finallyparte?
alper
12

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)    
Sandeep
fonte
1
aqui em baixo, encontra-se a resposta mais sã ('sã', ou seja, confiar tanto quanto possível nos built-ins e, portanto, no mínimo digitado).
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
fonte
8

No IPython , "timeit" qualquer script:

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

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/timeno 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 profilemódulo ( cProfileno Python 2):

$ python3 -mprofile your_module.py

Você pode passar -ppara o timeitcomando acima se quiser usar o mesmo timer queprofile módulo usa.

Consulte Como você pode criar um perfil de um script Python?

jfs
fonte
7

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))
Gall
fonte
7

Para o pessoal de dados que usa Jupyter Notebook

Em uma célula, você pode usar o %%timecomando mágico do Jupyter para medir o tempo de execução:

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

Resultado

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

Resultado

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.
Matt
fonte
5

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

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'
Tao Wang
fonte
5

Eu estava tendo o mesmo problema em muitos lugares, então criei um pacote de conveniência horology. Você pode instalá-lo pip install horologye 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.

Hans
fonte
@DarrenZou verifique mais documentos e fontes aqui
hans
Posso obter esses valores em uma variável?
PepeElMago33
Sim, use main.interval.
hans
3

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.

Saurabh Rana
fonte
3

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)
Utkarsh Dhawan
fonte
timeité a melhor resposta da IMO para muitas instâncias.
Marc
3

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

  • Quebre todo o seu código, incluindo todas as importações que você possa ter, dentro code_to_test .
  • number O argumento especifica a quantidade de vezes que o código deve repetir.
  • Demo
CONvid19
fonte
E se você quiser cronometrar alguma seção do código que não possa ser colocada em uma string?
Daniel Stracaboško 22/04
@daniel Você pode criar uma nova pergunta. Se você postar o link aqui, talvez eu possa ajudá-lo.
CONvid19
2

O tempo da medida de execução de um programa Python pode ser inconsistente, dependendo de:

  • O mesmo programa pode ser avaliado usando algoritmos diferentes
  • O tempo de execução varia entre algoritmos
  • O tempo de execução varia entre implementações
  • O tempo de execução varia entre computadores
  • O tempo de execução não é previsível com base em pequenas entradas

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")
Manu
fonte
2

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)
Mitul Panchal
fonte
2

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
usuário 923227
fonte
2

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:

insira a descrição da imagem aqui

Amar Kumar
fonte
1

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

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")
Hafez Ahmad
fonte
0

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.

Rui Carvalho
fonte