# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-03-11 00:16+0000\n"
"PO-Revision-Date: 2023-08-07 10:20+0800\n"
"Last-Translator: Griiid <gridwing@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.3.2\n"

#: ../../library/datetime.rst:2
msgid ":mod:`!datetime` --- Basic date and time types"
msgstr ":mod:`!datetime` --- 日期與時間的基本型別"

#: ../../library/datetime.rst:11
msgid "**Source code:** :source:`Lib/datetime.py`"
msgstr "**原始碼：**\\ :source:`Lib/datetime.py`"

#: ../../library/datetime.rst:15
msgid ""
"The :mod:`!datetime` module supplies classes for manipulating dates and "
"times."
msgstr ":mod:`!datetime` 模組提供操作日期與時間的類別。"

#: ../../library/datetime.rst:17
msgid ""
"While date and time arithmetic is supported, the focus of the implementation "
"is on efficient attribute extraction for output formatting and manipulation."
msgstr ""

#: ../../library/datetime.rst:22
msgid "Skip to :ref:`the format codes <format-codes>`."
msgstr "跳轉至\\ :ref:`格式碼 (format codes) <format-codes>`。"

#: ../../library/datetime.rst:26
msgid "Module :mod:`calendar`"
msgstr ":mod:`calendar` 模組"

#: ../../library/datetime.rst:27
msgid "General calendar related functions."
msgstr "與日曆相關的一般函式。"

#: ../../library/datetime.rst:29
msgid "Module :mod:`time`"
msgstr ":mod:`time` 模組"

#: ../../library/datetime.rst:30
msgid "Time access and conversions."
msgstr ""

#: ../../library/datetime.rst:32
msgid "Module :mod:`zoneinfo`"
msgstr ":mod:`zoneinfo` 模組"

#: ../../library/datetime.rst:33
msgid "Concrete time zones representing the IANA time zone database."
msgstr ""

#: ../../library/datetime.rst:35
msgid "Package `dateutil <https://dateutil.readthedocs.io/en/stable/>`_"
msgstr "`dateutil <https://dateutil.readthedocs.io/en/stable/>`_ 套件"

#: ../../library/datetime.rst:36
msgid "Third-party library with expanded time zone and parsing support."
msgstr "帶有時區與剖析擴充支援的第三方函式庫。"

#: ../../library/datetime.rst:38
msgid "Package :pypi:`DateType`"
msgstr ":pypi:`DateType` 套件"

#: ../../library/datetime.rst:39
msgid ""
"Third-party library that introduces distinct static types to for example, "
"allow :term:`static type checkers <static type checker>` to differentiate "
"between naive and aware datetimes."
msgstr ""

#: ../../library/datetime.rst:47
msgid "Aware and naive objects"
msgstr ""

#: ../../library/datetime.rst:49
msgid ""
"Date and time objects may be categorized as \"aware\" or \"naive\" depending "
"on whether or not they include time zone information."
msgstr ""

#: ../../library/datetime.rst:52
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 ""

#: ../../library/datetime.rst:58
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 ""

#: ../../library/datetime.rst:65
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 ""

#: ../../library/datetime.rst:71
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 ""

#: ../../library/datetime.rst:81
msgid "Constants"
msgstr "常數"

#: ../../library/datetime.rst:83
msgid "The :mod:`!datetime` module exports the following constants:"
msgstr ":mod:`!datetime` 模組匯出以下常數："

#: ../../library/datetime.rst:87
msgid ""
"The smallest year number allowed in a :class:`date` or :class:`.datetime` "
"object. :const:`MINYEAR` is 1."
msgstr ""

#: ../../library/datetime.rst:93
msgid ""
"The largest year number allowed in a :class:`date` or :class:`.datetime` "
"object. :const:`MAXYEAR` is 9999."
msgstr ""

#: ../../library/datetime.rst:99
msgid "Alias for the UTC time zone singleton :attr:`datetime.timezone.utc`."
msgstr ""

#: ../../library/datetime.rst:105
msgid "Available types"
msgstr ""

#: ../../library/datetime.rst:110
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 ""

#: ../../library/datetime.rst:118
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 ""

#: ../../library/datetime.rst:127
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 ""

#: ../../library/datetime.rst:135
msgid ""
"A duration expressing the difference between two :class:`.datetime` or :"
"class:`date` instances to microsecond resolution."
msgstr ""
"表示兩個 :class:`.datetime` 或 :class:`date` 實例之間時間的差異，以微秒為解析"
"度。"

#: ../../library/datetime.rst:142
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 ""

#: ../../library/datetime.rst:151
msgid ""
"A class that implements the :class:`tzinfo` abstract base class as a fixed "
"offset from the UTC."
msgstr ""

#: ../../library/datetime.rst:157 ../../library/datetime.rst:174
msgid "Objects of these types are immutable."
msgstr ""

#: ../../library/datetime.rst:159
msgid "Subclass relationships:"
msgstr ""

#: ../../library/datetime.rst:161
msgid ""
"timedelta, tzinfo, time, and date inherit from object; timezone inherits\n"
"from tzinfo; and datetime inherits from date."
msgstr ""

#: ../../library/datetime.rst:169
msgid "Common properties"
msgstr "常見屬性"

#: ../../library/datetime.rst:171
msgid ""
"The :class:`date`, :class:`.datetime`, :class:`.time`, and :class:`timezone` "
"types share these common features:"
msgstr ""

#: ../../library/datetime.rst:175
msgid ""
"Objects of these types are :term:`hashable`, meaning that they can be used "
"as dictionary keys."
msgstr ""

#: ../../library/datetime.rst:177
msgid ""
"Objects of these types support efficient pickling via the :mod:`pickle` "
"module."
msgstr ""

#: ../../library/datetime.rst:181
msgid "Determining if an object is aware or naive"
msgstr ""

#: ../../library/datetime.rst:183
msgid "Objects of the :class:`date` type are always naive."
msgstr ""

#: ../../library/datetime.rst:185
msgid ""
"An object of type :class:`.time` or :class:`.datetime` may be aware or naive."
msgstr ""

#: ../../library/datetime.rst:187
msgid ""
"A :class:`.datetime` object ``d`` is aware if both of the following hold:"
msgstr ""

#: ../../library/datetime.rst:189
msgid "``d.tzinfo`` is not ``None``"
msgstr "``d.tzinfo`` 不是 ``None``"

#: ../../library/datetime.rst:190
msgid "``d.tzinfo.utcoffset(d)`` does not return ``None``"
msgstr "``d.tzinfo.utcoffset(d)`` 不會回傳 ``None``"

#: ../../library/datetime.rst:192
msgid "Otherwise, ``d`` is naive."
msgstr "否則 ``d`` 會是 naive 的。"

#: ../../library/datetime.rst:194
msgid "A :class:`.time` object ``t`` is aware if both of the following hold:"
msgstr ""

#: ../../library/datetime.rst:196
msgid "``t.tzinfo`` is not ``None``"
msgstr "``t.tzinfo`` 不是 ``None``"

#: ../../library/datetime.rst:197
msgid "``t.tzinfo.utcoffset(None)`` does not return ``None``."
msgstr "``t.tzinfo.utcoffset(None)`` 沒有回傳 ``None``。"

#: ../../library/datetime.rst:199
msgid "Otherwise, ``t`` is naive."
msgstr "否則 ``t`` 會是 naive 的。"

#: ../../library/datetime.rst:201
msgid ""
"The distinction between aware and naive doesn't apply to :class:`timedelta` "
"objects."
msgstr ""

#: ../../library/datetime.rst:208
msgid ":class:`!timedelta` objects"
msgstr ":class:`!timedelta` 物件"

#: ../../library/datetime.rst:210
msgid ""
"A :class:`timedelta` object represents a duration, the difference between "
"two :class:`.datetime` or :class:`date` instances."
msgstr ""
"一個 :class:`timedelta` 物件代表著一段持續時間，即兩個 :class:`.datetime` "
"或 :class:`date` 之間的差異。"

#: ../../library/datetime.rst:215
msgid ""
"All arguments are optional and default to 0. Arguments may be integers or "
"floats, and may be positive or negative."
msgstr ""

#: ../../library/datetime.rst:218
msgid ""
"Only *days*, *seconds* and *microseconds* are stored internally. Arguments "
"are converted to those units:"
msgstr ""

#: ../../library/datetime.rst:221
msgid "A millisecond is converted to 1000 microseconds."
msgstr "一毫秒會被轉換為 1000 微秒。"

#: ../../library/datetime.rst:222
msgid "A minute is converted to 60 seconds."
msgstr "一分鐘會被轉換為 60 秒。"

#: ../../library/datetime.rst:223
msgid "An hour is converted to 3600 seconds."
msgstr "一小時會被轉換為 3600 秒。"

#: ../../library/datetime.rst:224
msgid "A week is converted to 7 days."
msgstr "一週會被轉換為 7 天。"

#: ../../library/datetime.rst:226
msgid ""
"and days, seconds and microseconds are then normalized so that the "
"representation is unique, with"
msgstr ""

#: ../../library/datetime.rst:229
msgid "``0 <= microseconds < 1000000``"
msgstr "``0 <= microseconds < 1000000``"

#: ../../library/datetime.rst:230
msgid "``0 <= seconds < 3600*24`` (the number of seconds in one day)"
msgstr ""

#: ../../library/datetime.rst:231
msgid "``-999999999 <= days <= 999999999``"
msgstr "``-999999999 <= days <= 999999999``"

#: ../../library/datetime.rst:233
msgid ""
"The following example illustrates how any arguments besides *days*, "
"*seconds* and *microseconds* are \"merged\" and normalized into those three "
"resulting attributes::"
msgstr ""

#: ../../library/datetime.rst:237
msgid ""
">>> import datetime as dt\n"
">>> delta = dt.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 ""

#: ../../library/datetime.rst:252
msgid ""
"``import datetime as dt`` instead of ``import datetime`` or ``from datetime "
"import datetime`` to avoid confusion between the module and the class. See "
"`How I Import Python’s datetime Module <https://adamj.eu/tech/2019/09/12/how-"
"i-import-pythons-datetime-module/>`__."
msgstr ""

#: ../../library/datetime.rst:257
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 ""

#: ../../library/datetime.rst:264
msgid ""
"If the normalized value of days lies outside the indicated range, :exc:"
"`OverflowError` is raised."
msgstr ""

#: ../../library/datetime.rst:267
msgid ""
"Note that normalization of negative values may be surprising at first. For "
"example::"
msgstr ""

#: ../../library/datetime.rst:270
msgid ""
">>> import datetime as dt\n"
">>> d = dt.timedelta(microseconds=-1)\n"
">>> (d.days, d.seconds, d.microseconds)\n"
"(-1, 86399, 999999)"
msgstr ""
">>> import datetime as dt\n"
">>> d = dt.timedelta(microseconds=-1)\n"
">>> (d.days, d.seconds, d.microseconds)\n"
"(-1, 86399, 999999)"

#: ../../library/datetime.rst:275
msgid ""
"Since the string representation of :class:`!timedelta` objects can be "
"confusing, use the following recipe to produce a more readable format:"
msgstr ""

#: ../../library/datetime.rst:278
msgid ""
">>> def pretty_timedelta(td):\n"
"...     if td.days >= 0:\n"
"...         return str(td)\n"
"...     return f'-({-td!s})'\n"
"...\n"
">>> d = timedelta(hours=-1)\n"
">>> str(d)  # not human-friendly\n"
"'-1 day, 23:00:00'\n"
">>> pretty_timedelta(d)\n"
"'-(1:00:00)'"
msgstr ""
">>> def pretty_timedelta(td):\n"
"...     if td.days >= 0:\n"
"...         return str(td)\n"
"...     return f'-({-td!s})'\n"
"...\n"
">>> d = timedelta(hours=-1)\n"
">>> str(d)  # not human-friendly\n"
"'-1 day, 23:00:00'\n"
">>> pretty_timedelta(d)\n"
"'-(1:00:00)'"

#: ../../library/datetime.rst:292 ../../library/datetime.rst:630
#: ../../library/datetime.rst:1200 ../../library/datetime.rst:1845
#: ../../library/datetime.rst:2481
msgid "Class attributes:"
msgstr "類別屬性："

#: ../../library/datetime.rst:296
msgid "The most negative :class:`timedelta` object, ``timedelta(-999999999)``."
msgstr ""

#: ../../library/datetime.rst:301
msgid ""
"The most positive :class:`timedelta` object, ``timedelta(days=999999999, "
"hours=23, minutes=59, seconds=59, microseconds=999999)``."
msgstr ""

#: ../../library/datetime.rst:307
msgid ""
"The smallest possible difference between non-equal :class:`timedelta` "
"objects, ``timedelta(microseconds=1)``."
msgstr ""

#: ../../library/datetime.rst:311
msgid ""
"Note that, because of normalization, ``timedelta.max`` is greater than ``-"
"timedelta.min``. ``-timedelta.max`` is not representable as a :class:"
"`timedelta` object."
msgstr ""

#: ../../library/datetime.rst:315 ../../library/datetime.rst:648
#: ../../library/datetime.rst:1220 ../../library/datetime.rst:1865
msgid "Instance attributes (read-only):"
msgstr ""

#: ../../library/datetime.rst:319
msgid "Between -999,999,999 and 999,999,999 inclusive."
msgstr "在 -999,999,999 到 999,999,999 （含）之間"

#: ../../library/datetime.rst:324
msgid "Between 0 and 86,399 inclusive."
msgstr "在 0 到 86,399 （含）之間"

#: ../../library/datetime.rst:328
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 ""

#: ../../library/datetime.rst:332
msgid ""
">>> import datetime as dt\n"
">>> duration = dt.timedelta(seconds=11235813)\n"
">>> duration.days, duration.seconds\n"
"(130, 3813)\n"
">>> duration.total_seconds()\n"
"11235813.0"
msgstr ""
">>> import datetime as dt\n"
">>> duration = dt.timedelta(seconds=11235813)\n"
">>> duration.days, duration.seconds\n"
"(130, 3813)\n"
">>> duration.total_seconds()\n"
"11235813.0"

#: ../../library/datetime.rst:344
msgid "Between 0 and 999,999 inclusive."
msgstr "在 0 到 999,999 （含）之間"

#: ../../library/datetime.rst:347 ../../library/datetime.rst:665
#: ../../library/datetime.rst:1274
msgid "Supported operations:"
msgstr ""

#: ../../library/datetime.rst:350 ../../library/datetime.rst:668
#: ../../library/datetime.rst:1277
msgid "Operation"
msgstr ""

#: ../../library/datetime.rst:350 ../../library/datetime.rst:668
#: ../../library/datetime.rst:1277
msgid "Result"
msgstr ""

#: ../../library/datetime.rst:352
msgid "``t1 = t2 + t3``"
msgstr "``t1 = t2 + t3``"

#: ../../library/datetime.rst:352
msgid ""
"Sum of ``t2`` and ``t3``. Afterwards ``t1 - t2 == t3`` and ``t1 - t3 == t2`` "
"are true. (1)"
msgstr ""

#: ../../library/datetime.rst:356
msgid "``t1 = t2 - t3``"
msgstr "``t1 = t2 - t3``"

#: ../../library/datetime.rst:356
msgid ""
"Difference of ``t2``  and ``t3``. Afterwards ``t1 == t2 - t3`` and ``t2 == "
"t1 + t3`` are true. (1)(6)"
msgstr ""

#: ../../library/datetime.rst:360
msgid "``t1 = t2 * i or t1 = i * t2``"
msgstr "``t1 = t2 * i or t1 = i * t2``"

#: ../../library/datetime.rst:360
msgid ""
"Delta multiplied by an integer. Afterwards ``t1 // i == t2`` is true, "
"provided ``i != 0``."
msgstr ""

#: ../../library/datetime.rst:364
msgid "In general, ``t1  * i == t1 * (i-1) + t1`` is true. (1)"
msgstr ""

#: ../../library/datetime.rst:367
msgid "``t1 = t2 * f or t1 = f * t2``"
msgstr "``t1 = t2 * f or t1 = f * t2``"

#: ../../library/datetime.rst:367
msgid ""
"Delta multiplied by a float. The result is rounded to the nearest multiple "
"of timedelta.resolution using round-half-to-even."
msgstr ""

#: ../../library/datetime.rst:371
msgid "``f = t2 / t3``"
msgstr "``f = t2 / t3``"

#: ../../library/datetime.rst:371
msgid ""
"Division (3) of overall duration ``t2`` by interval unit ``t3``. Returns a :"
"class:`float` object."
msgstr ""

#: ../../library/datetime.rst:375
msgid "``t1 = t2 / f or t1 = t2 / i``"
msgstr "``t1 = t2 / f or t1 = t2 / i``"

#: ../../library/datetime.rst:375
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 ""

#: ../../library/datetime.rst:379
msgid "``t1 = t2 // i`` or ``t1 = t2 // t3``"
msgstr "``t1 = t2 // i`` or ``t1 = t2 // t3``"

#: ../../library/datetime.rst:379
msgid ""
"The floor is computed and the remainder (if any) is thrown away. In the "
"second case, an integer is returned. (3)"
msgstr ""

#: ../../library/datetime.rst:383
msgid "``t1 = t2 % t3``"
msgstr "``t1 = t2 % t3``"

#: ../../library/datetime.rst:383
msgid "The remainder is computed as a :class:`timedelta` object. (3)"
msgstr ""

#: ../../library/datetime.rst:386
msgid "``q, r = divmod(t1, t2)``"
msgstr "``q, r = divmod(t1, t2)``"

#: ../../library/datetime.rst:386
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 ""

#: ../../library/datetime.rst:391
msgid "``+t1``"
msgstr "``+t1``"

#: ../../library/datetime.rst:391
msgid "Returns a :class:`timedelta` object with the same value. (2)"
msgstr ""

#: ../../library/datetime.rst:394
msgid "``-t1``"
msgstr "``-t1``"

#: ../../library/datetime.rst:394
msgid ""
"Equivalent to ``timedelta(-t1.days, -t1.seconds, -t1.microseconds)``, and to "
"``t1 * -1``. (1)(4)"
msgstr ""
"等價於 ``timedelta(-t1.days, -t1.seconds, -t1.microseconds)``，也等價於 ``t1 "
"* -1``。 (1)(4)"

#: ../../library/datetime.rst:398
msgid "``abs(t)``"
msgstr "``abs(t)``"

#: ../../library/datetime.rst:398
msgid ""
"Equivalent to ``+t`` when ``t.days >= 0``, and to ``-t`` when ``t.days < "
"0``. (2)"
msgstr ""

#: ../../library/datetime.rst:401
msgid "``str(t)``"
msgstr "``str(t)``"

#: ../../library/datetime.rst:401
msgid ""
"Returns a string in the form ``[D day[s], ][H]H:MM:SS[.UUUUUU]``, where D is "
"negative for negative ``t``. (5)"
msgstr ""

#: ../../library/datetime.rst:405
msgid "``repr(t)``"
msgstr "``repr(t)``"

#: ../../library/datetime.rst:405
msgid ""
"Returns a string representation of the :class:`timedelta` object as a "
"constructor call with canonical attribute values."
msgstr ""

#: ../../library/datetime.rst:410 ../../library/datetime.rst:687
#: ../../library/datetime.rst:2750
msgid "Notes:"
msgstr "註解："

#: ../../library/datetime.rst:413
msgid "This is exact but may overflow."
msgstr "這是精確的，但可能會溢位。"

#: ../../library/datetime.rst:416
msgid "This is exact and cannot overflow."
msgstr "這是精確的，且不會溢位。"

#: ../../library/datetime.rst:419
msgid "Division by zero raises :exc:`ZeroDivisionError`."
msgstr ""

#: ../../library/datetime.rst:422
msgid "``-timedelta.max`` is not representable as a :class:`timedelta` object."
msgstr ""

#: ../../library/datetime.rst:425
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 ""

#: ../../library/datetime.rst:429
msgid ""
">>> timedelta(hours=-5)\n"
"datetime.timedelta(days=-1, seconds=68400)\n"
">>> print(_)\n"
"-1 day, 19:00:00"
msgstr ""
">>> timedelta(hours=-5)\n"
"datetime.timedelta(days=-1, seconds=68400)\n"
">>> print(_)\n"
"-1 day, 19:00:00"

#: ../../library/datetime.rst:435
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 ""

#: ../../library/datetime.rst:439
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 ""

#: ../../library/datetime.rst:443
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 ""

#: ../../library/datetime.rst:449
msgid ":class:`timedelta` objects support equality and order comparisons."
msgstr ""

#: ../../library/datetime.rst:451
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 ""

#: ../../library/datetime.rst:454 ../../library/datetime.rst:729
#: ../../library/datetime.rst:1365 ../../library/datetime.rst:1990
msgid "Instance methods:"
msgstr "實例方法："

#: ../../library/datetime.rst:458
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 (for example, ``td / timedelta(microseconds=1)``)."
msgstr ""

#: ../../library/datetime.rst:462
msgid ""
"Note that for very large time intervals (greater than 270 years on most "
"platforms) this method will lose microsecond accuracy."
msgstr ""

#: ../../library/datetime.rst:469
msgid "Examples of usage: :class:`!timedelta`"
msgstr "用法範例：:class:`!timedelta`"

#: ../../library/datetime.rst:471
msgid "An additional example of normalization::"
msgstr ""

#: ../../library/datetime.rst:473
msgid ""
">>> # Components of another_year add up to exactly 365 days\n"
">>> import datetime as dt\n"
">>> year = dt.timedelta(days=365)\n"
">>> another_year = dt.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 ""

#: ../../library/datetime.rst:483
msgid "Examples of :class:`timedelta` arithmetic::"
msgstr ""

#: ../../library/datetime.rst:485
msgid ""
">>> import datetime as dt\n"
">>> year = dt.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 ""
">>> import datetime as dt\n"
">>> year = dt.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)"

#: ../../library/datetime.rst:503
msgid ":class:`!date` objects"
msgstr ":class:`!date` 物件"

#: ../../library/datetime.rst:505
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 ""

#: ../../library/datetime.rst:509
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 ""

#: ../../library/datetime.rst:514
msgid ""
"All arguments are required. Arguments must be integers, in the following "
"ranges:"
msgstr ""

#: ../../library/datetime.rst:517
msgid "``MINYEAR <= year <= MAXYEAR``"
msgstr "``MINYEAR <= year <= MAXYEAR``"

#: ../../library/datetime.rst:518
msgid "``1 <= month <= 12``"
msgstr "``1 <= month <= 12``"

#: ../../library/datetime.rst:519
msgid "``1 <= day <= number of days in the given month and year``"
msgstr "``1 <= day <= 該年該月的天數``"

#: ../../library/datetime.rst:521 ../../library/datetime.rst:950
msgid ""
"If an argument outside those ranges is given, :exc:`ValueError` is raised."
msgstr ""

#: ../../library/datetime.rst:524 ../../library/datetime.rst:956
msgid "Other constructors, all class methods:"
msgstr ""

#: ../../library/datetime.rst:528
msgid "Return the current local date."
msgstr "回傳目前的本地日期。"

#: ../../library/datetime.rst:530
msgid "This is equivalent to ``date.fromtimestamp(time.time())``."
msgstr "這等同於 ``date.fromtimestamp(time.time())``。"

#: ../../library/datetime.rst:535
msgid ""
"Return the local date corresponding to the POSIX *timestamp*, such as is "
"returned by :func:`time.time`."
msgstr ""

#: ../../library/datetime.rst:538
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 ""

#: ../../library/datetime.rst:545
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 ""

#: ../../library/datetime.rst:554
msgid ""
"Return the date corresponding to the proleptic Gregorian *ordinal*, where "
"January 1 of year 1 has ordinal 1."
msgstr ""

#: ../../library/datetime.rst:557
msgid ""
":exc:`ValueError` is raised unless ``1 <= ordinal <= date.max.toordinal()``. "
"For any date ``d``, ``date.fromordinal(d.toordinal()) == d``."
msgstr ""

#: ../../library/datetime.rst:564
msgid ""
"Return a :class:`date` corresponding to a *date_string* given in any valid "
"ISO 8601 format, with the following exceptions:"
msgstr ""

#: ../../library/datetime.rst:567 ../../library/datetime.rst:1121
msgid ""
"Reduced precision dates are not currently supported (``YYYY-MM``, ``YYYY``)."
msgstr ""

#: ../../library/datetime.rst:569 ../../library/datetime.rst:1123
msgid ""
"Extended date representations are not currently supported (``±YYYYYY-MM-"
"DD``)."
msgstr ""

#: ../../library/datetime.rst:571 ../../library/datetime.rst:1125
msgid "Ordinal dates are not currently supported (``YYYY-OOO``)."
msgstr ""

#: ../../library/datetime.rst:573 ../../library/datetime.rst:1127
#: ../../library/datetime.rst:1599
msgid "Examples::"
msgstr "範例： ::"

#: ../../library/datetime.rst:575
msgid ""
">>> import datetime as dt\n"
">>> dt.date.fromisoformat('2019-12-04')\n"
"datetime.date(2019, 12, 4)\n"
">>> dt.date.fromisoformat('20191204')\n"
"datetime.date(2019, 12, 4)\n"
">>> dt.date.fromisoformat('2021-W01-1')\n"
"datetime.date(2021, 1, 4)"
msgstr ""
">>> import datetime as dt\n"
">>> dt.date.fromisoformat('2019-12-04')\n"
"datetime.date(2019, 12, 4)\n"
">>> dt.date.fromisoformat('20191204')\n"
"datetime.date(2019, 12, 4)\n"
">>> dt.date.fromisoformat('2021-W01-1')\n"
"datetime.date(2021, 1, 4)"

#: ../../library/datetime.rst:584
msgid "Previously, this method only supported the format ``YYYY-MM-DD``."
msgstr ""

#: ../../library/datetime.rst:590
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 ""

#: ../../library/datetime.rst:598
msgid ""
"Return a :class:`.date` corresponding to *date_string*, parsed according to "
"*format*. This is equivalent to::"
msgstr ""

#: ../../library/datetime.rst:601
msgid "date(*(time.strptime(date_string, format)[0:3]))"
msgstr "date(*(time.strptime(date_string, format)[0:3]))"

#: ../../library/datetime.rst:603
msgid ""
":exc:`ValueError` is raised if the date_string and format can't be parsed "
"by :func:`time.strptime` or if it returns a value which isn't a time tuple.  "
"See also :ref:`strftime-strptime-behavior` and :meth:`date.fromisoformat`."
msgstr ""

#: ../../library/datetime.rst:610
msgid ""
"If *format* specifies a day of month without a year a :exc:"
"`DeprecationWarning` is emitted.  This is to avoid a quadrennial leap year "
"bug in code seeking to parse only a month and day as the default year used "
"in absence of one in the format is not a leap year. Such *format* values may "
"raise an error as of Python 3.15.  The workaround is to always include a "
"year in your *format*.  If parsing *date_string* values that do not have a "
"year, explicitly add a year that is a leap year before parsing:"
msgstr ""

#: ../../library/datetime.rst:619
msgid ""
">>> import datetime as dt\n"
">>> date_string = \"02/29\"\n"
">>> when = dt.date.strptime(f\"{date_string};1984\", \"%m/%d;%Y\")  # Avoids "
"leap year bug.\n"
">>> when.strftime(\"%B %d\")\n"
"'February 29'"
msgstr ""
">>> import datetime as dt\n"
">>> date_string = \"02/29\"\n"
">>> when = dt.date.strptime(f\"{date_string};1984\", \"%m/%d;%Y\")  # 避免閏年"
"錯誤。\n"
">>> when.strftime(\"%B %d\")\n"
"'February 29'"

#: ../../library/datetime.rst:634
msgid "The earliest representable date, ``date(MINYEAR, 1, 1)``."
msgstr ""

#: ../../library/datetime.rst:639
msgid "The latest representable date, ``date(MAXYEAR, 12, 31)``."
msgstr ""

#: ../../library/datetime.rst:644
msgid ""
"The smallest possible difference between non-equal date objects, "
"``timedelta(days=1)``."
msgstr ""

#: ../../library/datetime.rst:652 ../../library/datetime.rst:1224
msgid "Between :const:`MINYEAR` and :const:`MAXYEAR` inclusive."
msgstr ""

#: ../../library/datetime.rst:657 ../../library/datetime.rst:1229
msgid "Between 1 and 12 inclusive."
msgstr "在 1 到 12 （含）之間。"

#: ../../library/datetime.rst:662 ../../library/datetime.rst:1234
msgid "Between 1 and the number of days in the given month of the given year."
msgstr ""

#: ../../library/datetime.rst:670
msgid "``date2 = date1 + timedelta``"
msgstr "``date2 = date1 + timedelta``"

#: ../../library/datetime.rst:670
msgid "``date2`` will be ``timedelta.days`` days after ``date1``. (1)"
msgstr ""

#: ../../library/datetime.rst:673
msgid "``date2 = date1 - timedelta``"
msgstr "``date2 = date1 - timedelta``"

#: ../../library/datetime.rst:673
msgid "Computes ``date2`` such that ``date2 + timedelta == date1``. (2)"
msgstr ""

#: ../../library/datetime.rst:676
msgid "``timedelta = date1 - date2``"
msgstr "``timedelta = date1 - date2``"

#: ../../library/datetime.rst:676 ../../library/datetime.rst:1283
msgid "\\(3)"
msgstr "\\(3)"

#: ../../library/datetime.rst:0
msgid "``date1 == date2``"
msgstr "``date1 == date2``"

#: ../../library/datetime.rst:0
msgid "``date1 != date2``"
msgstr "``date1 != date2``"

#: ../../library/datetime.rst:678 ../../library/datetime.rst:1285
msgid "Equality comparison. (4)"
msgstr ""

#: ../../library/datetime.rst:0
msgid "``date1 < date2``"
msgstr "``date1 < date2``"

#: ../../library/datetime.rst:0
msgid "``date1 > date2``"
msgstr "``date1 > date2``"

#: ../../library/datetime.rst:0
msgid "``date1 <= date2``"
msgstr "``date1 <= date2``"

#: ../../library/datetime.rst:0
msgid "``date1 >= date2``"
msgstr "``date1 >= date2``"

#: ../../library/datetime.rst:681 ../../library/datetime.rst:1288
msgid "Order comparison. (5)"
msgstr ""

#: ../../library/datetime.rst:690
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 ""

#: ../../library/datetime.rst:697
msgid "``timedelta.seconds`` and ``timedelta.microseconds`` are ignored."
msgstr "``timedelta.seconds`` 和 ``timedelta.microseconds`` 被忽略。"

#: ../../library/datetime.rst:700
msgid ""
"This is exact, and cannot overflow. ``timedelta.seconds`` and ``timedelta."
"microseconds`` are 0, and ``date2 + timedelta == date1`` after."
msgstr ""

#: ../../library/datetime.rst:704
msgid ":class:`date` objects are equal if they represent the same date."
msgstr ""

#: ../../library/datetime.rst:706
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 ""

#: ../../library/datetime.rst:711
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 ""

#: ../../library/datetime.rst:715
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 ""

#: ../../library/datetime.rst:719 ../../library/datetime.rst:1356
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 ""

#: ../../library/datetime.rst:727
msgid ""
"In Boolean contexts, all :class:`date` objects are considered to be true."
msgstr ""

#: ../../library/datetime.rst:733
msgid ""
"Return a new :class:`date` object with the same values, but with specified "
"parameters updated."
msgstr ""

#: ../../library/datetime.rst:736 ../../library/datetime.rst:2036
msgid "Example::"
msgstr "範例： ::"

#: ../../library/datetime.rst:738
msgid ""
">>> import datetime as dt\n"
">>> d = dt.date(2002, 12, 31)\n"
">>> d.replace(day=26)\n"
"datetime.date(2002, 12, 26)"
msgstr ""
">>> import datetime as dt\n"
">>> d = dt.date(2002, 12, 31)\n"
">>> d.replace(day=26)\n"
"datetime.date(2002, 12, 26)"

#: ../../library/datetime.rst:743
msgid ""
"The generic function :func:`copy.replace` also supports :class:`date` "
"objects."
msgstr ""

#: ../../library/datetime.rst:749 ../../library/datetime.rst:1481
msgid ""
"Return a :class:`time.struct_time` such as returned by :func:`time."
"localtime`."
msgstr ""
"回傳一個 :class:`time.struct_time`，如同 :func:`time.localtime` 所回傳。"

#: ../../library/datetime.rst:751
msgid "The hours, minutes and seconds are 0, and the DST flag is -1."
msgstr ""

#: ../../library/datetime.rst:753 ../../library/datetime.rst:1483
msgid "``d.timetuple()`` is equivalent to::"
msgstr "``d.timetuple()`` 等價於： ::"

#: ../../library/datetime.rst:755
msgid ""
"time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))"
msgstr ""
"time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))"

#: ../../library/datetime.rst:757
msgid ""
"where ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` is the "
"day number within the current year starting with 1 for January 1st."
msgstr ""

#: ../../library/datetime.rst:763
msgid ""
"Return the proleptic Gregorian ordinal of the date, where January 1 of year "
"1 has ordinal 1. For any :class:`date` object ``d``, ``date.fromordinal(d."
"toordinal()) == d``."
msgstr ""

#: ../../library/datetime.rst:770
msgid ""
"Return the day of the week as an integer, where Monday is 0 and Sunday is 6. "
"For example, ``date(2002, 12, 4).weekday() == 2``, a Wednesday. See also :"
"meth:`isoweekday`."
msgstr ""
"回傳一個代表星期幾的整數，星期一為 0、星期日為 6。例如 ``date(2002, 12, 4)."
"weekday() == 2`` 為星期三。也請參考 :meth:`isoweekday`。"

#: ../../library/datetime.rst:777
msgid ""
"Return the day of the week as an integer, where Monday is 1 and Sunday is 7. "
"For example, ``date(2002, 12, 4).isoweekday() == 3``, a Wednesday. See also :"
"meth:`weekday`, :meth:`isocalendar`."
msgstr ""

#: ../../library/datetime.rst:784
msgid ""
"Return a :term:`named tuple` object with three components: ``year``, "
"``week`` and ``weekday``."
msgstr ""

#: ../../library/datetime.rst:787
msgid ""
"The ISO calendar is a widely used variant of the Gregorian calendar. [#]_"
msgstr ""

#: ../../library/datetime.rst:789
msgid ""
"The ISO year consists of 52 or 53 full weeks, and where a week starts on a "
"Monday and ends on a Sunday. The first week of an ISO year is the first "
"(Gregorian) calendar week of a year containing a Thursday. This is called "
"week number 1, and the ISO year of that Thursday is the same as its "
"Gregorian year."
msgstr ""

#: ../../library/datetime.rst:794
msgid ""
"For example, 2004 begins on a Thursday, so the first week of ISO year 2004 "
"begins on Monday, 29 Dec 2003 and ends on Sunday, 4 Jan 2004::"
msgstr ""

#: ../../library/datetime.rst:797
msgid ""
">>> import datetime as dt\n"
">>> dt.date(2003, 12, 29).isocalendar()\n"
"datetime.IsoCalendarDate(year=2004, week=1, weekday=1)\n"
">>> dt.date(2004, 1, 4).isocalendar()\n"
"datetime.IsoCalendarDate(year=2004, week=1, weekday=7)"
msgstr ""
">>> import datetime as dt\n"
">>> dt.date(2003, 12, 29).isocalendar()\n"
"datetime.IsoCalendarDate(year=2004, week=1, weekday=1)\n"
">>> dt.date(2004, 1, 4).isocalendar()\n"
"datetime.IsoCalendarDate(year=2004, week=1, weekday=7)"

#: ../../library/datetime.rst:803
msgid "Result changed from a tuple to a :term:`named tuple`."
msgstr ""

#: ../../library/datetime.rst:809
msgid ""
"Return a string representing the date in ISO 8601 format, ``YYYY-MM-DD``::"
msgstr "回傳一以 ISO 8601 格式 ``YYYY-MM-DD`` 表示的日期字串： ::"

#: ../../library/datetime.rst:811
msgid ""
">>> import datetime as dt\n"
">>> dt.date(2002, 12, 4).isoformat()\n"
"'2002-12-04'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.date(2002, 12, 4).isoformat()\n"
"'2002-12-04'"

#: ../../library/datetime.rst:818
msgid "For a date ``d``, ``str(d)`` is equivalent to ``d.isoformat()``."
msgstr ""

#: ../../library/datetime.rst:823
msgid "Return a string representing the date::"
msgstr ""

#: ../../library/datetime.rst:825
msgid ""
">>> import datetime as dt\n"
">>> dt.date(2002, 12, 4).ctime()\n"
"'Wed Dec  4 00:00:00 2002'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.date(2002, 12, 4).ctime()\n"
"'Wed Dec  4 00:00:00 2002'"

#: ../../library/datetime.rst:829 ../../library/datetime.rst:1670
msgid "``d.ctime()`` is equivalent to::"
msgstr "``d.ctime()`` 等價於： ::"

#: ../../library/datetime.rst:831 ../../library/datetime.rst:1672
msgid "time.ctime(time.mktime(d.timetuple()))"
msgstr "time.ctime(time.mktime(d.timetuple()))"

#: ../../library/datetime.rst:833
msgid ""
"on platforms where the native C :c:func:`ctime` function (which :func:`time."
"ctime` invokes, but which :meth:`date.ctime` does not invoke) conforms to "
"the C standard."
msgstr ""

#: ../../library/datetime.rst:840
msgid ""
"Return a string representing the date, controlled by an explicit format "
"string. Format codes referring to hours, minutes or seconds will see 0 "
"values. See also :ref:`strftime-strptime-behavior` and :meth:`date."
"isoformat`."
msgstr ""

#: ../../library/datetime.rst:847
msgid ""
"Same as :meth:`.date.strftime`. This makes it possible to specify a format "
"string for a :class:`.date` object in :ref:`formatted string literals <f-"
"strings>` and when using :meth:`str.format`. See also :ref:`strftime-"
"strptime-behavior` and :meth:`date.isoformat`."
msgstr ""

#: ../../library/datetime.rst:854
msgid "Examples of usage: :class:`!date`"
msgstr "用法範例：:class:`!date`"

#: ../../library/datetime.rst:856
msgid "Example of counting days to an event::"
msgstr "計算一個事件的天數的範例： ::"

#: ../../library/datetime.rst:858
msgid ""
">>> import time\n"
">>> import datetime as dt\n"
">>> today = dt.date.today()\n"
">>> today\n"
"datetime.date(2007, 12, 5)\n"
">>> today == dt.date.fromtimestamp(time.time())\n"
"True\n"
">>> my_birthday = dt.date(today.year, 6, 24)\n"
">>> if my_birthday < today:\n"
"...     my_birthday = my_birthday.replace(year=today.year + 1)\n"
"...\n"
">>> my_birthday\n"
"datetime.date(2008, 6, 24)\n"
">>> time_to_birthday = abs(my_birthday - today)\n"
">>> time_to_birthday.days\n"
"202"
msgstr ""
">>> import time\n"
">>> import datetime as dt\n"
">>> today = dt.date.today()\n"
">>> today\n"
"datetime.date(2007, 12, 5)\n"
">>> today == dt.date.fromtimestamp(time.time())\n"
"True\n"
">>> my_birthday = dt.date(today.year, 6, 24)\n"
">>> if my_birthday < today:\n"
"...     my_birthday = my_birthday.replace(year=today.year + 1)\n"
"...\n"
">>> my_birthday\n"
"datetime.date(2008, 6, 24)\n"
">>> time_to_birthday = abs(my_birthday - today)\n"
">>> time_to_birthday.days\n"
"202"

#: ../../library/datetime.rst:875
msgid "More examples of working with :class:`date`:"
msgstr "更多 :class:`date` 的用法範例："

#: ../../library/datetime.rst:877
msgid ""
">>> import datetime as dt\n"
">>> d = dt.date.fromordinal(730920) # 730920th day after 1. 1. 0001\n"
">>> d\n"
"datetime.date(2002, 3, 11)\n"
"\n"
">>> # Methods related to formatting string output\n"
">>> d.isoformat()\n"
"'2002-03-11'\n"
">>> d.strftime(\"%d/%m/%y\")\n"
"'11/03/02'\n"
">>> d.strftime(\"%A %d. %B %Y\")\n"
"'Monday 11. March 2002'\n"
">>> d.ctime()\n"
"'Mon Mar 11 00:00:00 2002'\n"
">>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, \"day\", \"month\")\n"
"'The day is 11, the month is March.'\n"
"\n"
">>> # Methods for extracting 'components' under different calendars\n"
">>> t = d.timetuple()\n"
">>> for i in t:\n"
"...     print(i)\n"
"2002                # year\n"
"3                   # month\n"
"11                  # day\n"
"0\n"
"0\n"
"0\n"
"0                   # weekday (0 = Monday)\n"
"70                  # 70th day in the year\n"
"-1\n"
">>> ic = d.isocalendar()\n"
">>> for i in ic:\n"
"...     print(i)\n"
"2002                # ISO year\n"
"11                  # ISO week number\n"
"1                   # ISO day number ( 1 = Monday )\n"
"\n"
">>> # A date object is immutable; all operations produce a new object\n"
">>> d.replace(year=2005)\n"
"datetime.date(2005, 3, 11)"
msgstr ""

#: ../../library/datetime.rst:924
msgid ":class:`!datetime` objects"
msgstr ":class:`!datetime` 物件"

#: ../../library/datetime.rst:926
msgid ""
"A :class:`.datetime` object is a single object containing all the "
"information from a :class:`date` object and a :class:`.time` object."
msgstr ""

#: ../../library/datetime.rst:929
msgid ""
"Like a :class:`date` object, :class:`.datetime` assumes the current "
"Gregorian calendar extended in both directions; like a :class:`.time` "
"object, :class:`!datetime` assumes there are exactly 3600\\*24 seconds in "
"every day."
msgstr ""

#: ../../library/datetime.rst:933
msgid "Constructor:"
msgstr "建構函式："

#: ../../library/datetime.rst:937
msgid ""
"The *year*, *month* and *day* arguments are required. *tzinfo* may be "
"``None``, or an instance of a :class:`tzinfo` subclass. The remaining "
"arguments must be integers in the following ranges:"
msgstr ""

#: ../../library/datetime.rst:941
msgid "``MINYEAR <= year <= MAXYEAR``,"
msgstr "``MINYEAR <= year <= MAXYEAR``,"

#: ../../library/datetime.rst:942
msgid "``1 <= month <= 12``,"
msgstr "``1 <= month <= 12``,"

#: ../../library/datetime.rst:943
msgid "``1 <= day <= number of days in the given month and year``,"
msgstr ""

#: ../../library/datetime.rst:944 ../../library/datetime.rst:1835
msgid "``0 <= hour < 24``,"
msgstr "``0 <= hour < 24``,"

#: ../../library/datetime.rst:945 ../../library/datetime.rst:1836
msgid "``0 <= minute < 60``,"
msgstr "``0 <= minute < 60``,"

#: ../../library/datetime.rst:946 ../../library/datetime.rst:1837
msgid "``0 <= second < 60``,"
msgstr "``0 <= second < 60``,"

#: ../../library/datetime.rst:947 ../../library/datetime.rst:1838
msgid "``0 <= microsecond < 1000000``,"
msgstr "``0 <= microsecond < 1000000``,"

#: ../../library/datetime.rst:948 ../../library/datetime.rst:1839
msgid "``fold in [0, 1]``."
msgstr "``fold in [0, 1]``。"

#: ../../library/datetime.rst:952 ../../library/datetime.rst:1402
#: ../../library/datetime.rst:2003
msgid "Added the *fold* parameter."
msgstr "新增 *fold* 參數。"

#: ../../library/datetime.rst:960
msgid "Return the current local date and time, with :attr:`.tzinfo` ``None``."
msgstr "回傳目前的本地日期與時間，且 :attr:`.tzinfo` 為 ``None``。"

#: ../../library/datetime.rst:962
msgid "Equivalent to::"
msgstr "等價於： ::"

#: ../../library/datetime.rst:964
msgid "datetime.fromtimestamp(time.time())"
msgstr "datetime.fromtimestamp(time.time())"

#: ../../library/datetime.rst:966
msgid "See also :meth:`now`, :meth:`fromtimestamp`."
msgstr "也請見 :meth:`now`、:meth:`fromtimestamp`。"

#: ../../library/datetime.rst:968
msgid ""
"This method is functionally equivalent to :meth:`now`, but without a ``tz`` "
"parameter."
msgstr ""

#: ../../library/datetime.rst:974
msgid "Return the current local date and time."
msgstr ""

#: ../../library/datetime.rst:976
msgid ""
"If optional argument *tz* is ``None`` or not specified, this is like :meth:"
"`today`, but, if possible, supplies more precision than can be gotten from "
"going through a :func:`time.time` timestamp (for example, this may be "
"possible on platforms supplying the C :c:func:`gettimeofday` function)."
msgstr ""
"如果選用的引數 *tz* 為 ``None`` 或未指定，則會像是 :meth:`today`，但盡可能提"
"供比透過 :func:`time.time` 取得的時間戳記更多位數的資訊（例如，這在有提供 C :"
"c:func:`gettimeofday` 函式的平台上可能可行）。"

#: ../../library/datetime.rst:982
msgid ""
"If *tz* is not ``None``, it must be an instance of a :class:`tzinfo` "
"subclass, and the current date and time are converted to *tz*’s time zone."
msgstr ""

#: ../../library/datetime.rst:985
msgid "This function is preferred over :meth:`today` and :meth:`utcnow`."
msgstr ""

#: ../../library/datetime.rst:989
msgid ""
"Subsequent calls to :meth:`!datetime.now` may return the same instant "
"depending on the precision of the underlying clock."
msgstr ""

#: ../../library/datetime.rst:995
msgid "Return the current UTC date and time, with :attr:`.tzinfo` ``None``."
msgstr ""

#: ../../library/datetime.rst:997
msgid ""
"This is like :meth:`now`, but returns the current UTC date and time, as a "
"naive :class:`.datetime` object. An aware current UTC datetime can be "
"obtained by calling ``datetime.now(timezone.utc)``. See also :meth:`now`."
msgstr ""

#: ../../library/datetime.rst:1003
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC. As such, the recommended way to create an object representing the "
"current time in UTC is by calling ``datetime.now(timezone.utc)``."
msgstr ""

#: ../../library/datetime.rst:1010
msgid "Use :meth:`datetime.now` with :const:`UTC` instead."
msgstr ""

#: ../../library/datetime.rst:1015
msgid ""
"Return the local date and time corresponding to the POSIX timestamp, such as "
"is returned by :func:`time.time`. If optional argument *tz* is ``None`` or "
"not specified, the timestamp is converted to the platform's local date and "
"time, and the returned :class:`.datetime` object is naive."
msgstr ""

#: ../../library/datetime.rst:1020
msgid ""
"If *tz* is not ``None``, it must be an instance of a :class:`tzinfo` "
"subclass, and the timestamp is converted to *tz*’s time zone."
msgstr ""

#: ../../library/datetime.rst:1023
msgid ""
":meth:`fromtimestamp` may raise :exc:`OverflowError`, if the timestamp is "
"out of the range of values supported by the platform C :c:func:`localtime` "
"or :c:func:`gmtime` functions, and :exc:`OSError` on :c:func:`localtime` or :"
"c:func:`gmtime` failure. It's common for this to be restricted to years in "
"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`, and then it's possible to have two timestamps differing by "
"a second that yield identical :class:`.datetime` objects. This method is "
"preferred over :meth:`utcfromtimestamp`."
msgstr ""

#: ../../library/datetime.rst:1034
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` "
"or :c:func:`gmtime` functions. Raise :exc:`OSError` instead of :exc:"
"`ValueError` on :c:func:`localtime` or :c:func:`gmtime` failure."
msgstr ""

#: ../../library/datetime.rst:1041
msgid ":meth:`fromtimestamp` may return instances with :attr:`.fold` set to 1."
msgstr ""

#: ../../library/datetime.rst:1046
msgid ""
"Return the UTC :class:`.datetime` corresponding to the POSIX timestamp, "
"with :attr:`.tzinfo` ``None``.  (The resulting object is naive.)"
msgstr ""

#: ../../library/datetime.rst:1049
msgid ""
"This may raise :exc:`OverflowError`, if the timestamp is out of the range of "
"values supported by the platform C :c:func:`gmtime` function, and :exc:"
"`OSError` on :c:func:`gmtime` failure. It's common for this to be restricted "
"to years in 1970 through 2038."
msgstr ""

#: ../../library/datetime.rst:1054
msgid "To get an aware :class:`.datetime` object, call :meth:`fromtimestamp`::"
msgstr ""

#: ../../library/datetime.rst:1056
msgid "datetime.fromtimestamp(timestamp, timezone.utc)"
msgstr "datetime.fromtimestamp(timestamp, timezone.utc)"

#: ../../library/datetime.rst:1058
msgid ""
"On the POSIX compliant platforms, it is equivalent to the following "
"expression::"
msgstr ""

#: ../../library/datetime.rst:1061
msgid ""
"datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)"
msgstr ""
"datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)"

#: ../../library/datetime.rst:1063
msgid ""
"except the latter formula always supports the full years range: between :"
"const:`MINYEAR` and :const:`MAXYEAR` inclusive."
msgstr ""

#: ../../library/datetime.rst:1068
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC. As such, the recommended way to create an object representing a "
"specific timestamp in UTC is by calling ``datetime.fromtimestamp(timestamp, "
"tz=timezone.utc)``."
msgstr ""

#: ../../library/datetime.rst:1074
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:`gmtime` "
"function. Raise :exc:`OSError` instead of :exc:`ValueError` on :c:func:"
"`gmtime` failure."
msgstr ""

#: ../../library/datetime.rst:1080
msgid "Accepts any real number as *timestamp*, not only integer or float."
msgstr ""

#: ../../library/datetime.rst:1085
msgid "Use :meth:`datetime.fromtimestamp` with :const:`UTC` instead."
msgstr ""

#: ../../library/datetime.rst:1090
msgid ""
"Return the :class:`.datetime` corresponding to the proleptic Gregorian "
"ordinal, where January 1 of year 1 has ordinal 1. :exc:`ValueError` is "
"raised unless ``1 <= ordinal <= datetime.max.toordinal()``. The hour, "
"minute, second and microsecond of the result are all 0, and :attr:`.tzinfo` "
"is ``None``."
msgstr ""

#: ../../library/datetime.rst:1098
msgid ""
"Return a new :class:`.datetime` object whose date components are equal to "
"the given :class:`date` object's, and whose time components are equal to the "
"given :class:`.time` object's. If the *tzinfo* argument is provided, its "
"value is used to set the :attr:`.tzinfo` attribute of the result, otherwise "
"the :attr:`~.time.tzinfo` attribute of the *time* argument is used.  If the "
"*date* argument is a :class:`!datetime` object, its time components and :"
"attr:`.tzinfo` attributes are ignored."
msgstr ""

#: ../../library/datetime.rst:1106
msgid ""
"For any :class:`.datetime` object ``d``, ``d == datetime.combine(d.date(), d."
"time(), d.tzinfo)``."
msgstr ""

#: ../../library/datetime.rst:1109
msgid "Added the *tzinfo* argument."
msgstr "新增 *tzinfo* 引數。"

#: ../../library/datetime.rst:1115
msgid ""
"Return a :class:`.datetime` corresponding to a *date_string* in any valid "
"ISO 8601 format, with the following exceptions:"
msgstr ""

#: ../../library/datetime.rst:1118 ../../library/datetime.rst:1937
msgid "Time zone offsets may have fractional seconds."
msgstr ""

#: ../../library/datetime.rst:1119
msgid "The ``T`` separator may be replaced by any single unicode character."
msgstr ""

#: ../../library/datetime.rst:1120 ../../library/datetime.rst:1942
msgid "Fractional hours and minutes are not supported."
msgstr ""

#: ../../library/datetime.rst:1129
msgid ""
">>> import datetime as dt\n"
">>> dt.datetime.fromisoformat('2011-11-04')\n"
"datetime.datetime(2011, 11, 4, 0, 0)\n"
">>> dt.datetime.fromisoformat('20111104')\n"
"datetime.datetime(2011, 11, 4, 0, 0)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23Z')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)\n"
">>> dt.datetime.fromisoformat('20111104T000523')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23)\n"
">>> dt.datetime.fromisoformat('2011-W01-2T00:05:23.283')\n"
"datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)\n"
">>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)\n"
">>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone."
"utc)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23+04:00')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23,\n"
"    tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))"
msgstr ""
">>> import datetime as dt\n"
">>> dt.datetime.fromisoformat('2011-11-04')\n"
"datetime.datetime(2011, 11, 4, 0, 0)\n"
">>> dt.datetime.fromisoformat('20111104')\n"
"datetime.datetime(2011, 11, 4, 0, 0)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23Z')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)\n"
">>> dt.datetime.fromisoformat('20111104T000523')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23)\n"
">>> dt.datetime.fromisoformat('2011-W01-2T00:05:23.283')\n"
"datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)\n"
">>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)\n"
">>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone."
"utc)\n"
">>> dt.datetime.fromisoformat('2011-11-04T00:05:23+04:00')\n"
"datetime.datetime(2011, 11, 4, 0, 5, 23,\n"
"    tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))"

#: ../../library/datetime.rst:1151
msgid ""
"Previously, this method only supported formats that could be emitted by :"
"meth:`date.isoformat` or :meth:`datetime.isoformat`."
msgstr ""

#: ../../library/datetime.rst:1158
msgid ""
"Return a :class:`.datetime` corresponding to the ISO calendar date specified "
"by *year*, *week* and *day*. The non-date components of the datetime are "
"populated with their normal default values. This is the inverse of the "
"function :meth:`datetime.isocalendar`."
msgstr ""

#: ../../library/datetime.rst:1168
msgid ""
"Return a :class:`.datetime` corresponding to *date_string*, parsed according "
"to *format*."
msgstr ""

#: ../../library/datetime.rst:1171
msgid ""
"If *format* does not contain microseconds or time zone information, this is "
"equivalent to::"
msgstr ""

#: ../../library/datetime.rst:1173 ../../library/datetime.rst:2730
msgid "datetime(*(time.strptime(date_string, format)[0:6]))"
msgstr "datetime(*(time.strptime(date_string, format)[0:6]))"

#: ../../library/datetime.rst:1175
msgid ""
":exc:`ValueError` is raised if the date_string and format can't be parsed "
"by :func:`time.strptime` or if it returns a value which isn't a time tuple.  "
"See also :ref:`strftime-strptime-behavior` and :meth:`datetime."
"fromisoformat`."
msgstr ""

#: ../../library/datetime.rst:1182
msgid ""
"If *format* specifies a day of month without a year a :exc:"
"`DeprecationWarning` is now emitted.  This is to avoid a quadrennial leap "
"year bug in code seeking to parse only a month and day as the default year "
"used in absence of one in the format is not a leap year. Such *format* "
"values may raise an error as of Python 3.15.  The workaround is to always "
"include a year in your *format*.  If parsing *date_string* values that do "
"not have a year, explicitly add a year that is a leap year before parsing:"
msgstr ""

#: ../../library/datetime.rst:1191
msgid ""
">>> import datetime as dt\n"
">>> date_string = \"02/29\"\n"
">>> when = dt.datetime.strptime(f\"{date_string};1984\", \"%m/%d;%Y\")  # "
"Avoids leap year bug.\n"
">>> when.strftime(\"%B %d\")\n"
"'February 29'"
msgstr ""
">>> import datetime as dt\n"
">>> date_string = \"02/29\"\n"
">>> when = dt.datetime.strptime(f\"{date_string};1984\", \"%m/%d;%Y\")  # "
"避免閏年錯誤。\n"
">>> when.strftime(\"%B %d\")\n"
"'February 29'"

#: ../../library/datetime.rst:1204
msgid ""
"The earliest representable :class:`.datetime`, ``datetime(MINYEAR, 1, 1, "
"tzinfo=None)``."
msgstr ""

#: ../../library/datetime.rst:1210
msgid ""
"The latest representable :class:`.datetime`, ``datetime(MAXYEAR, 12, 31, 23, "
"59, 59, 999999, tzinfo=None)``."
msgstr ""

#: ../../library/datetime.rst:1216
msgid ""
"The smallest possible difference between non-equal :class:`.datetime` "
"objects, ``timedelta(microseconds=1)``."
msgstr ""

#: ../../library/datetime.rst:1239 ../../library/datetime.rst:1869
msgid "In ``range(24)``."
msgstr ""

#: ../../library/datetime.rst:1244 ../../library/datetime.rst:1249
#: ../../library/datetime.rst:1874 ../../library/datetime.rst:1879
msgid "In ``range(60)``."
msgstr ""

#: ../../library/datetime.rst:1254 ../../library/datetime.rst:1884
msgid "In ``range(1000000)``."
msgstr ""

#: ../../library/datetime.rst:1259
msgid ""
"The object passed as the *tzinfo* argument to the :class:`.datetime` "
"constructor, or ``None`` if none was passed."
msgstr ""

#: ../../library/datetime.rst:1265 ../../library/datetime.rst:1895
msgid ""
"In ``[0, 1]``. Used to disambiguate wall times during a repeated interval. "
"(A repeated interval occurs when clocks are rolled back at the end of "
"daylight saving time or when the UTC offset for the current zone is "
"decreased for political reasons.) The values 0 and 1 represent, "
"respectively, the earlier and later of the two moments with the same wall "
"time representation."
msgstr ""

#: ../../library/datetime.rst:1279
msgid "``datetime2 = datetime1 + timedelta``"
msgstr "``datetime2 = datetime1 + timedelta``"

#: ../../library/datetime.rst:1279 ../../library/datetime.rst:2538
#: ../../library/datetime.rst:2543 ../../library/datetime.rst:2555
#: ../../library/datetime.rst:2560 ../../library/datetime.rst:2620
#: ../../library/datetime.rst:2625 ../../library/datetime.rst:2629
msgid "\\(1)"
msgstr "\\(1)"

#: ../../library/datetime.rst:1281
msgid "``datetime2 = datetime1 - timedelta``"
msgstr "``datetime2 = datetime1 - timedelta``"

#: ../../library/datetime.rst:1281 ../../library/datetime.rst:2571
msgid "\\(2)"
msgstr "\\(2)"

#: ../../library/datetime.rst:1283
msgid "``timedelta = datetime1 - datetime2``"
msgstr "``timedelta = datetime1 - datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 == datetime2``"
msgstr "``datetime1 == datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 != datetime2``"
msgstr "``datetime1 != datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 < datetime2``"
msgstr "``datetime1 < datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 > datetime2``"
msgstr "``datetime1 > datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 <= datetime2``"
msgstr "``datetime1 <= datetime2``"

#: ../../library/datetime.rst:0
msgid "``datetime1 >= datetime2``"
msgstr "``datetime1 >= datetime2``"

#: ../../library/datetime.rst:1295
msgid ""
"``datetime2`` is a duration of ``timedelta`` removed from ``datetime1``, "
"moving forward in time if ``timedelta.days > 0``, or backward if ``timedelta."
"days < 0``. The result has the same :attr:`~.datetime.tzinfo` attribute as "
"the input datetime, and ``datetime2 - datetime1 == timedelta`` after. :exc:"
"`OverflowError` is raised if ``datetime2.year`` would be smaller than :const:"
"`MINYEAR` or larger than :const:`MAXYEAR`. Note that no time zone "
"adjustments are done even if the input is an aware object."
msgstr ""

#: ../../library/datetime.rst:1304
msgid ""
"Computes the ``datetime2`` such that ``datetime2 + timedelta == datetime1``. "
"As for addition, the result has the same :attr:`~.datetime.tzinfo` attribute "
"as the input datetime, and no time zone adjustments are done even if the "
"input is aware."
msgstr ""

#: ../../library/datetime.rst:1309
msgid ""
"Subtraction of a :class:`.datetime` from a :class:`!datetime` is defined "
"only if both operands are naive, or if both are aware. If one is aware and "
"the other is naive, :exc:`TypeError` is raised."
msgstr ""

#: ../../library/datetime.rst:1313
msgid ""
"If both are naive, or both are aware and have the same :attr:`~.datetime."
"tzinfo` attribute, the :attr:`~.datetime.tzinfo` attributes are ignored, and "
"the result is a :class:`timedelta` object ``t`` such that ``datetime2 + t == "
"datetime1``. No time zone adjustments are done in this case."
msgstr ""

#: ../../library/datetime.rst:1318
msgid ""
"If both are aware and have different :attr:`~.datetime.tzinfo` attributes, "
"``a-b`` acts as if ``a`` and ``b`` were first converted to naive UTC "
"datetimes. The result is ``(a.replace(tzinfo=None) - a.utcoffset()) - (b."
"replace(tzinfo=None) - b.utcoffset())`` except that the implementation never "
"overflows."
msgstr ""

#: ../../library/datetime.rst:1324
msgid ""
":class:`.datetime` objects are equal if they represent the same date and "
"time, taking into account the time zone."
msgstr ""

#: ../../library/datetime.rst:1327
msgid "Naive and aware :class:`.datetime` objects are never equal."
msgstr ""

#: ../../library/datetime.rst:1329
msgid ""
"If both comparands are aware, and have the same :attr:`!tzinfo` attribute, "
"the :attr:`!tzinfo` and :attr:`~.datetime.fold` attributes are ignored and "
"the base datetimes are compared. If both comparands are aware and have "
"different :attr:`~.datetime.tzinfo` attributes, the comparison acts as "
"comparands were first converted to UTC datetimes except that the "
"implementation never overflows. :class:`.datetime` instances in a repeated "
"interval are never equal to :class:`!datetime` instances in other time zone."
msgstr ""

#: ../../library/datetime.rst:1339
msgid ""
"*datetime1* is considered less than *datetime2* when *datetime1* precedes "
"*datetime2* in time, taking into account the time zone."
msgstr ""

#: ../../library/datetime.rst:1342
msgid ""
"Order comparison between naive and aware :class:`.datetime` objects raises :"
"exc:`TypeError`."
msgstr ""

#: ../../library/datetime.rst:1345
msgid ""
"If both comparands are aware, and have the same :attr:`!tzinfo` attribute, "
"the :attr:`!tzinfo` and :attr:`~.datetime.fold` attributes are ignored and "
"the base datetimes are compared. If both comparands are aware and have "
"different :attr:`~.datetime.tzinfo` attributes, the comparison acts as "
"comparands were first converted to UTC datetimes except that the "
"implementation never overflows."
msgstr ""

#: ../../library/datetime.rst:1352
msgid ""
"Equality comparisons between aware and naive :class:`.datetime` instances "
"don't raise :exc:`TypeError`."
msgstr ""

#: ../../library/datetime.rst:1369
msgid "Return :class:`date` object with same year, month and day."
msgstr ""

#: ../../library/datetime.rst:1374
msgid ""
"Return :class:`.time` object with same hour, minute, second, microsecond and "
"fold. :attr:`.tzinfo` is ``None``. See also method :meth:`timetz`."
msgstr ""

#: ../../library/datetime.rst:1377 ../../library/datetime.rst:1386
msgid "The fold value is copied to the returned :class:`.time` object."
msgstr ""

#: ../../library/datetime.rst:1383
msgid ""
"Return :class:`.time` object with same hour, minute, second, microsecond, "
"fold, and tzinfo attributes. See also method :meth:`time`."
msgstr ""

#: ../../library/datetime.rst:1394
msgid ""
"Return a new :class:`datetime` object with the same attributes, but with "
"specified parameters updated. Note that ``tzinfo=None`` can be specified to "
"create a naive datetime from an aware datetime with no conversion of date "
"and time data."
msgstr ""

#: ../../library/datetime.rst:1399
msgid ""
":class:`.datetime` objects are also supported by generic function :func:"
"`copy.replace`."
msgstr ""

#: ../../library/datetime.rst:1408
msgid ""
"Return a :class:`.datetime` object with new :attr:`.tzinfo` attribute *tz*, "
"adjusting the date and time data so the result is the same UTC time as "
"*self*, but in *tz*'s local time."
msgstr ""

#: ../../library/datetime.rst:1412
msgid ""
"If provided, *tz* must be an instance of a :class:`tzinfo` subclass, and "
"its :meth:`utcoffset` and :meth:`dst` methods must not return ``None``. If "
"*self* is naive, it is presumed to represent time in the system time zone."
msgstr ""

#: ../../library/datetime.rst:1416
msgid ""
"If called without arguments (or with ``tz=None``) the system local time zone "
"is assumed for the target time zone. The ``.tzinfo`` attribute of the "
"converted datetime instance will be set to an instance of :class:`timezone` "
"with the zone name and offset obtained from the OS."
msgstr ""

#: ../../library/datetime.rst:1421
msgid ""
"If ``self.tzinfo`` is *tz*, ``self.astimezone(tz)`` is equal to *self*:  no "
"adjustment of date or time data is performed. Else the result is local time "
"in the time zone *tz*, representing the same UTC time as *self*:  after "
"``astz = dt.astimezone(tz)``, ``astz - astz.utcoffset()`` will have the same "
"date and time data as ``dt - dt.utcoffset()``."
msgstr ""

#: ../../library/datetime.rst:1427
msgid ""
"If you merely want to attach a :class:`timezone` object *tz* to a datetime "
"*dt* without adjustment of date and time data, use ``dt."
"replace(tzinfo=tz)``. If you merely want to remove the :class:`!timezone` "
"object from an aware datetime *dt* without conversion of date and time data, "
"use ``dt.replace(tzinfo=None)``."
msgstr ""

#: ../../library/datetime.rst:1432
msgid ""
"Note that the default :meth:`tzinfo.fromutc` method can be overridden in a :"
"class:`tzinfo` subclass to affect the result returned by :meth:`astimezone`. "
"Ignoring error cases, :meth:`astimezone` acts like::"
msgstr ""

#: ../../library/datetime.rst:1436
msgid ""
"def astimezone(self, tz):\n"
"    if self.tzinfo is tz:\n"
"        return self\n"
"    # Convert self to UTC, and attach the new timezone object.\n"
"    utc = (self - self.utcoffset()).replace(tzinfo=tz)\n"
"    # Convert from UTC to tz's local time.\n"
"    return tz.fromutc(utc)"
msgstr ""

#: ../../library/datetime.rst:1444
msgid "*tz* now can be omitted."
msgstr ""

#: ../../library/datetime.rst:1447
msgid ""
"The :meth:`astimezone` method can now be called on naive instances that are "
"presumed to represent system local time."
msgstr ""

#: ../../library/datetime.rst:1454
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"utcoffset(self)``, and raises an exception if the latter doesn't return "
"``None`` or a :class:`timedelta` object with magnitude less than one day."
msgstr ""

#: ../../library/datetime.rst:1458 ../../library/datetime.rst:2076
#: ../../library/datetime.rst:2185 ../../library/datetime.rst:2438
#: ../../library/datetime.rst:2450 ../../library/datetime.rst:2803
msgid "The UTC offset is not restricted to a whole number of minutes."
msgstr ""

#: ../../library/datetime.rst:1464
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"dst(self)``, and raises an exception if the latter doesn't return ``None`` "
"or a :class:`timedelta` object with magnitude less than one day."
msgstr ""

#: ../../library/datetime.rst:1468 ../../library/datetime.rst:2086
#: ../../library/datetime.rst:2243
msgid "The DST offset is not restricted to a whole number of minutes."
msgstr ""

#: ../../library/datetime.rst:1474
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"tzname(self)``, raises an exception if the latter doesn't return ``None`` or "
"a string object,"
msgstr ""

#: ../../library/datetime.rst:1485
msgid ""
"time.struct_time((d.year, d.month, d.day,\n"
"                  d.hour, d.minute, d.second,\n"
"                  d.weekday(), yday, dst))"
msgstr ""
"time.struct_time((d.year, d.month, d.day,\n"
"                  d.hour, d.minute, d.second,\n"
"                  d.weekday(), yday, dst))"

#: ../../library/datetime.rst:1489
msgid ""
"where ``yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`` is the "
"day number within the current year starting with 1 for January 1st. The :"
"attr:`~time.struct_time.tm_isdst` flag of the result is set according to "
"the :meth:`dst` method: :attr:`.tzinfo` is ``None`` or :meth:`dst` returns "
"``None``, :attr:`!tm_isdst` is set to ``-1``; else if :meth:`dst` returns a "
"non-zero value, :attr:`!tm_isdst` is set to 1; else :attr:`!tm_isdst` is set "
"to 0."
msgstr ""

#: ../../library/datetime.rst:1500
msgid ""
"If :class:`.datetime` instance ``d`` is naive, this is the same as ``d."
"timetuple()`` except that :attr:`~.time.struct_time.tm_isdst` is forced to 0 "
"regardless of what ``d.dst()`` returns. DST is never in effect for a UTC "
"time."
msgstr ""

#: ../../library/datetime.rst:1504
msgid ""
"If ``d`` is aware, ``d`` is normalized to UTC time, by subtracting ``d."
"utcoffset()``, and a :class:`time.struct_time` for the normalized time is "
"returned. :attr:`!tm_isdst` is forced to 0. Note that an :exc:"
"`OverflowError` may be raised if ``d.year`` was ``MINYEAR`` or ``MAXYEAR`` "
"and UTC adjustment spills over a year boundary."
msgstr ""

#: ../../library/datetime.rst:1513
msgid ""
"Because naive ``datetime`` objects are treated by many ``datetime`` methods "
"as local times, it is preferred to use aware datetimes to represent times in "
"UTC; as a result, using :meth:`datetime.utctimetuple` may give misleading "
"results. If you have a naive ``datetime`` representing UTC, use ``datetime."
"replace(tzinfo=timezone.utc)`` to make it aware, at which point you can use :"
"meth:`.datetime.timetuple`."
msgstr ""

#: ../../library/datetime.rst:1523
msgid ""
"Return the proleptic Gregorian ordinal of the date. The same as ``self."
"date().toordinal()``."
msgstr ""

#: ../../library/datetime.rst:1529
msgid ""
"Return POSIX timestamp corresponding to the :class:`.datetime` instance. The "
"return value is a :class:`float` similar to that returned by :func:`time."
"time`."
msgstr ""

#: ../../library/datetime.rst:1533
msgid ""
"Naive :class:`.datetime` instances are assumed to represent local time and "
"this method relies on the platform C :c:func:`mktime` function to perform "
"the conversion. Since :class:`!datetime` supports wider range of values "
"than :c:func:`mktime` on many platforms, this method may raise :exc:"
"`OverflowError` or :exc:`OSError` for times far in the past or far in the "
"future."
msgstr ""

#: ../../library/datetime.rst:1540
msgid ""
"For aware :class:`.datetime` instances, the return value is computed as::"
msgstr ""

#: ../../library/datetime.rst:1543
msgid "(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()"
msgstr "(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()"

#: ../../library/datetime.rst:1547
msgid ""
"There is no method to obtain the POSIX timestamp directly from a naive :"
"class:`.datetime` instance representing UTC time. If your application uses "
"this convention and your system time zone is not set to UTC, you can obtain "
"the POSIX timestamp by supplying ``tzinfo=timezone.utc``::"
msgstr ""

#: ../../library/datetime.rst:1553
msgid "timestamp = dt.replace(tzinfo=timezone.utc).timestamp()"
msgstr "timestamp = dt.replace(tzinfo=timezone.utc).timestamp()"

#: ../../library/datetime.rst:1555
msgid "or by calculating the timestamp directly::"
msgstr ""

#: ../../library/datetime.rst:1557
msgid "timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)"
msgstr "timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)"

#: ../../library/datetime.rst:1561
msgid ""
"The :meth:`timestamp` method uses the :attr:`.fold` attribute to "
"disambiguate the times during a repeated interval."
msgstr ""

#: ../../library/datetime.rst:1568
msgid ""
"Return the day of the week as an integer, where Monday is 0 and Sunday is 6. "
"The same as ``self.date().weekday()``. See also :meth:`isoweekday`."
msgstr ""

#: ../../library/datetime.rst:1574
msgid ""
"Return the day of the week as an integer, where Monday is 1 and Sunday is 7. "
"The same as ``self.date().isoweekday()``. See also :meth:`weekday`, :meth:"
"`isocalendar`."
msgstr ""

#: ../../library/datetime.rst:1581
msgid ""
"Return a :term:`named tuple` with three components: ``year``, ``week`` and "
"``weekday``. The same as ``self.date().isocalendar()``."
msgstr ""

#: ../../library/datetime.rst:1587
msgid "Return a string representing the date and time in ISO 8601 format:"
msgstr ""

#: ../../library/datetime.rst:1589
msgid "``YYYY-MM-DDTHH:MM:SS.ffffff``, if :attr:`microsecond` is not 0"
msgstr "``YYYY-MM-DDTHH:MM:SS.ffffff``，如果 :attr:`microsecond` 不是 0"

#: ../../library/datetime.rst:1590
msgid "``YYYY-MM-DDTHH:MM:SS``, if :attr:`microsecond` is 0"
msgstr "``YYYY-MM-DDTHH:MM:SS``，如果 :attr:`microsecond` 是 0"

#: ../../library/datetime.rst:1592
msgid ""
"If :meth:`utcoffset` does not return ``None``, a string is appended, giving "
"the UTC offset:"
msgstr ""
"如果 :meth:`utcoffset` 没有回傳 ``None``，則會附加一个字串，給出 UTC 偏移："

#: ../../library/datetime.rst:1595
msgid ""
"``YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, if :attr:`microsecond` "
"is not 0"
msgstr ""
"``YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``，如果 :attr:`microsecond` "
"不是 0"

#: ../../library/datetime.rst:1597
msgid ""
"``YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]``,  if :attr:`microsecond` is 0"
msgstr ""
"``YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]``，如果 :attr:`microsecond` 是 0"

#: ../../library/datetime.rst:1601
msgid ""
">>> import datetime as dt\n"
">>> dt.datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()\n"
"'2019-05-18T15:17:08.132263'\n"
">>> dt.datetime(2019, 5, 18, 15, 17, tzinfo=dt.timezone.utc).isoformat()\n"
"'2019-05-18T15:17:00+00:00'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()\n"
"'2019-05-18T15:17:08.132263'\n"
">>> dt.datetime(2019, 5, 18, 15, 17, tzinfo=dt.timezone.utc).isoformat()\n"
"'2019-05-18T15:17:00+00:00'"

#: ../../library/datetime.rst:1607
msgid ""
"The optional argument *sep* (default ``'T'``) is a one-character separator, "
"placed between the date and time portions of the result. For example::"
msgstr ""

#: ../../library/datetime.rst:1610
msgid ""
">>> import datetime as dt\n"
">>> class TZ(dt.tzinfo):\n"
"...     \"\"\"A time zone with an arbitrary, constant -06:39 offset.\"\"\"\n"
"...     def utcoffset(self, when):\n"
"...         return dt.timedelta(hours=-6, minutes=-39)\n"
"...\n"
">>> dt.datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')\n"
"'2002-12-25 00:00:00-06:39'\n"
">>> dt.datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()\n"
"'2009-11-27T00:00:00.000100-06:39'"
msgstr ""
">>> import datetime as dt\n"
">>> class TZ(dt.tzinfo):\n"
"...     \"\"\"A time zone with an arbitrary, constant -06:39 offset.\"\"\"\n"
"...     def utcoffset(self, when):\n"
"...         return dt.timedelta(hours=-6, minutes=-39)\n"
"...\n"
">>> dt.datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')\n"
"'2002-12-25 00:00:00-06:39'\n"
">>> dt.datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()\n"
"'2009-11-27T00:00:00.000100-06:39'"

#: ../../library/datetime.rst:1621 ../../library/datetime.rst:2016
msgid ""
"The optional argument *timespec* specifies the number of additional "
"components of the time to include (the default is ``'auto'``). It can be one "
"of the following:"
msgstr ""

#: ../../library/datetime.rst:1625 ../../library/datetime.rst:2020
msgid ""
"``'auto'``: Same as ``'seconds'`` if :attr:`microsecond` is 0, same as "
"``'microseconds'`` otherwise."
msgstr ""

#: ../../library/datetime.rst:1627 ../../library/datetime.rst:2022
msgid "``'hours'``: Include the :attr:`hour` in the two-digit ``HH`` format."
msgstr ""

#: ../../library/datetime.rst:1628 ../../library/datetime.rst:2023
msgid ""
"``'minutes'``: Include :attr:`hour` and :attr:`minute` in ``HH:MM`` format."
msgstr ""

#: ../../library/datetime.rst:1629 ../../library/datetime.rst:2024
msgid ""
"``'seconds'``: Include :attr:`hour`, :attr:`minute`, and :attr:`second` in "
"``HH:MM:SS`` format."
msgstr ""

#: ../../library/datetime.rst:1631 ../../library/datetime.rst:2026
msgid ""
"``'milliseconds'``: Include full time, but truncate fractional second part "
"to milliseconds. ``HH:MM:SS.sss`` format."
msgstr ""

#: ../../library/datetime.rst:1633 ../../library/datetime.rst:2028
msgid "``'microseconds'``: Include full time in ``HH:MM:SS.ffffff`` format."
msgstr ""

#: ../../library/datetime.rst:1637 ../../library/datetime.rst:2032
msgid "Excluded time components are truncated, not rounded."
msgstr ""

#: ../../library/datetime.rst:1639
msgid ":exc:`ValueError` will be raised on an invalid *timespec* argument::"
msgstr ""

#: ../../library/datetime.rst:1642
msgid ""
">>> import datetime as dt\n"
">>> dt.datetime.now().isoformat(timespec='minutes')\n"
"'2002-12-25T00:00'\n"
">>> my_datetime = dt.datetime(2015, 1, 1, 12, 30, 59, 0)\n"
">>> my_datetime.isoformat(timespec='microseconds')\n"
"'2015-01-01T12:30:59.000000'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.datetime.now().isoformat(timespec='minutes')\n"
"'2002-12-25T00:00'\n"
">>> my_datetime = dt.datetime(2015, 1, 1, 12, 30, 59, 0)\n"
">>> my_datetime.isoformat(timespec='microseconds')\n"
"'2015-01-01T12:30:59.000000'"

#: ../../library/datetime.rst:1649 ../../library/datetime.rst:2047
msgid "Added the *timespec* parameter."
msgstr "新增 *timespec* 參數。"

#: ../../library/datetime.rst:1655
msgid ""
"For a :class:`.datetime` instance ``d``, ``str(d)`` is equivalent to ``d."
"isoformat(' ')``."
msgstr ""

#: ../../library/datetime.rst:1661
msgid "Return a string representing the date and time::"
msgstr ""

#: ../../library/datetime.rst:1663
msgid ""
">>> import datetime as dt\n"
">>> dt.datetime(2002, 12, 4, 20, 30, 40).ctime()\n"
"'Wed Dec  4 20:30:40 2002'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.datetime(2002, 12, 4, 20, 30, 40).ctime()\n"
"'Wed Dec  4 20:30:40 2002'"

#: ../../library/datetime.rst:1667
msgid ""
"The output string will *not* include time zone information, regardless of "
"whether the input is aware or naive."
msgstr ""

#: ../../library/datetime.rst:1674
msgid ""
"on platforms where the native C :c:func:`ctime` function (which :func:`time."
"ctime` invokes, but which :meth:`datetime.ctime` does not invoke) conforms "
"to the C standard."
msgstr ""

#: ../../library/datetime.rst:1681
msgid ""
"Return a string representing the date and time, controlled by an explicit "
"format string. See also :ref:`strftime-strptime-behavior` and :meth:"
"`datetime.isoformat`."
msgstr ""

#: ../../library/datetime.rst:1688
msgid ""
"Same as :meth:`.datetime.strftime`. This makes it possible to specify a "
"format string for a :class:`.datetime` object in :ref:`formatted string "
"literals <f-strings>` and when using :meth:`str.format`. See also :ref:"
"`strftime-strptime-behavior` and :meth:`datetime.isoformat`."
msgstr ""

#: ../../library/datetime.rst:1695
msgid "Examples of usage: :class:`!datetime`"
msgstr "用法範例：:class:`!datetime`"

#: ../../library/datetime.rst:1697
msgid "Examples of working with :class:`.datetime` objects:"
msgstr "更多 :class:`.datetime` 的用法範例："

#: ../../library/datetime.rst:1699
msgid ""
">>> import datetime as dt\n"
"\n"
">>> # Using datetime.combine()\n"
">>> d = dt.date(2005, 7, 14)\n"
">>> t = dt.time(12, 30)\n"
">>> dt.datetime.combine(d, t)\n"
"datetime.datetime(2005, 7, 14, 12, 30)\n"
"\n"
">>> # Using datetime.now()\n"
">>> dt.datetime.now()\n"
"datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1\n"
">>> dt.datetime.now(dt.timezone.utc)\n"
"datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone."
"utc)\n"
"\n"
">>> # Using datetime.strptime()\n"
">>> my_datetime = dt.datetime.strptime(\"21/11/06 16:30\", \"%d/%m/%y %H:"
"%M\")\n"
">>> my_datetime\n"
"datetime.datetime(2006, 11, 21, 16, 30)\n"
"\n"
">>> # Using datetime.timetuple() to get tuple of all attributes\n"
">>> tt = my_datetime.timetuple()\n"
">>> for it in tt:\n"
"...     print(it)\n"
"...\n"
"2006    # year\n"
"11      # month\n"
"21      # day\n"
"16      # hour\n"
"30      # minute\n"
"0       # second\n"
"1       # weekday (0 = Monday)\n"
"325     # number of days since 1st January\n"
"-1      # dst - method tzinfo.dst() returned None\n"
"\n"
">>> # Date in ISO format\n"
">>> ic = my_datetime.isocalendar()\n"
">>> for it in ic:\n"
"...     print(it)\n"
"...\n"
"2006    # ISO year\n"
"47      # ISO week\n"
"2       # ISO weekday\n"
"\n"
">>> # Formatting a datetime\n"
">>> my_datetime.strftime(\"%A, %d. %B %Y %I:%M%p\")\n"
"'Tuesday, 21. November 2006 04:30PM'\n"
">>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'."
"format(my_datetime, \"day\", \"month\", \"time\")\n"
"'The day is 21, the month is November, the time is 04:30PM.'"
msgstr ""

#: ../../library/datetime.rst:1750
msgid ""
"The example below defines a :class:`tzinfo` subclass capturing time zone "
"information for Kabul, Afghanistan, which used +4 UTC until 1945 and then "
"+4:30 UTC thereafter::"
msgstr ""

#: ../../library/datetime.rst:1754
msgid ""
"import datetime as dt\n"
"\n"
"class KabulTz(dt.tzinfo):\n"
"    # Kabul used +4 until 1945, when they moved to +4:30\n"
"    UTC_MOVE_DATE = dt.datetime(1944, 12, 31, 20, tzinfo=dt.timezone.utc)\n"
"\n"
"    def utcoffset(self, when):\n"
"        if when.year < 1945:\n"
"            return dt.timedelta(hours=4)\n"
"        elif (1945, 1, 1, 0, 0) <= when.timetuple()[:5] < (1945, 1, 1, 0, "
"30):\n"
"            # An ambiguous (\"imaginary\") half-hour range representing\n"
"            # a 'fold' in time due to the shift from +4 to +4:30.\n"
"            # If when falls in the imaginary range, use fold to decide how\n"
"            # to resolve. See PEP 495.\n"
"            return dt.timedelta(hours=4, minutes=(30 if when.fold else 0))\n"
"        else:\n"
"            return dt.timedelta(hours=4, minutes=30)\n"
"\n"
"    def fromutc(self, when):\n"
"        # Follow same validations as in datetime.tzinfo\n"
"        if not isinstance(when, dt.datetime):\n"
"            raise TypeError(\"fromutc() requires a datetime argument\")\n"
"        if when.tzinfo is not self:\n"
"            raise ValueError(\"when.tzinfo is not self\")\n"
"\n"
"        # A custom implementation is required for fromutc as\n"
"        # the input to this function is a datetime with utc values\n"
"        # but with a tzinfo set to self.\n"
"        # See datetime.astimezone or fromtimestamp.\n"
"        if when.replace(tzinfo=dt.timezone.utc) >= self.UTC_MOVE_DATE:\n"
"            return when + dt.timedelta(hours=4, minutes=30)\n"
"        else:\n"
"            return when + dt.timedelta(hours=4)\n"
"\n"
"    def dst(self, when):\n"
"        # Kabul does not observe daylight saving time.\n"
"        return dt.timedelta(0)\n"
"\n"
"    def tzname(self, when):\n"
"        if when >= self.UTC_MOVE_DATE:\n"
"            return \"+04:30\"\n"
"        return \"+04\""
msgstr ""

#: ../../library/datetime.rst:1797
msgid "Usage of ``KabulTz`` from above::"
msgstr ""

#: ../../library/datetime.rst:1799
msgid ""
">>> tz1 = KabulTz()\n"
"\n"
">>> # Datetime before the change\n"
">>> dt1 = dt.datetime(1900, 11, 21, 16, 30, tzinfo=tz1)\n"
">>> print(dt1.utcoffset())\n"
"4:00:00\n"
"\n"
">>> # Datetime after the change\n"
">>> dt2 = dt.datetime(2006, 6, 14, 13, 0, tzinfo=tz1)\n"
">>> print(dt2.utcoffset())\n"
"4:30:00\n"
"\n"
">>> # Convert datetime to another time zone\n"
">>> dt3 = dt2.astimezone(dt.timezone.utc)\n"
">>> dt3\n"
"datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)\n"
">>> dt2\n"
"datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())\n"
">>> dt2 == dt3\n"
"True"
msgstr ""

#: ../../library/datetime.rst:1824
msgid ":class:`!time` objects"
msgstr ":class:`!time` 物件"

#: ../../library/datetime.rst:1826
msgid ""
"A :class:`.time` object represents a (local) time of day, independent of any "
"particular day, and subject to adjustment via a :class:`tzinfo` object."
msgstr ""

#: ../../library/datetime.rst:1831
msgid ""
"All arguments are optional. *tzinfo* may be ``None``, or an instance of a :"
"class:`tzinfo` subclass. The remaining arguments must be integers in the "
"following ranges:"
msgstr ""

#: ../../library/datetime.rst:1841
msgid ""
"If an argument outside those ranges is given, :exc:`ValueError` is raised. "
"All default to 0 except *tzinfo*, which defaults to ``None``."
msgstr ""

#: ../../library/datetime.rst:1850
msgid "The earliest representable :class:`.time`, ``time(0, 0, 0, 0)``."
msgstr ""

#: ../../library/datetime.rst:1855
msgid "The latest representable :class:`.time`, ``time(23, 59, 59, 999999)``."
msgstr ""

#: ../../library/datetime.rst:1860
msgid ""
"The smallest possible difference between non-equal :class:`.time` objects, "
"``timedelta(microseconds=1)``, although note that arithmetic on :class:`."
"time` objects is not supported."
msgstr ""

#: ../../library/datetime.rst:1889
msgid ""
"The object passed as the tzinfo argument to the :class:`.time` constructor, "
"or ``None`` if none was passed."
msgstr ""

#: ../../library/datetime.rst:1904
msgid ""
":class:`.time` objects support equality and order comparisons, where ``a`` "
"is considered less than ``b`` when ``a`` precedes ``b`` in time."
msgstr ""

#: ../../library/datetime.rst:1907
msgid ""
"Naive and aware :class:`!time` objects are never equal. Order comparison "
"between naive and aware :class:`!time` objects raises :exc:`TypeError`."
msgstr ""

#: ../../library/datetime.rst:1911
msgid ""
"If both comparands are aware, and have the same :attr:`~.time.tzinfo` "
"attribute, the :attr:`!tzinfo` and :attr:`!fold` attributes are ignored and "
"the base times are compared. If both comparands are aware and have "
"different :attr:`!tzinfo` attributes, the comparands are first adjusted by "
"subtracting their UTC offsets (obtained from ``self.utcoffset()``)."
msgstr ""

#: ../../library/datetime.rst:1917
msgid ""
"Equality comparisons between aware and naive :class:`.time` instances don't "
"raise :exc:`TypeError`."
msgstr ""

#: ../../library/datetime.rst:1921
msgid ""
"In Boolean contexts, a :class:`.time` object is always considered to be true."
msgstr ""

#: ../../library/datetime.rst:1923
msgid ""
"Before Python 3.5, a :class:`.time` object was considered to be false if it "
"represented midnight in UTC. This behavior was considered obscure and error-"
"prone and has been removed in Python 3.5. See :issue:`13936` for more "
"information."
msgstr ""

#: ../../library/datetime.rst:1930
msgid "Other constructors:"
msgstr "其他建構函式："

#: ../../library/datetime.rst:1934
msgid ""
"Return a :class:`.time` corresponding to a *time_string* in any valid ISO "
"8601 format, with the following exceptions:"
msgstr ""

#: ../../library/datetime.rst:1938
msgid ""
"The leading ``T``, normally required in cases where there may be ambiguity "
"between a date and a time, is not required."
msgstr ""

#: ../../library/datetime.rst:1940
msgid ""
"Fractional seconds may have any number of digits (anything beyond 6 will be "
"truncated)."
msgstr ""

#: ../../library/datetime.rst:1944
msgid "Examples:"
msgstr "範例： ::"

#: ../../library/datetime.rst:1946
msgid ""
">>> import datetime as dt\n"
">>> dt.time.fromisoformat('04:23:01')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('T04:23:01')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('T042301')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('04:23:01.000384')\n"
"datetime.time(4, 23, 1, 384)\n"
">>> dt.time.fromisoformat('04:23:01,000384')\n"
"datetime.time(4, 23, 1, 384)\n"
">>> dt.time.fromisoformat('04:23:01+04:00')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime."
"timedelta(seconds=14400)))\n"
">>> dt.time.fromisoformat('04:23:01Z')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)\n"
">>> dt.time.fromisoformat('04:23:01+00:00')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)"
msgstr ""
">>> import datetime as dt\n"
">>> dt.time.fromisoformat('04:23:01')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('T04:23:01')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('T042301')\n"
"datetime.time(4, 23, 1)\n"
">>> dt.time.fromisoformat('04:23:01.000384')\n"
"datetime.time(4, 23, 1, 384)\n"
">>> dt.time.fromisoformat('04:23:01,000384')\n"
"datetime.time(4, 23, 1, 384)\n"
">>> dt.time.fromisoformat('04:23:01+04:00')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime."
"timedelta(seconds=14400)))\n"
">>> dt.time.fromisoformat('04:23:01Z')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)\n"
">>> dt.time.fromisoformat('04:23:01+00:00')\n"
"datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)"

#: ../../library/datetime.rst:1968
msgid ""
"Previously, this method only supported formats that could be emitted by :"
"meth:`time.isoformat`."
msgstr ""

#: ../../library/datetime.rst:1975
msgid ""
"Return a :class:`.time` corresponding to *date_string*, parsed according to "
"*format*."
msgstr ""

#: ../../library/datetime.rst:1978
msgid ""
"If *format* does not contain microseconds or timezone information, this is "
"equivalent to::"
msgstr ""

#: ../../library/datetime.rst:1980
msgid "time(*(time.strptime(date_string, format)[3:6]))"
msgstr "time(*(time.strptime(date_string, format)[3:6]))"

#: ../../library/datetime.rst:1982
msgid ""
":exc:`ValueError` is raised if the *date_string* and *format* cannot be "
"parsed by :func:`time.strptime` or if it returns a value which is not a time "
"tuple.  See also :ref:`strftime-strptime-behavior` and :meth:`time."
"fromisoformat`."
msgstr ""

#: ../../library/datetime.rst:1995
msgid ""
"Return a new :class:`.time` with the same values, but with specified "
"parameters updated. Note that ``tzinfo=None`` can be specified to create a "
"naive :class:`!time` from an aware :class:`!time`, without conversion of the "
"time data."
msgstr ""

#: ../../library/datetime.rst:2000
msgid ""
":class:`.time` objects are also supported by generic function :func:`copy."
"replace`."
msgstr ""

#: ../../library/datetime.rst:2009
msgid "Return a string representing the time in ISO 8601 format, one of:"
msgstr ""

#: ../../library/datetime.rst:2011
msgid "``HH:MM:SS.ffffff``, if :attr:`microsecond` is not 0"
msgstr ""

#: ../../library/datetime.rst:2012
msgid "``HH:MM:SS``, if :attr:`microsecond` is 0"
msgstr ""

#: ../../library/datetime.rst:2013
msgid ""
"``HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]``, if :meth:`utcoffset` does not "
"return ``None``"
msgstr ""

#: ../../library/datetime.rst:2014
msgid ""
"``HH:MM:SS+HH:MM[:SS[.ffffff]]``, if :attr:`microsecond` is 0 and :meth:"
"`utcoffset` does not return ``None``"
msgstr ""

#: ../../library/datetime.rst:2034
msgid ":exc:`ValueError` will be raised on an invalid *timespec* argument."
msgstr ""

#: ../../library/datetime.rst:2038
msgid ""
">>> import datetime as dt\n"
">>> dt.time(hour=12, minute=34, second=56, microsecond=123456)."
"isoformat(timespec='minutes')\n"
"'12:34'\n"
">>> my_time = dt.time(hour=12, minute=34, second=56, microsecond=0)\n"
">>> my_time.isoformat(timespec='microseconds')\n"
"'12:34:56.000000'\n"
">>> my_time.isoformat(timespec='auto')\n"
"'12:34:56'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.time(hour=12, minute=34, second=56, microsecond=123456)."
"isoformat(timespec='minutes')\n"
"'12:34'\n"
">>> my_time = dt.time(hour=12, minute=34, second=56, microsecond=0)\n"
">>> my_time.isoformat(timespec='microseconds')\n"
"'12:34:56.000000'\n"
">>> my_time.isoformat(timespec='auto')\n"
"'12:34:56'"

#: ../../library/datetime.rst:2053
msgid "For a time ``t``, ``str(t)`` is equivalent to ``t.isoformat()``."
msgstr ""

#: ../../library/datetime.rst:2058
msgid ""
"Return a string representing the time, controlled by an explicit format "
"string.  See also :ref:`strftime-strptime-behavior` and :meth:`time."
"isoformat`."
msgstr ""

#: ../../library/datetime.rst:2064
msgid ""
"Same as :meth:`.time.strftime`. This makes it possible to specify a format "
"string for a :class:`.time` object in :ref:`formatted string literals <f-"
"strings>` and when using :meth:`str.format`. See also :ref:`strftime-"
"strptime-behavior` and :meth:`time.isoformat`."
msgstr ""

#: ../../library/datetime.rst:2072
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"utcoffset(None)``, and raises an exception if the latter doesn't return "
"``None`` or a :class:`timedelta` object with magnitude less than one day."
msgstr ""

#: ../../library/datetime.rst:2082
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"dst(None)``, and raises an exception if the latter doesn't return ``None``, "
"or a :class:`timedelta` object with magnitude less than one day."
msgstr ""

#: ../../library/datetime.rst:2092
msgid ""
"If :attr:`.tzinfo` is ``None``, returns ``None``, else returns ``self.tzinfo."
"tzname(None)``, or raises an exception if the latter doesn't return ``None`` "
"or a string object."
msgstr ""

#: ../../library/datetime.rst:2098
msgid "Examples of usage: :class:`!time`"
msgstr "用法範例：:class:`!time`"

#: ../../library/datetime.rst:2100
msgid "Examples of working with a :class:`.time` object::"
msgstr ""

#: ../../library/datetime.rst:2102
msgid ""
">>> import datetime as dt\n"
">>> class TZ1(dt.tzinfo):\n"
"...     def utcoffset(self, when):\n"
"...         return dt.timedelta(hours=1)\n"
"...     def dst(self, when):\n"
"...         return dt.timedelta(0)\n"
"...     def tzname(self, when):\n"
"...         return \"+01:00\"\n"
"...     def  __repr__(self):\n"
"...         return f\"{self.__class__.__name__}()\"\n"
"...\n"
">>> t = dt.time(12, 10, 30, tzinfo=TZ1())\n"
">>> t\n"
"datetime.time(12, 10, 30, tzinfo=TZ1())\n"
">>> t.isoformat()\n"
"'12:10:30+01:00'\n"
">>> t.dst()\n"
"datetime.timedelta(0)\n"
">>> t.tzname()\n"
"'+01:00'\n"
">>> t.strftime(\"%H:%M:%S %Z\")\n"
"'12:10:30 +01:00'\n"
">>> 'The {} is {:%H:%M}.'.format(\"time\", t)\n"
"'The time is 12:10.'"
msgstr ""
">>> import datetime as dt\n"
">>> class TZ1(dt.tzinfo):\n"
"...     def utcoffset(self, when):\n"
"...         return dt.timedelta(hours=1)\n"
"...     def dst(self, when):\n"
"...         return dt.timedelta(0)\n"
"...     def tzname(self, when):\n"
"...         return \"+01:00\"\n"
"...     def  __repr__(self):\n"
"...         return f\"{self.__class__.__name__}()\"\n"
"...\n"
">>> t = dt.time(12, 10, 30, tzinfo=TZ1())\n"
">>> t\n"
"datetime.time(12, 10, 30, tzinfo=TZ1())\n"
">>> t.isoformat()\n"
"'12:10:30+01:00'\n"
">>> t.dst()\n"
"datetime.timedelta(0)\n"
">>> t.tzname()\n"
"'+01:00'\n"
">>> t.strftime(\"%H:%M:%S %Z\")\n"
"'12:10:30 +01:00'\n"
">>> 'The {} is {:%H:%M}.'.format(\"time\", t)\n"
"'The time is 12:10.'"

#: ../../library/datetime.rst:2131
msgid ":class:`!tzinfo` objects"
msgstr ":class:`!tzinfo` 物件"

#: ../../library/datetime.rst:2135
msgid ""
"This is an :term:`abstract base class`, meaning that this class should not "
"be instantiated directly.  Define a subclass of :class:`tzinfo` to capture "
"information about a particular time zone."
msgstr ""

#: ../../library/datetime.rst:2139
msgid ""
"An instance of (a concrete subclass of) :class:`tzinfo` can be passed to the "
"constructors for :class:`.datetime` and :class:`.time` objects. The latter "
"objects view their attributes as being in local time, and the :class:`!"
"tzinfo` object supports methods revealing offset of local time from UTC, the "
"name of the time zone, and DST offset, all relative to a date or time object "
"passed to them."
msgstr ""

#: ../../library/datetime.rst:2145
msgid ""
"You need to derive a concrete subclass, and (at least) supply "
"implementations of the standard :class:`tzinfo` methods needed by the :class:"
"`.datetime` methods you use. The :mod:`!datetime` module provides :class:"
"`timezone`, a simple concrete subclass of :class:`!tzinfo` which can "
"represent time zones with fixed offset from UTC such as UTC itself or North "
"American EST and EDT."
msgstr ""

#: ../../library/datetime.rst:2152
msgid ""
"Special requirement for pickling:  A :class:`tzinfo` subclass must have an :"
"meth:`~object.__init__` method that can be called with no arguments, "
"otherwise it can be pickled but possibly not unpickled again. This is a "
"technical requirement that may be relaxed in the future."
msgstr ""

#: ../../library/datetime.rst:2158
msgid ""
"A concrete subclass of :class:`tzinfo` may need to implement the following "
"methods. Exactly which methods are needed depends on the uses made of aware :"
"mod:`!datetime` objects. If in doubt, simply implement all of them."
msgstr ""

#: ../../library/datetime.rst:2165
msgid ""
"Return offset of local time from UTC, as a :class:`timedelta` object that is "
"positive east of UTC. If local time is west of UTC, this should be negative."
msgstr ""

#: ../../library/datetime.rst:2168
msgid ""
"This represents the *total* offset from UTC; for example, if a :class:"
"`tzinfo` object represents both time zone and DST adjustments, :meth:"
"`utcoffset` should return their sum. If the UTC offset isn't known, return "
"``None``. Else the value returned must be a :class:`timedelta` object "
"strictly between ``-timedelta(hours=24)`` and ``timedelta(hours=24)`` (the "
"magnitude of the offset must be less than one day). Most implementations of :"
"meth:`utcoffset` will probably look like one of these two::"
msgstr ""

#: ../../library/datetime.rst:2176
msgid ""
"return CONSTANT                 # fixed-offset class\n"
"return CONSTANT + self.dst(dt)  # daylight-aware class"
msgstr ""

#: ../../library/datetime.rst:2179
msgid ""
"If :meth:`utcoffset` does not return ``None``, :meth:`dst` should not return "
"``None`` either."
msgstr ""

#: ../../library/datetime.rst:2182
msgid ""
"The default implementation of :meth:`utcoffset` raises :exc:"
"`NotImplementedError`."
msgstr ""

#: ../../library/datetime.rst:2191
msgid ""
"Return the daylight saving time (DST) adjustment, as a :class:`timedelta` "
"object or ``None`` if DST information isn't known."
msgstr ""

#: ../../library/datetime.rst:2195
msgid ""
"Return ``timedelta(0)`` if DST is not in effect. If DST is in effect, return "
"the offset as a :class:`timedelta` object (see :meth:`utcoffset` for "
"details). Note that DST offset, if applicable, has already been added to the "
"UTC offset returned by :meth:`utcoffset`, so there's no need to consult :"
"meth:`dst` unless you're interested in obtaining DST info separately. For "
"example, :meth:`datetime.timetuple` calls its :attr:`~.datetime.tzinfo` "
"attribute's :meth:`dst` method to determine how the :attr:`~time.struct_time."
"tm_isdst` flag should be set, and :meth:`tzinfo.fromutc` calls :meth:`dst` "
"to account for DST changes when crossing time zones."
msgstr ""

#: ../../library/datetime.rst:2205
msgid ""
"An instance *tz* of a :class:`tzinfo` subclass that models both standard and "
"daylight times must be consistent in this sense:"
msgstr ""

#: ../../library/datetime.rst:2208
msgid "``tz.utcoffset(dt) - tz.dst(dt)``"
msgstr "``tz.utcoffset(dt) - tz.dst(dt)``"

#: ../../library/datetime.rst:2210
msgid ""
"must return the same result for every :class:`.datetime` *dt* with ``dt."
"tzinfo == tz``. For sane :class:`!tzinfo` subclasses, this expression yields "
"the time zone's \"standard offset\", which should not depend on the date or "
"the time, but only on geographic location. The implementation of :meth:"
"`datetime.astimezone` relies on this, but cannot detect violations; it's the "
"programmer's responsibility to ensure it. If a :class:`!tzinfo` subclass "
"cannot guarantee this, it may be able to override the default implementation "
"of :meth:`tzinfo.fromutc` to work correctly with :meth:`~.datetime."
"astimezone` regardless."
msgstr ""

#: ../../library/datetime.rst:2219
msgid ""
"Most implementations of :meth:`dst` will probably look like one of these "
"two::"
msgstr ""

#: ../../library/datetime.rst:2221
msgid ""
"import datetime as dt\n"
"\n"
"def dst(self, when):\n"
"    # a fixed-offset class:  doesn't account for DST\n"
"    return dt.timedelta(0)"
msgstr ""

#: ../../library/datetime.rst:2227
msgid "or::"
msgstr "或是： ::"

#: ../../library/datetime.rst:2229
msgid ""
"import datetime as dt\n"
"\n"
"def dst(self, when):\n"
"    # Code to set dston and dstoff to the time zone's DST\n"
"    # transition times based on the input when.year, and expressed\n"
"    # in standard local time.\n"
"\n"
"    if dston <= when.replace(tzinfo=None) < dstoff:\n"
"        return dt.timedelta(hours=1)\n"
"    else:\n"
"        return dt.timedelta(0)"
msgstr ""

#: ../../library/datetime.rst:2241
msgid ""
"The default implementation of :meth:`dst` raises :exc:`NotImplementedError`."
msgstr ""

#: ../../library/datetime.rst:2249
msgid ""
"Return the time zone name corresponding to the :class:`.datetime` object "
"*dt*, as a string. Nothing about string names is defined by the :mod:`!"
"datetime` module, and there's no requirement that it mean anything in "
"particular. For example, ``\"GMT\"``, ``\"UTC\"``, ``\"-500\"``, "
"``\"-5:00\"``, ``\"EDT\"``, ``\"US/Eastern\"``, ``\"America/New York\"`` are "
"all valid replies. Return ``None`` if a string name isn't known. Note that "
"this is a method rather than a fixed string primarily because some :class:"
"`tzinfo` subclasses will wish to return different names depending on the "
"specific value of *dt* passed, especially if the :class:`!tzinfo` class is "
"accounting for daylight time."
msgstr ""

#: ../../library/datetime.rst:2259
msgid ""
"The default implementation of :meth:`tzname` raises :exc:"
"`NotImplementedError`."
msgstr ""

#: ../../library/datetime.rst:2262
msgid ""
"These methods are called by a :class:`.datetime` or :class:`.time` object, "
"in response to their methods of the same names. A :class:`!datetime` object "
"passes itself as the argument, and a :class:`!time` object passes ``None`` "
"as the argument. A :class:`tzinfo` subclass's methods should therefore be "
"prepared to accept a *dt* argument of ``None``, or of class :class:`!"
"datetime`."
msgstr ""

#: ../../library/datetime.rst:2268
msgid ""
"When ``None`` is passed, it's up to the class designer to decide the best "
"response. For example, returning ``None`` is appropriate if the class wishes "
"to say that time objects don't participate in the :class:`tzinfo` protocols. "
"It may be more useful for ``utcoffset(None)`` to return the standard UTC "
"offset, as there is no other convention for discovering the standard offset."
msgstr ""

#: ../../library/datetime.rst:2274
msgid ""
"When a :class:`.datetime` object is passed in response to a :class:`!"
"datetime` method, ``dt.tzinfo`` is the same object as *self*. :class:"
"`tzinfo` methods can rely on this, unless user code calls :class:`!tzinfo` "
"methods directly. The intent is that the :class:`!tzinfo` methods interpret "
"*dt* as being in local time, and not need worry about objects in other time "
"zones."
msgstr ""

#: ../../library/datetime.rst:2280
msgid ""
"There is one more :class:`tzinfo` method that a subclass may wish to "
"override:"
msgstr ""

#: ../../library/datetime.rst:2285
msgid ""
"This is called from the default :meth:`datetime.astimezone` implementation. "
"When called from that, ``dt.tzinfo`` is *self*, and *dt*'s date and time "
"data are to be viewed as expressing a UTC time. The purpose of :meth:"
"`fromutc` is to adjust the date and time data, returning an equivalent "
"datetime in *self*'s local time."
msgstr ""

#: ../../library/datetime.rst:2291
msgid ""
"Most :class:`tzinfo` subclasses should be able to inherit the default :meth:"
"`fromutc` implementation without problems. It's strong enough to handle "
"fixed-offset time zones, and time zones accounting for both standard and "
"daylight time, and the latter even if the DST transition times differ in "
"different years. An example of a time zone the default :meth:`fromutc` "
"implementation may not handle correctly in all cases is one where the "
"standard offset (from UTC) depends on the specific date and time passed, "
"which can happen for political reasons. The default implementations of :meth:"
"`~.datetime.astimezone` and :meth:`fromutc` may not produce the result you "
"want if the result is one of the hours straddling the moment the standard "
"offset changes."
msgstr ""

#: ../../library/datetime.rst:2302
msgid ""
"Skipping code for error cases, the default :meth:`fromutc` implementation "
"acts like::"
msgstr ""

#: ../../library/datetime.rst:2305
msgid ""
"import datetime as dt\n"
"\n"
"def fromutc(self, when):\n"
"    # raise ValueError error if when.tzinfo is not self\n"
"    dtoff = when.utcoffset()\n"
"    dtdst = when.dst()\n"
"    # raise ValueError if dtoff is None or dtdst is None\n"
"    delta = dtoff - dtdst  # this is self's standard offset\n"
"    if delta:\n"
"        when += delta   # convert to standard local time\n"
"        dtdst = when.dst()\n"
"        # raise ValueError if dtdst is None\n"
"    if dtdst:\n"
"        return when + dtdst\n"
"    else:\n"
"        return when"
msgstr ""

#: ../../library/datetime.rst:2322
msgid ""
"In the following :download:`tzinfo_examples.py <../includes/tzinfo_examples."
"py>` file there are some examples of :class:`tzinfo` classes:"
msgstr ""

#: ../../library/datetime.rst:2326
msgid ""
"import datetime as dt\n"
"\n"
"# A class capturing the platform's idea of local time.\n"
"# (May result in wrong values on historical times in\n"
"#  timezones where UTC offset and/or the DST rules had\n"
"#  changed in the past.)\n"
"import time\n"
"\n"
"ZERO = dt.timedelta(0)\n"
"HOUR = dt.timedelta(hours=1)\n"
"SECOND = dt.timedelta(seconds=1)\n"
"\n"
"STDOFFSET = dt.timedelta(seconds=-time.timezone)\n"
"if time.daylight:\n"
"    DSTOFFSET = dt.timedelta(seconds=-time.altzone)\n"
"else:\n"
"    DSTOFFSET = STDOFFSET\n"
"\n"
"DSTDIFF = DSTOFFSET - STDOFFSET\n"
"\n"
"\n"
"class LocalTimezone(dt.tzinfo):\n"
"\n"
"    def fromutc(self, when):\n"
"        assert when.tzinfo is self\n"
"        stamp = (when - dt.datetime(1970, 1, 1, tzinfo=self)) // SECOND\n"
"        args = time.localtime(stamp)[:6]\n"
"        dst_diff = DSTDIFF // SECOND\n"
"        # Detect fold\n"
"        fold = (args == time.localtime(stamp - dst_diff))\n"
"        return dt.datetime(*args, microsecond=when.microsecond,\n"
"                           tzinfo=self, fold=fold)\n"
"\n"
"    def utcoffset(self, when):\n"
"        if self._isdst(when):\n"
"            return DSTOFFSET\n"
"        else:\n"
"            return STDOFFSET\n"
"\n"
"    def dst(self, when):\n"
"        if self._isdst(when):\n"
"            return DSTDIFF\n"
"        else:\n"
"            return ZERO\n"
"\n"
"    def tzname(self, when):\n"
"        return time.tzname[self._isdst(when)]\n"
"\n"
"    def _isdst(self, when):\n"
"        tt = (when.year, when.month, when.day,\n"
"              when.hour, when.minute, when.second,\n"
"              when.weekday(), 0, 0)\n"
"        stamp = time.mktime(tt)\n"
"        tt = time.localtime(stamp)\n"
"        return tt.tm_isdst > 0\n"
"\n"
"\n"
"Local = LocalTimezone()\n"
"\n"
"\n"
"# A complete implementation of current DST rules for major US time zones.\n"
"\n"
"def first_sunday_on_or_after(when):\n"
"    days_to_go = 6 - when.weekday()\n"
"    if days_to_go:\n"
"        when += dt.timedelta(days_to_go)\n"
"    return when\n"
"\n"
"\n"
"# US DST Rules\n"
"#\n"
"# This is a simplified (i.e., wrong for a few cases) set of rules for US\n"
"# DST start and end times. For a complete and up-to-date set of DST rules\n"
"# and timezone definitions, visit the Olson Database (or try pytz):\n"
"# http://www.twinsun.com/tz/tz-link.htm\n"
"# https://sourceforge.net/projects/pytz/ (might not be up-to-date)\n"
"#\n"
"# In the US, since 2007, DST starts at 2am (standard time) on the second\n"
"# Sunday in March, which is the first Sunday on or after Mar 8.\n"
"DSTSTART_2007 = dt.datetime(1, 3, 8, 2)\n"
"# and ends at 2am (DST time) on the first Sunday of Nov.\n"
"DSTEND_2007 = dt.datetime(1, 11, 1, 2)\n"
"# From 1987 to 2006, DST used to start at 2am (standard time) on the first\n"
"# Sunday in April and to end at 2am (DST time) on the last\n"
"# Sunday of October, which is the first Sunday on or after Oct 25.\n"
"DSTSTART_1987_2006 = dt.datetime(1, 4, 1, 2)\n"
"DSTEND_1987_2006 = dt.datetime(1, 10, 25, 2)\n"
"# From 1967 to 1986, DST used to start at 2am (standard time) on the last\n"
"# Sunday in April (the one on or after April 24) and to end at 2am (DST "
"time)\n"
"# on the last Sunday of October, which is the first Sunday\n"
"# on or after Oct 25.\n"
"DSTSTART_1967_1986 = dt.datetime(1, 4, 24, 2)\n"
"DSTEND_1967_1986 = DSTEND_1987_2006\n"
"\n"
"\n"
"def us_dst_range(year):\n"
"    # Find start and end times for US DST. For years before 1967, return\n"
"    # start = end for no DST.\n"
"    if 2006 < year:\n"
"        dststart, dstend = DSTSTART_2007, DSTEND_2007\n"
"    elif 1986 < year < 2007:\n"
"        dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006\n"
"    elif 1966 < year < 1987:\n"
"        dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986\n"
"    else:\n"
"        return (dt.datetime(year, 1, 1), ) * 2\n"
"\n"
"    start = first_sunday_on_or_after(dststart.replace(year=year))\n"
"    end = first_sunday_on_or_after(dstend.replace(year=year))\n"
"    return start, end\n"
"\n"
"\n"
"class USTimeZone(dt.tzinfo):\n"
"\n"
"    def __init__(self, hours, reprname, stdname, dstname):\n"
"        self.stdoffset = dt.timedelta(hours=hours)\n"
"        self.reprname = reprname\n"
"        self.stdname = stdname\n"
"        self.dstname = dstname\n"
"\n"
"    def __repr__(self):\n"
"        return self.reprname\n"
"\n"
"    def tzname(self, when):\n"
"        if self.dst(when):\n"
"            return self.dstname\n"
"        else:\n"
"            return self.stdname\n"
"\n"
"    def utcoffset(self, when):\n"
"        return self.stdoffset + self.dst(when)\n"
"\n"
"    def dst(self, when):\n"
"        if when is None or when.tzinfo is None:\n"
"            # An exception may be sensible here, in one or both cases.\n"
"            # It depends on how you want to treat them.  The default\n"
"            # fromutc() implementation (called by the default astimezone()\n"
"            # implementation) passes a datetime with when.tzinfo is self.\n"
"            return ZERO\n"
"        assert when.tzinfo is self\n"
"        start, end = us_dst_range(when.year)\n"
"        # Can't compare naive to aware objects, so strip the timezone from\n"
"        # when first.\n"
"        when = when.replace(tzinfo=None)\n"
"        if start + HOUR <= when < end - HOUR:\n"
"            # DST is in effect.\n"
"            return HOUR\n"
"        if end - HOUR <= when < end:\n"
"            # Fold (an ambiguous hour): use when.fold to disambiguate.\n"
"            return ZERO if when.fold else HOUR\n"
"        if start <= when < start + HOUR:\n"
"            # Gap (a non-existent hour): reverse the fold rule.\n"
"            return HOUR if when.fold else ZERO\n"
"        # DST is off.\n"
"        return ZERO\n"
"\n"
"    def fromutc(self, when):\n"
"        assert when.tzinfo is self\n"
"        start, end = us_dst_range(when.year)\n"
"        start = start.replace(tzinfo=self)\n"
"        end = end.replace(tzinfo=self)\n"
"        std_time = when + self.stdoffset\n"
"        dst_time = std_time + HOUR\n"
"        if end <= dst_time < end + HOUR:\n"
"            # Repeated hour\n"
"            return std_time.replace(fold=1)\n"
"        if std_time < start or dst_time >= end:\n"
"            # Standard time\n"
"            return std_time\n"
"        if start <= std_time < end - HOUR:\n"
"            # Daylight saving time\n"
"            return dst_time\n"
"\n"
"\n"
"Eastern  = USTimeZone(-5, \"Eastern\",  \"EST\", \"EDT\")\n"
"Central  = USTimeZone(-6, \"Central\",  \"CST\", \"CDT\")\n"
"Mountain = USTimeZone(-7, \"Mountain\", \"MST\", \"MDT\")\n"
"Pacific  = USTimeZone(-8, \"Pacific\",  \"PST\", \"PDT\")\n"
msgstr ""

#: ../../library/datetime.rst:2328
msgid ""
"Note that there are unavoidable subtleties twice per year in a :class:"
"`tzinfo` subclass accounting for both standard and daylight time, at the DST "
"transition points. For concreteness, consider US Eastern (UTC -0500), where "
"EDT begins the minute after 1:59 (EST) on the second Sunday in March, and "
"ends the minute after 1:59 (EDT) on the first Sunday in November::"
msgstr ""

#: ../../library/datetime.rst:2334
msgid ""
"  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM\n"
"  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM\n"
"  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM\n"
"\n"
"start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM\n"
"\n"
"  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM"
msgstr ""
"  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM\n"
"  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM\n"
"  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM\n"
"\n"
"start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM\n"
"\n"
"  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM"

#: ../../library/datetime.rst:2342
msgid ""
"When DST starts (the \"start\" line), the local wall clock leaps from 1:59 "
"to 3:00. A wall time of the form 2:MM doesn't really make sense on that day, "
"so ``astimezone(Eastern)`` won't deliver a result with ``hour == 2`` on the "
"day DST begins. For example, at the Spring forward transition of 2016, we "
"get::"
msgstr ""

#: ../../library/datetime.rst:2347
msgid ""
">>> import datetime as dt\n"
">>> from tzinfo_examples import HOUR, Eastern\n"
">>> u0 = dt.datetime(2016, 3, 13, 5, tzinfo=dt.timezone.utc)\n"
">>> for i in range(4):\n"
"...     u = u0 + i*HOUR\n"
"...     t = u.astimezone(Eastern)\n"
"...     print(u.time(), 'UTC =', t.time(), t.tzname())\n"
"...\n"
"05:00:00 UTC = 00:00:00 EST\n"
"06:00:00 UTC = 01:00:00 EST\n"
"07:00:00 UTC = 03:00:00 EDT\n"
"08:00:00 UTC = 04:00:00 EDT"
msgstr ""
">>> import datetime as dt\n"
">>> from tzinfo_examples import HOUR, Eastern\n"
">>> u0 = dt.datetime(2016, 3, 13, 5, tzinfo=dt.timezone.utc)\n"
">>> for i in range(4):\n"
"...     u = u0 + i*HOUR\n"
"...     t = u.astimezone(Eastern)\n"
"...     print(u.time(), 'UTC =', t.time(), t.tzname())\n"
"...\n"
"05:00:00 UTC = 00:00:00 EST\n"
"06:00:00 UTC = 01:00:00 EST\n"
"07:00:00 UTC = 03:00:00 EDT\n"
"08:00:00 UTC = 04:00:00 EDT"

#: ../../library/datetime.rst:2361
msgid ""
"When DST ends (the \"end\" line), there's a potentially worse problem: "
"there's an hour that can't be spelled unambiguously in local wall time: the "
"last hour of daylight time. In Eastern, that's times of the form 5:MM UTC on "
"the day daylight time ends. The local wall clock leaps from 1:59 (daylight "
"time) back to 1:00 (standard time) again. Local times of the form 1:MM are "
"ambiguous. :meth:`~.datetime.astimezone` mimics the local clock's behavior "
"by mapping two adjacent UTC hours into the same local hour then. In the "
"Eastern example, UTC times of the form 5:MM and 6:MM both map to 1:MM when "
"converted to Eastern, but earlier times have the :attr:`~.datetime.fold` "
"attribute set to 0 and the later times have it set to 1. For example, at the "
"Fall back transition of 2016, we get::"
msgstr ""

#: ../../library/datetime.rst:2372
msgid ""
">>> import datetime as dt\n"
">>> from tzinfo_examples import HOUR, Eastern\n"
">>> u0 = dt.datetime(2016, 11, 6, 4, tzinfo=dt.timezone.utc)\n"
">>> for i in range(4):\n"
"...     u = u0 + i*HOUR\n"
"...     t = u.astimezone(Eastern)\n"
"...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)\n"
"...\n"
"04:00:00 UTC = 00:00:00 EDT 0\n"
"05:00:00 UTC = 01:00:00 EDT 0\n"
"06:00:00 UTC = 01:00:00 EST 1\n"
"07:00:00 UTC = 02:00:00 EST 0"
msgstr ""
">>> import datetime as dt\n"
">>> from tzinfo_examples import HOUR, Eastern\n"
">>> u0 = dt.datetime(2016, 11, 6, 4, tzinfo=dt.timezone.utc)\n"
">>> for i in range(4):\n"
"...     u = u0 + i*HOUR\n"
"...     t = u.astimezone(Eastern)\n"
"...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)\n"
"...\n"
"04:00:00 UTC = 00:00:00 EDT 0\n"
"05:00:00 UTC = 01:00:00 EDT 0\n"
"06:00:00 UTC = 01:00:00 EST 1\n"
"07:00:00 UTC = 02:00:00 EST 0"

#: ../../library/datetime.rst:2385
msgid ""
"Note that the :class:`.datetime` instances that differ only by the value of "
"the :attr:`~.datetime.fold` attribute are considered equal in comparisons."
msgstr ""

#: ../../library/datetime.rst:2388
msgid ""
"Applications that can't bear wall-time ambiguities should explicitly check "
"the value of the :attr:`~.datetime.fold` attribute or avoid using hybrid :"
"class:`tzinfo` subclasses; there are no ambiguities when using :class:"
"`timezone`, or any other fixed-offset :class:`!tzinfo` subclass (such as a "
"class representing only EST (fixed offset -5 hours), or only EDT (fixed "
"offset -4 hours))."
msgstr ""

#: ../../library/datetime.rst:2396
msgid ":mod:`zoneinfo`"
msgstr ":mod:`zoneinfo`"

#: ../../library/datetime.rst:2397
msgid ""
"The :mod:`!datetime` module has a basic :class:`timezone` class (for "
"handling arbitrary fixed offsets from UTC) and its :attr:`timezone.utc` "
"attribute (a UTC :class:`!timezone` instance)."
msgstr ""

#: ../../library/datetime.rst:2401
msgid ""
"``zoneinfo`` brings the *IANA time zone database* (also known as the Olson "
"database) to Python, and its usage is recommended."
msgstr ""

#: ../../library/datetime.rst:2404
msgid "`IANA time zone database <https://www.iana.org/time-zones>`_"
msgstr "`IANA 時區資料庫 <https://www.iana.org/time-zones>`_"

#: ../../library/datetime.rst:2405
msgid ""
"The Time Zone Database (often called tz, tzdata or zoneinfo) contains code "
"and data that represent the history of local time for many representative "
"locations around the globe. It is updated periodically to reflect changes "
"made by political bodies to time zone boundaries, UTC offsets, and daylight-"
"saving rules."
msgstr ""

#: ../../library/datetime.rst:2415
msgid ":class:`!timezone` objects"
msgstr ":class:`!timezone` 物件"

#: ../../library/datetime.rst:2417
msgid ""
"The :class:`timezone` class is a subclass of :class:`tzinfo`, each instance "
"of which represents a time zone defined by a fixed offset from UTC."
msgstr ""

#: ../../library/datetime.rst:2421
msgid ""
"Objects of this class cannot be used to represent time zone information in "
"the locations where different offsets are used in different days of the year "
"or where historical changes have been made to civil time."
msgstr ""

#: ../../library/datetime.rst:2428
msgid ""
"The *offset* argument must be specified as a :class:`timedelta` object "
"representing the difference between the local time and UTC. It must be "
"strictly between ``-timedelta(hours=24)`` and ``timedelta(hours=24)``, "
"otherwise :exc:`ValueError` is raised."
msgstr ""

#: ../../library/datetime.rst:2433
msgid ""
"The *name* argument is optional. If specified it must be a string that will "
"be used as the value returned by the :meth:`datetime.tzname` method."
msgstr ""

#: ../../library/datetime.rst:2444 ../../library/datetime.rst:2456
msgid ""
"Return the fixed value specified when the :class:`timezone` instance is "
"constructed."
msgstr ""

#: ../../library/datetime.rst:2447
msgid ""
"The *dt* argument is ignored. The return value is a :class:`timedelta` "
"instance equal to the difference between the local time and UTC."
msgstr ""

#: ../../library/datetime.rst:2459
msgid ""
"If *name* is not provided in the constructor, the name returned by "
"``tzname(dt)`` is generated from the value of the ``offset`` as follows. If "
"*offset* is ``timedelta(0)``, the name is \"UTC\", otherwise it is a string "
"in the format ``UTC±HH:MM``, where ± is the sign of ``offset``, HH and MM "
"are two digits of ``offset.hours`` and ``offset.minutes`` respectively."
msgstr ""

#: ../../library/datetime.rst:2465
msgid ""
"Name generated from ``offset=timedelta(0)`` is now plain ``'UTC'``, not "
"``'UTC+00:00'``."
msgstr ""

#: ../../library/datetime.rst:2472
msgid "Always returns ``None``."
msgstr "總是回傳 ``None``。"

#: ../../library/datetime.rst:2477
msgid ""
"Return ``dt + offset``. The *dt* argument must be an aware :class:`."
"datetime` instance, with ``tzinfo`` set to ``self``."
msgstr ""

#: ../../library/datetime.rst:2485
msgid "The UTC time zone, ``timezone(timedelta(0))``."
msgstr "UTC 時區，``timezone(timedelta(0))``。"

#: ../../library/datetime.rst:2494
msgid ":meth:`!strftime` and :meth:`!strptime` behavior"
msgstr ":meth:`!strftime` 與 :meth:`!strptime` 的行為"

#: ../../library/datetime.rst:2496
msgid ""
":class:`date`, :class:`.datetime`, and :class:`.time` objects all support a "
"``strftime(format)`` method, to create a string representing the time under "
"the control of an explicit format string."
msgstr ""

#: ../../library/datetime.rst:2500
msgid ""
"Conversely, the :meth:`date.strptime`, :meth:`datetime.strptime` and :meth:"
"`time.strptime` class methods create an object from a string representing "
"the time and a corresponding format string."
msgstr ""

#: ../../library/datetime.rst:2504
msgid ""
"The table below provides a high-level comparison of :meth:`~.datetime."
"strftime` versus :meth:`~.datetime.strptime`:"
msgstr ""

#: ../../library/datetime.rst:2508
msgid "``strftime``"
msgstr "``strftime``"

#: ../../library/datetime.rst:2508
msgid "``strptime``"
msgstr "``strptime``"

#: ../../library/datetime.rst:2510
msgid "Usage"
msgstr "用法"

#: ../../library/datetime.rst:2510
msgid "Convert object to a string according to a given format"
msgstr ""

#: ../../library/datetime.rst:2510
msgid "Parse a string into an object given a corresponding format"
msgstr ""

#: ../../library/datetime.rst:2512
msgid "Type of method"
msgstr ""

#: ../../library/datetime.rst:2512
msgid "Instance method"
msgstr "實例方法"

#: ../../library/datetime.rst:2512
msgid "Class method"
msgstr "類別方法"

#: ../../library/datetime.rst:2514
msgid "Signature"
msgstr ""

#: ../../library/datetime.rst:2514
msgid "``strftime(format)``"
msgstr "``strftime(format)``"

#: ../../library/datetime.rst:2514
msgid "``strptime(date_string, format)``"
msgstr "``strptime(date_string, format)``"

#: ../../library/datetime.rst:2521
msgid ":meth:`!strftime` and :meth:`!strptime` format codes"
msgstr ":meth:`!strftime` 與 :meth:`!strptime` 格式碼"

#: ../../library/datetime.rst:2523
msgid ""
"These methods accept format codes that can be used to parse and format "
"dates::"
msgstr ""

#: ../../library/datetime.rst:2525
msgid ""
">>> import datetime as dt\n"
">>> dt.datetime.strptime('31/01/22 23:59:59.999999',\n"
"...                      '%d/%m/%y %H:%M:%S.%f')\n"
"datetime.datetime(2022, 1, 31, 23, 59, 59, 999999)\n"
">>> _.strftime('%a %d %b %Y, %I:%M%p')\n"
"'Mon 31 Jan 2022, 11:59PM'"
msgstr ""
">>> import datetime as dt\n"
">>> dt.datetime.strptime('31/01/22 23:59:59.999999',\n"
"...                      '%d/%m/%y %H:%M:%S.%f')\n"
"datetime.datetime(2022, 1, 31, 23, 59, 59, 999999)\n"
">>> _.strftime('%a %d %b %Y, %I:%M%p')\n"
"'Mon 31 Jan 2022, 11:59PM'"

#: ../../library/datetime.rst:2532
msgid ""
"The following is a list of all the format codes that the 1989 C standard "
"requires, and these work on all platforms with a standard C implementation."
msgstr ""

#: ../../library/datetime.rst:2536 ../../library/datetime.rst:2639
msgid "Directive"
msgstr ""

#: ../../library/datetime.rst:2536 ../../library/datetime.rst:2639
msgid "Meaning"
msgstr "含義"

#: ../../library/datetime.rst:2536 ../../library/datetime.rst:2639
msgid "Example"
msgstr "範例"

#: ../../library/datetime.rst:2536 ../../library/datetime.rst:2639
msgid "Notes"
msgstr "註解"

#: ../../library/datetime.rst:2538
msgid "``%a``"
msgstr "``%a``"

#: ../../library/datetime.rst:2538
msgid "Weekday as locale's abbreviated name."
msgstr ""

#: ../../library/datetime.rst:0
msgid "Sun, Mon, ..., Sat (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "So, Mo, ..., Sa (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2543
msgid "``%A``"
msgstr "``%A``"

#: ../../library/datetime.rst:2543
msgid "Weekday as locale's full name."
msgstr ""

#: ../../library/datetime.rst:0
msgid "Sunday, Monday, ..., Saturday (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "Sonntag, Montag, ..., Samstag (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2548
msgid "``%w``"
msgstr "``%w``"

#: ../../library/datetime.rst:2548
msgid "Weekday as a decimal number, where 0 is Sunday and 6 is Saturday."
msgstr ""

#: ../../library/datetime.rst:2548
msgid "0, 1, ..., 6"
msgstr "0, 1, ..., 6"

#: ../../library/datetime.rst:2552
msgid "``%d``"
msgstr "``%d``"

#: ../../library/datetime.rst:2552
msgid "Day of the month as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2552
msgid "01, 02, ..., 31"
msgstr "01, 02, ..., 31"

#: ../../library/datetime.rst:2552 ../../library/datetime.rst:2565
#: ../../library/datetime.rst:2568 ../../library/datetime.rst:2574
#: ../../library/datetime.rst:2577 ../../library/datetime.rst:2583
#: ../../library/datetime.rst:2601
msgid "\\(9)"
msgstr "\\(9)"

#: ../../library/datetime.rst:2555
msgid "``%b``"
msgstr "``%b``"

#: ../../library/datetime.rst:2555
msgid "Month as locale's abbreviated name."
msgstr ""

#: ../../library/datetime.rst:0
msgid "Jan, Feb, ..., Dec (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "Jan, Feb, ..., Dez (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2560
msgid "``%B``"
msgstr "``%B``"

#: ../../library/datetime.rst:2560
msgid "Month as locale's full name."
msgstr ""

#: ../../library/datetime.rst:0
msgid "January, February, ..., December (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "Januar, Februar, ..., Dezember (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2565
msgid "``%m``"
msgstr "``%m``"

#: ../../library/datetime.rst:2565
msgid "Month as a zero-padded decimal number."
msgstr "以零填充的並以十進位數字表示的月份。"

#: ../../library/datetime.rst:2565 ../../library/datetime.rst:2577
msgid "01, 02, ..., 12"
msgstr "01, 02, ..., 12"

#: ../../library/datetime.rst:2568
msgid "``%y``"
msgstr "``%y``"

#: ../../library/datetime.rst:2568
msgid "Year without century as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2568
msgid "00, 01, ..., 99"
msgstr "00, 01, ..., 99"

#: ../../library/datetime.rst:2571
msgid "``%Y``"
msgstr "``%Y``"

#: ../../library/datetime.rst:2571
msgid "Year with century as a decimal number."
msgstr ""

#: ../../library/datetime.rst:2571 ../../library/datetime.rst:2641
msgid "0001, 0002, ..., 2013, 2014, ..., 9998, 9999"
msgstr "0001, 0002, ..., 2013, 2014, ..., 9998, 9999"

#: ../../library/datetime.rst:2574
msgid "``%H``"
msgstr "``%H``"

#: ../../library/datetime.rst:2574
msgid "Hour (24-hour clock) as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2574
msgid "00, 01, ..., 23"
msgstr "00, 01, ..., 23"

#: ../../library/datetime.rst:2577
msgid "``%I``"
msgstr "``%I``"

#: ../../library/datetime.rst:2577
msgid "Hour (12-hour clock) as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2580
msgid "``%p``"
msgstr "``%p``"

#: ../../library/datetime.rst:2580
msgid "Locale's equivalent of either AM or PM."
msgstr ""

#: ../../library/datetime.rst:0
msgid "AM, PM (en_US);"
msgstr "AM, PM (en_US);"

#: ../../library/datetime.rst:0
msgid "am, pm (de_DE)"
msgstr "am, pm (de_DE)"

#: ../../library/datetime.rst:2580
msgid "\\(1), \\(3)"
msgstr "\\(1), \\(3)"

#: ../../library/datetime.rst:2583
msgid "``%M``"
msgstr "``%M``"

#: ../../library/datetime.rst:2583
msgid "Minute as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2583 ../../library/datetime.rst:2586
msgid "00, 01, ..., 59"
msgstr "00, 01, ..., 59"

#: ../../library/datetime.rst:2586
msgid "``%S``"
msgstr "``%S``"

#: ../../library/datetime.rst:2586
msgid "Second as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2586
msgid "\\(4), \\(9)"
msgstr "\\(4), \\(9)"

#: ../../library/datetime.rst:2589
msgid "``%f``"
msgstr "``%f``"

#: ../../library/datetime.rst:2589
msgid "Microsecond as a decimal number, zero-padded to 6 digits."
msgstr ""

#: ../../library/datetime.rst:2589
msgid "000000, 000001, ..., 999999"
msgstr "000000, 000001, ..., 999999"

#: ../../library/datetime.rst:2589
msgid "\\(5)"
msgstr "\\(5)"

#: ../../library/datetime.rst:2593 ../../library/datetime.rst:2791
msgid "``%z``"
msgstr "``%z``"

#: ../../library/datetime.rst:2593
msgid ""
"UTC offset in the form ``±HHMM[SS[.ffffff]]`` (empty string if the object is "
"naive)."
msgstr ""

#: ../../library/datetime.rst:2593
msgid "(empty), +0000, -0400, +1030, +063415, -030712.345216"
msgstr ""

#: ../../library/datetime.rst:2593 ../../library/datetime.rst:2598
#: ../../library/datetime.rst:2655
msgid "\\(6)"
msgstr "\\(6)"

#: ../../library/datetime.rst:2598 ../../library/datetime.rst:2817
msgid "``%Z``"
msgstr "``%Z``"

#: ../../library/datetime.rst:2598
msgid "Time zone name (empty string if the object is naive)."
msgstr ""

#: ../../library/datetime.rst:2598
msgid "(empty), UTC, GMT"
msgstr ""

#: ../../library/datetime.rst:2601
msgid "``%j``"
msgstr "``%j``"

#: ../../library/datetime.rst:2601
msgid "Day of the year as a zero-padded decimal number."
msgstr ""

#: ../../library/datetime.rst:2601
msgid "001, 002, ..., 366"
msgstr "001, 002, ..., 366"

#: ../../library/datetime.rst:2604
msgid "``%U``"
msgstr "``%U``"

#: ../../library/datetime.rst:2604
msgid ""
"Week number of the year (Sunday as the first day of the week) as a zero-"
"padded decimal number. All days in a new year preceding the first Sunday are "
"considered to be in week 0."
msgstr ""

#: ../../library/datetime.rst:2604 ../../library/datetime.rst:2612
msgid "00, 01, ..., 53"
msgstr "00, 01, ..., 53"

#: ../../library/datetime.rst:2604 ../../library/datetime.rst:2612
msgid "\\(7), \\(9)"
msgstr "\\(7), \\(9)"

#: ../../library/datetime.rst:2612
msgid "``%W``"
msgstr "``%W``"

#: ../../library/datetime.rst:2612
msgid ""
"Week number of the year (Monday as the first day of the week) as a zero-"
"padded decimal number. All days in a new year preceding the first Monday are "
"considered to be in week 0."
msgstr ""

#: ../../library/datetime.rst:2620
msgid "``%c``"
msgstr "``%c``"

#: ../../library/datetime.rst:2620
msgid "Locale's appropriate date and time representation."
msgstr ""

#: ../../library/datetime.rst:0
msgid "Tue Aug 16 21:30:00 1988 (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "Di 16 Aug 21:30:00 1988 (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2625
msgid "``%x``"
msgstr "``%x``"

#: ../../library/datetime.rst:2625
msgid "Locale's appropriate date representation."
msgstr ""

#: ../../library/datetime.rst:0
msgid "08/16/88 (None);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "08/16/1988 (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "16.08.1988 (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2629
msgid "``%X``"
msgstr "``%X``"

#: ../../library/datetime.rst:2629
msgid "Locale's appropriate time representation."
msgstr ""

#: ../../library/datetime.rst:0
msgid "21:30:00 (en_US);"
msgstr ""

#: ../../library/datetime.rst:0
msgid "21:30:00 (de_DE)"
msgstr ""

#: ../../library/datetime.rst:2632
msgid "``%%``"
msgstr "``%%``"

#: ../../library/datetime.rst:2632
msgid "A literal ``'%'`` character."
msgstr ""

#: ../../library/datetime.rst:2632
msgid "%"
msgstr "%"

#: ../../library/datetime.rst:2635
msgid ""
"Several additional directives not required by the C89 standard are included "
"for convenience. These parameters all correspond to ISO 8601 date values."
msgstr ""

#: ../../library/datetime.rst:2641
msgid "``%G``"
msgstr "``%G``"

#: ../../library/datetime.rst:2641
msgid ""
"ISO 8601 year with century representing the year that contains the greater "
"part of the ISO week (``%V``)."
msgstr ""

#: ../../library/datetime.rst:2641
msgid "\\(8)"
msgstr "\\(8)"

#: ../../library/datetime.rst:2646
msgid "``%u``"
msgstr "``%u``"

#: ../../library/datetime.rst:2646
msgid "ISO 8601 weekday as a decimal number where 1 is Monday."
msgstr ""

#: ../../library/datetime.rst:2646
msgid "1, 2, ..., 7"
msgstr "1, 2, ..., 7"

#: ../../library/datetime.rst:2649
msgid "``%V``"
msgstr "``%V``"

#: ../../library/datetime.rst:2649
msgid ""
"ISO 8601 week as a decimal number with Monday as the first day of the week. "
"Week 01 is the week containing Jan 4."
msgstr ""

#: ../../library/datetime.rst:2649
msgid "01, 02, ..., 53"
msgstr "01, 02, ..., 53"

#: ../../library/datetime.rst:2649
msgid "\\(8), \\(9)"
msgstr "\\(8), \\(9)"

#: ../../library/datetime.rst:2655 ../../library/datetime.rst:2813
msgid "``%:z``"
msgstr "``%:z``"

#: ../../library/datetime.rst:2655
msgid ""
"UTC offset in the form ``±HH:MM[:SS[.ffffff]]`` (empty string if the object "
"is naive)."
msgstr ""

#: ../../library/datetime.rst:2655
msgid "(empty), +00:00, -04:00, +10:30, +06:34:15, -03:07:12.345216"
msgstr ""

#: ../../library/datetime.rst:2661
msgid ""
"These may not be available on all platforms when used with the :meth:`~."
"datetime.strftime` method. The ISO 8601 year and ISO 8601 week directives "
"are not interchangeable with the year and week number directives above. "
"Calling :meth:`~.datetime.strptime` with incomplete or ambiguous ISO 8601 "
"directives will raise a :exc:`ValueError`."
msgstr ""

#: ../../library/datetime.rst:2666
msgid ""
"The full set of format codes supported varies across platforms, because "
"Python calls the platform C library's :c:func:`strftime` function, and "
"platform variations are common. To see the full set of format codes "
"supported on your platform, consult the :manpage:`strftime(3)` "
"documentation. There are also differences between platforms in handling of "
"unsupported format specifiers."
msgstr ""

#: ../../library/datetime.rst:2672
msgid "``%G``, ``%u`` and ``%V`` were added."
msgstr "新增 ``%G``、``%u`` 與 ``%V``。"

#: ../../library/datetime.rst:2675
msgid "``%:z`` was added."
msgstr "新增 ``%:z``。"

#: ../../library/datetime.rst:2680
msgid "Technical detail"
msgstr "技術細節"

#: ../../library/datetime.rst:2682
msgid ""
"Broadly speaking, ``d.strftime(fmt)`` acts like the :mod:`time` module's "
"``time.strftime(fmt, d.timetuple())`` although not all objects support a :"
"meth:`~date.timetuple` method."
msgstr ""

#: ../../library/datetime.rst:2686
msgid ""
"For the :meth:`.datetime.strptime` and :meth:`.date.strptime` class methods, "
"the default value is ``1900-01-01T00:00:00.000``: any components not "
"specified in the format string will be pulled from the default value."
msgstr ""

#: ../../library/datetime.rst:2691
msgid ""
"Format strings without separators can be ambiguous for parsing. For example, "
"with ``%Y%m%d``, the string ``2026111`` may be parsed either as "
"``2026-11-01`` or as ``2026-01-11``. Use separators to ensure the input is "
"parsed as intended."
msgstr ""

#: ../../library/datetime.rst:2697
msgid ""
"When used to parse partial dates lacking a year, :meth:`.datetime.strptime` "
"and :meth:`.date.strptime` will raise when encountering February 29 because "
"the default year of 1900 is *not* a leap year.  Always add a default leap "
"year to partial date strings before parsing."
msgstr ""

#: ../../library/datetime.rst:2717
msgid ""
">>> import datetime as dt\n"
">>> value = \"2/29\"\n"
">>> dt.datetime.strptime(value, \"%m/%d\")\n"
"Traceback (most recent call last):\n"
"...\n"
"ValueError: day 29 must be in range 1..28 for month 2 in year 1900\n"
">>> dt.datetime.strptime(f\"1904 {value}\", \"%Y %m/%d\")\n"
"datetime.datetime(1904, 2, 29, 0, 0)"
msgstr ""

#: ../../library/datetime.rst:2728
msgid "Using ``datetime.strptime(date_string, format)`` is equivalent to::"
msgstr ""

#: ../../library/datetime.rst:2732
msgid ""
"except when the format includes sub-second components or time zone offset "
"information, which are supported in ``datetime.strptime`` but are discarded "
"by ``time.strptime``."
msgstr ""

#: ../../library/datetime.rst:2736
msgid ""
"For :class:`.time` objects, the format codes for year, month, and day should "
"not be used, as :class:`!time` objects have no such values. If they're used "
"anyway, 1900 is substituted for the year, and 1 for the month and day."
msgstr ""
"對 :class:`.time` 物件來說，不應該使用年、月、日的格式碼，因為 :class:`!"
"time` 物件並沒有這些值。如果使用這些格式碼，年份會以 1900 代替、月及日會以 1 "
"代替。"

#: ../../library/datetime.rst:2740
msgid ""
"For :class:`date` objects, the format codes for hours, minutes, seconds, and "
"microseconds should not be used, as :class:`date` objects have no such "
"values. If they're used anyway, 0 is substituted for them."
msgstr ""
"對 :class:`.date` 物件來說，不應該使用時、分、秒、微秒的格式碼，因為 :class:"
"`date` 物件並沒有這些值。如果使用這些格式碼，這些值都會以 0 代替。"

#: ../../library/datetime.rst:2744
msgid ""
"For the same reason, handling of format strings containing Unicode code "
"points that can't be represented in the charset of the current locale is "
"also platform-dependent. On some platforms such code points are preserved "
"intact in the output, while on others ``strftime`` may raise :exc:"
"`UnicodeError` or return an empty string instead."
msgstr ""

#: ../../library/datetime.rst:2753
msgid ""
"Because the format depends on the current locale, care should be taken when "
"making assumptions about the output value. Field orderings will vary (for "
"example, \"month/day/year\" versus \"day/month/year\"), and the output may "
"contain non-ASCII characters."
msgstr ""

#: ../../library/datetime.rst:2759
msgid ""
"The :meth:`~.datetime.strptime` method can parse years in the full [1, 9999] "
"range, but years < 1000 must be zero-filled to 4-digit width."
msgstr ""

#: ../../library/datetime.rst:2762
msgid ""
"In previous versions, :meth:`~.datetime.strftime` method was restricted to "
"years >= 1900."
msgstr ""

#: ../../library/datetime.rst:2766
msgid ""
"In version 3.2, :meth:`~.datetime.strftime` method was restricted to years "
">= 1000."
msgstr ""

#: ../../library/datetime.rst:2771
msgid ""
"When used with the :meth:`~.datetime.strptime` method, the ``%p`` directive "
"only affects the output hour field if the ``%I`` directive is used to parse "
"the hour."
msgstr ""

#: ../../library/datetime.rst:2775
msgid ""
"Unlike the :mod:`time` module, the :mod:`!datetime` module does not support "
"leap seconds."
msgstr ""

#: ../../library/datetime.rst:2779
msgid ""
"When used with the :meth:`~.datetime.strptime` method, the ``%f`` directive "
"accepts from one to six digits and zero pads on the right. ``%f`` is an "
"extension to the set of format characters in the C standard (but implemented "
"separately in datetime objects, and therefore always available)."
msgstr ""

#: ../../library/datetime.rst:2786
msgid ""
"For a naive object, the ``%z``, ``%:z`` and ``%Z`` format codes are replaced "
"by empty strings."
msgstr ""

#: ../../library/datetime.rst:2789
msgid "For an aware object:"
msgstr ""

#: ../../library/datetime.rst:2792
msgid ""
":meth:`~.datetime.utcoffset` is transformed into a string of the form "
"``±HHMM[SS[.ffffff]]``, where ``HH`` is a 2-digit string giving the number "
"of UTC offset hours, ``MM`` is a 2-digit string giving the number of UTC "
"offset minutes, ``SS`` is a 2-digit string giving the number of UTC offset "
"seconds and ``ffffff`` is a 6-digit string giving the number of UTC offset "
"microseconds. The ``ffffff`` part is omitted when the offset is a whole "
"number of seconds and both the ``ffffff`` and the ``SS`` part is omitted "
"when the offset is a whole number of minutes. For example, if :meth:`~."
"datetime.utcoffset` returns ``timedelta(hours=-3, minutes=-30)``, ``%z`` is "
"replaced with the string ``'-0330'``."
msgstr ""

#: ../../library/datetime.rst:2806
msgid ""
"When the ``%z`` directive is provided to the  :meth:`~.datetime.strptime` "
"method, the UTC offsets can have a colon as a separator between hours, "
"minutes and seconds. For example, ``'+01:00:00'`` will be parsed as an "
"offset of one hour. In addition, providing ``'Z'`` is identical to "
"``'+00:00'``."
msgstr ""

#: ../../library/datetime.rst:2814
msgid ""
"Behaves exactly as ``%z``, but has a colon separator added between hours, "
"minutes and seconds."
msgstr ""

#: ../../library/datetime.rst:2818
msgid ""
"In :meth:`~.datetime.strftime`, ``%Z`` is replaced by an empty string if :"
"meth:`~.datetime.tzname` returns ``None``; otherwise ``%Z`` is replaced by "
"the returned value, which must be a string."
msgstr ""

#: ../../library/datetime.rst:2822
msgid ":meth:`~.datetime.strptime` only accepts certain values for ``%Z``:"
msgstr ""

#: ../../library/datetime.rst:2824
msgid "any value in ``time.tzname`` for your machine's locale"
msgstr ""

#: ../../library/datetime.rst:2825
msgid "the hard-coded values ``UTC`` and ``GMT``"
msgstr ""

#: ../../library/datetime.rst:2827
msgid ""
"So someone living in Japan may have ``JST``, ``UTC``, and ``GMT`` as valid "
"values, but probably not ``EST``. It will raise ``ValueError`` for invalid "
"values."
msgstr ""

#: ../../library/datetime.rst:2831
msgid ""
"When the ``%z`` directive is provided to the :meth:`~.datetime.strptime` "
"method, an aware :class:`.datetime` object will be produced. The ``tzinfo`` "
"of the result will be set to a :class:`timezone` instance."
msgstr ""

#: ../../library/datetime.rst:2837
msgid ""
"When used with the :meth:`~.datetime.strptime` method, ``%U`` and ``%W`` are "
"only used in calculations when the day of the week and the calendar year "
"(``%Y``) are specified."
msgstr ""

#: ../../library/datetime.rst:2842
msgid ""
"Similar to ``%U`` and ``%W``, ``%V`` is only used in calculations when the "
"day of the week and the ISO year (``%G``) are specified in a :meth:`~."
"datetime.strptime` format string. Also note that ``%G`` and ``%Y`` are not "
"interchangeable."
msgstr ""

#: ../../library/datetime.rst:2848
msgid ""
"When used with the :meth:`~.datetime.strptime` method, the leading zero is "
"optional for  formats ``%d``, ``%m``, ``%H``, ``%I``, ``%M``, ``%S``, "
"``%j``, ``%U``, ``%W``, and ``%V``. Format ``%y`` does require a leading "
"zero."
msgstr ""

#: ../../library/datetime.rst:2853
msgid ""
"When parsing a month and day using :meth:`~.datetime.strptime`, always "
"include a year in the format.  If the value you need to parse lacks a year, "
"append an explicit dummy leap year.  Otherwise your code will raise an "
"exception when it encounters leap day because the default year used by the "
"parser (1900) is not a leap year.  Users run into that bug every leap year."
msgstr ""

#: ../../library/datetime.rst:2859
msgid ""
">>> month_day = \"02/29\"\n"
">>> dt.datetime.strptime(f\"{month_day};1984\", \"%m/%d;%Y\")  # No leap "
"year bug.\n"
"datetime.datetime(1984, 2, 29, 0, 0)"
msgstr ""
">>> month_day = \"02/29\"\n"
">>> dt.datetime.strptime(f\"{month_day};1984\", \"%m/%d;%Y\")  # 沒有閏年問"
"題。\n"
"datetime.datetime(1984, 2, 29, 0, 0)"

#: ../../library/datetime.rst:2865
msgid ""
":meth:`~.datetime.strptime` calls using a format string containing a day of "
"month without a year now emit a :exc:`DeprecationWarning`. In 3.15 or later "
"we may change this into an error or change the default year to a leap year. "
"See :gh:`70647`."
msgstr ""

#: ../../library/datetime.rst:2872
msgid "Footnotes"
msgstr "註解"

#: ../../library/datetime.rst:2873
msgid "If, that is, we ignore the effects of relativity."
msgstr "也就是說，我們會忽略相對論的效應。"

#: ../../library/datetime.rst:2875
msgid ""
"This matches the definition of the \"proleptic Gregorian\" calendar in "
"Dershowitz and Reingold's book *Calendrical Calculations*, where it's the "
"base calendar for all computations. See the book for algorithms for "
"converting between proleptic Gregorian ordinals and many other calendar "
"systems."
msgstr ""

#: ../../library/datetime.rst:2881
msgid ""
"See R. H. van Gent's `guide to the mathematics of the ISO 8601 calendar "
"<https://web.archive.org/web/20220531051136/https://webspace.science.uu.nl/"
"~gent0113/calendar/isocalendar.htm>`_ for a good explanation."
msgstr ""

#: ../../library/datetime.rst:2488
msgid "% (percent)"
msgstr "% （百分號）"

#: ../../library/datetime.rst:2488
msgid "datetime format"
msgstr "datetime format（日期時間格式）"

#~ msgid ""
#~ ">>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)\n"
#~ ">>> for i in range(4):\n"
#~ "...     u = u0 + i*HOUR\n"
#~ "...     t = u.astimezone(Eastern)\n"
#~ "...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)\n"
#~ "...\n"
#~ "04:00:00 UTC = 00:00:00 EDT 0\n"
#~ "05:00:00 UTC = 01:00:00 EDT 0\n"
#~ "06:00:00 UTC = 01:00:00 EST 1\n"
#~ "07:00:00 UTC = 02:00:00 EST 0"
#~ msgstr ""
#~ ">>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)\n"
#~ ">>> for i in range(4):\n"
#~ "...     u = u0 + i*HOUR\n"
#~ "...     t = u.astimezone(Eastern)\n"
#~ "...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)\n"
#~ "...\n"
#~ "04:00:00 UTC = 00:00:00 EDT 0\n"
#~ "05:00:00 UTC = 01:00:00 EDT 0\n"
#~ "06:00:00 UTC = 01:00:00 EST 1\n"
#~ "07:00:00 UTC = 02:00:00 EST 0"

#~ msgid ""
#~ "object\n"
#~ "    timedelta\n"
#~ "    tzinfo\n"
#~ "        timezone\n"
#~ "    time\n"
#~ "    date\n"
#~ "        datetime"
#~ msgstr ""
#~ "object\n"
#~ "    timedelta\n"
#~ "    tzinfo\n"
#~ "        timezone\n"
#~ "    time\n"
#~ "    date\n"
#~ "        datetime"

#~ msgid ":class:`date`; :class:`.datetime`; :class:`.time`"
#~ msgstr ":class:`date`; :class:`.datetime`; :class:`.time`"

#~ msgid ":class:`.datetime`"
#~ msgstr ":class:`.datetime`"