Время сколько прошло 3 секунды: Сколько часов прошло | Онлайн калькулятор

Сколько времени прошло с 3 февраля 706 года до сегодняшнего дня

Калькулятор делает расчет: сколько дней, лет, часов, минут или секунд прошло с 03.02.0706 по текущий момент времени.

Сколько прошло с 3 февраля 706 года?

В общем

• 1317 лет
• 1 месяц
• 24 дня
• 23 часа
• 27 минут
• 36 секунд

В целых величинах

• 1317 лет
• 15805 месяцев
• 68725 недель
• 481077 дней
• 11545871 час
• 692752287 минут
• 41565137256 секунд

Часовой пояс: Europe/Berlin

Сегодняшняя дата

27 марта 2023 года

Информация о дне: 3 февраля 706 года

• 3 февраля 706 года — это Суббота (Выходной день)
• Дней в феврале: 28
• 706 — это не Високосный год (365 дней)
• Февраль: пора года — Зима
• Знак зодиака 3 февраля 706 года — Водолей (aquarius)
• Unix Timestamp: -39885177600

Календарь на февраль 706 года

Ближайшие даты

28. 01.0706

29.01.0706

30.01.0706

31.01.0706

01.02.0706

02.02.0706

04.02.0706

05.02.0706

06.02.0706

07.02.0706

08.02.0706

09.02.0706

Все даты 706 года

Другие даты

03.02.0706 — 21.03.2023

03.02.0706 — 22.03.2023

03.02.0706 — 23.03.2023

03.02.0706 — 24.03.2023

03.02.0706 — 25.03.2023

03.02.0706 — 26.03.2023

03.02.0706 — 27.03.2023

03.02.0706 — 28.03.2023

03.02.0706 — 29.03.2023

03. 02.0706 — 30.03.2023

03.02.0706 — 31.03.2023

03.02.0706 — 01.04.2023

Вопросы и ответы

Данный инструмент является калькулятором дат. Он вычисляет количество времени, которое прошло с заданной даты на текущий момент. Результат можно отобразить в разных единицах измерения.

Просто выберите нужную вам дату с помощью календаря и сразу получайте результат!

Рекомендуем посмотреть

Спасибо за обратную связь!

Если потребуется, мы вышлем ответ на указанную почту.

×

Обратная связь

Оставьте сообщение и мы обязательно вам ответим!

Сообщение *

Имя

E-mail *

Я даю согласие на обработку персональных данных в соответствии с политикой конфиденциальности.

Отправить

Поддержите нас!

Мы рады, что вы пользуетесь нашим сервисом!
Чтобы отблагодарить нас за бесплатные инструменты — отключите блокировщик рекламы на сайте или сделайте пожертвование! Это очень поможет развитию наших проектов!
Спасибо 🙂

99₽

99₽

199₽

199₽

499₽

499₽

Любая сумма

Пожертвовать

• Ether: 0x2764e55bbbc6e60fa0678da98aae46635e850bdc
• Bitcoin cash: qzm2pkf9sdzc0lpe39lgh52u2gc52majqcnxc0uz8j

грамотная речь — О единицах времени: «прошли» или «прошло»?

С момента публикации новости прошло (прошли) 9283 секунды.

С одной стороны, «3 секунды прошли», но с другой — с большими числами почему-то лучше (по-моему) звучит «прошло». Говоря о годах, мы обычно используем слово «прошло», кроме случаев, когда хотим подчеркнуть, как долго тянулся каждый год. Применимо ли то же самое к часам, минутам и секундам?

• грамотная-речь
• согласование
• числительные

В реалистичном контексте с такой цифрой речь может идти о времени и его количестве, с акцентом на подразумеваемом «количестве» — с ним по роду и числу согласуется глагол:

С момента публикации новости прошло [количество времени, в секундах выражаемое так:)] 9283 секунды (времени).

Но при специфическом акценте на секундах (которые напр. ранее упоминались как таковые) возможно согласование с «секундами»:

Суд обязал данный сайт разместить опровержение не позже, чем через 9283 секунды с момента публикации. Эти [какие? — те самые, которых было заявлено столько-то] 9283 секунды давно прошли.

Количество секунд влияет на данный выбор не само по себе, а через общий контекст:

Три секунды [каждая — на счету], отведённые на подготовку к выстрелу, уже прошли.

Прошло аж три секунды [это много времени], прежде чем он отреагировал.

В данном случае я бы посоветовал поставить сказуемое в единственном числе:

С момента публикации новости прошло 9283 секунды.

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

А вообще-то выбор числа сказуемого — задача непростая. Подобные вопросы не раз задавались. Вот некоторые ссылки:

Как правильно писать?

Защищено / защищены.

«ГотовО» или «готовЫ»?

А правила изложены здесь

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки

Производительность

.

Как измерить прошедшее время в Python?

Задавать вопрос

спросил 11 лет, 6 месяцев назад

Изменено 12 дней назад

Просмотрено 2,5 млн раз

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

 время импорта
начало = время.время()
распечатать("привет")
конец = время.время()
печать (конец - начало)
 

• питон
• производительность
• мера
• время

3

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

 время импорта
начало = время.время()
распечатать("привет")
конец = время. время()
печать (конец - начало)
 

Время выполнения в секундах.

---

Другим вариантом, начиная с Python 3.3, может быть использование perf_counter или process_time , в зависимости от ваших требований. До версии 3.3 рекомендовалось использовать time.clock (спасибо Amber). Однако в настоящее время он устарел:

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

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

Устарело, начиная с версии 3.3 : поведение этой функции зависит на платформе: используйте perf_counter() или process_time() вместо , в зависимости от ваших требований, чтобы иметь четко определенное поведение.

Использовать timeit.default_timer вместо timeit.timeit . Первый автоматически предоставляет лучшие часы, доступные на вашей платформе и версии Python:

 from timeit import default_timer as timer
старт = таймер()
# ...
конец = таймер()
print(end - start) # Время в секундах, например 5.38091952400282
 

timeit.default_timer назначается для time.time() или time.clock() в зависимости от ОС. В Python 3.3+ default_timer — это time.perf_counter() на всех платформах. См. Python — time.clock () против time.time () — точность?

См. также:

• Код оптимизации
• Как оптимизировать скорость

1

Поскольку time.clock() устарел, начиная с Python 3.3, вам нужно будет использовать time.perf_counter() для общесистемного времени или time.process_time() для времени всего процесса, просто как вы использовали time. clock() :

 время импорта
т = время.процесс_время()
#сделай что-нибудь
прошедшее_время = время.время_процесса() - t
 

Новая функция process_time не будет включать время, прошедшее во время сна.

1

Время измерения в секундах:

 из timeit импортировать default_timer как таймер
из datetime импортировать timedelta
старт = таймер()
# ....
# (здесь работает ваш код)
# ...
конец = таймер()
печать (timedelta (секунды = конец-начало))
 

Выход :

 0:00:01.946339
 

0

Учитывая функцию, которую вы хотите вычислить по времени,

test.py:

 def foo():
    # напечатать "привет"
    верни "привет"
 

Самый простой способ использовать timeit — вызвать его из командной строки:

 % python -mtimeit -s'import test' 'test. foo()'
1000000 циклов, лучшее из 3: 0,254 мкс на цикл
 

Не пытайтесь использовать time.time или time.clock (наивно) для сравнения скорости функций. Они могут дать вводящие в заблуждение результаты.

PS. Не помещайте операторы печати в функцию, которую вы хотите задать по времени; в противном случае измеренное время будет зависеть от скорости терминала.

0

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

В основной библиотеке этого нет (но, вероятно, должно быть). Оказавшись на месте, вы можете делать такие вещи, как:

 с elapsed_timer() как истекшее:
    # какой-то длинный код
    print("midpoint at %.  2f секунды" % elapsed() ) # время на данный момент
    # другой длинный код
print("все сделано за %.2f секунд" % истекло() )
 

Вот достаточный код contextmanager:

 from contextlib import contextmanager
из timeit импортировать default_timer
@contextmanager
прошедший_таймер защиты ():
    запуск = таймер_по умолчанию()
    elapser = lambda: default_timer() — запуск
    выход лямбда: eplapser()
    конец = таймер_по умолчанию()
    elapser = лямбда: конец-начало
 

И некоторый исполняемый демонстрационный код:

 время импорта
с elapsed_timer() как истекшим:
    время сна(1)
    печать (истекшее())
    время сна(2)
    печать (истекшее())
    время сна(3)
 

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

2

Я предпочитаю это. время doc слишком запутанный.

 из даты и времени импорта даты и времени
start_time = дата и время.сейчас()
# ВСТАВЬТЕ СВОЙ КОД
time_elapsed = datetime.now() - start_time
print('Время истекло (чч:мм:сс.мс) {}'.format(time_elapsed))
 

Обратите внимание, что здесь не происходит никакого форматирования, я просто написал чч:мм:сс в распечатке, чтобы можно было интерпретировать time_elapsed

3

Вот еще один способ сделать это:

 >> из pytictoc импортировать TicToc
>> t = TicToc() # создать экземпляр TicToc
>> t.tic() # Запустить таймер
>> # сделать что-нибудь
>> t.toc() # Вывести прошедшее время
Прошедшее время составляет 2,612231 секунды.
 

По сравнению с традиционным способом:

 >> со времени импорта со времени
>> t1 = время()
>> # сделать что-нибудь
>> t2 = время()
>> прошло = t2 - t1
>> print('Прошедшее время: %f секунд.' Прошло %)
Прошедшее время составляет 2,612231 секунды. 
 

Установка:

 pip install pytictoc
 

Дополнительные сведения см. на странице PyPi.

5

Самый простой способ рассчитать продолжительность операции:

 время импорта
start_time = время.monotonic()
<операции, программы>
print('секунды:', time.monotonic() - start_time)
 

Официальная документация здесь.

2

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

Во-первых, если вы колеблетесь между timeit и time.time , timeit имеет два преимущества:

1. timeit выбирает лучший таймер, доступный для вашей ОС и версии Python.
2. timeit отключает сборку мусора, однако это не то, чего вы можете хотеть или не хотеть.

Теперь проблема в том, что timeit не так прост в использовании, потому что его нужно настроить, и все становится ужасно, когда у вас есть куча импорта. В идеале вам просто нужен декоратор или используйте с блоком и измерением времени. К сожалению, для этого нет ничего встроенного, поэтому у вас есть два варианта:

Вариант 1: использовать библиотеку timebudget

Timebudget — это универсальная и очень простая библиотека, которую вы можете использовать всего в одной строке кода после pip. установить.

 @timebudget # Запишите, сколько времени занимает эта функция
определить мой_метод():
    # мой код
 

Вариант 2: Используйте мой небольшой модуль

Ниже я создал небольшой служебный модуль синхронизации под названием Timing.py. Просто поместите этот файл в свой проект и начните его использовать. Единственная внешняя зависимость — это runstats, которая опять же невелика.

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

 время импорта
@timing.MeasureTime
определение MyBigFunc():
    #сделай что-нибудь, отнимающее много времени
    для я в диапазоне (10000):
        печать (я)
время. print_all_timings()
 

Если вы хотите синхронизировать часть кода, просто поместите ее в блок с блоком :

 время импорта
#где-то в моем коде
со временем.MeasureBlockTime("MyBlock"):
    #сделай что-нибудь, отнимающее много времени
    для я в диапазоне (10000):
        печать (я)
# остальная часть моего кода
время.print_all_timings()
 

Преимущества:

Существует несколько недоработанных версий, поэтому я хочу отметить несколько основных моментов:

1. Используйте таймер из timeit вместо time.time по причинам, описанным ранее.
2. При желании вы можете отключить сборщик мусора во время синхронизации.
3. Decorator принимает функции с именованными или безымянными параметрами.
4. Возможность отключить печать в блоке времени (используйте с time.MeasureBlockTime() как t , а затем t.elapsed ).
5. Возможность оставить gc включенным для синхронизации блоков.

2

Использование time. time для измерения выполнения дает вам общее время выполнения ваших команд, включая время выполнения, затрачиваемое другими процессами на вашем компьютере. Это время, которое пользователь замечает, но не очень хорошо, если вы хотите сравнить разные фрагменты кода/алгоритмы/функции/…

Дополнительная информация о timeit :

• Использование модуля timeit
• timeit — Время выполнения небольших фрагментов кода Python

Если вы хотите глубже понять профилирование:

• http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
• Как можно профилировать скрипт Python?

Обновление : я много использовал http://pythonhosted.org/line_profiler/ в течение последнего года и считаю его очень полезным и рекомендую использовать его вместо модуля профиля Python.

Использовать модуль профилировщика. Это дает очень подробный профиль.

 профиль импорта
profile. run('основной()')
 

выводит что-то вроде:

 5 вызовов функций за 0,047 секунды
   Упорядочено: стандартное имя
   ncalls tottime percall cumtime percall имя файла:lineno(функция)
        1 0,000 0,000 0,000 0,000 :0(исполнение)
        1 0,047 0,047 0,047 0,047 :0(установитьпрофиль)
        1 0,000 0,000 0,000 0,000 <строка>:1(<модуль>)
        0 0,000 0,000 профиль:0(профилировщик)
        1 0,000 0,000 0,047 0,047 профиль:0(основной())
        1 0,000 0,000 0,000 0,000 two_sum.py:2(twoSum)
 

Я нашел это очень информативным.

1

Модули Python cProfile и pstats предлагают отличную поддержку для измерения времени, прошедшего в определенных функциях, без необходимости добавлять какой-либо код вокруг существующих функций.

Например, если у вас есть скрипт python timeFunctions.py:

 время импорта
привет ():
    напечатать "Привет :)"
    время сна (0,1)
спасибо ():
    печатать "Спасибо!"
    время сна (0,05)
для idx в диапазоне (10):
    привет()
для idx в диапазоне (100):
    Спасибо()
 

Чтобы запустить профилировщик и сгенерировать статистику для файла, вы можете просто запустить:

 python -m cProfile -o timeStats. profile timeFunctions.py
 

При этом используется модуль cProfile для профилирования всех функций в timeFunctions.py и сбора статистики в файле timeStats.profile. Обратите внимание, что нам не нужно было добавлять какой-либо код в существующий модуль (timeFunctions.py), и это можно сделать с любым модулем.

Когда у вас есть файл статистики, вы можете запустить модуль pstats следующим образом:

 python -m pstats timeStats.profile
 

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

 Добро пожаловать в браузер статистики профиля.
timeStats.profile% статистика привет
<отметка времени> timeStats.profile
         224 вызова функций за 6,014 секунды
   Был использован случайный порядок перечисления
   Список сокращен с 6 до 1 из-за ограничения <'hello'>
   ncalls tottime percall cumtime percall имя файла:lineno(функция)
       10 0,000 0,000 1,001 0,100 timeFunctions. py:3(привет)
timeStats.profile% статистика спасибо
<отметка времени> timeStats.profile
         224 вызова функций за 6,014 секунды
   Был использован случайный порядок перечисления
   Список сокращен с 6 до 1 из-за ограничения <'thankyou'>
   ncalls tottime percall cumtime percall имя файла:lineno(функция)
      100 0,002 0,000 5,012 0,050 timeFunctions.py:7(спасибо)
 

Этот фиктивный пример мало что дает, но дает представление о том, что можно сделать. Самое приятное в этом подходе то, что мне не нужно редактировать какой-либо из моего существующего кода, чтобы получить эти числа и, очевидно, помочь с профилированием.

3

Вот еще один менеджер контекста для кода синхронизации —

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

 из эталонного теста импорта
с эталоном ("Тест 1+1"):
    1+1
=>
Тест 1+1: 1.41e-06 секунд
 

или, если вам нужно значение времени

 с эталоном ("Тест 1+1") как b:
    1+1
печать (б. время)
=>
Тест 1+1: 7.05e-07 секунд
7.05233786763э-07
 

Benchmark.py :

 из timeit импортировать default_timer как таймер
эталон класса (объект):
    def __init__(self, msg, fmt="%0.3g"):
        self.msg = сообщение
        селф.фмт = фмт
    защита __enter__(сам):
        self.start = таймер ()
        вернуть себя
    def __exit__(я, *аргументы):
        t = таймер () - self.start
        print(("%s : " + self.fmt + " секунды") % (self.msg, t))
        собственное время = т
 

Взято с http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

Вот крошечный класс таймера, который возвращает строку «чч:мм:сс»:

 класс Таймер:
  защита __init__(сам):
    self.start = время.время()
  перезагрузка защиты (самостоятельно):
    self.start = время.время()
  защита get_time_hhmmss (я):
    конец = время.время()
    m, s = divmod(end - self.start, 60)
    ч, м = divmod(m, 60)
    time_str = "%02d:%02d:%02d" % (ч, м, с)
    возврат time_str
 

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

 # Запуск таймера
мой_таймер = Таймер()
# . .. сделай что-нибудь
# Получить строку времени:
time_hhmmss = my_timer.get_time_hhmmss()
print("Прошло время: %s" % time_hhmmss )
# ... снова использовать таймер
мой_таймер.restart()
# ... сделай что-нибудь
# Получить время:
time_hhmmss = my_timer.get_time_hhmmss()
# ... и т. д
 

1

(только с Ipython) вы можете использовать %timeit для измерения среднего времени обработки:

 def foo():
    напечатать "привет"
 

, а затем:

 %timeit foo()
 

результат примерно такой:

 10000 циклов, лучшее из 3: 27 мкс на цикл
 

1

Мне нравится простой (python 3):

 from timeit import timeit
timeit(лямбда: печать("привет"))
 

Вывод микросекунд для однократного выполнения:

 2.430883963010274
 

Объяснение : timeit выполняет анонимную функцию 1 миллион раз по умолчанию, результат выдается за секунд . Следовательно, результат для 1 однократного выполнения будет таким же, но за микросекунд в среднем .

---

Для медленных операций добавьте меньшее число итераций, иначе вы можете ждать вечно:

 время импорта
timeit(лямбда: time.sleep(1.5), число=1)
 

Вывод всегда за секунд для общего числа итераций:

 1.5015795179999714
 

2

на python3:

 из времени импорта сна, perf_counter как ПК
t0 = пк()
спать(1)
печать (пк () - t0)
 

элегантный и короткий.

2

Еще один способ использования timeit:

 from timeit import timeit
Функция определения():
    вернуть 1 + 1
время = время (функция, число = 1)
печать (время)
 

 %load_ext змеиная визуализация
%%snakeviz
 

Он просто берет эти 2 строки кода в блокноте Jupyter и создает красивую интерактивную диаграмму. Например:

Вот код. Опять же, 2 строки, начинающиеся с % , являются единственными дополнительными строками кода, необходимыми для использования змейки:

 # !pip install snapviz
%load_ext змеиная визуализация
импортировать глобус
импортировать хеш-библиотеку
%%snakeviz
файлы = glob.glob('*.txt')
def print_files_hashed (файлы):
    для файла в файлах:
        с открытым (файл) как f:
            print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(файлы)
 9123
t2 = время.время()
печать (t2-t1)
 

7.9870223994e-05

1

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

 из functools import wraps
со времени импорта perf_counter
от ввода import Any, Callable, Optional, TypeVar, cast
F = TypeVar("F",bound=Callable[..., Any])
def timer (префикс: Необязательный [str] = Нет, точность: int = 6) -> Вызываемый [[F], F]:
    """Используйте в качестве декоратора для определения времени выполнения любой функции. 
    Аргументы:
        префикс: строка для печати до истечения времени.
            По умолчанию это имя функции.
        точность: сколько десятичных знаков включать в значение секунд.
    Примеры:
        >>> @таймер()
        ... определение foo(x):
        ... вернуть х
        >>> фоо(123)
        фу: 0,000... с
        123
        >>> @timer("Затраченное время: ", 2)
        ... определение foo(x):
        ... вернуть х
        >>> фоо(123)
        Затраченное время: 0,00 с
        123
    """
    def decorator(func: F) -> F:
        @обертывания (функция)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            нелокальный префикс
            prefix = префикс, если префикс не None else f"{func.__name__}: "
            старт = perf_counter()
            результат = функция (* аргументы, ** kwargs)
            конец = perf_counter()
            print(f"{prefix}{конец - начало:.{точность}f}s")
            вернуть результат
        возвратное литье (F, обертка)
    вернуться декоратор
 

Пример использования:

 из таймера импорта таймера
@таймер (точность = 9)
def take_long(x: int) -> bool:
    вернуть x в (i для i в диапазоне (x + 1))
результат = принимает_долго(10**8)
печать (результат)
 

Выход:

 занимает_долго: 4,942629056 с
Истинный
 

Доктесты можно проверить с помощью:

 $ python3 -m doctest --verbose -o=ELLIPSIS timer. py
 

И тип намекает на:

 $ mypy timer.py
 

3

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

 время импорта
определение time_decorator (функция):
    обертка def (*args, **kwargs):
        начало = время.perf_counter()
        original_return_val = func(*args, **kwargs)
        конец = время.perf_counter()
        print("прошедшее время в", func.__name__, ": ", end-start, sep='')
        вернуть original_return_val
    возвратная упаковка
 

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

 @timing_decorator
определение function_to_time():
    время сна(1)
function_to_time()
 

Каждый раз, когда вы вызываете function_to_time , он будет печатать, сколько времени это заняло, и имя функции, для которой выполняется синхронизация.

3

Очень поздний ответ, но, возможно, кому-то он пригодится. Это способ сделать это, который я считаю очень чистым.

 время импорта
def timed(fun, *args):
    с = время.время()
    г = весело (*аргументы)
    print('{} выполнение заняло {} секунд.'.format(fun.__name__, time.time()-s))
    возврат (г)
timed(печать, "Привет")
 

Имейте в виду, что «печать» — это функция в Python 3, а не в Python 2.7. Однако он работает с любой другой функцией. Ваше здоровье!

2

Вы можете использовать timeit.

Вот пример того, как протестировать naive_func, который принимает параметр, используя Python REPL:

 >>> import timeit
>>> определение наивной_функции (х):
... а = 0
... для i в диапазоне (a):
... а += я
... вернуть
>>> def wrapper(func, *args, **kwargs):
... деф обертка():
... return func(*args, **kwargs)
... возвратная обертка
>>> обернутый = обертка (naive_func, 1_000)
>>> timeit.timeit(обернутый, число=1_000_000)
0,4458435332577161
 

Вам не нужна функция-оболочка, если у функции нет параметров.

1

Функция print_elapsed_time ниже

 def print_elapsed_time (префикс = ''):
    e_time = время.время()
    если не hasattr(print_elapsed_time, 's_time'):
        print_elapsed_time.s_time = e_time
    еще:
        print(f'{prefix} прошедшее время: {e_time - print_elapsed_time.s_time:.2f} sec')
        print_elapsed_time.s_time = e_time
 

используйте его таким образом

 print_elapsed_time()
....тяжелые работы...
print_elapsed_time('после тяжелой работы')
....тонны рабочих мест...
print_elapsed_time('после тонны заданий')
 

результат

 после выполнения тяжелых работ время: 0,39 сек.
после тонны заданий прошло время: 0,60 сек.
 

плюсы и минусы этой функции в том, что вам не нужно передавать время начала

Мы также можем преобразовать время в удобочитаемое время.

 время импорта, дата и время
начало = время.часы()
определение num_multi1 (макс.):
    результат = 0
    для числа в диапазоне (0, 1000):
        если (число % 3 == 0 или число % 5 == 0):
            результат += число
    напечатать "Сумма %d" % результат
num_multi1 (1000)
конец = время. часы()
значение = конец - начало
отметка времени = datetime.datetime.fromtimestamp (значение)
печать timestamp.strftime('%Y-%m-%d %H:%M:%S')
 

Хотя в вопросе это строго не задано, довольно часто требуется простой и унифицированный способ постепенного измерения времени, прошедшего между несколькими строками кода.

Если вы используете Python 3.8 или более позднюю версию, вы можете использовать выражения присваивания (также известные как оператор walrus), чтобы добиться этого довольно элегантным способом:

 время импорта
начало, раз = time.perf_counter(), {}
распечатать("привет")
times["print"] = -start + (start := time.perf_counter())
время сна(1.42)
times["sleep"] = -start + (start := time.perf_counter())
a = [n**2 для n в диапазоне (10000)]
раз["pow"] = -start + (start := time.perf_counter())
печать (раз)
 

=>

 {'печать': 2.193450927734375e-05, 'сон': 1.4210970401763916, 'мощность': 0.005671024322509766}
 

Я сделал для этого библиотеку, если вы хотите измерить функцию, вы можете просто сделать это так

из импорта pythonbenchmark сравнить, измерить
время импорта
а, б, в, г, д = 10,10,10,10,10
что-то = [а, б, в, г, д]
@мера
def myFunction (что-то):
    время сна (0,4)
@мера
def myOptimizedFunction (что-то):
    время сна (0,2)
моя функция (ввод)
мояОптимизированнаяФункция(ввод)
 

https://github. com/Karlheinzniebuhr/pythonbenchmark

Этот уникальный подход на основе классов предлагает печатное строковое представление, настраиваемое округление и удобный доступ к прошедшему времени в виде строки или числа с плавающей запятой. Он был разработан с помощью Python 3.7.

 импорт даты и времени
импортировать время
класс Таймер:
    """Измерение использованного времени."""
    # Ссылка: https://stackoverflow.com/a/57931660/
    def __init__(self, round_ndigits: int = 0):
        self._round_ndigits = round_ndigits
        self._start_time = timeit.default_timer()
    def __call__(self) -> float:
        время возвратаit.default_timer() - self._start_time
    def __str__(я) -> ул:
        return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))
 

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

 # Настройка таймера
>>> таймер = Таймер()
# Доступ в виде строки
>>> print(f'Время истекло {timer}.')
Прошедшее время 0:00:03.
>>> print(f'Время истекло {timer}.')
Прошедшее время 0:00:04. 
# Доступ как поплавок
>>> таймер()
6.841332235
>>> таймер()
7.970274425
 

1

javascript — Проверьте, сколько времени прошло с момента вызова события (discord.js)

спросил 1 год, 2 месяца назад

Изменено 1 год, 2 месяца назад

Просмотрено 253 раза

Я хотел бы знать, как я могу проверить, сколько времени прошло с момента запуска события (interactionCreate в моем случае), и сделать что-то через определенное время. Это мой текущий код:

 client.once('interactionCreate', взаимодействие => {
                    если (!interaction.isButton()) return;
                    если (interaction.customId == '1') {
                        // сделай что-нибудь
                    } еще {
                        // сделать что-то еще
                    }
                })
 

Он проверит, какая из двух кнопок нажата, но я также хочу проверить, не была ли нажата ни одна кнопка, скажем, в течение 20 секунд, в этом случае он будет делать что-то другое, например отправлять сообщение, но, что наиболее важно, сделает его невозможным.