Класс date() модуля datetime в Python.
Варианты создания объекта даты datetime.date.
Синтаксис:import datetime date = datetime.date(year, month, day)Параметры:
Все аргументы обязательны. Аргументы должны быть целыми числами.
year— год в пределахMINYEAR <= year <= MAXYEAR,month— месяц в пределах1 <= month <= 12,day— день в пределах1 <= day <= n, n — количество дней в данном месяце и году.
Если задан аргумент вне этих диапазонов, вызывается исключение ValueError.
- объект даты
date().
Класс date() модуля datetime — объект даты, который представляет дату — год, месяц и день в идеализированном календаре, текущий григорианский календарь бесконечно расширяется в обоих направлениях.
Атрибуты экземпляра datetime.date (только для чтения):
date.year— возвращает год в диапазоне, указанном выше,date.month— возвращает месяц в диапазоне, указанном выше,date.day— возвращает день в диапазоне, указанном выше.
>>> import datetime >>> date = datetime.date(2020, 7, 14) >>> date # datetime.date(2020, 7, 14) >>> date.day # 14 >>> date.month # 7 >>> date.year # 2020
Создание объекта
datetime.date другими способами:datetime.date.today():Подкласс datetime.date.today() возвращает текущую местную дату, что эквивалентно вызову выражения
>>> import datetime >>> datetime.date.today() # datetime.date(2020, 5, 5)
datetime.date.fromtimestamp(timestamp):Подкласс datetime. возвращает локальную дату, соответствующую метке времени POSIX, например возвращается функцией 
date.fromtimestamp()time.time().
Если отметка времени выходит за пределы диапазона значений, поддерживаемых функцией localtime() платформы, то это может вызвать исключение OverflowError, а при сбое системной localtime() — исключение OSError. Отметка времени обычно ограничивается годами с 1970 по 2038 год.
Обратите внимание, что в системах без POSIX, которые включают в себя понятие високосных секунд в своем значении временной метки, високосные секунды игнорируются функцией fromtimestamp().
>>> import datetime, time >>> sec = time.time() >>> sec # 1588657177.4476178 >>> datetime.date.fromtimestamp(sec) # datetime.date(2020, 5, 5)
datetime.date.fromisoformat(date_string):Подкласс datetime.date.fromisoformat() возвращает дату, соответствующую строке date_string в формате YYYY-MM-DD:
>>> from datetime import date >>> date.fromisoformat('2021-12-06') # datetime.date(2021, 12, 6)
Это обратное значение возвращаемое методом date.isoformat(). Поддерживается только формат YYYY-MM-DD.
datetime.date.fromisocalendar(year, week, day):Подкласс datetime.date.fromisocalendar() возвращает дату, соответствующую календарной дате ISO, указанной по году year, неделе week и дню day.
Это обратное значение возвращаемое методом date.isocalendar().
Поддерживаемые операции:
| Операция | Результат | Заметка |
| date2 = date1 + timedelta | ‘date2’ это ‘timedelta.days’ дней, удаленных из ‘date1’. | (1) |
| date2 = date1 — timedelta | Вычисляет ‘date2’ так, что ‘date2 + timedelta == date1’. | (2) |
| timedelta = date1 — date2 | (3) | |
| date1 | ‘date1’ считается меньше чем ‘date2’, когда ‘date1’ предшествует ‘date2’ во времени. | (4) |
Заметки:
date2перемещается вперед во времени, еслиtimedelta.days > 0, или назад, еслиtimedelta.days < 0. После операции верно равенствоdate2 - date1 == timedelta.days,timedelta.secondsиtimedelta.microsecondsигнорируются. Еслиdate2.yearбудет меньше MINYEAR или больше MAXYEAR то появляется исключениеOverflowError.timedelta.secondsиtimedelta.microsecondsигнорируются.- Значение точно и не может переполниться.
timedelta.secondsиtimedelta.microsecondsравны 0, а после справедливо равенствоdate2 + timedelta == date1. - Другими словами,
date1< date2тогда и только тогда, когдаdate1.toordinal() < date2.toordinal(). Сравнение даты вызывает исключениеTypeError, если один из объектов сравнения не является объектом даты.
Если один из объектов сравнения имеет атрибут timetuple(), то возвращается исключениеNotImplemented. Этот хук дает другим типам объектов даты возможность реализовать сравнение смешанного типа. В противном случае, когда объект даты сравнивается с объектом другого типа, то вызывается исключениеTypeError.
Если один из объектов сравнения имеет атрибут В логическом контексте все объекты даты считаются истинными.
Модуль datetime | Python 3 для начинающих и чайников
Модуль datetime предоставляет классы для обработки времени и даты разными способами. Поддерживается и стандартный способ представления времени, однако больший упор сделан на простоту манипулирования датой, временем и их частями.
Класс datetime.date(year, month, day) — стандартная дата. Атрибуты: year, month, day. Неизменяемый объект.
Класс datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None) — стандартное время, не зависит от даты. Атрибуты: hour, minute, second, microsecond, tzinfo.
Класс datetime.timedelta — разница между двумя моментами времени, с точностью до микросекунд.
Класс datetime.tzinfo — абстрактный базовый класс для информации о временной зоне (например, для учета часового пояса и / или летнего времени).
Класс datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None) — комбинация даты и времени.
Обязательные аргументы:
- datetime.MINYEAR (1) ≤ year ≤ datetime.MAXYEAR (9999)
- 1 ≤ month ≤ 12
- 1 ≤ day ≤ количество дней в данном месяце и году
Необязательные:
- 0 ≤ minute < 60
- 0 ≤ second < 60
- 0 ≤ microsecond < 1000000
Методы класса datetime:
datetime.today() — объект datetime из текущей даты и времени. Работает также, как и datetime.now() со значением tz=None.
datetime.fromtimestamp(timestamp) — дата из стандартного представления времени.
datetime.fromordinal(ordinal) — дата из числа, представляющего собой количество дней, прошедших с 01.
datetime.now(tz=None) — объект datetime из текущей даты и времени.
datetime.combine(date, time) — объект datetime из комбинации объектов date и time.
datetime.strptime(date_string, format) — преобразует строку в datetime (так же, как и функция strptime из модуля time).
datetime.strftime(format) — см. функцию strftime из модуля time.
datetime.date() — объект даты (с отсечением времени).
datetime.time() — объект времени (с отсечением даты).
datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) — возвращает новый объект datetime с изменёнными атрибутами.
datetime.timetuple() — возвращает struct_time из datetime.
datetime.toordinal() — количество дней, прошедших с 01.01.1970.
datetime.timestamp() — возвращает время в секундах с начала эпохи.
datetime.weekday() — день недели в виде числа, понедельник — 0, воскресенье — 6.
datetime.isoweekday() — день недели в виде числа, понедельник — 1, воскресенье — 7.
datetime.isocalendar() — кортеж (год в формате ISO, ISO номер недели, ISO день недели).
datetime.isoformat(sep=’T’) — красивая строка вида «YYYY-MM-DDTHH:MM:SS.mmmmmm» или, если microsecond == 0, «YYYY-MM-DDTHH:MM:SS»
datetime.ctime() — см. ctime() из модуля time.
Пример работы с классом datetime:
>>> from datetime import datetime, date, time
>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now() or datetime.utcnow()
>>> datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043) # GMT +1
>>> datetime.utcnow()
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime. datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:
... print(it)
...
2006 # year
11 # month
21 # day
16 # hour
30 # minute
0 # second
1 # weekday (0 = Monday)
325 # number of days since 1st January
-1 # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:
... print(it)
...
2006 # ISO year
47 # ISO week
2 # ISO weekday
>>> # Formatting datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>
Свежее
- Модуль csv — чтение и запись CSV файлов
- Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
- Онлайн-обучение Python: сравнение популярных программ
Категории
- Книги о Python
- GUI (графический интерфейс пользователя)
- Курсы Python
- Модули
- Новости мира Python
- NumPy
- Обработка данных
- Основы программирования
- Примеры программ
- Типы данных в Python
- Видео
- Python для Web
- Работа для Python-программистов
Полезные материалы
- Сделай свой вклад в развитие сайта!
- Самоучитель Python
- Карта сайта
- Отзывы на книги по Python
- Реклама на сайте
Мы в соцсетях
Работа с датой и временем в Python
Python содержит несколько инструментов, которые разработчик может использовать для работы с датой и временем.
В данном разделе статье мы рассмотрим модули datetime и time. Мы изучим принципы их работы и способы их применения. Начнем с модуля datetime.
Модуль datetime
Мы изучим следующие классы модуля:
- datetime.date
- datetime.timedelta
- datetime.datetime
Благодаря этим классам мы в будущем сможем работать с большей частью случаев, в которых нам понадобятся объекты date и datetime. Также существует класс tzinfo, который применяется для работы с часовыми поясами. Для дополнительной информации об этом классе вы можете обратиться к документации Python.
datetime.date
Python может представлять даты различными способами. Для начала, рассмотрим формат datetime.date, так как это один из самых простых объектов date.
Python
print( datetime.date(2012, 13, 14) )
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
builtins.
print( datetime.date(2012, 13, 14) )
Traceback (most recent call last): File «<string>», line 1, in <fragment> builtins.ValueError: month must be in 1..12 |
Python
print(datetime.date(2012, 12, 14)) # datetime.date(2012, 12, 14)
print(datetime.date(2012, 12, 14)) # datetime.date(2012, 12, 14) |
В данном коде показано, как создать простой объект даты. Класс date принимает три аргумента: год, месяц и день. Если вы укажите неправильное значение, вы увидите ошибку ValueError, как в случае выше. В противном случае вы увидите, что объект
Python
import datetime
d = datetime.date(2012, 12, 14)
print(d.year) # 2012
print(d.day) # 14
print(d.
month) # 12
1 2 3 4 5 6 | import datetime d = datetime.date(2012, 12, 14)
print(d.year) # 2012 print(d.day) # 14 print(d.month) # 12 |
Здесь мы присваиваем объекту date переменную d. Теперь мы можем получить доступ к различным компонентам даты по названиям, таким как d.year или d.month. Давайте посмотрим, какой сейчас день:
Python
import datetime print(datetime.date.today()) # datetime.date(2017, 4, 5)
import datetime
print(datetime.date.today()) # datetime.date(2017, 4, 5) |
Это может быть полезно, когда вам нужно записать, какой сейчас день. Или, если вам нужно выполнить основанный на сегодняшней дате расчет. Мелочь, а приятно.
datetime.datetime
Объект datetime.
datetime содержит всю информацию объектов datetime.date плюс datetime.time. Давайте приведем несколько примеров, для лучшего понимания разницы между этим объектом, и объектом datetime.date.
Python
import datetime a = datetime.datetime(2017, 3, 5) print(a) # datetime.datetime(2017, 3, 5, 0, 0) b = datetime.datetime(2017, 3, 5, 12, 30, 10) print(b) # datetime.datetime(2017, 3, 5, 12, 30, 10) d = datetime.datetime(2017, 3, 5, 12, 30, 10) print(d.year) # 2017 print(d.second) # 10 print(d.hour) # 12
1 2 3 4 5 6 7 8 9 10 11 12 | import datetime
a = datetime.datetime(2017, 3, 5) print(a) # datetime.datetime(2017, 3, 5, 0, 0)
b = datetime.datetime(2017, 3, 5, 12, 30, 10) print(b) # datetime.datetime(2017, 3, 5, 12, 30, 10)
d = datetime. print(d.year) # 2017 print(d.second) # 10 print(d.hour) # 12 |
datetime(2017, 3, 5, 12, 30, 10)Мы видим, что datetime.datetime принимает несколько дополнительных аргументов: год, месяц, день, час, минута и секунда. Это также позволяет вам указывать информацию о микросекундах и часовом поясе. При работе с базами данных, данные типы объектов будут использоваться достаточно часто. Большую часть вашей работы, вам нужно будет конвертировать форматы date или datetime Python в форматы SQL datetime или timestamp. Обратите внимание на то, что today совместно с datetime.datetime использует два разных метода:
Python
import datetime a = datetime.datetime.today() print(a) # datetime.datetime(2017, 4, 5, 0, 16, 54, 989663) b = datetime.datetime.now() print(b) # datetime.datetime(2017, 4, 5, 0, 17, 8, 24239)
1 2 3 4 5 6 7 | import datetime
a = datetime. print(a) # datetime.datetime(2017, 4, 5, 0, 16, 54, 989663)
b = datetime.datetime.now() print(b) # datetime.datetime(2017, 4, 5, 0, 17, 8, 24239) |
datetime.today()Модуль datetime содержит другой метод, под названием strftime. Этот метод позволяет разработчику создавать строку, отображающую время в более понятной для человека форме. Существует целая таблица параметров форматирования, с которой рекомендуется ознакомиться в документации Python, в секции 8.1.7. Давайте взглянем на несколько примеров, показывающих всю полезность данного метода:
Python
import datetime a = datetime.datetime.today().strftime(«%Y%m%d») print(a) # ‘20170405’ today = datetime.datetime.today() print( today.strftime(«%m/%d/%Y») ) # ’04/05/2017′ print( today.strftime(«%Y-%m-%d-%H.%M.%S») ) # 2017-04-05-00.18.00
1 2 3 4 5 6 7 8 9 | import datetime
a = datetime. print(a) # ‘20170405’
today = datetime.datetime.today() print( today.strftime(«%m/%d/%Y») ) # ’04/05/2017′
print( today.strftime(«%Y-%m-%d-%H.%M.%S») ) # 2017-04-05-00.18.00 |
datetime.today().strftime(«%Y%m%d»)Первый пример – это скорее хитрость. В нем показано, как конвертировать сегодняшний объект datetime в строку, следующую за форматом YYYYMMDD (ГГГГММДД). Второй пример более наглядный.
Есть вопросы по Python?
На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!
Python Форум Помощи
Telegram Чат & Канал
Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!
Паблик VK
Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!
Подписаться
В нем мы присваиваем объект datetime переменной под названием today и применяем два разных параметра форматирования строки.
Первый параметр добавляет косые черточки между элементами datetime, а также перегруппировывает datetime, теперь он делится на месяц, день и год. В последнем примере мы создаем временную отметку, которая следует типичному формату: YYYY-MM-DD.HH.MM.SS. Если вам нужно указать год как двухзначный (“YY”), вы можете заменить %Y на %y.
datetime.timedelta
Объект datetime.timedelta отображает длительность времени. Другими словами, это разница между двумя датами или временными отметками. Давайте взглянем на наглядный пример:
Python
import datetime # Значение: datetime.datetime(2017, 4, 5, 0, 18, 51, 980187) now = datetime.datetime.now() then = datetime.datetime(2017, 2, 26) # Кол-во времени между датами. delta = now — then print(delta.days) # 38 print(delta.seconds) # 1131
1 2 3 4 5 6 7 8 9 10 11 12 | import datetime
# Значение: datetime. now = datetime.datetime.now()
then = datetime.datetime(2017, 2, 26)
# Кол-во времени между датами. delta = now — then
print(delta.days) # 38 print(delta.seconds) # 1131 |
datetime(2017, 4, 5, 0, 18, 51, 980187)Мы создали два объекта datetime. Один указывает на сегодняшний день, второй – на прошедшую неделю. После этого, мы берем разницу между ними. Это возвращает объект timedelta, который мы можем далее использовать, чтобы выяснить, сколько прошло дней или секунд, между этими двумя датами. Если вам нужно узнать количество часов или минут между двумя датами, вам понадобится немножко математики, чтобы выяснить это. Давайте взглянем на проверенный способ:
Python
seconds = delta.total_seconds() hours = seconds // 3600 print(hours) # 186.0 minutes = (seconds % 3600) // 60 print(minutes) # 13.0
1 2 3 4 5 6 7 | seconds = delta. hours = seconds // 3600
print(hours) # 186.0
minutes = (seconds % 3600) // 60 print(minutes) # 13.0 |
total_seconds()Отсюда мы узнаем, что в неделе 186 часов и 13 минут. Обратите внимание на то, что мы используем двойную косую черту в качестве нашего оператора деления, также известного как floor division. Теперь мы готовы к тому, чтобы узнать больше о модуле time Python.
Модуль time
Модуль time открывает разработчику Python доступ к нескольким связанным со временем функциям. Модуль основан на «эпохе», точке, с которой начинается время. Для систем Unix, эпоха началась в 1970 году. Чтобы узнать, какая эпоха в вашей системе, попробуйте запустить следующий код:
Python
import time print(time.gmtime(0))
import time print(time.gmtime(0)) |
Результат
Python
time.
struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=\
0, tm_wday=3, tm_yday=1, tm_isdst=0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=\ 0, tm_wday=3, tm_yday=1, tm_isdst=0) |
Я запустил его на Windows 7, которая также уверена в том, что начало времен датируется 1970м годом. В любом случае, в данном разделе мы ознакомимся со следующими функциями:
- time.ctime
- time.sleep
- time.strftime
- time.time
Приступим!
time.ctime
Функция time.ctime конвертирует время в секунды, начиная с эпохи, в строку, показывающую местное время. Если вы ничего не передадите данной функции, то настоящее время вернется обратно. Давайте взглянем на несколько примеров:
Python
import time
print(time.ctime()) # ‘Wed Apr 5 00:02:49 2017’
print(time.
ctime(1384112639)) # ‘Sun Nov 10 13:43:59 2013’
import time print(time.ctime()) # ‘Wed Apr 5 00:02:49 2017’
print(time.ctime(1384112639)) # ‘Sun Nov 10 13:43:59 2013’ |
В данном коде мы показали результаты вызова функции time.ctime, как со случайным набором секунд, начиная с эпохи, так и с пустным значением. Это можно применить, к примеру, в том случае, кода кому-нибудь нужно сохранить дату в секундах, начиная с эпохи, после чего конвертировать это в более удабриваемый формат. Немного проще, сохранить большое целое число (или длинное) в базу данных, чем страдать над ним, форматируя объект datetime в какой-либо объект даты, который принимает база данных. Конечно, это также имеет свой недостаток: вам, возможно, нужно будет преобразовать целое число или значение с плавающей запятой обратно в строку.
time.sleep
Функция time.sleep дает разработчику возможность приостановить выполнение его скрипта на определенное количество секунд.
Это можно сравнить с добавлением функции «Пауза» в вашу программу. Я нашел этот класс особенно полезным, когда мне нужно было подождать несколько секунд, пока закроется файл, или база данных закончит выполнять свою задачу. Давайте взглянем на пример. Откройте новое окно в IDLE и сохраните следующий код:
Python
import time for x in range(5): time.sleep(2) print(«Slept for 2 seconds»)
import time
for x in range(5): time.sleep(2) print(«Slept for 2 seconds») |
Теперь запустите этот код в IDLE. Сделав это, вы увидите фразу «Slept for 2 seconds» пять раз, с интервалом в 2 секунды между каждым сообщением. Это очень легко в использовании!
time.strftime
Модуль time имеет функцию strftime, которая работает по схожему с версией datetime принципу. Разница заключается, главным образом, в том, что именно она принимает для ввода: кортеж, или объект struct_time, вроде тех, которые возвращаются после вызова time.
gmtime() или time.localtime(). Вот небольшой пример:
Python
import time a = time.strftime(«%Y-%m-%d-%H.%M.%S», time.localtime()) print(a) # ‘2017-04-05-00.11.20’
import time
a = time.strftime(«%Y-%m-%d-%H.%M.%S», time.localtime()) print(a) # ‘2017-04-05-00.11.20’ |
Этот код очень похож на код временной отметки, который мы создавали в разделе datetime. На мой взгляд, метод datetime более интуитивен при создании объекта datetime.datetime а затем при вызове его метода strftime в том формате, который вам более удобен. С модулем time, вам нужно передать формат и кортеж времени. На самом деле выбор за вами, каким именно способом вам будет удобнее решить вашу задачу.
time.time
Функция time.time отображает время в секундах, начиная с эпохи, как число с плавающей запятой.
Давайте взглянем:
Python
import time x = time.time() print(x) # 1491340367.478385
import time
x = time.time() print(x) # 1491340367.478385 |
Весьма просто. Вы можете использовать данную функцию, когда вам нужно сохранить настоящее время в базу данных, но вам не нужно конвертировать его в метод datetime вашей базы данных. Вы можете вспомнить о том, что метод ctime принимает время в секундах, так что мы можем использовать time.time для получения количества секунд для передачи их ctime, вот так:
Python
import time a = time.ctime(time.time()) print(a) # Wed Apr 5 00:13:47 2017
import time
a = time.ctime(time.time()) print(a) # Wed Apr 5 00:13:47 2017 |
Если вы обратитесь к документации, чтобы узнать больше о модуле time, или если вы хотите немного поэкспериментировать, вы найдете несколько способов использования данной функции.
Подведем итоги
С этого момента вы готовы работать с датой и временем в стандартных модулях Python. Работая в Python, вы получаете широкий спектр возможностей при работе с датами. Вы найдете данные модули полезными, особенно при разработке приложения, которое отслеживает встречи, или должно срабатывать в определенные дни. Также они весьма полезны при работе с базами данных.
Vasile Buldumac
Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.
E-mail: [email protected]
Образование
Universitatea Tehnică a Moldovei (utm.md)
- 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
- 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»
Модуль datetime
Модуль datetime предоставляет классы для обработки времени и даты разными способами.
Поддерживается и стандартный способ представления времени, однако больший упор сделан на простоту манипулирования датой, временем и их частями.
Классы, предоставляемые модулем datetime:
datetime.date(year, month, day)
стандартная дата. Атрибуты: year, month, day. Неизменяемый объект.
import datetime d = datetime.date(2012, 12, 14) print(d.year) # 2012 print(d.day) # 14 print(d.month) # 12
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
содержит всю информацию объектов datetime.date плюс datetime.time.
import datetime a = datetime.datetime(2017, 3, 5) print(a) # datetime.datetime(2017, 3, 5, 0, 0) b = datetime.datetime(2017, 3, 5, 12, 30, 10) print(b) # datetime.datetime(2017, 3, 5, 12, 30, 10) d = datetime.datetime(2017, 3, 5, 12, 30, 10) print(d.year) # 2017 print(d.second) # 10 print(d.hour) # 12
datetime.datetime принимает несколько дополнительных аргументов: год, месяц, день, час, минута и секунда. Это также позволяет вам указывать информацию о микросекундах и часовом поясе.
datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
стандартное время, не зависит от даты. Атрибуты: hour, minute, second, microsecond, tzinfo.
datetime.timedelta
описывает определенный период во времени, который находится между двумя различными моментами
| Атрибут | Значение |
|---|---|
| days | Между −999999999 and 999999999 включительно |
| seconds | Между 0 и 86399 включительно |
| microseconds | Между 0 и 999999 включительно |
Поддерживаемые операции
| Операция | Результат |
|---|---|
| t1 = t2 + t3 | Суммирует дельту между датами |
| t1 = t2 — t3 | Разница дельт между датами |
| t1 = t2 * i or t1 = i * t2 | Умножение дельты на целое число |
| t1 = t2 * f or t1 = f * t2 | Дельта умножается на число с плавающей точкой |
| f = t2 / t3 | Деление общей длительности t2 на интервал t3. Возвращает объект с плавающей точкой |
| t1 = t2 / f or t1 = t2 / i | Дельта делится на число с плавающей точкой или целое |
| t1 = t2 % t3 | Остаток часть вычисляется как объект timedelta |
| q, r = divmod(t1, t2) | Вычисляет частное и остаток: q = t1 // t2 (3) и r = t1% t2. q — целое число, а r — объект deltatime |
| +t1 | Возвращает объект timedelta с полностью идентичным значением t1 |
| —t1 | возвращает объект timedelta с полностью противоположным значением t1 |
| abs(t) | возвращает объект timedelta с положительным значением всех свойств t |
| str(t) | возвращает строковое представление объекта a в формате, заданном по умолчанию |
| repr(t) | возвращает строковое представление объекта a в формате с отрицательными значениями |
timedelta.
total_seconds()Возвращает общее количество секунд, содержащихся в продолжительности. Эквивалентно (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10 * 6)/10 * 6 рассчитано с включенным истинным делением. Пример:
>>> from datetime import timedelta >>> year = timedelta(days=365) >>> another_year = timedelta(weeks=40, days=84, hours=23, ... minutes=50, seconds=600) # adds up to 365 days >>> year.total_seconds() 31536000.0 >>> year == another_year True >>> ten_years = 10 * year >>> ten_years, ten_years.days // 365 (datetime.timedelta(days=3650), 10) >>> nine_years = ten_years - year >>> nine_years, nine_years.days // 365 (datetime.timedelta(days=3285), 9) >>> three_years = nine_years // 3 >>> three_years, three_years.days // 365 (datetime.timedelta(days=1095), 3) >>> abs(three_years - ten_years) == 2 * three_years + year True
datetime.
tzinfoабстрактный базовый класс для информации о временной зоне (например, для учета часового пояса и/или летнего времени).
Методы класса datetime:
datetime.combine(date, time)
объект datetime из комбинации объектов date и time.
datetime.fromtimestamp(timestamp)
дата из стандартного представления времени.
datetime.fromordinal(ordinal)
дата из числа, представляющего собой количество дней, прошедших с 01.01.1970.
datetime.now(tz=None)
объект datetime из текущей даты и времени.
datetime.today()
объект datetime из текущей даты и времени. Работает также, как и datetime.now() со значением tz=None.
datetime.strptime(date_string, format)
преобразует строку в datetime по формату
| Формат | Значение |
|---|---|
| %a | Сокращенное название дня недели |
| %A | Полное название дня недели |
| %b | Сокращенное название месяца |
| %B | Полное название месяца |
| %c | Дата и время |
| %d | День месяца [01,31] |
| %H | Час (24-часовой формат) [00,23] |
| %I | Час (12-часовой формат) [01,12] |
| %j | День года [001,366] |
| %m | Номер месяца [01,12] |
| %M | Число минут [00,59] |
| %p | До полудня или после (при 12-часовом формате) |
| %S | Число секунд [00,61] |
| %U | Номер недели в году (нулевая неделя начинается с воскресенья) [00,53] |
| %w | Номер дня недели [0(Sunday),6] |
| %W | Номер недели в году (нулевая неделя начинается с понедельника) [00,53] |
| %x | Дата |
| %X | Время |
| %y | Год без века [00,99] |
| %Y | Год с веком |
| %Z | Временная зона |
| %% | Знак ‘%’ |
datetime.
strftime(format)преобразует datetime в строку по формату
| Формат | Значение |
|---|---|
| %a | Сокращенное название дня недели |
| %A | Полное название дня недели |
| %b | Сокращенное название месяца |
| %B | Полное название месяца |
| %c | Дата и время |
| %d | День месяца [01,31] |
| %H | Час (24-часовой формат) [00,23] |
| %I | Час (12-часовой формат) [01,12] |
| %j | День года [001,366] |
| %m | Номер месяца [01,12] |
| %M | Число минут [00,59] |
| %p | До полудня или после (при 12-часовом формате) |
| %S | Число секунд [00,61] |
| %U | Номер недели в году (нулевая неделя начинается с воскресенья) [00,53] |
| %w | Номер дня недели [0(Sunday),6] |
| %W | Номер недели в году (нулевая неделя начинается с понедельника) [00,53] |
| %x | Дата |
| %X | Время |
| %y | Год без века [00,99] |
| %Y | Год с веком |
| %Z | Временная зона |
| %% | Знак ‘%’ |
datetime.
date()объект даты (с отсечением времени).
datetime.isoweekday()
день недели в виде числа, понедельник — 1, воскресенье — 7.
datetime.isocalendar()
кортеж (год в формате ISO, ISO номер недели, ISO день недели).
datetime.isoformat(sep=’T’)
красивая строка вида «YYYY-MM-DDTHH:MM:SS.mmmmmm» или, если microsecond == 0, «YYYY-MM-DDTHH:MM:SS»
datetime.replace ([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
возвращает новый объект datetime с изменёнными атрибутами.
datetime.time()
объект времени (с отсечением даты).
datetime.timetuple()
возвращает struct_time из datetime.
datetime.timestamp()
возвращает время в секундах с начала эпохи.
datetime.toordinal()
количество дней, прошедших с 01.01.1970.
datetime.weekday()
день недели в виде числа, понедельник — 0, воскресенье — 6.
Поддерживаемые операции:
| Операция | Результат |
|---|---|
| datetime2 = datetime1 + timedelta | Прибавляет к дате указанный период |
| datetime2 = datetime1 — timedelta | Вычитает из даты указанный период |
| timedelta = datetime1 — datetime2 | Возвращает разницу между двумя датами |
| datetime1 < datetime2 | Сравнивает дату и время(3) |
Модуль datetime в Python OTUS
Статья посвящена работе с модулем datetime, который используется в языке программирования Python для определения даты и времени. В рамках изучения модуля будут рассмотрены классы Python date, Python time и Python timedelta.
Получение текущего времени и даты в Python
Сначала напишем пару простейших программ на Python.
В коде выше модуль datetime импортирован посредством import datetime, а одним из классов, который определен в модуле datetime, является одноименный класс datetime. Далее используется метод now, который создает в Python объект datetime. Этот объект содержит локальное время и дату на текущий момент (на момент отработки кода).
Выполнив этот код на Python, мы получим в выводе текущие дату и время. Это будет выглядеть приблизительно следующим образом:
2021-01-26 13:13:56.780540
Получаем только дату в Python. Работа с датой
Внеся небольшие изменения в код на Python, можно получить только дату (date).
Теперь для получения объекта date был задействован метод today, который определен в классе date. Это позволило получить объект date и отобразить локальную дату на момент запуска программы.
В итоге результат отображения даты в Python изменится:
2021-01-26
Так как вы будете запускать этот код в другие дни (days), результат будет отличаться.
Что внутри datetime?У модуля datetime есть атрибуты: time, timezone, tzinfo, timedelta и многие другие. Количество доступных атрибутов довольно велико, поэтому, чтобы увидеть все возможные данные (data), можно воспользоваться функцией dir:
Приблизительный вывод в Python:
На практике в Python чаще всего используют следующие классы модуля datetime:
- time,
- date,
- datetime,
- timedelta.
Объект date позволяет работать с датой:
import datetime
a = datetime.date(2021, 1, 26)
print(a)
То есть вывод даты будет соответствовать тому, что вы пропишете в коде:
2021-01-26
Здесь date — конструктор класса date. Этот конструктор принимает 3 аргумента: год, месяц, день. Также присутствует переменная a — объект date.
Если надо получит текущую дату, используем уже знакомый метод today.
from datetime import date
today = date.today()
print("Какая сегодня дата:", today)
Вывод на момент проверки:
Какая сегодня дата: 2021-01-26
Также существует возможность создавать объекты date, используя метку времени — timestamp. Этот термин используется при обозначении времени POSIX — подразумевается число секунд, которые прошли с 00:00:00 UTC 1.01.1970 г. Для преобразования метки времени в дату в Python используют метод fromtimestamp.
Из объекта date можно без проблем получить текущие значения дня, года, месяца:
from datetime import date
today = date. today()
print("Какой сейчас год:", today.year)
print("Какой сейчас месяц:", today.month)
print("Какой сегодня день:", today.day)
А вот и результат:
Класс timeЭкземпляр класса time отвечает за время, куда входит широкий спектр данных (data): и часы, и минуты, и секунды, и даже микросекунды.
Давайте опять передадим любые атрибуты, но чуть изменим код.
from datetime import time
a = time(11, 34, 56)
print("часы =", a.hour)
print("минуты =", a.minute)
print("секунды =", a.second)
print("микросекунды =", a.microsecond)
Следует обратить внимание, что аргумент microsecond передан не был. В результате было присвоение дефолтное значение, равное нулю.
Класс datetimeВключает в себя информацию и о дате, и о времени.
Первые 3 аргумента обязательны для конструктора datetime — это year, month и day. Значения, которые отсутствуют, заполняются нулями.
Дополнительно можно прописать вывод метки времени:
Если же нужны значения текущего момента времени, получить его можно как посредством метода now, так и посредством метода today. В примере ниже задействован и now, и today:
Класс timedeltaОбъект, называемый timedelta, позволяет получить разницу между 2-мя моментами времени. Вот, как это работает:
Приведем еще один пример с time delta:
Выше были созданы 2 timedelta-объекта — t1 и t2. Их разница и была выведена на экран.
Если нужна более подробная информация о timedeltas , лучше всего заглянуть в официальную документацию.
ФорматДаты (dates), как и времена (times), могут быть представлены в разных странах по-разному. В США чаще применяют формат «MM/DD/YYYY» (months, days, years), в Соединенном Королевстве — «DD/MM/YYYY» (days, months, years). В языке программирования Python для работы с форматами существуют специальные методы: strftime и strptime.
Метод strftime определяется в классах time, date и datetime. Он позволит создать форматированную строку на основе заданного объекта.
Давайте отформатируем дату посредством strftime:
Если же надо преобразовать строку в объект datetime, используют уже strptime.
Обработка часового поясаПредставим, что мы работаем над проектом, в котором надо обеспечить отображение даты и времени с учетом от часового пояса пользователей. Получить нужные данные (data) и обработать часовой пояс можно самостоятельно, но лучше всего воспользоваться готовым модулем pytZ.
Что здесь что: datetime_NY и datetime_London представляют собой объекты datetime, которые содержат текущее время и дату соответствующего часового пояса. Как видите, ничего сложного.
Хотите получить самые новые знания про Python? Добро пожаловать на наши курсы!
Источник: https://pythonist. ru/rabota-s-datoj-i-vremenem-modul-datetime/.
Работа с датой и временем: модуль datetime
В этой статье мы разберемся, как работать с датой и временем в Python при помощи модуля datetime. И для начала давайте напишем несколько простых программ, связанных с датой и временем.
Пример 1: Получение текущей даты и времени.
import datetime datetime_object = datetime.datetime.now() print(datetime_object)
Когда вы запустите программу, результат будет примерно таким:
2020-06-29 20:30:33.139533
В этом примере мы импортировали модуль datetime с помощью оператора import datetime.
Одним из классов, определенных в модуле datetime, является класс datetime. После импортирования модуля мы использовали метод now() для создания объекта datetime, содержащего текущие локальные дату и время.
Пример 2: Получение текущей даты.
import datetime date_object = datetime.date.today() print(date_object)
Когда вы запустите программу, результат будет примерно таким:
2020-06-29
В этой программе мы использовали метод today(), определенный в классе date, чтобы получить объект date, содержащий текущую локальную дату.
Что находится внутри datetime?
Мы можем использовать функцию dir() для получения списка, содержащего все атрибуты модуля datetime.
import datetime print(dir(datetime))
Когда вы запустите программу, вывод будет следующим:
['MAXYEAR', 'MINYEAR', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'date', 'datetime', 'datetime_CAPI', 'sys', 'time', 'timedelta', 'timezone', 'tzinfo']
Наиболее часто используемыми классами в модуле datetime являются:
datetimedatetimetimedelta
Класс datetime.
dateОбъект date представляет дату (год, месяц и день).
Пример 3: объект date для представления даты.
import datetime d = datetime.date(2020, 6, 29) print(d)
Когда вы запустите программу, вывод будет следующим:
2020-06-29
В приведенном выше примере date() является конструктором класса date. Конструктор принимает три аргумента: год, месяц и день.
Переменная d — это объект date.
Вы можете создавать объекты класса date, предварительно импортировав модуль datetime, а можете импортировать только класс date из модуля datetime. Вот как это делается:
from datetime import date a = date(2020, 6, 29) print(a) # 2020-06-29
Пример 4: Получение текущей даты.
Для получения информации о текущей дате можно воспользоваться методом today().
from datetime import date
today = date.today()
print("Current date =", today)Когда вы запустите программу, вывод будет следующим:
Current date = 2020-06-29
Пример 5: получение даты из метки времени (timestamp).
Мы также можем создавать объекты date из метки времени (timestamp). Термин timestamp употребляется для обозначения POSIX-времени — количества секунд, прошедшего с 00:00:00 UTC 1 января, 1970 года. Вы можете преобразовать метку времени в дату при помощи метода fromtimestamp().
from datetime import date timestamp = date.
Когда вы запустите программу, вывод будет следующим:
Date = 2012-01-11
Пример 6: вывод текущего года, месяца и дня.
Мы легко можем получить год, месяц, день, день недели и т. д. из объекта date. Вот как это делается:
from datetime import date
today = date.today()
print("Current year:", today.year)
print("Current month:", today.month)
print("Current day:", today.day)Когда вы запустите программу, результат будет примерно таким:
Current year: 2020
Current month: 6
Current day: 29
Класс datetime.time
Экземпляр класса time представляет собой время (часы, минуты, секунды и микросекунды).
Пример 7: объект time для представления времени.
from datetime import time
# time(hour = 0, minute = 0, second = 0)
a = time()
print("a =", a)
# time(hour, minute and second)
b = time(11, 34, 56)
print("b =", b)
# time(hour, minute and second)
c = time(hour = 11, minute = 34, second = 56)
print("c =", c)
# time(hour, minute, second, microsecond)
d = time(11, 34, 56, 234566)
print("d =", d)Когда вы запустите программу, вывод будет следующим:
a = 00:00:00
b = 11:34:56
c = 11:34:56
d = 11:34:56.234566
Пример 8: вывод часов, минут, секунд и микросекунд.
После того как вы создадите объект time, вы можете легко получить его атрибуты, такие как часы, минуты и т. д.
from datetime import time
a = time(11, 34, 56)
print("hour =", a.hour)
print("minute =", a.minute)
print("second =", a.second)
print("microsecond =", a.microsecond)Когда вы запустите программу, вывод будет следующим:
hour = 11
minute = 34
second = 56
microsecond = 0
Обратите внимание, что мы не передали аргумент microsecond. Следовательно, его значение по умолчанию будет равно 0.
Класс datetime.datetime
Экземпляр класса datetime содержит информацию как о дате, так и о времени.
Пример 9: объект datetime.
from datetime import datetime #datetime(year, month, day) a = datetime(2018, 11, 28) print(a) # datetime(year, month, day, hour, minute, second, microsecond) b = datetime(2017, 11, 28, 23, 55, 59, 342380) print(b)
Когда вы запустите программу, вывод будет следующим:
2018-11-28 00:00:00
2017-11-28 23:55:59. 342380
Первые три аргумента year, month и day в конструкторе datetime() являются обязательными. Отсутствующие данные будут заполнены нулями по умолчанию.
Пример 10: вывод года, месяца, часа, минуты и метки времени.
from datetime import datetime
a = datetime(2017, 11, 28, 23, 55, 59, 342380)
print("year =", a.year)
print("month =", a.month)
print("hour =", a.hour)
print("minute =", a.minute)
print("timestamp =", a.timestamp())Когда вы запустите программу, вывод будет следующим:
year = 2017
month = 11
day = 28
hour = 23
minute = 55
timestamp = 1511913359.34238
Пример 11: получение текущего момента времени.
Мы можем получить информацию о текущем моменте времени не только с помощью уже упомянутого метода now(), но и с помощью today().
from datetime import datetime date = datetime.today() print(date) date = datetime.now() print(date)
Когда вы запустите программу, результат будет примерно таким:
2020-06-29 20:35:33.353184
2020-06-29 20:35:33.356184
Класс datetime.timedelta
Объект timedelta представляет разницу между двумя моментами времени.
Пример 12: разница между двумя моментами времени.
from datetime import datetime, date
t1 = date(year = 2018, month = 7, day = 12)
t2 = date(year = 2017, month = 12, day = 23)
t3 = t1 - t2
print("t3 =", t3)
t4 = datetime(year = 2018, month = 7, day = 12, hour = 7, minute = 9, second = 33)
t5 = datetime(year = 2019, month = 6, day = 10, hour = 5, minute = 55, second = 13)
t6 = t4 - t5
print("t6 =", t6)
print("type of t3 =", type(t3))
print("type of t6 =", type(t6)) Когда вы запустите программу, вывод будет следующим:
t3 = 201 days, 0:00:00
t6 = -333 days, 1:14:20
type of t3 = <class 'datetime. timedelta'>
type of t6 = <class 'datetime.timedelta'>
Обратите внимание, что и t3, и t6 имеют тип <class 'datetime.timedelta'>.
Пример 13: разница между двумя объектами timedelta.
from datetime import timedelta
t1 = timedelta(weeks = 2, days = 5, hours = 1, seconds = 33)
t2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)
t3 = t1 - t2
print("t3 =", t3)Когда вы запустите программу, вывод будет следующим:
t3 = 14 days, 13:55:39
Здесь мы создали два объекта timedelta — t1 и t2, и их разница выводится на экран.
Пример 14: отрицательный объект timedelta.
from datetime import timedelta
t1 = timedelta(seconds = 33)
t2 = timedelta(seconds = 54)
t3 = t1 - t2
print("t3 =", t3)
print("t3 =", abs(t3))Когда вы запустите программу, вывод будет следующим:
t3 = -1 day, 23:59:39
t3 = 0:00:21
Пример 15: интервал времени в секундах.
Вы можете получить общее количество секунд объекта timedelta, используя метод total_seconds().
from datetime import timedelta
t = timedelta(days = 5, hours = 1, seconds = 33, microseconds = 233423)
print("total seconds =", t.total_seconds())Когда вы запустите программу, вывод будет следующим:
total seconds = 435633.233423
Вы также можете найти сумму двух моментов времени, используя оператор +. Кроме того, вы можете умножить и разделить объект timedelta на целые числа и числа с плавающей точкой.
Больше информации о timedelta вы можете найти в документации.
Формат datetime
Представление даты и времени может отличатся в разных странах, организациях и т. д. В США, например, чаще всего используется формат «мм/дд/гггг», тогда как в Великобритании более распространен формат «дд/мм/гггг».
В Python для работы с форматами есть методы strftime() и strptime().
Python strftime() — преобразование объекта datetime в строку
Метод strftime() определен в классах date, datetime и time. Он создает форматированную строку из заданного объекта date, datetime или time.
Пример 16: форматирование даты с использованием метода strftime().
from datetime import datetime
now = datetime.now()
t = now.strftime("%H:%M:%S")
print("time:", t)
s1 = now.strftime("%m/%d/%Y, %H:%M:%S")
# mm/dd/YY H:M:S format
print("s1:", s1)
s2 = now.strftime("%d/%m/%Y, %H:%M:%S")
# dd/mm/YY H:M:S format
print("s2:", s2)Когда вы запустите программу, результат будет примерно таким:
time: 20:43:57
s1: 06/29/2020, 20:43:57
s2: 29/06/2020, 20:43:57
Здесь %Y, %m, %d, %H и т. д. — коды для определения формата. Метод strftime() принимает один или несколько кодов и возвращает отформатированную строку на его основе.
В приведенной выше программе переменные t, s1 и s2 являются строками.
Основные коды для определения формата:
%Y— год [0001, …, 2018, 2019, …, 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, 59]
Чтобы узнать больше о методе strftime() и кодах форматирования, перейдите по ссылке.
Python strptime()- преобразование строки в объект datetime
Метод strptime() создает объект datetime из заданной строки (представляющей дату и время).
Пример 17: метод strptime().
from datetime import datetime
date_string = "21 June, 2018"
print("date_string =", date_string)
date_object = datetime. strptime(date_string, "%d %B, %Y")
print("date_object =", date_object)Когда вы запустите программу, вывод будет следующим:
date_string = 21 June, 2018
date_object = 2018-06-21 00:00:00
Метод strptime() принимает два аргумента:
- строка, представляющая дату и время.
- формат, определяющий, каким образом части даты и времени расположены в переданной строке.
Кстати, коды %d, %B и %Y используются для обозначения дня, месяца (название месяца в полном виде) и года соответственно.
Перейдите по ссылке чтобы узнать больше о методе strptime().
Обработка часового пояса в Python
Предположим, вы работаете над проектом и должны отображать дату и время в зависимости от часового пояса пользователей. Вместо того, чтобы пытаться обрабатывать часовой пояс самостоятельно, мы предлагаем вам использовать модуль pytZ.
from datetime import datetime import pytz local = datetime.
Когда вы запустите программу, результат будет примерно таким:
Local: 06/29/2020, 00:16:45
NY: 06/28/2020, 17:17:00
London: 06/28/2020, 22:17:00
Здесь datetime_NY и datetime_London — это объекты datetime, содержащие текущую дату и время соответствующего часового пояса.
Английский для программистов
Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас
Скачать
×
Даты Python
❮ Предыдущая Далее ❯
Даты Python
Дата в Python не является собственным типом данных, но мы можем импортировать модуль
named datetime для работы с датами как с датами
объекты.
Пример
Импорт модуля datetime и отображение текущей даты:
import datetime
x = datetime.datetime.now()
print(x)
Попробуйте сами »
Вывод даты
Когда мы выполним код из приведенного выше примера, результатом будет:
Дата содержит год, месяц, день, час, минуту, секунду и микросекунду.
Модуль datetime имеет множество методов для возврата информации о дате
объект.
Вот несколько примеров, вы узнаете о них позже в этом глава:
Пример
Вернуть год и название дня недели:
import datetime
x = datetime.datetime.now()
print(x.year)
print(x.strftime(«%A»))
Попробуйте сами »
Создание объектов даты
Чтобы создать дату, мы можем использовать класс datetime() (конструктор) класса модуль даты и времени .
Класс datetime() требует три параметра для создания даты: год,
день месяца.
Пример
Создать объект даты:
import datetime
x = datetime.datetime(2020, 5, 17)
print(x)
Попробуйте сами »
datetime() 9Класс 0009 также принимает параметры для времени и часового пояса (час,
минута, секунда, микросекунда, tzone), но они являются необязательными и имеют значение по умолчанию.
значение 0 , ( Нет для часового пояса).
Метод strftime()
Объект datetime имеет метод для форматирования объектов даты в читаемые строки.
Метод называется strftime() и принимает один параметр, формат , чтобы указать формат возвращаемой строки:
Пример
Показать название месяца:
import datetime
x = datetime. datetime(2018, 6, 1)
print(x.strftime("%B"))
Попробуйте сами »
Ссылка на все коды юридических форматов:
| Директива | Описание | Пример | Попробуй |
|---|---|---|---|
| %а | Будний день, короткая версия | Ср | Попробуй » |
| %А | Будний день, полная версия | Среда | Попробуй » |
| % вес | День недели в виде числа 0-6, 0 — воскресенье | 3 | Попробуй » |
| %д | День месяца 01-31 | 31 | Попробуй » |
| %b | Название месяца, короткая версия | декабрь | Попробуй » |
| %В | Название месяца, полная версия | декабря | Попробуй » |
| %м | Месяц в виде числа 01-12 | 12 | Попробуй » |
| %г | Год, короткая версия, без века | 18 | Попробуй » |
| %Y | Год, полная версия | 2018 | Попробуй » |
| %H | Час 00-23 | 17 | Попробуй » |
| %I | Час 00-12 | 05 | Попробуй » |
| %р | утра/вечера | PM | Попробуй » |
| %М | Минута 00-59 | 41 | Попробуй » |
| %S | Второй 00-59 | 08 | Попробуй » |
| %f | Микросекунда 000000-999999 | 548513 | Попробуй » |
| %z | Смещение UTC | +0100 | |
| %Z | Часовой пояс | КСТ | |
| %j | Номер дня года 001-366 | 365 | Попробуй » |
| %U | Номер недели в году, воскресенье как первый день недели, 00-53 | 52 | Попробуй » |
| %W | Номер недели в году, понедельник как первый день недели, 00-53 | 52 | Попробуй » |
| %с | Локальная версия даты и времени | Пн Дек 31 17:41:00 2018 | Попробуй » |
| %С | Век | 20 | Попробуй » |
| %х | Локальная версия даты | 31. 12.18 | Попробуй » |
| %Х | Локальная версия времени | 17:41:00 | Попробуй » |
| %% | Символ % | % | Попробуй » |
| %G | ИСО 8601 год | 2018 | Попробуй » |
| %u | ISO 8601 рабочий день (1-7) | 1 | Попробуй » |
| %В | Номер недели ISO 8601 (01-53) | 01 | Попробуй » |
❮ Предыдущий Следующий ❯
NEW
Мы только что запустили
Видео W3Schools
Узнать
ВЫБОР ЦВЕТА
КОД ИГРЫ
Играть в игру
Top Tutorials
Учебное пособие по HTMLУчебное пособие по CSS
Учебное пособие по JavaScript
Учебное пособие
Учебное пособие по SQL
Учебное пособие по Python
Учебное пособие по W3.
CSS Учебное пособие по Bootstrap
Учебное пособие по PHP
Учебное пособие по Java
Учебное пособие по C++
Учебное пособие по jQuery
9003 900
Справочник по HTML
Справочник по CSS
Справочник по JavaScript
Справочник по SQL
Справочник по Python
Справочник по W3.CSS
Справочник по Bootstrap
Справочник по PHP
Цвета HTML
Справочник по Java
Справочник по Angular
Справочник по jQuery
Основные примеры
Примеры HTMLПримеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery
ФОРУМ | О
W3Schools оптимизирован для обучения и обучения. Примеры могут быть упрощены для улучшения чтения и обучения.
Учебники, ссылки и примеры постоянно пересматриваются, чтобы избежать ошибок, но мы не можем гарантировать полную правильность всего содержания. Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования,
куки-файлы и политика конфиденциальности.
Copyright 1999-2022 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.
Модуль Python datetime — GeeksforGeeks
В Python дата и время не являются самостоятельным типом данных, но модуль с именем datetime может быть импортирован для работы с датой так же, как и со временем. Модуль Python Datetime встроен в Python, поэтому нет необходимости устанавливать его извне.
Модуль Python Datetime предоставляет классы для работы с датой и временем. Эти классы предоставляют ряд функций для работы с датами, временем и временными интервалами. Дата и дата-время являются объектами в Python, поэтому, когда вы манипулируете ими, вы на самом деле манипулируете объектами, а не строками или временными метками.
Модуль DateTime подразделяется на 6 основных классов —
- дата — идеализированная наивная дата, предполагающая, что текущий григорианский календарь всегда был и всегда будет действовать. Его атрибутами являются год, месяц и день.
- время – Идеализированное время, не зависящее от какого-либо конкретного дня, при условии, что в каждом дне ровно 24*60*60 секунд. Его атрибутами являются часы, минуты, секунды, микросекунды и tzinfo.
- дата-время - Это комбинация даты и времени, а также атрибутов год, месяц, день, час, минута, секунда, микросекунда и tzinfo.
- timedelta — Продолжительность, выражающая разницу между двумя экземплярами даты, времени или даты и времени с разрешением в микросекундах.
- tzinfo — Предоставляет объекты с информацией о часовом поясе.
- часовой пояс — класс, который реализует абстрактный базовый класс tzinfo как фиксированное смещение от UTC (Новое в версии 3.2).
Класс даты
Класс даты используется для создания объектов даты в Python. Когда создается экземпляр объекта этого класса, он представляет дату в формате ГГГГ-ММ-ДД. Конструктору этого класса нужны три обязательных аргумента: год, месяц и дата.
Синтаксис конструктора:
class datetime.date(year, month, day)
Аргументы должны быть в следующем диапазоне –
- MINYEAR <= year <= MAXYEAR
- 1 <= месяц <= 12
- 1 <= день <= количество дней в данном месяце и году
Примечание . Если аргумент не является целым числом, он вызовет ошибку типа, а если он находится за пределами диапазон будет поднят ValueError.
Пример 1: Объект даты, представляющий дату, в Python
Python3
|
Вывод:
Дата, переданная в качестве аргумента: 1996-12-112 Трассировка: Файл "/home/ccabfb570d9bd1dcd11dc4fe55fd6ba2.py", строка 14, в моя_дата = дата (1996, 12, 39) ValueError: день выходит за пределы допустимого диапазона для месяца Traceback (последний последний вызов): Файл "/home/53b974e10651f1853eee3c004b48c481.py", строка 18, в my_date = дата('1996', 12, 11) TypeError: требуется целое число (получен тип str)
Пример 2: Получить текущую дату
Для возврата текущей локальной даты используется функция today() класса date. Функция today() имеет несколько атрибутов (год, месяц и день). Их можно распечатать по отдельности.
Python3
|
Вывод
Сегодняшняя дата 2021-08-19Месяц, Год 3:Получить 3:011 Примеры0012
Мы можем получить атрибуты года, месяца и даты из объекта даты, используя атрибут года, месяца и даты класса даты.
Python3
Текущий год: 2021 Текущий месяц: 8 Текущий день: 19 Пример 4: Получить дату из метки времениМы можем создать объекты даты из метки времени y=используя метод fromtimestamp(). Временная метка — это количество секунд с 1 января 19 года.70 по UTC до определенной даты. Python3
Вывод Дата и время из метки времени: 2029-10-25 16:17:48 Пример 5: Преобразование даты в строку Мы можем преобразовать объект даты в строковое представление, используя две функции isoformat() и strftime(). Python3
Выход Представление строки 2021-08-19 Список методов класса Date
Класс времениКласс времени создает объект времени, который представляет местное время независимо от дня недели. Синтаксис конструктора:
Все аргументы являются необязательными. tzinfo может быть None, в противном случае все атрибуты должны быть целыми числами в следующем диапазоне –
Example 1: Time object representing time in PythonPython3
Вывод: Время с одним аргументом 00:12:00
Время без аргумента 00:00:00 После создания объекта времени его атрибуты также можно распечатать отдельно. Вывод: Мы можем преобразовать объект времени в строку, используя метод isoformat(). |
8 8 7980479 Класс DateTime содержит информацию как о дате, так и о времени. Подобно объекту даты, datetime предполагает текущий григорианский календарь, расширенный в обоих направлениях; как и объект времени, datetime предполагает, что в каждом дне ровно 3600*24 секунды. Синтаксис конструктора: class datetime. Аргументы года, месяца и дня являются обязательными. tzinfo может быть None, остальные атрибуты должны быть целыми числами в следующем диапазоне – Output: После создания объекта DateTime его атрибуты также можно распечатать отдельно. Выход: Вы можете напечатать текущую дату и время, используя функцию Datetime.now(). Функция now() возвращает текущую локальную дату и время. Выход: Выход Класс Python timedelta используется для вычисления разницы в датах, а также может использоваться для манипуляций с датами в Python. Это один из самых простых способов выполнения манипуляций с датами. Синтаксис конструктора: класс datetime. Выход: : . Разницу в дате и времени также можно найти с помощью этого класса. Вывод: Форматирование даты и времени может быть очень необходимо, так как представление даты может отличаться от места к месту. Например, в некоторых странах это может быть гггг-мм-дд, а в другой стране это может быть дд-мм-гггг. Для форматирования Python Datetime можно использовать функции strptime и strftime. Метод strftime() преобразует заданную дату, время или объект даты и времени в строковое представление заданного формата. Вывод Примечание: Для получения дополнительной информации см. метод strftime(). strptime() создает объект datetime из заданной строки. Выход Часовые пояса в DateTime можно использовать в том случае, когда требуется отображать время в соответствии с часовым поясом определенного региона. Output Тип Тип Тип данных A MySQL преобразует В MySQL 8.0.19 и более поздних версиях вы можете указать смещение часового пояса
при вставке Неверный В MySQL 8.0.22 и более поздних версиях вы можете конвертировать Для получения полной информации о синтаксисе и дополнительных
примеры смотрите в описании Помните об определенных свойствах интерпретации значения даты в
MySQL: MySQL допускает «расслабленный» формат для значений
указывается как строка, в которой любой знак пунктуации может
использоваться в качестве разделителя между частями даты или частями времени.
В некоторых случаях этот синтаксис может быть обманчивым. Например,
значение, такое как Единственный разделитель, распознаваемый между частью даты и времени
а доля секунды - десятичная точка. Сервер требует, чтобы значения месяца и дня были действительными, и
не только в диапазоне от 1 до 12 и от 1 до 31 соответственно.
При отключенном строгом режиме недопустимые даты, такие как MySQL не принимает значения Даты, содержащие двузначные значения года, неоднозначны, потому что
век неизвестен. MySQL интерпретирует двузначные значения года
используя эти правила: См. также Раздел 11.2.8, «Двузначное обозначение года в дате». Иногда работа с данными, содержащими дату и время, может быть утомительной работой, к счастью, есть встроенный способ помочь нам в работе. Python предоставляет модуль datetime , который позволяет нам разными способами манипулировать датой и временем. Нам нужно рассмотреть пять основных классов объектов в этом модуле, которые нам в конечном итоге потребуются в зависимости от работы, которую мы хотим выполнять. Поскольку datetime включает в себя, позволяет нам иметь дело как с датой, так и со временем, поэтому сначала давайте посмотрим, как ведет себя этот объект. datetime является как модулем, так и классом внутри этого модуля. Мы импортируем класс datetime из модуля datetime и распечатаем текущую дату и время, чтобы рассмотреть их поближе. # получить сегодняшнюю дату тогда мы можем написать: Итак, мы видим сверху, что сегодня действительно объект datetime класса datetime. Из приведенного выше примера мы можем понять, как следует дата и время объекты работают. дата будет работать только с датами, исключая время и время будет работать наоборот. # чтобы получить час из даты и времени # чтобы получить минуты из даты и времени Из datetime мы также можем получить день недели, используя его . weekday() функция как число. Представление строки: 12:24:36.001212
List of Time class Methods
Function Name Description dst() Returns tzinfo. dst() is tzinfo is not None fromisoformat () Возвращает объект времени из строкового представления времени isoformat() Возвращает строковое представление времени из объекта времени replace() Изменяет значение объекта времени с заданным параметром strftime() Возвращает строковое представление времени в заданном формате tzinfo.tzname() означает, что tzinfo не равно None utcoffset() Возвращает tzinfo.utcffsets(), если tzinfo не равно None Класс Datetime
datetime(год, месяц, день, час=0, минута=0, секунда=0, микросекунда=0, tzinfo=None, *, fold=0)
Пример 1. Объект DateTime, представляющий DateTime в Python
Python3
из datetime import datetime a = datetime( 1999 , 12 , 12 ) print (a ) A = DateTime ( 1999 , 12 , 12 , 12 , 12 , 12 , 12 , 12 , 0009 12 , 12 , 342380 ) print (a) 1999-12-12 00:00: 00
1999-12-12 12:12:12.
342380 Пример 2. Получение года, месяца, часа, минуты и метки времени
Python3
from datetime import datetime a = datetime( 1999 , 12 , 12 , 12 , 12 , 12 ) Печать ( "Год =" , A.year) Печать () .0009 "Месяц =" , A. Month) Печать ( "час =" , A.Hour) Печать ( "Минут =" , A.Minute) Печать ( "TimeStamp =" , A.TimestAmp ()) 1 год = 1999 год = 1999 год = 1999 год = 1999 год = 1999 год.
месяц = 12
час = 12
минута = 12
метка времени =
Пример 3: Текущая дата и время
Python3
from datetime import datetime today = datetime. now() print ( " Текущая дата и время:" , сегодня) Текущая дата и время-2019-10-25 11: 12: 11,289834
Пример 4: Конверт Python DateTime To STRING 9002
. строку в Python, используя методы datetime.strftime и datetime.isoformat.
Python3
из datetime импорт datetime as dt now = dt.now() string = dt.isoformat(now) print (string) print ( тип (строка)) 2021-08-19T18:13:25.
346259
Список методов класса Datetime
Имя функции Описание astimezone() Возвращает объект DateTime, содержащий информацию о часовом поясе. comb() Объединяет объекты даты и времени и возвращает объект DateTime ctime() Возвращает строковое представление даты и времени объект из изоформата() Возвращает объект даты и времени из строкового представления даты и времени fromordinal() Возвращает объект даты из пролептического григорианского порядкового номера, где 1 января года 1 имеет порядковый номер 1. Часы, минуты, секунды , и микросекунды равны 0 fromtimestamp() Возвращает дату и время из временной метки POSIX isocalendar() Возвращает год, неделю и день недели в кортеже 9 9 00121 isoformat() Возвращает строковое представление даты и времени isoweekday() Возвращает день недели в виде целого числа, где понедельник равен 1, а воскресенье равно 7 now()2 9012 Возвращает текущий локальная дата и время с параметром tz replace() Изменяет определенные атрибуты объекта DateTime strftime() Возвращает строковое представление объекта DateTime в заданном формате strptime() Returns a DateTime object corresponding to the date string time() Return the Time class object timetuple() Returns an object of type time. struct_time timetz() Вернуть объект класса Time Today() Вернуть локальную DateTime с tzinfo как None года 1 имеет порядковый номер 1 tzname() Returns the name of the timezone utcfromtimestamp() Return UTC from POSIX timestamp utcoffset() Returns the UTC offset utcnow() Возвращает текущую дату и время UTC weekday() Возвращает день недели в виде целого числа, где понедельник равен 0, а воскресенье равно 6 Класс Timedelta
timedelta(дни=0, секунды=0, микросекунды=0, миллисекунды=0, минуты=0, часы=0, недели=0)
Возвращает: Дата Пример 1. Добавление дней к объекту datetime
Python3
from datetime import datetime, timedelta ini_time_for_now = datetime.now() print ( "initial_date " , str (ini_time_for_now)) future_date_after_2yrs = ini_time_for_now ini_time_for_now0009 + timedelta(days = 730 ) future_date_after_2days = ini_time_for_now + timedelta(days = 2 ) печать ( 'future_date_after_2yrs:' , str (future_date_after_2yrs)) ( 'future_date_after_2days:' , STR (Future_Date_after_2Days)) 198
future_date_after_2yrs: 2021-10-24 12:01:01.227848
future_date_after_2days: 2019-10-27 12:01:01.227848 Пример 2: Разница между двумя датами и временем
Python3
from datetime import datetime, timedelta ini_time_for_now = datetime.now() print ( "initial_date " , str (ini_time_for_now)) new_final_time = 8 ini_time_09 +
8
8
0009 \ timedelta(days = 2 ) print ( "new_final_time" , str (new_final_time)) Печать ( 'Разница во времени:' , Str (New_final_time - ini_time_for_now)) initial_date 2019-10-25 12:02:32.
799814
new_final_time 27.10.2019 12:02:32.799814
Разница во времени: 2 дня, 0:00:00 Операции, поддерживаемые TimeDelta Class
Оператор Описание Дострой (-) Subtracts and returns two timedelta objects Multiplication (*) Multiplies timedelta object with float or int Division (/) Divides the timedelta object with float or int Floor division ( //) Делит объект timedelta на число с плавающей запятой или int и возвращает значение int нижнего предела вывода Модуль (%) Делит два объекта timedelta и возвращает остаток +(timedelta) Returns the same timedelta object -(timedelta) Returns the resultant of -1*timedelta abs(timedelta) Returns the +(timedelta) if timedelta. days > 1=0 else возвращает -(timedelta) str(timedelta) Возвращает строку в формате (+/-) day[s], HH:MM:SS.UUUUUU repr(timedelta) Возвращает строковое представление в виде вызова конструктора Формат даты и времени
Python Datetime strftime
Пример: Формат даты и времени Python
Python3
from datetime import datetime as dt now = dt. now() print ( "Без форматирования" , теперь) S = Now.strftime ( " %A %M %-y" ) " %M %-y" ) "0015 Печать ( '\ nexample 1:' , S) S = Сейчас. Печать ( '\ Nexample 2:' , S) S = сейчас. печать ( '\nПример 3:' , S) S = теперь. :' , s) Без форматирования 2021-08-19 18:16:25.881661
Пример 1: Четверг, 08 2021 г.
Пример 2: Чт 8 21
Пример 3: 6 вечера 25
Пример 4: 18:16:25
Python DateTime strptime
Example: DateTime strptime
Python3
from datetime import datetime time_data = [ "25/05/99 02 :35:8.023" , "26/05/99 12:45:0.003" , "27/05/99 07:35:5. 523" , "28/05/99 05:15:55.523" ] format_data = «%d/%m/%y%h:%m:%s.%f» для I в Time_data: 9000 ( datetime.strptime(i, format_data)) 1999-05-25 02:35:08.023000
1999-05-26 12:45:00.003000
1999-05-27 07:35:05.523000
1999-05-28 05:15:55.523000
Обработка часового пояса Python DateTime
Это можно сделать с помощью модуля pytz Python. Этот модуль выполняет функции преобразования даты и времени и помогает пользователям обслуживать международные клиентские базы. Python3
from datetime import datetime from pytz import timezone format = "%Y- %m-%d%h:%m:%s%z%z " Now_UTC = DateTime.Now (Timezone ( 'UTC' )) (now_utc.strftime( format )) timezones = [ 'Asia/Kolkata' , 'Europe/Kiev' , ' America/new_york ' ] для Tzone в часовые пояса: Теперь_ас - now_utc. astimezone(timezone(tzone)) print (now_asia.strftime( format )) 2021-08-19 18 :27:28 UTC+0000
2021-08-19 23:57:28 IST+0530
2021-08-19 21:27:28 Восточное восточное время +0300
2021-08-19 14:27:28 EDT-0400
11.2.2 Типы DATE, DATETIME и TIMESTAMP
11.2.2 Типы DATE, DATETIME и TIMESTAMP
DATE , DATETIME и TIMESTAMP типы связаны между собой. Эта секция
описывает их характеристики, чем они похожи и чем
они отличаются. MySQL распознает DATE , DATETIME и TIMESTAMP значения в нескольких форматах, описанных в
Раздел 9.1.3, «Литералы даты и времени». Для ДАТА и ДАТАВРЕМЯ диапазон
описания, «поддерживается» означает, что хотя
более ранние значения могут работать, нет никакой гарантии. DATE используется для значений с датой
часть, но не часть времени. MySQL извлекает и отображает ДАТА значения в ' формат. Поддерживаемый диапазон: ГГГГ-ММ-ДД ' '1000-01-01' на '9999-12-31' . DATETIME используется для значений, которые
содержат как дату, так и время. MySQL извлекает и отображает DATETIME значений в ' . Поддерживаемый диапазон ГГГГ-ММ-ДД
формат чч:мм:сс ' '1000-01-01 00:00:00' от до '9999-12-31
23:59:59' . TIMESTAMP используется для значений
которые содержат как дату, так и время. TIMESTAMP имеет диапазон '1970-01-01
00:00:01' UTC до '2038-01-19
03:14:07' 900:09 по всемирному координированному времени. DATETIME или TIMESTAMP значение может включать завершающую часть доли секунды до
микросекунды (6 цифр) точность. В частности, любое дробное
часть значения, вставленного в DATETIME или Столбец TIMESTAMP сохраняется, а не
отброшен. С включенной дробной частью формат для
эти значения ' ,
диапазон значений ГГГГ-ММ-ДД
чч:мм:сс [. дробь ]' DATETIME составляет '1000-01-01 00:00:00.000000' до '9999-12-31 23:59:59.999999' и диапазон
для TIMESTAMP значение равно '1970-01-01
00:00:01.000000' от до '2038-01-19
03:14:07.999999' . Дробная часть всегда должна быть
отделяется от остального времени десятичной точкой; нет другого
распознается разделитель долей секунды. Для информации
о поддержке дробных секунд в MySQL см.
Раздел 11.2.6, «Доли секунд в значениях времени». TIMESTAMP и DATETIME типы данных предлагают автоматическую инициализацию и обновление до
текущая дата и время. Для получения дополнительной информации см.
Раздел 11.2.5, «Автоматическая инициализация и обновление для TIMESTAMP и DATETIME». значений TIMESTAMP из
текущего часового пояса в UTC для хранения и обратно из UTC в
текущий часовой пояс для поиска. (это не происходит для других
типа DATETIME .) По умолчанию
текущим часовым поясом для каждого соединения является время сервера.
часовой пояс может быть установлен для каждого соединения отдельно. Пока
настройка часового пояса остается неизменной, вы получаете то же значение
вы храните. Если вы сохраните значение TIMESTAMP ,
а затем измените часовой пояс и получите значение,
полученное значение отличается от значения, которое вы сохранили. Этот
происходит потому, что тот же часовой пояс не использовался для преобразования в
оба направления. Текущий часовой пояс доступен как значение
из часовой пояс система
переменная. Для получения дополнительной информации см.
Раздел 5.1.15, «Поддержка часовых поясов MySQL Server». TIMESTAMP или Значение DATETIME в таблицу. Видеть
Раздел 9.1.3, «Литералы даты и времени», для получения дополнительной информации.
и примеры. ДАТА , ДАТАВРЕМЯ или Значения TIMESTAMP преобразуются в
«нулевое» значение соответствующего типа
( '0000-00-00' или '0000-00-00
00:00:00' ), если режим SQL позволяет это преобразование.
Точное поведение зависит от того, какой из строгих режимов SQL
и режим SQL NO_ZERO_DATE включены; см. раздел 5.1.11, «Режимы SQL сервера». ВРЕМЕННАЯ МЕТКА значений в UTC DATETIME значений при получении их с помощью CAST() с ВО ВРЕМЯ
Оператор ZONE , как показано здесь: mysql> ВЫБЕРИТЕ столбец,
> CAST(col AT TIME ZONE INTERVAL '+00:00' AS DATETIME) AS ut
> ИЗ ЗАКАЗА ПО ИДЕНТИФИКАТОРу;
+------------------------------------+-------+
| кол | ут |
+------------------------------------+-------+
| 2020-01-01 10:10:10 | 2020-01-01 15:10:10 |
| 2019-12-31 23:40:10 | 2020-01-01 04:40:10 |
| 2020-01-01 13:10:10 | 2020-01-01 18:10:10 |
| 2020-01-01 10:10:10 | 2020-01-01 15:10:10 |
| 2020-01-01 04:40:10 | 2020-01-01 09:40:10 |
| 2020-01-01 18:10:10 | 2020-01-01 23:10:10 |
+--------------------------------------------------+-------+ Функция CAST() . '10:11:12' может выглядеть как
значение времени из-за : , но
интерпретируется как год '2010-11-12' , если
используется в контексте даты. Значение '10:45:15' преобразуется в '0000-00-00' потому что '45' не является действительным месяцем. '2004-04-31' преобразуются в '0000-00-00' и генерируется предупреждение.
При включенном строгом режиме неверные даты вызывают ошибку.
Чтобы разрешить такие даты, включите РАЗРЕШЕННЫЕ_НЕДОПУСТИМЫЕ_ДАТЫ . Видеть
Раздел 5.1.11, «Режимы SQL сервера», для получения дополнительной информации. TIMESTAMP которые включают ноль в столбце дня или месяца или значениях
которые не являются допустимой датой. Единственное исключение из этого правила
это специальное «нулевое» значение '0000-00-00 00:00:00' , если режим SQL
позволяет это значение. Точное поведение зависит от того, что если
любой из строгого режима SQL и NO_ZERO_DATE Режим SQL
включено; см. раздел 5.1.11, «Режимы SQL сервера». Основные операции DateTime в Python | by Munia Humaira
Photo by Brooke Lark on Unsplash После этого мы обсудим несколько примеров, поясняющих задачи занятий. Классы следующие - 9 Мы можем сделать это, используя datetime Функция .now(). Мы напечатаем наш объект datetime . # импортировать класс datetime из модуля datetime
.
from datetime import datetime print('Type :- ',type(today)) dt_nw = datetime.now()
print('Hour: ', dt_nw.hour)
print('Minute: ', dt_nw.minute) Но мы можем преобразовать это в текстовый формат (т. е. понедельник, вторник, среда…) с помощью модуля календаря и метода с именем 9.0478 .day_name()
Сначала мы импортируем модуль календаря , а затем узнаем, что такое месяц и год, и проделаем вышеупомянутые операции.
# импорт модуля календаря
импорт календаряmy_date= datetime.now()
# Чтобы получить месяц из даты
print('Month: ', my_date.month)# Чтобы получить месяц из года
print('Year: ', my_date.year)# Чтобы получить день месяца
print('Day of Month:', my_date.day)# чтобы получить название дня (числом) из даты
print('День недели (число): ', my_date.weekday())# чтобы получить название дня из даты
print('День недели ( name): ', calendar.day_name[my_date.weekday()])
Теперь нам нужно понять два типа объектов datetime ;
- Осведомленный — Осведомленный объект обладает знаниями, необходимыми для работы с неоднозначным временем. Он содержит информацию о часовом поясе и летнем времени, чтобы он мог определить свое местоположение относительно других осведомленных объектов.
- Простой — с ним проще работать. Потому что он не содержит информации о разных часовых поясах и переходе на летнее время. Операция просто зависит от программы.
Для программ, которым требуются осведомленные объекты, объекты datetime , date и time имеют необязательный атрибут информации о часовом поясе, tzinfo . Но tzinfo — это абстрактный класс. Имея дело с этим, вы должны решить, какие именно методы необходимы. Потому что это полностью зависит от использования осознанных дата-время объектов.
Но управление часовыми поясами упрощается благодаря модулю pytz . Это помогает нам справляться с преобразованиями между часовыми поясами и обрабатывает летнее время в местах, где это используется. Давайте рассмотрим пример:
# импорт часового пояса из модуля pytz
из pytz import timezone# создание часового пояса UTC
utc = timezone('UTC')# локализация даты и времени
loc = utc.localize(datetime(2020) , 1, 1, 3, 50, 0))
print(loc)# Преобразование локализованных даты и времени в часовой пояс Азии/Дакки
dhaka = timezone("Asia/Dhaka")
print(loc.astimezone(dhaka))# Преобразование локализованных даты и времени в часовой пояс Европы/Берлина
berlin = timezone('Europe/Berlin')
print(loc.astimezone(berlin))
Мы использовали функцию localize() для добавления часового пояса к объекту datetime . Функция astimezone() преобразует существующий местный часовой пояс в любой другой указанный часовой пояс.
Иногда в программе нам может понадобиться указать оставшееся время или промежуток времени. В этом случае мы всегда можем использовать объектов timedelta . Мы можем использовать это, чтобы манипулировать датами или временем, добавляя и вычитая из них. Давайте рассмотрим несколько примеров:
#import timedelta
from datetime import timedelta
print(timedelta(дни= 365, часы= 12, минуты= 30))
# получить текущее время
now = datetime.now()
print ("Сегодняшняя дата и время: ", ул(сейчас))# добавить 365 дней к текущей дате
future_date_after_one_year = now + timedelta(days = 365)
print('Дата и время через год: ', future_date_after_one_year)#вычесть 7 дней из текущей даты
seven_days_ago = now - timedelta( days = 7)
print('Дата и время семь дней назад: ', seven_days_ago)
# print('seven_days_ago тип объекта: ', type(seven_days_ago))
Вот как мы можем работать с объектами timedelta . В большинстве научных скриптов/кейсов дельта всегда означает разницу между двумя вещами.
datetime включает два метода, strptime() и strftime() , для преобразования объектов из строк в объекты datetime и наоборот. strptime() может считывать строки с информацией о дате и времени и преобразовывать их в объекты datetime, а strftime() преобразует объекты datetime обратно в строки.
# импорт даты и времени
из даты и времени импорт даты и времениdate_str = "2 января, 2020"
# формат даты 9# текущая дата и время
now = datetime.now()# время в формате ЧЧ:ММ:СС
time = now.strftime("%H:%M:%S")
print("Time:", time)# формат даты
date_time = now.strftime("%m/%d/%Y, %H:%M:%S")
print("Дата и время:",date_time)
При работе с данные, очень часто приходится иметь дело с метками времени. Возможно, вы хотите хранить свои данные в формате временной метки Unix. Мы будем использовать datetime timestamp() для этого.
# получить текущую дату
now = datetime.now()# преобразовать текущую дату в метку времени , временная метка)
Аналогично, из временной метки мы можем преобразовать в объекты даты и времени.
timestamp = 1577971124.673931#convert timestamp to datetime object
date_obj = datetime.fromtimestamp(timestamp)print("Сегодняшняя дата и время:", date_obj)
Pandas является своего рода основным ингредиентом проектов по науке о данных в python, и это правильно. Это делает работу с датой и временем проще, чем любые другие методы.
Гораздо проще преобразовать текстовые строки даты и времени в объекты pandas Datetime, используя to_datetime() .
Эта функция достаточно хороша для преобразования строк в объекты даты и времени Python, автоматически определяя их форматы без необходимости определять их с помощью шаблонов strftime.
# импортировать модуль pandas
импортировать pandas как pd# создать объект даты с помощью функции to_datetime() операции, которые можно выполнять с помощью панд с данными о дате и времени. Но для этого нужен отдельный пост. Тем не менее, я надеюсь, что этот пост дает начальные представления об операциях, которые мы можем выполнять с модулем datetime и pandas.
Первоначально опубликовано на https://muniah.com 2 января 2020 г.
Использование Python datetime для работы с датами и временем — Real Python создан командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание:
Использование модуля Python datetimeРабота с датами и временем — одна из самых больших проблем в программировании. Имея дело с часовыми поясами, переходом на летнее время и различными письменными форматами даты, может быть сложно отслеживать, на какие дни и время вы ссылаетесь. К счастью, встроенный Python 9Модуль 0478
datetimeможет помочь вам управлять сложной природой дат и времени.Из этого руководства вы узнаете:
- Почему программирование с датами и временем так сложно
- Какие функции доступны в модуле Python
datetime - Как распечатать или прочитать дату и время в определенном формате
- Как сделать арифметику с датами и временем
Кроме того, вы разработаете аккуратное приложение для отсчета времени, оставшегося до следующего PyCon US!
Бесплатный бонус: Нажмите здесь, чтобы получить нашу бесплатную памятку по Python, которая покажет вам основы Python 3, такие как работа с типами данных, словарями, списками и функциями Python.
Начнем!
Программирование с датами и временем
Если вы когда-либо работали над программным обеспечением, которое должно было отслеживать время в нескольких географических областях, то вы, вероятно, понимаете, почему программирование со временем может быть такой проблемой. Фундаментальное несоответствие заключается в том, что компьютерные программы предпочитают совершенно упорядоченные и регулярные события, но то, как большинство людей используют время и ссылаются на него, крайне нерегулярно.
Примечание: Если вы хотите узнать больше о том, почему со временем так сложно иметь дело, то в Интернете доступно множество замечательных ресурсов. Вот несколько хороших мест для начала:
- Компьютерофил: проблема со временем и часовыми поясами
- Работа с часовыми поясами: все, что вам не нужно знать
- Сложность программирования временных данных
Одним из замечательных примеров такого отклонения является переход на летнее время 9. 0479 . В Соединенных Штатах и Канаде часы переводятся на один час вперед во второе воскресенье марта и на один час назад в первое воскресенье ноября. Однако так было только с 2007 года. До 2007 года часы переводились вперед в первое воскресенье апреля и переводились назад в последнее воскресенье октября.
Все становится еще сложнее, если учесть часовых поясов . В идеале границы часовых поясов должны точно соответствовать линиям долготы. Однако по историческим и политическим причинам линии часовых поясов редко бывают прямыми. Часто районы, разделенные большими расстояниями, оказываются в одном часовом поясе, а соседние районы — в разных часовых поясах. Есть несколько часовых поясов с довольно причудливыми формами.
Удаление рекламы
Как компьютеры считают время
Почти все компьютеры ведут отсчет времени с момента, называемого эпохой Unix . Это произошло 1 января 1970 года в 00:00:00 UTC. UTC означает Всемирное координированное время и относится ко времени на долготе 0°. UTC часто также называют средним временем по Гринвичу или GMT. Всемирное координированное время не корректируется с учетом перехода на летнее время, поэтому оно стабильно сохраняет двадцать четыре часа каждый день.
По определению, время Unix течет с той же скоростью, что и UTC, поэтому шаг в одну секунду в UTC соответствует шагу в одну секунду во времени Unix. Обычно вы можете определить дату и время в UTC любого момента с 1 января 19.70, подсчитав количество секунд с эпохи Unix, за исключением високосных секунд . Високосные секунды иногда добавляются к UTC для учета замедления вращения Земли, но не добавляются к времени Unix.
Примечание: Есть интересная ошибка, связанная со временем Unix. Поскольку многие старые операционные системы являются 32-разрядными, они хранят время Unix в виде 32-разрядного целого числа со знаком.
Это означает, что в 03:14:07 19 января 2038 года целое число переполнится, что приведет к так называемой проблеме 2038 года, или Y2038. Подобно проблеме Y2K, Y2038 необходимо будет исправить, чтобы избежать катастрофических последствий для критически важных систем.
Почти все языки программирования, включая Python, включают концепцию времени Unix. Стандартная библиотека Python включает модуль с именем time , который может печатать количество секунд, прошедших с эпохи Unix:
>>>
>>> время импорта >>> время.время() 1579718137.550164
В этом примере вы импортируете модуль time и выполняете time() для вывода времени Unix или количества секунд (исключая високосные секунды) с начала эпохи.
Помимо времени Unix, компьютерам нужен способ передачи информации о времени пользователям. Как вы видели в последнем примере, время Unix практически невозможно разобрать человеку. Вместо этого время Unix обычно преобразуется в UTC, которое затем может быть преобразовано в местное время с использованием смещения часового пояса .
Администрация адресного пространства Интернета (IANA) поддерживает базу данных всех значений смещения часовых поясов. IANA также выпускает регулярные обновления, включающие любые изменения смещения часовых поясов. Эта база данных часто входит в состав вашей операционной системы, хотя некоторые приложения могут включать обновленную копию.
База данных содержит копию всех назначенных часовых поясов и количество часов и минут, на которые они смещены от UTC. Таким образом, зимой, когда летнее время не действует, восточный часовой пояс США имеет смещение -05:00, или минус пять часов от UTC. Другие регионы имеют другие смещения, которые могут не быть целыми часами. Смещение UTC для Непала, например, составляет +05:45, или плюс пять часов и сорок пять минут от UTC.
Как сообщать стандартные даты
Время Unix — это то, как компьютеры считают время, но для людей было бы невероятно неэффективно определять время, вычисляя количество секунд из произвольной даты. Вместо этого мы работаем с годами, месяцами, днями и так далее. Но даже при наличии этих соглашений еще один уровень сложности возникает из-за того, что в разных языках и культурах используются разные способы написания даты.
Например, в Соединенных Штатах даты обычно пишутся, начиная с месяца, затем дня и года. Это означает, что 31 января 2020 года записывается как 31-01-2020 . Это точно соответствует полной письменной версии даты.
Однако в большинстве стран Европы и во многих других регионах дату записывают, начиная с числа, затем месяца и года. Это означает, что 31 января 2020 года записывается как 31-01-2020 . Эти различия могут вызвать разного рода путаницу при общении между культурами.
Во избежание ошибок при общении Международная организация по стандартизации (ISO) разработала стандарт ISO 8601 9.0479 . Этот стандарт указывает, что все даты должны быть записаны в порядке от наиболее значимых данных к наименее значимым. Это означает, что формат год, месяц, день, час, минута и секунда:
ГГГГ-ММ-ДД ЧЧ:ММ:СС
В этом примере ГГГГ представляет собой четырехзначный год, а ММ и ДД представляют собой двузначный месяц и день, начиная с нуля, если необходимо. После этого HH , MM и SS представляют собой двузначные часы, минуты и секунды, начиная с нуля, если необходимо.
Преимущество этого формата в том, что дата может быть представлена без двусмысленности. Даты, записанные как ДД-ММ-ГГГГ или ММ-ДД-ГГГГ , могут быть неверно истолкованы, если день является допустимым номером месяца. Чуть позже вы увидите, как можно использовать формат ISO 8601 с Python datetime .
Как время должно храниться в вашей программе
Большинство разработчиков, которые работали со временем, слышали совет конвертировать местное время в UTC и сохранять это значение для дальнейшего использования. Во многих случаях, особенно когда вы храните даты из прошлого, этой информации достаточно для выполнения любых необходимых арифметических действий.
Однако может возникнуть проблема, если пользователь вашей программы вводит будущую дату по своему местному времени. Часовой пояс и правила перехода на летнее время меняются довольно часто, как вы уже видели ранее, когда в 2007 году в США и Канаде было изменено летнее время. Если правила часового пояса для местоположения вашего пользователя изменятся до даты будущего, которую они ввели, то UTC не предоставит достаточно информации для обратного преобразования в правильное местное время.
Примечание: Существует ряд отличных ресурсов, которые помогут вам определить подходящий способ хранения данных о времени в вашем приложении. Вот несколько мест для начала:
- Летнее время и рекомендации по часовому поясу
- Хранение UTC не является серебряной пулей
- Как сохранить дату и время для будущих событий
- Рекомендации по кодированию с использованием DateTime в . NET Framework
В этом случае вам необходимо сохранить местное время, включая часовой пояс, который ввел пользователь, а также версию базы данных часовых поясов IANA, которая действовала, когда пользователь сохранил время. Таким образом, вы всегда сможете преобразовать местное время в UTC. Однако этот подход не всегда позволит вам преобразовать UTC в правильное местное время.
Удалить рекламу
Использование модуля Python
datetime Как видите, работа с датами и временем в программировании может быть сложной. К счастью, в наши дни вам редко приходится реализовывать сложные функции с нуля, поскольку вам может помочь множество библиотек с открытым исходным кодом. Это определенно относится к Python, который включает в себя три отдельных модуля в стандартной библиотеке для работы с датами и временем:
.-
календарьвыводит календари и предоставляет функции, использующие идеализированный григорианский календарь. -
datetimeпредоставляет классы для управления датами и временем. -
времяпредоставляет функции, связанные со временем, где даты не нужны.
В этом руководстве вы сосредоточитесь на использовании модуля Python datetime . Основная цель datetime — упростить доступ к атрибутам объекта, связанным с датами, временем и часовыми поясами. Поскольку эти предметы так полезны, 9Календарь 0008 также возвращает экземпляры классов из datetime .
time менее мощный и более сложный в использовании, чем datetime . Многие функции в time возвращают специальный экземпляр struct_time . Этот объект имеет интерфейс именованного кортежа для доступа к сохраненным данным, что делает его похожим на экземпляр datetime . Однако он не поддерживает все функции datetime , особенно возможность выполнять арифметические действия со значениями времени.
datetime предоставляет три класса, которые составляют высокоуровневый интерфейс, который будет использовать большинство людей:
-
datetime.date— это идеализированная дата, которая предполагает, что григорианский календарь бесконечно простирается в прошлое и будущее. Этот объект хранитгод,месяциденьв качестве атрибутов. -
datetime.time— это идеализированное время, которое предполагает, что в сутках 86 400 секунд без дополнительных секунд. Этот объект хранитчас,минут,секунд,микросекундиtzinfo(информация о часовом поясе). -
datetime.datetimeпредставляет собой комбинацию даты
Создание экземпляров Python
datetime Три класса, представляющие дату и время в datetime , имеют аналогичные инициализаторы . Их можно создать, передав аргументы ключевого слова для каждого из атрибутов, например год , дата или час . Вы можете попробовать код ниже, чтобы понять, как создается каждый объект:
>>>
>>> из даты и времени импорта дата, время, дата и время >>> дата (год = 2020, месяц = 1, день = 31) datetime.date(2020, 1, 31) >>> время (час=13, минута=14, секунда=31) дата и время. время (13, 14, 31) >>> datetime (год = 2020, месяц = 1, день = 31, час = 13, минута = 14, секунда = 31) datetime.datetime(2020, 1, 31, 13, 14, 31)
В этом коде вы импортируете три основных класса из datetime и , создаете экземпляры каждого из них, передавая аргументы конструктору. Вы можете видеть, что этот код несколько многословен, и если у вас нет необходимой информации в виде целых чисел, эти методы нельзя использовать для создания экземпляров datetime .
К счастью, datetime предоставляет несколько других удобных способов создания экземпляров datetime . Эти методы не требуют, чтобы вы использовали целые числа для указания каждого атрибута, но вместо этого позволяют вам использовать некоторую другую информацию:
-
date.today()создает экземплярdatetime.dateс текущей локальной датой. -
datetime.now()создает экземплярdatetime.datetimeс текущей локальной датой и временем. -
datetime.combine()объединяет экземплярыdatetime.dateиdatetime.timeв один экземплярdatetime.datetime.
Эти три способа создания 9Экземпляры 0008 datetime полезны, когда вы заранее не знаете, какую информацию вам нужно передать в базовые инициализаторы. Вы можете попробовать этот код, чтобы увидеть, как работают альтернативные инициализаторы:
>>>
>>> из даты и времени импорта дата, время, дата и время >>> сегодня = дата.
В этом коде вы используете date.today() , datetime.now() и datetime.combine() для создания экземпляров объектов date , datetime и time . Каждый экземпляр хранится в отдельной переменной:
-
today— экземплярdate, который содержит только год, месяц и день. -
now— это экземплярdatetime, который имеет год, месяц, день, час, минуту, секунду и микросекунды. -
current_time— это экземплярtime, в котором часы, минуты и секунды установлены на те же значения, что иnow.
В последней строке вы объединяете информацию о дате в today с информацией о времени в current_time для создания нового экземпляра datetime .
Предупреждение: datetime также предоставляет datetime.utcnow() , который возвращает экземпляр datetime в текущем UTC. Однако документация Python не рекомендует использовать этот метод, поскольку он не включает информацию о часовом поясе в результирующий экземпляр.
Использование datetime.utcnow() может привести к неожиданным результатам при выполнении арифметических операций или сравнений между экземплярами datetime . В следующем разделе вы увидите, как назначить информацию о часовом поясе экземплярам datetime .
Использование строк для создания Python
дата-время Экземпляры Другой способ создать экземпляров даты — использовать . . Чтобы использовать этот метод, вы предоставляете строку с датой в формате ISO 8601, о котором вы узнали ранее. Например, вы можете указать строку с указанием года, месяца и даты: fromisoformat()
2020-01-31
Эта строка представляет дату 31 января 2020 г. в соответствии с форматом ISO 8601. Вы можете создать экземпляр даты со следующим примером:
>>>
>>> с даты импорта даты и времени
>>> date.fromisoformat("2020-01-31")
datetime.date(2020, 1, 31)
В этом коде вы используете date.fromisoformat() для создания экземпляра date на 31 января 2020 года. Этот метод очень полезен, поскольку он основан на стандарте ISO 8601. Но что, если у вас есть строка, представляющая дату и время, но не в формате ISO 8601?
К счастью, Python datetime предоставляет метод .strptime() для обработки этой ситуации. Этот метод использует специальный мини-язык , чтобы сообщить Python, какие части строки связаны с атрибутами datetime .
Чтобы построить datetime из строки с помощью .strptime() , вы должны сообщить Python, что представляет каждая из частей строки, используя коды форматирования из мини-языка. Вы можете попробовать этот пример, чтобы увидеть, как .strptime() работ:
>>>
1>>> date_string = "31-01-2020 14:45:37" 2>>> format_string = "%m-%d-%Y %H:%M:%S"
В строке 1 вы создаете date_string , которая представляет дату и время 31 января 2020 г., 14:45:37. В строке 2 вы создаете format_string , который использует мини-язык, чтобы указать, как части date_string будут преобразованы в атрибуты datetime .
В format_string вы включаете несколько кодов форматирования и все дефисы ( - ), двоеточия ( : ) и пробелы точно так же, как они появляются в date_string . Чтобы обработать дату и время в date_string , вы включаете следующие коды форматирования:
| Компонент | Код | Значение |
|---|---|---|
| Год (четырехзначное целое) | %Y | 2020 |
| Месяц (десятичное число с нулями) | %м | 01 |
| Дата (десятичное число, дополненное нулями) | %д | 31 |
| Час (десятичное число с нулями и 24-часовым форматом) | %H | 14 |
| Минуты (десятичное число, дополненное нулями) | %М | 45 |
| Секунда (десятичное число с нулями) | %S | 37 |
Полный список всех параметров мини-языка выходит за рамки этого руководства, но вы можете найти несколько полезных ссылок в Интернете, в том числе в документации Python и на веб-сайте strftime. org.
Теперь, когда определены date_string и format_string , вы можете использовать их для создания экземпляра datetime . Вот пример того, как .strptime() работ:
>>>
3>>> из даты и времени импорта даты и времени 4>>> datetime.strptime(строка_даты, строка_формата) 5datetime.datetime(2020, 1, 31, 14, 45, 37)
В этом коде вы импортируете datetime в строку 3 и используете datetime.strptime() с date_string и format_string в строке 4 . Наконец, строка 5 показывает значения атрибутов в datetime 9Экземпляр 0009, созданный .strptime() . Вы можете видеть, что они соответствуют значениям, показанным в таблице выше.
Примечание: Существуют более сложные способы создания экземпляров datetime , но они включают использование сторонних библиотек, которые необходимо установить. Одна особенно удобная библиотека называется dateparser , которая позволяет вам предоставлять строковые входные данные на естественном языке. Ввод поддерживается даже на нескольких языках:
>>>
1>>> импортировать синтаксический анализатор даты
2>>> dateparser.parse("вчера")
3datetime.datetime(2020, 3, 13, 14, 39, 1, 350918)
4>>> dateparser.parse("морген")
5datetime.datetime(2020, 3, 15, 14, 39, 7, 314754)
В этом коде вы используете dateparser для создания двух экземпляров datetime путем передачи двух разных строковых представлений времени. В строке 1 вы импортируете dateparser . Затем в строке 2 вы используете .parse() с аргументом "вчера" для создания экземпляра datetime двадцать четыре часа назад. На момент написания это было 13 марта 2020 года, 14:39.
В строке 3 вы используете . с аргументом parse() "morgen" . Morgen — это немецкое слово, обозначающее завтра, поэтому dateparser создает экземпляр datetime через двадцать четыре часа в будущем. На момент написания это было 15 марта в 2:39.ВЕЧЕРА.
Удалить рекламу
Запуск обратного отсчета PyCon
Теперь у вас достаточно информации, чтобы начать работу над часами обратного отсчета для PyCon US в следующем году! PyCon US 2021 начнется 12 мая 2021 года в Питтсбурге, штат Пенсильвания. Поскольку мероприятие 2020 года было отменено, многие питонисты очень рады встрече в следующем году. Это отличный способ отслеживать, как долго вам придется ждать, и одновременно улучшать свои навыки datetime !
Для начала создайте файл с именем pyconcd.py и добавьте этот код:
# pyconcd.py из даты и времени импортировать дату и время PYCON_DATE = дата и время (год = 2021, месяц = 5, день = 12, час = 8) обратный отсчет = PYCON_DATE - datetime.
В этом коде вы импортируете datetime из datetime и определяете константу PYCON_DATE , в которой хранится дата следующего PyCon US. Вы не ожидаете, что дата PyCon изменится, поэтому вы называете переменную большими буквами, чтобы указать, что это константа.
Затем вы вычисляете разницу между datetime.now() , которое является текущим временем, и PYCON_DATE . Взяв разницу между двумя экземплярами datetime , вы получите экземпляр datetime.timedelta .
экземпляров timedelta представляют изменение во времени между двумя экземплярами datetime . Дельта в названии является отсылкой к греческой букве дельта, которая используется в науке и технике для обозначения изменения. Позже вы узнаете больше о том, как использовать timedelta для более общих арифметических операций.
Наконец, распечатанный вывод по состоянию на 9 апреля 2020 г., незадолго до 21:30:
.Обратный отсчет до PyCon US 2021: 397 дней, 10:35:32.139350
Всего 397 дней до PyCon US 2021! Этот вывод немного неуклюж, поэтому позже вы увидите, как можно улучшить форматирование. Если вы запустите этот скрипт в другой день, вы получите другой результат. Если вы запустите скрипт после 8:00 12 мая 2021 года, вы получите отрицательное количество оставшегося времени!
Работа с часовыми поясами
Как вы видели ранее, сохранение часового пояса, в котором происходит дата, является важным аспектом обеспечения правильности вашего кода. Python datetime предоставляет tzinfo , который является абстрактным базовым классом, который позволяет datetime.datetime и datetime.time включать информацию о часовом поясе, включая идею перехода на летнее время.
Однако datetime не обеспечивает прямого взаимодействия с базой данных часовых поясов IANA. Питон 9В документации 0008 datetime.tzinfo рекомендуется использовать сторонний пакет под названием dateutil . Вы можете установить dateutil с pip :
$ python -m pip установить python-dateutil
Обратите внимание, что имя пакета, который вы устанавливаете из PyPI, python-dateutil , отличается от имени, которое вы используете для импорта пакета, а именно dateutil .
Использование
dateutil для добавления часовых поясов в Python дата-время Одной из причин полезности dateutil является то, что он включает интерфейс к базе данных часовых поясов IANA. Это избавляет от необходимости назначать часовые пояса вашим экземплярам datetime . Попробуйте этот пример, чтобы увидеть, как установить экземпляр datetime для вашего местного часового пояса:
>>>
>>> from dateutil import tz >>> из даты и времени импортировать дату и время >>> сейчас = datetime.
В этом примере вы импортируете tz из dateutil и datetime из datetime . Затем вы создаете экземпляр datetime , установленный на текущее время, используя .now() .
Вы также передаете ключевое слово tz в .now() и устанавливаете tz равным tz.tzlocal() . В dateutil , tz.tzlocal() возвращает конкретный экземпляр datetime.tzinfo . Это означает, что он может представлять всю необходимую информацию о смещении часового пояса и переходе на летнее время, которая требуется datetime .
Вы также печатаете название часового пояса, используя .tzname() , который печатает 'Восточное стандартное время' . Это вывод для Windows, но в macOS или Linux ваш вывод может выглядеть как «EST» , если зимой вы находитесь в восточном часовом поясе США.
Вы также можете создать часовые пояса, которые не совпадают с часовым поясом, указанным на вашем компьютере. Для этого вы будете использовать tz.gettz() и передайте официальное имя IANA для интересующего вас часового пояса. Вот пример использования tz.gettz() :
>>>
>>> from dateutil import tz
>>> из даты и времени импортировать дату и время
>>> London_tz = tz.gettz("Европа/Лондон")
>>> сейчас = datetime.now(tz=London_tz)
>>> сейчас
datetime.datetime(2020, 1, 26, 6, 14, 53, 513460, tzinfo=tzfile('GB-Eire'))
>>> сейчас.tzname()
'ВРЕМЯ ПО ГРИНВИЧУ'
В этом примере вы используете tz.gettz() для получения информации о часовом поясе для Лондона, Соединенное Королевство, и сохраняете ее в London_tz . Затем вы получаете текущее время, устанавливая часовой пояс на London_tz .
В Windows это дает атрибуту tzinfo значение tzfile('GB-Eire') . В macOS или Linux атрибут tzinfo будет выглядеть примерно так: tzfile('/usr/share/zoneinfo/Europe/London) , но может немного отличаться в зависимости от того, где находится .0008 dateutil извлекает данные о часовом поясе.
Вы также используете tzname() для вывода названия часового пояса, которое теперь равно 'GMT' , что означает среднее время по Гринвичу. Этот вывод одинаков для Windows, macOS и Linux.
В предыдущем разделе вы узнали, что не следует использовать .utcnow() для создания экземпляра datetime в текущем UTC. Теперь вы знаете, как использовать dateutil.tz для указания часового пояса в datetime 9.экземпляр 0009. Вот пример, измененный из рекомендации в документации Python:
>>>
>>> from dateutil import tz >>> из даты и времени импортировать дату и время >>> datetime.
В этом коде вы используете tz.UTC , чтобы установить часовой пояс datetime.now() в часовой пояс UTC. Этот метод рекомендуется вместо использования utcnow() , потому что utcnow() возвращает наивный экземпляр datetime , тогда как метод, продемонстрированный здесь, возвращает осведомленный экземпляр datetime .
Далее вы совершите небольшое отступление, чтобы узнать о наивных против осведомленных дат-времени экземпляров. Если вы уже знаете все об этом, вы можете пропустить вперед, чтобы улучшить обратный отсчет PyCon с информацией о часовом поясе.
Удалить рекламу
Сравнение Naive и Aware Python
дата-время Экземпляры Экземпляры Python datetime поддерживают два типа операций: наивный и осведомленный. Основное различие между ними заключается в том, что наивные экземпляры не содержат информацию о часовом поясе, тогда как осведомлённые экземпляры содержат. Более формально, если процитировать документацию Python:
Осознанный объект представляет собой определенный момент времени, который не подлежит интерпретации. Наивный объект не содержит достаточно информации, чтобы однозначно определить свое местонахождение относительно других объектов даты/времени. (Источник)
Это важное отличие для работы с Python datetime . Экземпляр , поддерживающий datetime , может однозначно сравнивать себя с другими осведомленными экземплярами datetime и всегда будет возвращать правильный временной интервал при использовании в арифметических операциях.
Naive datetime могут быть неоднозначными. Один из примеров этой неоднозначности относится к переходу на летнее время. В районах, где практикуется переход на летнее время, часы переводят на один час вперед весной и на час назад осенью. Обычно это происходит в 2 часа ночи по местному времени. Весной час с 2:00 до 2:59.AM никогда не бывает , а осенью в час с 1:00 до 1:59 бывает дважды !
На практике происходит следующее: смещение от UTC в этих часовых поясах меняется в течение года. IANA отслеживает эти изменения и каталогизирует их в различных файлах баз данных, установленных на вашем компьютере. Использование такой библиотеки, как dateutil , которая использует под капотом базу данных IANA, — отличный способ убедиться, что ваш код правильно обрабатывает арифметические операции со временем.
Примечание: В Python разница между простыми и осведомленными экземплярами datetime определяется атрибутом tzinfo . Осведомленный экземпляр datetime имеет атрибут tzinfo , равный подклассу абстрактного базового класса datetime.. tzinfo
Python 3.8 и более ранние версии предоставляют одну конкретную реализацию tzinfo с именем timezone . Однако часовой пояс ограничен выражением фиксированных смещений от UTC, которые не могут меняться в течение года, поэтому он не так полезен, когда вам нужно учитывать такие изменения, как переход на летнее время.
Python 3.9 включает новый модуль zoneinfo , который обеспечивает конкретную реализацию tzinfo , которая отслеживает базу данных IANA, поэтому он включает такие изменения, как переход на летнее время. Однако до тех пор, пока Python 3.9 не станет широко использоваться, вероятно, имеет смысл полагаться на dateutil , если вам нужно поддерживать несколько версий Python.
dateutil также предоставляет несколько конкретных реализаций tzinfo в tz .модуль, который вы использовали ранее. Вы можете ознакомиться с документацией dateutil. для получения дополнительной информации. tz
Это не означает, что вам всегда нужно использовать осведомленные экземпляры datetime . Но осведомленные экземпляры имеют решающее значение, если вы сравниваете время друг с другом, особенно если вы сравниваете время в разных частях мира.
Улучшение обратного отсчета PyCon
Теперь, когда вы знаете, как добавить информацию о часовом поясе в дату и время Python Например, вы можете улучшить свой код обратного отсчета PyCon. Ранее вы использовали стандартный конструктор datetime для передачи года, месяца, дня и часа запуска PyCon. Вы можете обновить свой код, чтобы использовать модуль dateutil.parser , который обеспечивает более естественный интерфейс для создания экземпляров datetime :
# pyconcd.py
из парсера импорта dateutil, tz
из даты и времени импортировать дату и время
PYCON_DATE = parser.parse("12 мая 2021 г., 8:00")
PYCON_DATE = PYCON_DATE. replace(tzinfo=tz.gettz("Америка/Нью-Йорк"))
сейчас = datetime.now(tz=tz.tzlocal())
обратный отсчет = PYCON_DATE - сейчас
print(f"Обратный отсчет до PyCon US 2021: {countdown}")
В этом коде вы импортируете парсер и tz из dateutil и datetime из datetime . Затем вы используете parser.parse() , чтобы прочитать дату следующего PyCon US из строки. Это гораздо более читабельно, чем простой конструктор datetime .
parser.parse() возвращает наивный экземпляр datetime , поэтому вы используете .replace() , чтобы изменить tzinfo на Америка/Нью-Йорк часовой пояс. PyCon US 2021 пройдет в Питтсбурге, штат Пенсильвания, который находится в восточном часовом поясе США. Каноническое название этого часового пояса — America/New_York , поскольку Нью-Йорк — крупнейший город в этом часовом поясе.
PYCON_DATE — это осведомленный экземпляр datetime с часовым поясом, установленным на восточное время США. Поскольку 12 мая наступает после вступления в силу летнего времени, название часового пояса — «EDT» или «Eastern Daylight Time» 9.0009 .
Затем вы создаете теперь , чтобы представить текущий момент времени и указать свой местный часовой пояс. Наконец, вы находите timedelta между PYCON_DATE и теперь и печатаете результат. Если вы находитесь в регионе, где часы не переводятся на летнее время, вы можете увидеть количество часов, оставшихся до перехода PyCon на час.
Выполнение арифметических операций с помощью Python
datetime Python дата-время 9Экземпляры 0009 поддерживают несколько типов арифметики. Как вы видели ранее, это зависит от использования экземпляров timedelta для представления временных интервалов. timedelta очень полезен, потому что он встроен в стандартную библиотеку Python. Вот пример работы с timedelta :
>>>
>>> из даты и времени импортировать дату и время, дельта времени >>> сейчас = datetime.
В этом коде вы создаете сейчас , в котором хранится текущее время, и завтра , что является timedelta из +1 дней. Затем вы добавляете сейчас и завтра , чтобы создать экземпляр datetime через день в будущем. Обратите внимание, что работа с наивными экземплярами datetime , как вы здесь, означает, что 9Атрибут 0008 day атрибута datetime увеличивается на единицу и не учитывает повторяющиеся или пропущенные временные интервалы.
экземпляры timedelta также поддерживают отрицательные значения в качестве входных данных для аргументов:
>>>
>>> вчера = дельта времени (дни = -1) >>> сейчас + вчера datetime.
В этом примере вы предоставляете -1 в качестве входных данных для timedelta , поэтому, когда вы добавляете сейчас и вчера , результатом будет уменьшение атрибута дней на единицу.
экземпляры timedelta поддерживают сложение и вычитание, а также положительные и отрицательные целые числа для всех аргументов. Вы даже можете предоставить смесь положительных и отрицательных аргументов. Например, вы можете добавить три дня и вычесть четыре часа:
>>>
>>> дельта = дельта времени (дни = +3, часы = -4) >>> сейчас + дельта datetime.datetime (2020, 1, 29, 5, 37, 46, 380905)
В этом примере вы добавляете три дня и вычитаете четыре часа, поэтому новое значение datetime приходится на 29 января в 5:37 утра. timedelta очень полезен в этом отношении, но он несколько ограничен, поскольку не может добавлять или вычитать интервалы больше дня, такие как месяц или год. К счастью, dateutil предоставляет более мощную замену под названием relativedelta .
Основной синтаксис relativedelta очень похож на timedelta . Вы можете указать аргументы ключевого слова, которые производят изменения на любое количество лет, месяцев, дней, часов, секунд или микросекунд. Вы можете воспроизвести первый пример timedelta с помощью этого кода:
>>>
>>> from dateutil.relativedelta import relativedelta >>> завтра = относительная дельта (дни = +1) >>> сейчас + завтра datetime.datetime(2020, 1, 27, 9, 37, 46, 380905)
В этом примере вы используете relativedelta вместо timedelta , чтобы найти datetime , соответствующее завтрашнему дню. Теперь вы можете попробовать прибавить пять лет, один месяц и три дня к , теперь , вычитая при этом четыре часа и тридцать минут:
>>>
>>> дельта = относительная дельта(годы=+5, месяцы=+1, дни=+3, часы=-4, минуты=-30) >>> сейчас + дельта datetime.datetime(2025, 3, 1, 5, 7, 46, 380905)
Обратите внимание, что в этом примере дата заканчивается 1 марта 2025 года. Это связано с тем, что добавление трех дней к теперь будет 29 января, а добавление одного месяца к этому будет 29 февраля, которое существует только в високосный год. Поскольку 2025 год не високосный, дата переносится на следующий месяц.
Вы также можете использовать relativedelta для вычисления разницы между двумя экземплярами datetime . Ранее вы использовали оператор вычитания, чтобы найти разницу между двумя экземплярами Python datetime , PYCON_DATE и теперь . С относительной дельтой вместо использования оператора вычитания вам нужно передать два экземпляра datetime в качестве аргументов:
>>>
>>> сейчас datetime.
В этом примере вы создаете новый экземпляр datetime для завтра , увеличивая дней поле на единицу. Затем вы используете relativedelta и передаете сейчас и завтра в качестве двух аргументов. Затем dateutil берет разницу между этими двумя экземплярами datetime и возвращает результат в виде экземпляра relativedelta . В данном случае разница составляет -1 дней, так как сейчас бывает до завтра .
dateutil.relativedelta Объекты имеют бесчисленное множество других применений. Вы можете использовать их для поиска сложной календарной информации, такой как следующий год, в котором 13 октября выпадает на пятницу, или какая дата будет в последнюю пятницу текущего месяца. Вы даже можете использовать их для замены атрибутов datetime экземпляр и создайте, например, экземпляр datetime через одну неделю в 10:00. Вы можете прочитать все об этих других применениях в документации dateutil .
Удалить рекламу
Завершение обратного отсчета PyCon
Теперь у вас на поясе достаточно инструментов, чтобы закончить часы обратного отсчета PyCon 2021, а также обеспечить удобный интерфейс. В этом разделе вы будете использовать относительную дельту для расчета времени, оставшегося до PyCon, разработать функцию для печати оставшегося времени в удобном формате и показать пользователю дату PyCon.
Использование
относительной дельты в обратном отсчете вашего PyCon Сначала замените простой оператор вычитания на relativedelta . С оператором вычитания ваш объект timedelta не мог считать интервалы времени больше суток. Однако относительная дельта позволяет отображать оставшиеся годы, месяцы и дни:
1# pyconcd.py
2
парсер импорта 3from dateutil, tz
4from dateutil.relativedelta импортирует относительную дельту
5из даты и времени импортировать дату и время
6
7PYCON_DATE = parser.parse("12 мая 2021 г., 8:00")
8PYCON_DATE = PYCON_DATE.replace(tzinfo=tz.gettz("Америка/Нью-Йорк"))
9сейчас = datetime.now(tz=tz.tzlocal())
10
11обратный отсчет = относительная дельта (PYCON_DATE, сейчас)
12print(f"Обратный отсчет до PyCon US 2021: {обратный отсчет}")
Единственное изменение, которое вы внесли в этот код, заключалось в замене строки 11 на countdown = relativedelta(PYCON_DATE, now) . Вывод этого скрипта должен сказать вам, что PyCon US 2021 состоится примерно через год и один месяц, в зависимости от того, когда вы запустите скрипт.
Однако этот результат выглядит не очень красиво, так как выглядит как подпись числа 9.0008 относительнаядельта() . Вы можете создать более красивый вывод, заменив строку 11 в предыдущем коде кодом ниже:
11def time_amount(time_unit: str, обратный отсчет: относительнаядельта) -> str:
12 t = getattr(обратный отсчет, единица_времени)
13 вернуть f"{t} {time_unit}", если t != 0 иначе ""
14
15обратный отсчет = относительная дельта (PYCON_DATE, сейчас)
16time_units = ["годы", "месяцы", "дни", "часы", "минуты", "секунды"]
17output = (t для tu в единицах_времени if (t := time_amount(tu, обратный отсчет)))
18print("Обратный отсчет до PyCon US 2021:", ", ".join(output))
Для этого кода требуется Python 3.8, поскольку он использует новый оператор walrus . Вы можете заставить этот скрипт работать в более старых версиях Python, используя традиционный цикл for вместо строки 17 .
В этом коде вы определяете time_amount() , который принимает два аргумента, единицу времени и экземпляр relativedelta , из которого должны быть получены единицы времени. Если количество времени не равно нулю, то time_amount() возвращает строку с количеством времени и единицей времени. В противном случае возвращается пустая строка.
Вы используете time_amount() в понимании на строке 17 . Эта строка создает генератор , хранящий непустые строки, возвращенные из time_amount() . Он использует оператор walrus для назначения возвращаемого значения time_amount() на t и включает t , только если это True .
Наконец, строка 18 печатает окончательный вывод, используя .join() на генераторе. Далее вы рассмотрите включение даты PyCon в выходные данные вашего скрипта.
Отображение даты PyCon в обратном отсчете PyCon
Ранее вы узнали о создании экземпляров datetime с использованием .strptime() . Этот метод использует специальный мини-язык в Python, чтобы указать, как форматируется строка даты.
Python datetime имеет дополнительный метод с именем .strftime() , который позволяет форматировать экземпляр datetime в строку. В некотором смысле это обратная операция синтаксического анализа с использованием .strptime() . Вы можете различать эти два метода, помня, что p в .strptime() означает parse , а f в .strftime() означает формат .
В обратном отсчете PyCon вы можете использовать .strftime() для вывода вывода, чтобы сообщить пользователю дату начала PyCon US. Помните, что вы можете найти коды форматирования, которые хотите использовать, на strftime.org. Теперь добавьте этот код на строка 18 вашего скрипта обратного отсчета PyCon:
18pycon_date_str = PYCON_DATE.strftime("%A, %B %d, %Y в %H:%M %p %Z")
19print(f"PyCon US 2021 начнется:", pycon_date_str)
20print("Обратный отсчет до PyCon US 2021:", ", ". join(output))
В этом коде строка 18 использует .strftime() для создания строки, представляющей дату начала PyCon US 2021. Выходные данные включают день недели, месяц, день, год, час, минуту, AM или PM и часовой пояс:
В строке 19 вы печатаете эту строку, чтобы пользователь мог ее увидеть с пояснительным текстом. Последняя строка выводит количество времени, оставшееся до даты начала PyCon. Затем вы закончите свой сценарий, чтобы другим людям было проще его использовать.
Удалить рекламу
Завершение обратного отсчета PyCon
Последний шаг, который вам нужно сделать, — это следовать рекомендациям Python и поместить код, который производит выходные данные, в функция main() . Вы можете проверить полный, окончательный код после применения всех этих изменений:
1# pyconcd.
В этом коде вы перемещаете print() и код, используемый для генератора, в main() . В строке 23 вы используете защитное предложение , чтобы убедиться, что main() запускается только тогда, когда этот файл выполняется как скрипт. Это позволяет другим людям импортировать ваш код и повторно использовать PYCON_DATE , например, если они хотят.
Теперь вы можете изменять этот скрипт сколько угодно. Можно было бы разрешить пользователю изменить часовой пояс, связанный с , на , передав аргумент командной строки. Вы также можете изменить PYCON_DATE на что-то более близкое к дому, скажем, PyCon Africa или EuroPython.
Чтобы получить еще больше удовольствия от PyCon, ознакомьтесь с Real Python на PyCon US 2019 и о том, как получить максимальную отдачу от PyCon!
Альтернативы Python
datetime и dateutil Python datetime и dateutil — это мощная комбинация библиотек, когда вы работаете с датами и временем. dateutil даже рекомендуется в документации Python. Однако есть много других библиотек, которые можно использовать для работы с датами и временем в Python. Некоторые из них полагаются на datetime и dateutil , в то время как другие являются полностью независимыми заменами:
- pytz предоставляет информацию о часовом поясе, аналогичную
dateutil. Он использует несколько иной интерфейс, чем стандартныйdatetime.tzinfo, поэтому помните о потенциальных проблемах, если вы решите его использовать. - Arrow обеспечивает замену
datetime. Он вдохновленmoment.js, поэтому, если вы пришли из веб-разработки, то этот интерфейс может быть более знакомым. - Маятник обеспечивает еще одну замену
datetime. Он включает в себя интерфейс часового пояса и улучшенную реализациюtimedelta. - Maya предоставляет интерфейс, аналогичный
datetime. Он полагается на Pendulum для частей библиотеки синтаксического анализа. - dateparser предоставляет интерфейс для создания
экземпляров datetimeиз удобочитаемого текста. Он гибкий и поддерживает множество языков.
Кроме того, если вы активно работаете с NumPy, Pandas или другими пакетами обработки данных, вам могут пригодиться следующие варианты:
- NumPy предоставляет API, аналогичный встроенной библиотеке Python
datetime, но версию NumPy можно использовать в массивах. - Pandas обеспечивает поддержку данных временных рядов в DataFrames, обычно последовательных значений событий, основанных на времени, с помощью модуля NumPy
datetime. - cftime обеспечивает поддержку календарей, отличных от пролептического григорианского календаря, а также других единиц времени, соответствующих соглашениям о климате и прогнозировании (CF). Он используется
Пакет xarrayдля обеспечения поддержки временных рядов.
Дополнительная литература
Поскольку программирование со временем может быть очень сложным, в Интернете есть много ресурсов, которые помогут вам узнать больше об этом. К счастью, об этой проблеме задумывались многие люди, работающие с любым языком программирования, поэтому обычно вы можете найти информацию или инструменты, которые помогут решить любую проблему, которая может возникнуть. Вот избранный список статей и видео, которые мне помогли при написании этого руководства:
- Летнее время и рекомендации по часовому поясу
- Хранение UTC не является серебряной пулей
- Как сохранить дату и время для будущих событий
- Рекомендации по кодированию с использованием DateTime в .NET Framework
- Компьютерофил: проблема со временем и часовыми поясами
- Сложность программирования временных данных
Кроме того, Пол Ганссле является основным участником CPython и в настоящее время сопровождает dateutil . Его статьи и видео — отличный ресурс для пользователей Python:
- Работа с часовыми поясами: все, что вам не нужно знать (PyCon 2019)
- pytz: Самый быстрый футган на Западе
- Прекратить использование utcnow и utcfromtimestamp
- Любопытный случай нетранзитивного сравнения даты и времени
Заключение
В этом руководстве вы узнали о программировании с датами и временем и о том, почему это часто приводит к ошибкам и путанице. Вы также узнали о Python datetime и dateutil , а также как работать с часовыми поясами в вашем коде.
Теперь вы можете:
- Храните в своих программах дат в удобном и перспективном формате
- Создание экземпляров Python
datetimeс отформатированными строками - Добавить информацию о часовом поясе в экземпляры
datetimeсdateutil - Выполнить арифметических операций с
datetimeэкземпляров с использованиемrelativedelta
В конце концов, вы создали сценарий, который отсчитывает время, оставшееся до следующего PyCon в США, чтобы вы могли с нетерпением ждать самого большого собрания Python. Даты и время могут быть сложными, но с этими инструментами Python в вашем арсенале вы готовы решать самые сложные задачи!
Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Использование модуля datetime Python
Простое руководство с 39 примерами кода (2022)
11 мая 2022 г.
Возможно, вы уже знакомы с различными типами данных в Python, такими как целые числа, числа с плавающей точкой, строки и т. д. вы разрабатываете сценарий или алгоритм машинного обучения, вы должны использовать даты и время. В повседневной жизни мы можем представлять дату и время в различных форматах, например, 4 июля , 8 марта 2022 года , 22:00 или 31 декабря 2022 г., 23:59:59 . Они используют комбинацию целых чисел и строк, или вы также можете использовать числа с плавающей запятой для представления доли дня, минуты и т. д.
Но это не единственное осложнение! Добавьте к этому списку различные часовые пояса, переход на летнее время, различные соглашения о формате времени (в США это 23.07.2022, а в Европе — 23.07.2023) и т. д.
Компьютеры требуют недвусмысленной точности, когда мы говорим им, что делать, но даты и время представляют собой проблему. К счастью, у Python есть 9Модуль 0008 datetime , который позволяет нам легко манипулировать объектами, представляющими дату и время.
В этом руководстве Python datetime мы узнаем следующее:
- Использование модуля
datetimeв Python - Преобразование строки в объект
datetimeи наоборот с использованием функций Pythondatetime - Извлечение даты и времени из объекта
datetime - Работа с отметками времени
- Выполнение арифметических операций с датами и временем
- Работа с часовыми поясами
- Наконец, создание таймера обратного отсчета, чтобы определить, сколько осталось до Нового 2023 года (в Нью-Йорке!)
Давайте начнем работать с датами и временем в Python.
Примечание . Если фрагмент кода не содержит оператора import , предполагается, что класс/функция, используемые в коде, уже импортированы.
Как использовать дату и время в Python?
Как мы уже говорили ранее, представление даты и времени в программировании — непростая задача. Прежде всего, мы должны представить их в стандартном, общепринятом формате. К счастью, Международная организация по стандартизации (ISO) разработала всемирный стандарт ISO 8601, который представляет объекты, связанные с датой и временем, в виде ГГГГ-ММ-ДД ЧЧ:ММ:СС с информацией в диапазоне от самых важных (годы , YYYY ) до наименее важного (секунды, SS ). Каждая часть этого формата представлена в виде четырех- или двузначного числа.
Модуль datetime в Python имеет 5 основных классов (частей модуля):
-
датадля управления объектами даты -
времядля управления объектами времени -
datetimeпредставляет собой комбинациюдатыивремени -
timedeltaпозволяет нам работать с длительностью времени -
тцинфопозволяет нам работать с часовыми поясами
Дополнительно воспользуемся модулем zoneinfo , предоставляющим современный способ работы с часовыми поясами, и пакетом dateutil , содержащим множество полезных функций для работы с датами и временем.
Давайте импортируем модуль datetime и создадим наши первые объекты даты и времени:
# Из даты импорта модуля datetime с даты импорта datetime # Создать объект даты 2000-02-03 дата(2000, 2, 3)
дата/время.дата(2000, 2, 3)
В приведенном выше коде мы импортировали класс date из модуля, а затем создали объект datetime.date от 3 февраля 2000 года. Мы можем отметить, что порядок чисел, который мы используем для создания этого объекта, точно то же, что и в ISO 8061 (но мы опускаем 0 и пишем только однозначные числа для месяца и дня).
Кодирование основано на экспериментах, поэтому, допустим, мы хотим создать объект 2000-26-03:
.# Создать объект даты 2000-26-03 дата(2000, 26, 3)
-------------------------------------------------- --------------------------
ValueError Traceback (последний последний вызов)
Вход In [2], in
1 # Создать объект даты 2000-26-03
----> 2 даты (2000, 26, 3)
ValueError: месяц должен быть в диапазоне 1. .12 Получаем ValueError: месяц должен быть в 1..12 , что логично, т.к. в календаре нет месяца 26. Эта функция строго соответствует формату ISO 8601. Для практики добавьте больше аргументов к date и обратите внимание на то, что происходит.
Давайте посмотрим, как мы можем создать объект datetime.time :
# Из времени импорта модуля datetime из даты и времени импорта # Создаем объект времени 05:35:02 время(5, 35, 2)
дата/время.время(5, 35, 2)
Нам это удалось, и вы можете догадаться, что эта функция также соответствует формату ISO 8061. Можете ли вы сломать его, как мы это делали раньше, с функцией date ?
Что, если мы хотим, чтобы и дата, и время были в одном объекте? Мы должны использовать дата-время класс:
# Из модуля datetime импортировать дату и время из даты и времени импортировать дату и время # Создать объект даты и времени 03.02.2000 05:35:02 дата/время(2000, 2, 3, 5, 35, 2)
datetime.
Отлично, у нас есть объект datetime . Мы также можем быть более явными и передать аргументы ключевого слова конструктору datetime :
дата и время (год = 2000, месяц = 2, день = 3, час = 5, минута = 35, секунда = 2)
дата и время. дата и время (2000, 2, 3, 5, 35, 2)
Что, если мы передадим только три аргумента (год, месяц и день)? Это вызовет ошибку?
# Создать объект даты и времени 2000-02-03 дата и время (2000, 2, 3)
дата и время. дата и время (2000, 2, 3, 0, 0)
Мы видим, что теперь в объекте есть два нуля, которые представляют (соответственно) час и минуту. Секунды в этом случае опущены.
Во многих ситуациях мы хотим знать точное время в данный момент. Мы можем использовать now() метод класса datetime :
# Время в данный момент сейчас = дата/время.сейчас() сейчас
datetime.datetime(2022, 2, 14, 11, 33, 25, 516707)
Мы получаем объект datetime . Здесь последнее число — микросекунды.
Если нам нужна только сегодняшняя дата, мы можем использовать метод today() из класса date :
сегодня = date.today() сегодня
дата/время.дата(2022, 2, 14)
Если нам нужно только время, мы можем написать time.now() , но это не сработает. Вместо этого мы должны получить доступ к часам , минутам и секундам атрибутов объекта datetime.now() и передать их конструктору time :
время(сейчас.час,сейчас.минута,сейчас.секунда)
дата/время.время(11, 33, 25)
Для практики получите дату из объекта datetime в Python (назначенного переменной now ).
Мы также можем извлечь номер недели и номер дня из числа 9.0008 объект datetime с использованием функции isocalendar() . Он вернет кортеж из трех элементов, содержащий год ISO, номер недели и номер дня недели:
# isocalendar() возвращает кортеж из 3 элементов с годом ISO, номером недели и номером дня недели сейчас.изокалендарь()
datetime.IsoCalendarDate (год = 2022, неделя = 7, день недели = 1)
В формате ISO неделя начинается в понедельник и заканчивается в воскресенье. Дни недели кодируются цифрами от 1 (понедельник) до 7 (воскресенье). Если мы хотим получить доступ к одному из этих элементов кортежа, мы используем обозначение в скобках :
# Номер недели доступа week_number = now.isocalendar () [1] неделя_номер
7
Извлечение дат из строк
В науке о данных и в программировании в целом мы в основном работаем с датами и временем, которые хранятся в виде строк в десятках различных форматов, в зависимости от региона, компании или детализации необходимой нам информации. Иногда нам нужна дата и точное время, но в других случаях нам нужны только год и месяц. Как мы можем извлечь нужные нам данные из строки, чтобы легко манипулировать ею как datetime ( дата , время ) объект?
Первая функция, которую мы изучим для преобразования строки даты в объект даты , — это из изоформата . Мы называем его так, потому что он использует формат ISO 8601 (т. е. ГГГГ-ММ-ДД ). Давайте посмотрим на пример:
# Преобразование строки даты в объект даты
date.fromisoformat("2022-12-31") дата/время.дата(2022, 12, 31)
Формат ISO также содержит время, но если мы передаем его в функцию, оно не будет работать:
date.fromisoformat("2022-12-31 00:00:00") -------------------------------------------------- --------------------------
ValueError Traceback (последний последний вызов)
Вход In [13], in
----> 1 date.fromisoformat("2022-12-31 00:00:00")
ValueError: недопустимая строка изоформата: «2022-12-31 00:00:00» Конечно, мы можем также выполнить обратную операцию и преобразовать объект datetime в строку даты в формате ISO. Для этого мы должны использовать isoformat() :
# Преобразование объекта datetime в строку в формате ISO дата (2022, 12, 31). изоформат ()
'2022-12-31'время выполнения()
Чтобы решить указанную выше проблему ValueError , мы можем использовать функцию strptime() , которая может преобразовать произвольную строку даты/времени в строку datetime объект. Наша строка не обязательно должна соответствовать формату ISO, но мы должны указать, какая часть строки представляет какую дату или единицу времени (год, час и т. д.). Давайте посмотрим на пример, чтобы пояснить. Прежде всего, мы будем использовать строгий формат ISO для преобразования строки в объект datetime :
# Дата в виде строки iso_date = "2022-12-31 23:59:58" # формат ISO iso_format = "%Y-%m-%d %H:%M:%S" # Преобразование строки в объект даты и времени datetime.strptime(iso_date, iso_format)
datetime.datetime(2022, 12, 31, 23, 59, 58)
В первой строке мы создаем строку даты/времени. Во второй строке мы указываем формат строки, используя специальный код, который содержит знак процента, за которым следует символ, кодирующий единицу измерения даты или времени. Наконец, в третьей строке мы используем функцию strptime() для преобразования строки в объект datetime . Эта функция принимает два аргумента: строку и формат строки.
Код, который мы использовали выше, может также кодировать другие единицы даты и времени, такие как день недели, название месяца, номер недели и т. д.
| Код | Пример | Описание |
|---|---|---|
| %А | Понедельник | Полное название дня недели |
| %В | декабрь | Полное название месяца |
| %W | 2 | Номер недели (понедельник как первый день недели) |
На этом веб-сайте можно найти другие коды, используемые в Python.
Давайте рассмотрим еще несколько примеров с использованием других форматов:
# Европейская дата в виде строки европейская_дата = "31-12-2022" # европейский формат европейский_формат = "%d-%m-%Y" # Преобразование строки в объект даты и времени datetime.strptime (европейская_дата, европейский_формат)
datetime.
Как мы видим выше, строка была успешно преобразована, но у нас есть дополнительные нули, представляющие время. Давайте посмотрим на пример, используя другие коды:
# Полное название месяца дата full_month_date = "12 сентября 2022 г." # Полный формат месяца full_month_format = "%d %B %Y" # Преобразование строки в объект даты и времени datetime.strptime (полная_месяц_дата, полный_месяц_формат)
datetime.datetime(2022, 9, 12, 0, 0)
Снова успех! Обратите внимание, что формат , который мы определяем, должен соответствовать формату строки даты . Таким образом, если у нас есть пробелы, двоеточия, дефисы или другие символы для разделения единиц времени, они должны быть в строке кода. В противном случае Python выдаст Ошибка значения :
# Полное название месяца дата full_month_date = "12 сентября 2022 г." # Неверный формат (отсутствует пробел) full_month_format = "%d%B %Y" # Преобразование строки в объект даты и времени datetime.
-------------------------------------------------- --------------------------
ValueError Traceback (последний последний вызов)
Вход In [18], in
5 full_month_format = "%d%B %Y"
7 # Преобразование строки в объект даты и времени
----> 8 datetime.strptime(full_month_date, full_month_format)
Файл ~/coding/dataquest/articles/using-the-datetime-package/env/lib/python3.10/_strptime.py:568, в _strptime_datetime(cls, data_string, format)
565 def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
566 """Вернуть экземпляр класса cls на основе входной строки и
Строка формата 567."""
--> 568 тт, дробь, gmtoff_fraction = _strptime(строка_данных, формат)
569tzname, gmtoff = tt[-2:]
570 аргументов = tt[:6] + (доля,)
Файл ~/coding/dataquest/articles/using-the-datetime-package/env/lib/python3.10/_strptime.py:349, в _strptime (строка_данных, формат)
347 найдено = format_regex.match(data_string)
348, если не найдено:
--> 349 поднять ValueError("данные времени %r не соответствуют формату %r" %
350 (строка_данных, формат))
351, если len(data_string) != found. end():
352 поднять ValueError("непреобразованные данные остались: %s" %
353 data_string[found.end():])
ValueError: данные времени «12 сентября 2022 года» не соответствуют формату «%d%B %Y» Даже один пропущенный пробел может вызвать ошибку!
Преобразование объектов даты и времени в строки
стрфтайм() В Python мы также можем преобразовать объект datetime в строку, используя функцию strftime() . Он принимает два аргумента: объект datetime и формат выходной строки.
# Создать объект даты и времени
datetime_obj = дата и время (2022, 12, 31)
# Американский формат даты
американский_формат = "%m-%d-%Y"
# европейский формат
европейский_формат = "%d-%m-%Y"
# американская строка даты
print(f"Американская строка даты: {datetime.strftime(datetime_obj, american_format)}.")
# европейская строка даты
print(f"Европейская строка даты: {datetime.strftime(datetime_obj, european_format)}.") Американская строка даты: 31-12-2022.
Мы взяли один и тот же объект datetime и преобразовали его в два разных формата. Мы также можем указать другие форматы, например полное название месяца, за которым следует день и год.
full_month = "%B %d, %Y" datetime.strftime (datetime_obj, полный_месяц)
'31 декабря 2022 г.'
Другой способ использования strftime — поместить его после объекта datetime :
datetime_obj = дата и время (2022, 12, 31, 23, 59, 59) full_datetime = "%B %d, %Y %H:%M:%S" datetime_obj.strftime(full_datetime)
'31 декабря 2022 г., 23:59:59'
На практике strftime() может быть полезно, если мы хотим извлечь название дня недели, выпадающего на 31 декабря в разные годы:
# Извлечь название дня недели 31 декабря
будний_формат = "%А"
за год в диапазоне (2022, 2026):
print(f"День недели 31 декабря, {год} равен {дате(год, 12, 31). strftime(weekday_format)}.") 31 декабря 2022 года днем недели является суббота. Будний день 31 декабря 2023 года — воскресенье. Будний день 31 декабря 2024 года — вторник. Будний день 31 декабря 2025 года — среда.
Временные метки
В программировании даты и время обычно хранятся в формате временных меток Unix. Этот формат представляет любую дату в виде цифр. По сути, отметка времени — это количество секунд, прошедших с эпохи Unix , которая началась в 00:00:00 UTC (Всемирное скоординированное время) 1 января 19 года.70. Мы можем вычислить это число с помощью функции timestamp() :
new_year_2023 = дата и время (2022, 12, 31) datetime.timestamp(new_year_2023)
1672441200.0
1672441200 — количество секунд между началом эпохи Unix и 31 декабря 2022 года.
Мы можем выполнить обратную операцию, используя функцию fromtimestamp() :
дата и время. от метки времени (1672441200)
datetime.
Арифметические операции с датами
Иногда нам может понадобиться вычислить разницу между двумя датами или выполнить другие арифметические операции над датами и временем. К счастью, в наборе инструментов Python есть много инструментов для выполнения таких вычислений.
Основные арифметические операции
Первая операция, которую мы можем выполнить, — вычислить разницу между двумя датами. Для этого используем знак минус:
# Установить две даты
первая_дата = дата (2022, 1, 1)
second_date = дата (2022, 12, 31)
# Разница между двумя датами
date_diff = вторая_дата - первая_дата
# Функция для преобразования даты и времени в строку
def dt_string(дата, date_format="%B %d, %Y"):
дата возврата.strftime(date_format)
print(f"Количество дней и часов между {dt_string(first_date)} и {dt_string(second_date)} равно {date_diff}.") Количество дней и часов между 01 января 2022 г. и 31 декабря 2022 г. составляет 364 дня, 0:00:00.
Давайте посмотрим, какой тип объекта возвращает: first_date - second_date
тип (дата_diff)
дата-время.timedelta
Тип этого объекта: datetime.timedelta . В его названии есть delta , что относится к зеленой букве delta , $\Delta$, которая в науке и технике описывает изменение. Действительно, здесь оно представляет собой изменение (разницу) во времени.
Что, если нас интересует только количество дней между двумя датами? Мы можем получить доступ к различным атрибутам объектов timedelta , и один из них называется .days .
print(f"Количество дней между {dt_string(first_date)} и {dt_string(second_date)} равно {(date_diff).days}.") Количество дней между 01 января 2022 г. и 31 декабря 2022 г. составляет 364.дельта времени()
Теперь, когда мы знаем о timedelta , пришло время представить функцию timedelta() . Это позволяет нам выполнять множество арифметических операций над объектами времени, добавляя и вычитая единицы времени, такие как дни, годы, недели, секунды и т. д. Например, нам может быть интересно узнать, какой день недели будет через 30 дней. Для этого нам нужно создать объект, представляющий текущее время, и объект timedelta , определяющий количество времени, которое мы добавляем к нему:
# Импорт временной дельты
из datetime импортировать timedelta
# Текущее время
сейчас = дата/время.сейчас()
# timedelta 30 дней
one_month = timedelta (дни = 30)
# День в одном месяце/с использованием функции dt_string, определенной выше
print(f"День через 30 дней – {dt_string(now + one_month)}.") День через 30 дней — 16 марта 2022 года.
Если мы проверим страницу справки функции timedelta ( help(timedelta) ), то увидим, что она имеет следующие аргументы: дней=0, секунд=0, микросекунд=0, миллисекунд=0, минуты=0, часы=0, недели=0 . Таким образом, вы можете потренироваться добавлять или вычитать другие единицы времени из даты. Например, мы можем вычислить время за 12 часов до Нового 2030 года:
# Новый 2030 год
новый_год_2030 = дата/время (2030, 1, 1, 0, 0)
# timedelta 12 часов
двенадцать_часов = дельта времени (часы = 12)
# Строка времени за 12 часов до Нового 2023 года
12_hours_before = (new_year_2030 - 12_hours).strftime("%B %d, %Y, %H:%M:%S")
# Вывести время за 12 часов до Нового 2023 года
print(f"Время за двенадцать часов до Нового 2030 года будет {twelve_hours_before}.") Время за двенадцать часов до Нового 2030 года будет 31 декабря 2029 года, 12:00:00.
Мы также можем объединить несколько аргументов функции timedelta() , чтобы определить более точное время. Например, какое время будет через 27 дней, 3 часа и 45 минут?
# Текущее время сейчас = дата/время.сейчас() # Timedelta 27 дней, 3 часа и 45 минут Specific_timedelta = timedelta (дни = 27, часы = 3, минуты = 45) # Время за 27 дней, 3 часа и 45 минут двадцать_севен_дней = (сейчас + дельта_времени).
Время через 27 дней, 3 часа и 45 минут будет 13 марта 2022 года, 15:18:39.относительная дельта()
К сожалению, на странице справки мы видим, что функция не позволяет нам использовать месяцы или годы. Чтобы обойти это ограничение, мы можем использовать функцию relativedelta из пакета dateutil . Эта функция очень похожа на timedelta() , но расширяет ее функциональность.
Например, мы хотим вычесть из текущего времени 2 года, 3 месяца, 4 дня и 5 часов:
# Импорт относительной дельты
из dateutil.relativedelta импортировать относительную дельту
# Текущее время
сейчас = дата/время.сейчас()
# объект относительной дельты
относительная_дельта = относительнаядельта (годы = 2, месяцы = 3, дни = 4, часы = 5)
two_years = (сейчас - относительная_дельта).strftime("%B %d, %Y, %H:%M:%S")
print(f"Время 2 года, 3 месяца, 4 дня и 5 часов назад было {two_years}. ") Время 2 года, 3 месяца, 4 дня и 5 часов назад было 10 ноября 2019 г., 06:33:40.
Мы также можем использовать relativedelta() для вычисления разницы между двумя объектами datetime :
относительная дельта (дата-время (2030, 12, 31), сейчас)
относительная дельта(годы=+8, месяцы=+10, дни=+16, часы=+12, минуты=+26, секунды=+19, микросекунды=+728345)
Эти арифметические операции могут показаться очень абстрактными и непрактичными, но на самом деле они полезны во многих приложениях. Один из таких сценариев может выглядеть следующим образом.
Скажем, некая операция в нашем скрипте должна быть выполнена только за 30 дней до определенной даты. Мы можем определить переменную, которая содержит текущее время и добавляет timedelta объект 30 дней ему. Если сегодня день, операция будет вызвана!
В противном случае представьте, что мы работаем с наборами данных с помощью панд, и один из столбцов содержит некоторые даты. Представьте, что у нас есть набор данных, в котором хранится прибыль нашей компании каждый день в году. Мы хотим создать еще один набор данных, который будет содержать даты ровно через год от текущей даты и прогнозируемую прибыль в каждый из этих дней. Мы обязаны использовать арифметические вычисления с датами!
Рано или поздно вы столкнетесь с датами и временем в одном из своих проектов по науке о данных. Когда вы это сделаете, вернитесь к этому руководству.
Работа с часовыми поясами
Как мы упоминали во введении, одной из проблем работы со временем в программировании является обработка часовых поясов. Они могут иметь разную форму. Мы также должны знать, что в некоторых регионах используется переход на летнее время (DST), а в других нет.
Python различает два типа объектов даты и времени: наивный и знающий . Наивный объект не содержит никакой информации о часовых поясах, а осведомлённый объект её хранит.
Прежде всего, давайте посмотрим на наивный объект времени:
# Импорт tzinfo из datetime импортировать tzinfo # Наивная дата и время naive_datetime = datetime.
НетТип
Из Python 3.9 у нас есть конкретная реализация часовых поясов с использованием База данных Управления по присвоению номеров в Интернете. Модуль, реализующий эту функциональность, называется zoneinfo . Обратите внимание: если вы используете предыдущие версии Python, вы можете использовать пакеты pytz или dateutil .
Давайте создадим осведомленный объект datetime , используя zoneinfo и, в частности, класс ZoneInfo , который является реализацией datetime.tzinfo абстрактного класса:
# Импорт ZoneInfo
из zoneinfo импортировать ZoneInfo
utc_tz = информация о зоне ("UTC")
# Осведомленный объект datetime с часовым поясом UTC
dt_utc = datetime.now (tz = utc_tz)
# Тип осведомленного объекта, реализованного с помощью ZoneInfo, - zoneinfo. ZoneInfo.
тип (dt_utc.tzinfo) zoneinfo.ZoneInfo
Мы видим, что осведомленный объект datetime содержит информацию о часовых поясах (реализован как объект zoneinfo.ZoneInfo ).
Давайте рассмотрим несколько примеров. Мы хотим определить текущее время в Центральной Европе и Калифорнии.
Прежде всего, мы можем перечислить все доступные часовые пояса в zoneinfo :
информация о зоне импорта # вернет длинный список часовых поясов (открывает много файлов!) zoneinfo.available_timezones()
{'Африка/Абиджан',
'Африка/Аккра',
'Африка/Аддис-Абеба',
'Африка/Алжир',
'Африка/Асмэра',
'Африка/Асмера',
'Африка/Бамако',
'Африка/Банги',
'Африка/Банжул',
'Африка/Бисау',
'Африка/Блантайр',
'Африка/Браззавиль',
'Африка/Бужумбура',
'Африка/Каир',
'Африка/Касабланка',
'Африка/Сеута',
'Африка/Конакри',
'Африка/Дакар',
'Африка/Дар_эс-Салам',
'Африка/Джибути',
'Африка/Дуала',
'Африка/Эль_Аюн',
'Африка/Фритаун',
'Африка/Габороне',
'Африка/Хараре',
'Африка/Йоханнесбург',
'Африка/Джуба',
'Африка/Кампала',
'Африка/Хартум',
'Африка/Кигали',
'Африка/Киншаса',
'Африка/Лагос',
'Африка/Либревиль',
'Африка/Ломе',
'Африка/Луанда',
'Африка/Лубумбаши',
'Африка/Лусака',
'Африка/Малабо',
'Африка/Мапуту',
'Африка/Масеру',
'Африка/Мбабане',
'Африка/Могадишо',
'Африка/Монровия',
'Африка/Найроби',
'Африка/Нджамена',
'Африка/Ниамей',
'Африка/Нуакшот',
'Африка/Уагадугу',
'Африка/Порто-Ново',
'Африка/Сан-Томе',
'Африка/Тимбукту',
'Африка/Триполи',
'Африка/Тунис',
'Африка/Виндхук',
'Америка/Адак',
'Америка/Анкоридж',
'Америка/Ангилья',
'Америка/Антигуа',
'Америка/Арагуайна',
'Америка/Аргентина/Буэнос_Айрес',
'Америка/Аргентина/Катамарка',
'Америка/Аргентина/Комод-Ривадавия',
'Америка/Аргентина/Кордова',
'Америка/Аргентина/Жужуй',
'Америка/Аргентина/Ла_Риоха',
'Америка/Аргентина/Мендоса',
'Америка/Аргентина/Рио_Гальегос',
'Америка/Аргентина/Сальта',
'Америка/Аргентина/Сан_Хуан',
'Америка/Аргентина/Сан_Луис',
'Америка/Аргентина/Тукуман',
'Америка/Аргентина/Ушуайя',
'Америка/Аруба',
'Америка/Асунсьон',
'Америка/Атикокан',
'Америка/Атка',
'Америка/Баия',
'Америка/Баия_Бандерас',
'Америка/Барбадос',
'Америка/Белем',
'Америка/Белиз',
'Америка/Блан-Саблон',
'Америка/Удав_Виста',
'Америка/Богота',
'Америка/Бойсе',
'Америка/Буэнос_Айрес',
'Америка/Кембридж_Бей',
'Америка/Кампо_Гранде',
'Америка/Канкун',
'Америка/Каракас',
'Америка/Катамарка',
'Америка/Кайенна',
'Америка/Кайман',
'Америка/Чикаго',
'Америка/Чихуахуа',
'Америка/Коралловая_гавань',
'Америка/Кордова',
'Америка/Коста_Рика',
'Америка/Крестон',
'Америка/Куяба',
'Америка/Кюрасао',
'Америка/Данмарксхавн',
'Америка/Доусон',
'Америка/Доусон_Крик',
'Америка/Денвер',
'Америка/Детройт',
'Америка/Доминика',
'Америка/Эдмонтон',
'Америка/Эйрунепе',
'Америка/Эль_Сальвадор',
'Америка/Энсенада',
'Америка/Форт_Нельсон',
'Америка/Форт_Уэйн',
'Америка/Форталеза',
'Америка/Glace_Bay',
'Америка/Готаб',
'Америка/Гусь_Бэй',
'Америка/Grand_Turk',
'Америка/Гренада',
'Америка/Гваделупа',
'Америка/Гватемала',
'Америка/Гуаякиль',
'Америка/Гайана',
'Америка/Галифакс',
'Америка/Гавана',
'Америка/Эрмосильо',
'Америка/Индиана/Индианаполис',
'Америка/Индиана/Нокс',
'Америка/Индиана/Маренго',
'Америка/Индиана/Петербург',
'Америка/Индиана/Tell_City',
'Америка/Индиана/Вевай',
'Америка/Индиана/Винсеннес',
'Америка/Индиана/Винамак',
'Америка/Индианаполис',
'Америка/Инувик',
'Америка/Икалуит',
'Америка/Ямайка',
'Америка/Жужуй',
'Америка/Джуно',
'Америка/Кентукки/Луисвилл',
'Америка/Кентукки/Монтиселло',
'Америка/Нокс_IN',
'Америка/Кралендейк',
'Америка/Ла-Пас',
'Америка/Лима',
'Америка/Лос-Анджелес',
'Америка/Луисвилль',
'Америка/Нижние_князья',
'Америка/Масейо',
'Америка/Манагуа',
'Америка/Манаус',
'Америка/Мариго',
'Америка/Мартиника',
'Америка/Матаморос',
'Америка/Мазатлан',
'Америка/Мендоза',
'Америка/Меномини',
'Америка/Мерида',
'Америка/Метлакатла',
'Америка/Мехико_Сити',
'Америка/Микелон',
'Америка/Монктон',
'Америка/Монтеррей',
'Америка/Монтевидео',
'Америка/Монреаль',
'Америка/Монтсеррат',
'Америка/Нассау',
'Америка/Нью-Йорк',
'Америка/Нипигон',
'Америка/Ном',
'Америка/Норонья',
'Америка/Северная Дакота/Беула',
'Америка/Северная_Дакота/Центр',
'Америка/Северная_Дакота/Нью-Салем',
'Америка/Нуук',
'Америка/Охинага',
'Америка/Панама',
'Америка/Пангниртунг',
'Америка/Парамарибо',
'Америка/Феникс',
'Америка/Порт-о-Пренс',
'Америка/Порт_Испания',
'Америка/Порто_Акр',
'Америка/Порто_Велью',
'Америка/Пуэрто_Рико',
'Америка/Пунта_Аренас',
'Америка/Дождливая_Река',
'Америка/Ранкин_Инлет',
'Америка/Ресифи',
'Америка/Регина',
«Америка/Решительный»,
'Америка/Рио_Бранко',
'Америка/Росарио',
'Америка/Санта_Изабель',
'Америка/Сантарем',
'Америка/Сантьяго',
'Америка/Санто_Доминго',
'Америка/Сан-Паулу',
'Америка/Скорсбисунд',
'Америка/Шипрок',
'Америка/Ситка',
'Америка/Сент-Бартельми',
'Америка/Сент-Джонс',
'Америка/Сент-Киттс',
'Америка/Сент-Люсия',
'Америка/Сент-Томас',
'Америка/Сент-Винсент',
'Америка/Swift_Current',
'Америка/Тегусигальпа',
'Америка/Туле',
'Америка/Тандер_Бей',
'Америка/Тихуана',
'Америка/Торонто',
'Америка/Тортола',
'Америка/Ванкувер',
'Америка/Девственница',
'Америка/Уайтхорс',
'Америка/Виннипег',
'Америка/Якутат',
'Америка/Желтый Найф',
'Антарктида/Кейси',
'Антарктида/Дэвис',
'Антарктида/Дюмон-ДЮрвиль',
'Антарктида/Маккуори',
'Антарктида/Моусон',
'Антарктида/Мак-Мердо',
'Антарктида/Палмер',
'Антарктида/Ротера',
'Антарктида/Южный_Полюс',
'Антарктида/Сёва',
'Антарктида/Тролль',
'Антарктида/Восток',
'Арктика/Лонгйир',
'Азия/Аден',
'Азия/Алматы',
'Азия/Амман',
'Азия/Анадырь',
'Азия/Актау',
'Азия/Актобе',
'Азия/Ашхабад',
'Азия/Ашхабад',
'Азия/Атырау',
'Азия/Багдад',
'Азия/Бахрейн',
'Азия/Баку',
'Азия/Бангкок',
'Азия/Барнаул',
'Азия/Бейрут',
'Азия/Бишкек',
'Азия/Бруней',
'Азия/Калькутта',
'Азия/Чита',
'Азия/Чойбалсан',
'Азия/Чунцин',
'Азия/Чунцин',
'Азия/Коломбо',
'Азия/Дакка',
'Азия/Дамаск',
'Азия/Дакка',
'Азия/Дили',
'Азия/Дубай',
'Азия/Душанбе',
'Азия/Фамагуста',
'Азия/Газа',
'Азия/Харбин',
'Азия/Хеврон',
'Азия/Хо_Ши_Мин',
'Азия/Гонконг',
'Азия/Ховд',
'Азия/Иркутск',
'Азия/Стамбул',
'Азия/Джакарта',
'Азия/Джаяпура',
'Азия/Иерусалим',
'Азия/Кабул',
'Азия/Камчатка',
'Азия/Карачи',
'Азия/Кашгар',
'Азия/Катманду',
'Азия/Катманду',
'Азия/Хандыга',
'Азия/Калькутта',
'Азия/Красноярск',
'Азия/Куала-Лумпур',
'Азия/Кучинг',
'Азия/Кувейт',
'Азия/Макао',
'Азия/Макао',
'Азия/Магадан',
'Азия/Макассар',
'Азия/Манила',
'Азия/Мускат',
'Азия/Никосия',
'Азия/Новокузнецк',
'Азия/Новосибирск',
'Азия/Омск',
'Азия/Орал',
'Азия/Пномпень',
'Азия/Понтианак',
'Азия/Пхеньян',
'Азия/Катар',
'Азия/Костанай',
'Азия/Кызылорда',
'Азия/Рангун',
'Азия/Рияд',
'Азия/Сайгон',
'Азия/Сахалин',
'Азия/Самарканд',
'Азия/Сеул',
'Азия/Шанхай',
'Азия/Сингапур',
'Азия/Среднеколымск',
'Азия/Тайбэй',
'Азия/Ташкент',
'Азия/Тбилиси',
'Азия/Тегеран',
'Азия/Тель-Авив',
'Азия/Тимбу',
'Азия/Тхимпху',
'Азия/Токио',
'Азия/Томск',
'Азия/Уджунг_Панданг',
'Азия/Улан-Батор',
'Азия/Улан-Батор',
'Азия/Урумчи',
'Азия/Усть-Нера',
'Азия/Вьентьян',
'Азия/Владивосток',
'Азия/Якутск',
'Азия/Янгон',
'Азия/Екатеринбург',
'Азия/Ереван',
'Атлантика/Азорские острова',
'Атлантика/Бермуды',
'Атлантика/Канарейка',
'Атлантика/Кабо-Верде',
'Атлантика/Фареры',
'Атлантика/Фареры',
'Атлантика/Ян_Майен',
'Атлантика/Мадейра',
'Атлантик/Рейкьявик',
'Атлантика/Южная_Джорджия',
'Атлантика/Святая Елена',
'Атлантик/Стэнли',
'Австралия/ACT',
'Австралия/Аделаида',
'Австралия/Брисбен',
'Австралия/Брокен_Хилл',
'Австралия/Канберра',
'Австралия/Карри',
'Австралия/Дарвин',
'Австралия/Юкла',
'Австралия/Хобарт',
'Австралия/LHI',
'Австралия/Линдеман',
'Австралия/Лорд_Хау',
'Австралия/Мельбурн',
'Австралия/Новый Южный Уэльс',
'Австралия/Север',
'Австралия/Перт',
'Австралия/Квинсленд',
'Австралия/Юг',
'Австралия/Сидней',
'Австралия/Тасмания',
'Австралия/Виктория',
'Австралия/Запад',
'Австралия/Янковинна',
'Бразилия/акр',
'Бразилия/ДеНоронья',
'Бразилия/Восток',
'Бразилия/Запад',
"среднеевропейское время",
'CST6CDT',
'Канада/Атлантика',
'Канада/Центральная',
'Канада/Восток',
'Канада/Гора',
'Канада/Ньюфаундленд',
'Канада/Тихий океан',
'Канада/Саскачеван',
'Канада/Юкон',
'Чили/Континентальный',
'Чили/Остров Пасхи',
'Куба',
'ВОСТОЧНОЕВРОПЕЙСКОЕ ВРЕМЯ',
'СТАНДАРТНОЕ ВОСТОЧНОЕ ВРЕМЯ',
'EST5EDT',
'Египет',
'Эйр',
'и т. д./GMT',
'И т. д./GMT+0',
'и т. д./GMT+1',
'и т. д./GMT+10',
'и т. д./GMT+11',
'и т. д./GMT+12',
'и т. д./GMT+2',
'и т. д./GMT+3',
'и т. д./GMT+4',
'и т. д./GMT+5',
'и т. д./GMT+6',
'и т. д./GMT+7',
'и т. д./GMT+8',
'и т.д./GMT+9',
'И т.д./GMT-0',
'И т. д./GMT-1',
'И т.д./GMT-10',
'И т.д./GMT-11',
'И т.д./GMT-12',
'И т.д./GMT-13',
'И т.д./GMT-14',
'И т.д./GMT-2',
'И т.д./GMT-3',
'И т.д./GMT-4',
'И т.д./GMT-5',
'И т.д./GMT-6',
'И т.д./GMT-7',
'И т.д./GMT-8',
'И т.д./GMT-9',
'И т. д./GMT0',
'И т. д./Гринвич',
'И т. д./UCT',
'И т. д./UTC',
'И т. д./Универсальный',
«И т. Д. / Зулу»,
'Европа/Амстердам',
'Европа/Андорра',
'Европа/Астрахань',
'Европа/Афины',
'Европа/Белфаст',
'Европа/Белград',
'Европа/Берлин',
'Европа/Братислава',
'Европа/Брюссель',
'Европа/Бухарест',
'Европа/Будапешт',
'Европа/Бузинген',
'Европа/Кишинев',
'Европа/Копенгаген',
'Европа/Дублин',
'Европа/Гибралтар',
'Европа/Гернси',
'Европа/Хельсинки',
'Европа/Остров_Мэн',
'Европа/Стамбул',
'Европа/Джерси',
'Европа/Калининград',
'Европа/Киев',
'Европа/Киров',
'Европа/Лиссабон',
'Европа/Любляна',
'Европа/Лондон',
'Европа/Люксембург',
'Европа/Мадрид',
'Европа/Мальта',
'Европа/Мариехамн',
'Европа/Минск',
'Европа/Монако',
'Европа/Москва',
'Европа/Никосия',
'Европа/Осло',
'Европа/Париж',
'Европа/Подгорица',
'Европа/Прага',
'Европа/Рига',
'Европа/Рим',
'Европа/Самара',
'Европа/Сан_Марино',
'Европа/Сараево',
'Европа/Саратов',
'Европа/Симферополь',
'Европа/Скопье',
'Европа/София',
'Европа/Стокгольм',
'Европа/Таллинн',
'Европа/Тиран',
'Европа/Тирасполь',
'Европа/Ульяновск',
'Европа/Ужгород',
'Европа/Вадуц',
'Европа/Ватикан',
'Европа/Вена',
'Европа/Вильнюс',
'Европа/Волгоград',
'Европа/Варшава',
'Европа/Загреб',
'Европа/Запорожье',
'Европа/Цюрих',
'Фабрика',
'ГБ',
'GB-Eire',
'ВРЕМЯ ПО ГРИНВИЧУ',
'Время по Гринвичу+0',
'Время по Гринвичу-0',
'Время по Гринвичу0',
'Гринвич',
'ХСТ',
'Гонконг',
'Исландия',
'Индийский/Антананариву',
'Индийский/Чагос',
'Индийский/Рождество',
'Индийский/Кокосовые орехи',
'Индийский/Коморский',
'Индийский/Кергелен',
'Индийский/Маэ',
'Индия/Мальдивы',
'Индийский/маврикийский',
'Индийский/Майотта',
'Индианка/Воссоединение',
'Иран',
'Израиль',
'Ямайка',
'Япония',
'Кваджалейн',
'Ливия',
'ВСТРЕТИЛИСЬ',
'МСТ',
'МСТ7МДТ',
'Мексика/БахаНорте',
'Мексика/Баха-Сур',
'Мексика/Генерал',
"Новая Зеландия",
'НЗ-ЧАТ',
'Навахо',
'КНР',
'PST8PDT',
'Тихий/Апиа',
'Тихий океан/Окленд',
'Тихий океан/Бугенвиль',
'Тихий океан/Чатем',
'Тихий/Чуук',
'Тихий океан/Пасха',
'Тихий/Эфате',
'Тихий океан/Эндербери',
'Тихий океан/Факаофо',
'Тихий океан/Фиджи',
'Тихий океан/Фунафути',
«Тихий океан/Галапагосские острова»,
'Тихий океан/Гамбье',
'Тихий океан/Гуадалканал',
'Тихий океан/Гуам',
'Тихий океан/Гонолулу',
'Тихий океан/Джонстон',
'Тихий/Кантон',
'Тихий океан/Киритимати',
'Тихий океан/Косраэ',
"Тихий океан/Кваджалейн",
'Тихий океан/Маджуро',
'Тихий океан/Маркизские острова',
'Тихий океан / Мидуэй',
'Тихий океан/Науру',
'Тихий океан/Ниуэ',
'Тихий океан/Норфолк',
'Тихий океан/Нумеа',
'Тихий океан/Паго_Паго',
'Тихий океан/Палау',
'Тихий океан/Питкэрн',
'Тихий океан/Понпеи',
'Тихий/Понапе',
'Тихий океан/Порт_Морсби',
'Тихий океан/Раротонга',
'Тихий/Сайпан',
'Тихий океан/Самоа',
'Тихий океан/Таити',
'Тихий океан/Тарава',
'Тихий океан/Тонгатапу',
"Пасифик/Трук",
'Тихий/Пробуждение',
"Пасифик/Уоллис",
'Тихий/Яп',
'Польша',
'Португалия',
'РПЦ',
'РК',
'Сингапур',
'Турция',
'УКТ',
'США/Аляска',
'США/Алеутский',
'США/Аризона',
'США/Центральный',
'США/Восточная Индиана',
'США/Восток',
'США/Гавайи',
'США/Индиана-Старке',
'США/Мичиган',
'США/Гора',
'США/Тихоокеанский регион',
'США/Самоа',
'УНИВЕРСАЛЬНОЕ ГЛОБАЛЬНОЕ ВРЕМЯ',
«Универсальный»,
'В-СУ',
'МОКРЫЙ',
зулу,
'сборка/и т. д./местное время'} Теперь мы можем использовать ZoneInfo для определения текущего времени в разных регионах:
# Функция для преобразования даты и времени в формат времени ISO
def iso(time, time_format="%Y-%m-%d %H:%M:%S"):
время возврата.strftime(time_format)
# часовой пояс CET
cet_tz = ZoneInfo("Европа/Париж")
# часовой пояс по тихоокеанскому времени
pst_tz = ZoneInfo("Америка/Лос-Анджелес")
# Текущее время в Центральной Европе
dt_cet = datetime.now(tz=cet_tz)
# Текущее время в Калифорнии
dt_pst = datetime.now (tz = pst_tz)
print(f"Текущее время в Центральной Европе {iso(dt_cet)}.")
print(f"Текущее время в Калифорнии {iso(dt_pst)}.") Текущее время в Центральной Европе 2022-02-14 11:33:42. Текущее время в Калифорнии 2022-02-14 02:33:42.
Давайте напечатаем datetime.now(tz=cet_tz) :
печать (datetime.now (tz = cet_tz))
2022-02-14 11:33:43.048967+01:00
Мы видим, что есть +01:00 , что указывает на смещение UTC. Действительно, часовой пояс CET на один час опережает UTC.
Кроме того, класс ZoneInfo обрабатывает летнее время. Например, мы можем добавить один день (24 часа) к дню, когда происходит переход на летнее время. В США в 2022 году это произойдет 5 ноября (обратные часы).
# Определить временную дельту time_delta = timedelta (дни = 1) # 5 ноября 2022 г., 15:00 november_5_2022 = datetime(2022, 11, 5, 15, tzinfo=pst_tz) # Обратите внимание, что мы должны использовать tzinfo в конструкции datetime печать(ноябрь_5_2022) # Добавить 1 день к 5 ноября 2022 г. печать (ноябрь_5_2022 + время_дельта)
05.11.2022 15:00:00-07:00 2022-11-06 15:00:00-08:00
Как мы видим, смещение изменилось с -07:00 на -08:00 , но время осталось прежним (15:00).
Таймер обратного отсчета до Нового 2023 года в Нью-Йорке
Times Square в New Your City привлекает тысячи людей в канун Нового года. Давайте применим все, что мы узнали до сих пор, чтобы создать таймер обратного отсчета в канун Нового года на Таймс-сквер!
Здесь мы будем использовать tz из пакета dateutil , который позволяет нам установить местный часовой пояс, чтобы продемонстрировать полезность пакета dateutil . Однако мы также можем использовать файл build/etc/localtime 9.0009 часовой пояс из zoneinfo , чтобы сделать то же самое.
из импорта zoneinfo ZoneInfo
импорт из dateutil tz
из даты и времени импортировать дату и время
деф основной():
"""Основная функция."""
# Установить текущее время в нашем местном часовом поясе
сейчас = datetime.now(tz=tz.tzlocal())
# часовой пояс Нью-Йорка
nyc_tz = ZoneInfo("Америка/Нью-Йорк")
# Новый год 2023 в Нью-Йорке
new_year_2023 = дата/время (2023, 1, 1, 0, 0, tzinfo=nyc_tz)
# Вычислить время, оставшееся до Нового года в Нью-Йорке
обратный отсчет = относительная дельта (новый_год_2023, сейчас)
# Время печати осталось до Нового 2023 года
print(f"Новый год в New Your City наступит: {new_year_2023.strftime('%B %-d, %Y %H:%M:%S')}.")
print(f"До Нового 2023 года в Нью-Йорке осталось: {countdown.months} месяцев, {countdown.days} дней, {countdown.hours} часов, {countdown.minutes} минут, {countdown. seconds} секунд." )
если __name__ == "__main__":
главная() Новый год в Новом Твоем Городе наступит: 1 января 2023 00:00:00. До Нового 2023 года в Нью-Йорке осталось: 10 месяцев, 17 дней, 18 часов, 26 минут, 16 секунд.
Мы обернули код в функцию main() , и теперь мы можем использовать его в файле .py . В этом скрипте мы работали с часовыми поясами, создали объект datetime , преобразовали его в строку с помощью strftime() и даже получили доступ к атрибутам времени relativedelta .объект!
Для практики можно улучшить скрипт. Я пишу этот урок в 2022 году, поэтому для меня Новый год еще не наступил. Если вы читаете его в последующие годы, вы можете улучшить его и учесть тот факт, что Новый 2023 год уже наступил. Вы также можете указать время, оставшееся до будущего Нового года. Или вы можете посчитать время, прошедшее с предыдущего Нового года. Вы также можете обновить скрипт с помощью пакета pytz , чтобы сделать его совместимым со старыми версиями Python (до 3. 9).). Теперь это зависит от вас.
Выводы
Вот что мы рассмотрели в этом руководстве:
- Проблемы с представлением даты и времени на компьютерах
- Создание
даты,времениидаты и времениобъектов - Стандартный формат даты, ISO 8061
- Извлечение дат из строк с помощью
fromisoformat()иstrptime() - Преобразование
объектов datetimeв строки с использованиемстрфтайм() - Временные метки
- Арифметические операции с датами и
timedeltaобъектами - Работа с часовыми поясами в Python с помощью
- Создание таймера обратного отсчета до Нового 2023 года в Нью-Йорке
Теперь у вас есть множество инструментов в вашем наборе инструментов, и вы можете начать работать с датами и временем в Python.
Не стесняйтесь связаться со мной в LinkedIn и GitHub.