Измерение прошедшего времени с помощью модуля Time


337

С помощью модуля времени в Python можно измерить прошедшее время? Если так, то как мне это сделать?

Мне нужно сделать это так, чтобы, если курсор находился в виджете в течение определенной продолжительности, происходило событие.


3
Обратите внимание, что любой ответ, используемый time.time()неверно. Простейший пример - изменение системного времени в течение периода измерения.
OrangeDog

Что касается вашего первоначального вопроса, касающегося запуска события, если на виджете в течение некоторого времени остается курсор, docs.python.org/3/library/threading.html предоставляет все, что вам нужно, я думаю. Многопоточность и условная переменная с таймаутом могут быть одним из решений. Ваши обстоятельства, однако, в настоящее время неясно, чтобы ответить.
Тора

2
Нет никаких причин, по которым кто-либо должен был time.time()бы измерять прошедшее время в современном питоне (на него влияют ручные изменения, дрейф, дополнительные секунды и т. Д.). Этот ответ ниже должен быть выше, учитывая, что этот вопрос теперь является лучшим результатом в Google для измерения прошедшего времени.
NPras

Вы также можете измерить время с помощью профилировщика cProfile: docs.python.org/3/library/profile.html#module-cProfile stackoverflow.com/questions/582336/…
Антон Тарасенко

1
@NPras забыть "современный питон". Это всегда было неправильно использовать time.time().
OrangeDog

Ответы:


514
start_time = time.time()
# your code
elapsed_time = time.time() - start_time

Вы также можете написать простой декоратор, чтобы упростить измерение времени выполнения различных функций:

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__name__ not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

Использование:

@profile
def your_function(...):
    ...

Вы можете профилировать более одной функции одновременно. Затем для печати измерений просто вызовите print_prof_data ():


11
Вы также можете посмотреть на profilehooks pip install profilehooks и его домашнюю страницу здесь
pjama

11
Обратите внимание, что начиная с Python 3.3, вероятно, следует использовать, time.monotonic()а не time.time()при измерении времени ожидания или продолжительности. docs.python.org/3/library/time.html#time.monotonic
Дебильски

39
Здесь стоит добавить / отметить, что единица измерения за прошедшее время будет секундами.
Эрик Крамер

4
@EricKramer спасибо! Огромный мой любимый человек, объясняющий измерения без определения единицы измерения. И как парень .NET, впервые погружающий свои пальцы в Python, я автоматически подумал «миллисекунды».
Адам Плохер

2
Не работает, если (например) системные часы изменены, и может не иметь субсекундного разрешения. Правильный ответ: stackoverflow.com/a/47637891/476716
OrangeDog

97

time.time() сделаю работу.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

Возможно, вы захотите взглянуть на этот вопрос, но я не думаю, что это будет необходимо.


6
Да, время в секундах
Эрик Крамер

Вы должны изменить начало на start_time.
Зоран Пандовски

time.time()это плохая идея, потому что системные часы могут быть сброшены, что заставит вас вернуться во времени. time.monotonic()заботится об этом (монотонно = это только идет вперед). time.perf_counter()также монотонен, но имеет еще более высокую точность, так что это рекомендуется для настенных часов.
xjcl

76

Для пользователей, которые хотят лучшего форматирования,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

распечатает, в течение 2 секунд:

'00:00:02'

и на 7 минут одну секунду:

'00:07:01'

обратите внимание, что минимальная единица времени с gmtime - секунды. Если вам нужны микросекунды, учтите следующее:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

документация strftime


1
Спасибо за ваш ответ, который вдохновляет меня. Я собираюсь использовать e = time.time() - start_time ; print("%02d:%02d:%02d" % (e // 3600, (e % 3600 // 60), (e % 60 // 1)))эту доходность почти так же, как и при освещении ситуации, которая длится более 24 часов.
Тора

@Tora, вы можете захотеть проверить "{}". Format () вместо% 02d для будущих проблем совместимости.
Рутгер Хофсте

2
Спасибо! Теперь я привыкаю к ​​новому. '{: 02d}: {: 02d}: {: 02d}'. Формат (e // 3600, (e% 3600 // 60), e% 60)
Тора

вы можете использовать time.monotonic()как в других ответах?
эндолиты

elapsed.secondsбудет неправильным, если продолжительность больше одного дня. Хочешь elapsed.total_seconds()быть бодрым
Эш Берлин-Тейлор

51

Для лучшей оценки прошедшего времени (начиная с Python 3.3) используйте time.perf_counter().

Возвращает значение (в долях секунды) счетчика производительности, то есть часов с наибольшим доступным разрешением для измерения короткой длительности. Он включает время, прошедшее во время сна, и является общесистемным. Контрольная точка возвращаемого значения не определена, поэтому допустима только разница между результатами последовательных вызовов.

Для измерений порядка часов / дней вам не нужно разрешение до секунды, поэтому используйте time.monotonic()вместо этого.

Возвращает значение (в долях секунды) монотонных часов, то есть часов, которые не могут двигаться назад. На часы не влияют обновления системных часов. Контрольная точка возвращаемого значения не определена, поэтому допустима только разница между результатами последовательных вызовов.

Во многих реализациях это может быть одно и то же.

До 3.3 вы застряли time.clock().

В Unix верните текущее время процессора в виде числа с плавающей запятой, выраженного в секундах. Точность, и фактически само определение значения «процессорного времени», зависит от точности функции C с тем же именем.

В Windows эта функция возвращает настенные часы, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой на основе функции Win32 QueryPerformanceCounter (). Разрешение обычно лучше, чем одна микросекунда.


Обновление для Python 3.7

Новым в Python 3.7 является PEP 564. Добавлены новые функции времени с наносекундным разрешением.

Их использование может дополнительно устранить ошибки округления и с плавающей запятой, особенно если вы измеряете очень короткие периоды или ваше приложение (или машина Windows) работает долго.

Разрешение начинает ухудшаться perf_counter()примерно через 100 дней. Так, например, после года безотказной работы самый короткий интервал (больше 0), который он может измерить, будет больше, чем когда он начался.


Обновление для Python 3.8

time.clock сейчас нет.


«Во многих реализациях это может быть одно и то же». Правда, на моем компьютере Linux Mint time.monotonic () и time.perf_counter (), похоже, возвращают одинаковые значения.
xjcl

7

Для более длительного периода.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

будет печатать

00:03:15

если более 24 часов

25:33:57

Это вдохновлено ответом Рутгера Хофсте. Спасибо Рутгер!


6

Вам нужно импортировать время, а затем использовать метод time.time (), чтобы узнать текущее время.

import time

start_time=time.time() #taking current time as starting time

#here your code

elapsed_time=time.time()-start_time #again taking current time - starting time 

3

Еще один хороший способ рассчитать время - использовать с python.

со структурой автоматически вызывает __enter__ и __exit__ методы , которые именно то , что нам нужно время вещей.

Давайте создадим класс Timer .

from time import time

class Timer():
    def __init__(self, message):
        self.message = message
    def __enter__(self):
        self.start = time()
        return None  # could return anything, to be used like this: with Timer("Message") as value:
    def __exit__(self, type, value, traceback):
        elapsed_time = (time() - self.start) * 1000
        print(self.message.format(elapsed_time))

Затем можно использовать класс Timer следующим образом:

with Timer("Elapsed time to compute some prime numbers: {}ms"):
    primes = []
    for x in range(2, 500):
        if not any(x % p == 0 for p in primes):
            primes.append(x)
    print("Primes: {}".format(primes))

Результат следующий:

Простые числа: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227 , 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 , 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

Прошедшее время для вычисления некоторых простых чисел: 5.01704216003418ms


2

Ответ Вадима Шендера великолепен. Вы также можете использовать более простой декоратор, как показано ниже:

import datetime
def calc_timing(original_function):                            
    def new_function(*args,**kwargs):                        
        start = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        elapsed = datetime.datetime.now()                      
        print("Elapsed Time = {0}".format(elapsed-start))     
        return x                                             
    return new_function()  

@calc_timing
def a_func(*variables):
    print("do something big!")

1

В программировании есть 2 основных способа измерения времени с разными результатами:

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit
  • Время процессора . Это время, которое этот конкретный процесс активно выполняет на процессоре. Сон, ожидание веб-запроса или время, когда выполняются только другие процессы, не будут этому способствовать.

    • использование time.process_time()
  • Время настенных часов : это относится к тому, сколько времени прошло «на часах, висящих на стене», то есть вне реального времени.

    • использование time.perf_counter()

      • time.time() также измеряет время настенных часов, но может быть сброшено, чтобы вы могли вернуться во времени
      • time.monotonic() не может быть сброшен (монотонный = только вперед), но имеет меньшую точность, чем time.perf_counter()

0

Вот обновление умного кода Вадима Шендера с табличным выводом:

import collections
import time
from functools import wraps

PROF_DATA = collections.defaultdict(list)

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()
        ret = fn(*args, **kwargs)
        elapsed_time = time.time() - start_time
        PROF_DATA[fn.__name__].append(elapsed_time)
        return ret
    return with_profiling

Metrics = collections.namedtuple("Metrics", "sum_time num_calls min_time max_time avg_time fname")

def print_profile_data():
    results = []
    for fname, elapsed_times in PROF_DATA.items():
        num_calls = len(elapsed_times)
        min_time = min(elapsed_times)
        max_time = max(elapsed_times)
        sum_time = sum(elapsed_times)
        avg_time = sum_time / num_calls
        metrics = Metrics(sum_time, num_calls, min_time, max_time, avg_time, fname)
        results.append(metrics)
    total_time = sum([m.sum_time for m in results])
    print("\t".join(["Percent", "Sum", "Calls", "Min", "Max", "Mean", "Function"]))
    for m in sorted(results, reverse=True):
        print("%.1f\t%.3f\t%d\t%.3f\t%.3f\t%.3f\t%s" % (100 * m.sum_time / total_time, m.sum_time, m.num_calls, m.min_time, m.max_time, m.avg_time, m.fname))
    print("%.3f Total Time" % total_time)
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.