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

Python – язык программирования, который можно отнести к общему назначению. С его помощью пишут как бизнес-софт, так и развлекательный (игровой) контент. Это отличное решение для новичков в разработке. Относится к объектно-ориентированному типу.

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

Ключевые термины

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

1. Ключевое слово – зарезервированное системой слово или фраза. Обозначает действие, операцию, функцию. Ключевики не могут выступать в виде имен переменных.
2. Переменная – именованная ячейка памяти, которую можно изменять, сохранять и считывать.
3. Алгоритм – последовательность действий, набор правил, помогающих решать те или иные задачи.
4. Класс – набор связанных между собой объектов, которые имеют общие свойства.
5. Объект – комбинация переменных, констант и иных структурных единиц. Они выбираются совместно и аналогичным образом проходят обработку.
6. Константа – значение, которое не будет меняться на протяжении всего выполнения утилиты.
7. Тип данных – классификация информации определенного вида.
8. Массив – множество данных. Они предварительно группируются.

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

Задержка – это…

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

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

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

Класс Timer

Класс Timer () в Python отвечает за время и работу с ним «от начала по конца». Модуль, метод, используемый для задержки и всего, что с ней связано. Перед использованием оного требуется произвести импорт компонента.

Для этого подойдет запись типа import time в Python. Класс относится к модулю threading. Он создает таймер, который запускает функцию с аргументами и ключевыми значениями (kwargs). Происходит это за счет time, установленного как interval. Этот параметр указывается в секундах.

Программеру предстоит запомнить следующее:

• Запись функции с классом, отвечающего за таймаут (timeout) –

• Если args равен None (этот показатель устанавливается изначально), Python использует пустой список.
• Когда ключевое слово kwargs равен None, применяется пустой словарь.
• Класс «Таймер» представлен действием, которое нужно запускать только по прошествии конкретного промежутка времени.
• Таймер выступает в виде подкласса threading.Thread().

Все это требуется запомнить. А еще – учесть, что в процессе коддинга предстоит использовать суперкласс (super class), а также мета данные.

Функции

Рассматривая methods time, программисту требуется изучить разнообразные функции, связанные со временем. Это поможет лучше разобраться в потоках и задержках. Не стоит забывать, что при тестинге важно использовать print. Эта операция выводит результат на экран.

Time.Time

Функция Time() будет возвращать число секунд, которые прошли с начала эпохи. Для Unix-систем это – 1.01.1970. Отсчет с 12 часов ночи ровно.

Ctime()

Компонент, который будет в виде аргумента в Python принимать количество секунд, прошедших с самого начала эпохи. Результат – возврат строки по местному time.

Sleep

Отвечает за непосредственную задержку. Откладывает исполнение нынешнего потока на заданное количество секунд.

Класс struct_time

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

Выше – наглядный пример.

Реализация Sleep

Когда нужный метод для работы с задержкой изучен, можно рассмотреть то, как сделать таймаут. Для этого используют super class, а также sleep. Он проходит реализацию несколькими способами:

• Через time.sleep(). Это – встроенная возможность Python. Отвечает за таймаут через модуль time. Откладывает выполнение потока на установленное количество секунд.

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

• В потоках. Такие ситуации требуют, чтобы приложение избегало простоя. Для этого применяют или time.sleep(), или Event.wait() из модуля threading.
• Из Async IO. Асинхронные возможности появились в Питоне, начиная с 3.4 версии. Это – тип параллельного программирования.

• В Tkinter и wxPython. Отсрочки возможны при создании пользовательских интерфейсов. При применении sleep() внутри GUI кода блокируется цикл обработки событий.
• After(). Это – метод, который погружает в сон для Tkinter. Часть стандартной библиотеки.

• CallLater. Метод для wxPython. Имеет больше виджетов и хорошо годится для нативной разработки.

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

Время на прочтение
6 мин

Количество просмотров 29K

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

А именно, здесь мы коснёмся следующих вопросов:

• Как пользоваться Python-модулем datetime для работы с датой и временем.
• Что собой представляют объекты timedelta и что они могут дать программисту.
• Как вычислять продолжительность временных интервалов, выражая результат в разных единицах измерения.

Python-модуль datetime

Для работы с датой и временем в Python используется модуль datetime. Он является частью стандартной библиотеки Python. Для того чтобы применить этот модуль в своём проекте — достаточно его импортировать:

import datetime

Для вычисления продолжительности временного интервала нужно создать две различных отметки времени. Тут есть несколько вариантов:

• Два объекта date — стандартное представление даты.
• Два объекта time — стандартное представление времени.
• Два объекта datetime, комбинирующие сведения, которые обычно хранятся в объектах date и time.

Создание объектов date

Импортируем класс date из модуля datetime. Для того чтобы создать в Python объект date — можно воспользоваться обычной синтаксической конструкцией вида datetime.date(<year>,<month>,<day>). Вот пример создания объекта date с именем date1:

from datetime import date
date1 = datetime.date(2022,3,27)
print(date1)

# Вывод: 2022-03-27

Этот код можно попробовать запустить в онлайн-интерпретаторе Python на Geekflare. Ещё можно установить Python у себя.

Из предыдущего примера видно, что дата выводится в формате YYYY-MM-DD.

Обратите внимание на то, что при создании объекта date месяц надо задавать с использованием целого числа, в начале которого нет дополнительных нулей. Обычно в числовой записи месяцев соответствующие числа дополняют нулями. Здесь же, например, чтобы указать Июнь, то есть — 6 месяц — нужно воспользоваться числом 6, а не 06.

Попробуйте запустить следующий фрагмент кода. Тут месяц намеренно записан неправильно — 03 вместо 3. Из-за этого возникает ошибка SyntaxError:

date1 = datetime.date(2022,03,27)

print(date1)

# Сообщение об ошибке
File "<ipython-input-12-6eb72084e6ce>", line 1
    date1 = datetime.date(2022,03,27)
                                ^
SyntaxError: invalid token

Поговорим теперь о том, как создавать объекты time.

Создание объектов time

Для создания объектов time импортируем класс time. При создании таких объектов указывают следующие атрибуты класса: hour, minute, second и microsecond. Они, соответственно, позволяют указывать часы, минуты, секунды и микросекунды.

Правда, все эти атрибуты являются необязательными. Если какой-то из них опустить, предположим — second, то он, по умолчанию, будет установлен в 0.

В следующем примере показано создание объекта time с именем time1. Так же, как и при работе с объектами date, объекты time можно выводить в консоль:

from datetime import time
time1 = datetime.time(13,27,45,4600)
print(time1)

# Вывод: 13:27:45.004600

Создание объектов datetime

Как видите, объекты типа date не содержат сведений о времени. А в объектах time нет информации о дате.

Но на практике обычно нужны данные и о дате, и о времени. Поэтому вместо двух вышеописанных классов рекомендуется прибегнуть к классу datetime.

Обратиться к этому классу и создать соответствующий объект (dt1) можно так:

dt1 = datetime.datetime(2022,3,27,13,27,45,46000)
print(dt1)

# Вывод: 2022-03-27 13:27:45.046000

Создадим ещё один объект datetime и дадим ему имя dt2, опустив при его создании атрибут second. Это приведёт к тому, что он будет установлен в значение по умолчанию — 0.

dt2 = datetime.datetime(2022,6,30,14,28)
print(dt2)

# Вывод: 2022-06-30 14:28:00

Итак, теперь вы знаете о том, как создавать Python-объекты date, time и datetime, представляющие отметки времени. Пришло время поговорить о том, как находить длительность временных интервалов.

Применение объектов timedelta

В Python объекты timedelta представляют собой сведения о промежутках времени. Это — разница двух объектов date, time или datetime.

Если сложить или вычесть два объекта date, time или datetime, получится объект timedelta. У этого объекта имеются полезные атрибуты и методы, которые могут помочь в деле нахождения длительности временных интервалов.

Посчитаем длительность интервала, задаваемого двумя объектами типа datetime — dt1 и dt2:

dt1 = datetime.datetime(2022,3,27,13,27,45,46000) 
dt2 = datetime.datetime(2022,6,30,14,28) 
tdelta = dt2 - dt1 
print(tdelta) 
print(type(tdelta)) 

# Вывод 
95 days, 1:00:14.954000 
<class 'datetime.timedelta'>

Видно, что переменная tdelta хранит разницу между dt1 и dt2. Тут, кроме того, пользуясь встроенной Python-функцией type(), мы проверили тип tdelta. Это — timedelta.

Проведём ещё один эксперимент.

Нахождение временного промежутка между двумя датами

Рассмотрим простой, но интересный пример.

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

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

Создадим пару объектов datetime:

• Первый будет хранить сегодняшнюю дату, мы назовём его today.
• Второй будет хранить дату дня рождения. Назовём его bday.

У класса datetime есть метод now(), который позволяет создавать объекты, содержащие сведения о текущем местном времени и дате. Воспользуемся этим методом для того чтобы получить сегодняшнюю дату, играющую роль точки отсчёта:

today = datetime.datetime.now()
print(today)

# Пример вывода: 2022-01-22 09:10:18.489538

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

Если же ваш день рождения в этом году уже прошёл, можете записать в bday дату из следующего года.

bday = datetime.datetime(2022,8,30,11,59)
print(bday)

# Пример вывода: 2022-08-30 11:59:00

Следующий шаг нашей работы — нахождение разницы между двумя отметками времени. Её мы будем хранить в переменной time_diff. Подобные переменные, как мы уже говорили, имеют тип timedelta. Нам достаточно вычесть today из bday.

time_diff = bday - today
print(f"Your birthday is in {time_diff}")

# Вывод
Your birthday is in 220 days, 2:46:00.127416

Для того чтобы узнать о том, сколько полных дней осталось до дня рождения, можно воспользоваться атрибутом days объекта типа timedelta.

tdays = time_diff.days
print(f"Your birthday is in {tdays} days.")

# Вывод
Your birthday is in 220 days.

Выражение длительности временных промежутков в секундах

Теперь узнаем о том, сколько ждать дня рождения, выразив результат в секундах.

Для этого можно воспользоваться методом total_seconds() объекта типа timedelta. В следующем примере это — всё тот же объект time_diff.

tsecs = time_diff.total_seconds()
print(f"Your birthday is {tsecs} seconds away.")

# Вывод
Your birthday is 19017960.127416 seconds away.

Да, дня рождения придётся подождать!

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

Давайте вспомним то, что мы знаем о времени, и поговорим об измерении времени в днях, часах, минутах и секундах. В сутках 24 часа, в часе 60 минут, а 60 секунд — это минута.

Часы, минуты и секунды

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

Воспользуемся этими знаниями.

Выражение длительности временных промежутков в минутах

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

Разделим то, что хранится в переменной tsecs, на 60, и сохраним то, что получится, в переменной tmins:

tmins = tsecs/60
print(f"Your birthday is {tmins} minutes away.")

# Вывод
Your birthday is 316966.0021236 minutes away.

Выражение длительности временных промежутков в часах

Теперь посчитаем длительность временного промежутка, выраженную в часах. Учитывая то, что у нас уже есть значение, выраженное в минутах, для достижения этой цели его можно просто поделить на 60. Или можно поделить значение, выраженное в секундах, на 3600 (60*60).

thrs = tsecs/(60*60)
print(f"Your birthday is {thrs} hours away.")

# Вывод
Your birthday is 5282.76670206 hours away.

Теперь вы знаете о том, как представлять разные промежутки времени в нужном вам виде.

Итоги

Освоив это руководство, вы узнали следующее:

• Как создавать объекты, содержащие сведения о дате и времени, пользуясь модулем datetime, и как работать с такими объектами.
• Как пользоваться объектами типа timedelta для нахождения длительности временных промежутков или разницы между двумя объектами, содержащими сведения о дате или времени.
• Как выражать длительность временных промежутков в секундах, минутах и часах.

Надеюсь, вам пригодится то, о чём вы узнали. Теперь эти знания вполне можно применить на практике.

Какие задачи вы решаете с помощью Python?

В пространстве имен System.Threading содержится класс Timer, позволяющий повторять выполнение какой-либо задачи в потоке через равные промежутки времени. Рассмотрим несколько примеров использования таймеров в приложениях C#.

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

В приведенном ниже примере каждую секунду в консоль выводится сообщение «Hello world»:

using System;
using System.Threading;

namespace Multithread
{

    internal class Program
    {

        static void Main(string[] args)
        {
            Timer ts = new Timer(Callback, null, 500, 1000);
            Console.ReadLine();
        }

        public static void Callback(object? obj)
        {
            Console.WriteLine("Hello world");
        }

    }
}

Рассмотрим этот пример подробнее. В начале мы создаем объект таймера, используя один из его конструкторов, который принимает четыре параметра:

1. Метод обратного вызова (Callback).
2. Объект, используемый в методе обратного вызова или null, если такой объект не требуется;
3. Время в миллисекундах в течение которого таймер простаивает
4. Интервал с которым будет срабатывать таймер и выполняться метод Callback.

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

public delegate void TimerCallback(object? state);

Так как нам не требуется использовать в методе обратного вызова данные какого-либо объекта, то во втором параметре мы указали null. Как только объект таймера создан, метод обратного вызова начинает выполняться, спустя время, указанное в третьем параметре конструктора, т.е. в нашем случае — это 0,5 секунды. В приведенном выше примере таймер будет срабатывать бесконечное количество раз.

Рассмотрим различные варианты использования таймера, а также те моменты, на которые стоит обратить внимание.

Использование объекта для метода обратного вызова в таймере

Второй параметр конструктора у Timer принимает объект, который должен использоваться в методе обратного вызова. Учитывая то, что этот параметр имеет тип object, мы можем передать в него всё, что захотим — строки, числа, объекты и т.д. То есть, по сути, такой подход является не типобезопасным, поэтому при использовании каких-либо объектов в методе обратного вызова стоит обращать внимание на то, что мы передаем в метод обратного вызова и то, как мы работаем с этим объектом в методе. Рассмотрим следующий пример:

using System;
using System.Threading;

namespace Multithread
{

    public class Car
    { 
        public int Velocity { get; set; } //скорость в м/с
        public double Distance { get; set; } //пройденное расстояние

        public Car(int velocity)
        {
            Velocity = velocity;
        }

        public void SetDistance(int timeInterval)
        {
            Distance += Velocity * (timeInterval / 1000);
        }
    }

    internal class Program
    {
        public static int time = 1000;
        static void Main(string[] args)
        {
            Car car = new Car(15);
            Timer ts = new Timer(Callback, car, 500, time);
            Console.ReadLine();
        }

        public static void Callback(object? obj)
        {
            if ((obj != null) && (obj.GetType() == typeof(Car)))
            {
                ((Car)obj).SetDistance(time);
                Console.WriteLine($"Машина проехала {((Car)obj).Distance} метров");
            }
            
        }

    }
}

В этом примере мы используем для таймера объект типа Car (машина) и через заданные промежутки времени рассчитываем какой путь прошла машина. Перед тем, как вызвать метод SetDistance у машины мы в методе Callback проверяем, чтобы объект не был равным null и, при это, объект имел тип Car, а не что-либо иное.

Прерывание работы таймера

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

using System;
using System.Threading;

namespace Multithread
{

    public class Car
    {
        public int Velocity { get; set; } //скорость в м/с
        public double Distanse { get; set; } //пройденное расстояние

        public Car(int velocity)
        {
            Velocity = velocity;
        }

        public void SetDistanse(int timeInterval)
        {
            Distanse += Velocity * ((double)timeInterval / 1000);
        }
    }

    internal class Program
    {
        public static int time = 1000;
        public static Timer ts;
        static void Main(string[] args)
        {
            Car car = new Car(30);
            ts = new Timer(Callback, car, 500, time);
            Console.ReadLine();
        }

        public static void Callback(object? obj)
        {
            if ((obj != null) && (obj.GetType() == typeof(Car)))
            {
                ((Car)obj).SetDistanse(time);
                Console.WriteLine($"Машина проехала {((Car)obj).Distanse} метров");
                if (((Car)obj).Distanse >= 1000)
                {
                    ts.Dispose(); //освобождаем ресурсы таймера
                    Console.WriteLine("Машина приехала");
                }

            }
        }
    }
}

Здесь, в методе Callback мы проверяем какое расстояние было пройдено и, при достижении расстояния 1000 или более метров вызываем метод Dispose таймера, полностью прекращая тем самым его работу.

Изменение интервала срабатывания таймера

Для изменение интервала срабатывания таймера используется его метод Change.  Этот метод принимает два параметра:

1. Время задержки срабатывания таймера
2. Интервал срабатывания таймера

Например, такой код

ts.Change(0, 500)

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

ts.Change(Timeout.Infinite, 500)

Соответственно, чтобы остановить работу таймера (но не освобождать, занимаемые им ресурсы) необходимо указать бесконечность во втором параметре метода Change:

ts.Change(0, Timeout.Infinite)

Итого

Сегодня мы рассмотрели работу с одним из таймеров в .NET, расположенном в пространстве имен System.Threading. Timer позволяет вызывать метод с заданным интервалом времени. В случае необходимости, мы можем либо полностью освободить ресурсы, занимаемые таймером, либо изменить интервал срабатывания таймера, используя его метод Change.

Интервал времени timedelta, поддерживаемые операции.

Синтаксис:

import datetime

delta = datetime.timedelta(days=0, 
                           seconds=0, 
                           microseconds=0, 
                           milliseconds=0, 
                           minutes=0, 
                           hours=0, 
                           weeks=0)

Параметры:

Все аргументы являются необязательными и по умолчанию равны 0. Аргументы могут быть целыми числами или числами с плавающей запятой и могут быть положительными или отрицательными.

• days=0 — день,
• seconds=0 — секунды,
• microseconds=0 — микросекунды,
• milliseconds=0 — миллисекунды,
• minutes=0 — минуты,
• hours=0 — часы,
• weeks=0 — недели.

Возвращаемое значение:

• продолжительность datetime.timedelta.

Описание:

Класс timedelta() модуля datetime представляет собой продолжительность, разницу между двумя датами или временем.

Экземпляр datetime.timedelta продолжительность хранит как сочетание days, seconds и microseconds, а остальные переданные в конструктор аргументы конвертируются в эти единицы:

• millisecond преобразуется в 1000 microseconds.
• minute преобразуется в 60 seconds.
• hour преобразуется в 3600 seconds.
• week преобразуется в 7 days.

days, seconds и microseconds затем нормализуются так, чтобы представление было уникальным:

• 0 <= microseconds < 1000000
• 0 <= seconds < 3600*24 (количество секунд в одном дне)
• -999999999 <= days <= 999999999

В следующем примере показано, как любые аргументы, кроме days, seconds и microseconds объединяются и нормализуются в эти три результирующих атрибута:

>>> from datetime import timedelta
>>> delta = timedelta(
...     days=50,
...     seconds=27,
...     microseconds=10,
...     milliseconds=29000,
...     minutes=5,
...     hours=8,
...     weeks=2
... )

# Остались только дни, секунды и микросекунды
>>> delta
# datetime.timedelta(days=64, seconds=29156, microseconds=10)
>>> delta.days
# 64
>>> delta.seconds
# 29156
>>> delta.microseconds
# 10
>>> delta.total_seconds()
# 5558756.00001

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

Если нормализованное значение дней находится за пределами диапазона -999999999 <= days <= 999999999, то появляется исключение OverflowError.

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

>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
# (-1, 86399, 999999)

Продолжительность timedelta имеет 1 метод:

delta.total_seconds():

Метод timedelta.total_seconds() возвращает общее количество секунд, содержащихся в продолжительности timedelta. Эквивалент td/timedelta(seconds=1).

Для интервальных единиц, отличных от секунд, используйте форму деления напрямую, например td/timedelta(microseconds=1).

Обратите внимание, что для очень больших временных интервалов более 270 лет на большинстве платформ этот метод теряет микросекундную точность.

Поддерживаемые операции timedelta:

Замечания:

1. Это точно, но может быть переполнение.
2. Это точно и не может быть переполнения.
3. Деление на 0 поднимает исключение ZeroDivisionError.
4. -timedelta.max не может быть представлен как объект datetime.timedelta.

5. Строковые представления объектов datetime.timedelta нормализуются аналогично их внутреннему представлению. Это приводит к несколько необычным результатам для отрицательных timedeltas.Например:

   >>> datetime.timedelta(days=-1, seconds=68400)
   >>> print(_)
   # -1 day, 19:00:00
   

6. Выражение t2 - t3 всегда будет равно выражению t2 + (-t3), кроме случаев, когда t3 равно timedelta.max. В этом случае первое даст результат, а второе вызовет переполнение.

В дополнение к операциям, перечисленным выше, объекты datetime.timedelta поддерживают определенные дополнения и вычитания с объектами date и datetime. Смотрите «Частые приемы работы c datetime.timedelta«.

Поддерживаются сравнения объектов datetime.timedelta с некоторыми оговорками.

Сравнения == или != всегда возвращают bool, независимо от типа сравниваемого объекта:

>>> from datetime import timedelta
>>> delta1 = timedelta(seconds=57)
>>> delta2 = timedelta(hours=25, seconds=2)
>>> delta2 != delta1
# True
>>> delta2 == 5
# False

Для всех других сравнений, таких < как > и когда объект timedelta сравнивается с объектом другого типа, вызывается исключение TypeError:

>>> delta2 > delta1
# True
>>> delta2 > 5
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: '>' not supported between instances of 'datetime.timedelta' and 'int'

В булевых контекстах объект timedelta считается истинным тогда и только тогда, когда он не равен datetime.timedelta(0).

Дополнительный пример нормализации:

>>> # Components of another_year add up to exactly 365 days
>>> from datetime import timedelta
>>> year = timedelta(days=365)

# Компоненты 'another_year' составляют ровно 365 дней
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)
>>> year == another_year
# True
>>> year.total_seconds()
# 31536000.0

Более четкое, удобочитаемое и мощное кодирование с помощью Java SE 8 Новый API DateTime JSR 310… ..

В предыдущей статье « Обработка коллекций с помощью Streams API »; Я глубоко погрузился в объяснение и изучение способов обхода коллекций с помощью потоков , создания потоков из коллекций и массивов и, наконец, агрегации значений потоков. В этой статье серии «Обзор новых функций Java SE 8» мы углубимся в изучение объяснение и исследование кода спецификации JSR 310, о том, как вычислять временные интервалы с помощью нового API DateTime, вычислять интервалы времени с мгновенными и длительными значениями, представлять значения даты и времени, форматировать значения даты и времени и поддерживать смещения часовых поясов.

Исходный код размещен на моей учетной записи Github : клонируйте его отсюда .

Содержание:

1. Расчет промежутков времени с Instant и Duration.
2. Представление даты и времени.
3. Форматирование значений даты и времени.
4. Поддержка часовых поясов.

1- Расчет промежутков времени с Мгновенным и Длительностью

Вступление:
Java SE 8 включает полностью новый API для управления значениями даты и времени. Классы, которые на самом деле содержат данные в этом новом API, являются неизменяемыми и поточно-ориентированными . Это означает, что вам не нужно беспокоиться о передаче объектов в многопоточном окружении. И если вы используете их в параллельных потоках , все всегда будет работать идеально. Все классы в этом новом API являются членами пакета java.time . И я начну с двух основных классов, названных Instant и Duration .

Как это работает:
Я начну с этого примера в пакете eg.com.tm.java8.features.datetime.InstDuration проекта Java8Features . В коде класса с именем InstantAndDuration . И я помещу весь этот код в метод main . Первый класс, который я опишу, называется Instant . Я java.time имя класса и java.time Ctrl + Space , и выберу класс из пакета java.time , и он импортирован выше. Мгновенный объект представляет момент на временной шкале Java. Как и в случае с классом даты, который является частью старого способа управления датами и временем, экземпляр представляет количество миллисекунд.

Начиная с эпохи Java, 1 января 1970 года. Чтобы объявить мгновенный объект, я объявлю его с его типом, и дам ему имя start. И тогда я вызову статический метод мгновенного класса, который вызывается now() . И это представляет момент на текущей машине, когда код был вызван. Затем я выведу это значение в виде строки, используя стандартный системный вывод. Запустите код, и вы увидите, что вывод начинается с даты в формате год, месяц, дата, а затем время после буквы T.

Результат:

Если у вас есть момент времени, вы можете использовать его для вычисления разницы между этим и другим моментом времени. Поэтому я создам еще одно мгновение, которое назову концом. И я получу это значение из метода now() . Затем я буду использовать системный вывод и выводить это значение. Обратите внимание, что между этими двумя значениями есть небольшая разница, и это время, которое требуется моей системе. Чтобы обработать эту строку кода, это выводит начальное значение.

Результат:

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

Результат:

Теперь я покажу вам, как рассчитать разницу между этими двумя значениями. Когда вы сравниваете два момента друг с другом, вы получите объект, который называется продолжительностью. Он представлен классом Duration , который также является членом Java.time . Я назову этот объект прошедшим. Я вызову статический метод класса продолжительности, который between(Temporal startInclusive, Temporal endExclusive) . Обратите внимание, что он ищет объекты, напечатанные как нечто, называемое Temporal . Мгновенный класс является подклассом Temporal.

Результат:

Я передам начало и конец как два моих временных значения. И тогда я выведу разницу. Я передам буквальный ярлык истекшего, а затем я передам в моей переменной. Этот объект длительности начинается с буквы p, а затем t для времени. Это снова значение в формате ISO. И тогда он показывает мне ноль секунд. Хорошо, давайте посмотрим, что произойдет, если мы бросим вызов метода сна. Я установлю курсор между начальным и конечным вызовами. И я буду использовать класс Thread .

Я нажму точку, а затем нажмите Ctrl + Пробел . Затем я вызову метод sleep() и передам значение 1,000. Значение сна на одну секунду. Метод sleep может вызвать ошибку, поэтому я воспользуюсь быстрым исправлением и добавлю объявление throws в сигнатуру основных методов. Я сохраняю и запускаю код, и вижу, что мое время перерыва теперь составляет 1,001 секунды. Вы никогда не можете рассчитывать на то, что все будет точно, все зависит от того, что происходит, на компьютере обработки.

Результат:

Затем я возьму этот вызов printline и верну его в исходное местоположение. Так что теперь, после того как я получу начальное значение, я буду выполнять команду printline. И я буду спать одну секунду. И я буду запускать код. И теперь мой промежуток времени составляет 1,057 секунды.

Результат:

Чтобы сделать это немного более читабельным, я добавлю вызов метода объекта duration, используя elapsed.to millis . Это означает, что получите эквивалент в миллисекундах. И я добавлю к этому, миллисекунды, и я выполню код.

Результат:

Вывод:
И теперь я вижу, читаемое значение 1054 миллисекунды. Итак, это класс Instant класс Duration . Два основных класса нового API даты и времени в Java SE 8.

2- Представление значений даты и времени:

Вступление:
Ранее я описывал, как использовать моментальный класс в новом API времени и даты для представления момента на временной шкале Java. Вот еще три полезных класса для представления частей дат и времени. Они называются местная дата , местное время и местное время . Скажем, например, что вы хотите представлять только значение даты. И вас не волнует время, секунды или миллисекунды, а только текущая дата. Создайте экземпляр класса с именем LocalDate .
Как это работает :
Я работаю в пакете eg.com.tm.java8.features.datetime.localdt проекта Java8Features . В коде класса с именем LocalDateAndTime . с основным методом. Я начну с названия класса LocalDate . И когда я нажимаю Ctrl + Space , я выбираю класс из пакета java.time. Я назову объект currentDate и получу его значение с помощью localDate.now . Обратите внимание, что в синтаксисе есть согласованность между работой с моментом, датой, временем и датой-временем.

Чтобы получить текущее значение на текущем компьютере, вы всегда используете метод now . Теперь я выведу эту дату в формате по умолчанию. Я сохраняю и запускаю код, и он показывает мне дату в формате год-месяц-дата .

Результат:

Вы также можете создать объект даты, используя конкретные значения года, месяца и даты. Еще раз, я создам объект, типизированный как LocalDate . И я назову эту specificDate . Чтобы получить это значение, вызовите LocalDate.of .

И есть несколько доступных версий. Я собираюсь использовать тот, который принимает три целых значения. Они не названы в документации, но представляют год, месяц и день. Я исправлю значения 2000, 1 и 1. Теперь, в более старой версии API даты и времени, использующего класс даты. Когда вы имели дело с месяцами, вам всегда приходилось делать это с нулевым смещением. Так что для января вы будете использовать 0, для 1 февраля и так далее.

И это не было особенно интуитивно понятно. В новом дневном API все основано на 1. Итак, 1 означает январь , 2 означает февраль и так далее. Как и следовало ожидать.

Я снова буду использовать вывод системы, и на этот раз я поставлю новую конкретную дату. И когда я сохраняю и запускаю это, я получаю значение, которое я ввел, 1 января 2000 года.

Результат:

Если вы хотите представить только значение времени, используйте класс LocalTime , я LocalTime имя класса и импортирую его, назову объект currentTime и получу его значение из LocalTime.now .

Опять же, используя тот же синтаксис, что и для localdate, и для Instant. Тогда я буду использовать системный вывод. И я выведу это текущее время. Значением по умолчанию для времени является 24-часовая запись, и оно показывает часы, минуты, секунды и миллисекунды.

Результат:

Я буду использовать LocalTime . Я назову это specificTime . И, как и в случае с локальным классом дат, я вызову метод с именем of . Опять же, существует множество разных версий, принимающих разное количество аргументов.

Я буду использовать версию, которая ищет три целочисленных значения, и я введу 14, 0 и 45. И затем я выведу это значение на консоль. И есть результат. 14, 00 и 45 секунд. Обратите внимание, что поскольку я не указал значение в миллисекундах, форматированная версия этого времени не отображает значения после точки.

Результат:

Наконец, я покажу, как использовать класс LocalDateTime .

Я напишу имя класса и импортирую его. Я назову этот объект currentDT . И я получу его значение из LocalDateTime.now . Когда вы выводите значение даты и времени, вы получите длинный формат даты и времени ISO. Начиная с даты и заканчивая временем. И если в значении есть миллисекунды, они будут отображены. И, наконец, я создам конкретную дату и время, и я сделаю это, комбинируя мою конкретную дату и мое конкретное время.

Этот код будет выглядеть как следующий код. Я LocalDateTime объект LocalDateTime . Я назову его, specificDT и снова вызову LocalDateTime.of . И на этот раз я буду использовать эту первую версию метода, который принимает объект локальной даты и объект местного времени. Вы также можете построить свое значение даты и времени из комбинаций лет, месяцев, дат и значений времени. Я передам свою конкретную дату и мое конкретное время. И тогда я выведу его на консоль. И когда я запускаю этот код, мое конкретное время даты представляет собой комбинацию моей конкретной даты и моего конкретного времени.

Результат:

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

3- Форматирование значений даты и времени:

Вступление:
Ранее я описывал, как использовать LocalDate , LocalTime и LocalDateTime для представления значений времени. Чтобы представить эту информацию пользователю, вам необходимо отформатировать ее. И для этой цели есть новый класс с именем DateTimeFormatter . Я покажу вам, как создавать форматтеры, используя простой синтаксис. А затем, как сделать очень нестандартную работу, используя класс Daytime Formatter Builder.

Как это работает:
Я работаю в пакете eg.com.tm.java8.features.datetime.format проекта Java8Features . В коде класса с именем DateTimeFormater . с основным методом.

Сначала я создам дату. Я дам ему тип LocalDate , LocalDate , что импортировал этот класс. И я назову это currentDate . И я получу его значение из LocalDate.now . Далее я создам объект форматирования. Я java.time.format имя класса DateTimeFormatter и java.time.format его из пакета java.time.format . Я назову этот объект df . Сейчас существует несколько способов создания форматера. Одним из самых простых является использование константы класса DateTmeFormatter .

Я еще раз DateTimeFormatter в DateTimeFormatter . И затем после ввода периода я вижу список всех доступных констант. Я выберу ISO Date . И это обеспечит форматирование по умолчанию для этого объекта. Затем я буду использовать вывод системы. Я вызову метод форматирования отформатированного объекта и передам объект даты. И вот результат. Я вывожу значение в формате год-месяц-дата. С месяцем и датой, дополненной до двух символов каждый. Теперь вы можете делать то же самое со временем и датой.

Результат:

Я возьму приведенный выше фрагмент кода, пару раз дублирую его и внесу некоторые изменения. Во второй версии я поменяю тип с местного на местное время. Имя объекта до текущего времени и имя класса, который я использую, чтобы получить значение по местному времени. Я изменю название форматера даты и времени с DF на TF для форматера времени. И я заменю постоянную, которую я использую, на ISO Time . И тогда я изменю объект, который я форматирую. Я обязательно импортирую класс LocalTime .

А потом я внесу аналогичные изменения в третью версию. Класс, с которым я буду работать в этот раз, – LocalDateTime . Я буду обязательно импортировать его. Я назову этот объект, текущий DT. И я изменю класс, из которого я вызываю метод now. Я изменю форматер на DTF для DateTimeFormatter . И я изменю константу на ISO Date Time. И тогда я отформатирую текущий объект DT. Я буду уверен, что использую правильные средства форматирования в каждой версии кода. Я сохраню изменения и выполню код.

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

Результат:

Я опускаюсь ниже существующего кода. И я создам еще один DateTimeFormatter , назову этот f_long для длинного формата даты и получу его значение, вызвав метод класса DateTimeFormatter, называемый Localized Date.

Обратите внимание, что существуют методы для даты, времени и даты-времени с различными аргументами. Я выберу один из локализованной даты и передам константу класса с именем FormatStyle . Обязательно импортируйте этот класс. И после того, как вы введете точку, вы увидите, что доступно четыре константы. Полный, длинный, средний и короткий. Я выберу длинную версию, а затем выведу отформатированную дату, вызвав F _ long.format, и передам текущий объект DT.

Когда я запускаю этот код, я получаю длинную версию даты.

Результат:

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

Результат:

А затем я покажу вам, как использовать локали. Я создам пару строк. Первый будет называться fr_ short, для французского, в коротком формате. Чтобы получить это значение, я вызову мой форматтер f_short, а затем назову имя метода с помощью withLocal() . Чтобы получить значение локали, я буду использовать класс Local , это существующий класс, который был доступен в предыдущих версиях Java . Это член пакета Java.util .

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

Я продублирую эту строку кода и для этой версии буду использовать fr_long. Я буду использовать длинный форматер, иначе код будет таким же. И тогда я fr_short эти два значения fr_short и fr_long .

И вот результат. Обратите внимание на fr_short, что месяц и день поменялись местами с американской версии. И это потому, что в Европе сначала указывается дата, а затем месяц, а затем год. И когда я использую длинную версию, я получаю месяцы, записанные на французском языке.

Результат:

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

Я напишу имя класса и позабочусь, чтобы он был импортирован. И я назову объект б. Я создам его экземпляр с помощью нового ключевого слова и метода конструктора.

Теперь, в конце этого кода я не буду ставить точку с запятой, потому что я хочу немедленно вызвать серию методов, которые позволят мне с нуля собрать средство форматирования. Я начну с метода с именем Append Value. Обратите внимание, что есть «Добавить», «Добавить», «Добавить», «Локализовать» и многие другие. Я собираюсь вызвать метод с именем appendValue() который принимает экземпляр класса с именем TemporalField а затем я буду использовать перечислитель с именем ChronoField . Который расширен от того TemporalField .

И оттуда я буду использовать постоянное название месяца года. Далее я добавлю буквальное значение. Это может быть любой символ или любая строка. И просто, чтобы сделать это совершенно уникальным, я добавлю пару символов. Теперь я возьму эти две строки кода и продублирую их для второй версии вместо месяца года. Я положу в день месяца. Обратите внимание, что есть также день недели и день года. Затем я продублирую эту строку кода и переместу ее вниз. И я закончу выражение с ChronoField.year .

Как только вы создали объект построителя, вы можете получить средство форматирования. Я создам новый объект, типизированный как DateTimeFormatter . Я назову это f для Formatter. И вызывал объекты построителя для методов форматирования, а затем, наконец, я отформатирую текущее значение даты и времени. Я буду использовать системный вывод, вызову f.format() и currentDT .

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

Результат:

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

4- Поддержка смещения часового пояса:

Вступление:
Новый API даты и времени предлагает ряд классов, которые позволяют вам управлять часовыми поясами . Создание объектов дневного времени, смещенных от среднего времени по Гринвичу , на определенное количество часов или на определенные местоположения , и вычисление различий между часовыми поясами.

Как это работает:
Я работаю в пакете eg.com.tm.java8.features.datetime.zone проекта Java8Features . В коде класса с именем TimeZones . с main методом.

В его основном методе я создал объект DateTimeFormatter и LocalDateTime . LocalDateTime представляет текущую дату и время в моей системе, в моем часовом поясе . И это египетское время, потому что я на Ближнем Востоке.

А потом я выводю отформатированное значение на консоль. Я выводю значение в коротком формате. А в египетской нотации это месяц, день и год.

Результат:

Для представления значения даты и времени на основе часового пояса используйте класс ZonedDateTime . Как и LocalDateTime , он неизменен и безопасен для потоков. Я напишу имя класса, а затем нажмите Control + Пробел, чтобы добавить оператор импорта. И я назову объект gmt для среднего времени по Гринвичу.

Есть несколько разных способов создания этого объекта. Я покажу вам, как создать объект, вычисляющий смещение от среднего времени по Гринвичу. Я снова буду использовать класс ZonedDateTime , и после того, как я введу точку, я увижу, что доступно много методов. Я могу снова вызвать now() , чтобы получить значение даты и времени в моем регионе. Я могу вызывать методы of() которые позволяют мне делать различные вычисления. Я могу разобрать строки, но я собираюсь использовать эту версию метода now. Я передам экземпляр класса ZoneId .

ZoneId представляет собой определенное количество часов, смещенное от среднего времени по Гринвичу. И я получу это значение, вызвав метод с именем ZoneId.of() . И я передам буквальную строку «GMT + 0» . Это означает, что покажите мне текущую дату и время в среднем времени по Гринвичу.

Теперь я продублирую свой код, который выводит значение на консоль. Я переместу это вниз, и я изменю эту версию для вывода gmt. Я запускаю код, и есть результат.

Результат:

Я на Ближнем Востоке, в Египте, и сейчас среднее время по Гринвичу на два часа вперед.

Вот еще один подход к получению ZonedDateTime . Допустим, вы хотели получить ZoneDateTime в Нью-Йорке . Есть много встроенных строк или констант, которые позволят вам назвать конкретные местоположения, и вы получите правильный ZoneId для этого местоположения, и вам не придется беспокоиться о математике самостоятельно. Я создам другой объект ZonedDateTime, и на этот раз я назову его ny для Нью-Йорка, и получу его значение, вызвав ZonedDateTime.now() , и снова передам Z oneId.of() , но на этот раз я передам в строку Америки / New_York .

Убедитесь, что написали эту строку именно так, как вы видите здесь . Я создам строку кода для вывода этого значения. Я сохраню изменения и запусту их. А Нью-Йорк на восточном побережье, на три часа опережая тихоокеанское

Результат:

Чтобы узнать обо всех доступных строках, вы можете вызвать метод класса getAvailableZoneIds() именем getAvailableZoneIds() . Ты вернешь набор. Я Java.util Set и Java.util Control + Space , а затем выберу set из Java.util .

И я установлю общий тип элементов в этом наборе на String . Я называю установленные зоны. И тогда я вызову метод ZoneId.getAvailableZoneIds . Затем я переберу строки с помощью метода forEach() . А потом я передам в лямбда- выражении. Так что я могу разбираться с каждым из пунктов по очереди.

Результат:
Когда я запускаю этот код, я вижу все доступные строки.

Сейчас их так много, что может быть трудно найти то, что вы ищете. Итак, скажем, что я хотел искать Лондон .

И использовать часовой пояс для этого конкретного места, в это конкретное время года. Как я показал ранее в этой статье, я мог использовать predicate для поиска строк. Я создам объект предиката. И я установлю универсальный тип на String . И я назову состояние объекта. Затем я реализую предикат с помощью лямбда-выражения. Я передам в str, а затем я реализую предикат с условием. str.contains, и я передам в лондонской нити.

Тогда я сделаю рефакторинг своего выражения ламба. Я собираюсь обернуть System.out.println() в фигурные скобки. Затем я расширю код, чтобы было легче работать с ним. Я добавлю точку с запятой в конце строки печати, а затем создам оператор if. И я установлю условие для condition.test() , и я передам в z для текущей зоны. Я переместу rintln() p rintln() в условие, и теперь я выведу только те строки, которые соответствуют моему тесту предикатов.

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

Результат:

Вывод:
Это немного о работе с часовыми поясами. Опять же, используйте класс ZonedDateTime вместо LocalDateTime для представления значений, которые можно изменять и вычислять. ZoneId представляет собой смещение из среднего времени по Гринвичу. И есть также класс с именем Zone Offset, который вы можете использовать для расчета разных часовых поясов друг против друга.
Ресурсы:

1. Учебные руководства по Java, Trail: Date Time
2. API LocalDate
3. JSR 310: API даты и времени
4. JSR 337: Java SE 8 Release Содержание
5. Сайт OpenJDK
6. Платформа Java, стандартное издание 8, спецификация API

Надеюсь, вам понравилось читать, так как мне понравилось писать, пожалуйста, поделитесь, если вам нравится, распространите слово.