Dates

Модуль Dates предоставляет два типа для работы с датами: Date и DateTime, представляющие собой точность в днях и миллисекундах соответственно; оба являются подтипами абстрактного TimeType. Мотивация для различных типов проста: некоторые операции значительно проще, как с точки зрения кода, так и с точки зрения умственного восприятия, когда не нужно иметь дело со сложностями большей точности. Например, поскольку тип 4d61726b646f776e2e436f64652822222c2022446174652229_40726566 разрешает только точность одной даты (т.е. без часов, минут или секунд), обычные соображения по временным зонам, переходу на летнее/зимнее время и високосным секундам становятся ненужными и избегаются.

Оба Date и DateTime по сути являются неизменяемыми обертками Int64. Единственное поле instant любого типа на самом деле является типом UTInstant{P}, который представляет собой непрерывно увеличивающуюся временную шкалу машины, основанную на UT-секунде ^[1]. Тип 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 не учитывает часовые пояса (naive, в терминах Python), аналогично LocalDateTime в Java 8. Дополнительная функциональность часового пояса может быть добавлена через TimeZones.jl package, который компилирует IANA time zone database. Оба 4d61726b646f776e2e436f64652822222c2022446174652229_40726566 и 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 основаны на стандарте ISO 8601, который следует проективному григорианскому календарю. Одно замечание: стандарт ISO 8601 особенно относится к датам до нашей эры (BC/BCE). В общем, последний день эры до нашей эры (BC/BCE), 31-12-1 до н.э. (BC/BCE), был за ним 1-1-1 н.э. (AD/CE), таким образом, года ноль не существует. Однако стандарт ISO утверждает, что 1 до н.э. (BC/BCE) является годом ноль, так что 0000-12-31 — это день перед 0001-01-01, а год -0001 (да, минус один за год) — это 2 до н.э. (BC/BCE), год -0002 — это 3 до н.э. (BC/BCE) и т.д.

Constructors

Date и DateTime типы могут быть сконструированы из целых чисел или Period типов, путем парсинга или через адаптеры (больше об этом позже):

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

julia> Date(Dates.Month(7),Dates.Year(2013))
2013-07-01

Date или DateTime парсинг осуществляется с помощью строк формата. Строки формата работают на основе определения разделенных или фиксированной ширины "слотов", которые содержат период для парсинга, и передают текст для парсинга и строку формата в конструктор 4d61726b646f776e2e436f64652822222c2022446174652229_40726566 или 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 в форме Date("2015-01-01",dateformat"y-m-d") или DateTime("20150101",dateformat"yyyymmdd").

Разделенные слоты обозначаются указанием разделителя, который парсер должен ожидать между двумя последующими периодами; таким образом, "y-m-d" дает парсеру знать, что между первым и вторым слотами в строке даты, такой как "2014-07-16", он должен найти символ -. Символы y, m и d сообщают парсеру, какие периоды нужно анализировать в каждом слоте.

Как и в случае с конструкторами выше, такими как Date(2013), разделенные DateFormat позволяют пропускать части дат и времени, при условии, что предыдущие части указаны. Остальные части получают обычные значения по умолчанию. Например, Date("1981-03", dateformat"y-m-d") возвращает 1981-03-01, в то время как Date("31/12", dateformat"d/m/y") дает 0001-12-31. (Обратите внимание, что год по умолчанию - 1 год н.э.) Однако пустая строка всегда вызывает ArgumentError.

Фиксированные слоты задаются повторением символа точки столько раз, сколько соответствует ширине, без разделителей между символами. Таким образом, dateformat"yyyymmdd" будет соответствовать строке даты, такой как "20140716". Парсер различает фиксированный слот по отсутствию разделителя, отмечая переход "yyyymm" от одного символа точки к следующему.

Поддержка парсинга месяцев в текстовом формате также поддерживается через символы u и U, для сокращенных и полных названий месяцев соответственно. По умолчанию поддерживаются только английские названия месяцев, поэтому u соответствует "Jan", "Feb", "Mar" и т.д. А U соответствует "January", "February", "March" и т.д. Подобно другим функциям сопоставления имя=>значение dayname и monthname, пользовательские локали могут быть загружены путем передачи сопоставления locale=>Dict{String,Int} в словари MONTHTOVALUEABBR и MONTHTOVALUE для сокращенных и полных названий месяцев соответственно.

В приведенных выше примерах использовался строковый макрос dateformat"". Этот макрос создает объект DateFormat один раз при расширении макроса и использует тот же объект DateFormat, даже если фрагмент кода выполняется несколько раз.

julia> for i = 1:10^5
           Date("2015-01-01", dateformat"y-m-d")
       end

Или вы можете явно создать объект DateFormat:

julia> df = DateFormat("y-m-d");

julia> dt = Date("2015-01-01",df)
2015-01-01

julia> dt2 = Date("2015-01-02",df)
2015-01-02

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

julia> years = ["2015", "2016"];

julia> Date.(years, DateFormat("yyyy"))
2-element Vector{Date}:
 2015-01-01
 2016-01-01

Для удобства вы можете передать строку формата напрямую (например, Date("2015-01-01","y-m-d")), хотя эта форма влечет за собой затраты на производительность, если вы многократно разбираете один и тот же формат, так как она внутренне создает новый объект DateFormat каждый раз.

Кроме того, Date или DateTime можно создать из строк с помощью функций parse и tryparse, но с необязательным третьим аргументом типа DateFormat, указывающим формат; например, parse(Date, "06.23.2013", dateformat"m.d.y") или tryparse(DateTime, "1999-12-31T23:59:59"), который использует формат по умолчанию. Основное отличие между функциями заключается в том, что при использовании 4d61726b646f776e2e436f64652822222c202274727970617273652229_40726566 ошибка не возникает, если строка пуста или имеет недопустимый формат; вместо этого возвращается nothing.

Julia 1.9

До Julia 1.9 пустые строки могли передаваться в конструкторы и parse без ошибок, возвращая соответственно DateTime(1), Date(1) или Time(0). Аналогично, tryparse не возвращал nothing.

Полный набор тестов и примеров парсинга и форматирования доступен в stdlib/Dates/test/io.jl.

Durations/Comparisons

Нахождение длины времени между двумя Date или DateTime является простым, учитывая их базовое представление как UTInstant{Day} и UTInstant{Millisecond}, соответственно. Разница между 4d61726b646f776e2e436f64652822222c2022446174652229_40726566 возвращается в количестве Day, а 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 в количестве Millisecond. Аналогично, сравнение TimeType является простой задачей сравнения базовых машинных мгновений (что, в свою очередь, сравнивает внутренние значения Int64).

julia> dt = Date(2012,2,29)
2012-02-29

julia> dt2 = Date(2000,2,1)
2000-02-01

julia> dump(dt)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 734562

julia> dump(dt2)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 730151

julia> dt > dt2
true

julia> dt != dt2
true

julia> dt + dt2
ERROR: MethodError: no method matching +(::Date, ::Date)
[...]

julia> dt * dt2
ERROR: MethodError: no method matching *(::Date, ::Date)
[...]

julia> dt / dt2
ERROR: MethodError: no method matching /(::Date, ::Date)

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

julia> dt = DateTime(2012,2,29)
2012-02-29T00:00:00

julia> dt2 = DateTime(2000,2,1)
2000-02-01T00:00:00

julia> dt - dt2
381110400000 milliseconds

Accessor Functions

Поскольку типы Date и DateTime хранятся как отдельные значения Int64, части или поля даты могут быть извлечены с помощью функций доступа. Функции доступа в нижнем регистре возвращают поле в виде целого числа:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

Пока propercase возвращает то же значение в соответствующем Period типе:

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

Комплексные методы предоставляются, потому что более эффективно получать доступ к нескольким полям одновременно, чем по отдельности:

julia> Dates.yearmonth(t)
(2014, 1)

julia> Dates.monthday(t)
(1, 31)

julia> Dates.yearmonthday(t)
(2014, 1, 31)

Также можно получить доступ к базовому UTInstant или целочисленному значению:

julia> dump(t)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 735264

julia> t.instant
Dates.UTInstant{Day}(Day(735264))

julia> Dates.value(t)
735264

Query Functions

Функции запроса предоставляют календарную информацию о TimeType. Они включают информацию о дне недели:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

julia> Dates.dayofweekofmonth(t) # 5th Friday of January
5

Месяц года:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

Также информация о годе и квартале TimeType:

julia> Dates.isleapyear(t)
false

julia> Dates.dayofyear(t)
31

julia> Dates.quarterofyear(t)
1

julia> Dates.dayofquarter(t)
31

Методы dayname и monthname также могут принимать необязательный ключевое слово locale, которое можно использовать для возврата названия дня или месяца года для других языков/локалей. Существуют также версии этих функций, возвращающие сокращенные названия, а именно dayabbr и monthabbr. Сначала отображение загружается в переменную LOCALES:

julia> french_months = ["janvier", "février", "mars", "avril", "mai", "juin",
                        "juillet", "août", "septembre", "octobre", "novembre", "décembre"];

julia> french_months_abbrev = ["janv","févr","mars","avril","mai","juin",
                              "juil","août","sept","oct","nov","déc"];

julia> french_days = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"];

julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_months_abbrev, french_days, [""]);

Упомянутые выше функции могут быть использованы для выполнения запросов:

julia> Dates.dayname(t;locale="french")
"vendredi"

julia> Dates.monthname(t;locale="french")
"janvier"

julia> Dates.monthabbr(t;locale="french")
"janv"

Поскольку сокращенные версии дней не загружены, попытка использовать функцию dayabbr вызовет ошибку.

julia> Dates.dayabbr(t;locale="french")
ERROR: BoundsError: attempt to access 1-element Vector{String} at index [5]
Stacktrace:
[...]

TimeType-Period Arithmetic

Хорошей практикой при использовании любого языкового/дата фреймворка является знакомство с тем, как обрабатывается арифметика периодов дат, так как есть некоторые tricky issues, с которыми нужно иметь дело (хотя это гораздо менее актуально для типов с точностью до дня).

Модуль Dates пытается следовать простому принципу, стараясь изменить как можно меньше при выполнении арифметики Period. Этот подход также часто известен как календарная арифметика или то, что вы, вероятно, предположите, если кто-то спросит вас о том же вычислении в разговоре. Почему все это так важно? Давайте рассмотрим классический пример: добавьте 1 месяц к 31 января 2014 года. Каков ответ? Javascript скажет March 3 (предполагает 31 день). PHP скажет March 2 (предполагает 30 дней). Факт в том, что правильного ответа нет. В модуле Dates результатом будет 28 февраля. Как он это вычисляет? Рассмотрите классическую азартную игру 7-7-7 в казино.

Теперь просто представьте, что вместо 7-7-7 слоты — это Год-Месяц-День, или в нашем примере, 2014-01-31. Когда вы просите добавить 1 месяц к этой дате, слот месяца увеличивается, так что теперь у нас 2014-02-31. Затем проверяется номер дня, если он больше последнего действительного дня нового месяца; если это так (как в приведенном выше случае), номер дня корректируется до последнего действительного дня (28). Каковы последствия этого подхода? Продолжайте и добавьте еще один месяц к нашей дате, 2014-02-28 + Month(1) == 2014-03-28. Что? Вы ожидали последний день марта? Нет, извините, помните о слотах 7-7-7. Как можно меньше слотов должно измениться, поэтому мы сначала увеличиваем слот месяца на 1, 2014-03-28, и бум, мы закончили, потому что это действительная дата. С другой стороны, если бы мы добавили 2 месяца к нашей исходной дате, 2014-01-31, то мы бы получили 2014-03-31, как и ожидалось. Другим последствием этого подхода является потеря ассоциативности, когда принудительно устанавливается определенный порядок (т.е. добавление вещей в разном порядке приводит к разным результатам). Например:

julia> (Date(2014,1,29)+Dates.Day(1)) + Dates.Month(1)
2014-02-28

julia> (Date(2014,1,29)+Dates.Month(1)) + Dates.Day(1)
2014-03-01

Что там происходит? В первой строке мы добавляем 1 день к 29 января, что приводит к 2014-01-30; затем мы добавляем 1 месяц, и получаем 2014-02-30, который затем корректируется до 2014-02-28. В втором примере мы сначала добавляем 1 месяц, в результате чего получаем 2014-02-29, который корректируется до 2014-02-28, а затем добавляем 1 день, что приводит к 2014-03-01. Один принцип проектирования, который помогает в этом случае, заключается в том, что при наличии нескольких Периодов операции будут упорядочены по типам Периодов, а не по их значению или порядковому номеру; это означает, что Year всегда будет добавляться первым, затем Month, затем Week и т.д. Таким образом, следующее действительно приводит к ассоциативности и просто работает:

julia> Date(2014,1,29) + Dates.Day(1) + Dates.Month(1)
2014-03-01

julia> Date(2014,1,29) + Dates.Month(1) + Dates.Day(1)
2014-03-01

Запутанно? Возможно. Что innocent Dates пользователь должен делать? Главное - быть осведомленным о том, что явное принуждение к определенной ассоциативности при работе с месяцами может привести к неожиданным результатам, но в остальном все должно работать как ожидалось. К счастью, это, в общем-то, вся странность в арифметике периодов дат при работе с временем в UT (избегая "радостей" работы с переходом на летнее/зимнее время, високосными секундами и т.д.).

В качестве бонуса все объекты периодической арифметики работают напрямую с диапазонами:

julia> dr = Date(2014,1,29):Day(1):Date(2014,2,3)
Date("2014-01-29"):Day(1):Date("2014-02-03")

julia> collect(dr)
6-element Vector{Date}:
 2014-01-29
 2014-01-30
 2014-01-31
 2014-02-01
 2014-02-02
 2014-02-03

julia> dr = Date(2014,1,29):Dates.Month(1):Date(2014,07,29)
Date("2014-01-29"):Month(1):Date("2014-07-29")

julia> collect(dr)
7-element Vector{Date}:
 2014-01-29
 2014-02-28
 2014-03-29
 2014-04-29
 2014-05-29
 2014-06-29
 2014-07-29

Adjuster Functions

Хотя арифметика дат и периодов удобна, часто виды расчетов, необходимых для дат, имеют календарный или темпоральный характер, а не фиксированное количество периодов. Праздники являются отличным примером; большинство из них следуют правилам, таким как "День памяти = Последний понедельник мая" или "День благодарения = 4-й четверг ноября". Такие виды темпоральных выражений имеют дело с правилами, относящимися к календарю, такими как первый или последний день месяца, следующий вторник или первые и третьи среды и т.д.

Модуль Dates предоставляет API регулятора через несколько удобных методов, которые помогают просто и лаконично выражать временные правила. Первая группа методов регулятора касается первого и последнего дней недели, месяца, квартала и года. Каждый из них принимает один TimeType в качестве входных данных и возвращает или регулирует к первому или последнему желаемого периода относительно входных данных.

julia> Dates.firstdayofweek(Date(2014,7,16)) # Adjusts the input to the Monday of the input's week
2014-07-14

julia> Dates.lastdayofmonth(Date(2014,7,16)) # Adjusts to the last day of the input's month
2014-07-31

julia> Dates.lastdayofquarter(Date(2014,7,16)) # Adjusts to the last day of the input's quarter
2014-09-30

Следующие два метода более высокого порядка, tonext и toprev, обобщают работу с временными выражениями, принимая DateFunction в качестве первого аргумента, вместе с начальным TimeType. DateFunction — это просто функция, обычно анонимная, которая принимает одно 4d61726b646f776e2e436f64652822222c202254696d65547970652229_40726566 в качестве входных данных и возвращает Bool, true, указывающее на удовлетворение критерия корректировки. Например:

julia> istuesday = x->Dates.dayofweek(x) == Dates.Tuesday; # Returns true if the day of the week of x is Tuesday

julia> Dates.tonext(istuesday, Date(2014,7,13)) # 2014-07-13 is a Sunday
2014-07-15

julia> Dates.tonext(Date(2014,7,13), Dates.Tuesday) # Convenience method provided for day of the week adjustments
2014-07-15

Это полезно с синтаксисом do-блока для более сложных временных выражений:

julia> Dates.tonext(Date(2014,7,13)) do x
           # Return true on the 4th Thursday of November (Thanksgiving)
           Dates.dayofweek(x) == Dates.Thursday &&
           Dates.dayofweekofmonth(x) == 4 &&
           Dates.month(x) == Dates.November
       end
2014-11-27

Метод Base.filter может быть использован для получения всех действительных дат/моментов в указанном диапазоне:

# Pittsburgh street cleaning; Every 2nd Tuesday from April to November
# Date range from January 1st, 2014 to January 1st, 2015
julia> dr = Dates.Date(2014):Day(1):Dates.Date(2015);

julia> filter(dr) do x
           Dates.dayofweek(x) == Dates.Tue &&
           Dates.April <= Dates.month(x) <= Dates.Nov &&
           Dates.dayofweekofmonth(x) == 2
       end
8-element Vector{Date}:
 2014-04-08
 2014-05-13
 2014-06-10
 2014-07-08
 2014-08-12
 2014-09-09
 2014-10-14
 2014-11-11

Дополнительные примеры и тесты доступны в stdlib/Dates/test/adjusters.jl.

Period Types

Периоды — это человеческое восприятие дискретных, иногда нерегулярных промежутков времени. Рассмотрим 1 месяц; он может представлять, в днях, значение 28, 29, 30 или 31 в зависимости от года и контекста месяца. Или год может представлять 365 или 366 дней в случае високосного года. Period типы являются простыми Int64 обертками и создаются путем обертывания любого типа, который можно преобразовать в Int64, т.е. Year(1) или Month(3.0). Арифметика между 4d61726b646f776e2e436f64652822222c2022506572696f642229_40726566 одного типа ведет себя как целые числа, и доступна ограниченная арифметика Period-Real. Вы можете извлечь основное целое число с помощью Dates.value.

julia> y1 = Dates.Year(1)
1 year

julia> y2 = Dates.Year(2)
2 years

julia> y3 = Dates.Year(10)
10 years

julia> y1 + y2
3 years

julia> div(y3,y2)
5

julia> y3 - y2
8 years

julia> y3 % y2
0 years

julia> div(y3,3) # mirrors integer division
3 years

julia> Dates.value(Dates.Millisecond(10))
10

Представление периодов или длительностей, которые не являются целыми кратными базовым типам, может быть достигнуто с помощью типа Dates.CompoundPeriod. Сложные периоды могут быть сконструированы вручную из простых типов Period. Кроме того, функция canonicalize может быть использована для разбиения периода на 4d61726b646f776e2e436f64652822222c202244617465732e436f6d706f756e64506572696f642229_40726566. Это особенно полезно для преобразования длительности, например, разности двух DateTime, в более удобное представление.

julia> cp = Dates.CompoundPeriod(Day(1),Minute(1))
1 day, 1 minute

julia> t1 = DateTime(2018,8,8,16,58,00)
2018-08-08T16:58:00

julia> t2 = DateTime(2021,6,23,10,00,00)
2021-06-23T10:00:00

julia> canonicalize(t2-t1) # creates a CompoundPeriod
149 weeks, 6 days, 17 hours, 2 minutes

Rounding

Date и DateTime значения могут быть округлены до заданного разрешения (например, 1 месяц или 15 минут) с floor, ceil или round:

julia> floor(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:45:00

julia> round(DateTime(2016, 8, 6, 20, 15), Dates.Day)
2016-08-07T00:00:00

В отличие от числового метода round, который по умолчанию разбивает ничьи в сторону четного числа, метод TimeType4d61726b646f776e2e436f64652822222c2022726f756e642229_40726566 использует режим округления RoundNearestTiesUp. (Трудно угадать, что будет означать разбивка ничьих к ближайшему "четному" 4d61726b646f776e2e436f64652822222c202254696d65547970652229_40726566.) Дополнительные сведения о доступных RoundingMode можно найти в API reference.

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

Rounding Epoch

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

julia> round(DateTime(2016, 7, 17, 11, 55), Dates.Hour(10))
2016-07-17T12:00:00

Это может показаться запутанным, учитывая, что час (12) не делится на 10. Причина, по которой была выбрана 2016-07-17T12:00:00, заключается в том, что это 17,676,660 часов после 0000-01-01T00:00:00, и 17,676,660 делится на 10.

Поскольку значения Julia Date и DateTime представлены в соответствии со стандартом ISO 8601, в качестве базовой даты (или "эпохи округления") был выбран 0000-01-01T00:00:00, от которой начинается отсчет дней (и миллисекунд), используемых в расчетах округления. (Обратите внимание, что это немного отличается от внутреннего представления Julia 4d61726b646f776e2e436f64652822222c2022446174652229_40726566, использующего Rata Die notation; но поскольку стандарт ISO 8601 наиболее виден конечному пользователю, в качестве эпохи округления был выбран 0000-01-01T00:00:00, а не 0000-12-31T00:00:00, используемая внутренне, чтобы минимизировать путаницу.)

Единственное исключение из использования 0000-01-01T00:00:00 в качестве эпохи округления — это округление до недель. Округление до ближайшей недели всегда будет возвращать понедельник (первый день недели, как указано в ISO 8601). По этой причине мы используем 0000-01-03T00:00:00 (первый день первой недели года 0000, как определено в ISO 8601) в качестве базы при округлении до количества недель.

Вот связанный случай, в котором ожидаемое поведение не обязательно очевидно: Что происходит, когда мы округляем до ближайшего P(2), где P — это тип Period? В некоторых случаях (в частности, когда P <: Dates.TimePeriod) ответ ясен:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Hour(2))
2016-07-17T08:00:00

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Minute(2))
2016-07-17T08:56:00

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

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Month(2))
2016-07-01T00:00:00

Почему округлять до первого дня июля, даже если это месяц 7 (нечетное число)? Ключ в том, что месяцы индексируются с 1 (первому месяцу присваивается 1), в отличие от часов, минут, секунд и миллисекунд (первым из которых присваивается 0).

Это означает, что округление DateTime до четного кратного секунд, минут, часов или лет (поскольку спецификация ISO 8601 включает нулевой год) приведет к 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 с четным значением в этом поле, в то время как округление 4d61726b646f776e2e436f64652822222c20224461746554696d652229_40726566 до четного кратного месяцев приведет к тому, что поле месяцев будет иметь нечетное значение. Поскольку как месяцы, так и годы могут содержать нерегулярное количество дней, неясно, приведет ли округление до четного числа дней к четному значению в поле дней.

Смотрите API reference для получения дополнительной информации о методах, экспортируемых из модуля Dates.

API reference

Dates and Time Types

Dates.Period — Type

Период
Год
Квартал
Месяц
Неделя
День
Час
Минута
Секунда
Миллисекунда
Микросекунда
Наносекунда

Period типы представляют собой дискретные, человеческие представления времени.

Код	Примеры	Комментарий
`y`	6	Числовой год с фиксированной шириной
`Y`	1996	Числовой год с минимальной шириной
`m`	1, 12	Числовой месяц с минимальной шириной
`u`	Jan	Название месяца, сокращенное до 3-х символов в соответствии с `locale`
`U`	January	Полное название месяца в соответствии с ключевым словом `locale`
`d`	1, 31	День месяца с минимальной шириной
`H`	0, 23	Час (24-часовой формат) с минимальной шириной
`M`	0, 59	Минута с минимальной шириной
`S`	0, 59	Секунда с минимальной шириной
`s`	000, 500	Миллисекунда с минимальной шириной 3
`e`	Mon, Tue	Сокращенные дни недели
`E`	Monday	Полное название дня недели

Код	Совпадения	Комментарий
`Y`	1996, 96	Возвращает год 1996, 0096
`y`	1996, 96	То же самое, что и `Y` при `parse`, но отбрасывает лишние цифры при `format`
`m`	1, 01	Совпадает с 1- или 2-значными месяцами
`u`	Jan	Совпадает с сокращенными названиями месяцев в соответствии с ключевым словом `locale`
`U`	January	Совпадает с полными названиями месяцев в соответствии с ключевым словом `locale`
`d`	1, 01	Совпадает с 1- или 2-значными днями
`H`	00	Совпадает с часами (24-часовой формат)
`I`	00	Для вывода часов в 12-часовом формате
`M`	00	Совпадает с минутами
`S`	00	Совпадает с секундами
`s`	.500	Совпадает с миллисекундами
`e`	Mon, Tues	Совпадает с сокращенными названиями дней недели
`E`	Monday	Совпадает с полными названиями дней недели
`p`	AM	Совпадает с AM/PM (регистр не имеет значения)
`yyyymmdd`	19960101	Совпадает с фиксированной шириной года, месяца и дня

Variable	Abbr.	Value (Int)
`Monday`	`Mon`	1
`Tuesday`	`Tue`	2
`Wednesday`	`Wed`	3
`Thursday`	`Thu`	4
`Friday`	`Fri`	5
`Saturday`	`Sat`	6
`Sunday`	`Sun`	7

Variable	Abbr.	Value (Int)
`January`	`Jan`	1
`February`	`Feb`	2
`March`	`Mar`	3
`April`	`Apr`	4
`May`	`May`	5
`June`	`Jun`	6
`July`	`Jul`	7
`August`	`Aug`	8
`September`	`Sep`	9
`October`	`Oct`	10
`November`	`Nov`	11
`December`	`Dec`	12