Python time clock: Python time clock() Method — Tutorialspoint

Модуль time – таймеры времени

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

Для тестирования производительности perf_counter() обеспечивает доступ к таймерам с самым высоким дроблением единиц времени для более точного измерения. Время CPU доступно через clock(), а process_time() возвращает комбинированное значение времени процессора и системы.

В реализациях представлены функции библиотеки C для управления датами и временем. Поскольку они связаны с базовой реализацией языка C, некоторые элементы (такие как начало эпохи и максимальное значение даты) зависят от платформы. Подробную информацию смотрите в документации к библиотеке.

Детали реализации таймера в Python модуле time зависят от платформы. Используйте get_clock_info() для получения основной информации о текущей реализации, включая доступную точность часов:

time_get_clock_info.py
import textwrap
import time
available_clocks = [
    ('clock', time.clock),
    ('monotonic', time.monotonic),
    ('perf_counter', time.perf_counter),
    ('process_time', time.process_time),
    ('time', time.time),
]
for clock_name, func in available_clocks:
    print(textwrap.dedent('''
    {name}:
        adjustable    : {info.adjustable}
        implementation: {info.implementation}
        monotonic     : {info.monotonic}
        resolution    : {info.resolution}
        current       : {current}
    ''').format(
        name=clock_name,
        info=time.get_clock_info(clock_name),
        current=func())
    )

Этот вывод для Mac OS X показывает, что Python time таймеры monotonic и perf_counter реализованы с использованием одного и того же базового системного вызова:

$ python3 time_get_clock_info.py
clock:
    adjustable    : False
    implementation: clock()
    monotonic     : True
    resolution    : 1e-06
    current       : 0.028399
monotonic:
    adjustable    : False
    implementation: mach_absolute_time()
    monotonic     : True
    resolution    : 1e-09
    current       : 172336.002232467
perf_counter:
    adjustable    : False
    implementation: mach_absolute_time()
    monotonic     : True
    resolution    : 1e-09
    current       : 172336.002280763
process_time:
    adjustable    : False
    implementation: getrusage(RUSAGE_SELF)
    monotonic     : True
    resolution    : 1e-06
    current       : 0.028593
time:
    adjustable    : True
    implementation: gettimeofday()
    monotonic     : False
    resolution    : 1e-06
    current       : 1471198232.045526

Одной из функций ядра Python модуля time является функция time(), которая возвращает количество секунд с момента начала «эпохи» в виде значения с плавающей запятой:

time_time.py
import time
print('The time is:', time.time())

Эпоха — это начало измерения времени, которым для систем Unix является 0:00 1 января 1970 года. Хотя значение всегда является числом с плавающей запятой, фактическая точность зависит от платформы:

$ python3 time_time.py
The time is: 1471198232.091589

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

$ python3 time_ctime.py
The time is      : Sun Aug 14 14:10:32 2016
15 secs from now : Sun Aug 14 14:10:47 2016

Второй вызов print() в этом примере иллюстрирует, как использовать ctime() для форматирования значения времени, которое отличается от текущего:

$ python3 time_ctime.py
The time is      : Sun Aug 14 14:10:32 2016
15 secs from now : Sun Aug 14 14:10:47 2016

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

Избегайте таких ситуаций путем использования функции monotonic(), у которой возвращаемое при повторном вызове значение всегда больше предыдущего:

time_monotonic.py
import time
start = time.monotonic()
time.sleep(0.1)
end = time.monotonic()
print('start : {:>9.2f}'.format(start))
print('end   : {:>9.2f}'.format(end))
print('span  : {:>9.2f}'.format(end - start))

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

$ python3 time_monotonic.py
start : 172336.14
end   : 172336.24
span  :      0.10

В то время как time() возвращает время основных часов, clock() возвращает время процессора. Для этого можно использовать Python get time.

Значения, возвращаемые функцией clock(), отражают фактическое время, используемое программой при ее запуске:

time_clock.py
import hashlib
import time
# Данные, используемые для вычисления контрольной суммы md5
data = open(__file__, 'rb').read()
for i in range(5):
    h = hashlib.sha1()
    print(time.ctime(), ': {:0.3f} {:0.3f}'.format(
        time.time(), time.clock()))
    for i in range(300000):
        h.update(data)
    cksum = h.digest()

В этом примере отформатированная ctime() выводится вместе со значениями с плавающей запятой из time() и clock() через цикл для каждой итерации.

Если хотите запустить этот код в своей системе, то может потребоваться добавить во внутренний цикл другие циклы или придется работать с большим количеством данных, чтобы увидеть разницу во времени с помощью Python time:

$ python3 time_clock.py
Sun Aug 14 14:10:32 2016 : 1471198232.327 0.033
Sun Aug 14 14:10:32 2016 : 1471198232.705 0.409
Sun Aug 14 14:10:33 2016 : 1471198233.086 0.787
Sun Aug 14 14:10:33 2016 : 1471198233.466 1.166
Sun Aug 14 14:10:33 2016 : 1471198233.842 1.540

Как правило, часы процессора ничего не засекают, если программа ничего не делает:

time_clock_sleep.py
import time
template = '{} - {:0.2f} - {:0.2f}'
print(template.format(
    time.ctime(), time.time(), time.clock())
)
for i in range(3, 0, -1):
    print('Sleeping', i)
    time.sleep(i)
    print(template.format(
        time.ctime(), time.time(), time.clock())
    )

В этом примере Python 3 time sleep цикл выполняет мало действий, переходя в спящий режим после каждой итерации. Значение time() увеличивается даже тогда, когда приложение находится в спящем режиме, но значение clock() отсутствует:

$ python3 -u time_clock_sleep.py
Sun Aug 14 14:10:34 2016 - 1471198234.28 - 0.03
Sleeping 3
Sun Aug 14 14:10:37 2016 - 1471198237.28 - 0.03
Sleeping 2
Sun Aug 14 14:10:39 2016 - 1471198239.29 - 0.03
Sleeping 1
Sun Aug 14 14:10:40 2016 - 1471198240.29 - 0.03

Вызов sleep() передает управление из текущего потока и указывает ожидать, пока система активирует его. Если программа имеет только один поток, это эффективно блокирует приложение, и оно не работает.

Для измерения производительности важно иметь таймеры monotonic с высокой точностью. Определение наилучшего источника данных синхронизации требует наличия информации о платформе, которую Python предоставляет в perf_counter():

time_perf_counter.py
import hashlib
import time
# Data to use to calculate md5 checksums
data = open(__file__, 'rb').read()
loop_start = time.perf_counter()
for i in range(5):
    iter_start = time.perf_counter()
    h = hashlib.sha1()
    for i in range(300000):
        h.update(data)
    cksum = h.digest()
    now = time.perf_counter()
    loop_elapsed = now - loop_start
    iter_elapsed = now - iter_start
    print(time.ctime(), ': {:0.3f} {:0.3f}'.format(
        iter_elapsed, loop_elapsed))

Как и в случае с функцией Python time monotonic(), эпоха для perf_counter() не определяется. Значения предназначены для сравнения и вычисления, а не в качестве абсолютных значений:

$ python3 time_perf_counter.py
Sun Aug 14 14:10:40 2016 : 0.487 0.487
Sun Aug 14 14:10:41 2016 : 0.485 0.973
Sun Aug 14 14:10:41 2016 : 0.494 1.466
Sun Aug 14 14:10:42 2016 : 0.487 1.953
Sun Aug 14 14:10:42 2016 : 0.480 2.434

Хранимое в виде прошедших секунд время используется в некоторых ситуациях. Но иногда программа должна иметь доступ к отдельным полям даты (год, месяц и т. д.). Модуль времени определяет struct_time для хранения значений даты и времени с разбитыми компонентами, поэтому они легко доступны. Существует несколько функций, которые работают со значениями struct_time вместо float:

time_struct.py
import time
def show_struct(s):
    print('  tm_year :', s.tm_year)
    print('  tm_mon  :', s.tm_mon)
    print('  tm_mday :', s.tm_mday)
    print('  tm_hour :', s.tm_hour)
    print('  tm_min  :', s.tm_min)
    print('  tm_sec  :', s.tm_sec)
    print('  tm_wday :', s.tm_wday)
    print('  tm_yday :', s.tm_yday)
    print('  tm_isdst:', s.tm_isdst)
print('gmtime:')
show_struct(time.gmtime())
print('nlocaltime:')
show_struct(time.localtime())
print('nmktime:', time.mktime(time.localtime()))

Функция Python модуля time gmtime() возвращает текущее время в UTC. Localtime() возвращает текущее время с использованием текущего часового пояса. Mktime() принимает struct_time и преобразует его в формат с плавающей запятой:

$ python3 time_struct.py
gmtime:
  tm_year : 2016
  tm_mon  : 8
  tm_mday : 14
  tm_hour : 18
  tm_min  : 10
  tm_sec  : 42
  tm_wday : 6
  tm_yday : 227
  tm_isdst: 0
localtime:
  tm_year : 2016
  tm_mon  : 8
  tm_mday : 14
  tm_hour : 14
  tm_min  : 10
  tm_sec  : 42
  tm_wday : 6
  tm_yday : 227
  tm_isdst: 1
mktime: 1471198242.0

Выбор функции для определения текущего времени зависит от того, установлен ли часовой пояс программой или системой. Изменение часового пояса не изменяет фактическое время — только способ его представления.

Чтобы изменить часовой пояс, установите переменную среды TZ, затем вызовите tzset(). Часовой пояс можно указать с различными данными, вплоть до времени начала и завершения периода так называемого «летнего» времени. Проще всего использовать название часового пояса, но базовые библиотеки получают и другую информацию.

Приведенная ниже программа без Python time sleep, и задает несколько разных значений для часового пояса и показывает, как изменения влияют на другие настройки в модуле времени:

time_timezone.py
import time
import os
def show_zone_info():
    print('  TZ    :', os.environ.get('TZ', '(not set)'))
    print('  tzname:', time.tzname)
    print('  Zone  : {} ({})'.format(
        time.timezone, (time.timezone / 3600)))
    print('  DST   :', time.daylight)
    print('  Time  :', time.ctime())
    print()
print('Default :')
show_zone_info()
ZONES = [
    'GMT',
    'Europe/Amsterdam',
]
for zone in ZONES:
    os.environ['TZ'] = zone
    time.tzset()
    print(zone, ':')
    show_zone_info()

Часовой пояс по умолчанию для системы, используемой в примерах — US / Eastern. Другие зоны в примере Python модуля time изменяют значение tzname, продолжительности светового дня и значение смещения часового пояса:

$ python3 time_timezone.py
Default :
  TZ    : (not set)
  tzname: ('EST', 'EDT')
  Zone  : 18000 (5.0)
  DST   : 1
  Time  : Sun Aug 14 14:10:42 2016
GMT :
  TZ    : GMT
  tzname: ('GMT', 'GMT')
  Zone  : 0 (0.0)
  DST   : 0
  Time  : Sun Aug 14 18:10:42 2016
Europe/Amsterdam :
  TZ    : Europe/Amsterdam
  tzname: ('CET', 'CEST')
  Zone  : -3600 (-1.0)
  DST   : 1
  Time  : Sun Aug 14 20:10:42 2016

Функции strptime() и strftime() преобразуют struct_time в строковые представления значений времени и наоборот. Существует длинный список инструкций по форматированию для поддержки ввода и вывода в разных форматах. Полный список указан в документации библиотеки для модуля time.

В приведенном ниже примере Python time текущее время преобразуется из строки в экземпляр struct_time и обратно в строку:

time_strptime.py
import time
def show_struct(s):
    print('  tm_year :', s.tm_year)
    print('  tm_mon  :', s.tm_mon)
    print('  tm_mday :', s.tm_mday)
    print('  tm_hour :', s.tm_hour)
    print('  tm_min  :', s.tm_min)
    print('  tm_sec  :', s.tm_sec)
    print('  tm_wday :', s.tm_wday)
    print('  tm_yday :', s.tm_yday)
    print('  tm_isdst:', s.tm_isdst)
now = time.ctime(1483391847.433716)
print('Now:', now)
parsed = time.strptime(now)
print('nParsed:')
show_struct(parsed)
print('nFormatted:',
      time.strftime("%a %b %d %H:%M:%S %Y", parsed))

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

$ python3 time_strptime.py

Now: Mon Jan  2 16:17:27 2017

Parsed:
  tm_year : 2017
  tm_mon  : 1
  tm_mday : 2
  tm_hour : 16
  tm_min  : 17
  tm_sec  : 27
  tm_wday : 0
  tm_yday : 2
  tm_isdst: -1

Formatted: Mon Jan 02 16:17:27 2017

Данная публикация представляет собой перевод статьи «time — Clock Time» , подготовленной дружной командой проекта Интернет-технологии.ру

Главные методы модуля time в python 3, шаблоны и примеры ~ PythonRu

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

import time

Дальше перечислены самые распространенные функции, связанные со временем.

Python time.time()

Функция time() возвращает число секунд, прошедших с начала эпохи. Для операционных систем Unix 1 января 1970, 00:00:00 (UTC) — начало эпохи (момент, с которого время пошло).

import time

seconds = time.time()
print("Секунды с начала эпохи =", seconds)

Python time.ctime()

Функция time.ctime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает строку, представляющую собой местное время.

import time


seconds = 1575721830.711298
local_time = time.ctime(seconds)
print("Местное время:", local_time)

Если запустить программу, то вывод будет выглядеть так:

Местное время: Sat Dec  7 14:31:36 2019

Python time.sleep()

Функция sleep() откладывает исполнение текущего потока на данное количество секунд.

import time

print("Сейчас.")
time.sleep(2.4)
print("Через 2.4 секунды.")

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

Класс time.struct_time

Некоторые функции в модуле time, такие как gmtime(), asctime() и другие, принимают объект time.struct_time в качестве аргумента или возвращают его.

Вот пример объекта time.struct_time.

Индекс	Атрибут	Значения
0	tm_year	0000, …, 2019, …, 9999
1	tm_mon	1, 2, …, 12
2	tm_mday	1, 2, …, 31
3	tm_hour	0, 1, …, 23
4	tm_min	0, 1, …, 59
5	tm_sec	0, 1, …, 61
6	tm_wday	0, 1, …, 6; Monday is 0
7	tm_yday	1, 2, …, 366
8	tm_isdst	0, 1 or -1

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

Python time.localtime()

Функция localtime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает stuct_time в локальном времени.

import time

result = time.localtime(1575721830)
print("результат:", result)
print("\nгод:", result.tm_year)
print("tm_hour:", result.tm_hour)

Вывод этой программы будет следующим:

result: time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=14, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)

year: 2019
tm_hour: 14

Если localtime() передан аргумент None, то вернется значение из time().

Python time.gmtime()

Функция gmtime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи и возвращает struct_time в UTC.

import time

result = time.gmtime(1575721830)
print("результат:", result)
print("\nгод:", result.tm_year)
print("tm_hour:", result.tm_hour)

Вывод этой программы будет следующим:

result: time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=12, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)

year: 2019
tm_hour: 12

Если gmtime() передан аргумент None, то вернется значение time().

Python time.mktime()

Функция mktime() принимает struct_time (или кортеж, содержащий 9 значений, относящихся к struct_time) в качестве аргумента и возвращает количество секунд, прошедших с начала эпохи, в местном времени. Это функция, обратная localtime().

import time

t = (2019, 12, 7, 14, 30, 30, 5, 341, 0)
local_time = time.mktime(t)
print("Местное время:", local_time)

Следующий пример показывает, как связаны mktime() и localtime().

import time

seconds = 1575721830


t = time.localtime(seconds)
print("t1: ", t)


s = time.mktime(t)
print("\ns:", seconds)

Вывод будет следующий:

t1:  time.struct_time(tm_year=2019, tm_mon=12, tm_mday=7, tm_hour=14, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=341, tm_isdst=0)

s: 1575721830

Python time.asctime()

Функция asctime() принимает struct_time (или кортеж, содержащий 9 значений, относящихся к struct_time) в качестве аргумента и возвращает строку, представляющую собой дату.

Например:

import time

t = (2019, 12, 7, 14, 30, 30, 5, 341, 0)

result = time.asctime(t)
print("Результат:", result)

Вывод:

Результат: Sat Dec  7 14:30:30 2019

Python time.strftime()

Функция strftime принимает stuct_time (или соответствующий кортеж) в качестве аргумента и возвращает строку с датой в зависимости от использованного формата. Например:

import time

named_tuple = time.localtime() 
time_string = time.strftime("%m/%d/%Y, %H:%M:%S", named_tuple)

print(time_string)

Вывод будет следующий:

12/07/2019, 15:01:09

Здесь %Y, %m, %d, %H и другие — элементы форматирования.

• %Y — год [0001,…, 2019, 2020,…, 9999]
• %m — месяц [01, 02, …, 11, 12]
• %d — день [01, 02, …, 30, 31]
• %H — час [00, 01, …, 22, 23
• %M — минута [00, 01, …, 58, 59]
• %S — секунда [00, 01, …, 58, 61]

Python time.strptime()

Функция strptime() делает разбор строки python, в которой упоминается время и возвращает struct_time.

import time

time_string = "15 June, 2019"
result = time.strptime(time_string, "%d %B, %Y")
print(result)

Вывод:

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

Python | метод time.clock ()

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

time.clock() модуля времени в Python используется для получения текущего времени процессора в виде числа с плавающей запятой, выраженного в секундах.
Так же, большинство функций, определенных во временном модуле, вызывают соответствующую функцию библиотеки C. time.clock() также вызывает библиотечную функцию C с тем же именем, чтобы получить результат. Точность возвращаемого значения с плавающей запятой зависит от вызываемой библиотечной функции C.

Примечание. Этот метод устарел с Python версии 3.3 и будет удален в Python версии 3.8. Поведение этого метода зависит от платформы.

Syntax: time.clock()

Parameter: No parameter is required.

Return type: This method returns a float value which represents the current processor time in seconds.

Код № 1: Использование метода time.clock() для получения текущего времени процессора

import time    pro_time = time.clock()    print("Current processor time (in seconds):", pro_time)

Выход:

Current processor time (in seconds): 0.042379

Код № 2: Использование метода time.clock() для получения текущего времени процессора

import time        def factorial(n):      f = 1     for i in range(n, 1, -1):          f = f * i             return f        start = time.clock()     print("At the beginning of the calculation")  print("Processor time (in seconds):", start, "\n")        i = 0 fact = [0] * 10;     while i < 10:      fact[i] = factorial(i)      i = i + 1    for i in range(0, len(fact)):      print("Factorial of % d:" % i, fact[i])     end = time.clock()     print("\nAt the end of the calculation")  print("Processor time (in seconds):", end)  print("Time elapsed during the calculation:", end - start)

Выход:

At the beginning of the calculation
Processor time (in seconds): 0.03451 

Factorial of  0: 1
Factorial of  1: 1
Factorial of  2: 2
Factorial of  3: 6
Factorial of  4: 24
Factorial of  5: 120
Factorial of  6: 720
Factorial of  7: 5040
Factorial of  8: 40320
Factorial of  9: 362880

At the end of the calculation
Processor time (in seconds): 0.034715
Time elapsed during the calculation: 0.0002050000000000038

Ссылка: https://docs.python.org/3/library/time.html#time.clock

Рекомендуемые посты:

Python | метод time.clock ()

0.00 (0%) 0 votes

Python | метод time.clock_getres ()

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

time.clock_getres() модуля Time используется для получения разрешения или точности указанных часов clk_id . По сути, clk_id является целочисленным значением, которое представляет идентификатор часов.

Ниже приведены константы, доступные на платформах UNIX, которые можно использовать в качестве значения параметра clk_id :

clk_id	clk_id constant	Meaning
0	time.CLOCK_REALTIME	System-wide real-time clock
1	time.CLOCK_PROCESS_CPUTIME_ID	High-resolution per-process timer from the CPU
2	time.CLOCK_MONOTONIC	It represents monotonic time since some unspecified starting point
3	time.CLOCK_THREAD_CPUTIME_ID	Thread-specific CPU-time clock
4	time.CLOCK_MONOTONIC_RAW	Similar to time.CLOCK_MONOTONIC, but provides access to a raw hardware-based time that is not subject to NTP adjustments

Примечание: time.clock_getres() доступен только в UNIX-подобных системах.

Syntax: time.clock_getres(clk_id)

Parameter:
clk_id: A clk_id constant or an integer value representing clk_id of the clock.

Return type: This method returns a float value which represents the precision or resolution of specified clock clk_id.

Код № 1: Использование метода time.clock_getres()

import time       clk_id1 = time.CLOCK_REALTIME    clk_id2 = time.CLOCK_MONOTONIC    clk_id3 = time.CLOCK_MONOTONIC    clk_id4 = time.CLOCK_THREAD_CPUTIME_ID    clk_id5 = time.CLOCK_PROCESS_CPUTIME_ID       precision1 = time.clock_getres(clk_id1) precision2 = time.clock_getres(clk_id2) precision3 = time.clock_getres(clk_id3) precision4 = time.clock_getres(clk_id4) precision5 = time.clock_getres(clk_id5)    print("Precision of system-wide real-time clock:", precision1) print("Precision of monotonic clock:", precision2) print("Precision of monotonic (raw-hardware based time) clock:",                                                    precision3) print("Precision of thread-specific CPU time clock:", precision4) print("Precision of per-process time from the CPU:", precision5)

Выход:

Precision of system-wide real-time clock: 1e-09
Precision of monotonic clock: 1e-09
Precision of monotonic (raw-hardware based time) clock: 1e-09
Precision of thread-specific CPU time clock: 1e-09
Precision of per-process time from the CPU: 1e-09

Код № 2: Использование целочисленного значения в качестве параметра метода time.clock_getres()

import time       clk_id1 = 0    clk_id2 = 2       precision1 = time.clock_getres(clk_id1) precision2 = time.clock_getres(clk_id2)    print("Precision of system-wide real-time clock:", precision1) print("Precision of monotonic clock:", precision2)

Выход:

Precision of system-wide real-time clock: 1e-09
Precision of monotonic clock: 1e-09

Ссылка: https://docs.python.org/3/library/time.html#time.clock_getres

Рекомендуемые посты:

Python | метод time.clock_getres ()

0.00 (0%) 0 votes

15.3. time — Доступ ко времени и преобразования — документация Python 2.7.18

Этот модуль предоставляет различные функции, связанные со временем. Для связанных функциональность, см. также модули datetime и calendar .

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

Разъяснение терминологии и условных обозначений.

• Эпоха — это точка, где начинается время. 1 января этого год, в 0 часов «время с эпохи» равно нулю. Для Unix эпоха 1970. Чтобы узнать, что это за эпоха, посмотрите на gmtime (0) .

• Проблемы 2000 года (2000 год) : Python зависит от библиотеки C платформы, которая обычно не имеет выпусков за 2000 год, так как все даты и время представлен внутри как секунды с эпохи.Функции, принимающие struct_time (см. Ниже) обычно требует 4-значного года. Для обратного совместимость, поддерживаются 2-значные годы, если переменная модуля accept2dyear — ненулевое целое число; эта переменная инициализируется как 1 если для переменной среды PYTHONY2K не задано непустое значение строка, в этом случае она инициализируется как 0 . Таким образом, вы можете установить PYTHONY2K в непустую строку в среде, чтобы требовать 4-значную лет для всего года ввода.Когда принимаются двузначные годы, они конвертируются в соответствии со стандартом POSIX или X / Open: значения 69-99 соответствуют 1969-1999 гг., а значения 0–68 соответствуют 2000–2068 гг. Значения 100–1899 всегда недопустимы.

• DST — переход на летнее время, изменение часового пояса (обычно) на единицу. час в течение части года. Правила DST волшебны (определяются местным законодательством) и может меняться из года в год. В библиотеке C есть таблица, содержащая локальные rules (часто для гибкости он читается из системного файла) и является единственным источник Истинной Мудрости в этом отношении.

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

• С другой стороны, точность time () и sleep () лучше чем их эквиваленты в Unix: время выражается как числа с плавающей запятой, time () возвращает наиболее точное доступное время (с использованием Unix gettimeofday () , если доступно) и sleep () примет время с ненулевой дробью (для этого используется Unix select () , где доступный).

• Значение времени, возвращаемое функциями gmtime () , localtime () и strptime () и принимается asctime () , mktime () и strftime () , можно рассматривать как последовательность из 9 целых чисел. Возврат значения gmtime () , localtime () и strptime () также предлагают имена атрибутов для отдельных полей.

  Описание этих объектов см. В struct_time .

  Изменено в версии 2.2: последовательность значений времени была изменена с кортежа на struct_time , с добавление имен атрибутов для полей.

• Используйте следующие функции для преобразования между представлениями времени:

Модуль определяет следующие функции и элементы данных:

раз. принять 2 года

Логическое значение, указывающее, будут ли приняты двузначные значения года.это по умолчанию true, но будет установлено значение false, если переменная среды PYTHONY2K — это непустая строка. Он также может быть изменен во время выполнения.

раз. altzone

Смещение местного часового пояса летнего времени в секундах к западу от UTC, если он определен. Это отрицательно, если местный часовой пояс DST находится к востоку от UTC (как в Западной Европе, включая Великобританию). Используйте это, только если дневной свет отличен от нуля.

раз. asctime ([ t ])

Преобразование кортежа или struct_time , представляющего время, возвращаемое gmtime () или localtime () в 24-символьную строку следующего форма: 'Вс, 20 июня 23:21:05 1993' . Если t не указано, текущее время как возвращается localtime () используется . Информация о локали не используется asctime () .

Примечание

В отличие от одноименной функции C, в конце строки новой строки нет.

Изменено в версии 2.1: разрешено не указывать т .

раз. часы ()

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

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

раз. ctime ([ секунд ])

Преобразует время, выраженное в секундах с начала эпохи, в строку, представляющую местное время. Если секунд не указано или Нет , текущее время как возвращается time () используется . ctime (secs) эквивалентно asctime (местное время (секунды)) . Информация о локали не используется ctime () .

Изменено в версии 2.1: Допускается пропуск секунд .

Изменено в версии 2.4: Если секунд равно Нет , используется текущее время.

.

16,3. time — Доступ ко времени и преобразования — документация Python 3.3.7

Этот модуль предоставляет различные функции, связанные со временем. Для связанных функциональность, см. также модули datetime и calendar.

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

Разъяснение терминологии и условных обозначений.

• Эпоха — точка, где начинается время. 1 января этого год, в 0 часов «время с эпохи» равно нулю. Для Unix эпоха 1970. Чтобы узнать, что это за эпоха, посмотрите на gmtime (0).

• Функции этого модуля могут не обрабатывать даты и время до эпохи или далеко в будущее. Точка отсечения в будущем определяется C библиотека; для 32-битных систем это обычно 2038 год.

• Проблемы 2000 года (2000 г.) : Python зависит от библиотеки C платформы, которая обычно не имеет выпусков за 2000 год, так как все даты и время представлен внутри как секунды с эпохи. Функция strptime () может анализировать 2-значные годы при заданном коде формата% y. Когда 2-значные годы проанализированы, они преобразуются в соответствии со стандартами POSIX и ISO C: значения 69–99 сопоставлены с 1969–1999, а значения 0–68 сопоставлены с 2000–2068.

• UTC — всемирное координированное время (ранее известное как среднее время по Гринвичу, или ВРЕМЯ ПО ГРИНВИЧУ).Аббревиатура UTC — это не ошибка, а компромисс между английским и Французский язык.

• DST — переход на летнее время, изменение часового пояса (обычно) на единицу. час в течение части года. Правила DST волшебны (определяются местным законодательством) и может меняться из года в год. В библиотеке C есть таблица, содержащая локальные rules (часто для гибкости он читается из системного файла) и является единственным источник Истинной Мудрости в этом отношении.

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

• С другой стороны, точность time () и sleep () лучше чем их эквиваленты в Unix: время выражается как числа с плавающей запятой, time () возвращает наиболее точное доступное время (используя Unix gettimeofday (), если доступно), а sleep () примет время с ненулевой дробью (для реализации этого используется Unix select (), где доступный).

• Значение времени, возвращаемое функциями gmtime (), localtime () и strptime () и принимается asctime (), mktime () и strftime () — это последовательность из 9 целых чисел.Возвращаемые значения gmtime (), localtime () и strptime () также предлагают атрибут имена для отдельных полей.

  Описание этих объектов см. В struct_time.

  Изменено в версии 3.3: Тип struct_time был расширен для предоставления tm_gmtoff и tm_zone, если платформа поддерживает соответствующие struct tm members.

• Используйте следующие функции для преобразования между представлениями времени:

Модуль определяет следующие функции и элементы данных:

время.altzone

Смещение местного часового пояса летнего времени в секундах к западу от UTC, если он определен. Это отрицательно, если местный часовой пояс DST находится к востоку от UTC (как в Западной Европе, включая Великобританию). Используйте это, только если дневной свет отличен от нуля.

time.asctime ([ t ])

Преобразование кортежа или struct_time, представляющего время, возвращаемое gmtime () или localtime () в строку из следующих форма: «Вс, 20 июня, 23:21:05 1993». Если t не указано, текущее время как возвращено localtime ().Информация о локали не используется asctime ().

Примечание

В отличие от одноименной функции C, asctime () не добавляет завершающий символ новой строки.

time.clock ()

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

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

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

время.clock_getres ( clk_id )

Возвращает разрешение (точность) указанных часов clk_id .

Доступность: Unix.

time.clock_gettime ( clk_id )

Возвращает время указанных часов clk_id .

Доступность: Unix.

time.clock_settime ( clk_id , время )

Установить время указанных часов clk_id .

Доступность: Unix.

время.CLOCK_HIGHRES

В ОС Solaris есть таймер CLOCK_HIGHRES, который пытается использовать оптимальное аппаратный источник и может давать разрешение, близкое к наносекундному. CLOCK_HIGHRES — это нерегулируемые часы с высоким разрешением.

Наличие: Solaris.

время.CLOCK_MONOTONIC

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

Доступность: Unix.

время.CLOCK_MONOTONIC_RAW

Аналогичен CLOCK_MONOTONIC, но предоставляет доступ к необработанному аппаратное время, не зависящее от настроек NTP.

Доступность: Linux 2.6.28 или новее.

time.CLOCK_PROCESS_CPUTIME_ID

Таймер каждого процесса с высоким разрешением от ЦП.

Доступность: Unix.

время.CLOCK_REALTIME

Часы реального времени в масштабе всей системы. Для установки этих часов требуются соответствующие привилегии.

Доступность: Unix.

.

16,3. time — Доступ ко времени и преобразования — документация Python 3.4.10

Этот модуль предоставляет различные функции, связанные со временем. Для связанных функциональность, см. также модули datetime и calendar.

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

Разъяснение терминологии и условных обозначений.

• Эпоха — точка, где начинается время. 1 января этого год, в 0 часов «время с эпохи» равно нулю. Для Unix эпоха 1970. Чтобы узнать, что это за эпоха, посмотрите на gmtime (0).

• Функции этого модуля могут не обрабатывать даты и время до эпохи или далеко в будущее. Точка отсечения в будущем определяется C библиотека; для 32-битных систем это обычно 2038 год.

• Проблемы 2000 года (2000 г.) : Python зависит от библиотеки C платформы, которая обычно не имеет выпусков за 2000 год, так как все даты и время представлен внутри как секунды с эпохи. Функция strptime () может анализировать 2-значные годы при заданном коде формата% y. Когда 2-значные годы проанализированы, они преобразуются в соответствии со стандартами POSIX и ISO C: значения 69–99 сопоставлены с 1969–1999, а значения 0–68 сопоставлены с 2000–2068.

• UTC — всемирное координированное время (ранее известное как среднее время по Гринвичу, или ВРЕМЯ ПО ГРИНВИЧУ).Аббревиатура UTC — это не ошибка, а компромисс между английским и Французский язык.

• DST — переход на летнее время, изменение часового пояса (обычно) на единицу. час в течение части года. Правила DST волшебны (определяются местным законодательством) и может меняться из года в год. В библиотеке C есть таблица, содержащая локальные rules (часто для гибкости он читается из системного файла) и является единственным источник Истинной Мудрости в этом отношении.

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

• С другой стороны, точность time () и sleep () лучше чем их эквиваленты в Unix: время выражается как числа с плавающей запятой, time () возвращает наиболее точное доступное время (используя Unix gettimeofday (), если доступно), а sleep () примет время с ненулевой дробью (для реализации этого используется Unix select (), где доступный).

• Значение времени, возвращаемое функциями gmtime (), localtime () и strptime () и принимается asctime (), mktime () и strftime () — это последовательность из 9 целых чисел.Возвращаемые значения gmtime (), localtime () и strptime () также предлагают атрибут имена для отдельных полей.

  Описание этих объектов см. В struct_time.

  Изменено в версии 3.3: Тип struct_time был расширен для предоставления tm_gmtoff и tm_zone, если платформа поддерживает соответствующие struct tm members.

• Используйте следующие функции для преобразования между представлениями времени:

Модуль определяет следующие функции и элементы данных:

время.altzone

Смещение местного часового пояса летнего времени в секундах к западу от UTC, если он определен. Это отрицательно, если местный часовой пояс DST находится к востоку от UTC (как в Западной Европе, включая Великобританию). Используйте это, только если дневной свет отличен от нуля.

time.asctime ([ t ])

Преобразование кортежа или struct_time, представляющего время, возвращаемое gmtime () или localtime () в строку из следующих форма: «Вс, 20 июня, 23:21:05 1993». Если t не указано, текущее время как возвращено localtime ().Информация о локали не используется asctime ().

Примечание

В отличие от одноименной функции C, asctime () не добавляет завершающий символ новой строки.

time.clock ()

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

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

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

time.clock_getres ( clk_id )

Возвращает разрешение (точность) указанных часов clk_id .

Доступность: Unix.

время.clock_gettime ( clk_id )

Возвращает время указанных часов clk_id .

Доступность: Unix.

time.clock_settime ( clk_id , время )

Установить время указанных часов clk_id .

Доступность: Unix.

время.CLOCK_HIGHRES

В ОС Solaris есть таймер CLOCK_HIGHRES, который пытается использовать оптимальное аппаратный источник и может давать разрешение, близкое к наносекундному.CLOCK_HIGHRES — это нерегулируемые часы с высоким разрешением.

Наличие: Solaris.

время.CLOCK_MONOTONIC

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

Доступность: Unix.

время.CLOCK_MONOTONIC_RAW

Аналогичен CLOCK_MONOTONIC, но предоставляет доступ к необработанному аппаратное время, не зависящее от настроек NTP.

Доступность: Linux 2.6.28 или новее.

time.CLOCK_PROCESS_CPUTIME_ID

Таймер каждого процесса с высоким разрешением от ЦП.

Доступность: Unix.

время.CLOCK_REAL

.

time — Функции для управления временем на часах

Назначение:	Функции для управления временем на часах.
Доступен в:	1.4 или более ранней версии

Модуль времени предоставляет функции библиотеки C для управления даты и время. Поскольку он привязан к базовой реализации C, некоторые детали (например, начало эпохи и максимальное значение даты поддерживается) зависят от платформы.Обратитесь к документации библиотеки для получения полной информации.

Часы настенные

Одна из основных функций модуля времени — time (), который возвращает количество секунд с начала эпохи как значение с плавающей запятой.

 время импорта

print 'Время:', time.time ()
 

Хотя значение всегда является плавающим, фактическая точность равна платформенно-зависимый.

 $ питон time_time.py
Время: 1205079300,54
 

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

 время импорта

print 'Время:', time.ctime ()
позже = time.time () + 15
напечатайте '15 секунд с этого момента: ', time.ctime (позже)
 

Здесь вторая строка вывода показывает, как использовать ctime () для форматирования значение времени, отличное от текущего времени.

 $ python time_ctime.py
Время: вс, 9 марта, 12:18:02 2008
Через 15 секунд: вс, 9 марта, 12:18:17 2008 г.
 

Тактовая частота процессора

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

 импорт хэшлиба
время импорта

# Данные для расчета контрольных сумм md5
данные = открыть (__ файл__, 'rt'). читать ()

для i в диапазоне (5):
    h = hashlib.sha1 ()
    напечатать time.ctime (), ':% 0.3f% 0.3f'% (time.time (), time.clock ())
    для i в диапазоне (100000):
        h.update (данные)
    cksum = h.digest ()
 

В этом примере отформатированный ctime () печатается вместе с значения с плавающей запятой из time () и clock () для каждую итерацию цикла.Если вы хотите запустить пример на ваша система, возможно, вам придется добавить больше циклов во внутренний цикл или работать с большим объемом данных, чтобы увидеть разницу.

 $ python time_clock.py
Вс 9 мар 12:41:53 2008: 1205080913.260 0,030
Вс 9 мар 12:41:53 2008: 1205080913.682 0.440
Вс 9 мар 12:41:54 2008: 1205080914.103 0,860
Вс 9 мар 12:41:54 2008: 1205080914.518 1.270
Вс 9 мар 12:41:54 2008: 1205080914.932 1.680
 

Обычно тактовая частота процессора не тикает, если ваша программа не работает. что-нибудь.

 время импорта

для i в диапазоне (6, 1, -1):
    напечатайте '% s% 0.2f% 0.2f'% (time.ctime (), time.time (), time.clock ())
    печать "Спящий", я
    time.sleep (я)
 

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

 $ python time_clock_sleep.py
Вс 9 мар 12:46:36 2008 1205081196.20 0,02
Спящие 6
Вс 9 мар 12:46:42 2008 1205081202.20 0,02
Спящая 5
Вс 9 мар 12:46:47 2008 1205081207.20 0,02
Спящая 4
Вс 9 мар 12:46:51 2008 1205081211.20 0,02
Спящая 3
Вс 9 мар 12:46:54 2008 1205081214.21 0,02
Спящая 2
 

Вызов sleep () дает управление из текущего потока и просит его подождать, пока система вернет его в рабочий режим. Если в вашей программе только один поток, это эффективно блокирует приложение и не работает.

struct_time

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

 время импорта

напечатайте 'gmtime:', time.gmtime ()
напечатать 'localtime:', time.localtime ()
напечатайте 'mktime:', time.mktime (time.localtime ())

Распечатать
t = время.localtime ()
print 'День месяца:', t.tm_mday
print 'День недели:', t.tm_wday
print 'День года:', t.tm_yday
 

gmtime () возвращает текущее время в формате UTC.местное время() возвращает текущее время с текущим часовым поясом применяется. mktime () принимает struct_time и преобразует ее в представление с плавающей запятой.

 $ python time_struct.py
gmtime: (2008, 3, 9, 16, 58, 19, 6, 69, 0)
местное время: (2008, 3, 9, 12, 58, 19, 6, 69, 1)
mktime: 1205081899.0

День месяца: 9
 День недели: 6
 День в году: 69
 

Время синтаксического анализа и форматирования

Две функции strptime () и strftime () конвертируют между struct_time и строковым представлением значений времени.Там длинный список инструкций по форматированию, доступных для поддержки ввода и выводить в разных стилях. Полный список задокументирован в документация библиотеки для модуля времени.

В этом примере текущее время преобразуется из строки в struct_time и обратно к строке.

 время импорта

сейчас = время.ctime ()
распечатать сейчас
parsed = time.strptime (сейчас)
печать проанализирована
print time.strftime ("% a% b% d% H:% M:% S% Y", проанализировано)
 

Выходная строка не совсем такая, как входная, так как день месяц начинается с нуля.

 $ python time_strptime.py
Вс 9 мар 13:01:19 2008
(2008, 3, 9, 13, 1, 19, 6, 69, -1)
Вс, 09 мар, 13:01:19 2008
 

Работа с часовыми поясами

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

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

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

 время импорта
импорт ОС

def show_zone_info ():
    print '\ tTZ:', os.environ.get ('TZ', '(не установлено)')
    напечатайте '\ ttzname:', время.tzname
    print '\ tZone:% d (% d)'% (time.timezone, (time.timezone / 3600))
    print '\ tDST:', time.daylight
    печать '\ tTime:', time.ctime ()
    Распечатать

print 'По умолчанию:'
show_zone_info ()

для зоны в ["США / Восток", "США / Тихоокеанский регион", "GMT", "Европа / Амстердам"]:
    os.environ ['TZ'] = зона
    time.tzset ()
    зона печати, ':'
    show_zone_info ()
 

Мой часовой пояс по умолчанию — США / Восток, поэтому установка TZ на это не имеет эффект. Другие используемые зоны меняют имя tzname, флаг дневного света и значение смещения часового пояса.

 $ питон time_timezone.py
По умолчанию :
    ТЗ: (не установлено)
    tzname: ('EST', 'EDT')
    Зона: 18000 (5)
    Летнее время: 1
    Время: 9 Мар, Вс, 13:06:53, 2008

США / Восток:
    TZ: США / Восток
    tzname: ('EST', 'EDT')
    Зона: 18000 (5)
    Летнее время: 1
    Время: 9 Мар, Вс, 13:06:53, 2008

США / Тихоокеанский регион:
    TZ: США / Тихоокеанский регион
    tzname: ('PST', 'PDT')
    Зона: 28800 (8)
    Летнее время: 1
    Время: 9 Мар, Вс, 10:06:53, 2008

ВРЕМЯ ПО ГРИНВИЧУ :
    TZ: GMT
    tzname: ('GMT', 'GMT')
    Зона: 0 (0)
    Летнее время: 0
    Время: 9 марта, вс, 17:06:53, 2008

Европа / Амстердам:
    TZ: Европа / Амстердам
    tzname: ('CET', 'CEST')
    Зона: -3600 (-1)
    Летнее время: 1
    Время: 9 Мар, Вс 18:06:53 2008
 

См. Также

время

Документация стандартной библиотеки для этого модуля.

дата и время

Модуль datetime включает другие классы для вычислений с датой и временем.

календарь

Работа с функциями даты более высокого уровня для создания календарей или рассчитывать повторяющиеся события.

.