# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Dmytro Kazanzhy, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-04-25 14:19+0000\n"

"PO-Revision-Date: 2021-06-28 01:04+0000\n"

"Last-Translator: Dmytro Kazanzhy, 2025\n"

"Language-Team: Ukrainian (https://app.transifex.com/python-doc/teams/5390/"

"uk/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: uk\n"

"Plural-Forms: nplurals=4; plural=(n % 1 == 0 && n % 10 == 1 && n % 100 != "

"11 ? 0 : n % 1 == 0 && n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % "

"100 > 14) ? 1 : n % 1 == 0 && (n % 10 ==0 || (n % 10 >=5 && n % 10 <=9) || "

"(n % 100 >=11 && n % 100 <=14 )) ? 2: 3);\n"

msgid ":mod:`!datetime` --- Basic date and time types"

msgstr ":mod:`!datetime` --- Базові типи дати і часу"

msgid "**Source code:** :source:`Lib/datetime.py`"

msgstr "**Вихідний код:** :source:`Lib/datetime.py`"

msgid ""

"The :mod:`!datetime` module supplies classes for manipulating dates and "

"times."

msgstr "Модуль :mod:`!datetime` постачає класи для маніпуляції датою і часом."

msgid ""

"While date and time arithmetic is supported, the focus of the implementation "

"is on efficient attribute extraction for output formatting and manipulation."

msgstr ""

"Хоча арифметика дати й часу підтримується, основна увага при реалізації "

"зосереджена на ефективному отриманні атрибутів для форматування виводу та "

"обробки."

msgid "Skip to :ref:`the format codes <format-codes>`."

msgstr "Пропустити до :ref:`кодів формату <format-codes>`."

msgid "Module :mod:`calendar`"

msgstr "Модуль :mod:`calendar`"

msgid "General calendar related functions."

msgstr "Загальні функції, пов’язані з календарем."

msgid "Module :mod:`time`"

msgstr "Модуль :mod:`time`"

msgid "Time access and conversions."

msgstr "Доступ до часу та перетворення."

msgid "Module :mod:`zoneinfo`"

msgstr "Модуль :mod:`zoneinfo`"

msgid "Concrete time zones representing the IANA time zone database."

msgstr "Конкретні часові пояси, що представляють базу часових поясів IANA."

msgid "Package `dateutil <https://dateutil.readthedocs.io/en/stable/>`_"

msgstr "Пакет `dateutil <https://dateutil.readthedocs.io/en/stable/>`_"

msgid "Third-party library with expanded time zone and parsing support."

msgstr ""

"Бібліотека третьої сторони з розширеним часовим поясом і підтримкою аналізу."

msgid "Package :pypi:`DateType`"

msgstr "Пакет :pypi:`DateType`"

msgid ""

"Third-party library that introduces distinct static types to e.g. allow :"

"term:`static type checkers <static type checker>` to differentiate between "

"naive and aware datetimes."

msgstr ""

msgid "Aware and Naive Objects"

msgstr "Обізнані та наївні об’єкти"

msgid ""

"Date and time objects may be categorized as \"aware\" or \"naive\" depending "

"on whether or not they include time zone information."

msgstr ""

msgid ""

"With sufficient knowledge of applicable algorithmic and political time "

"adjustments, such as time zone and daylight saving time information, an "

"**aware** object can locate itself relative to other aware objects. An aware "

"object represents a specific moment in time that is not open to "

"interpretation. [#]_"

msgstr ""

"Завдяки достатнім знанням застосовних алгоритмів і політичних коригувань "

"часу, таких як інформація про часовий пояс і літній час, **свідомий** об’єкт "

"може визначити своє місцезнаходження відносно інших обізнаних об’єктів. "

"Усвідомлюваний об'єкт представляє конкретний момент часу, який не піддається "

"інтерпретації. [#]_"

msgid ""

"A **naive** object does not contain enough information to unambiguously "

"locate itself relative to other date/time objects. Whether a naive object "

"represents Coordinated Universal Time (UTC), local time, or time in some "

"other time zone is purely up to the program, just like it is up to the "

"program whether a particular number represents metres, miles, or mass. Naive "

"objects are easy to understand and to work with, at the cost of ignoring "

"some aspects of reality."

msgstr ""

msgid ""

"For applications requiring aware objects, :class:`.datetime` and :class:`."

"time` objects have an optional time zone information attribute, :attr:`!"

"tzinfo`, that can be set to an instance of a subclass of the abstract :class:"

"`tzinfo` class. These :class:`tzinfo` objects capture information about the "

"offset from UTC time, the time zone name, and whether daylight saving time "

"is in effect."

msgstr ""

"Для додатків, яким потрібні об’єкти, об’єкти :class:`.datetime` і :class:`."

"time` мають необов’язковий атрибут інформації про часовий пояс, :attr:`!"

"tzinfo`, який можна встановити як екземпляр підкласу абстрактний :class:"

"`tzinfo` клас. Ці об’єкти :class:`tzinfo` зберігають інформацію про зміщення "

"від часу UTC, назву часового поясу та чи діє літній час."

msgid ""

"Only one concrete :class:`tzinfo` class, the :class:`timezone` class, is "

"supplied by the :mod:`!datetime` module. The :class:`!timezone` class can "

"represent simple time zones with fixed offsets from UTC, such as UTC itself "

"or North American EST and EDT time zones. Supporting time zones at deeper "

"levels of detail is up to the application. The rules for time adjustment "

"across the world are more political than rational, change frequently, and "

"there is no standard suitable for every application aside from UTC."

msgstr ""

msgid "Constants"

msgstr "Константи"

msgid "The :mod:`!datetime` module exports the following constants:"

msgstr ""

msgid ""

"The smallest year number allowed in a :class:`date` or :class:`.datetime` "

"object. :const:`MINYEAR` is 1."

msgstr ""

msgid ""

"The largest year number allowed in a :class:`date` or :class:`.datetime` "

"object. :const:`MAXYEAR` is 9999."

msgstr ""

msgid "Alias for the UTC time zone singleton :attr:`datetime.timezone.utc`."

msgstr ""

msgid "Available Types"

msgstr "Доступні типи"

msgid ""

"An idealized naive date, assuming the current Gregorian calendar always was, "

"and always will be, in effect. Attributes: :attr:`year`, :attr:`month`, and :"

"attr:`day`."

msgstr ""

"Ідеалізована наївна дата, припускаючи, що поточний григоріанський календар "

"завжди був і завжди буде в силі. Атрибути: :attr:`year`, :attr:`month` і :"

"attr:`day`."

msgid ""

"An idealized time, independent of any particular day, assuming that every "

"day has exactly 24\\*60\\*60 seconds. (There is no notion of \"leap "

"seconds\" here.) Attributes: :attr:`hour`, :attr:`minute`, :attr:`second`, :"

"attr:`microsecond`, and :attr:`.tzinfo`."

msgstr ""

"Ідеалізований час, незалежний від будь-якого конкретного дня, припускаючи, "

"що кожен день має рівно 24\\*60\\*60 секунд. (Тут немає поняття \"високосні "

"секунди\".) Атрибути: :attr:`hour`, :attr:`minute`, :attr:`second`, :attr:"

"`microsecond` і :attr:`.tzinfo`."

msgid ""

"A combination of a date and a time. Attributes: :attr:`year`, :attr:"

"`month`, :attr:`day`, :attr:`hour`, :attr:`minute`, :attr:`second`, :attr:"

"`microsecond`, and :attr:`.tzinfo`."

msgstr ""

"Поєднання дати й часу. Атрибути: :attr:`year`, :attr:`month`, :attr:`day`, :"

"attr:`hour`, :attr:`minute`, :attr:`second`, :attr:`microsecond` і :attr:`."

"tzinfo`."

msgid ""

"A duration expressing the difference between two :class:`.datetime` or :"

"class:`date` instances to microsecond resolution."

msgstr ""

msgid ""

"An abstract base class for time zone information objects. These are used by "

"the :class:`.datetime` and :class:`.time` classes to provide a customizable "

"notion of time adjustment (for example, to account for time zone and/or "

"daylight saving time)."

msgstr ""

"Абстрактний базовий клас для інформаційних об’єктів часового поясу. Вони "

"використовуються класами :class:`.datetime` і :class:`.time` для надання "

"настроюваного поняття коригування часу (наприклад, для врахування часового "

"поясу та/або літнього часу)."

msgid ""

"A class that implements the :class:`tzinfo` abstract base class as a fixed "

"offset from the UTC."

msgstr ""

"Клас, який реалізує :class:`tzinfo` абстрактний базовий клас як фіксоване "

"зміщення від UTC."

msgid "Objects of these types are immutable."

msgstr "Об'єкти цих типів незмінні."

msgid "Subclass relationships::"

msgstr "Відносини підкласів::"

msgid ""

"object\n"

" timedelta\n"

" tzinfo\n"

" timezone\n"

" time\n"

" date\n"

" datetime"

msgstr ""

msgid "Common Properties"

msgstr "Загальні властивості"

msgid ""

"The :class:`date`, :class:`.datetime`, :class:`.time`, and :class:`timezone` "

"types share these common features:"

msgstr ""

"Типи :class:`date`, :class:`.datetime`, :class:`.time` і :class:`timezone` "

"мають такі спільні риси:"

msgid ""

"Objects of these types are :term:`hashable`, meaning that they can be used "

"as dictionary keys."

msgstr ""

msgid ""

"Objects of these types support efficient pickling via the :mod:`pickle` "

"module."

msgstr ""

"Об’єкти цих типів підтримують ефективне маринування за допомогою модуля :mod:"

"`pickle`."

msgid "Determining if an Object is Aware or Naive"

msgstr "Визначення того, чи є об’єкт усвідомленим чи наївним"

msgid "Objects of the :class:`date` type are always naive."

msgstr "Об’єкти типу :class:`date` завжди наївні."

msgid ""

"An object of type :class:`.time` or :class:`.datetime` may be aware or naive."

msgstr ""

"Об’єкт типу :class:`.time` або :class:`.datetime` може бути обізнаним або "

"наївним."

msgid ""

"A :class:`.datetime` object ``d`` is aware if both of the following hold:"

msgstr ""

msgid "``d.tzinfo`` is not ``None``"

msgstr "``d.tzinfo`` не є ``None``"

msgid "``d.tzinfo.utcoffset(d)`` does not return ``None``"

msgstr "``d.tzinfo.utcoffset(d)`` не повертає ``None``"

msgid "Otherwise, ``d`` is naive."

msgstr ""

msgid "A :class:`.time` object ``t`` is aware if both of the following hold:"

msgstr ""

msgid "``t.tzinfo`` is not ``None``"

msgstr "``t.tzinfo`` не є ``None``"

msgid "``t.tzinfo.utcoffset(None)`` does not return ``None``."

msgstr "``t.tzinfo.utcoffset(None)`` не повертає ``None``."

msgid "Otherwise, ``t`` is naive."

msgstr ""

msgid ""

"The distinction between aware and naive doesn't apply to :class:`timedelta` "

"objects."

msgstr ""

"Розрізнення між обізнаним і наївним не стосується об’єктів :class:"

"`timedelta`."

msgid ":class:`timedelta` Objects"

msgstr ":class:`timedelta` Об'єкти"

msgid ""

"A :class:`timedelta` object represents a duration, the difference between "

"two :class:`.datetime` or :class:`date` instances."

msgstr ""

msgid ""

"All arguments are optional and default to 0. Arguments may be integers or "

"floats, and may be positive or negative."

msgstr ""

msgid ""

"Only *days*, *seconds* and *microseconds* are stored internally. Arguments "

"are converted to those units:"

msgstr ""

"Усередині зберігаються лише *дні*, *секунди* та *мікросекунди*. Аргументи "

"конвертуються в такі одиниці:"

msgid "A millisecond is converted to 1000 microseconds."

msgstr "Мілісекунда перетворюється на 1000 мікросекунд."

msgid "A minute is converted to 60 seconds."

msgstr "Хвилина перетворюється на 60 секунд."

msgid "An hour is converted to 3600 seconds."

msgstr "Година перетворюється на 3600 секунд."

msgid "A week is converted to 7 days."

msgstr "Тиждень перетворюється на 7 днів."

msgid ""

"and days, seconds and microseconds are then normalized so that the "

"representation is unique, with"

msgstr ""

"і дні, секунди та мікросекунди потім нормалізуються, щоб представлення було "

"унікальним, з"

msgid "``0 <= microseconds < 1000000``"

msgstr "``0 <= мікросекунди < 1000000``"

msgid "``0 <= seconds < 3600*24`` (the number of seconds in one day)"

msgstr "``0 <= секунд < 3600*24`` (кількість секунд в одному дні)"

msgid "``-999999999 <= days <= 999999999``"

msgstr "``-999999999 <= днів <= 999999999``"

msgid ""

"The following example illustrates how any arguments besides *days*, "

"*seconds* and *microseconds* are \"merged\" and normalized into those three "

"resulting attributes::"

msgstr ""

"У наступному прикладі показано, як будь-які аргументи, окрім *днів*, "

"*секунд* і *мікросекунд*, \"об’єднуються\" та нормалізуються в ці три "

"отримані атрибути:"

msgid ""

">>> from datetime import timedelta\n"

">>> delta = timedelta(\n"

"... days=50,\n"

"... seconds=27,\n"

"... microseconds=10,\n"

"... milliseconds=29000,\n"

"... minutes=5,\n"

"... hours=8,\n"

"... weeks=2\n"

"... )\n"

">>> # Only days, seconds, and microseconds remain\n"

">>> delta\n"

"datetime.timedelta(days=64, seconds=29156, microseconds=10)"

msgstr ""

msgid ""

"If any argument is a float and there are fractional microseconds, the "

"fractional microseconds left over from all arguments are combined and their "

"sum is rounded to the nearest microsecond using round-half-to-even "

"tiebreaker. If no argument is a float, the conversion and normalization "

"processes are exact (no information is lost)."

msgstr ""

"Якщо будь-який аргумент є числом із плаваючою точкою та є дробові "

"мікросекунди, дробові мікросекунди, що залишилися від усіх аргументів, "

"об’єднуються, а їхня сума округлюється до найближчої мікросекунди за "

"допомогою тай-брейку округлення від половини до навіть. Якщо жоден аргумент "

"не є числом з плаваючою речовиною, процеси перетворення та нормалізації є "

"точними (інформація не втрачається)."

msgid ""

"If the normalized value of days lies outside the indicated range, :exc:"

"`OverflowError` is raised."

msgstr ""

"Якщо нормалізоване значення днів лежить за межами зазначеного діапазону, "

"виникає :exc:`OverflowError`."

msgid ""

"Note that normalization of negative values may be surprising at first. For "

"example::"

msgstr ""

"Зверніть увагу, що нормалізація від’ємних значень спочатку може викликати "

"подив. Наприклад::"

msgid ""

">>> from datetime import timedelta\n"

">>> d = timedelta(microseconds=-1)\n"

">>> (d.days, d.seconds, d.microseconds)\n"

"(-1, 86399, 999999)"

msgstr ""

">>> from datetime import timedelta\n"

">>> d = timedelta(microseconds=-1)\n"

">>> (d.days, d.seconds, d.microseconds)\n"

"(-1, 86399, 999999)"

msgid "Class attributes:"

msgstr "Атрибути класу:"

msgid "The most negative :class:`timedelta` object, ``timedelta(-999999999)``."

msgstr ""

"Найбільш негативний об’єкт :class:`timedelta`, ``timedelta(-999999999)``."

msgid ""

"The most positive :class:`timedelta` object, ``timedelta(days=999999999, "

"hours=23, minutes=59, seconds=59, microseconds=999999)``."

msgstr ""

"Найбільш позитивний об’єкт :class:`timedelta`, ``timedelta(days=999999999, "

"hours=23, minutes=59, seconds=59, microseconds=999999)``."

msgid ""

"The smallest possible difference between non-equal :class:`timedelta` "

"objects, ``timedelta(microseconds=1)``."

msgstr ""

"Найменша можлива різниця між нерівними об’єктами :class:`timedelta`, "

"``timedelta(microseconds=1)``."

msgid ""

"Note that, because of normalization, ``timedelta.max`` is greater than ``-"

"timedelta.min``. ``-timedelta.max`` is not representable as a :class:"

"`timedelta` object."

msgstr ""

msgid "Instance attributes (read-only):"

msgstr "Атрибути екземпляра (тільки для читання):"

msgid "Between -999,999,999 and 999,999,999 inclusive."

msgstr "Між -999,999,999 та 999,999,999 включно."

msgid "Between 0 and 86,399 inclusive."

msgstr "Між 0 та 86,399 включно."

msgid ""

"It is a somewhat common bug for code to unintentionally use this attribute "

"when it is actually intended to get a :meth:`~timedelta.total_seconds` value "

"instead:"

msgstr ""

msgid ""

">>> from datetime import timedelta\n"

">>> duration = timedelta(seconds=11235813)\n"

">>> duration.days, duration.seconds\n"

"(130, 3813)\n"

">>> duration.total_seconds()\n"

"11235813.0"

msgstr ""

">>> from datetime import timedelta\n"

">>> duration = timedelta(seconds=11235813)\n"

">>> duration.days, duration.seconds\n"

"(130, 3813)\n"

">>> duration.total_seconds()\n"

"11235813.0"

msgid "Between 0 and 999,999 inclusive."

msgstr "Між 0 та 999,999 включно."

msgid "Supported operations:"

msgstr "Підтримувані операції:"

msgid "Operation"

msgstr "Операція"

msgid "Result"

msgstr "Результат"

msgid "``t1 = t2 + t3``"

msgstr "``t1 = t2 + t3``"

msgid ""

"Sum of ``t2`` and ``t3``. Afterwards ``t1 - t2 == t3`` and ``t1 - t3 == t2`` "

"are true. (1)"

msgstr ""

msgid "``t1 = t2 - t3``"

msgstr "``t1 = t2 - t3``"

msgid ""

"Difference of ``t2`` and ``t3``. Afterwards ``t1 == t2 - t3`` and ``t2 == "

"t1 + t3`` are true. (1)(6)"

msgstr ""

msgid "``t1 = t2 * i or t1 = i * t2``"

msgstr "``t1 = t2 * i або t1 = i * t2``"

msgid ""

"Delta multiplied by an integer. Afterwards ``t1 // i == t2`` is true, "

"provided ``i != 0``."

msgstr ""

msgid "In general, ``t1 * i == t1 * (i-1) + t1`` is true. (1)"

msgstr ""

msgid "``t1 = t2 * f or t1 = f * t2``"

msgstr "``t1 = t2 * f або t1 = f * t2``"

msgid ""

"Delta multiplied by a float. The result is rounded to the nearest multiple "

"of timedelta.resolution using round-half-to-even."

msgstr ""

"Дельта, помножена на float. Результат округлюється до найближчого кратного "

"timedelta.resolution за допомогою округлення від половини до навіть."

msgid "``f = t2 / t3``"

msgstr "``f = t2 / t3``"

msgid ""

"Division (3) of overall duration ``t2`` by interval unit ``t3``. Returns a :"

"class:`float` object."

msgstr ""

msgid "``t1 = t2 / f or t1 = t2 / i``"

msgstr "``t1 = t2 / f або t1 = t2 / i``"

msgid ""

"Delta divided by a float or an int. The result is rounded to the nearest "

"multiple of timedelta.resolution using round-half-to-even."

msgstr ""

"Дельта, поділена на float або int. Результат округлюється до найближчого "

"кратного timedelta.resolution за допомогою округлення від половини до навіть."

msgid "``t1 = t2 // i`` or ``t1 = t2 // t3``"

msgstr "``t1 = t2 // i`` або ``t1 = t2 // t3``"

msgid ""

"The floor is computed and the remainder (if any) is thrown away. In the "

"second case, an integer is returned. (3)"

msgstr ""

"Підлога обчислюється, а залишок (якщо є) викидається. У другому випадку "

"повертається ціле число. (3)"

msgid "``t1 = t2 % t3``"

msgstr "``t1 = t2 % t3``"

msgid "The remainder is computed as a :class:`timedelta` object. (3)"

msgstr "Залишок обчислюється як об’єкт :class:`timedelta`. (3)"

msgid "``q, r = divmod(t1, t2)``"

msgstr "``q, r = divmod(t1, t2)``"

msgid ""

"Computes the quotient and the remainder: ``q = t1 // t2`` (3) and ``r = t1 % "

"t2``. ``q`` is an integer and ``r`` is a :class:`timedelta` object."

msgstr ""

msgid "``+t1``"

msgstr "``+t1``"

msgid "Returns a :class:`timedelta` object with the same value. (2)"

msgstr "Повертає об’єкт :class:`timedelta` з тим самим значенням. (2)"

msgid "``-t1``"

msgstr "``-t1``"

msgid ""

"Equivalent to ``timedelta(-t1.days, -t1.seconds, -t1.microseconds)``, and to "

"``t1 * -1``. (1)(4)"

msgstr ""

msgid "``abs(t)``"

msgstr "``abs(t)``"

msgid ""

"Equivalent to ``+t`` when ``t.days >= 0``, and to ``-t`` when ``t.days < "

"0``. (2)"

msgstr ""

msgid "``str(t)``"

msgstr "``str(t)``"

msgid ""

"Returns a string in the form ``[D day[s], ][H]H:MM:SS[.UUUUUU]``, where D is "

"negative for negative ``t``. (5)"

msgstr ""

"Повертає рядок у формі ``[D day[s], ][H]H:MM:SS[.UUUUUU]``, де D є від’ємним "

"для від’ємного ``t``. (5)"

msgid "``repr(t)``"

msgstr "``repr(t)``"

msgid ""

"Returns a string representation of the :class:`timedelta` object as a "

"constructor call with canonical attribute values."

msgstr ""

"Повертає рядкове представлення об’єкта :class:`timedelta` як виклик "

"конструктора з канонічними значеннями атрибутів."

msgid "Notes:"

msgstr "Примітки:"

msgid "This is exact but may overflow."

msgstr "Це точно, але може переповнюватись."

msgid "This is exact and cannot overflow."

msgstr "Це точно і не може переповнюватися."

msgid "Division by zero raises :exc:`ZeroDivisionError`."

msgstr ""

msgid "``-timedelta.max`` is not representable as a :class:`timedelta` object."

msgstr ""

msgid ""

"String representations of :class:`timedelta` objects are normalized "

"similarly to their internal representation. This leads to somewhat unusual "

"results for negative timedeltas. For example::"

msgstr ""

"Рядкові представлення об’єктів :class:`timedelta` нормалізуються подібно до "

"їх внутрішнього представлення. Це призводить до дещо незвичайних результатів "

"для негативних часових дельт. Наприклад::"

msgid ""

">>> timedelta(hours=-5)\n"

"datetime.timedelta(days=-1, seconds=68400)\n"

">>> print(_)\n"

"-1 day, 19:00:00"

msgstr ""

msgid ""

"The expression ``t2 - t3`` will always be equal to the expression ``t2 + (-"

"t3)`` except when t3 is equal to ``timedelta.max``; in that case the former "

"will produce a result while the latter will overflow."

msgstr ""

"Вираз ``t2 - t3`` завжди дорівнюватиме виразу ``t2 + (-t3)``, за винятком "

"випадків, коли t3 дорівнює ``timedelta.max``; у цьому випадку перший дасть "

"результат, а другий переповниться."

msgid ""

"In addition to the operations listed above, :class:`timedelta` objects "

"support certain additions and subtractions with :class:`date` and :class:`."

"datetime` objects (see below)."

msgstr ""

"Окрім перерахованих вище операцій, об’єкти :class:`timedelta` підтримують "

"певні додавання та віднімання за допомогою об’єктів :class:`date` і :class:`."

"datetime` (див. нижче)."

msgid ""

"Floor division and true division of a :class:`timedelta` object by another :"

"class:`timedelta` object are now supported, as are remainder operations and "

"the :func:`divmod` function. True division and multiplication of a :class:"

"`timedelta` object by a :class:`float` object are now supported."

msgstr ""

"Тепер підтримується поділ на поверх і справжній поділ об’єкта :class:"

"`timedelta` на інший об’єкт :class:`timedelta`, а також операції з залишком "

"і функція :func:`divmod`. Тепер підтримується справжнє ділення та множення "

"об’єкта :class:`timedelta` на об’єкт :class:`float`."

msgid ":class:`timedelta` objects support equality and order comparisons."

msgstr ""

msgid ""

"In Boolean contexts, a :class:`timedelta` object is considered to be true if "

"and only if it isn't equal to ``timedelta(0)``."

msgstr ""

"У логічних контекстах об’єкт :class:`timedelta` вважається істинним тоді і "

"тільки тоді, коли він не дорівнює ``timedelta(0)``."

msgid "Instance methods:"

msgstr "Методи екземплярів:"

msgid ""

"Return the total number of seconds contained in the duration. Equivalent to "

"``td / timedelta(seconds=1)``. For interval units other than seconds, use "

"the division form directly (e.g. ``td / timedelta(microseconds=1)``)."

msgstr ""

"Повертає загальну кількість секунд, що міститься в тривалості. Еквівалент "

"``td / timedelta(seconds=1)``. Для одиниць інтервалу, відмінних від секунд, "

"використовуйте напряму форму ділення (наприклад, ``td / "

"timedelta(microseconds=1)``)."

msgid ""

"Note that for very large time intervals (greater than 270 years on most "

"platforms) this method will lose microsecond accuracy."

msgstr ""

"Зауважте, що для дуже великих інтервалів часу (понад 270 років на більшості "

"платформ) цей метод втратить мікросекундну точність."

msgid "Examples of usage: :class:`timedelta`"

msgstr "Приклади використання: :class:`timedelta`"

msgid "An additional example of normalization::"

msgstr "Додатковий приклад нормалізації::"

msgid ""

">>> # Components of another_year add up to exactly 365 days\n"

">>> from datetime import timedelta\n"

">>> year = timedelta(days=365)\n"

">>> another_year = timedelta(weeks=40, days=84, hours=23,\n"

"... minutes=50, seconds=600)\n"

">>> year == another_year\n"

"True\n"

">>> year.total_seconds()\n"

"31536000.0"

msgstr ""

msgid "Examples of :class:`timedelta` arithmetic::"

msgstr "Приклади арифметики :class:`timedelta`::"

msgid ""

">>> from datetime import timedelta\n"

">>> year = timedelta(days=365)\n"

">>> ten_years = 10 * year\n"

">>> ten_years\n"

"datetime.timedelta(days=3650)\n"

">>> ten_years.days // 365\n"

"10\n"

">>> nine_years = ten_years - year\n"

">>> nine_years\n"

"datetime.timedelta(days=3285)\n"

">>> three_years = nine_years // 3\n"

">>> three_years, three_years.days // 365\n"

"(datetime.timedelta(days=1095), 3)"

msgstr ""

msgid ":class:`date` Objects"

msgstr ":class:`date` Об'єкти"

msgid ""

"A :class:`date` object represents a date (year, month and day) in an "

"idealized calendar, the current Gregorian calendar indefinitely extended in "

"both directions."

msgstr ""

"Об’єкт :class:`date` представляє дату (рік, місяць і день) в ідеалізованому "

"календарі, поточний григоріанський календар необмежено розширений в обох "

"напрямках."

msgid ""

"January 1 of year 1 is called day number 1, January 2 of year 1 is called "

"day number 2, and so on. [#]_"

msgstr ""

"1 січня року 1 називається днем номер 1, 2 січня року 1 називається днем "

"номер 2 і так далі. [#]_"

msgid ""

"All arguments are required. Arguments must be integers, in the following "

"ranges:"

msgstr ""

"Всі аргументи необхідні. Аргументи мають бути цілими числами в таких "

"діапазонах:"

msgid "``MINYEAR <= year <= MAXYEAR``"

msgstr "``MINYEAR <= рік <= MAXYEAR``"

msgid "``1 <= month <= 12``"

msgstr "``1 <= місяць <= 12``"

msgid "``1 <= day <= number of days in the given month and year``"

msgstr "``1 <= день <= кількість днів у заданому місяці та році``"

msgid ""

"If an argument outside those ranges is given, :exc:`ValueError` is raised."

msgstr ""

"Якщо вказано аргумент поза цими діапазонами, виникає :exc:`ValueError`."

msgid "Other constructors, all class methods:"

msgstr "Інші конструктори, усі методи класу:"

msgid "Return the current local date."

msgstr "Повернути поточну місцеву дату."

msgid "This is equivalent to ``date.fromtimestamp(time.time())``."

msgstr "Це еквівалентно ``date.fromtimestamp(time.time())``."

msgid ""

"Return the local date corresponding to the POSIX timestamp, such as is "

"returned by :func:`time.time`."

msgstr ""

"Повертає місцеву дату, що відповідає мітці часу POSIX, наприклад, яку "

"повертає :func:`time.time`."

msgid ""

"This may raise :exc:`OverflowError`, if the timestamp is out of the range of "

"values supported by the platform C :c:func:`localtime` function, and :exc:"

"`OSError` on :c:func:`localtime` failure. It's common for this to be "

"restricted to years from 1970 through 2038. Note that on non-POSIX systems "

"that include leap seconds in their notion of a timestamp, leap seconds are "

"ignored by :meth:`fromtimestamp`."

msgstr ""

"Це може спричинити помилку :exc:`OverflowError`, якщо позначка часу виходить "

"за межі діапазону значень, які підтримує функція C :c:func:`localtime`, і :"

"exc:`OSError` у :c:func:`localtime` невдача. Зазвичай це обмежується роками "

"з 1970 по 2038 рік. Зауважте, що в системах без POSIX, які включають "

"високосні секунди в своє поняття позначки часу, високосні секунди "

"ігноруються :meth:`fromtimestamp`."

msgid ""

"Raise :exc:`OverflowError` instead of :exc:`ValueError` if the timestamp is "

"out of the range of values supported by the platform C :c:func:`localtime` "

"function. Raise :exc:`OSError` instead of :exc:`ValueError` on :c:func:"

"`localtime` failure."

msgstr ""

"Викликайте :exc:`OverflowError` замість :exc:`ValueError`, якщо позначка "

"часу виходить за межі діапазону значень, які підтримує функція C :c:func:"

"`localtime` платформи. Викликати :exc:`OSError` замість :exc:`ValueError` у "

"разі помилки :c:func:`localtime`."

msgid ""

"Return the date corresponding to the proleptic Gregorian ordinal, where "

"January 1 of year 1 has ordinal 1."

msgstr ""

"Повертає дату, що відповідає пролептичному григоріанському порядковому "

"номеру, де 1 січня 1 року має порядковий номер 1."

msgid ""

":exc:`ValueError` is raised unless ``1 <= ordinal <= date.max.toordinal()``. "

"For any date ``d``, ``date.fromordinal(d.toordinal()) == d``."

msgstr ""

msgid ""

"Return a :class:`date` corresponding to a *date_string* given in any valid "

"ISO 8601 format, with the following exceptions:"

msgstr ""

msgid ""

"Reduced precision dates are not currently supported (``YYYY-MM``, ``YYYY``)."

msgstr ""

msgid ""

"Extended date representations are not currently supported (``±YYYYYY-MM-"

"DD``)."

msgstr ""

msgid "Ordinal dates are not currently supported (``YYYY-OOO``)."

msgstr ""

msgid "Examples::"

msgstr "Приклади::"

msgid ""

">>> from datetime import date\n"

">>> date.fromisoformat('2019-12-04')\n"

"datetime.date(2019, 12, 4)\n"

">>> date.fromisoformat('20191204')\n"

"datetime.date(2019, 12, 4)\n"

">>> date.fromisoformat('2021-W01-1')\n"

"datetime.date(2021, 1, 4)"

msgstr ""

msgid "Previously, this method only supported the format ``YYYY-MM-DD``."

msgstr ""

msgid ""

"Return a :class:`date` corresponding to the ISO calendar date specified by "

"year, week and day. This is the inverse of the function :meth:`date."

"isocalendar`."

msgstr ""

"Повертає :class:`date`, що відповідає календарній даті ISO, визначеній "

"роком, тижнем і днем. Це зворотна функція :meth:`date.isocalendar`."

msgid "The earliest representable date, ``date(MINYEAR, 1, 1)``."

msgstr "Найраніша дата, яку можна представити, ``date(MINYEAR, 1, 1)``."

msgid "The latest representable date, ``date(MAXYEAR, 12, 31)``."

msgstr "Остання представлена дата, ``date(MAXYEAR, 12, 31)``."

msgid ""

"The smallest possible difference between non-equal date objects, "

"``timedelta(days=1)``."

msgstr ""

"Найменша можлива різниця між об’єктами нерівних дат, ``timedelta(days=1)``."

msgid "Between :const:`MINYEAR` and :const:`MAXYEAR` inclusive."

msgstr "Між :const:`MINYEAR` і :const:`MAXYEAR` включно."

msgid "Between 1 and 12 inclusive."

msgstr "Від 1 до 12 включно."

msgid "Between 1 and the number of days in the given month of the given year."

msgstr "Від 1 до числа днів у даному місяці даного року."

msgid "``date2 = date1 + timedelta``"

msgstr "``дата2 = дата1 + дельта часу``"

msgid "``date2`` will be ``timedelta.days`` days after ``date1``. (1)"

msgstr ""

msgid "``date2 = date1 - timedelta``"

msgstr "``дата2 = дата1 - дельта часу``"

msgid "Computes ``date2`` such that ``date2 + timedelta == date1``. (2)"

msgstr ""

msgid "``timedelta = date1 - date2``"

msgstr "``timedelta = дата1 - дата2``"

msgid "\\(3)"

msgstr "\\(3)"

msgid "``date1 == date2``"

msgstr ""

msgid "``date1 != date2``"

msgstr ""

msgid "Equality comparison. (4)"

msgstr ""

msgid "``date1 < date2``"

msgstr "``дата1 < дата2``"

msgid "``date1 > date2``"

msgstr ""

msgid "``date1 <= date2``"

msgstr ""

msgid "``date1 >= date2``"

msgstr ""

msgid "Order comparison. (5)"

msgstr ""

msgid ""

"*date2* is moved forward in time if ``timedelta.days > 0``, or backward if "

"``timedelta.days < 0``. Afterward ``date2 - date1 == timedelta.days``. "

"``timedelta.seconds`` and ``timedelta.microseconds`` are ignored. :exc:"

"`OverflowError` is raised if ``date2.year`` would be smaller than :const:"

"`MINYEAR` or larger than :const:`MAXYEAR`."

msgstr ""

"*date2* пересувається вперед у часі, якщо ``timedelta.days > 0``, або назад, "

"``timedelta.days < 0``. Після цього ``date2 - date1 == timedelta.days``. "

"``timedelta.seconds`` і ``timedelta.microseconds`` ігноруються. :exc:"

"`OverflowError` виникає, якщо ``date2.year`` буде меншим за :const:`MINYEAR` "

"або більшим за :const:`MAXYEAR`."

msgid "``timedelta.seconds`` and ``timedelta.microseconds`` are ignored."

msgstr "``timedelta.seconds`` і ``timedelta.microseconds`` ігноруються."

msgid ""

"This is exact, and cannot overflow. ``timedelta.seconds`` and ``timedelta."

"microseconds`` are 0, and ``date2 + timedelta == date1`` after."

msgstr ""

msgid ":class:`date` objects are equal if they represent the same date."

msgstr ""

msgid ""

":class:`!date` objects that are not also :class:`.datetime` instances are "

"never equal to :class:`!datetime` objects, even if they represent the same "

"date."

msgstr ""

msgid ""

"*date1* is considered less than *date2* when *date1* precedes *date2* in "

"time. In other words, ``date1 < date2`` if and only if ``date1.toordinal() < "

"date2.toordinal()``."

msgstr ""

msgid ""

"Order comparison between a :class:`!date` object that is not also a :class:`."

"datetime` instance and a :class:`!datetime` object raises :exc:`TypeError`."

msgstr ""

msgid ""

"Comparison between :class:`.datetime` object and an instance of the :class:"

"`date` subclass that is not a :class:`!datetime` subclass no longer converts "

"the latter to :class:`!date`, ignoring the time part and the time zone. The "

"default behavior can be changed by overriding the special comparison methods "

"in subclasses."

msgstr ""

msgid ""

"In Boolean contexts, all :class:`date` objects are considered to be true."

msgstr "У логічних контекстах усі об’єкти :class:`date` вважаються істинними."

msgid ""

"Return a new :class:`date` object with the same values, but with specified "

"parameters updated."

msgstr ""

msgid "Example::"

msgstr "Приклад::"

msgid ""

">>> from datetime import date\n"

">>> d = date(2002, 12, 31)\n"

">>> d.replace(day=26)\n"

"datetime.date(2002, 12, 26)"

msgstr ""

msgid ""

"The generic function :func:`copy.replace` also supports :class:`date` "

"objects."

msgstr ""

msgid ""

"Return a :class:`time.struct_time` such as returned by :func:`time."

"localtime`."

msgstr ""

"Повертає :class:`time.struct_time`, наприклад, повертає :func:`time."

"localtime`."