Даты
Модуль Dates предоставляет два типа для работы с датами: Date и DateTime, представляющие точность до дня и миллисекунды соответственно; оба являются подтипами абстрактного TimeType. Мотивация для разных типов проста: некоторые операции намного проще, как с точки зрения кода, так и с точки зрения логики, когда не нужно учитывать сложность большей точности. Например, так как тип Date разрешается только с точностью до дня (т.е. без часов, минут или секунд), обычные соображения по часовым поясам, переходу на летнее/зимнее время и високосным секундам не нужны и не учитываются.
Оба типа Date и DateTime — это по существу неизменяемые обертки над Int64. Единственное поле каждого типа — это фактически поле типа UTInstant{P}, представляющее непрерывно возрастающую временную шкалу машины на основе UT секунды [1]. Тип DateTime не учитывает часовые пояса (неявный, по терминологии Python), аналогично типу LocalDateTime в Java 8. Дополнительную функциональность часовых поясов можно добавить с помощью пакета TimeZones.jl, который компилирует базу данных часовых поясов IANA. Оба типа Date и DateTime основаны на стандарте ISO 8601, который следует пролептическому григорианскому календарю. Одна замечание заключается в том, что стандарт ISO 8601 имеет особенности относительно дат до нашей эры (BC/BCE). В общем случае, последний день эры до нашей эры, 1-12-31 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 и так далее.
Конструкторы
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 разбор выполняется с использованием строк формата. Строки формата работают, определяя «слоты» с разделителями или фиксированной шириной, содержащие период для разбора, и передавая текст для разбора и строку формата конструктору Date или DateTime в форме 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 AD/CE.) Однако пустая строка всегда вызывает ArgumentError.
Слоты фиксированной ширины задаются путем повторения символа периода количество раз, соответствующее ширине без разделителя между символами. Таким образом, dateformat"yyyymmdd" соответствует строке даты, например, "20140716". Парсер различает слот фиксированной ширины по отсутствию разделителя, отмечая переход "yyyymm" от одного символа периода к следующему.
Поддержка разбора месяцев в текстовой форме также поддерживается символами u и U для сокращенных и полных названий месяцев соответственно. По умолчанию поддерживаются только английские названия месяцев, поэтому u соответствует «Янв», «Фев», «Март» и т. д. А U соответствует «Январь», «Февраль», «Март» и т. д. Аналогично другим функциям сопоставления «имя»→«значение» 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"), который использует формат по умолчанию. Отличительная особенность функций заключается в том, что с tryparse ошибка не возникает, если строка пустая или имеет неправильный формат; вместо этого возвращается nothing.
До Julia 1.9, пустые строки могли передаваться в конструкторы и parse без ошибок, возвращая соответствующим образом DateTime(1), Date(1) или Time(0). Аналогично, tryparse не возвращало nothing.
Полный набор тестов и примеров разбора и форматирования доступен в stdlib/Dates/test/io.jl.
Длительности/Сравнения
Определение длительности между двумя Date или DateTime легко, учитывая их внутреннее представление как UTInstant{Day} и UTInstant{Millisecond} соответственно. Разница между Date возвращается в количестве Day, и DateTime в количестве 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
Функции-аксессоры
Поскольку типы 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
В то время как функции-аксессоры с заглавными буквами возвращают то же значение в соответствующем типе 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
Функции запроса
Функции запроса предоставляют календарную информацию о 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_monts_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_monts_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
Полезно при использовании любого языка/фреймворка для работы с датами и временем ознакомиться с тем, как обрабатывается арифметика дат и периодов, так как есть некоторые сложные вопросы (хотя гораздо меньше для типов с точностью до дня).
Подход модуля Dates пытается следовать простому принципу, чтобы при выполнении арифметики с Period минимально изменять исходные данные. Этот подход также часто называют календарной арифметикой или тем, что вы, вероятно, предположили бы, если бы вас попросили выполнить то же самое вычисление в разговоре. Зачем всё это? Давайте рассмотрим классический пример: прибавить 1 месяц к 31 января 2014 года. Какой ответ? Javascript скажет 3 марта (предполагается 31 день). PHP скажет 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
Сложно? Возможно. Что делать обычному пользователю 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
Функции корректировки
Хотя арифметика дат-периодов удобна, часто вычисления, необходимые для дат, имеют *календарный* или *временной* характер, а не фиксированное число периодов. Праздники — идеальный пример; большинство следуют правилам, таким как «День поминовения = Последний понедельник мая» или «День благодарения = Четвертый четверг ноября». Эти виды временных выражений работают с правилами, относящимися к календарю, например, первое или последнее число месяца, следующее вторник или первый и третий среды и т. д.
Модуль 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 — это просто функция, обычно анонимная, которая принимает на вход одиночный TimeType и возвращает 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.
Типы периодов
Периоды — это человеческое представление о дискретных, иногда нерегулярных временных интервалах. Рассмотрим 1 месяц; он может представлять, в днях, значение 28, 29, 30 или 31 в зависимости от года и месяца. Или год может представлять 365 или 366 дней в случае високосного года. Типы Period — это простые обёртки Int64 и создаются с помощью обертывания любого типа, преобразуемого в Int64, т. е. Year(1) или Month(3.0). Арифметика между Period одного типа ведёт себя как арифметика целых чисел, и доступна ограниченная арифметика 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 может использоваться для разбиения периода на Dates.CompoundPeriod. Это особенно полезно для преобразования длительности, например, разницы между двумя 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
Округление
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, который по умолчанию округляет до ближайшего чётного числа, метод TimeTyperound использует режим округления RoundNearestTiesUp. (Трудно предположить, что бы означало округление до ближайшего "чётного" TimeType). Более подробные сведения об доступных режимах округления можно найти в справочнике API.
Округление, как правило, должно работать как ожидается, но есть несколько случаев, в которых ожидаемое поведение не очевидно.
Округление эпохи
Во многих случаях разрешение, указанное для округления (например, 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 значений Date с использованием обозначения Rata Die; но поскольку стандарт 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 включает год ноль) приведёт к DateTime с чётным значением в соответствующем поле, в то время как округление DateTime до чётного кратного месяцев приведёт к нечётного значения в поле месяца. Поскольку и месяцы, и годы могут содержать неравное число дней, не известно, приведёт ли округление до чётного числа дней к чётному значению в поле дней.
См. справочник API для получения дополнительной информации о методах, экспортированных из модуля Dates.
Справочник API
Типы дат и времени
Dates.PeriodТип
Period Year Quarter Month Week Day Hour Minute Second Millisecond Microsecond Nanosecond
Period типы представляют дискретные, человекочитаемые представления времени.
Dates.CompoundPeriodТип
CompoundPeriod
CompoundPeriod полезен для выражения временных интервалов, которые не являются фиксированным кратным более мелким интервалам. Например, «год и один день» не является фиксированным числом дней, но может быть выражено с помощью CompoundPeriod. Фактически, CompoundPeriod автоматически генерируется при сложении разных типов интервалов, например, Year(1) + Day(1) приводит к результату типа CompoundPeriod.
Dates.InstantТип
Instant
Instant типы представляют целочисленные, машиночитаемые представления времени как непрерывные временные шкалы, начиная с эпохи.
Dates.UTInstantТип
UTInstant{T}
UTInstant представляет собой машиночитаемую временную шкалу, основанную на времени UT (1 день = одно вращение Земли). T — это Period параметр, который указывает разрешение или точность момента.
Dates.TimeTypeТип
TimeType
TimeType типы оборачивают Instant машинные экземпляры, чтобы предоставить человекочитаемые представления машинного момента. Time, DateTime и Date являются подтипами TimeType.
Dates.DateTimeТип
DateTime
DateTime оборачивает UTInstant{Millisecond} и интерпретирует его в соответствии с пролептическим григорианским календарем.
Dates.DateТип
Date
Date оборачивает UTInstant{Day} и интерпретирует его в соответствии с пролептическим григорианским календарем.
Dates.TimeТип
Time
Time оборачивает Nanosecond и представляет собой определенный момент в 24-часовом дне.
Dates.TimeZoneТип
TimeZone
Географическая зона, обычно основанная на долготе, определяющая время в определенном месте. Некоторые часовые пояса соблюдают летнее время (например, EST -> EDT). Для реализации и большей поддержки обратитесь к пакету TimeZones.jl
Dates.UTCТип
UTC
UTC, или Координированное универсальное время, является TimeZone, от которого отсчитываются все остальные. Он связан со временем на 0° долготы. Он не корректируется на летнее время.
Функции дат
Dates.DateTimeМетод
DateTime(y, [m, d, h, mi, s, ms]) -> DateTime
Создайте тип DateTime по частям. Аргументы должны быть преобразуемы к Int64.
Dates.DateTimeМетод
DateTime(periods::Period...) -> DateTime
Создайте тип DateTime по частям типа Period. Аргументы могут быть в любом порядке. Части DateTime, не предоставленные, будут иметь значение по умолчанию Dates.default(period).
Dates.DateTimeМетод
DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), limit=10000) -> DateTime
Создайте DateTime с помощью API корректировки. Точка отсчета будет построена из предоставленных аргументов y, m, d..., и будет корректироваться до тех пор, пока f::Function не вернет true. Шаг корректировки может быть задан вручную через ключевое слово step. limit задает предел максимального количества итераций, которые API корректировки будет выполнять перед ошибкой (в случае, если f::Function никогда не выполняется).
Примеры
julia> DateTime(dt -> second(dt) == 40, 2010, 10, 20, 10; step = Second(1)) 2010-10-20T10:00:40 julia> DateTime(dt -> hour(dt) == 20, 2010, 10, 20, 10; step = Hour(1), limit = 5) ERROR: ArgumentError: Adjustment limit reached: 5 iterations Stacktrace: [...]
Dates.DateTimeМетод
DateTime(dt::Date) -> DateTime
Преобразуйте Date в DateTime. Части часа, минуты, секунды и миллисекунды нового DateTime предполагаются равными нулю.
Dates.DateTimeМетод
DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime
Создайте DateTime, проанализировав строку даты и времени dt в соответствии с шаблоном, заданным в строке format (см. DateFormat для синтаксиса).
Этот метод создает объект DateFormat каждый раз при вызове. Рекомендуется создать объект DateFormat и использовать его как второй аргумент, чтобы избежать потери производительности при многократном использовании одного и того же формата.
Пример
julia> DateTime("2020-01-01", "yyyy-mm-dd")
2020-01-01T00:00:00
julia> a = ("2020-01-01", "2020-01-02");
julia> [DateTime(d, dateformat"yyyy-mm-dd") for d ∈ a] # preferred
2-element Vector{DateTime}:
2020-01-01T00:00:00
2020-01-02T00:00:00
Dates.formatМетод
format(dt::TimeType, format::AbstractString; locale="english") -> AbstractString
Создайте строку, используя объект TimeType и применяя предоставленный format. Для построения строки format можно использовать следующие символы:
| Код | Примеры | Комментарий |
|---|---|---|
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 | Полное название дня недели |
Количество последовательных символов кода указывает ширину кода. Формат yyyy-mm указывает, что код y должен иметь ширину четыре, а m - ширину два. Коды, которые возвращают числовые цифры, имеют связанный режим: фиксированная или минимальная ширина. Режим фиксированной ширины заполняет слева нулями значение, если оно короче заданной ширины, и обрезает значение, если оно длиннее. Режим минимальной ширины работает так же, как режим фиксированной ширины, за исключением того, что он не обрезает значения, которые длиннее заданной ширины.
При создании format вы можете использовать любые символы, не являющиеся кодом, в качестве разделителя. Например, чтобы сгенерировать строку «1996-01-15T00:00:00», вы можете использовать format: «yyyy-mm-ddTHH:MM:SS». Обратите внимание, что если вам нужно использовать символ кода как литерный символ, вы можете использовать символ экранирования обратный слэш. Строка «1996y01m» может быть получена с помощью формата «yyyy\ymm\m».
Dates.DateFormatТип
DateFormat(format::AbstractString, locale="english") -> DateFormat
Создайте объект форматирования даты, который можно использовать для анализа строк дат или форматирования объекта даты в виде строки. Следующие символьные коды могут быть использованы для построения строки format:
| Код | Совпадения | Комментарий |
|---|---|---|
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 | Соответствует году, месяцу и дню с фиксированной шириной |
Символы, не перечисленные выше, обычно обрабатываются как разделители между частями даты и времени. Например, строка "1996-01-15T00:00:00.0" будет иметь строку формата "y-m-dTH:M:S.s". Если вам нужно использовать символ кода в качестве разделителя, вы можете экранировать его с помощью обратного слэша. Дата "1995y01m" будет иметь формат "y\ym\m".
Обратите внимание, что 12:00 AM соответствует 00:00 (полночь), а 12:00 PM соответствует 12:00 (полдень). При анализе времени со спецификатором p, любая цифра часа (как H, так и I) интерпретируется как 12-часовой формат, поэтому код I в основном полезен для вывода.
Создание объекта DateFormat требует ресурсов. Всякий раз, когда это возможно, создайте его один раз и используйте многократно или попробуйте использовать макрос строки dateformat"". Использование этого макроса создает объект DateFormat один раз во время расширения макроса и повторно использует его позже. Также доступны несколько предопределенных форматировщиков, перечисленных позже.
См. DateTime и format, чтобы узнать, как использовать объект DateFormat для анализа и записи строк дат соответственно.
Dates.@dateformat_strМакрос
dateformat"Y-m-d H:M:S"
Создайте объект DateFormat. Аналогично DateFormat("Y-m-d H:M:S"), но создает объект DateFormat один раз во время расширения макроса.
См. DateFormat для получения подробной информации о спецификаторах формата.
Dates.DateTimeМетод
DateTime(dt::AbstractString, df::DateFormat=ISODateTimeFormat) -> DateTime
Создайте объект DateTime, проанализировав строку даты и времени dt по шаблону, заданному объектом DateFormat, или "yyyy-mm-dd\THH:MM:SS.s" по умолчанию.
Аналогично DateTime(::AbstractString, ::AbstractString), но более эффективно при многократном анализе строк дат и времени с предварительно созданным объектом DateFormat.
Dates.DateМетод
Date(y, [m, d]) -> Date
Создайте тип Date по частям. Аргументы должны быть преобразуемы к Int64.
Dates.DateМетод
Date(period::Period...) -> Date
Создайте тип Date по частям типа Period. Аргументы могут быть в любом порядке. Date Части, которые не указаны, будут по умолчанию иметь значение Dates.default(period).
Dates.DateМетод
Date(f::Function, y[, m, d]; step=Day(1), limit=10000) -> Date
Создайте Date с помощью API корректировки. Начальная точка будет создана из предоставленных аргументов y, m, d, и будет корректироваться до тех пор, пока f::Function не вернет true. Размер шага при корректировке можно указать вручную с помощью ключевого слова step. limit задаёт ограничение на максимальное количество итераций, которые API корректировки будет выполнять, прежде чем выдать ошибку (при условии, что f::Function никогда не будет удовлетворена).
Примеры
julia> Date(date -> week(date) == 20, 2010, 01, 01) 2010-05-17 julia> Date(date -> year(date) == 2010, 2000, 01, 01) 2010-01-01 julia> Date(date -> month(date) == 10, 2000, 01, 01; limit = 5) ERROR: ArgumentError: Adjustment limit reached: 5 iterations Stacktrace: [...]
Dates.DateМетод
Date(dt::DateTime) -> Date
Преобразуйте DateTime в Date. Части часа, минуты, секунды и миллисекунды в DateTime усекаются, поэтому при построении используются только год, месяц и день.
Dates.DateМетод
Date(d::AbstractString, format::AbstractString; locale="english") -> Date
Создайте Date, проанализировав строку даты d по шаблону, заданному в строке format (синтаксис см. в DateFormat).
Этот метод создаёт объект DateFormat каждый раз при вызове. Рекомендуется создавать объект DateFormat вместо этого и использовать его в качестве второго аргумента, чтобы избежать потери производительности при многократном использовании одного и того же формата.
Пример
julia> Date("2020-01-01", "yyyy-mm-dd")
2020-01-01
julia> a = ("2020-01-01", "2020-01-02");
julia> [Date(d, dateformat"yyyy-mm-dd") for d ∈ a] # preferred
2-element Vector{Date}:
2020-01-01
2020-01-02
Dates.DateМетод
Date(d::AbstractString, df::DateFormat=ISODateFormat) -> Date
Создайте Date, проанализировав строку даты d по шаблону, заданному объектом DateFormat, или по умолчанию "yyyy-mm-dd".
Аналогично Date(::AbstractString, ::AbstractString), но более эффективно при многократном анализе строк дат с предварительно созданным объектом DateFormat.
Dates.TimeМетод
Time(h, [mi, s, ms, us, ns]) -> Time
Создайте тип Time по частям. Аргументы должны быть преобразуемы к Int64.
Dates.TimeМетод
Time(period::TimePeriod...) -> Time
Создайте тип Time по частям типа Period. Аргументы могут быть в любом порядке. Time Части, которые не указаны, будут по умолчанию иметь значение Dates.default(period).
Dates.TimeМетод
Time(f::Function, h, mi=0; step::Period=Second(1), limit::Int=10000) Time(f::Function, h, mi, s; step::Period=Millisecond(1), limit::Int=10000) Time(f::Function, h, mi, s, ms; step::Period=Microsecond(1), limit::Int=10000) Time(f::Function, h, mi, s, ms, us; step::Period=Nanosecond(1), limit::Int=10000)
Создайте Time с помощью API корректировки. Начальная точка будет создана из предоставленных аргументов h, mi, s, ms, us, и будет корректироваться до тех пор, пока f::Function не вернет true. Размер шага при корректировке можно указать вручную с помощью ключевого слова step. limit задаёт ограничение на максимальное количество итераций, которые API корректировки будет выполнять, прежде чем выдать ошибку (в случае, если f::Function никогда не будет удовлетворена). Обратите внимание, что шаг по умолчанию будет скорректирован для обеспечения большей точности для заданных аргументов; например, если указаны час, минута и секунда, шаг по умолчанию будет Millisecond(1), а не Second(1).
Примеры
julia> Time(t -> minute(t) == 30, 20) 20:30:00 julia> Time(t -> minute(t) == 0, 20) 20:00:00 julia> Time(t -> hour(t) == 10, 3; limit = 5) ERROR: ArgumentError: Adjustment limit reached: 5 iterations Stacktrace: [...]
Dates.TimeМетод
Time(dt::DateTime) -> Time
Преобразуйте DateTime в Time. Части часа, минуты, секунды и миллисекунды в DateTime используются для создания нового Time. Микросекунды и наносекунды по умолчанию равны нулю.
Dates.TimeМетод
Time(t::AbstractString, format::AbstractString; locale="english") -> Time
Создайте Time, разобрав строку времени t по шаблону, заданному в строке format (см. DateFormat для синтаксиса).
Этот метод создаёт объект DateFormat каждый раз при вызове. Рекомендуется создать объект DateFormat и использовать его как второй аргумент, чтобы избежать потерь производительности при многократном использовании одного и того же формата.
Пример
julia> Time("12:34pm", "HH:MMp")
12:34:00
julia> a = ("12:34pm", "2:34am");
julia> [Time(d, dateformat"HH:MMp") for d ∈ a] # preferred
2-element Vector{Time}:
12:34:00
02:34:00
Dates.TimeМетод
Time(t::AbstractString, df::DateFormat=ISOTimeFormat) -> Time
Создайте Time, разобрав строку даты и времени t по шаблону, указанному в объекте DateFormat, или «HH:MM:SS.s», если он опущен.
Аналогично Time(::AbstractString, ::AbstractString), но более эффективен при многократном разборе строк времени с подобным форматом с помощью предварительно созданного объекта DateFormat.
Dates.nowМетод
now() -> DateTime
Возвращает DateTime, соответствующий системному времени пользователя, включая часовой пояс.
Dates.nowМетод
now(::Type{UTC}) -> DateTime
Возвращает DateTime, соответствующий системному времени пользователя в формате UTC/GMT.
Base.epsМетод
eps(::Type{DateTime}) -> Millisecond
eps(::Type{Date}) -> Day
eps(::Type{Time}) -> Nanosecond
eps(::TimeType) -> Period
Возвращает наименьшее значение единицы, поддерживаемое TimeType.
Примеры
julia> eps(DateTime) 1 millisecond julia> eps(Date) 1 day julia> eps(Time) 1 nanosecond
Функции доступа
Dates.yearФункция
year(dt::TimeType) -> Int64
Год Date или DateTime в формате Int64.
Dates.monthФункция
month(dt::TimeType) -> Int64
Месяц Date или DateTime в формате Int64.
Dates.weekФункция
week(dt::TimeType) -> Int64
Возвращает номер недели ISO Date или DateTime в формате Int64. Обратите внимание, что первая неделя года — это неделя, содержащая первый четверг года, что может привести к тому, что даты до 4 января будут в последней неделе предыдущего года. Например, week(Date(2005, 1, 1)) — 53-я неделя 2004 года.
Примеры
julia> week(Date(1989, 6, 22)) 25 julia> week(Date(2005, 1, 1)) 53 julia> week(Date(2004, 12, 31)) 53
Dates.dayФункция
day(dt::TimeType) -> Int64
День месяца Date или DateTime в формате Int64.
Dates.hourФункция
hour(dt::DateTime) -> Int64
Час дня DateTime в формате Int64.
hour(t::Time) -> Int64
Час Time в формате Int64.
Dates.minuteФункция
minute(dt::DateTime) -> Int64
Минута DateTime в формате Int64.
minute(t::Time) -> Int64
Минута Time в формате Int64.
Dates.secondФункция
second(dt::DateTime) -> Int64
Секунда DateTime в формате Int64.
second(t::Time) -> Int64
Секунда Time в формате Int64.
Dates.millisecondФункция
millisecond(dt::DateTime) -> Int64
Миллисекунда DateTime в формате Int64.
millisecond(t::Time) -> Int64
Миллисекунда Time в формате Int64.
Dates.microsecondФункция
microsecond(t::Time) -> Int64
Микросекунда Time в формате Int64.
Dates.nanosecondФункция
nanosecond(t::Time) -> Int64
Наносекунда Time в формате Int64.
Dates.YearМетод
Year(v)
Создаёт объект Year с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.
Dates.MonthМетод
Month(v)
Создаёт объект Month с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.
Dates.WeekМетод
Week(v)
Создаёт объект Week с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.
Dates.DayМетод
Day(v)
Создаёт объект Day с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.
Dates.HourМетод
Hour(dt::DateTime) -> Hour
Часовая часть DateTime как Hour.
Dates.MinuteМетод
Minute(dt::DateTime) -> Minute
Минутная часть DateTime как Minute.
Dates.SecondМетод
Second(dt::DateTime) -> Second
Секундная часть DateTime как Second.
Dates.MillisecondМетод
Millisecond(dt::DateTime) -> Millisecond
Миллисекундная часть DateTime как Millisecond.
Dates.MicrosecondМетод
Microsecond(dt::Time) -> Microsecond
Микросекундная часть Time как Microsecond.
Dates.NanosecondМетод
Nanosecond(dt::Time) -> Nanosecond
Наносекундная часть Time как Nanosecond.
Dates.yearmonthФункция
yearmonth(dt::TimeType) -> (Int64, Int64)
Одновременное возвращение частей года и месяца Date или DateTime.
Dates.monthdayФункция
monthday(dt::TimeType) -> (Int64, Int64)
Одновременное возвращение частей месяца и дня Date или DateTime.
Dates.yearmonthdayФункция
yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)
Одновременное возвращение частей года, месяца и дня Date или DateTime.
Функции запроса
Dates.daynameФункция
dayname(dt::TimeType; locale="english") -> String dayname(day::Integer; locale="english") -> String
Возвращает полное имя дня недели Date или DateTime в указанном locale. Также принимает Integer.
Примеры
julia> dayname(Date("2000-01-01"))
"Saturday"
julia> dayname(4)
"Thursday"
Dates.dayabbrФункция
dayabbr(dt::TimeType; locale="english") -> String dayabbr(day::Integer; locale="english") -> String
Возвращает сокращённое имя дня недели Date или DateTime в указанном locale. Также принимает Integer.
Примеры
julia> dayabbr(Date("2000-01-01"))
"Sat"
julia> dayabbr(3)
"Wed"
Dates.dayofweekФункция
dayofweek(dt::TimeType) -> Int64
Возвращает день недели как Int64 с 1 = Monday, 2 = Tuesday, etc..
Примеры
julia> dayofweek(Date("2000-01-01"))
6
Dates.dayofmonthФункция
dayofmonth(dt::TimeType) -> Int64
День месяца Date или DateTime в формате Int64.
Dates.dayofweekofmonthФункция
dayofweekofmonth(dt::TimeType) -> Int
Для дня недели dt, вернуть номер этого дня в месяце dt. Например, если день недели dt — понедельник, то 1 = First Monday of the month, 2 = Second Monday of the month, etc. В диапазоне от 1 до 5.
Примеры
julia> dayofweekofmonth(Date("2000-02-01"))
1
julia> dayofweekofmonth(Date("2000-02-08"))
2
julia> dayofweekofmonth(Date("2000-02-15"))
3
Dates.daysofweekinmonthФункция
daysofweekinmonth(dt::TimeType) -> Int
Для дня недели dt, вернуть общее количество этого дня недели в месяце dt. Возвращает 4 или 5. Полезно в временных выражениях для указания последнего дня недели в месяце, включив dayofweekofmonth(dt) == daysofweekinmonth(dt) в функцию корректировки.
Примеры
julia> daysofweekinmonth(Date("2005-01-01"))
5
julia> daysofweekinmonth(Date("2005-01-04"))
4
Dates.monthnameФункция
monthname(dt::TimeType; locale="english") -> String monthname(month::Integer, locale="english") -> String
Возвращает полное имя месяца Date или DateTime или Integer в заданном locale.
Примеры
julia> monthname(Date("2005-01-04"))
"January"
julia> monthname(2)
"February"
Dates.monthabbrФункция
monthabbr(dt::TimeType; locale="english") -> String monthabbr(month::Integer, locale="english") -> String
Возвращает сокращенное имя месяца Date или DateTime или Integer в заданном locale.
Примеры
julia> monthabbr(Date("2005-01-04"))
"Jan"
julia> monthabbr(2)
"Feb"
Dates.daysinmonthФункция
daysinmonth(dt::TimeType) -> Int
Возвращает количество дней в месяце dt. Значение будет 28, 29, 30 или 31.
Примеры
julia> daysinmonth(Date("2000-01"))
31
julia> daysinmonth(Date("2001-02"))
28
julia> daysinmonth(Date("2000-02"))
29
Dates.isleapyearФункция
isleapyear(dt::TimeType) -> Bool
Возвращает true, если год dt високосный.
Примеры
julia> isleapyear(Date("2004"))
true
julia> isleapyear(Date("2005"))
false
Dates.dayofyearФункция
dayofyear(dt::TimeType) -> Int
Возвращает день года для dt, где 1 января — день 1.
Dates.daysinyearФункция
daysinyear(dt::TimeType) -> Int
Возвращает 366, если год dt високосный, иначе возвращает 365.
Примеры
julia> daysinyear(1999) 365 julia> daysinyear(2000) 366
Dates.quarterofyearФункция
quarterofyear(dt::TimeType) -> Int
Возвращает квартал, в котором находится dt. Диапазон значений от 1 до 4.
Dates.dayofquarterФункция
dayofquarter(dt::TimeType) -> Int
Возвращает день текущего квартала dt. Диапазон значений от 1 до 92.
Функции корректировки
Base.truncМетод
trunc(dt::TimeType, ::Type{Period}) -> TimeType
Обрезает значение dt в соответствии с предоставленным типом Period.
Примеры
julia> trunc(DateTime("1996-01-01T12:30:00"), Day)
1996-01-01T00:00:00
Dates.firstdayofweekФункция
firstdayofweek(dt::TimeType) -> TimeType
Корректирует dt до понедельника своей недели.
Примеры
julia> firstdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-01T00:00:00
Dates.lastdayofweekФункция
lastdayofweek(dt::TimeType) -> TimeType
Корректирует dt до воскресенья своей недели.
Примеры
julia> lastdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-07T00:00:00
Dates.firstdayofmonthФункция
firstdayofmonth(dt::TimeType) -> TimeType
Корректирует dt до первого числа своего месяца.
Примеры
julia> firstdayofmonth(DateTime("1996-05-20"))
1996-05-01T00:00:00
Dates.lastdayofmonthФункция
lastdayofmonth(dt::TimeType) -> TimeType
Корректирует dt до последнего числа своего месяца.
Примеры
julia> lastdayofmonth(DateTime("1996-05-20"))
1996-05-31T00:00:00
Dates.firstdayofyearФункция
firstdayofyear(dt::TimeType) -> TimeType
Корректирует dt до первого числа своего года.
Примеры
julia> firstdayofyear(DateTime("1996-05-20"))
1996-01-01T00:00:00
Dates.lastdayofyearФункция
lastdayofyear(dt::TimeType) -> TimeType
Корректирует dt до последнего числа своего года.
Примеры
julia> lastdayofyear(DateTime("1996-05-20"))
1996-12-31T00:00:00
Dates.firstdayofquarterФункция
firstdayofquarter(dt::TimeType) -> TimeType
Корректирует dt до первого числа своего квартала.
Примеры
julia> firstdayofquarter(DateTime("1996-05-20"))
1996-04-01T00:00:00
julia> firstdayofquarter(DateTime("1996-08-20"))
1996-07-01T00:00:00
Dates.lastdayofquarterФункция
lastdayofquarter(dt::TimeType) -> TimeType
Корректирует dt до последнего числа своего квартала.
Примеры
julia> lastdayofquarter(DateTime("1996-05-20"))
1996-06-30T00:00:00
julia> lastdayofquarter(DateTime("1996-08-20"))
1996-09-30T00:00:00
Dates.tonextМетод
tonext(dt::TimeType, dow::Int; same::Bool=false) -> TimeType
Корректирует dt до следующего дня недели, соответствующего dow, с шагом 1 = Monday, 2 = Tuesday, etc. Установка same=true позволяет рассматривать текущий dt как следующий dow, что предотвращает корректировку.
Dates.toprevМетод
toprev(dt::TimeType, dow::Int; same::Bool=false) -> TimeType
Корректирует dt до предыдущего дня недели, соответствующего dow, с шагом 1 = Monday, 2 = Tuesday, etc. Установка same=true позволяет рассматривать текущий dt как предыдущий dow, что предотвращает корректировку.
Dates.tofirstФункция
tofirst(dt::TimeType, dow::Int; of=Month) -> TimeType
Корректирует dt до первого dow своего месяца. В качестве альтернативы, of=Year скорректирует до первого dow года.
Dates.tolastФункция
tolast(dt::TimeType, dow::Int; of=Month) -> TimeType
Корректирует dt до последнего dow своего месяца. В качестве альтернативы, of=Year скорректирует до последнего dow года.
Dates.tonextМетод
tonext(func::Function, dt::TimeType; step=Day(1), limit=10000, same=false) -> TimeType
Корректирует dt, итерационно максимум limit раз с шагом step до тех пор, пока func не вернёт true. func должна принимать единственный аргумент TimeType и возвращать Bool. same позволяет рассматривать dt как удовлетворяющее условию func.
Dates.toprevМетод
toprev(func::Function, dt::TimeType; step=Day(-1), limit=10000, same=false) -> TimeType
Корректирует dt итерационно максимум limit раз с шагом step до тех пор, пока func не вернёт true. func должна принимать единственный аргумент TimeType и возвращать Bool. same позволяет рассматривать dt как удовлетворяющее условию func.
Периоды
Dates.PeriodМетод
Year(v) Quarter(v) Month(v) Week(v) Day(v) Hour(v) Minute(v) Second(v) Millisecond(v) Microsecond(v) Nanosecond(v)
Создаёт тип Period со значением v. Входное значение должно быть без потерь преобразуемо в Int64.
Dates.CompoundPeriodМетод
CompoundPeriod(periods) -> CompoundPeriod
Создаёт CompoundPeriod из Vector Period. Все Period одного типа складываются.
Примеры
julia> Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13)) 25 hours julia> Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1)) -1 hour, 1 minute julia> Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2)) 1 month, -2 weeks julia> Dates.CompoundPeriod(Dates.Minute(50000)) 50000 minutes
Dates.canonicalizeФункция
canonicalize(::CompoundPeriod) -> CompoundPeriod
Приводит CompoundPeriod к канонической форме, применяя следующие правила:
- Любой
Periodдостаточно большой, чтобы быть частично представленным более грубымPeriod, разбивается на несколькоPeriod(например,Hour(30)становитсяDay(1) + Hour(6)). -
Periodс противоположными знаками будут объединены, если это возможно (например,Hour(1) - Day(1)становится-Hour(23)).
Примеры
julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13))) 1 day, 1 hour julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1))) -59 minutes julia> canonicalize(Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2))) 1 month, -2 weeks julia> canonicalize(Dates.CompoundPeriod(Dates.Minute(50000))) 4 weeks, 6 days, 17 hours, 20 minutes
Dates.valueФункция
Dates.value(x::Period) -> Int64
Для данного периода возвращает связанное значение. Например, value(Millisecond(10)) возвращает 10 как целое число.
Dates.defaultФункция
default(p::Period) -> Period
Возвращает разумное «значение по умолчанию» для входящего периода, возвращая T(1) для Года, Месяца и Дня, и T(0) для Часа, Минуты, Секунды и Миллисекунды.
Dates.periodsФункция
Dates.periods(::CompoundPeriod) -> Vector{Period}
Возвращает Vector Period , которые составляют данный CompoundPeriod.
Эта функция требует Julia 1.7 или новее.
Функции округления
Значения Date и DateTime можно округлить до заданного разрешения (например, 1 месяц или 15 минут) с помощью floor, ceil, или round.
Base.floorМетод
floor(dt::TimeType, p::Period) -> TimeType
Возвращает ближайшее значение Date или DateTime, меньшее или равное dt с разрешением p.
Для удобства p может быть типом вместо значения: floor(dt, Dates.Hour) — это сокращение для floor(dt, Dates.Hour(1)).
julia> floor(Date(1985, 8, 16), Month) 1985-08-01 julia> floor(DateTime(2013, 2, 13, 0, 31, 20), Minute(15)) 2013-02-13T00:30:00 julia> floor(DateTime(2016, 8, 6, 12, 0, 0), Day) 2016-08-06T00:00:00
Base.ceilМетод
ceil(dt::TimeType, p::Period) -> TimeType
Возвращает ближайшее значение Date или DateTime, большее или равное dt с разрешением p.
Для удобства p может быть типом вместо значения: ceil(dt, Dates.Hour) — это сокращение для ceil(dt, Dates.Hour(1)).
julia> ceil(Date(1985, 8, 16), Month) 1985-09-01 julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Minute(15)) 2013-02-13T00:45:00 julia> ceil(DateTime(2016, 8, 6, 12, 0, 0), Day) 2016-08-07T00:00:00
Base.roundМетод
round(dt::TimeType, p::Period, [r::RoundingMode]) -> TimeType
Возвращает значение Date или DateTime, ближайшее к dt с разрешением p. По умолчанию (RoundNearestTiesUp) значения, которые находятся посередине (например, округление 9:30 до ближайшего часа), округляются вверх.
Для удобства p может быть типом вместо значения: round(dt, Dates.Hour) — это сокращение для round(dt, Dates.Hour(1)).
julia> round(Date(1985, 8, 16), Month) 1985-08-01 julia> round(DateTime(2013, 2, 13, 0, 31, 20), Minute(15)) 2013-02-13T00:30:00 julia> round(DateTime(2016, 8, 6, 12, 0, 0), Day) 2016-08-07T00:00:00
Допустимые режимы округления для round(::TimeType, ::Period, ::RoundingMode) — это RoundNearestTiesUp (по умолчанию), RoundDown (floor) и RoundUp (ceil).
Большинство значений Period также можно округлить до заданного разрешения:
Base.floorМетод
floor(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T
Округлить x вниз до ближайшего кратного precision. Если x и precision являются разными подтипами Period, возвращаемое значение будет иметь тот же тип, что и precision.
Для удобства precision может быть типом вместо значения: floor(x, Dates.Hour) — это сокращение для floor(x, Dates.Hour(1)).
julia> floor(Day(16), Week) 2 weeks julia> floor(Minute(44), Minute(15)) 30 minutes julia> floor(Hour(36), Day) 1 day
Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.
Base.ceilМетод
ceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T
Округлить x вверх до ближайшего кратного precision. Если x и precision являются разными подтипами Period, возвращаемое значение будет иметь тот же тип, что и precision.
Для удобства precision может быть типом вместо значения: ceil(x, Dates.Hour) — это сокращение для ceil(x, Dates.Hour(1)).
julia> ceil(Day(16), Week) 3 weeks julia> ceil(Minute(44), Minute(15)) 45 minutes julia> ceil(Hour(36), Day) 2 days
Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.
Base.roundМетод
round(x::Period, precision::T, [r::RoundingMode]) where T <: Union{TimePeriod, Week, Day} -> T
Округлить x до ближайшего кратного precision. Если x и precision являются разными подтипами Period, возвращаемое значение будет иметь тот же тип, что и precision. По умолчанию (RoundNearestTiesUp) значения, которые находятся посередине (например, округление 90 минут до ближайшего часа), округляются вверх.
Для удобства precision может быть типом вместо значения: round(x, Dates.Hour) — это сокращение для round(x, Dates.Hour(1)).
julia> round(Day(16), Week) 2 weeks julia> round(Minute(44), Minute(15)) 45 minutes julia> round(Hour(36), Day) 2 days
Допустимые режимы округления для round(::Period, ::T, ::RoundingMode) — это RoundNearestTiesUp (по умолчанию), RoundDown (floor) и RoundUp (ceil).
Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.
Следующие функции не экспортируются:
Dates.floorceilФункция
floorceil(dt::TimeType, p::Period) -> (TimeType, TimeType)
Одновременно возвращает floor и ceil значения Date или DateTime с разрешением p. Более эффективно, чем вызов floor и ceil по отдельности.
floorceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> (T, T)
Одновременно возвращает floor и ceil значения Period с разрешением p. Более эффективно, чем вызов floor и ceil по отдельности.
Dates.epochdays2dateФункция
epochdays2date(days) -> Date
Принимает количество дней с эпохи округления (0000-01-01T00:00:00) и возвращает соответствующую Date.
Dates.epochms2datetimeФункция
epochms2datetime(milliseconds) -> DateTime
Принимает количество миллисекунд с эпохи округления (0000-01-01T00:00:00) и возвращает соответствующую DateTime.
Dates.date2epochdaysФункция
date2epochdays(dt::Date) -> Int64
Принимает заданную Date и возвращает количество дней с эпохи округления (0000-01-01T00:00:00) как Int64.
Dates.datetime2epochmsФункция
datetime2epochms(dt::DateTime) -> Int64
Принимает заданную DateTime и возвращает количество миллисекунд с эпохи округления (0000-01-01T00:00:00) как Int64.
Функции преобразования
Dates.todayФункция
today() -> Date
Возвращает дату из now().
Dates.unix2datetimeФункция
unix2datetime(x) -> DateTime
Принимает количество секунд с эпохи Unix 1970-01-01T00:00:00 и преобразует в соответствующую DateTime.
Dates.datetime2unixФункция
datetime2unix(dt::DateTime) -> Float64
Принимает заданную DateTime и возвращает количество секунд с эпохи Unix 1970-01-01T00:00:00 как Float64.
Dates.julian2datetimeФункция
julian2datetime(julian_days) -> DateTime
Принимает количество дней юлианского календаря с эпохи -4713-11-24T12:00:00 и возвращает соответствующую DateTime.
Dates.datetime2julianФункция
datetime2julian(dt::DateTime) -> Float64
Принимает заданную DateTime и возвращает количество дней юлианского календаря с юлианской эпохи -4713-11-24T12:00:00 как Float64.
Dates.rata2datetimeФункция
rata2datetime(days) -> DateTime
Принимает количество дней Rata Die с эпохи 0000-12-31T00:00:00 и возвращает соответствующую DateTime.
Dates.datetime2rataФункция
datetime2rata(dt::TimeType) -> Int64
Возвращает количество дней Rata Die с эпохи для заданной Date или DateTime.
Константы
Дни недели:
| Переменная | Сокр. | Значение (Цел.) |
|---|---|---|
Monday |
Mon |
1 |
Tuesday |
Tue |
2 |
Wednesday |
Wed |
3 |
Thursday |
Thu |
4 |
Friday |
Fri |
5 |
Saturday |
Sat |
6 |
Sunday |
Sun |
7 |
Месяцы года:
| Переменная | Сокр. | Значение (Цел.) |
|---|---|---|
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 |
Форматы дат по умолчанию
Dates.ISODateTimeFormatКонстанта
Dates.ISODateTimeFormat
Описывает форматирование даты и времени в формате ISO8601. Это значение по умолчанию для Dates.format объекта DateTime.
Пример
julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), ISODateTimeFormat) "2018-08-08T12:00:43.001"
Dates.ISODateFormatКонстанта
Dates.ISODateFormat
Описывает форматирование даты в формате ISO8601. Это значение по умолчанию для Dates.format объекта Date.
Пример
julia> Dates.format(Date(2018, 8, 8), ISODateFormat) "2018-08-08"
Dates.ISOTimeFormatКонстанта
Dates.ISOTimeFormat
Описывает форматирование времени в формате ISO8601. Это значение по умолчанию для Dates.format объекта Time.
Пример
julia> Dates.format(Time(12, 0, 43, 1), ISOTimeFormat) "12:00:43.001"
Dates.RFC1123FormatКонстанта
Dates.RFC1123Format
Описывает форматирование даты и времени в формате RFC1123.
Пример
julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), RFC1123Format) "Wed, 08 Aug 2018 12:00:43"
-
1Понятие секунды UT на самом деле довольно фундаментально. Существуют в основном два разных понятия времени, обычно принятых, одно основано на физическом вращении Земли (один полный оборот = 1 день), другое основано на СИ секунде (фиксированное, постоянное значение). Они радикально отличаются! Подумайте об этом, «секунда UT», как определена относительно вращения Земли, может иметь разную абсолютную длину в зависимости от дня! В любом случае, тот факт, что
DateиDateTimeоснованы на секундах UT, является упрощающим, но честным предположением, чтобы избежать таких сложностей, как високосные секунды и вся их сложность. Эта основа времени формально называется UT или UT1. Основывание типов на секунде UT в основном означает, что каждая минута имеет 60 секунд, а каждый день 24 часа и приводит к более естественным вычислениям при работе с календарными датами.
© 2009–2023 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
https://docs.julialang.org/en/v1.9/stdlib/Dates/