typing.po

# 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-05-23 00:37+0000\n"
"PO-Revision-Date: 2024-07-11 11:12+0800\n"
"Last-Translator: Li-Hung Wang <therockleona@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.4.4\n"

#: ../../library/typing.rst:3
msgid ":mod:`!typing` --- Support for type hints"
msgstr ":mod:`!typing` --- 支援型別提示"

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

#: ../../library/typing.rst:20
msgid ""
"The Python runtime does not enforce function and variable type annotations. "
"They can be used by third party tools such as :term:`type checkers <static "
"type checker>`, IDEs, linters, etc."
msgstr ""
"Python runtime 不強制要求函式與變數的型別註釋。他們可以被第三方工具使用，如："
"\\ :term:`型別檢查器 <static type checker>`、IDE、linter 等。"

#: ../../library/typing.rst:26
msgid "This module provides runtime support for type hints."
msgstr "此模組提供 runtime 型別提示支援。"

#: ../../library/typing.rst:28
msgid "Consider the function below::"
msgstr "動腦筋思考下面的函式： ::"

#: ../../library/typing.rst:30
msgid ""
"def surface_area_of_cube(edge_length: float) -> str:\n"
"    return f\"The surface area of the cube is {6 * edge_length ** 2}.\""
msgstr ""
"def surface_area_of_cube(edge_length: float) -> str:\n"
"    return f\"The surface area of the cube is {6 * edge_length ** 2}.\""

#: ../../library/typing.rst:33
msgid ""
"The function ``surface_area_of_cube`` takes an argument expected to be an "
"instance of :class:`float`, as indicated by the :term:`type hint` "
"``edge_length: float``. The function is expected to return an instance of :"
"class:`str`, as indicated by the ``-> str`` hint."
msgstr ""
"函式 ``surface_area_of_cube`` 需要一個引數且預期是一個 :class:`float` 的實"
"例，如 ``edge_length: float`` 所指出的\\ :term:`型別提示 <type hint>`。這個函"
"式預期會回傳一個 :class:`str` 的實例，如 ``-> str`` 所指出的提示。"

#: ../../library/typing.rst:38
msgid ""
"While type hints can be simple classes like :class:`float` or :class:`str`, "
"they can also be more complex. The :mod:`typing` module provides a "
"vocabulary of more advanced type hints."
msgstr ""
"儘管型別提示可以是簡單類別，像是 :class:`float` 或 :class:`str`，他們也可以變"
"得更為複雜。模組 :mod:`typing` 提供一組更高階的型別提示詞彙。"

#: ../../library/typing.rst:42
msgid ""
"New features are frequently added to the ``typing`` module. The :pypi:"
"`typing_extensions` package provides backports of these new features to "
"older versions of Python."
msgstr ""
"新功能會頻繁的新增至 ``typing`` 模組中。:pypi:`typing_extensions` 套件為這些"
"新功能提供了 backport（向後移植的）版本，提供給舊版本的 Python 使用。"

#: ../../library/typing.rst:48
msgid ""
"`Typing cheat sheet <https://mypy.readthedocs.io/en/stable/cheat_sheet_py3."
"html>`_"
msgstr ""
"`型別小抄 (Typing cheat sheet) <https://mypy.readthedocs.io/en/stable/"
"cheat_sheet_py3.html>`_"

#: ../../library/typing.rst:49
msgid "A quick overview of type hints (hosted at the mypy docs)"
msgstr "型別提示的快速預覽（發布於 mypy 的文件中）"

#: ../../library/typing.rst:51
msgid ""
"Type System Reference section of `the mypy docs <https://mypy.readthedocs.io/"
"en/stable/index.html>`_"
msgstr ""
"`mypy 文件 <https://mypy.readthedocs.io/en/stable/index.html>`_\\ 的 型別系統"
"參考資料 (Type System Reference) 章節"

#: ../../library/typing.rst:52
msgid ""
"The Python typing system is standardised via PEPs, so this reference should "
"broadly apply to most Python type checkers. (Some parts may still be "
"specific to mypy.)"
msgstr ""
"Python 的加註型別系統是基於 PEPs 進行標準化，所以這個參照 (reference) 應該在"
"多數 Python 型別檢查器中廣為使用。（某些部分依然是特定給 mypy 使用。）"

#: ../../library/typing.rst:56
msgid "`Static Typing with Python <https://typing.python.org/en/latest/>`_"
msgstr ""
"`Python 的靜態型別 (Static Typing) <https://typing.python.org/en/latest/>`_"

#: ../../library/typing.rst:57
msgid ""
"Type-checker-agnostic documentation written by the community detailing type "
"system features, useful typing related tools and typing best practices."
msgstr ""
"由社群編寫的跨平台型別檢查器文件 (type-checker-agnostic) 詳細描述加註型別系統"
"的功能、實用的加註型別衍伸工具、以及加註型別的最佳實踐 (best practice)。"

#: ../../library/typing.rst:64
msgid "Specification for the Python Type System"
msgstr "Python 型別系統的技術規範"

#: ../../library/typing.rst:66
msgid ""
"The canonical, up-to-date specification of the Python type system can be "
"found at `Specification for the Python type system <https://typing.python."
"org/en/latest/spec/index.html>`_."
msgstr ""
"關於 Python 型別系統標準的 (canonical)、最新的技術規範可以在\\ `Python 型別系"
"統的技術規範 <https://typing.python.org/en/latest/spec/index.html>`_\\ 找到。"

#: ../../library/typing.rst:72
msgid "Type aliases"
msgstr "型別別名"

#: ../../library/typing.rst:74
msgid ""
"A type alias is defined using the :keyword:`type` statement, which creates "
"an instance of :class:`TypeAliasType`. In this example, ``Vector`` and "
"``list[float]`` will be treated equivalently by static type checkers::"
msgstr ""
"一個型別別名被定義來使用 :keyword:`type` 陳述式，其建立了 :class:"
"`TypeAliasType` 的實例。在這個範例中，``Vector`` 及 ``list[float]`` 會被當作"
"和靜態型別檢查器一樣同等對待： ::"

#: ../../library/typing.rst:79
msgid ""
"type Vector = list[float]\n"
"\n"
"def scale(scalar: float, vector: Vector) -> Vector:\n"
"    return [scalar * num for num in vector]\n"
"\n"
"# passes type checking; a list of floats qualifies as a Vector.\n"
"new_vector = scale(2.0, [1.0, -4.2, 5.4])"
msgstr ""

#: ../../library/typing.rst:87
msgid ""
"Type aliases are useful for simplifying complex type signatures. For "
"example::"
msgstr ""
"型別別名對於簡化複雜的型別簽名 (complex type signature) 非常好用。舉例來"
"說： ::"

#: ../../library/typing.rst:89
msgid ""
"from collections.abc import Sequence\n"
"\n"
"type ConnectionOptions = dict[str, str]\n"
"type Address = tuple[str, int]\n"
"type Server = tuple[Address, ConnectionOptions]\n"
"\n"
"def broadcast_message(message: str, servers: Sequence[Server]) -> None:\n"
"    ...\n"
"\n"
"# The static type checker will treat the previous type signature as\n"
"# being exactly equivalent to this one.\n"
"def broadcast_message(\n"
"    message: str,\n"
"    servers: Sequence[tuple[tuple[str, int], dict[str, str]]]\n"
") -> None:\n"
"    ..."
msgstr ""

#: ../../library/typing.rst:106
msgid ""
"The :keyword:`type` statement is new in Python 3.12. For backwards "
"compatibility, type aliases can also be created through simple assignment::"
msgstr ""
":keyword:`type` 陳述式是 Python 3.12 的新功能。為了向後相容性，型別別名可以透"
"過簡單的賦值來建立： ::"

#: ../../library/typing.rst:109
msgid "Vector = list[float]"
msgstr "Vector = list[float]"

#: ../../library/typing.rst:111
msgid ""
"Or marked with :data:`TypeAlias` to make it explicit that this is a type "
"alias, not a normal variable assignment::"
msgstr ""
"或是用 :data:`TypeAlias` 標記，讓它明確的表示這是一個型別別名，而非一般的變數"
"賦值： ::"

#: ../../library/typing.rst:114
msgid ""
"from typing import TypeAlias\n"
"\n"
"Vector: TypeAlias = list[float]"
msgstr ""

#: ../../library/typing.rst:121
msgid "NewType"
msgstr "NewType"

#: ../../library/typing.rst:123
msgid "Use the :class:`NewType` helper to create distinct types::"
msgstr "使用 :class:`NewType` 輔助工具 (helper) 建立獨特型別： ::"

#: ../../library/typing.rst:125
msgid ""
"from typing import NewType\n"
"\n"
"UserId = NewType('UserId', int)\n"
"some_id = UserId(524313)"
msgstr ""

#: ../../library/typing.rst:130
msgid ""
"The static type checker will treat the new type as if it were a subclass of "
"the original type. This is useful in helping catch logical errors::"
msgstr ""
"若它是原本型別的子類別，靜態型別檢查器會將其視為一個新的型別。這對於幫助擷取"
"邏輯性錯誤非常有用： ::"

#: ../../library/typing.rst:133
msgid ""
"def get_user_name(user_id: UserId) -> str:\n"
"    ...\n"
"\n"
"# passes type checking\n"
"user_a = get_user_name(UserId(42351))\n"
"\n"
"# fails type checking; an int is not a UserId\n"
"user_b = get_user_name(-1)"
msgstr ""

#: ../../library/typing.rst:142
msgid ""
"You may still perform all ``int`` operations on a variable of type "
"``UserId``, but the result will always be of type ``int``. This lets you "
"pass in a ``UserId`` wherever an ``int`` might be expected, but will prevent "
"you from accidentally creating a ``UserId`` in an invalid way::"
msgstr ""
"你依然可以在對於型別 ``UserId`` 的變數中執行所有 ``int`` 的操作。這讓你可以在"
"預期接受 ``int`` 的地方傳遞一個 ``UserId``，還能預防你意外使用無效的方法建立"
"一個 ``UserId``： ::"

#: ../../library/typing.rst:147
msgid ""
"# 'output' is of type 'int', not 'UserId'\n"
"output = UserId(23413) + UserId(54341)"
msgstr ""

#: ../../library/typing.rst:150
msgid ""
"Note that these checks are enforced only by the static type checker. At "
"runtime, the statement ``Derived = NewType('Derived', Base)`` will make "
"``Derived`` a callable that immediately returns whatever parameter you pass "
"it. That means the expression ``Derived(some_value)`` does not create a new "
"class or introduce much overhead beyond that of a regular function call."
msgstr ""
"注意這只會透過靜態型別檢查器強制檢查。在 runtime 中，陳述式 (statement) "
"``Derived = NewType('Derived', Base)`` 會使 ``Derived`` 成為一個 callable（可"
"呼叫物件），會立即回傳任何你傳遞的引數。這意味著 expression （運算式）\\ "
"``Derived(some_value)`` 不會建立一個新的類別或過度引入原有的函式呼叫。"

#: ../../library/typing.rst:156
msgid ""
"More precisely, the expression ``some_value is Derived(some_value)`` is "
"always true at runtime."
msgstr ""
"更精確地說，expression ``some_value is Derived(some_value)`` 在 runtime 永遠"
"為 true。"

#: ../../library/typing.rst:159
msgid "It is invalid to create a subtype of ``Derived``::"
msgstr "這會無法建立一個 ``Derived`` 的子型別： ::"

#: ../../library/typing.rst:161
msgid ""
"from typing import NewType\n"
"\n"
"UserId = NewType('UserId', int)\n"
"\n"
"# Fails at runtime and does not pass type checking\n"
"class AdminUserId(UserId): pass"
msgstr ""

#: ../../library/typing.rst:168
msgid ""
"However, it is possible to create a :class:`NewType` based on a 'derived' "
"``NewType``::"
msgstr ""
"無論如何，這有辦法基於 '衍生的' ``NewType`` 建立一個 :class:`NewType`： ::"

#: ../../library/typing.rst:170
msgid ""
"from typing import NewType\n"
"\n"
"UserId = NewType('UserId', int)\n"
"\n"
"ProUserId = NewType('ProUserId', UserId)"
msgstr ""
"from typing import NewType\n"
"\n"
"UserId = NewType('UserId', int)\n"
"\n"
"ProUserId = NewType('ProUserId', UserId)"

#: ../../library/typing.rst:176
msgid "and typechecking for ``ProUserId`` will work as expected."
msgstr "以及針對 ``ProUserId`` 的型別檢查會如期運作。"

#: ../../library/typing.rst:178
msgid "See :pep:`484` for more details."
msgstr "更多細節請見 :pep:`484`。"

#: ../../library/typing.rst:182
msgid ""
"Recall that the use of a type alias declares two types to be *equivalent* to "
"one another. Doing ``type Alias = Original`` will make the static type "
"checker treat ``Alias`` as being *exactly equivalent* to ``Original`` in all "
"cases. This is useful when you want to simplify complex type signatures."
msgstr ""
"請記得使用型別別名是宣告兩種型別是互相\\ *相等*\\ 的。使用 ``type Alias = "
"Original`` 則會讓靜態型別檢查器在任何情況之下將 ``Alias`` 視為與 "
"``Original`` \\ *完全相等*。這當你想把複雜的型別簽名進行簡化時，非常好用。"

#: ../../library/typing.rst:187
msgid ""
"In contrast, ``NewType`` declares one type to be a *subtype* of another. "
"Doing ``Derived = NewType('Derived', Original)`` will make the static type "
"checker treat ``Derived`` as a *subclass* of ``Original``, which means a "
"value of type ``Original`` cannot be used in places where a value of type "
"``Derived`` is expected. This is useful when you want to prevent logic "
"errors with minimal runtime cost."
msgstr ""
"相反的，``NewType`` 宣告一個型別會是另外一種型別的子類別。使用 ``Derived = "
"NewType('Derived', Original)`` 會使靜態型別檢查器將 ``Derived`` 視為 "
"``Original`` 的子類別，也意味著一個型別為 ``Original`` 的值，不能被使用在任何"
"預期接收到型別 ``Derived`` 的值的區域。這當你想用最小的 runtime 成本預防邏輯"
"性錯誤而言，非常有用。"

#: ../../library/typing.rst:196
msgid ""
"``NewType`` is now a class rather than a function.  As a result, there is "
"some additional runtime cost when calling ``NewType`` over a regular "
"function."
msgstr ""
"現在的 ``NewType`` 比起一個函式更像一個類別。因此，比起一般的函式，呼叫 "
"``NewType`` 需要額外的 runtime 成本。"

#: ../../library/typing.rst:201
msgid ""
"The performance of calling ``NewType`` has been restored to its level in "
"Python 3.9."
msgstr "呼叫 ``NewType`` 的效能已經恢復與 Python 3.9 相同的水準。"

#: ../../library/typing.rst:208
msgid "Annotating callable objects"
msgstr "註釋 callable 物件"

#: ../../library/typing.rst:210
msgid ""
"Functions -- or other :term:`callable` objects -- can be annotated using :"
"class:`collections.abc.Callable` or deprecated :data:`typing.Callable`. "
"``Callable[[int], str]`` signifies a function that takes a single parameter "
"of type :class:`int` and returns a :class:`str`."
msgstr ""
"函式，或者是其他 :term:`callable` 物件，可以使用 :class:`collections.abc."
"Callable` 或以棄用的 :data:`typing.Callable` 進行註釋。 ``Callable[[int], "
"str]`` 象徵為一個函式，可以接受一個型別為 :class:`int` 的引數，並回傳一個 :"
"class:`str`。"

#: ../../library/typing.rst:215 ../../library/typing.rst:3297
#: ../../library/typing.rst:3483 ../../library/typing.rst:3511
msgid "For example:"
msgstr "舉例來說："

#: ../../library/typing.rst:217
msgid ""
"from collections.abc import Callable, Awaitable\n"
"\n"
"def feeder(get_next_item: Callable[[], str]) -> None:\n"
"    ...  # Body\n"
"\n"
"def async_query(on_success: Callable[[int], None],\n"
"                on_error: Callable[[int, Exception], None]) -> None:\n"
"    ...  # Body\n"
"\n"
"async def on_update(value: str) -> None:\n"
"    ...  # Body\n"
"\n"
"callback: Callable[[str], Awaitable[None]] = on_update"
msgstr ""
"from collections.abc import Callable, Awaitable\n"
"\n"
"def feeder(get_next_item: Callable[[], str]) -> None:\n"
"    ...  # 主體\n"
"\n"
"def async_query(on_success: Callable[[int], None],\n"
"                on_error: Callable[[int, Exception], None]) -> None:\n"
"    ...  # 主體\n"
"\n"
"async def on_update(value: str) -> None:\n"
"    ...  # 主體\n"
"\n"
"callback: Callable[[str], Awaitable[None]] = on_update"

#: ../../library/typing.rst:235
msgid ""
"The subscription syntax must always be used with exactly two values: the "
"argument list and the return type.  The argument list must be a list of "
"types, a :class:`ParamSpec`, :data:`Concatenate`, or an ellipsis (``...``). "
"The return type must be a single type."
msgstr ""
"使用下標語法 (subscription syntax) 時，必須使用到兩個值，分別為引述串列以及回"
"傳類別。引數串列必須為一個型別串列：:class:`ParamSpec`、:data:`Concatenate` "
"或是一個刪節號 (ellipsis, ``...``)。回傳類別必為一個單一類別。"

#: ../../library/typing.rst:240
msgid ""
"If a literal ellipsis ``...`` is given as the argument list, it indicates "
"that a callable with any arbitrary parameter list would be acceptable:"
msgstr ""
"若刪節號字面值 ``...`` 被當作引數串列給定，其指出一個具任何、任意參數列表的 "
"callable 會被接受： ::"

#: ../../library/typing.rst:243
msgid ""
"def concat(x: str, y: str) -> str:\n"
"    return x + y\n"
"\n"
"x: Callable[..., str]\n"
"x = str     # OK\n"
"x = concat  # Also OK"
msgstr ""
"def concat(x: str, y: str) -> str:\n"
"    return x + y\n"
"\n"
"x: Callable[..., str]\n"
"x = str     # OK\n"
"x = concat  # 也 OK"

#: ../../library/typing.rst:252
msgid ""
"``Callable`` cannot express complex signatures such as functions that take a "
"variadic number of arguments, :ref:`overloaded functions <overload>`, or "
"functions that have keyword-only parameters. However, these signatures can "
"be expressed by defining a :class:`Protocol` class with a :meth:`~object."
"__call__` method:"
msgstr ""
"``Callable`` 不如有可變數量引數的函式、:func:`overloaded functions "
"<overload>`、或是僅限關鍵字參數的函式，可以表示複雜簽名。然而，這些簽名可以透"
"過定義一個具有 :meth:`~object.__call__` 方法的 :class:`Protocol` 類別進行表"
"示："

#: ../../library/typing.rst:258
msgid ""
"from collections.abc import Iterable\n"
"from typing import Protocol\n"
"\n"
"class Combiner(Protocol):\n"
"    def __call__(self, *vals: bytes, maxlen: int | None = None) -> "
"list[bytes]: ...\n"
"\n"
"def batch_proc(data: Iterable[bytes], cb_results: Combiner) -> bytes:\n"
"    for item in data:\n"
"        ...\n"
"\n"
"def good_cb(*vals: bytes, maxlen: int | None = None) -> list[bytes]:\n"
"    ...\n"
"def bad_cb(*vals: bytes, maxitems: int | None) -> list[bytes]:\n"
"    ...\n"
"\n"
"batch_proc([], good_cb)  # OK\n"
"batch_proc([], bad_cb)   # Error! Argument 2 has incompatible type because "
"of\n"
"                         # different name and kind in the callback"
msgstr ""

#: ../../library/typing.rst:279
msgid ""
"Callables which take other callables as arguments may indicate that their "
"parameter types are dependent on each other using :class:`ParamSpec`. "
"Additionally, if that callable adds or removes arguments from other "
"callables, the :data:`Concatenate` operator may be used.  They take the form "
"``Callable[ParamSpecVariable, ReturnType]`` and "
"``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], "
"ReturnType]`` respectively."
msgstr ""
"Callable 物件可以取用其他 callable 當作引數使用，可以透過 :class:`ParamSpec` "
"指出他們的參數型別是個別獨立的。另外，如果這個 callable 從其他 callable 新增"
"或刪除引數時，將會使用到 :data:`Concatenate` 運算子。他們可以分別採用 "
"``Callable[ParamSpecVariable, ReturnType]`` 以及 "
"``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], "
"ReturnType]`` 的形式。"

#: ../../library/typing.rst:287 ../../library/typing.rst:4053
msgid ""
"``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`. See :"
"pep:`612` for more details."
msgstr ""
"``Callable`` 現已支援 :class:`ParamSpec` 以及 :data:`Concatenate`。請參閱 :"
"pep:`612` 閱讀詳細內容。"

#: ../../library/typing.rst:292
msgid ""
"The documentation for :class:`ParamSpec` and :class:`Concatenate` provides "
"examples of usage in ``Callable``."
msgstr ""
":class:`ParamSpec` 以及 :class:`Concatenate` 的文件中，提供範例如何在 "
"``Callable`` 中使用。"

#: ../../library/typing.rst:298
msgid "Generics"
msgstr "泛型"

#: ../../library/typing.rst:300
msgid ""
"Since type information about objects kept in containers cannot be statically "
"inferred in a generic way, many container classes in the standard library "
"support subscription to denote the expected types of container elements."
msgstr ""
"因為關於物件的型別資訊留存在容器之內，且無法使用通用的方式進行靜態推論 "
"(statically inferred)，許多標準函式庫的容器類別支援以下標來表示容器內預期的元"
"素。"

#: ../../library/typing.rst:304
msgid ""
"from collections.abc import Mapping, Sequence\n"
"\n"
"class Employee: ...\n"
"\n"
"# Sequence[Employee] indicates that all elements in the sequence\n"
"# must be instances of \"Employee\".\n"
"# Mapping[str, str] indicates that all keys and all values in the mapping\n"
"# must be strings.\n"
"def notify_by_email(employees: Sequence[Employee],\n"
"                    overrides: Mapping[str, str]) -> None: ..."
msgstr ""

#: ../../library/typing.rst:317
msgid ""
"Generic functions and classes can be parameterized by using :ref:`type "
"parameter syntax <type-params>`::"
msgstr ""
"泛型函式及類別可以使用\\ :ref:`型別參數語法 (type parameter syntax) <type-"
"params>` 進行參數化 (parameterize) ： ::"

#: ../../library/typing.rst:320
msgid ""
"from collections.abc import Sequence\n"
"\n"
"def first[T](l: Sequence[T]) -> T:  # Function is generic over the TypeVar "
"\"T\"\n"
"    return l[0]"
msgstr ""

#: ../../library/typing.rst:325
msgid "Or by using the :class:`TypeVar` factory directly::"
msgstr "或是直接使用 :class:`TypeVar` 工廠 (factory)： ::"

#: ../../library/typing.rst:327
msgid ""
"from collections.abc import Sequence\n"
"from typing import TypeVar\n"
"\n"
"U = TypeVar('U')                  # Declare type variable \"U\"\n"
"\n"
"def second(l: Sequence[U]) -> U:  # Function is generic over the TypeVar "
"\"U\"\n"
"    return l[1]"
msgstr ""

#: ../../library/typing.rst:335
msgid "Syntactic support for generics is new in Python 3.12."
msgstr "在 Python 3.12 中，泛型的語法支援是全新功能。"

#: ../../library/typing.rst:341
msgid "Annotating tuples"
msgstr "註釋元組 (tuple)"

#: ../../library/typing.rst:343
msgid ""
"For most containers in Python, the typing system assumes that all elements "
"in the container will be of the same type. For example::"
msgstr ""
"在 Python 大多數的容器當中，加註型別系統認為容器內的所有元素會是相同型別。舉"
"例來說： ::"

#: ../../library/typing.rst:346
msgid ""
"from collections.abc import Mapping\n"
"\n"
"# Type checker will infer that all elements in ``x`` are meant to be ints\n"
"x: list[int] = []\n"
"\n"
"# Type checker error: ``list`` only accepts a single type argument:\n"
"y: list[int, str] = [1, 'foo']\n"
"\n"
"# Type checker will infer that all keys in ``z`` are meant to be strings,\n"
"# and that all values in ``z`` are meant to be either strings or ints\n"
"z: Mapping[str, str | int] = {}"
msgstr ""

#: ../../library/typing.rst:358
msgid ""
":class:`list` only accepts one type argument, so a type checker would emit "
"an error on the ``y`` assignment above. Similarly, :class:`~collections.abc."
"Mapping` only accepts two type arguments: the first indicates the type of "
"the keys, and the second indicates the type of the values."
msgstr ""
":class:`list` 只接受一個型別引數，所以型別檢查器可能在上述 ``y`` 賦值 "
"(assignment) 觸發錯誤。類似的範例，:class:`~collections.abc.Mapping` 只接受兩"
"個型別引數：第一個引數指出 keys（鍵）的型別；第二個引數指出 values（值）的型"
"別。"

#: ../../library/typing.rst:364
msgid ""
"Unlike most other Python containers, however, it is common in idiomatic "
"Python code for tuples to have elements which are not all of the same type. "
"For this reason, tuples are special-cased in Python's typing system. :class:"
"`tuple` accepts *any number* of type arguments::"
msgstr ""
"然而，與其他多數的 Python 容器不同，在慣用的 (idiomatic) Python 程式碼中，元"
"組可以擁有不完全相同型別的元素是相當常見的。為此，元組在 Python 的加註型別系"
"統中是個特例 (special-cased)。:class:`tuple` 接受\\ *任何數量*\\ 的型別引"
"數： ::"

#: ../../library/typing.rst:369
msgid ""
"# OK: ``x`` is assigned to a tuple of length 1 where the sole element is an "
"int\n"
"x: tuple[int] = (5,)\n"
"\n"
"# OK: ``y`` is assigned to a tuple of length 2;\n"
"# element 1 is an int, element 2 is a str\n"
"y: tuple[int, str] = (5, \"foo\")\n"
"\n"
"# Error: the type annotation indicates a tuple of length 1,\n"
"# but ``z`` has been assigned to a tuple of length 3\n"
"z: tuple[int] = (1, 2, 3)"
msgstr ""

#: ../../library/typing.rst:382
msgid ""
"To denote a tuple which could be of *any* length, and in which all elements "
"are of the same type ``T``, use the literal ellipsis ``...``: "
"``tuple[T, ...]``. To denote an empty tuple, use ``tuple[()]``. Using plain "
"``tuple`` as an annotation is equivalent to using ``tuple[Any, ...]``::"
msgstr ""
"為了標示一個元組可以為\\ *任意*\\ 長度，且所有元素皆是相同型別 ``T``，請使用 "
"刪節號字面值 (literal ellipsis) ``...``：``tuple[T, ...]``。為了標示一個空元"
"組，請使用 ``tuple[()]``。單純使用 ``tuple`` 作為註釋會與使用 "
"``tuple[Any, ...]`` 相等： ::"

#: ../../library/typing.rst:388
msgid ""
"x: tuple[int, ...] = (1, 2)\n"
"# These reassignments are OK: ``tuple[int, ...]`` indicates x can be of any "
"length\n"
"x = (1, 2, 3)\n"
"x = ()\n"
"# This reassignment is an error: all elements in ``x`` must be ints\n"
"x = (\"foo\", \"bar\")\n"
"\n"
"# ``y`` can only ever be assigned to an empty tuple\n"
"y: tuple[()] = ()\n"
"\n"
"z: tuple = (\"foo\", \"bar\")\n"
"# These reassignments are OK: plain ``tuple`` is equivalent to "
"``tuple[Any, ...]``\n"
"z = (1, 2, 3)\n"
"z = ()"
msgstr ""

#: ../../library/typing.rst:406
msgid "The type of class objects"
msgstr "類別物件的型別"

#: ../../library/typing.rst:408
msgid ""
"A variable annotated with ``C`` may accept a value of type ``C``. In "
"contrast, a variable annotated with ``type[C]`` (or deprecated :class:"
"`typing.Type[C] <Type>`) may accept values that are classes themselves -- "
"specifically, it will accept the *class object* of ``C``. For example::"
msgstr ""
"一個變數被註釋為 ``C`` 可以接受一個型別為 ``C`` 的值。相對的，一個變數備註解"
"為 ``type[C]`` \\ （或已棄用的 :class:`typing.Type[C] <Type>`）\\ 可以接受本"
"身為該類別的值 -- 具體來說，他可能會接受 ``C`` 的\\ *類別物件*\\。舉例來"
"說： ::"

#: ../../library/typing.rst:414
msgid ""
"a = 3         # Has type ``int``\n"
"b = int       # Has type ``type[int]``\n"
"c = type(a)   # Also has type ``type[int]``"
msgstr ""

#: ../../library/typing.rst:418
msgid "Note that ``type[C]`` is covariant::"
msgstr "請記得 ``type[C]`` 是共變 (covariant) 的： ::"

#: ../../library/typing.rst:420
msgid ""
"class User: ...\n"
"class ProUser(User): ...\n"
"class TeamUser(User): ...\n"
"\n"
"def make_new_user(user_class: type[User]) -> User:\n"
"    # ...\n"
"    return user_class()\n"
"\n"
"make_new_user(User)      # OK\n"
"make_new_user(ProUser)   # Also OK: ``type[ProUser]`` is a subtype of "
"``type[User]``\n"
"make_new_user(TeamUser)  # Still fine\n"
"make_new_user(User())    # Error: expected ``type[User]`` but got ``User``\n"
"make_new_user(int)       # Error: ``type[int]`` is not a subtype of "
"``type[User]``"
msgstr ""

#: ../../library/typing.rst:434
msgid ""
"The only legal parameters for :class:`type` are classes, :data:`Any`, :ref:"
"`type variables <generics>`, and unions of any of these types. For example::"
msgstr ""
":class:`type` 僅有的合法參數是類別、:data:`Any`、:ref:`型別變數 "
"<generics>`\\ 以及這些型別任意組合成的聯集。舉例來說： ::"

#: ../../library/typing.rst:438
msgid ""
"def new_non_team_user(user_class: type[BasicUser | ProUser]): ...\n"
"\n"
"new_non_team_user(BasicUser)  # OK\n"
"new_non_team_user(ProUser)    # OK\n"
"new_non_team_user(TeamUser)   # Error: ``type[TeamUser]`` is not a subtype\n"
"                              # of ``type[BasicUser | ProUser]``\n"
"new_non_team_user(User)       # Also an error"
msgstr ""

#: ../../library/typing.rst:446
msgid ""
"``type[Any]`` is equivalent to :class:`type`, which is the root of Python's :"
"ref:`metaclass hierarchy <metaclasses>`."
msgstr ""
"``type[Any]`` 等價於 :class:`type` ，其為 Python :ref:`metaclass 階層結構 "
"(hierachy) <metaclasses>`。"

#: ../../library/typing.rst:453
msgid "Annotating generators and coroutines"
msgstr ""

#: ../../library/typing.rst:455
msgid ""
"A generator can be annotated using the generic type :class:"
"`Generator[YieldType, SendType, ReturnType] <collections.abc.Generator>`. "
"For example::"
msgstr ""

#: ../../library/typing.rst:459
msgid ""
"def echo_round() -> Generator[int, float, str]:\n"
"    sent = yield 0\n"
"    while sent >= 0:\n"
"        sent = yield round(sent)\n"
"    return 'Done'"
msgstr ""
"def echo_round() -> Generator[int, float, str]:\n"
"    sent = yield 0\n"
"    while sent >= 0:\n"
"        sent = yield round(sent)\n"
"    return 'Done'"

#: ../../library/typing.rst:465
msgid ""
"Note that unlike many other generic classes in the standard library, the "
"``SendType`` of :class:`~collections.abc.Generator` behaves contravariantly, "
"not covariantly or invariantly."
msgstr ""

#: ../../library/typing.rst:469
msgid ""
"The ``SendType`` and ``ReturnType`` parameters default to :const:`!None`::"
msgstr ""

#: ../../library/typing.rst:471
msgid ""
"def infinite_stream(start: int) -> Generator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"
msgstr ""
"def infinite_stream(start: int) -> Generator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"

#: ../../library/typing.rst:476
msgid "It is also possible to set these types explicitly::"
msgstr ""

#: ../../library/typing.rst:478
msgid ""
"def infinite_stream(start: int) -> Generator[int, None, None]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"
msgstr ""
"def infinite_stream(start: int) -> Generator[int, None, None]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"

#: ../../library/typing.rst:483
msgid ""
"Simple generators that only ever yield values can also be annotated as "
"having a return type of either :class:`Iterable[YieldType] <collections.abc."
"Iterable>` or :class:`Iterator[YieldType] <collections.abc.Iterator>`::"
msgstr ""

#: ../../library/typing.rst:488
msgid ""
"def infinite_stream(start: int) -> Iterator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"
msgstr ""
"def infinite_stream(start: int) -> Iterator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start += 1"

#: ../../library/typing.rst:493
msgid ""
"Async generators are handled in a similar fashion, but don't expect a "
"``ReturnType`` type argument (:class:`AsyncGenerator[YieldType, SendType] "
"<collections.abc.AsyncGenerator>`). The ``SendType`` argument defaults to :"
"const:`!None`, so the following definitions are equivalent::"
msgstr ""

#: ../../library/typing.rst:499
msgid ""
"async def infinite_stream(start: int) -> AsyncGenerator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)\n"
"\n"
"async def infinite_stream(start: int) -> AsyncGenerator[int, None]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)"
msgstr ""
"async def infinite_stream(start: int) -> AsyncGenerator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)\n"
"\n"
"async def infinite_stream(start: int) -> AsyncGenerator[int, None]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)"

#: ../../library/typing.rst:509
msgid ""
"As in the synchronous case, :class:`AsyncIterable[YieldType] <collections."
"abc.AsyncIterable>` and :class:`AsyncIterator[YieldType] <collections.abc."
"AsyncIterator>` are available as well::"
msgstr ""

#: ../../library/typing.rst:514
msgid ""
"async def infinite_stream(start: int) -> AsyncIterator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)"
msgstr ""
"async def infinite_stream(start: int) -> AsyncIterator[int]:\n"
"    while True:\n"
"        yield start\n"
"        start = await increment(start)"

#: ../../library/typing.rst:519
msgid ""
"Coroutines can be annotated using :class:`Coroutine[YieldType, SendType, "
"ReturnType] <collections.abc.Coroutine>`. Generic arguments correspond to "
"those of :class:`~collections.abc.Generator`, for example::"
msgstr ""

#: ../../library/typing.rst:524
msgid ""
"from collections.abc import Coroutine\n"
"c: Coroutine[list[str], str, int]  # Some coroutine defined elsewhere\n"
"x = c.send('hi')                   # Inferred type of 'x' is list[str]\n"
"async def bar() -> None:\n"
"    y = await c                    # Inferred type of 'y' is int"
msgstr ""

#: ../../library/typing.rst:533
msgid "User-defined generic types"
msgstr "使用者定義泛型型別"

#: ../../library/typing.rst:535
msgid "A user-defined class can be defined as a generic class."
msgstr "一個使用者定義的類別可以被定義成一個泛型類別。"

#: ../../library/typing.rst:539
msgid ""
"from logging import Logger\n"
"\n"
"class LoggedVar[T]:\n"
"    def __init__(self, value: T, name: str, logger: Logger) -> None:\n"
"        self.name = name\n"
"        self.logger = logger\n"
"        self.value = value\n"
"\n"
"    def set(self, new: T) -> None:\n"
"        self.log('Set ' + repr(self.value))\n"
"        self.value = new\n"
"\n"
"    def get(self) -> T:\n"
"        self.log('Get ' + repr(self.value))\n"
"        return self.value\n"
"\n"
"    def log(self, message: str) -> None:\n"
"        self.logger.info('%s: %s', self.name, message)"
msgstr ""
"from logging import Logger\n"
"\n"
"class LoggedVar[T]:\n"
"    def __init__(self, value: T, name: str, logger: Logger) -> None:\n"
"        self.name = name\n"
"        self.logger = logger\n"
"        self.value = value\n"
"\n"
"    def set(self, new: T) -> None:\n"
"        self.log('Set ' + repr(self.value))\n"
"        self.value = new\n"
"\n"
"    def get(self) -> T:\n"
"        self.log('Get ' + repr(self.value))\n"
"        return self.value\n"
"\n"
"    def log(self, message: str) -> None:\n"
"        self.logger.info('%s: %s', self.name, message)"

#: ../../library/typing.rst:558
msgid ""
"This syntax indicates that the class ``LoggedVar`` is parameterised around a "
"single :ref:`type variable <typevar>` ``T`` . This also makes ``T`` valid as "
"a type within the class body."
msgstr ""
"這個語法指出類別 ``LoggedVar`` 透過一個單一的 :ref:`型別變數 <typevar>` "
"``T`` 進行參數化 (parameterised)。這使得 ``T`` 在類別中有效的成為型別。"

#: ../../library/typing.rst:562
msgid ""
"Generic classes implicitly inherit from :class:`Generic`. For compatibility "
"with Python 3.11 and lower, it is also possible to inherit explicitly from :"
"class:`Generic` to indicate a generic class::"
msgstr ""
"泛型類別隱性繼承了 :class:`Generic`。為了相容 Python 3.11 及更早版本，也可以"
"明確的繼承 :class:`Generic` 並指出是一個泛型類別： ::"

#: ../../library/typing.rst:566
msgid ""
"from typing import TypeVar, Generic\n"
"\n"
"T = TypeVar('T')\n"
"\n"
"class LoggedVar(Generic[T]):\n"
"    ..."
msgstr ""
"from typing import TypeVar, Generic\n"
"\n"
"T = TypeVar('T')\n"
"\n"
"class LoggedVar(Generic[T]):\n"
"    ..."

#: ../../library/typing.rst:573
msgid ""
"Generic classes have :meth:`~object.__class_getitem__` methods, meaning they "
"can be parameterised at runtime (e.g. ``LoggedVar[int]`` below)::"
msgstr ""
"泛型類別有 :meth:`~object.__class_getitem__` 方法，其意味著可以在 runtime 進"
"行參數化（如下述的 ``LoggedVar[int]``）： ::"

#: ../../library/typing.rst:576
msgid ""
"from collections.abc import Iterable\n"
"\n"
"def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:\n"
"    for var in vars:\n"
"        var.set(0)"
msgstr ""
"from collections.abc import Iterable\n"
"\n"
"def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:\n"
"    for var in vars:\n"
"        var.set(0)"

#: ../../library/typing.rst:582
msgid ""
"A generic type can have any number of type variables. All varieties of :"
"class:`TypeVar` are permissible as parameters for a generic type::"
msgstr ""
"一個泛型型別可以有任意數量的型別變數。所有種類的 :class:`TypeVar` 都可以作為"
"泛型型別的參數： ::"

#: ../../library/typing.rst:585
msgid ""
"from typing import TypeVar, Generic, Sequence\n"
"\n"
"class WeirdTrio[T, B: Sequence[bytes], S: (int, str)]:\n"
"    ...\n"
"\n"
"OldT = TypeVar('OldT', contravariant=True)\n"
"OldB = TypeVar('OldB', bound=Sequence[bytes], covariant=True)\n"
"OldS = TypeVar('OldS', int, str)\n"
"\n"
"class OldWeirdTrio(Generic[OldT, OldB, OldS]):\n"
"    ..."
msgstr ""
"from typing import TypeVar, Generic, Sequence\n"
"\n"
"class WeirdTrio[T, B: Sequence[bytes], S: (int, str)]:\n"
"    ...\n"
"\n"
"OldT = TypeVar('OldT', contravariant=True)\n"
"OldB = TypeVar('OldB', bound=Sequence[bytes], covariant=True)\n"
"OldS = TypeVar('OldS', int, str)\n"
"\n"
"class OldWeirdTrio(Generic[OldT, OldB, OldS]):\n"
"    ..."

#: ../../library/typing.rst:597
msgid ""
"Each type variable argument to :class:`Generic` must be distinct. This is "
"thus invalid::"
msgstr ":class:`Generic` 的每個型別變數引數必不相同。因此以下是無效的： ::"

#: ../../library/typing.rst:600
msgid ""
"from typing import TypeVar, Generic\n"
"...\n"
"\n"
"class Pair[M, M]:  # SyntaxError\n"
"    ...\n"
"\n"
"T = TypeVar('T')\n"
"\n"
"class Pair(Generic[T, T]):   # INVALID\n"
"    ..."
msgstr ""
"from typing import TypeVar, Generic\n"
"...\n"
"\n"
"class Pair[M, M]:  # SyntaxError\n"
"    ...\n"
"\n"
"T = TypeVar('T')\n"
"\n"
"class Pair(Generic[T, T]):   # INVALID\n"
"    ..."

#: ../../library/typing.rst:611
msgid "Generic classes can also inherit from other classes::"
msgstr "泛型類別亦可以繼承其他類別： ::"

#: ../../library/typing.rst:613
msgid ""
"from collections.abc import Sized\n"
"\n"
"class LinkedList[T](Sized):\n"
"    ..."
msgstr ""
"from collections.abc import Sized\n"
"\n"
"class LinkedList[T](Sized):\n"
"    ..."

#: ../../library/typing.rst:618
msgid ""
"When inheriting from generic classes, some type parameters could be fixed::"
msgstr "當繼承泛型類別時，部份的型別參數可固定： ::"

#: ../../library/typing.rst:620
msgid ""
"from collections.abc import Mapping\n"
"\n"
"class MyDict[T](Mapping[str, T]):\n"
"    ..."
msgstr ""
"from collections.abc import Mapping\n"
"\n"
"class MyDict[T](Mapping[str, T]):\n"
"    ..."

#: ../../library/typing.rst:625
msgid "In this case ``MyDict`` has a single parameter, ``T``."
msgstr "在這種情況下 ``MyDict`` 有一個單一的參數 ``T``。"

#: ../../library/typing.rst:627
msgid ""
"Using a generic class without specifying type parameters assumes :data:`Any` "
"for each position. In the following example, ``MyIterable`` is not generic "
"but implicitly inherits from ``Iterable[Any]``:"
msgstr ""
"若使用泛型類別卻沒有特指型別參數，則會將每個位置視為 :data:`Any`。在下列的範"
"例中 ``MyIterable`` 不是泛型，但隱性繼承了 ``Iterable[Any]``： ::"

#: ../../library/typing.rst:631
msgid ""
"from collections.abc import Iterable\n"
"\n"
"class MyIterable(Iterable): # Same as Iterable[Any]\n"
"    ..."
msgstr ""

#: ../../library/typing.rst:638
msgid "User-defined generic type aliases are also supported. Examples::"
msgstr "使用者定義的泛型型別別名也有支援。例如： ::"

#: ../../library/typing.rst:640
msgid ""
"from collections.abc import Iterable\n"
"\n"
"type Response[S] = Iterable[S] | int\n"
"\n"
"# Return type here is same as Iterable[str] | int\n"
"def response(query: str) -> Response[str]:\n"
"    ...\n"
"\n"
"type Vec[T] = Iterable[tuple[T, T]]\n"
"\n"
"def inproduct[T: (int, float, complex)](v: Vec[T]) -> T: # Same as "
"Iterable[tuple[T, T]]\n"
"    return sum(x*y for x, y in v)"
msgstr ""

#: ../../library/typing.rst:653
msgid ""
"For backward compatibility, generic type aliases can also be created through "
"a simple assignment::"
msgstr "為了向後相容性，泛型型別別名可以透過簡單的賦值來建立： ::"

#: ../../library/typing.rst:656
msgid ""
"from collections.abc import Iterable\n"
"from typing import TypeVar\n"
"\n"
"S = TypeVar(\"S\")\n"
"Response = Iterable[S] | int"
msgstr ""
"from collections.abc import Iterable\n"
"from typing import TypeVar\n"
"\n"
"S = TypeVar(\"S\")\n"
"Response = Iterable[S] | int"

#: ../../library/typing.rst:662
msgid ":class:`Generic` no longer has a custom metaclass."
msgstr ":class:`Generic` 不再是一個自訂的 metaclass。"

#: ../../library/typing.rst:665
msgid ""
"Syntactic support for generics and type aliases is new in version 3.12. "
"Previously, generic classes had to explicitly inherit from :class:`Generic` "
"or contain a type variable in one of their bases."
msgstr ""
"在版本 3.12 新增了泛型及型別別名的語法支援。在之前的版本中，泛型類別必須顯性"
"繼承 :class:`Generic` 或是包含一個型別變數在基底類別 (base) 當中。"

#: ../../library/typing.rst:670
msgid ""
"User-defined generics for parameter expressions are also supported via "
"parameter specification variables in the form ``[**P]``.  The behavior is "
"consistent with type variables' described above as parameter specification "
"variables are treated by the :mod:`!typing` module as a specialized type "
"variable.  The one exception to this is that a list of types can be used to "
"substitute a :class:`ParamSpec`::"
msgstr ""
"使用者定義的參數運算式 (parameter expression) 泛型一樣有支援，透過 ``[**P]`` "
"格式的參數規格變數來進行表示。對於上述作為參數規格變數的型別變數，將持續被 :"
"mod:`!typing` 模組視為一個特定的型別變數。對此，其中一個例外是一個型別列表可"
"以替代 :class:`ParamSpec`： ::"

#: ../../library/typing.rst:676
msgid ""
">>> class Z[T, **P]: ...  # T is a TypeVar; P is a ParamSpec\n"
"...\n"
">>> Z[int, [dict, float]]\n"
"__main__.Z[int, [dict, float]]"
msgstr ""
">>> class Z[T, **P]: ...  # T 為 TypeVar；P 為 ParamSpec\n"
"...\n"
">>> Z[int, [dict, float]]\n"
"__main__.Z[int, [dict, float]]"

#: ../../library/typing.rst:681
msgid ""
"Classes generic over a :class:`ParamSpec` can also be created using explicit "
"inheritance from :class:`Generic`. In this case, ``**`` is not used::"
msgstr ""
"具有 :class:`ParamSpec` 的泛型類別可以透過顯性繼承 :class:`Generic` 進行建"
"立。在這種情況下，不需要使用 ``**``： ::"

#: ../../library/typing.rst:684
msgid ""
"from typing import ParamSpec, Generic\n"
"\n"
"P = ParamSpec('P')\n"
"\n"
"class Z(Generic[P]):\n"
"    ..."
msgstr ""
"from typing import ParamSpec, Generic\n"
"\n"
"P = ParamSpec('P')\n"
"\n"
"class Z(Generic[P]):\n"
"    ..."

#: ../../library/typing.rst:691
msgid ""
"Another difference between :class:`TypeVar` and :class:`ParamSpec` is that a "
"generic with only one parameter specification variable will accept parameter "
"lists in the forms ``X[[Type1, Type2, ...]]`` and also ``X[Type1, "
"Type2, ...]`` for aesthetic reasons.  Internally, the latter is converted to "
"the former, so the following are equivalent::"
msgstr ""
"另外一個 :class:`TypeVar` 以及 :class:`ParamSpec` 之間的差異是，基於美觀因"
"素，只有一個參數規格變數的泛型可以接受如 ``X[[Type1, Type2, ...]]`` 以及 "
"``X[Type1, Type2, ...]`` 的參數列表。在內部中，後者會被轉換為前者，所以在下方"
"的範例中為相等的： ::"

#: ../../library/typing.rst:697
msgid ""
">>> class X[**P]: ...\n"
"...\n"
">>> X[int, str]\n"
"__main__.X[[int, str]]\n"
">>> X[[int, str]]\n"
"__main__.X[[int, str]]"
msgstr ""
">>> class X[**P]: ...\n"
"...\n"
">>> X[int, str]\n"
"__main__.X[[int, str]]\n"
">>> X[[int, str]]\n"
"__main__.X[[int, str]]"

#: ../../library/typing.rst:704
msgid ""
"Note that generics with :class:`ParamSpec` may not have correct "
"``__parameters__`` after substitution in some cases because they are "
"intended primarily for static type checking."
msgstr ""
"請記得，具有 :class:`ParamSpec` 的泛型在某些情況下替換之後可能不會有正確的 "
"``__parameters__``，因為參數規格主要還是用於靜態型別檢查。"

#: ../../library/typing.rst:708
msgid ""
":class:`Generic` can now be parameterized over parameter expressions. See :"
"class:`ParamSpec` and :pep:`612` for more details."
msgstr ""
":class:`Generic` 現在可以透過參數運算式來進行參數化。詳細內容請見 :class:"
"`ParamSpec` 以及 :pep:`612`。"

#: ../../library/typing.rst:712
msgid ""
"A user-defined generic class can have ABCs as base classes without a "
"metaclass conflict. Generic metaclasses are not supported. The outcome of "
"parameterizing generics is cached, and most types in the :mod:`!typing` "
"module are :term:`hashable` and comparable for equality."
msgstr ""
"一個使用者定義的泛型類別可以將 ABC 作為他們的基底類別，且不會有 metaclass 衝"
"突。泛型的 metaclass 則不支援。參數化泛型的輸出將被存為快取，而在 :mod:`!"
"typing` 模組中多數的型別皆為 :term:`hashable` 且可以比較相等性。"

#: ../../library/typing.rst:719
msgid "The :data:`Any` type"
msgstr ":data:`Any` 型別"

#: ../../library/typing.rst:721
msgid ""
"A special kind of type is :data:`Any`. A static type checker will treat "
"every type as assignable to :data:`Any` and :data:`Any` as assignable to "
"every type."
msgstr ""
":data:`Any` 是一種特別的型別。靜態型別檢查器會將每個型別視為可賦值給 :data:"
"`Any`，且 :data:`Any` 也可賦值給每個型別。"

#: ../../library/typing.rst:725
msgid ""
"This means that it is possible to perform any operation or method call on a "
"value of type :data:`Any` and assign it to any variable::"
msgstr ""
"這意味著如果在一個為 :data:`Any` 的值上執行任何操作或呼叫方法是可行的，且可以"
"賦值給任意變數： ::"

#: ../../library/typing.rst:728
msgid ""
"from typing import Any\n"
"\n"
"a: Any = None\n"
"a = []          # OK\n"
"a = 2           # OK\n"
"\n"
"s: str = ''\n"
"s = a           # OK\n"
"\n"
"def foo(item: Any) -> int:\n"
"    # Passes type checking; 'item' could be any type,\n"
"    # and that type might have a 'bar' method\n"
"    item.bar()\n"
"    ..."
msgstr ""

#: ../../library/typing.rst:743
msgid ""
"Notice that no type checking is performed when assigning a value of type :"
"data:`Any` to a more precise type. For example, the static type checker did "
"not report an error when assigning ``a`` to ``s`` even though ``s`` was "
"declared to be of type :class:`str` and receives an :class:`int` value at "
"runtime!"
msgstr ""
"請注意，當賦予型別為 :data:`Any` 的值更精確的型別時，將不會執行任何型別檢查。"
"舉例來說，靜態型別檢查器不會在 runtime 中，將 ``a`` 賦值給 ``s`` 的情況下回報"
"錯誤，儘管 ``s`` 是被宣告為型別 :class:`str` 卻接收到 :class:`int` 的值！"

#: ../../library/typing.rst:749
msgid ""
"Furthermore, all functions without a return type or parameter types will "
"implicitly default to using :data:`Any`::"
msgstr "另外，所有缺少回傳型別或參數型別的函式將會隱性預設為 :data:`Any`： ::"

#: ../../library/typing.rst:752
msgid ""
"def legacy_parser(text):\n"
"    ...\n"
"    return data\n"
"\n"
"# A static type checker will treat the above\n"
"# as having the same signature as:\n"
"def legacy_parser(text: Any) -> Any:\n"
"    ...\n"
"    return data"
msgstr ""

#: ../../library/typing.rst:762
msgid ""
"This behavior allows :data:`Any` to be used as an *escape hatch* when you "
"need to mix dynamically and statically typed code."
msgstr ""
"當你需要混和動態及靜態的型別程式碼，這個行為允許 :data:`Any` 被當作一個\\ *緊"
"急出口 (escape hatch)*\\使用。"

#: ../../library/typing.rst:765
msgid ""
"Contrast the behavior of :data:`Any` with the behavior of :class:`object`. "
"Similar to :data:`Any`, every type is a subtype of :class:`object`. However, "
"unlike :data:`Any`, the reverse is not true: :class:`object` is *not* a "
"subtype of every other type."
msgstr ""
":data:`Any` 的行為對比 :class:`object` 的行為。與 :data:`Any` 相似，所有的型"
"別會作為 :class:`object` 的子型別。然而，不像 :data:`Any`，反之不亦然：:"
"class:`object` 並\\ *不是*\\一個其他型別的子型別。"

#: ../../library/typing.rst:770
msgid ""
"That means when the type of a value is :class:`object`, a type checker will "
"reject almost all operations on it, and assigning it to a variable (or using "
"it as a return value) of a more specialized type is a type error. For "
"example::"
msgstr ""
"這意味著當一個值的型別為 :class:`object` 時，型別檢查器會拒絕幾乎所有的操作，"
"並將賦予這個值到一個特定型別變數（或是當作回傳值使用）視為一個型別錯誤。舉例"
"來說： ::"

#: ../../library/typing.rst:774
msgid ""
"def hash_a(item: object) -> int:\n"
"    # Fails type checking; an object does not have a 'magic' method.\n"
"    item.magic()\n"
"    ...\n"
"\n"
"def hash_b(item: Any) -> int:\n"
"    # Passes type checking\n"
"    item.magic()\n"
"    ...\n"
"\n"
"# Passes type checking, since ints and strs are subclasses of object\n"
"hash_a(42)\n"
"hash_a(\"foo\")\n"
"\n"
"# Passes type checking, since Any is assignable to all types\n"
"hash_b(42)\n"
"hash_b(\"foo\")"
msgstr ""

#: ../../library/typing.rst:792
msgid ""
"Use :class:`object` to indicate that a value could be any type in a typesafe "
"manner. Use :data:`Any` to indicate that a value is dynamically typed."
msgstr ""
"使用 :class:`object` ，將指出在型別安全 (typesafe) 的習慣之下一個值可以為任意"
"型別。使用 :data:`Any`，將指出這個值是個動態型別。"

#: ../../library/typing.rst:797
msgid "Nominal vs structural subtyping"
msgstr "標稱 (nominal) 子型別 vs 結構子型別"

#: ../../library/typing.rst:799
msgid ""
"Initially :pep:`484` defined the Python static type system as using *nominal "
"subtyping*. This means that a class ``A`` is allowed where a class ``B`` is "
"expected if and only if ``A`` is a subclass of ``B``."
msgstr ""
"最初 :pep:`484` 定義 Python 靜態型別系統使用\\ *標稱子型別*。這意味著只有 "
"``A`` 為 ``B`` 的子類別時，``A`` 才被允許使用在預期是類別 ``B`` 出現的地方。"

#: ../../library/typing.rst:803
msgid ""
"This requirement previously also applied to abstract base classes, such as :"
"class:`~collections.abc.Iterable`. The problem with this approach is that a "
"class had to be explicitly marked to support them, which is unpythonic and "
"unlike what one would normally do in idiomatic dynamically typed Python "
"code. For example, this conforms to :pep:`484`::"
msgstr ""
"這個需求之前也被運用在抽象基底類別，例如 :class:`~collections.abc.Iterable`。"
"這種方式的問題在於，一個類別需要顯式的標記來支援他們，這並不符合 Python 風"
"格，也不像一個常見的慣用動態型別 Python 程式碼。舉例來說，下列程式碼符合 :"
"pep:`484`： ::"

#: ../../library/typing.rst:809
msgid ""
"from collections.abc import Sized, Iterable, Iterator\n"
"\n"
"class Bucket(Sized, Iterable[int]):\n"
"    ...\n"
"    def __len__(self) -> int: ...\n"
"    def __iter__(self) -> Iterator[int]: ..."
msgstr ""
"from collections.abc import Sized, Iterable, Iterator\n"
"\n"
"class Bucket(Sized, Iterable[int]):\n"
"    ...\n"
"    def __len__(self) -> int: ...\n"
"    def __iter__(self) -> Iterator[int]: ..."

#: ../../library/typing.rst:816
msgid ""
":pep:`544` solves this problem by allowing users to write the above code "
"without explicit base classes in the class definition, allowing ``Bucket`` "
"to be implicitly considered a subtype of both ``Sized`` and "
"``Iterable[int]`` by static type checkers. This is known as *structural "
"subtyping* (or static duck-typing)::"
msgstr ""
":pep:`544` 讓使用者可以撰寫上方的程式碼，且不用在類別定義中寫基底類別來解決這"
"個問題，讓 ``Bucket`` 被靜態型別檢查器隱性認為是 ``Sized`` 以及 "
"``Iterable[int]`` 兩者的子型別。這就是眾所周知的\\ *結構子型別*\\ （或是靜態"
"鴨子型別）： ::"

#: ../../library/typing.rst:822
msgid ""
"from collections.abc import Iterator, Iterable\n"
"\n"
"class Bucket:  # Note: no base classes\n"
"    ...\n"
"    def __len__(self) -> int: ...\n"
"    def __iter__(self) -> Iterator[int]: ...\n"
"\n"
"def collect(items: Iterable[int]) -> int: ...\n"
"result = collect(Bucket())  # Passes type check"
msgstr ""
"from collections.abc import Iterator, Iterable\n"
"\n"
"class Bucket:  # 注意：沒有基底類別\n"
"    ...\n"
"    def __len__(self) -> int: ...\n"
"    def __iter__(self) -> Iterator[int]: ...\n"
"\n"
"def collect(items: Iterable[int]) -> int: ...\n"
"result = collect(Bucket())  # Passes type check"

#: ../../library/typing.rst:832
msgid ""
"Moreover, by subclassing a special class :class:`Protocol`, a user can "
"define new custom protocols to fully enjoy structural subtyping (see "
"examples below)."
msgstr ""
"而且，基於一個特別的型別  :class:`Protocol` 建立子型別時，使用者可以定義新的"
"協定並充份發揮結構子型別的優勢（請見下方範例）。"

#: ../../library/typing.rst:837
msgid "Module contents"
msgstr "模組內容"

#: ../../library/typing.rst:839
msgid ""
"The ``typing`` module defines the following classes, functions and "
"decorators."
msgstr "模組 ``typing`` 定義了下列的類別、函式以及裝飾器。"

#: ../../library/typing.rst:842
msgid "Special typing primitives"
msgstr "特別型別原語 (primitive)"

#: ../../library/typing.rst:845
msgid "Special types"
msgstr "特別型別"

#: ../../library/typing.rst:847
msgid ""
"These can be used as types in annotations. They do not support subscription "
"using ``[]``."
msgstr "這些可以在註釋中做為型別。他們並不支援 ``[]`` 的下標使用。"

#: ../../library/typing.rst:852
msgid "Special type indicating an unconstrained type."
msgstr "特別型別，指出一個不受約束 (unconstrained) 的型別。"

#: ../../library/typing.rst:854
msgid "Every type is assignable to :data:`Any`."
msgstr "所有型別皆可賦值給 :data:`Any`。"

#: ../../library/typing.rst:855
msgid ":data:`Any` is assignable to every type."
msgstr ":data:`Any` 可賦值給所有型別。"

#: ../../library/typing.rst:857
msgid ""
":data:`Any` can now be used as a base class. This can be useful for avoiding "
"type checker errors with classes that can duck type anywhere or are highly "
"dynamic."
msgstr ""
":data:`Any` 可以作為一個基礎類別。這對於在任何地方使用鴨子型別或是高度動態的"
"型別，避免型別檢查器的錯誤是非常有用的。"

#: ../../library/typing.rst:864
msgid "A :ref:`constrained type variable <typing-constrained-typevar>`."
msgstr "一個\\ :ref:`不受約束的型別變數 <typing-constrained-typevar>`。"

#: ../../library/typing.rst:866
msgid "Definition::"
msgstr "定義： ::"

#: ../../library/typing.rst:868
msgid "AnyStr = TypeVar('AnyStr', str, bytes)"
msgstr "AnyStr = TypeVar('AnyStr', str, bytes)"

#: ../../library/typing.rst:870
msgid ""
"``AnyStr`` is meant to be used for functions that may accept :class:`str` "
"or :class:`bytes` arguments but cannot allow the two to mix."
msgstr ""
"``AnyStr`` 是對於函式有用的，他可以接受 :class:`str` 或 :class:`bytes` 引數但"
"不可以將此兩種混合。"

#: ../../library/typing.rst:873 ../../library/typing.rst:991
#: ../../library/typing.rst:1048 ../../library/typing.rst:1231
#: ../../library/typing.rst:1318 ../../library/typing.rst:1360
#: ../../library/typing.rst:1569 ../../library/typing.rst:1630
#: ../../library/typing.rst:3234
msgid "For example::"
msgstr "舉例來說： ::"

#: ../../library/typing.rst:875
msgid ""
"def concat(a: AnyStr, b: AnyStr) -> AnyStr:\n"
"    return a + b\n"
"\n"
"concat(\"foo\", \"bar\")    # OK, output has type 'str'\n"
"concat(b\"foo\", b\"bar\")  # OK, output has type 'bytes'\n"
"concat(\"foo\", b\"bar\")   # Error, cannot mix str and bytes"
msgstr ""

#: ../../library/typing.rst:882
msgid ""
"Note that, despite its name, ``AnyStr`` has nothing to do with the :class:"
"`Any` type, nor does it mean \"any string\". In particular, ``AnyStr`` and "
"``str | bytes`` are different from each other and have different use cases::"
msgstr ""
"請注意，儘管他的名稱相近，``AnyStr`` 與 :class:`Any` 型別無關，更不代表是「任"
"何字串」的意思。尤其，``AnyStr`` 與 ``str | bytes`` 兩者不同且具有不同的使用"
"情境： ::"

#: ../../library/typing.rst:887
msgid ""
"# Invalid use of AnyStr:\n"
"# The type variable is used only once in the function signature,\n"
"# so cannot be \"solved\" by the type checker\n"
"def greet_bad(cond: bool) -> AnyStr:\n"
"    return \"hi there!\" if cond else b\"greetings!\"\n"
"\n"
"# The better way of annotating this function:\n"
"def greet_proper(cond: bool) -> str | bytes:\n"
"    return \"hi there!\" if cond else b\"greetings!\""
msgstr ""

#: ../../library/typing.rst:897
msgid ""
"Deprecated in favor of the new :ref:`type parameter syntax <type-params>`. "
"Use ``class A[T: (str, bytes)]: ...`` instead of importing ``AnyStr``. See :"
"pep:`695` for more details."
msgstr ""

#: ../../library/typing.rst:902
msgid ""
"In Python 3.16, ``AnyStr`` will be removed from ``typing.__all__``, and "
"deprecation warnings will be emitted at runtime when it is accessed or "
"imported from ``typing``. ``AnyStr`` will be removed from ``typing`` in "
"Python 3.18."
msgstr ""

#: ../../library/typing.rst:909
msgid "Special type that includes only literal strings."
msgstr "特別型別，只包含文本字串。"

#: ../../library/typing.rst:911
msgid ""
"Any string literal is compatible with ``LiteralString``, as is another "
"``LiteralString``. However, an object typed as just ``str`` is not. A string "
"created by composing ``LiteralString``-typed objects is also acceptable as a "
"``LiteralString``."
msgstr ""
"任何文本字串都相容於 ``LiteralString``，對於另一個 ``LiteralString`` 亦是如"
"此。然而，若是一個型別僅為 ``str`` 的物件則不相容。一個字串若是透過組合多個 "
"``LiteralString`` 型別的物件建立，則此字串也可以視為 ``LiteralString``。"

#: ../../library/typing.rst:917 ../../library/typing.rst:2251
msgid "Example:"
msgstr "舉例來說： ::"

#: ../../library/typing.rst:919
msgid ""
"def run_query(sql: LiteralString) -> None:\n"
"    ...\n"
"\n"
"def caller(arbitrary_string: str, literal_string: LiteralString) -> None:\n"
"    run_query(\"SELECT * FROM students\")  # OK\n"
"    run_query(literal_string)  # OK\n"
"    run_query(\"SELECT * FROM \" + literal_string)  # OK\n"
"    run_query(arbitrary_string)  # type checker error\n"
"    run_query(  # type checker error\n"
"        f\"SELECT * FROM students WHERE name = {arbitrary_string}\"\n"
"    )"
msgstr ""
"def run_query(sql: LiteralString) -> None:\n"
"    ...\n"
"\n"
"def caller(arbitrary_string: str, literal_string: LiteralString) -> None:\n"
"    run_query(\"SELECT * FROM students\")  # OK\n"
"    run_query(literal_string)  # OK\n"
"    run_query(\"SELECT * FROM \" + literal_string)  # OK\n"
"    run_query(arbitrary_string)  # 型別檢查錯誤\n"
"    run_query(  # 型別檢查錯誤\n"
"        f\"SELECT * FROM students WHERE name = {arbitrary_string}\"\n"
"    )"

#: ../../library/typing.rst:933
msgid ""
"``LiteralString`` is useful for sensitive APIs where arbitrary user-"
"generated strings could generate problems. For example, the two cases above "
"that generate type checker errors could be vulnerable to an SQL injection "
"attack."
msgstr ""
"``LiteralString`` 對於敏感的 API 來說是有用的，其中任意的使用者產生的字串可能"
"會產生問題。舉例來說，上面兩個案例中產生的型別檢查器錯誤是脆弱的且容易受到 "
"SQL 注入攻擊。"

#: ../../library/typing.rst:938
msgid "See :pep:`675` for more details."
msgstr "更多細節請見 :pep:`675`。"

#: ../../library/typing.rst:945
msgid ""
":data:`!Never` and :data:`!NoReturn` represent the `bottom type <https://en."
"wikipedia.org/wiki/Bottom_type>`_, a type that has no members."
msgstr ""
":data:`!Never` 和 :data:`!NoReturn` 表示\\ `底部型別 (bottom type) <https://"
"en.wikipedia.org/wiki/Bottom_type>`_，為一個沒有任何成員的型別。"

#: ../../library/typing.rst:949
msgid ""
"They can be used to indicate that a function never returns, such as :func:"
"`sys.exit`::"
msgstr "它們可以被用來代表一個不會回傳的函式，像是 :func:`sys.exit`： ::"

#: ../../library/typing.rst:952
msgid ""
"from typing import Never  # or NoReturn\n"
"\n"
"def stop() -> Never:\n"
"    raise RuntimeError('no way')"
msgstr ""
"from typing import Never  # 或 NoReturn\n"
"\n"
"def stop() -> Never:\n"
"    raise RuntimeError('no way')"

#: ../../library/typing.rst:957
msgid ""
"Or to define a function that should never be called, as there are no valid "
"arguments, such as :func:`assert_never`::"
msgstr ""
"或被用來定義一個不應被呼叫的函式，因為不會有有效的引數，、像是 :func:"
"`assert_never`： ::"

#: ../../library/typing.rst:961
msgid ""
"from typing import Never  # or NoReturn\n"
"\n"
"def never_call_me(arg: Never) -> None:\n"
"    pass\n"
"\n"
"def int_or_str(arg: int | str) -> None:\n"
"    never_call_me(arg)  # type checker error\n"
"    match arg:\n"
"        case int():\n"
"            print(\"It's an int\")\n"
"        case str():\n"
"            print(\"It's a str\")\n"
"        case _:\n"
"            never_call_me(arg)  # OK, arg is of type Never (or NoReturn)"
msgstr ""

#: ../../library/typing.rst:976
msgid ""
":data:`!Never` and :data:`!NoReturn` have the same meaning in the type "
"system and static type checkers treat both equivalently."
msgstr ""
":data:`!Never` 以及 :data:`!NoReturn` 在型別系統中具有相同的意義且靜態型別檢"
"查器會將兩者視為相等。"

#: ../../library/typing.rst:981
msgid "Added :data:`NoReturn`."
msgstr "新增 :data:`NoReturn`。"

#: ../../library/typing.rst:985
msgid "Added :data:`Never`."
msgstr "新增 :data:`Never`。"

#: ../../library/typing.rst:989
msgid "Special type to represent the current enclosed class."
msgstr "特別型別，用來表示目前類別之內 (enclosed class)。"

#: ../../library/typing.rst:993
msgid ""
"from typing import Self, reveal_type\n"
"\n"
"class Foo:\n"
"    def return_self(self) -> Self:\n"
"        ...\n"
"        return self\n"
"\n"
"class SubclassOfFoo(Foo): pass\n"
"\n"
"reveal_type(Foo().return_self())  # Revealed type is \"Foo\"\n"
"reveal_type(SubclassOfFoo().return_self())  # Revealed type is "
"\"SubclassOfFoo\""
msgstr ""

#: ../../library/typing.rst:1005
msgid ""
"This annotation is semantically equivalent to the following, albeit in a "
"more succinct fashion::"
msgstr "這個註釋在語意上相等於下列內容，且形式更為簡潔： ::"

#: ../../library/typing.rst:1008
msgid ""
"from typing import TypeVar\n"
"\n"
"Self = TypeVar(\"Self\", bound=\"Foo\")\n"
"\n"
"class Foo:\n"
"    def return_self(self: Self) -> Self:\n"
"        ...\n"
"        return self"
msgstr ""
"from typing import TypeVar\n"
"\n"
"Self = TypeVar(\"Self\", bound=\"Foo\")\n"
"\n"
"class Foo:\n"
"    def return_self(self: Self) -> Self:\n"
"        ...\n"
"        return self"

#: ../../library/typing.rst:1017
msgid ""
"In general, if something returns ``self``, as in the above examples, you "
"should use ``Self`` as the return annotation. If ``Foo.return_self`` was "
"annotated as returning ``\"Foo\"``, then the type checker would infer the "
"object returned from ``SubclassOfFoo.return_self`` as being of type ``Foo`` "
"rather than ``SubclassOfFoo``."
msgstr ""
"一般來說，如果某個東西回傳 ``self`` 如上方的範例所示，你則應該使用 ``Self`` "
"做為回傳值的註釋。若 ``Foo.return_self`` 被註釋為回傳 ``\"Foo\"``，則型別檢查"
"器應該推論這個從 ``SubclassOfFoo.return_self`` 回傳的物件為 ``Foo`` 型別，而"
"並非回傳 ``SubclassOfFoo`` 型別。"

#: ../../library/typing.rst:1023
msgid "Other common use cases include:"
msgstr "其他常見的使用案例包含： ::"

#: ../../library/typing.rst:1025
msgid ""
":class:`classmethod`\\s that are used as alternative constructors and return "
"instances of the ``cls`` parameter."
msgstr ""
":class:`classmethod` 被用來作為替代的建構函式 (constructor) 並回傳 ``cls`` 參"
"數的實例。"

#: ../../library/typing.rst:1027
msgid "Annotating an :meth:`~object.__enter__` method which returns self."
msgstr "註釋一個回傳自己的 :meth:`~object.__enter__` 方法。"

#: ../../library/typing.rst:1029
msgid ""
"You should not use ``Self`` as the return annotation if the method is not "
"guaranteed to return an instance of a subclass when the class is subclassed::"
msgstr ""
"當類別被子類別化時，若方法不保證回傳一個子類別的實例，你不應該使用 ``Self`` "
"作為回傳註釋： ::"

#: ../../library/typing.rst:1033
msgid ""
"class Eggs:\n"
"    # Self would be an incorrect return annotation here,\n"
"    # as the object returned is always an instance of Eggs,\n"
"    # even in subclasses\n"
"    def returns_eggs(self) -> \"Eggs\":\n"
"        return Eggs()"
msgstr ""

#: ../../library/typing.rst:1040
msgid "See :pep:`673` for more details."
msgstr "更多細節請見 :pep:`673`。"

#: ../../library/typing.rst:1046
msgid ""
"Special annotation for explicitly declaring a :ref:`type alias <type-"
"aliases>`."
msgstr "做為明確宣告一個\\ :ref:`型別別名 <type-aliases>` 的特別註釋。"

#: ../../library/typing.rst:1050
msgid ""
"from typing import TypeAlias\n"
"\n"
"Factors: TypeAlias = list[int]"
msgstr ""
"from typing import TypeAlias\n"
"\n"
"Factors: TypeAlias = list[int]"

#: ../../library/typing.rst:1054
msgid ""
"``TypeAlias`` is particularly useful on older Python versions for annotating "
"aliases that make use of forward references, as it can be hard for type "
"checkers to distinguish these from normal variable assignments:"
msgstr ""
"``TypeAlias`` 在舊的 Python 版本中特別有用，其註釋別名可以用來進行傳遞參照 "
"(forward reference)，因為對於型別檢查器來說，分辨這些別名與一般的變數賦值相當"
"困難： ::"

#: ../../library/typing.rst:1058
msgid ""
"from typing import Generic, TypeAlias, TypeVar\n"
"\n"
"T = TypeVar(\"T\")\n"
"\n"
"# \"Box\" does not exist yet,\n"
"# so we have to use quotes for the forward reference on Python <3.12.\n"
"# Using ``TypeAlias`` tells the type checker that this is a type alias "
"declaration,\n"
"# not a variable assignment to a string.\n"
"BoxOfStrings: TypeAlias = \"Box[str]\"\n"
"\n"
"class Box(Generic[T]):\n"
"    @classmethod\n"
"    def make_box_of_strings(cls) -> BoxOfStrings: ..."
msgstr ""

#: ../../library/typing.rst:1074
msgid "See :pep:`613` for more details."
msgstr "更多細節請見 :pep:`613`。"

#: ../../library/typing.rst:1078
msgid ""
":data:`TypeAlias` is deprecated in favor of the :keyword:`type` statement, "
"which creates instances of :class:`TypeAliasType` and which natively "
"supports forward references. Note that while :data:`TypeAlias` and :class:"
"`TypeAliasType` serve similar purposes and have similar names, they are "
"distinct and the latter is not the type of the former. Removal of :data:"
"`TypeAlias` is not currently planned, but users are encouraged to migrate "
"to :keyword:`type` statements."
msgstr ""
":data:`TypeAlias` 被棄用，請改用 :keyword:`type` 陳述式來建立 :class:"
"`TypeAliasType` 的實例，其自然可以支援傳遞參照的使用。請注意，雖然 :data:"
"`TypeAlias` 以及 :class:`TypeAliasType` 提供相似的用途且具有相似的名稱，他們"
"是不同的，且後者不是前者的型別。現在還沒有移除 :data:`TypeAlias` 的計畫，但鼓"
"勵使用者們遷移 (migrate) 至 :keyword:`type` 陳述式。"

#: ../../library/typing.rst:1089
msgid "Special forms"
msgstr "特別型式"

#: ../../library/typing.rst:1091
msgid ""
"These can be used as types in annotations. They all support subscription "
"using ``[]``, but each has a unique syntax."
msgstr ""
"這些在註釋中可以當作型別使用。他們全都支援 ``[]`` 的下標使用，但每個都具有獨"
"特的語法。"

#: ../../library/typing.rst:1096
msgid ""
"Union type; ``Union[X, Y]`` is equivalent to ``X | Y`` and means either X or "
"Y."
msgstr ""
"聯集型別；``Union[X, Y]`` 與 ``X | Y`` 是相等的，且都意味著 X 或 Y 兩者其一。"

#: ../../library/typing.rst:1098
msgid ""
"To define a union, use e.g. ``Union[int, str]`` or the shorthand ``int | "
"str``. Using that shorthand is recommended. Details:"
msgstr ""
"為了定義聯集，例如可以使用 ``Union[int, str]`` 或是使用簡寫 (shorthand) "
"``int | str``。使用這種簡寫是非常推薦的。詳細請看： ::"

#: ../../library/typing.rst:1100
msgid "The arguments must be types and there must be at least one."
msgstr "引數必須為型別且必須有至少一個。"

#: ../../library/typing.rst:1102
msgid "Unions of unions are flattened, e.g.::"
msgstr "聯集中的聯集會是扁平化的 (flattened)，舉例來說： ::"

#: ../../library/typing.rst:1104
msgid "Union[Union[int, str], float] == Union[int, str, float]"
msgstr "Union[Union[int, str], float] == Union[int, str, float]"

#: ../../library/typing.rst:1106
msgid ""
"However, this does not apply to unions referenced through a type alias, to "
"avoid forcing evaluation of the underlying :class:`TypeAliasType`::"
msgstr ""

#: ../../library/typing.rst:1109
msgid ""
"type A = Union[int, str]\n"
"Union[A, float] != Union[int, str, float]"
msgstr ""
"type A = Union[int, str]\n"
"Union[A, float] != Union[int, str, float]"

#: ../../library/typing.rst:1112
msgid "Unions of a single argument vanish, e.g.::"
msgstr "單一引數的聯集會消失不見，舉例來說： ::"

#: ../../library/typing.rst:1114
msgid "Union[int] == int  # The constructor actually returns int"
msgstr "Union[int] == int  # 實際上建構函式會回傳 int"

#: ../../library/typing.rst:1116 ../../library/typing.rst:1261
msgid "Redundant arguments are skipped, e.g.::"
msgstr "多餘的引數會被略過，舉例來說： ::"

#: ../../library/typing.rst:1118
msgid "Union[int, str, int] == Union[int, str] == int | str"
msgstr "Union[int, str, int] == Union[int, str] == int | str"

#: ../../library/typing.rst:1120
msgid "When comparing unions, the argument order is ignored, e.g.::"
msgstr "當比較聯集時，引數的順序會被忽略，舉例來說： ::"

#: ../../library/typing.rst:1122
msgid "Union[int, str] == Union[str, int]"
msgstr "Union[int, str] == Union[str, int]"

#: ../../library/typing.rst:1124
msgid "You cannot subclass or instantiate a ``Union``."
msgstr "你不能建立 ``Union`` 的子類別或是實例。"

#: ../../library/typing.rst:1126
msgid "You cannot write ``Union[X][Y]``."
msgstr "你不能寫成 ``Union[X][Y]``。"

#: ../../library/typing.rst:1128
msgid "Don't remove explicit subclasses from unions at runtime."
msgstr "請勿在 runtime 中將顯性子類別從聯集中移除。"

#: ../../library/typing.rst:1131
msgid ""
"Unions can now be written as ``X | Y``. See :ref:`union type "
"expressions<types-union>`."
msgstr ""
"現在可以將聯集寫成 ``X | Y``。請見\\ :ref:`聯集型別運算式 <types-union>`。"

#: ../../library/typing.rst:1135
msgid ""
":class:`types.UnionType` is now an alias for :class:`Union`, and both "
"``Union[int, str]`` and ``int | str`` create instances of the same class. To "
"check whether an object is a ``Union`` at runtime, use ``isinstance(obj, "
"Union)``. For compatibility with earlier versions of Python, use "
"``get_origin(obj) is typing.Union or get_origin(obj) is types.UnionType``."
msgstr ""

#: ../../library/typing.rst:1145
msgid "``Optional[X]`` is equivalent to ``X | None`` (or ``Union[X, None]``)."
msgstr "``Optional[X]`` 與 ``X | None`` 是相等的（或是 ``Union[X, None]``）。"

#: ../../library/typing.rst:1147
msgid ""
"Note that this is not the same concept as an optional argument, which is one "
"that has a default.  An optional argument with a default does not require "
"the ``Optional`` qualifier on its type annotation just because it is "
"optional. For example::"
msgstr ""
"請注意，這與具有預設值的選擇性引數 (optional argument) 不是相同的概念。一個具"
"有預設值的選擇性引數的型別註釋中不具有 ``Optional`` 限定符 (qualifier)，單純"
"的因為它就是選擇性的。舉例來說： ::"

#: ../../library/typing.rst:1152
msgid ""
"def foo(arg: int = 0) -> None:\n"
"    ..."
msgstr ""
"def foo(arg: int = 0) -> None:\n"
"    ..."

#: ../../library/typing.rst:1155
msgid ""
"On the other hand, if an explicit value of ``None`` is allowed, the use of "
"``Optional`` is appropriate, whether the argument is optional or not. For "
"example::"
msgstr ""
"另一方面，如果一個顯性的值 ``None`` 是被允許的，不論引數是不是選擇性的，"
"``Optional`` 都適用。舉例來說： ::"

#: ../../library/typing.rst:1159
msgid ""
"def foo(arg: Optional[int] = None) -> None:\n"
"    ..."
msgstr ""
"def foo(arg: Optional[int] = None) -> None:\n"
"    ..."

#: ../../library/typing.rst:1162
msgid ""
"Optional can now be written as ``X | None``. See :ref:`union type "
"expressions<types-union>`."
msgstr ""
"現在可以將 Optional 寫成 ``X | None``。請見\\ :ref:`聯集型別運算式 <types-"
"union>`。"

#: ../../library/typing.rst:1168
msgid "Special form for annotating higher-order functions."
msgstr "用於註釋高階函式的特別型式。"

#: ../../library/typing.rst:1172
msgid ""
"``Concatenate`` can be used in conjunction with :ref:`Callable <annotating-"
"callables>` and :class:`ParamSpec` to annotate a higher-order callable which "
"adds, removes, or transforms parameters of another callable.  Usage is in "
"the form ``Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]``. "
"``Concatenate`` is valid when used in :ref:`Callable <annotating-callables>` "
"type hints and when instantiating user-defined generic classes with :class:"
"`ParamSpec` parameters. The last parameter to ``Concatenate`` must be a :"
"class:`ParamSpec` or ellipsis (``...``)."
msgstr ""
"``Concatenate`` 可以被用在\\ :ref:`可呼叫物件 <annotating-callables>`\\ 與 :"
"class:`ParamSpec` 的接合 (conjunction) 並註釋一個高階的 Callable 物件可以新"
"增、移除、轉換另一個 Callable 物件的參數。使用方法是依照這個格式 "
"``Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]``。``Concatenate`` "
"可用於 :ref:`Callable <annotating-callables>` 型別提示中，也可在使用 :class:"
"`ParamSpec` 參數實例化使用者自訂泛型類別時使用。``Concatenate`` 的最後一個參"
"數必須為一個 :class:`ParamSpec` 或是刪節號 (``...``)。"

#: ../../library/typing.rst:1182
msgid ""
"For example, to annotate a decorator ``with_lock`` which provides a :class:"
"`threading.Lock` to the decorated function,  ``Concatenate`` can be used to "
"indicate that ``with_lock`` expects a callable which takes in a ``Lock`` as "
"the first argument, and returns a callable with a different type signature.  "
"In this case, the :class:`ParamSpec` indicates that the returned callable's "
"parameter types are dependent on the parameter types of the callable being "
"passed in::"
msgstr ""
"舉例來說，註釋一個為裝飾過後的函式提供 :class:`threading.Lock` 的裝飾器 "
"``with_lock``，``Concatenate`` 可以用於指出 ``with_lock`` 預期一個 Callable "
"物件，該物件可以接受 ``Lock`` 作為第一引數，並回傳一個具有不同型別簽名 "
"Callable 物件。在這種情況下，:class:`ParamSpec` 指出回傳的 Callable 物件的參"
"數型別會依賴傳遞的 Callable 物件的參數型別： ::"

#: ../../library/typing.rst:1190
msgid ""
"from collections.abc import Callable\n"
"from threading import Lock\n"
"from typing import Concatenate\n"
"\n"
"# Use this lock to ensure that only one thread is executing a function\n"
"# at any time.\n"
"my_lock = Lock()\n"
"\n"
"def with_lock[**P, R](f: Callable[Concatenate[Lock, P], R]) -> Callable[P, "
"R]:\n"
"    '''A type-safe decorator which provides a lock.'''\n"
"    def inner(*args: P.args, **kwargs: P.kwargs) -> R:\n"
"        # Provide the lock as the first argument.\n"
"        return f(my_lock, *args, **kwargs)\n"
"    return inner\n"
"\n"
"@with_lock\n"
"def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:\n"
"    '''Add a list of numbers together in a thread-safe manner.'''\n"
"    with lock:\n"
"        return sum(numbers)\n"
"\n"
"# We don't need to pass in the lock ourselves thanks to the decorator.\n"
"sum_threadsafe([1.1, 2.2, 3.3])"
msgstr ""

#: ../../library/typing.rst:1218 ../../library/typing.rst:2219
msgid ""
":pep:`612` -- Parameter Specification Variables (the PEP which introduced "
"``ParamSpec`` and ``Concatenate``)"
msgstr ":pep:`612` -- 參數技術規範變數"

#: ../../library/typing.rst:1220
msgid ":class:`ParamSpec`"
msgstr ":class:`ParamSpec`"

#: ../../library/typing.rst:1221 ../../library/typing.rst:2222
msgid ":ref:`annotating-callables`"
msgstr ":ref:`annotating-callables`"

#: ../../library/typing.rst:1225
msgid "Special typing form to define \"literal types\"."
msgstr "特殊型別格式，用於定義「文本型別 (literal type)」。"

#: ../../library/typing.rst:1227
msgid ""
"``Literal`` can be used to indicate to type checkers that the annotated "
"object has a value equivalent to one of the provided literals."
msgstr ""
"``Literal`` 可以用於型別檢查器並指出註釋物件具有一個與提供的文本相同的值。"

#: ../../library/typing.rst:1233
msgid ""
"def validate_simple(data: Any) -> Literal[True]:  # always returns True\n"
"    ...\n"
"\n"
"type Mode = Literal['r', 'rb', 'w', 'wb']\n"
"def open_helper(file: str, mode: Mode) -> str:\n"
"    ...\n"
"\n"
"open_helper('/some/path', 'r')      # Passes type check\n"
"open_helper('/other/path', 'typo')  # Error in type checker"
msgstr ""
"def validate_simple(data: Any) -> Literal[True]:  # 永遠回傳 True\n"
"    ...\n"
"\n"
"type Mode = Literal['r', 'rb', 'w', 'wb']\n"
"def open_helper(file: str, mode: Mode) -> str:\n"
"    ...\n"
"\n"
"open_helper('/some/path', 'r')      # 通過型別檢查\n"
"open_helper('/other/path', 'typo')  # 型別檢查器中的錯誤"

#: ../../library/typing.rst:1243
msgid ""
"``Literal[...]`` cannot be subclassed. At runtime, an arbitrary value is "
"allowed as type argument to ``Literal[...]``, but type checkers may impose "
"restrictions. See :pep:`586` for more details about literal types."
msgstr ""
"``Literal[...]`` 不可以進行子類別化。在 runtime 之中，任意的值是允許作為 "
"``Literal[...]`` 的型別引數，但型別檢查器可能會加強限制。更多有關文本型別的詳"
"細資訊請看 :pep:`586`。"

#: ../../library/typing.rst:1247
msgid "Additional details:"
msgstr "其他細節："

#: ../../library/typing.rst:1249
msgid "The arguments must be literal values and there must be at least one."
msgstr "引數必須為文本值且必須有至少一個。"

#: ../../library/typing.rst:1251
msgid "Nested ``Literal`` types are flattened, e.g.::"
msgstr "巢狀的 ``Literal`` 會是扁平化的 (flattened)，舉例來說： ::"

#: ../../library/typing.rst:1253
msgid "assert Literal[Literal[1, 2], 3] == Literal[1, 2, 3]"
msgstr "assert Literal[Literal[1, 2], 3] == Literal[1, 2, 3]"

#: ../../library/typing.rst:1255
msgid ""
"However, this does not apply to ``Literal`` types referenced through a type "
"alias, to avoid forcing evaluation of the underlying :class:`TypeAliasType`::"
msgstr ""

#: ../../library/typing.rst:1258
msgid ""
"type A = Literal[1, 2]\n"
"assert Literal[A, 3] != Literal[1, 2, 3]"
msgstr ""
"type A = Literal[1, 2]\n"
"assert Literal[A, 3] != Literal[1, 2, 3]"

#: ../../library/typing.rst:1263
msgid "assert Literal[1, 2, 1] == Literal[1, 2]"
msgstr "assert Literal[1, 2, 1] == Literal[1, 2]"

#: ../../library/typing.rst:1265
msgid "When comparing literals, the argument order is ignored, e.g.::"
msgstr "當比較文本時，引數的順序會被忽略，舉例來說： ::"

#: ../../library/typing.rst:1267
msgid "assert Literal[1, 2] == Literal[2, 1]"
msgstr "assert Literal[1, 2] == Literal[2, 1]"

#: ../../library/typing.rst:1269
msgid "You cannot subclass or instantiate a ``Literal``."
msgstr "你不能建立 ``Literal`` 的子類別或是實例。"

#: ../../library/typing.rst:1271
msgid "You cannot write ``Literal[X][Y]``."
msgstr "你不能寫成 ``Literal[X][Y]``。"

#: ../../library/typing.rst:1275
msgid ""
"``Literal`` now de-duplicates parameters.  Equality comparisons of "
"``Literal`` objects are no longer order dependent. ``Literal`` objects will "
"now raise a :exc:`TypeError` exception during equality comparisons if one of "
"their parameters are not :term:`hashable`."
msgstr ""
"``Literal`` 現在可以刪除重複 (de-deplicate) 的參數。``Literal`` 物件的相等性"
"比較不再依照相依性排序。``Literal`` 物件現在會在相等性比較期間，若任一個其中"
"的參數無法 :term:`hashable` 時，則會引發一個 :exc:`TypeError` 例外。"

#: ../../library/typing.rst:1283
msgid "Special type construct to mark class variables."
msgstr "特殊型別建構，用來標記類別變數。"

#: ../../library/typing.rst:1285
msgid ""
"As introduced in :pep:`526`, a variable annotation wrapped in ClassVar "
"indicates that a given attribute is intended to be used as a class variable "
"and should not be set on instances of that class. Usage::"
msgstr ""
"如同在 :pep:`526` 中的介紹，一個變數註解被包裝在 ClassVar 中時，會指出一個給"
"定的屬性 (attribute) 意圖被當作類別變數使用，且不該被設定成該類別的實例。使用"
"方法如下： ::"

#: ../../library/typing.rst:1289
msgid ""
"class Starship:\n"
"    stats: ClassVar[dict[str, int]] = {} # class variable\n"
"    damage: int = 10                     # instance variable"
msgstr ""
"class Starship:\n"
"    stats: ClassVar[dict[str, int]] = {} # 類別變數\n"
"    damage: int = 10                     # 實例變數"

#: ../../library/typing.rst:1293
msgid ":data:`ClassVar` accepts only types and cannot be further subscribed."
msgstr ":data:`ClassVar` 只接受型別請不得使用下標。"

#: ../../library/typing.rst:1295
msgid ""
":data:`ClassVar` is not a class itself, and cannot be used with :func:"
"`isinstance` or :func:`issubclass`. :data:`ClassVar` does not change Python "
"runtime behavior, but it can be used by static type checkers. For example, a "
"type checker might flag the following code as an error::"
msgstr ""
":data:`ClassVar` 並不代表該類別本身，而且不能和 :func:`isinstance` 或是 :"
"func:`issubclass` 一起使用。:data:`ClassVar` 不會改變 Python runtime 的行為，"
"但它可以被靜態型別檢查器使用。舉例來說，一個型別檢查器可能會標記下方的程式碼"
"為一個錯誤： ::"

#: ../../library/typing.rst:1301
msgid ""
"enterprise_d = Starship(3000)\n"
"enterprise_d.stats = {} # Error, setting class variable on instance\n"
"Starship.stats = {}     # This is OK"
msgstr ""

#: ../../library/typing.rst:1309
msgid ":data:`ClassVar` can now be nested in :data:`Final` and vice versa."
msgstr ""

#: ../../library/typing.rst:1313
msgid "Special typing construct to indicate final names to type checkers."
msgstr "特殊型別建構，用來指出給型別檢查器的最終名稱。"

#: ../../library/typing.rst:1315
msgid ""
"Final names cannot be reassigned in any scope. Final names declared in class "
"scopes cannot be overridden in subclasses."
msgstr ""
"最終名稱不可以在任何作用域 (scope) 中重新賦值。在類別作用域中宣告的最終名稱，"
"不得在子類別中進行覆寫 (override)。"

#: ../../library/typing.rst:1320
msgid ""
"MAX_SIZE: Final = 9000\n"
"MAX_SIZE += 1  # Error reported by type checker\n"
"\n"
"class Connection:\n"
"    TIMEOUT: Final[int] = 10\n"
"\n"
"class FastConnector(Connection):\n"
"    TIMEOUT = 1  # Error reported by type checker"
msgstr ""

#: ../../library/typing.rst:1329 ../../library/typing.rst:3250
msgid ""
"There is no runtime checking of these properties. See :pep:`591` for more "
"details."
msgstr ""
"這些屬性 (property) 不會在 runtime 時進行檢查。更多詳細資訊請看 :pep:`591`。"

#: ../../library/typing.rst:1336
msgid ":data:`Final` can now be nested in :data:`ClassVar` and vice versa."
msgstr ""

#: ../../library/typing.rst:1340
msgid "Special typing construct to mark a :class:`TypedDict` key as required."
msgstr "特殊型別建構，用來標記一個 :class:`TypedDict` 鍵值是必須的。"

#: ../../library/typing.rst:1342
msgid ""
"This is mainly useful for ``total=False`` TypedDicts. See :class:`TypedDict` "
"and :pep:`655` for more details."
msgstr ""
"主要用於 ``total=False`` 的 TypedDict。更多細節請見 :class:`TypedDict` 與 :"
"pep:`655`。"

#: ../../library/typing.rst:1349
msgid ""
"Special typing construct to mark a :class:`TypedDict` key as potentially "
"missing."
msgstr "特殊型別建構，用來標記一個 :class:`TypedDict` 鍵值是可能消失的。"

#: ../../library/typing.rst:1352
msgid "See :class:`TypedDict` and :pep:`655` for more details."
msgstr "更多細節請見 :class:`TypedDict` 與 :pep:`655`。"

#: ../../library/typing.rst:1358
msgid ""
"A special typing construct to mark an item of a :class:`TypedDict` as read-"
"only."
msgstr "特殊型別建構，用來標記一個 :class:`TypedDict` 的項目是唯讀的。"

#: ../../library/typing.rst:1362
msgid ""
"class Movie(TypedDict):\n"
"   title: ReadOnly[str]\n"
"   year: int\n"
"\n"
"def mutate_movie(m: Movie) -> None:\n"
"   m[\"year\"] = 1999  # allowed\n"
"   m[\"title\"] = \"The Matrix\"  # type checker error"
msgstr ""
"class Movie(TypedDict):\n"
"   title: ReadOnly[str]\n"
"   year: int\n"
"\n"
"def mutate_movie(m: Movie) -> None:\n"
"   m[\"year\"] = 1999  # allowed\n"
"   m[\"title\"] = \"The Matrix\"  # 型別檢查器錯誤"

#: ../../library/typing.rst:1370
msgid "There is no runtime checking for this property."
msgstr "這些屬性 (property) 不會在 runtime 時進行檢查。"

#: ../../library/typing.rst:1372
msgid "See :class:`TypedDict` and :pep:`705` for more details."
msgstr "更多細節請見 :class:`TypedDict` 與 :pep:`705`。"

#: ../../library/typing.rst:1378
msgid "Special typing form to add context-specific metadata to an annotation."
msgstr ""

#: ../../library/typing.rst:1380
msgid ""
"Add metadata ``x`` to a given type ``T`` by using the annotation "
"``Annotated[T, x]``. Metadata added using ``Annotated`` can be used by "
"static analysis tools or at runtime. At runtime, the metadata is stored in "
"a :attr:`!__metadata__` attribute."
msgstr ""

#: ../../library/typing.rst:1385
msgid ""
"If a library or tool encounters an annotation ``Annotated[T, x]`` and has no "
"special logic for the metadata, it should ignore the metadata and simply "
"treat the annotation as ``T``. As such, ``Annotated`` can be useful for code "
"that wants to use annotations for purposes outside Python's static typing "
"system."
msgstr ""

#: ../../library/typing.rst:1391
msgid ""
"Using ``Annotated[T, x]`` as an annotation still allows for static "
"typechecking of ``T``, as type checkers will simply ignore the metadata "
"``x``. In this way, ``Annotated`` differs from the :deco:`no_type_check` "
"decorator, which can also be used for adding annotations outside the scope "
"of the typing system, but completely disables typechecking for a function or "
"class."
msgstr ""

#: ../../library/typing.rst:1398
msgid ""
"The responsibility of how to interpret the metadata lies with the tool or "
"library encountering an ``Annotated`` annotation. A tool or library "
"encountering an ``Annotated`` type can scan through the metadata elements to "
"determine if they are of interest (e.g., using :func:`isinstance`)."
msgstr ""

#: ../../library/typing.rst:1406
msgid ""
"Here is an example of how you might use ``Annotated`` to add metadata to "
"type annotations if you were doing range analysis:"
msgstr ""

#: ../../library/typing.rst:1409
msgid ""
"@dataclass\n"
"class ValueRange:\n"
"    lo: int\n"
"    hi: int\n"
"\n"
"T1 = Annotated[int, ValueRange(-10, 5)]\n"
"T2 = Annotated[T1, ValueRange(-20, 3)]"
msgstr ""
"@dataclass\n"
"class ValueRange:\n"
"    lo: int\n"
"    hi: int\n"
"\n"
"T1 = Annotated[int, ValueRange(-10, 5)]\n"
"T2 = Annotated[T1, ValueRange(-20, 3)]"

#: ../../library/typing.rst:1419
msgid ""
"The first argument to ``Annotated`` must be a valid type. Multiple metadata "
"elements can be supplied as ``Annotated`` supports variadic arguments. The "
"order of the metadata elements is preserved and matters for equality checks::"
msgstr ""

#: ../../library/typing.rst:1423
msgid ""
"@dataclass\n"
"class ctype:\n"
"     kind: str\n"
"\n"
"a1 = Annotated[int, ValueRange(3, 10), ctype(\"char\")]\n"
"a2 = Annotated[int, ctype(\"char\"), ValueRange(3, 10)]\n"
"\n"
"assert a1 != a2  # Order matters"
msgstr ""
"@dataclass\n"
"class ctype:\n"
"     kind: str\n"
"\n"
"a1 = Annotated[int, ValueRange(3, 10), ctype(\"char\")]\n"
"a2 = Annotated[int, ctype(\"char\"), ValueRange(3, 10)]\n"
"\n"
"assert a1 != a2  # 順序是有意義的"

#: ../../library/typing.rst:1432
msgid ""
"It is up to the tool consuming the annotations to decide whether the client "
"is allowed to add multiple metadata elements to one annotation and how to "
"merge those annotations."
msgstr ""

#: ../../library/typing.rst:1436
msgid ""
"Nested ``Annotated`` types are flattened. The order of the metadata elements "
"starts with the innermost annotation::"
msgstr ""

#: ../../library/typing.rst:1439
msgid ""
"assert Annotated[Annotated[int, ValueRange(3, 10)], ctype(\"char\")] == "
"Annotated[\n"
"    int, ValueRange(3, 10), ctype(\"char\")\n"
"]"
msgstr ""
"assert Annotated[Annotated[int, ValueRange(3, 10)], ctype(\"char\")] == "
"Annotated[\n"
"    int, ValueRange(3, 10), ctype(\"char\")\n"
"]"

#: ../../library/typing.rst:1443
msgid ""
"However, this does not apply to ``Annotated`` types referenced through a "
"type alias, to avoid forcing evaluation of the underlying :class:"
"`TypeAliasType`::"
msgstr ""

#: ../../library/typing.rst:1446
msgid ""
"type From3To10[T] = Annotated[T, ValueRange(3, 10)]\n"
"assert Annotated[From3To10[int], ctype(\"char\")] != Annotated[\n"
"   int, ValueRange(3, 10), ctype(\"char\")\n"
"]"
msgstr ""
"type From3To10[T] = Annotated[T, ValueRange(3, 10)]\n"
"assert Annotated[From3To10[int], ctype(\"char\")] != Annotated[\n"
"   int, ValueRange(3, 10), ctype(\"char\")\n"
"]"

#: ../../library/typing.rst:1451
msgid "Duplicated metadata elements are not removed::"
msgstr ""

#: ../../library/typing.rst:1453
msgid ""
"assert Annotated[int, ValueRange(3, 10)] != Annotated[\n"
"    int, ValueRange(3, 10), ValueRange(3, 10)\n"
"]"
msgstr ""
"assert Annotated[int, ValueRange(3, 10)] != Annotated[\n"
"    int, ValueRange(3, 10), ValueRange(3, 10)\n"
"]"

#: ../../library/typing.rst:1457
msgid "``Annotated`` can be used with nested and generic aliases:"
msgstr ""

#: ../../library/typing.rst:1459
msgid ""
"@dataclass\n"
"class MaxLen:\n"
"    value: int\n"
"\n"
"type Vec[T] = Annotated[list[tuple[T, T]], MaxLen(10)]\n"
"\n"
"# When used in a type annotation, a type checker will treat \"V\" the same "
"as\n"
"# ``Annotated[list[tuple[int, int]], MaxLen(10)]``:\n"
"type V = Vec[int]"
msgstr ""

#: ../../library/typing.rst:1471
msgid "``Annotated`` cannot be used with an unpacked :class:`TypeVarTuple`::"
msgstr ""

#: ../../library/typing.rst:1473
msgid ""
"type Variadic[*Ts] = Annotated[*Ts, Ann1] = Annotated[T1, T2, T3, ..., "
"Ann1]  # NOT valid"
msgstr ""
"type Variadic[*Ts] = Annotated[*Ts, Ann1] = Annotated[T1, T2, T3, ..., "
"Ann1]  # 無效"

#: ../../library/typing.rst:1475
msgid ""
"where ``T1``, ``T2``, ... are :class:`TypeVars <TypeVar>`. This is invalid "
"as only one type should be passed to Annotated."
msgstr ""

#: ../../library/typing.rst:1478
msgid ""
"By default, :func:`get_type_hints` strips the metadata from annotations. "
"Pass ``include_extras=True`` to have the metadata preserved:"
msgstr ""

#: ../../library/typing.rst:1481
msgid ""
">>> from typing import Annotated, get_type_hints\n"
">>> def func(x: Annotated[int, \"metadata\"]) -> None: pass\n"
"...\n"
">>> get_type_hints(func)\n"
"{'x': <class 'int'>, 'return': <class 'NoneType'>}\n"
">>> get_type_hints(func, include_extras=True)\n"
"{'x': typing.Annotated[int, 'metadata'], 'return': <class 'NoneType'>}"
msgstr ""
">>> from typing import Annotated, get_type_hints\n"
">>> def func(x: Annotated[int, \"metadata\"]) -> None: pass\n"
"...\n"
">>> get_type_hints(func)\n"
"{'x': <class 'int'>, 'return': <class 'NoneType'>}\n"
">>> get_type_hints(func, include_extras=True)\n"
"{'x': typing.Annotated[int, 'metadata'], 'return': <class 'NoneType'>}"

#: ../../library/typing.rst:1491
msgid ""
"At runtime, the metadata associated with an ``Annotated`` type can be "
"retrieved via the :attr:`!__metadata__` attribute:"
msgstr ""

#: ../../library/typing.rst:1494
msgid ""
">>> from typing import Annotated\n"
">>> X = Annotated[int, \"very\", \"important\", \"metadata\"]\n"
">>> X\n"
"typing.Annotated[int, 'very', 'important', 'metadata']\n"
">>> X.__metadata__\n"
"('very', 'important', 'metadata')"
msgstr ""
">>> from typing import Annotated\n"
">>> X = Annotated[int, \"very\", \"important\", \"metadata\"]\n"
">>> X\n"
"typing.Annotated[int, 'very', 'important', 'metadata']\n"
">>> X.__metadata__\n"
"('very', 'important', 'metadata')"

#: ../../library/typing.rst:1503
msgid ""
"If you want to retrieve the original type wrapped by ``Annotated``, use the :"
"attr:`!__origin__` attribute:"
msgstr ""

#: ../../library/typing.rst:1506
msgid ""
">>> from typing import Annotated, get_origin\n"
">>> Password = Annotated[str, \"secret\"]\n"
">>> Password.__origin__\n"
"<class 'str'>"
msgstr ""
">>> from typing import Annotated, get_origin\n"
">>> Password = Annotated[str, \"secret\"]\n"
">>> Password.__origin__\n"
"<class 'str'>"

#: ../../library/typing.rst:1513
msgid "Note that using :func:`get_origin` will return ``Annotated`` itself:"
msgstr ""

#: ../../library/typing.rst:1515
msgid ""
">>> get_origin(Password)\n"
"typing.Annotated"
msgstr ""
">>> get_origin(Password)\n"
"typing.Annotated"

#: ../../library/typing.rst:1522
msgid ":pep:`593` - Flexible function and variable annotations"
msgstr ""

#: ../../library/typing.rst:1523
msgid "The PEP introducing ``Annotated`` to the standard library."
msgstr ""

#: ../../library/typing.rst:1530 ../../library/typing.rst:1614
msgid ""
"Special typing construct for marking user-defined type predicate functions."
msgstr ""

#: ../../library/typing.rst:1532
msgid ""
"``TypeIs`` can be used to annotate the return type of a user-defined type "
"predicate function.  ``TypeIs`` only accepts a single type argument. At "
"runtime, functions marked this way should return a boolean and take at least "
"one positional argument."
msgstr ""

#: ../../library/typing.rst:1537
msgid ""
"``TypeIs`` aims to benefit *type narrowing* -- a technique used by static "
"type checkers to determine a more precise type of an expression within a "
"program's code flow.  Usually type narrowing is done by analyzing "
"conditional code flow and applying the narrowing to a block of code.  The "
"conditional expression here is sometimes referred to as a \"type "
"predicate\"::"
msgstr ""

#: ../../library/typing.rst:1543
msgid ""
"def is_str(val: str | float):\n"
"    # \"isinstance\" type predicate\n"
"    if isinstance(val, str):\n"
"        # Type of ``val`` is narrowed to ``str``\n"
"        ...\n"
"    else:\n"
"        # Else, type of ``val`` is narrowed to ``float``.\n"
"        ..."
msgstr ""

#: ../../library/typing.rst:1552
msgid ""
"Sometimes it would be convenient to use a user-defined boolean function as a "
"type predicate.  Such a function should use ``TypeIs[...]`` or :data:"
"`TypeGuard` as its return type to alert static type checkers to this "
"intention.  ``TypeIs`` usually has more intuitive behavior than "
"``TypeGuard``, but it cannot be used when the input and output types are "
"incompatible (e.g., ``list[object]`` to ``list[int]``) or when the function "
"does not return ``True`` for all instances of the narrowed type."
msgstr ""

#: ../../library/typing.rst:1560
msgid ""
"Using  ``-> TypeIs[NarrowedType]`` tells the static type checker that for a "
"given function:"
msgstr ""

#: ../../library/typing.rst:1563 ../../library/typing.rst:1624
msgid "The return value is a boolean."
msgstr "回傳值是一個布林值。"

#: ../../library/typing.rst:1564
msgid ""
"If the return value is ``True``, the type of its argument is the "
"intersection of the argument's original type and ``NarrowedType``."
msgstr ""

#: ../../library/typing.rst:1566
msgid ""
"If the return value is ``False``, the type of its argument is narrowed to "
"exclude ``NarrowedType``."
msgstr ""

#: ../../library/typing.rst:1571
msgid ""
"from typing import assert_type, final, TypeIs\n"
"\n"
"class Parent: pass\n"
"class Child(Parent): pass\n"
"@final\n"
"class Unrelated: pass\n"
"\n"
"def is_parent(val: object) -> TypeIs[Parent]:\n"
"    return isinstance(val, Parent)\n"
"\n"
"def run(arg: Child | Unrelated):\n"
"    if is_parent(arg):\n"
"        # Type of ``arg`` is narrowed to the intersection\n"
"        # of ``Parent`` and ``Child``, which is equivalent to\n"
"        # ``Child``.\n"
"        assert_type(arg, Child)\n"
"    else:\n"
"        # Type of ``arg`` is narrowed to exclude ``Parent``,\n"
"        # so only ``Unrelated`` is left.\n"
"        assert_type(arg, Unrelated)"
msgstr ""

#: ../../library/typing.rst:1592
msgid ""
"The type inside ``TypeIs`` must be consistent with the type of the "
"function's argument; if it is not, static type checkers will raise an "
"error.  An incorrectly written ``TypeIs`` function can lead to unsound "
"behavior in the type system; it is the user's responsibility to write such "
"functions in a type-safe manner."
msgstr ""

#: ../../library/typing.rst:1598
msgid ""
"If a ``TypeIs`` function is a class or instance method, then the type in "
"``TypeIs`` maps to the type of the second parameter (after ``cls`` or "
"``self``)."
msgstr ""

#: ../../library/typing.rst:1602
msgid ""
"In short, the form ``def foo(arg: TypeA) -> TypeIs[TypeB]: ...``, means that "
"if ``foo(arg)`` returns ``True``, then ``arg`` is an instance of ``TypeB``, "
"and if it returns ``False``, it is not an instance of ``TypeB``."
msgstr ""

#: ../../library/typing.rst:1606
msgid ""
"``TypeIs`` also works with type variables.  For more information, see :pep:"
"`742` (Narrowing types with ``TypeIs``)."
msgstr ""

#: ../../library/typing.rst:1616
msgid ""
"Type predicate functions are user-defined functions that return whether "
"their argument is an instance of a particular type. ``TypeGuard`` works "
"similarly to :data:`TypeIs`, but has subtly different effects on type "
"checking behavior (see below)."
msgstr ""

#: ../../library/typing.rst:1621
msgid ""
"Using  ``-> TypeGuard`` tells the static type checker that for a given "
"function:"
msgstr ""

#: ../../library/typing.rst:1625
msgid ""
"If the return value is ``True``, the type of its argument is the type inside "
"``TypeGuard``."
msgstr ""

#: ../../library/typing.rst:1628
msgid ""
"``TypeGuard`` also works with type variables.  See :pep:`647` for more "
"details."
msgstr ""

#: ../../library/typing.rst:1632
msgid ""
"def is_str_list(val: list[object]) -> TypeGuard[list[str]]:\n"
"    '''Determines whether all objects in the list are strings'''\n"
"    return all(isinstance(x, str) for x in val)\n"
"\n"
"def func1(val: list[object]):\n"
"    if is_str_list(val):\n"
"        # Type of ``val`` is narrowed to ``list[str]``.\n"
"        print(\" \".join(val))\n"
"    else:\n"
"        # Type of ``val`` remains as ``list[object]``.\n"
"        print(\"Not a list of strings!\")"
msgstr ""

#: ../../library/typing.rst:1644
msgid "``TypeIs`` and ``TypeGuard`` differ in the following ways:"
msgstr "``TypeIs`` 和 ``TypeGuard`` 在以下幾個方面有所不同："

#: ../../library/typing.rst:1646
msgid ""
"``TypeIs`` requires the narrowed type to be a subtype of the input type, "
"while ``TypeGuard`` does not.  The main reason is to allow for things like "
"narrowing ``list[object]`` to ``list[str]`` even though the latter is not a "
"subtype of the former, since ``list`` is invariant."
msgstr ""

#: ../../library/typing.rst:1650
msgid ""
"When a ``TypeGuard`` function returns ``True``, type checkers narrow the "
"type of the variable to exactly the ``TypeGuard`` type. When a ``TypeIs`` "
"function returns ``True``, type checkers can infer a more precise type "
"combining the previously known type of the variable with the ``TypeIs`` "
"type. (Technically, this is known as an intersection type.)"
msgstr ""

#: ../../library/typing.rst:1654
msgid ""
"When a ``TypeGuard`` function returns ``False``, type checkers cannot narrow "
"the type of the variable at all. When a ``TypeIs`` function returns "
"``False``, type checkers can narrow the type of the variable to exclude the "
"``TypeIs`` type."
msgstr ""

#: ../../library/typing.rst:1663
msgid "Typing operator to conceptually mark an object as having been unpacked."
msgstr ""

#: ../../library/typing.rst:1665
msgid ""
"For example, using the unpack operator ``*`` on a :ref:`type variable tuple "
"<typevartuple>` is equivalent to using ``Unpack`` to mark the type variable "
"tuple as having been unpacked::"
msgstr ""

#: ../../library/typing.rst:1669
msgid ""
"Ts = TypeVarTuple('Ts')\n"
"tup: tuple[*Ts]\n"
"# Effectively does:\n"
"tup: tuple[Unpack[Ts]]"
msgstr ""

#: ../../library/typing.rst:1674
msgid ""
"In fact, ``Unpack`` can be used interchangeably with ``*`` in the context "
"of :class:`typing.TypeVarTuple <TypeVarTuple>` and :class:`builtins.tuple "
"<tuple>` types. You might see ``Unpack`` being used explicitly in older "
"versions of Python, where ``*`` couldn't be used in certain places::"
msgstr ""

#: ../../library/typing.rst:1680
msgid ""
"# In older versions of Python, TypeVarTuple and Unpack\n"
"# are located in the `typing_extensions` backports package.\n"
"from typing_extensions import TypeVarTuple, Unpack\n"
"\n"
"Ts = TypeVarTuple('Ts')\n"
"tup: tuple[*Ts]         # Syntax error on Python <= 3.10!\n"
"tup: tuple[Unpack[Ts]]  # Semantically equivalent, and backwards-compatible"
msgstr ""

#: ../../library/typing.rst:1688
msgid ""
"``Unpack`` can also be used along with :class:`typing.TypedDict` for typing "
"``**kwargs`` in a function signature::"
msgstr ""

#: ../../library/typing.rst:1691
msgid ""
"from typing import TypedDict, Unpack\n"
"\n"
"class Movie(TypedDict):\n"
"    name: str\n"
"    year: int\n"
"\n"
"# This function expects two keyword arguments - `name` of type `str`\n"
"# and `year` of type `int`.\n"
"def foo(**kwargs: Unpack[Movie]): ..."
msgstr ""

#: ../../library/typing.rst:1701
msgid ""
"See :pep:`692` for more details on using ``Unpack`` for ``**kwargs`` typing."
msgstr ""

#: ../../library/typing.rst:1706
msgid "Building generic types and type aliases"
msgstr ""

#: ../../library/typing.rst:1708
msgid ""
"The following classes should not be used directly as annotations. Their "
"intended purpose is to be building blocks for creating generic types and "
"type aliases."
msgstr ""

#: ../../library/typing.rst:1712
msgid ""
"These objects can be created through special syntax (:ref:`type parameter "
"lists <type-params>` and the :keyword:`type` statement). For compatibility "
"with Python 3.11 and earlier, they can also be created without the dedicated "
"syntax, as documented below."
msgstr ""

#: ../../library/typing.rst:1719
msgid "Abstract base class for generic types."
msgstr ""

#: ../../library/typing.rst:1721
msgid ""
"A generic type is typically declared by adding a list of type parameters "
"after the class name::"
msgstr ""

#: ../../library/typing.rst:1724
msgid ""
"class Mapping[KT, VT]:\n"
"    def __getitem__(self, key: KT) -> VT:\n"
"        ...\n"
"        # Etc."
msgstr ""
"class Mapping[KT, VT]:\n"
"    def __getitem__(self, key: KT) -> VT:\n"
"        ...\n"
"        # Etc."

#: ../../library/typing.rst:1729
msgid ""
"Such a class implicitly inherits from ``Generic``. The runtime semantics of "
"this syntax are discussed in the :ref:`Language Reference <generic-classes>`."
msgstr ""

#: ../../library/typing.rst:1733
msgid "This class can then be used as follows::"
msgstr ""

#: ../../library/typing.rst:1735
msgid ""
"def lookup_name[X, Y](mapping: Mapping[X, Y], key: X, default: Y) -> Y:\n"
"    try:\n"
"        return mapping[key]\n"
"    except KeyError:\n"
"        return default"
msgstr ""
"def lookup_name[X, Y](mapping: Mapping[X, Y], key: X, default: Y) -> Y:\n"
"    try:\n"
"        return mapping[key]\n"
"    except KeyError:\n"
"        return default"

#: ../../library/typing.rst:1741
msgid ""
"Here the brackets after the function name indicate a :ref:`generic function "
"<generic-functions>`."
msgstr ""

#: ../../library/typing.rst:1744
msgid ""
"For backwards compatibility, generic classes can also be declared by "
"explicitly inheriting from ``Generic``. In this case, the type parameters "
"must be declared separately::"
msgstr ""

#: ../../library/typing.rst:1749
msgid ""
"KT = TypeVar('KT')\n"
"VT = TypeVar('VT')\n"
"\n"
"class Mapping(Generic[KT, VT]):\n"
"    def __getitem__(self, key: KT) -> VT:\n"
"        ...\n"
"        # Etc."
msgstr ""
"KT = TypeVar('KT')\n"
"VT = TypeVar('VT')\n"
"\n"
"class Mapping(Generic[KT, VT]):\n"
"    def __getitem__(self, key: KT) -> VT:\n"
"        ...\n"
"        # Etc."

#: ../../library/typing.rst:1761
msgid "Type variable."
msgstr ""

#: ../../library/typing.rst:1763
msgid ""
"The preferred way to construct a type variable is via the dedicated syntax "
"for :ref:`generic functions <generic-functions>`, :ref:`generic classes "
"<generic-classes>`, and :ref:`generic type aliases <generic-type-aliases>`::"
msgstr ""

#: ../../library/typing.rst:1768
msgid ""
"class Sequence[T]:  # T is a TypeVar\n"
"    ..."
msgstr ""
"class Sequence[T]:  # T 是一個 TypeVar\n"
"    ..."

#: ../../library/typing.rst:1771
msgid ""
"This syntax can also be used to create bounded and constrained type "
"variables::"
msgstr ""

#: ../../library/typing.rst:1774
msgid ""
"class StrSequence[S: str]:  # S is a TypeVar with a `str` upper bound;\n"
"    ...                     # we can say that S is \"bounded by `str`\"\n"
"\n"
"\n"
"class StrOrBytesSequence[A: (str, bytes)]:  # A is a TypeVar constrained to "
"str or bytes\n"
"    ..."
msgstr ""

#: ../../library/typing.rst:1781
msgid ""
"However, if desired, reusable type variables can also be constructed "
"manually, like so::"
msgstr ""

#: ../../library/typing.rst:1783
msgid ""
"T = TypeVar('T')  # Can be anything\n"
"S = TypeVar('S', bound=str)  # Can be any subtype of str\n"
"A = TypeVar('A', str, bytes)  # Must be exactly str or bytes"
msgstr ""
"T = TypeVar('T')  # 可以是任何東西\n"
"S = TypeVar('S', bound=str)  # 可以是任何 str 的子型別\n"
"A = TypeVar('A', str, bytes)  # 必須是 str 或 bytes"

#: ../../library/typing.rst:1787
msgid ""
"Type variables exist primarily for the benefit of static type checkers.  "
"They serve as the parameters for generic types as well as for generic "
"function and type alias definitions. See :class:`Generic` for more "
"information on generic types.  Generic functions work as follows::"
msgstr ""

#: ../../library/typing.rst:1793
msgid ""
"def repeat[T](x: T, n: int) -> Sequence[T]:\n"
"    \"\"\"Return a list containing n references to x.\"\"\"\n"
"    return [x]*n\n"
"\n"
"\n"
"def print_capitalized[S: str](x: S) -> S:\n"
"    \"\"\"Print x capitalized, and return x.\"\"\"\n"
"    print(x.capitalize())\n"
"    return x\n"
"\n"
"\n"
"def concatenate[A: (str, bytes)](x: A, y: A) -> A:\n"
"    \"\"\"Add two strings or bytes objects together.\"\"\"\n"
"    return x + y"
msgstr ""

#: ../../library/typing.rst:1808
msgid ""
"Note that type variables can be *bounded*, *constrained*, or neither, but "
"cannot be both bounded *and* constrained."
msgstr ""

#: ../../library/typing.rst:1811
msgid ""
"The variance of type variables is inferred by type checkers when they are "
"created through the :ref:`type parameter syntax <type-params>` or when "
"``infer_variance=True`` is passed. Manually created type variables may be "
"explicitly marked covariant or contravariant by passing ``covariant=True`` "
"or ``contravariant=True``. By default, manually created type variables are "
"invariant. See :pep:`484` and :pep:`695` for more details."
msgstr ""

#: ../../library/typing.rst:1819
msgid ""
"Bounded type variables and constrained type variables have different "
"semantics in several important ways. Using a *bounded* type variable means "
"that the ``TypeVar`` will be solved using the most specific type possible::"
msgstr ""

#: ../../library/typing.rst:1823
msgid ""
"x = print_capitalized('a string')\n"
"reveal_type(x)  # revealed type is str\n"
"\n"
"class StringSubclass(str):\n"
"    pass\n"
"\n"
"y = print_capitalized(StringSubclass('another string'))\n"
"reveal_type(y)  # revealed type is StringSubclass\n"
"\n"
"z = print_capitalized(45)  # error: int is not a subtype of str"
msgstr ""

#: ../../library/typing.rst:1834
msgid ""
"The upper bound of a type variable can be a concrete type, abstract type "
"(ABC or Protocol), or even a union of types::"
msgstr ""

#: ../../library/typing.rst:1837
msgid ""
"# Can be anything with an __abs__ method\n"
"def print_abs[T: SupportsAbs](arg: T) -> None:\n"
"    print(\"Absolute value:\", abs(arg))\n"
"\n"
"U = TypeVar('U', bound=str|bytes)  # Can be any subtype of the union str|"
"bytes\n"
"V = TypeVar('V', bound=SupportsAbs)  # Can be anything with an __abs__ method"
msgstr ""

#: ../../library/typing.rst:1846
msgid ""
"Using a *constrained* type variable, however, means that the ``TypeVar`` can "
"only ever be solved as being exactly one of the constraints given::"
msgstr ""

#: ../../library/typing.rst:1849
msgid ""
"a = concatenate('one', 'two')\n"
"reveal_type(a)  # revealed type is str\n"
"\n"
"b = concatenate(StringSubclass('one'), StringSubclass('two'))\n"
"reveal_type(b)  # revealed type is str, despite StringSubclass being passed "
"in\n"
"\n"
"c = concatenate('one', b'two')  # error: type variable 'A' can be either str "
"or bytes in a function call, but not both"
msgstr ""

#: ../../library/typing.rst:1857
msgid "At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`."
msgstr "在 runtime ``isinstance(x, T)`` 會引發 :exc:`TypeError`。"

#: ../../library/typing.rst:1861
msgid "The name of the type variable."
msgstr ""

#: ../../library/typing.rst:1865
msgid "Whether the type var has been explicitly marked as covariant."
msgstr ""

#: ../../library/typing.rst:1869
msgid "Whether the type var has been explicitly marked as contravariant."
msgstr ""

#: ../../library/typing.rst:1873
msgid ""
"Whether the type variable's variance should be inferred by type checkers."
msgstr ""

#: ../../library/typing.rst:1879
msgid "The upper bound of the type variable, if any."
msgstr ""

#: ../../library/typing.rst:1883
msgid ""
"For type variables created through :ref:`type parameter syntax <type-"
"params>`, the bound is evaluated only when the attribute is accessed, not "
"when the type variable is created (see :ref:`lazy-evaluation`)."
msgstr ""

#: ../../library/typing.rst:1889
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`~TypeVar.__bound__` "
"attribute. When called directly, this method supports only the :attr:"
"`~annotationlib.Format.VALUE` format, which is equivalent to accessing the :"
"attr:`~TypeVar.__bound__` attribute directly, but the method object can be "
"passed to :func:`annotationlib.call_evaluate_function` to evaluate the value "
"in a different format."
msgstr ""

#: ../../library/typing.rst:1899
msgid "A tuple containing the constraints of the type variable, if any."
msgstr ""

#: ../../library/typing.rst:1903
msgid ""
"For type variables created through :ref:`type parameter syntax <type-"
"params>`, the constraints are evaluated only when the attribute is accessed, "
"not when the type variable is created (see :ref:`lazy-evaluation`)."
msgstr ""

#: ../../library/typing.rst:1909
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`~TypeVar."
"__constraints__` attribute. When called directly, this method supports only "
"the :attr:`~annotationlib.Format.VALUE` format, which is equivalent to "
"accessing the :attr:`~TypeVar.__constraints__` attribute directly, but the "
"method object can be passed to :func:`annotationlib.call_evaluate_function` "
"to evaluate the value in a different format."
msgstr ""

#: ../../library/typing.rst:1919
msgid ""
"The default value of the type variable, or :data:`typing.NoDefault` if it "
"has no default."
msgstr ""

#: ../../library/typing.rst:1926
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`~TypeVar."
"__default__` attribute. When called directly, this method supports only the :"
"attr:`~annotationlib.Format.VALUE` format, which is equivalent to accessing "
"the :attr:`~TypeVar.__default__` attribute directly, but the method object "
"can be passed to :func:`annotationlib.call_evaluate_function` to evaluate "
"the value in a different format."
msgstr ""

#: ../../library/typing.rst:1936
msgid ""
"Return whether or not the type variable has a default value. This is "
"equivalent to checking whether :attr:`__default__` is not the :data:`typing."
"NoDefault` singleton, except that it does not force evaluation of the :ref:"
"`lazily evaluated <lazy-evaluation>` default value."
msgstr ""

#: ../../library/typing.rst:1945
msgid ""
"Type variables can now be declared using the :ref:`type parameter <type-"
"params>` syntax introduced by :pep:`695`. The ``infer_variance`` parameter "
"was added."
msgstr ""

#: ../../library/typing.rst:1951 ../../library/typing.rst:2100
#: ../../library/typing.rst:2212
msgid "Support for default values was added."
msgstr "新增對預設值的支援。"

#: ../../library/typing.rst:1957
msgid ""
"Type variable tuple. A specialized form of :ref:`type variable <typevar>` "
"that enables *variadic* generics."
msgstr ""

#: ../../library/typing.rst:1960
msgid ""
"Type variable tuples can be declared in :ref:`type parameter lists <type-"
"params>` using a single asterisk (``*``) before the name::"
msgstr ""

#: ../../library/typing.rst:1963
msgid ""
"def move_first_element_to_last[T, *Ts](tup: tuple[T, *Ts]) -> tuple[*Ts, "
"T]:\n"
"    return (*tup[1:], tup[0])"
msgstr ""
"def move_first_element_to_last[T, *Ts](tup: tuple[T, *Ts]) -> tuple[*Ts, "
"T]:\n"
"    return (*tup[1:], tup[0])"

#: ../../library/typing.rst:1966
msgid "Or by explicitly invoking the ``TypeVarTuple`` constructor::"
msgstr ""

#: ../../library/typing.rst:1968
msgid ""
"T = TypeVar(\"T\")\n"
"Ts = TypeVarTuple(\"Ts\")\n"
"\n"
"def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:\n"
"    return (*tup[1:], tup[0])"
msgstr ""
"T = TypeVar(\"T\")\n"
"Ts = TypeVarTuple(\"Ts\")\n"
"\n"
"def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:\n"
"    return (*tup[1:], tup[0])"

#: ../../library/typing.rst:1974
msgid ""
"A normal type variable enables parameterization with a single type. A type "
"variable tuple, in contrast, allows parameterization with an *arbitrary* "
"number of types by acting like an *arbitrary* number of type variables "
"wrapped in a tuple. For example::"
msgstr ""

#: ../../library/typing.rst:1979
msgid ""
"# T is bound to int, Ts is bound to ()\n"
"# Return value is (1,), which has type tuple[int]\n"
"move_first_element_to_last(tup=(1,))\n"
"\n"
"# T is bound to int, Ts is bound to (str,)\n"
"# Return value is ('spam', 1), which has type tuple[str, int]\n"
"move_first_element_to_last(tup=(1, 'spam'))\n"
"\n"
"# T is bound to int, Ts is bound to (str, float)\n"
"# Return value is ('spam', 3.0, 1), which has type tuple[str, float, int]\n"
"move_first_element_to_last(tup=(1, 'spam', 3.0))\n"
"\n"
"# This fails to type check (and fails at runtime)\n"
"# because tuple[()] is not compatible with tuple[T, *Ts]\n"
"# (at least one element is required)\n"
"move_first_element_to_last(tup=())"
msgstr ""

#: ../../library/typing.rst:1996
msgid ""
"Note the use of the unpacking operator ``*`` in ``tuple[T, *Ts]``. "
"Conceptually, you can think of ``Ts`` as a tuple of type variables ``(T1, "
"T2, ...)``. ``tuple[T, *Ts]`` would then become ``tuple[T, *(T1, "
"T2, ...)]``, which is equivalent to ``tuple[T, T1, T2, ...]``. (Note that in "
"older versions of Python, you might see this written using :data:`Unpack "
"<Unpack>` instead, as ``Unpack[Ts]``.)"
msgstr ""

#: ../../library/typing.rst:2004
msgid ""
"Type variable tuples must *always* be unpacked. This helps distinguish type "
"variable tuples from normal type variables::"
msgstr ""

#: ../../library/typing.rst:2007
msgid ""
"x: Ts          # Not valid\n"
"x: tuple[Ts]   # Not valid\n"
"x: tuple[*Ts]  # The correct way to do it"
msgstr ""
"x: Ts          # 無效\n"
"x: tuple[Ts]   # 無效\n"
"x: tuple[*Ts]  # 正確的做法"

#: ../../library/typing.rst:2011
msgid ""
"Type variable tuples can be used in the same contexts as normal type "
"variables. For example, in class definitions, arguments, and return types::"
msgstr ""

#: ../../library/typing.rst:2014
msgid ""
"class Array[*Shape]:\n"
"    def __getitem__(self, key: tuple[*Shape]) -> float: ...\n"
"    def __abs__(self) -> \"Array[*Shape]\": ...\n"
"    def get_shape(self) -> tuple[*Shape]: ..."
msgstr ""
"class Array[*Shape]:\n"
"    def __getitem__(self, key: tuple[*Shape]) -> float: ...\n"
"    def __abs__(self) -> \"Array[*Shape]\": ...\n"
"    def get_shape(self) -> tuple[*Shape]: ..."

#: ../../library/typing.rst:2019
msgid ""
"Type variable tuples can be happily combined with normal type variables:"
msgstr ""

#: ../../library/typing.rst:2021
msgid ""
"class Array[DType, *Shape]:  # This is fine\n"
"    pass\n"
"\n"
"class Array2[*Shape, DType]:  # This would also be fine\n"
"    pass\n"
"\n"
"class Height: ...\n"
"class Width: ...\n"
"\n"
"float_array_1d: Array[float, Height] = Array()     # Totally fine\n"
"int_array_2d: Array[int, Height, Width] = Array()  # Yup, fine too"
msgstr ""

#: ../../library/typing.rst:2035
msgid ""
"However, note that at most one type variable tuple may appear in a single "
"list of type arguments or type parameters::"
msgstr ""

#: ../../library/typing.rst:2038
msgid ""
"x: tuple[*Ts, *Ts]            # Not valid\n"
"class Array[*Shape, *Shape]:  # Not valid\n"
"    pass"
msgstr ""
"x: tuple[*Ts, *Ts]            # 無效\n"
"class Array[*Shape, *Shape]:  # 無效\n"
"    pass"

#: ../../library/typing.rst:2042
msgid ""
"Finally, an unpacked type variable tuple can be used as the type annotation "
"of ``*args``::"
msgstr ""

#: ../../library/typing.rst:2045
msgid ""
"def call_soon[*Ts](\n"
"    callback: Callable[[*Ts], None],\n"
"    *args: *Ts\n"
") -> None:\n"
"    ...\n"
"    callback(*args)"
msgstr ""
"def call_soon[*Ts](\n"
"    callback: Callable[[*Ts], None],\n"
"    *args: *Ts\n"
") -> None:\n"
"    ...\n"
"    callback(*args)"

#: ../../library/typing.rst:2052
msgid ""
"In contrast to non-unpacked annotations of ``*args`` - e.g. ``*args: int``, "
"which would specify that *all* arguments are ``int`` - ``*args: *Ts`` "
"enables reference to the types of the *individual* arguments in ``*args``. "
"Here, this allows us to ensure the types of the ``*args`` passed to "
"``call_soon`` match the types of the (positional) arguments of ``callback``."
msgstr ""

#: ../../library/typing.rst:2059
msgid "See :pep:`646` for more details on type variable tuples."
msgstr ""

#: ../../library/typing.rst:2063
msgid "The name of the type variable tuple."
msgstr ""

#: ../../library/typing.rst:2067
msgid ""
"The default value of the type variable tuple, or :data:`typing.NoDefault` if "
"it has no default."
msgstr ""

#: ../../library/typing.rst:2074
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`~TypeVarTuple."
"__default__` attribute. When called directly, this method supports only the :"
"attr:`~annotationlib.Format.VALUE` format, which is equivalent to accessing "
"the :attr:`~TypeVarTuple.__default__` attribute directly, but the method "
"object can be passed to :func:`annotationlib.call_evaluate_function` to "
"evaluate the value in a different format."
msgstr ""

#: ../../library/typing.rst:2084
msgid ""
"Return whether or not the type variable tuple has a default value. This is "
"equivalent to checking whether :attr:`__default__` is not the :data:`typing."
"NoDefault` singleton, except that it does not force evaluation of the :ref:"
"`lazily evaluated <lazy-evaluation>` default value."
msgstr ""

#: ../../library/typing.rst:2095
msgid ""
"Type variable tuples can now be declared using the :ref:`type parameter "
"<type-params>` syntax introduced by :pep:`695`."
msgstr ""

#: ../../library/typing.rst:2104
msgid ""
"Parameter specification variable.  A specialized version of :ref:`type "
"variables <typevar>`."
msgstr ""

#: ../../library/typing.rst:2107
msgid ""
"In :ref:`type parameter lists <type-params>`, parameter specifications can "
"be declared with two asterisks (``**``)::"
msgstr ""

#: ../../library/typing.rst:2110
msgid "type IntFunc[**P] = Callable[P, int]"
msgstr "type IntFunc[**P] = Callable[P, int]"

#: ../../library/typing.rst:2112
msgid ""
"For compatibility with Python 3.11 and earlier, ``ParamSpec`` objects can "
"also be created as follows::"
msgstr ""

#: ../../library/typing.rst:2115
msgid "P = ParamSpec('P')"
msgstr "P = ParamSpec('P')"

#: ../../library/typing.rst:2117
msgid ""
"Parameter specification variables exist primarily for the benefit of static "
"type checkers.  They are used to forward the parameter types of one callable "
"to another callable -- a pattern commonly found in higher order functions "
"and decorators.  They are only valid when used in ``Concatenate``, or as the "
"first argument to ``Callable``, or as parameters for user-defined Generics.  "
"See :class:`Generic` for more information on generic types."
msgstr ""

#: ../../library/typing.rst:2124
msgid ""
"For example, to add basic logging to a function, one can create a decorator "
"``add_logging`` to log function calls.  The parameter specification variable "
"tells the type checker that the callable passed into the decorator and the "
"new callable returned by it have inter-dependent type parameters::"
msgstr ""

#: ../../library/typing.rst:2129
msgid ""
"from collections.abc import Callable\n"
"import logging\n"
"\n"
"def add_logging[T, **P](f: Callable[P, T]) -> Callable[P, T]:\n"
"    '''A type-safe decorator to add logging to a function.'''\n"
"    def inner(*args: P.args, **kwargs: P.kwargs) -> T:\n"
"        logging.info(f'{f.__name__} was called')\n"
"        return f(*args, **kwargs)\n"
"    return inner\n"
"\n"
"@add_logging\n"
"def add_two(x: float, y: float) -> float:\n"
"    '''Add two numbers together.'''\n"
"    return x + y"
msgstr ""

#: ../../library/typing.rst:2144
msgid ""
"Without ``ParamSpec``, the simplest way to annotate this previously was to "
"use a :class:`TypeVar` with upper bound ``Callable[..., Any]``.  However "
"this causes two problems:"
msgstr ""

#: ../../library/typing.rst:2148
msgid ""
"The type checker can't type check the ``inner`` function because ``*args`` "
"and ``**kwargs`` have to be typed :data:`Any`."
msgstr ""

#: ../../library/typing.rst:2150
msgid ""
":func:`~cast` may be required in the body of the ``add_logging`` decorator "
"when returning the ``inner`` function, or the static type checker must be "
"told to ignore the ``return inner``."
msgstr ""

#: ../../library/typing.rst:2157
msgid ""
"Since ``ParamSpec`` captures both positional and keyword parameters, ``P."
"args`` and ``P.kwargs`` can be used to split a ``ParamSpec`` into its "
"components.  ``P.args`` represents the tuple of positional parameters in a "
"given call and should only be used to annotate ``*args``.  ``P.kwargs`` "
"represents the mapping of keyword parameters to their values in a given "
"call, and should be only be used to annotate ``**kwargs``.  Both attributes "
"require the annotated parameter to be in scope. At runtime, ``P.args`` and "
"``P.kwargs`` are instances respectively of :class:`ParamSpecArgs` and :class:"
"`ParamSpecKwargs`."
msgstr ""

#: ../../library/typing.rst:2169
msgid "The name of the parameter specification."
msgstr ""

#: ../../library/typing.rst:2173
msgid ""
"The default value of the parameter specification, or :data:`typing."
"NoDefault` if it has no default."
msgstr ""

#: ../../library/typing.rst:2180
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`~ParamSpec."
"__default__` attribute. When called directly, this method supports only the :"
"attr:`~annotationlib.Format.VALUE` format, which is equivalent to accessing "
"the :attr:`~ParamSpec.__default__` attribute directly, but the method object "
"can be passed to :func:`annotationlib.call_evaluate_function` to evaluate "
"the value in a different format."
msgstr ""

#: ../../library/typing.rst:2190
msgid ""
"Return whether or not the parameter specification has a default value. This "
"is equivalent to checking whether :attr:`__default__` is not the :data:"
"`typing.NoDefault` singleton, except that it does not force evaluation of "
"the :ref:`lazily evaluated <lazy-evaluation>` default value."
msgstr ""

#: ../../library/typing.rst:2197
msgid ""
"Parameter specification variables created with ``covariant=True`` or "
"``contravariant=True`` can be used to declare covariant or contravariant "
"generic types.  The ``bound`` argument is also accepted, similar to :class:"
"`TypeVar`.  However the actual semantics of these keywords are yet to be "
"decided."
msgstr ""

#: ../../library/typing.rst:2207
msgid ""
"Parameter specifications can now be declared using the :ref:`type parameter "
"<type-params>` syntax introduced by :pep:`695`."
msgstr ""

#: ../../library/typing.rst:2215
msgid ""
"Only parameter specification variables defined in global scope can be "
"pickled."
msgstr ""

#: ../../library/typing.rst:2221
msgid ":data:`Concatenate`"
msgstr ":data:`Concatenate`"

#: ../../library/typing.rst:2227
msgid ""
"Arguments and keyword arguments attributes of a :class:`ParamSpec`. The ``P."
"args`` attribute of a ``ParamSpec`` is an instance of ``ParamSpecArgs``, and "
"``P.kwargs`` is an instance of ``ParamSpecKwargs``. They are intended for "
"runtime introspection and have no special meaning to static type checkers."
msgstr ""

#: ../../library/typing.rst:2232
msgid ""
"Calling :func:`get_origin` on either of these objects will return the "
"original ``ParamSpec``:"
msgstr ""

#: ../../library/typing.rst:2235
msgid ""
">>> from typing import ParamSpec, get_origin\n"
">>> P = ParamSpec(\"P\")\n"
">>> get_origin(P.args) is P\n"
"True\n"
">>> get_origin(P.kwargs) is P\n"
"True"
msgstr ""
">>> from typing import ParamSpec, get_origin\n"
">>> P = ParamSpec(\"P\")\n"
">>> get_origin(P.args) is P\n"
"True\n"
">>> get_origin(P.kwargs) is P\n"
"True"

#: ../../library/typing.rst:2249
msgid "The type of type aliases created through the :keyword:`type` statement."
msgstr ""

#: ../../library/typing.rst:2253
msgid ""
">>> type Alias = int\n"
">>> type(Alias)\n"
"<class 'typing.TypeAliasType'>"
msgstr ""
">>> type Alias = int\n"
">>> type(Alias)\n"
"<class 'typing.TypeAliasType'>"

#: ../../library/typing.rst:2263
msgid "The name of the type alias:"
msgstr ""

#: ../../library/typing.rst:2265
msgid ""
">>> type Alias = int\n"
">>> Alias.__name__\n"
"'Alias'"
msgstr ""
">>> type Alias = int\n"
">>> Alias.__name__\n"
"'Alias'"

#: ../../library/typing.rst:2273
msgid "The name of the module in which the type alias was defined::"
msgstr ""

#: ../../library/typing.rst:2275
msgid ""
">>> type Alias = int\n"
">>> Alias.__module__\n"
"'__main__'"
msgstr ""
">>> type Alias = int\n"
">>> Alias.__module__\n"
"'__main__'"

#: ../../library/typing.rst:2281
msgid ""
"The type parameters of the type alias, or an empty tuple if the alias is not "
"generic:"
msgstr ""

#: ../../library/typing.rst:2284
msgid ""
">>> type ListOrSet[T] = list[T] | set[T]\n"
">>> ListOrSet.__type_params__\n"
"(T,)\n"
">>> type NotGeneric = int\n"
">>> NotGeneric.__type_params__\n"
"()"
msgstr ""
">>> type ListOrSet[T] = list[T] | set[T]\n"
">>> ListOrSet.__type_params__\n"
"(T,)\n"
">>> type NotGeneric = int\n"
">>> NotGeneric.__type_params__\n"
"()"

#: ../../library/typing.rst:2295
msgid ""
"The type alias's value. This is :ref:`lazily evaluated <lazy-evaluation>`, "
"so names used in the definition of the alias are not resolved until the "
"``__value__`` attribute is accessed:"
msgstr ""

#: ../../library/typing.rst:2299
msgid ""
">>> type Mutually = Recursive\n"
">>> type Recursive = Mutually\n"
">>> Mutually\n"
"Mutually\n"
">>> Recursive\n"
"Recursive\n"
">>> Mutually.__value__\n"
"Recursive\n"
">>> Recursive.__value__\n"
"Mutually"
msgstr ""
">>> type Mutually = Recursive\n"
">>> type Recursive = Mutually\n"
">>> Mutually\n"
"Mutually\n"
">>> Recursive\n"
"Recursive\n"
">>> Mutually.__value__\n"
"Recursive\n"
">>> Recursive.__value__\n"
"Mutually"

#: ../../library/typing.rst:2314
msgid ""
"An :term:`evaluate function` corresponding to the :attr:`__value__` "
"attribute. When called directly, this method supports only the :attr:"
"`~annotationlib.Format.VALUE` format, which is equivalent to accessing the :"
"attr:`__value__` attribute directly, but the method object can be passed to :"
"func:`annotationlib.call_evaluate_function` to evaluate the value in a "
"different format:"
msgstr ""

#: ../../library/typing.rst:2320
msgid ""
">>> type Alias = undefined\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"...\n"
"NameError: name 'undefined' is not defined\n"
">>> from annotationlib import Format, call_evaluate_function\n"
">>> Alias.evaluate_value(Format.VALUE)\n"
"Traceback (most recent call last):\n"
"...\n"
"NameError: name 'undefined' is not defined\n"
">>> call_evaluate_function(Alias.evaluate_value, Format.FORWARDREF)\n"
"ForwardRef('undefined')"
msgstr ""
">>> type Alias = undefined\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"...\n"
"NameError: name 'undefined' is not defined\n"
">>> from annotationlib import Format, call_evaluate_function\n"
">>> Alias.evaluate_value(Format.VALUE)\n"
"Traceback (most recent call last):\n"
"...\n"
"NameError: name 'undefined' is not defined\n"
">>> call_evaluate_function(Alias.evaluate_value, Format.FORWARDREF)\n"
"ForwardRef('undefined')"

#: ../../library/typing.rst:2338
msgid "Unpacking"
msgstr ""

#: ../../library/typing.rst:2339
msgid ""
"Type aliases support star unpacking using the ``*Alias`` syntax. This is "
"equivalent to using ``Unpack[Alias]`` directly:"
msgstr ""

#: ../../library/typing.rst:2342
msgid ""
">>> type Alias = tuple[int, str]\n"
">>> type Unpacked = tuple[bool, *Alias]\n"
">>> Unpacked.__value__\n"
"tuple[bool, typing.Unpack[Alias]]"
msgstr ""
">>> type Alias = tuple[int, str]\n"
">>> type Unpacked = tuple[bool, *Alias]\n"
">>> Unpacked.__value__\n"
"tuple[bool, typing.Unpack[Alias]]"

#: ../../library/typing.rst:2353
msgid "Other special directives"
msgstr ""

#: ../../library/typing.rst:2355
msgid ""
"These functions and classes should not be used directly as annotations. "
"Their intended purpose is to be building blocks for creating and declaring "
"types."
msgstr ""

#: ../../library/typing.rst:2361
msgid "Typed version of :func:`collections.namedtuple`."
msgstr ""

#: ../../library/typing.rst:2363 ../../library/typing.rst:2463
#: ../../library/typing.rst:3611
msgid "Usage::"
msgstr "用法： ::"

#: ../../library/typing.rst:2365
msgid ""
"class Employee(NamedTuple):\n"
"    name: str\n"
"    id: int"
msgstr ""
"class Employee(NamedTuple):\n"
"    name: str\n"
"    id: int"

#: ../../library/typing.rst:2369
msgid "This is equivalent to::"
msgstr "這等價於： ::"

#: ../../library/typing.rst:2371
msgid "Employee = collections.namedtuple('Employee', ['name', 'id'])"
msgstr "Employee = collections.namedtuple('Employee', ['name', 'id'])"

#: ../../library/typing.rst:2373
msgid ""
"To give a field a default value, you can assign to it in the class body::"
msgstr ""

#: ../../library/typing.rst:2375
msgid ""
"class Employee(NamedTuple):\n"
"    name: str\n"
"    id: int = 3\n"
"\n"
"employee = Employee('Guido')\n"
"assert employee.id == 3"
msgstr ""
"class Employee(NamedTuple):\n"
"    name: str\n"
"    id: int = 3\n"
"\n"
"employee = Employee('Guido')\n"
"assert employee.id == 3"

#: ../../library/typing.rst:2382
msgid ""
"Fields with a default value must come after any fields without a default."
msgstr ""

#: ../../library/typing.rst:2384
msgid ""
"The types for each field name can be retrieved by calling :func:"
"`annotationlib.get_annotations` on the resulting class. (The field names are "
"in the ``_fields`` attribute and the default values are in the "
"``_field_defaults`` attribute, both of which are part of the :func:"
"`~collections.namedtuple` API.)"
msgstr ""

#: ../../library/typing.rst:2390
msgid "``NamedTuple`` subclasses can also have docstrings and methods::"
msgstr ""

#: ../../library/typing.rst:2392
msgid ""
"class Employee(NamedTuple):\n"
"    \"\"\"Represents an employee.\"\"\"\n"
"    name: str\n"
"    id: int = 3\n"
"\n"
"    def __repr__(self) -> str:\n"
"        return f'<Employee {self.name}, id={self.id}>'"
msgstr ""

#: ../../library/typing.rst:2400
msgid "``NamedTuple`` subclasses can be generic::"
msgstr ""

#: ../../library/typing.rst:2402
msgid ""
"class Group[T](NamedTuple):\n"
"    key: T\n"
"    group: list[T]"
msgstr ""
"class Group[T](NamedTuple):\n"
"    key: T\n"
"    group: list[T]"

#: ../../library/typing.rst:2406
msgid "Backward-compatible usage::"
msgstr ""

#: ../../library/typing.rst:2408
msgid ""
"# For creating a generic NamedTuple on Python 3.11\n"
"T = TypeVar(\"T\")\n"
"\n"
"class Group(NamedTuple, Generic[T]):\n"
"    key: T\n"
"    group: list[T]\n"
"\n"
"# A functional syntax is also supported\n"
"Employee = NamedTuple('Employee', [('name', str), ('id', int)])"
msgstr ""

#: ../../library/typing.rst:2418
msgid "Added support for :pep:`526` variable annotation syntax."
msgstr ""

#: ../../library/typing.rst:2421
msgid "Added support for default values, methods, and docstrings."
msgstr ""

#: ../../library/typing.rst:2424
msgid ""
"The ``_field_types`` and ``__annotations__`` attributes are now regular "
"dictionaries instead of instances of ``OrderedDict``."
msgstr ""

#: ../../library/typing.rst:2428
msgid ""
"Removed the ``_field_types`` attribute in favor of the more standard "
"``__annotations__`` attribute which has the same information."
msgstr ""

#: ../../library/typing.rst:2432
msgid ""
"``NamedTuple`` is now a function rather than a class. It can still be used "
"as a class base, as described above."
msgstr ""

#: ../../library/typing.rst:2436
msgid "Added support for generic namedtuples."
msgstr ""

#: ../../library/typing.rst:2439
msgid ""
"Using :func:`super` (and the ``__class__`` :term:`closure variable`) in "
"methods of ``NamedTuple`` subclasses is unsupported and causes a :class:"
"`TypeError`."
msgstr ""

#: ../../library/typing.rst:2443
msgid ""
"The undocumented keyword argument syntax for creating NamedTuple classes "
"(``NT = NamedTuple(\"NT\", x=int)``) is deprecated, and will be disallowed "
"in 3.15. Use the class-based syntax or the functional syntax instead."
msgstr ""

#: ../../library/typing.rst:2448
msgid ""
"When using the functional syntax to create a NamedTuple class, failing to "
"pass a value to the 'fields' parameter (``NT = NamedTuple(\"NT\")``) is "
"deprecated. Passing ``None`` to the 'fields' parameter (``NT = "
"NamedTuple(\"NT\", None)``) is also deprecated. Both will be disallowed in "
"Python 3.15. To create a NamedTuple class with 0 fields, use ``class "
"NT(NamedTuple): pass`` or ``NT = NamedTuple(\"NT\", [])``."
msgstr ""

#: ../../library/typing.rst:2458
msgid "Helper class to create low-overhead :ref:`distinct types <distinct>`."
msgstr ""

#: ../../library/typing.rst:2460
msgid ""
"A ``NewType`` is considered a distinct type by a type checker. At runtime, "
"however, calling a ``NewType`` returns its argument unchanged."
msgstr ""

#: ../../library/typing.rst:2465
msgid ""
"UserId = NewType('UserId', int)  # Declare the NewType \"UserId\"\n"
"first_user = UserId(1)  # \"UserId\" returns the argument unchanged at "
"runtime"
msgstr ""

#: ../../library/typing.rst:2470
msgid "The name of the module in which the new type is defined."
msgstr ""

#: ../../library/typing.rst:2474
msgid "The name of the new type."
msgstr ""

#: ../../library/typing.rst:2478
msgid "The type that the new type is based on."
msgstr ""

#: ../../library/typing.rst:2482
msgid "``NewType`` is now a class rather than a function."
msgstr ""

#: ../../library/typing.rst:2487
msgid "Base class for protocol classes."
msgstr ""

#: ../../library/typing.rst:2489
msgid "Protocol classes are defined like this::"
msgstr ""

#: ../../library/typing.rst:2491
msgid ""
"class Proto(Protocol):\n"
"    def meth(self) -> int:\n"
"        ..."
msgstr ""
"class Proto(Protocol):\n"
"    def meth(self) -> int:\n"
"        ..."

#: ../../library/typing.rst:2495
msgid ""
"Such classes are primarily used with static type checkers that recognize "
"structural subtyping (static duck-typing), for example::"
msgstr ""

#: ../../library/typing.rst:2498
msgid ""
"class C:\n"
"    def meth(self) -> int:\n"
"        return 0\n"
"\n"
"def func(x: Proto) -> int:\n"
"    return x.meth()\n"
"\n"
"func(C())  # Passes static type check"
msgstr ""

#: ../../library/typing.rst:2507
msgid ""
"See :pep:`544` for more details. Protocol classes decorated with :func:"
"`runtime_checkable` (described later) act as simple-minded runtime protocols "
"that check only the presence of given attributes, ignoring their type "
"signatures. Protocol classes without this decorator cannot be used as the "
"second argument to :func:`isinstance` or :func:`issubclass`."
msgstr ""

#: ../../library/typing.rst:2513
msgid "Protocol classes can be generic, for example::"
msgstr ""

#: ../../library/typing.rst:2515
msgid ""
"class GenProto[T](Protocol):\n"
"    def meth(self) -> T:\n"
"        ..."
msgstr ""
"class GenProto[T](Protocol):\n"
"    def meth(self) -> T:\n"
"        ..."

#: ../../library/typing.rst:2519
msgid ""
"In code that needs to be compatible with Python 3.11 or older, generic "
"Protocols can be written as follows::"
msgstr ""

#: ../../library/typing.rst:2522
msgid ""
"T = TypeVar(\"T\")\n"
"\n"
"class GenProto(Protocol[T]):\n"
"    def meth(self) -> T:\n"
"        ..."
msgstr ""
"T = TypeVar(\"T\")\n"
"\n"
"class GenProto(Protocol[T]):\n"
"    def meth(self) -> T:\n"
"        ..."

#: ../../library/typing.rst:2532
msgid "Mark a protocol class as a runtime protocol."
msgstr ""

#: ../../library/typing.rst:2534
msgid ""
"Such a protocol can be used with :func:`isinstance` and :func:`issubclass`. "
"This allows a simple-minded structural check, very similar to \"one-trick "
"ponies\" in :mod:`collections.abc` such as :class:`~collections.abc."
"Iterable`.  For example::"
msgstr ""

#: ../../library/typing.rst:2538
msgid ""
"@runtime_checkable\n"
"class Closable(Protocol):\n"
"    def close(self): ...\n"
"\n"
"assert isinstance(open('/some/file'), Closable)\n"
"\n"
"@runtime_checkable\n"
"class Named(Protocol):\n"
"    name: str\n"
"\n"
"import threading\n"
"assert isinstance(threading.Thread(name='Bob'), Named)"
msgstr ""
"@runtime_checkable\n"
"class Closable(Protocol):\n"
"    def close(self): ...\n"
"\n"
"assert isinstance(open('/some/file'), Closable)\n"
"\n"
"@runtime_checkable\n"
"class Named(Protocol):\n"
"    name: str\n"
"\n"
"import threading\n"
"assert isinstance(threading.Thread(name='Bob'), Named)"

#: ../../library/typing.rst:2551
msgid ""
"This decorator raises :exc:`TypeError` when applied to a non-protocol class."
msgstr ""

#: ../../library/typing.rst:2555
msgid ""
":func:`!runtime_checkable` will check only the presence of the required "
"methods or attributes, not their type signatures or types. For example, :"
"class:`ssl.SSLObject` is a class, therefore it passes an :func:`issubclass` "
"check against :ref:`Callable <annotating-callables>`. However, the ``ssl."
"SSLObject.__init__`` method exists only to raise a :exc:`TypeError` with a "
"more informative message, therefore making it impossible to call "
"(instantiate) :class:`ssl.SSLObject`."
msgstr ""

#: ../../library/typing.rst:2566
msgid ""
"An :func:`isinstance` check against a runtime-checkable protocol can be "
"surprisingly slow compared to an ``isinstance()`` check against a non-"
"protocol class. Consider using alternative idioms such as :func:`hasattr` "
"calls for structural checks in performance-sensitive code."
msgstr ""

#: ../../library/typing.rst:2574
msgid ""
"The internal implementation of :func:`isinstance` checks against runtime-"
"checkable protocols now uses :func:`inspect.getattr_static` to look up "
"attributes (previously, :func:`hasattr` was used). As a result, some objects "
"which used to be considered instances of a runtime-checkable protocol may no "
"longer be considered instances of that protocol on Python 3.12+, and vice "
"versa. Most users are unlikely to be affected by this change."
msgstr ""

#: ../../library/typing.rst:2583
msgid ""
"The members of a runtime-checkable protocol are now considered \"frozen\" at "
"runtime as soon as the class has been created. Monkey-patching attributes "
"onto a runtime-checkable protocol will still work, but will have no impact "
"on :func:`isinstance` checks comparing objects to the protocol. See :ref:"
"`What's new in Python 3.12 <whatsnew-typing-py312>` for more details."
msgstr ""

#: ../../library/typing.rst:2594
msgid ""
"Special construct to add type hints to a dictionary. At runtime \":class:`!"
"TypedDict` instances\" are simply :class:`dicts <dict>`."
msgstr ""

#: ../../library/typing.rst:2597
msgid ""
"``TypedDict`` declares a dictionary type that expects all of its instances "
"to have a certain set of keys, where each key is associated with a value of "
"a consistent type. This expectation is not checked at runtime but is only "
"enforced by type checkers. Usage::"
msgstr ""

#: ../../library/typing.rst:2603
msgid ""
"class Point2D(TypedDict):\n"
"    x: int\n"
"    y: int\n"
"    label: str\n"
"\n"
"a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK\n"
"b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check\n"
"\n"
"assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')"
msgstr ""

#: ../../library/typing.rst:2613
msgid ""
"An alternative way to create a ``TypedDict`` is by using function-call "
"syntax. The second argument must be a literal :class:`dict`::"
msgstr ""

#: ../../library/typing.rst:2616
msgid "Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})"
msgstr "Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})"

#: ../../library/typing.rst:2618
msgid ""
"This functional syntax allows defining keys which are not valid :ref:"
"`identifiers <identifiers>`, for example because they are keywords or "
"contain hyphens, or when key names must not be :ref:`mangled <private-name-"
"mangling>` like regular private names::"
msgstr ""

#: ../../library/typing.rst:2623
msgid ""
"# raises SyntaxError\n"
"class Point2D(TypedDict):\n"
"    in: int  # 'in' is a keyword\n"
"    x-y: int  # name with hyphens\n"
"\n"
"class Definition(TypedDict):\n"
"    __schema: str  # mangled to `_Definition__schema`\n"
"\n"
"# OK, functional syntax\n"
"Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})\n"
"Definition = TypedDict('Definition', {'__schema': str})  # not mangled"
msgstr ""

#: ../../library/typing.rst:2635
msgid ""
"By default, all keys must be present in a ``TypedDict``. It is possible to "
"mark individual keys as non-required using :data:`NotRequired`::"
msgstr ""

#: ../../library/typing.rst:2638
msgid ""
"class Point2D(TypedDict):\n"
"    x: int\n"
"    y: int\n"
"    label: NotRequired[str]\n"
"\n"
"# Alternative syntax\n"
"Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': "
"NotRequired[str]})"
msgstr ""
"class Point2D(TypedDict):\n"
"    x: int\n"
"    y: int\n"
"    label: NotRequired[str]\n"
"\n"
"# 替代語法\n"
"Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': "
"NotRequired[str]})"

#: ../../library/typing.rst:2646
msgid ""
"This means that a ``Point2D`` ``TypedDict`` can have the ``label`` key "
"omitted."
msgstr ""

#: ../../library/typing.rst:2649
msgid ""
"It is also possible to mark all keys as non-required by default by "
"specifying a totality of ``False``::"
msgstr ""

#: ../../library/typing.rst:2652
msgid ""
"class Point2D(TypedDict, total=False):\n"
"    x: int\n"
"    y: int\n"
"\n"
"# Alternative syntax\n"
"Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)"
msgstr ""
"class Point2D(TypedDict, total=False):\n"
"    x: int\n"
"    y: int\n"
"\n"
"# 替代語法\n"
"Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)"

#: ../../library/typing.rst:2659
msgid ""
"This means that a ``Point2D`` ``TypedDict`` can have any of the keys "
"omitted. A type checker is only expected to support a literal ``False`` or "
"``True`` as the value of the ``total`` argument. ``True`` is the default, "
"and makes all items defined in the class body required."
msgstr ""

#: ../../library/typing.rst:2664
msgid ""
"Individual keys of a ``total=False`` ``TypedDict`` can be marked as required "
"using :data:`Required`::"
msgstr ""

#: ../../library/typing.rst:2667
msgid ""
"class Point2D(TypedDict, total=False):\n"
"    x: Required[int]\n"
"    y: Required[int]\n"
"    label: str\n"
"\n"
"# Alternative syntax\n"
"Point2D = TypedDict('Point2D', {\n"
"    'x': Required[int],\n"
"    'y': Required[int],\n"
"    'label': str\n"
"}, total=False)"
msgstr ""
"class Point2D(TypedDict, total=False):\n"
"    x: Required[int]\n"
"    y: Required[int]\n"
"    label: str\n"
"\n"
"# 替代語法\n"
"Point2D = TypedDict('Point2D', {\n"
"    'x': Required[int],\n"
"    'y': Required[int],\n"
"    'label': str\n"
"}, total=False)"

#: ../../library/typing.rst:2679
msgid ""
"It is possible for a ``TypedDict`` type to inherit from one or more other "
"``TypedDict`` types using the class-based syntax. Usage::"
msgstr ""

#: ../../library/typing.rst:2683
msgid ""
"class Point3D(Point2D):\n"
"    z: int"
msgstr ""
"class Point3D(Point2D):\n"
"    z: int"

#: ../../library/typing.rst:2686
msgid ""
"``Point3D`` has three items: ``x``, ``y`` and ``z``. It is equivalent to "
"this definition::"
msgstr ""

#: ../../library/typing.rst:2689
msgid ""
"class Point3D(TypedDict):\n"
"    x: int\n"
"    y: int\n"
"    z: int"
msgstr ""
"class Point3D(TypedDict):\n"
"    x: int\n"
"    y: int\n"
"    z: int"

#: ../../library/typing.rst:2694
msgid ""
"A ``TypedDict`` cannot inherit from a non-\\ ``TypedDict`` class, except "
"for :class:`Generic`. For example::"
msgstr ""

#: ../../library/typing.rst:2697
msgid ""
"class X(TypedDict):\n"
"    x: int\n"
"\n"
"class Y(TypedDict):\n"
"    y: int\n"
"\n"
"class Z(object): pass  # A non-TypedDict class\n"
"\n"
"class XY(X, Y): pass  # OK\n"
"\n"
"class XZ(X, Z): pass  # raises TypeError"
msgstr ""
"class X(TypedDict):\n"
"    x: int\n"
"\n"
"class Y(TypedDict):\n"
"    y: int\n"
"\n"
"class Z(object): pass  # 一個非 TypedDict 的類別\n"
"\n"
"class XY(X, Y): pass  # OK\n"
"\n"
"class XZ(X, Z): pass  # 引發 TypeError"

#: ../../library/typing.rst:2709
msgid "A ``TypedDict`` can be generic::"
msgstr ""

#: ../../library/typing.rst:2711
msgid ""
"class Group[T](TypedDict):\n"
"    key: T\n"
"    group: list[T]"
msgstr ""
"class Group[T](TypedDict):\n"
"    key: T\n"
"    group: list[T]"

#: ../../library/typing.rst:2715
msgid ""
"To create a generic ``TypedDict`` that is compatible with Python 3.11 or "
"lower, inherit from :class:`Generic` explicitly:"
msgstr ""

#: ../../library/typing.rst:2718
msgid ""
"T = TypeVar(\"T\")\n"
"\n"
"class Group(TypedDict, Generic[T]):\n"
"    key: T\n"
"    group: list[T]"
msgstr ""
"T = TypeVar(\"T\")\n"
"\n"
"class Group(TypedDict, Generic[T]):\n"
"    key: T\n"
"    group: list[T]"

#: ../../library/typing.rst:2726
msgid ""
"A ``TypedDict`` can be introspected via :func:`annotationlib."
"get_annotations` (see :ref:`annotations-howto` for more information on "
"annotations best practices) and the following attributes:"
msgstr ""

#: ../../library/typing.rst:2732
msgid ""
"``Point2D.__total__`` gives the value of the ``total`` argument. Example:"
msgstr ""

#: ../../library/typing.rst:2735
msgid ""
">>> from typing import TypedDict\n"
">>> class Point2D(TypedDict): pass\n"
">>> Point2D.__total__\n"
"True\n"
">>> class Point2D(TypedDict, total=False): pass\n"
">>> Point2D.__total__\n"
"False\n"
">>> class Point3D(Point2D): pass\n"
">>> Point3D.__total__\n"
"True"
msgstr ""
">>> from typing import TypedDict\n"
">>> class Point2D(TypedDict): pass\n"
">>> Point2D.__total__\n"
"True\n"
">>> class Point2D(TypedDict, total=False): pass\n"
">>> Point2D.__total__\n"
"False\n"
">>> class Point3D(Point2D): pass\n"
">>> Point3D.__total__\n"
"True"

#: ../../library/typing.rst:2748
msgid ""
"This attribute reflects *only* the value of the ``total`` argument to the "
"current ``TypedDict`` class, not whether the class is semantically total. "
"For example, a ``TypedDict`` with ``__total__`` set to ``True`` may have "
"keys marked with :data:`NotRequired`, or it may inherit from another "
"``TypedDict`` with ``total=False``. Therefore, it is generally better to "
"use :attr:`__required_keys__` and :attr:`__optional_keys__` for "
"introspection."
msgstr ""

#: ../../library/typing.rst:2761
msgid ""
"``Point2D.__required_keys__`` and ``Point2D.__optional_keys__`` return :"
"class:`frozenset` objects containing required and non-required keys, "
"respectively."
msgstr ""

#: ../../library/typing.rst:2764
msgid ""
"Keys marked with :data:`Required` will always appear in "
"``__required_keys__`` and keys marked with :data:`NotRequired` will always "
"appear in ``__optional_keys__``."
msgstr ""

#: ../../library/typing.rst:2767
msgid ""
"For backwards compatibility with Python 3.10 and below, it is also possible "
"to use inheritance to declare both required and non-required keys in the "
"same ``TypedDict``. This is done by declaring a ``TypedDict`` with one value "
"for the ``total`` argument and then inheriting from it in another "
"``TypedDict`` with a different value for ``total``:"
msgstr ""

#: ../../library/typing.rst:2774
msgid ""
">>> class Point2D(TypedDict, total=False):\n"
"...     x: int\n"
"...     y: int\n"
"...\n"
">>> class Point3D(Point2D):\n"
"...     z: int\n"
"...\n"
">>> Point3D.__required_keys__ == frozenset({'z'})\n"
"True\n"
">>> Point3D.__optional_keys__ == frozenset({'x', 'y'})\n"
"True"
msgstr ""
">>> class Point2D(TypedDict, total=False):\n"
"...     x: int\n"
"...     y: int\n"
"...\n"
">>> class Point3D(Point2D):\n"
"...     z: int\n"
"...\n"
">>> Point3D.__required_keys__ == frozenset({'z'})\n"
"True\n"
">>> Point3D.__optional_keys__ == frozenset({'x', 'y'})\n"
"True"

#: ../../library/typing.rst:2792
msgid ""
"If ``from __future__ import annotations`` is used or if annotations are "
"given as strings, annotations are not evaluated when the ``TypedDict`` is "
"defined. Therefore, the runtime introspection that ``__required_keys__`` and "
"``__optional_keys__`` rely on may not work properly, and the values of the "
"attributes may be incorrect."
msgstr ""

#: ../../library/typing.rst:2798
msgid "Support for :data:`ReadOnly` is reflected in the following attributes:"
msgstr ""

#: ../../library/typing.rst:2802
msgid ""
"A :class:`frozenset` containing the names of all read-only keys. Keys are "
"read-only if they carry the :data:`ReadOnly` qualifier."
msgstr ""

#: ../../library/typing.rst:2809
msgid ""
"A :class:`frozenset` containing the names of all mutable keys. Keys are "
"mutable if they do not carry the :data:`ReadOnly` qualifier."
msgstr ""

#: ../../library/typing.rst:2814
msgid ""
"See the `TypedDict <https://typing.python.org/en/latest/spec/typeddict."
"html#typeddict>`_ section in the typing documentation for more examples and "
"detailed rules."
msgstr ""

#: ../../library/typing.rst:2818
msgid ""
"``TypedDict`` is now a function rather than a class. It can still be used as "
"a class base, as described above."
msgstr ""

#: ../../library/typing.rst:2822
msgid ""
"Added support for marking individual keys as :data:`Required` or :data:"
"`NotRequired`. See :pep:`655`."
msgstr ""

#: ../../library/typing.rst:2826
msgid "Added support for generic ``TypedDict``\\ s."
msgstr ""

#: ../../library/typing.rst:2829
msgid ""
"Removed support for the keyword-argument method of creating ``TypedDict``\\ "
"s."
msgstr ""

#: ../../library/typing.rst:2832
msgid "Support for the :data:`ReadOnly` qualifier was added."
msgstr ""

#: ../../library/typing.rst:2835
msgid ""
"When using the functional syntax to create a TypedDict class, failing to "
"pass a value to the 'fields' parameter (``TD = TypedDict(\"TD\")``) is "
"deprecated. Passing ``None`` to the 'fields' parameter (``TD = "
"TypedDict(\"TD\", None)``) is also deprecated. Both will be disallowed in "
"Python 3.15. To create a TypedDict class with 0 fields, use ``class "
"TD(TypedDict): pass`` or ``TD = TypedDict(\"TD\", {})``."
msgstr ""

#: ../../library/typing.rst:2844
msgid "Protocols"
msgstr "協定"

#: ../../library/typing.rst:2846
msgid ""
"The following protocols are provided by the :mod:`!typing` module. All are "
"decorated with :deco:`runtime_checkable`."
msgstr ""

#: ../../library/typing.rst:2851
msgid ""
"A protocol with one abstract method ``__abs__`` that is covariant in its "
"return type."
msgstr ""

#: ../../library/typing.rst:2856
msgid "A protocol with one abstract method ``__bytes__``."
msgstr "一個有抽象方法 ``__bytes__`` 的協定。"

#: ../../library/typing.rst:2860
msgid "A protocol with one abstract method ``__complex__``."
msgstr "一個有抽象方法 ``__complex__`` 的協定。"

#: ../../library/typing.rst:2864
msgid "A protocol with one abstract method ``__float__``."
msgstr "一個有抽象方法 ``__float__`` 的協定。"

#: ../../library/typing.rst:2868
msgid "A protocol with one abstract method ``__index__``."
msgstr "一個有抽象方法 ``__index__`` 的協定。"

#: ../../library/typing.rst:2874
msgid "A protocol with one abstract method ``__int__``."
msgstr "一個有抽象方法 ``__int__`` 的協定。"

#: ../../library/typing.rst:2878
msgid ""
"A protocol with one abstract method ``__round__`` that is covariant in its "
"return type."
msgstr ""

#: ../../library/typing.rst:2884
msgid "ABCs and Protocols for working with I/O"
msgstr ""

#: ../../library/typing.rst:2890
msgid ""
"Generic class ``IO[AnyStr]`` and its subclasses ``TextIO(IO[str])`` and "
"``BinaryIO(IO[bytes])`` represent the types of I/O streams such as returned "
"by :func:`open`. Please note that these classes are not protocols, and their "
"interface is fairly broad."
msgstr ""

#: ../../library/typing.rst:2896
msgid ""
"The protocols :class:`io.Reader` and :class:`io.Writer` offer a simpler "
"alternative for argument types, when only the ``read()`` or ``write()`` "
"methods are accessed, respectively::"
msgstr ""

#: ../../library/typing.rst:2900
msgid ""
"def read_and_write(reader: Reader[str], writer: Writer[bytes]):\n"
"    data = reader.read()\n"
"    writer.write(data.encode())"
msgstr ""
"def read_and_write(reader: Reader[str], writer: Writer[bytes]):\n"
"    data = reader.read()\n"
"    writer.write(data.encode())"

#: ../../library/typing.rst:2904
msgid ""
"Also consider using :class:`collections.abc.Iterable` for iterating over the "
"lines of an input stream::"
msgstr ""

#: ../../library/typing.rst:2907
msgid ""
"def read_config(stream: Iterable[str]):\n"
"    for line in stream:\n"
"        ..."
msgstr ""
"def read_config(stream: Iterable[str]):\n"
"    for line in stream:\n"
"        ..."

#: ../../library/typing.rst:2912
msgid "Functions and decorators"
msgstr "函式與裝飾器"

#: ../../library/typing.rst:2916
msgid "Cast a value to a type."
msgstr ""

#: ../../library/typing.rst:2918
msgid ""
"This returns the value unchanged.  To the type checker this signals that the "
"return value has the designated type, but at runtime we intentionally don't "
"check anything (we want this to be as fast as possible)."
msgstr ""

#: ../../library/typing.rst:2925
msgid ""
"Ask a static type checker to confirm that *val* has an inferred type of "
"*typ*."
msgstr ""

#: ../../library/typing.rst:2927
msgid ""
"At runtime this does nothing: it returns the first argument unchanged with "
"no checks or side effects, no matter the actual type of the argument."
msgstr ""

#: ../../library/typing.rst:2930
msgid ""
"When a static type checker encounters a call to ``assert_type()``, it emits "
"an error if the value is not of the specified type::"
msgstr ""

#: ../../library/typing.rst:2933
msgid ""
"def greet(name: str) -> None:\n"
"    assert_type(name, str)  # OK, inferred type of `name` is `str`\n"
"    assert_type(name, int)  # type checker error"
msgstr ""
"def greet(name: str) -> None:\n"
"    assert_type(name, str)  # OK，推斷出的 `name` 型別是 `str`\n"
"    assert_type(name, int)  # 型別檢查器錯誤"

#: ../../library/typing.rst:2937
msgid ""
"This function is useful for ensuring the type checker's understanding of a "
"script is in line with the developer's intentions::"
msgstr ""

#: ../../library/typing.rst:2940
msgid ""
"def complex_function(arg: object):\n"
"    # Do some complex type-narrowing logic,\n"
"    # after which we hope the inferred type will be `int`\n"
"    ...\n"
"    # Test whether the type checker correctly understands our function\n"
"    assert_type(arg, int)"
msgstr ""

#: ../../library/typing.rst:2951
msgid ""
"Ask a static type checker to confirm that a line of code is unreachable."
msgstr ""

#: ../../library/typing.rst:2953
msgid "Example::"
msgstr "舉例來說： ::"

#: ../../library/typing.rst:2955
msgid ""
"def int_or_str(arg: int | str) -> None:\n"
"    match arg:\n"
"        case int():\n"
"            print(\"It's an int\")\n"
"        case str():\n"
"            print(\"It's a str\")\n"
"        case _ as unreachable:\n"
"            assert_never(unreachable)"
msgstr ""
"def int_or_str(arg: int | str) -> None:\n"
"    match arg:\n"
"        case int():\n"
"            print(\"It's an int\")\n"
"        case str():\n"
"            print(\"It's a str\")\n"
"        case _ as unreachable:\n"
"            assert_never(unreachable)"

#: ../../library/typing.rst:2964
msgid ""
"Here, the annotations allow the type checker to infer that the last case can "
"never execute, because ``arg`` is either an :class:`int` or a :class:`str`, "
"and both options are covered by earlier cases."
msgstr ""

#: ../../library/typing.rst:2969
msgid ""
"If a type checker finds that a call to ``assert_never()`` is reachable, it "
"will emit an error. For example, if the type annotation for ``arg`` was "
"instead ``int | str | float``, the type checker would emit an error pointing "
"out that ``unreachable`` is of type :class:`float`. For a call to "
"``assert_never`` to pass type checking, the inferred type of the argument "
"passed in must be the bottom type, :data:`Never`, and nothing else."
msgstr ""

#: ../../library/typing.rst:2977
msgid "At runtime, this throws an exception when called."
msgstr ""

#: ../../library/typing.rst:2980
msgid ""
"`Unreachable Code and Exhaustiveness Checking <https://typing.python.org/en/"
"latest/guides/unreachable.html>`__ has more information about exhaustiveness "
"checking with static typing."
msgstr ""

#: ../../library/typing.rst:2988
msgid "Ask a static type checker to reveal the inferred type of an expression."
msgstr ""

#: ../../library/typing.rst:2990
msgid ""
"When a static type checker encounters a call to this function, it emits a "
"diagnostic with the inferred type of the argument. For example::"
msgstr ""

#: ../../library/typing.rst:2993
msgid ""
"x: int = 1\n"
"reveal_type(x)  # Revealed type is \"builtins.int\""
msgstr ""

#: ../../library/typing.rst:2996
msgid ""
"This can be useful when you want to debug how your type checker handles a "
"particular piece of code."
msgstr ""

#: ../../library/typing.rst:2999
msgid ""
"At runtime, this function prints the runtime type of its argument to :data:"
"`sys.stderr` and returns the argument unchanged (allowing the call to be "
"used within an expression)::"
msgstr ""

#: ../../library/typing.rst:3003
msgid ""
"x = reveal_type(1)  # prints \"Runtime type is int\"\n"
"print(x)  # prints \"1\""
msgstr ""
"x = reveal_type(1)  # 印出 \"Runtime type is int\"\n"
"print(x)  # 印出 \"1\""

#: ../../library/typing.rst:3006
msgid ""
"Note that the runtime type may be different from (more or less specific "
"than) the type statically inferred by a type checker."
msgstr ""

#: ../../library/typing.rst:3009
msgid ""
"Most type checkers support ``reveal_type()`` anywhere, even if the name is "
"not imported from ``typing``. Importing the name from ``typing``, however, "
"allows your code to run without runtime errors and communicates intent more "
"clearly."
msgstr ""

#: ../../library/typing.rst:3020
msgid ""
"Decorator to mark an object as providing :func:`dataclass <dataclasses."
"dataclass>`-like behavior."
msgstr ""

#: ../../library/typing.rst:3023
msgid ""
"``dataclass_transform`` may be used to decorate a class, metaclass, or a "
"function that is itself a decorator. The presence of "
"``@dataclass_transform()`` tells a static type checker that the decorated "
"object performs runtime \"magic\" that transforms a class in a similar way "
"to :deco:`dataclasses.dataclass`."
msgstr ""

#: ../../library/typing.rst:3030
msgid "Example usage with a decorator function:"
msgstr ""

#: ../../library/typing.rst:3032
msgid ""
"@dataclass_transform()\n"
"def create_model[T](cls: type[T]) -> type[T]:\n"
"    ...\n"
"    return cls\n"
"\n"
"@create_model\n"
"class CustomerModel:\n"
"    id: int\n"
"    name: str"
msgstr ""
"@dataclass_transform()\n"
"def create_model[T](cls: type[T]) -> type[T]:\n"
"    ...\n"
"    return cls\n"
"\n"
"@create_model\n"
"class CustomerModel:\n"
"    id: int\n"
"    name: str"

#: ../../library/typing.rst:3044
msgid "On a base class::"
msgstr ""

#: ../../library/typing.rst:3046
msgid ""
"@dataclass_transform()\n"
"class ModelBase: ...\n"
"\n"
"class CustomerModel(ModelBase):\n"
"    id: int\n"
"    name: str"
msgstr ""
"@dataclass_transform()\n"
"class ModelBase: ...\n"
"\n"
"class CustomerModel(ModelBase):\n"
"    id: int\n"
"    name: str"

#: ../../library/typing.rst:3053
msgid "On a metaclass::"
msgstr ""

#: ../../library/typing.rst:3055
msgid ""
"@dataclass_transform()\n"
"class ModelMeta(type): ...\n"
"\n"
"class ModelBase(metaclass=ModelMeta): ...\n"
"\n"
"class CustomerModel(ModelBase):\n"
"    id: int\n"
"    name: str"
msgstr ""
"@dataclass_transform()\n"
"class ModelMeta(type): ...\n"
"\n"
"class ModelBase(metaclass=ModelMeta): ...\n"
"\n"
"class CustomerModel(ModelBase):\n"
"    id: int\n"
"    name: str"

#: ../../library/typing.rst:3064
msgid ""
"The ``CustomerModel`` classes defined above will be treated by type checkers "
"similarly to classes created with :deco:`dataclasses.dataclass`. For "
"example, type checkers will assume these classes have ``__init__`` methods "
"that accept ``id`` and ``name``."
msgstr ""

#: ../../library/typing.rst:3070
msgid ""
"The decorated class, metaclass, or function may accept the following bool "
"arguments which type checkers will assume have the same effect as they would "
"have on the :deco:`dataclasses.dataclass` decorator: ``init``, ``eq``, "
"``order``, ``unsafe_hash``, ``frozen``, ``match_args``, ``kw_only``, and "
"``slots``. It must be possible for the value of these arguments (``True`` or "
"``False``) to be statically evaluated."
msgstr ""

#: ../../library/typing.rst:3078
msgid ""
"The arguments to the ``dataclass_transform`` decorator can be used to "
"customize the default behaviors of the decorated class, metaclass, or "
"function:"
msgstr ""

#: ../../library/typing.rst:0
msgid "Parameters"
msgstr ""

#: ../../library/typing.rst:3082
msgid ""
"Indicates whether the ``eq`` parameter is assumed to be ``True`` or "
"``False`` if it is omitted by the caller. Defaults to ``True``."
msgstr ""

#: ../../library/typing.rst:3087
msgid ""
"Indicates whether the ``order`` parameter is assumed to be ``True`` or "
"``False`` if it is omitted by the caller. Defaults to ``False``."
msgstr ""

#: ../../library/typing.rst:3092
msgid ""
"Indicates whether the ``kw_only`` parameter is assumed to be ``True`` or "
"``False`` if it is omitted by the caller. Defaults to ``False``."
msgstr ""

#: ../../library/typing.rst:3097
msgid ""
"Indicates whether the ``frozen`` parameter is assumed to be ``True`` or "
"``False`` if it is omitted by the caller. Defaults to ``False``.  .. "
"versionadded:: 3.12"
msgstr ""

#: ../../library/typing.rst:3098
msgid ""
"Indicates whether the ``frozen`` parameter is assumed to be ``True`` or "
"``False`` if it is omitted by the caller. Defaults to ``False``."
msgstr ""

#: ../../library/typing.rst:3104
msgid ""
"Specifies a static list of supported classes or functions that describe "
"fields, similar to :func:`dataclasses.field`. Defaults to ``()``."
msgstr ""

#: ../../library/typing.rst:3110
msgid ""
"Arbitrary other keyword arguments are accepted in order to allow for "
"possible future extensions."
msgstr ""

#: ../../library/typing.rst:3114
msgid ""
"Type checkers recognize the following optional parameters on field "
"specifiers:"
msgstr ""

#: ../../library/typing.rst:3117
msgid "**Recognised parameters for field specifiers**"
msgstr ""

#: ../../library/typing.rst:3121
msgid "Parameter name"
msgstr ""

#: ../../library/typing.rst:3122
msgid "Description"
msgstr ""

#: ../../library/typing.rst:3123
msgid "``init``"
msgstr "``init``"

#: ../../library/typing.rst:3124
msgid ""
"Indicates whether the field should be included in the synthesized "
"``__init__`` method. If unspecified, ``init`` defaults to ``True``."
msgstr ""

#: ../../library/typing.rst:3127
msgid "``default``"
msgstr "``default``"

#: ../../library/typing.rst:3128
msgid "Provides the default value for the field."
msgstr ""

#: ../../library/typing.rst:3129
msgid "``default_factory``"
msgstr "``default_factory``"

#: ../../library/typing.rst:3130
msgid ""
"Provides a runtime callback that returns the default value for the field. If "
"neither ``default`` nor ``default_factory`` are specified, the field is "
"assumed to have no default value and must be provided a value when the class "
"is instantiated."
msgstr ""

#: ../../library/typing.rst:3135
msgid "``factory``"
msgstr "``factory``"

#: ../../library/typing.rst:3136
msgid "An alias for the ``default_factory`` parameter on field specifiers."
msgstr ""

#: ../../library/typing.rst:3137
msgid "``kw_only``"
msgstr "``kw_only``"

#: ../../library/typing.rst:3138
msgid ""
"Indicates whether the field should be marked as keyword-only. If ``True``, "
"the field will be keyword-only. If ``False``, it will not be keyword-only. "
"If unspecified, the value of the ``kw_only`` parameter on the object "
"decorated with ``dataclass_transform`` will be used, or if that is "
"unspecified, the value of ``kw_only_default`` on ``dataclass_transform`` "
"will be used."
msgstr ""

#: ../../library/typing.rst:3144
msgid "``alias``"
msgstr "``alias``"

#: ../../library/typing.rst:3145
msgid ""
"Provides an alternative name for the field. This alternative name is used in "
"the synthesized ``__init__`` method."
msgstr ""

#: ../../library/typing.rst:3148
msgid ""
"At runtime, this decorator records its arguments in the "
"``__dataclass_transform__`` attribute on the decorated object. It has no "
"other runtime effect."
msgstr ""

#: ../../library/typing.rst:3152
msgid "See :pep:`681` for more details."
msgstr "更多細節請見 :pep:`681`。"

#: ../../library/typing.rst:3160
msgid "Decorator for creating overloaded functions and methods."
msgstr ""

#: ../../library/typing.rst:3162
msgid ""
"The ``@overload`` decorator allows describing functions and methods that "
"support multiple different combinations of argument types. A series of "
"``@overload``-decorated definitions must be followed by exactly one non-"
"``@overload``-decorated definition (for the same function/method)."
msgstr ""

#: ../../library/typing.rst:3167
msgid ""
"``@overload``-decorated definitions are for the benefit of the type checker "
"only, since they will be overwritten by the non-``@overload``-decorated "
"definition. The non-``@overload``-decorated definition, meanwhile, will be "
"used at runtime but should be ignored by a type checker.  At runtime, "
"calling an ``@overload``-decorated function directly will raise :exc:"
"`NotImplementedError`."
msgstr ""

#: ../../library/typing.rst:3175
msgid ""
"An example of overload that gives a more precise type than can be expressed "
"using a union or a type variable:"
msgstr ""

#: ../../library/typing.rst:3178
msgid ""
"@overload\n"
"def process(response: None) -> None:\n"
"    ...\n"
"@overload\n"
"def process(response: int) -> tuple[int, str]:\n"
"    ...\n"
"@overload\n"
"def process(response: bytes) -> str:\n"
"    ...\n"
"def process(response):\n"
"    ...  # actual implementation goes here"
msgstr ""
"@overload\n"
"def process(response: None) -> None:\n"
"    ...\n"
"@overload\n"
"def process(response: int) -> tuple[int, str]:\n"
"    ...\n"
"@overload\n"
"def process(response: bytes) -> str:\n"
"    ...\n"
"def process(response):\n"
"    ...  # 實際的實作在這邊"

#: ../../library/typing.rst:3192
msgid ""
"See :pep:`484` for more details and comparison with other typing semantics."
msgstr ""

#: ../../library/typing.rst:3194
msgid ""
"Overloaded functions can now be introspected at runtime using :func:"
"`get_overloads`."
msgstr ""

#: ../../library/typing.rst:3201
msgid "Return a sequence of :deco:`overload`-decorated definitions for *func*."
msgstr ""

#: ../../library/typing.rst:3204
msgid ""
"*func* is the function object for the implementation of the overloaded "
"function. For example, given the definition of ``process`` in the "
"documentation for :deco:`overload`, ``get_overloads(process)`` will return a "
"sequence of three function objects for the three defined overloads. If "
"called on a function with no overloads, ``get_overloads()`` returns an empty "
"sequence."
msgstr ""

#: ../../library/typing.rst:3211
msgid ""
"``get_overloads()`` can be used for introspecting an overloaded function at "
"runtime."
msgstr ""

#: ../../library/typing.rst:3219
msgid "Clear all registered overloads in the internal registry."
msgstr ""

#: ../../library/typing.rst:3221
msgid "This can be used to reclaim the memory used by the registry."
msgstr ""

#: ../../library/typing.rst:3228
msgid "Decorator to indicate final methods and final classes."
msgstr ""

#: ../../library/typing.rst:3230
msgid ""
"Decorating a method with ``@final`` indicates to a type checker that the "
"method cannot be overridden in a subclass. Decorating a class with "
"``@final`` indicates that it cannot be subclassed."
msgstr ""

#: ../../library/typing.rst:3236
msgid ""
"class Base:\n"
"    @final\n"
"    def done(self) -> None:\n"
"        ...\n"
"class Sub(Base):\n"
"    def done(self) -> None:  # Error reported by type checker\n"
"        ...\n"
"\n"
"@final\n"
"class Leaf:\n"
"    ...\n"
"class Other(Leaf):  # Error reported by type checker\n"
"    ..."
msgstr ""
"class Base:\n"
"    @final\n"
"    def done(self) -> None:\n"
"        ...\n"
"class Sub(Base):\n"
"    def done(self) -> None:  # 型別檢查器回報的錯誤\n"
"        ...\n"
"\n"
"@final\n"
"class Leaf:\n"
"    ...\n"
"class Other(Leaf):  # 型別檢查器回報的錯誤\n"
"    ..."

#: ../../library/typing.rst:3255
msgid ""
"The decorator will now attempt to set a ``__final__`` attribute to ``True`` "
"on the decorated object. Thus, a check like ``if getattr(obj, \"__final__\", "
"False)`` can be used at runtime to determine whether an object ``obj`` has "
"been marked as final. If the decorated object does not support setting "
"attributes, the decorator returns the object unchanged without raising an "
"exception."
msgstr ""

#: ../../library/typing.rst:3266
msgid "Decorator to indicate that annotations are not type hints."
msgstr ""

#: ../../library/typing.rst:3268
msgid ""
"This works as a class or function :term:`decorator`.  With a class, it "
"applies recursively to all methods and classes defined in that class (but "
"not to methods defined in its superclasses or subclasses). Type checkers "
"will ignore all annotations in a function or class with this decorator."
msgstr ""

#: ../../library/typing.rst:3274
msgid "``@no_type_check`` mutates the decorated object in place."
msgstr ""

#: ../../library/typing.rst:3278
msgid "Decorator to give another decorator the :func:`no_type_check` effect."
msgstr ""

#: ../../library/typing.rst:3280
msgid ""
"This wraps the decorator with something that wraps the decorated function "
"in :func:`no_type_check`."
msgstr ""

#: ../../library/typing.rst:3283
msgid ""
"No type checker ever added support for ``@no_type_check_decorator``. It is "
"therefore deprecated, and will be removed in Python 3.15."
msgstr ""

#: ../../library/typing.rst:3289
msgid ""
"Decorator to indicate that a method in a subclass is intended to override a "
"method or attribute in a superclass."
msgstr ""

#: ../../library/typing.rst:3292
msgid ""
"Type checkers should emit an error if a method decorated with ``@override`` "
"does not, in fact, override anything. This helps prevent bugs that may occur "
"when a base class is changed without an equivalent change to a child class."
msgstr ""

#: ../../library/typing.rst:3299
msgid ""
"class Base:\n"
"    def log_status(self) -> None:\n"
"        ...\n"
"\n"
"class Sub(Base):\n"
"    @override\n"
"    def log_status(self) -> None:  # Okay: overrides Base.log_status\n"
"        ...\n"
"\n"
"    @override\n"
"    def done(self) -> None:  # Error reported by type checker\n"
"        ..."
msgstr ""

#: ../../library/typing.rst:3314
msgid "There is no runtime checking of this property."
msgstr ""

#: ../../library/typing.rst:3316
msgid ""
"The decorator will attempt to set an ``__override__`` attribute to ``True`` "
"on the decorated object. Thus, a check like ``if getattr(obj, "
"\"__override__\", False)`` can be used at runtime to determine whether an "
"object ``obj`` has been marked as an override.  If the decorated object does "
"not support setting attributes, the decorator returns the object unchanged "
"without raising an exception."
msgstr ""

#: ../../library/typing.rst:3323
msgid "See :pep:`698` for more details."
msgstr "更多細節請見 :pep:`698`。"

#: ../../library/typing.rst:3330
msgid "Decorator to mark a class or function as unavailable at runtime."
msgstr ""

#: ../../library/typing.rst:3332
msgid ""
"This decorator is itself not available at runtime. It is mainly intended to "
"mark classes that are defined in type stub files if an implementation "
"returns an instance of a private class::"
msgstr ""

#: ../../library/typing.rst:3336
msgid ""
"@type_check_only\n"
"class Response:  # private or not available at runtime\n"
"    code: int\n"
"    def get_header(self, name: str) -> str: ...\n"
"\n"
"def fetch_response() -> Response: ..."
msgstr ""

#: ../../library/typing.rst:3343
msgid ""
"Note that returning instances of private classes is not recommended. It is "
"usually preferable to make such classes public."
msgstr ""

#: ../../library/typing.rst:3347
msgid "Introspection helpers"
msgstr ""

#: ../../library/typing.rst:3351
msgid ""
"Return a dictionary containing type hints for a function, method, module, "
"class object, or other callable object."
msgstr ""

#: ../../library/typing.rst:3354
msgid ""
"This is often the same as :func:`annotationlib.get_annotations`, but this "
"function makes the following changes to the annotations dictionary:"
msgstr ""

#: ../../library/typing.rst:3357
msgid ""
"Forward references encoded as string literals or :class:`ForwardRef` objects "
"are handled by evaluating them in *globalns*, *localns*, and (where "
"applicable) *obj*'s :ref:`type parameter <type-params>` namespace. If "
"*globalns* or *localns* is not given, appropriate namespace dictionaries are "
"inferred from *obj*."
msgstr ""

#: ../../library/typing.rst:3362
msgid "``None`` is replaced with :class:`types.NoneType`."
msgstr ""

#: ../../library/typing.rst:3363
msgid ""
"If :deco:`no_type_check` has been applied to *obj*, an empty dictionary is "
"returned."
msgstr ""

#: ../../library/typing.rst:3365
msgid ""
"If *obj* is a class ``C``, the function returns a dictionary that merges "
"annotations from ``C``'s base classes with those on ``C`` directly. This is "
"done by traversing :attr:`C.__mro__ <type.__mro__>` and iteratively "
"combining :term:`annotations <variable annotation>` of each base class. "
"Annotations on classes appearing earlier in the :term:`method resolution "
"order` always take precedence over annotations on classes appearing later in "
"the method resolution order."
msgstr ""

#: ../../library/typing.rst:3373
msgid ""
"The function recursively replaces all occurrences of ``Annotated[T, ...]``, "
"``Required[T]``, ``NotRequired[T]``, and ``ReadOnly[T]`` with ``T``, unless "
"*include_extras* is set to ``True`` (see :class:`Annotated` for more "
"information)."
msgstr ""

#: ../../library/typing.rst:3380 ../../library/typing.rst:3572
msgid ""
"This function may execute arbitrary code contained in annotations. See :ref:"
"`annotationlib-security` for more information."
msgstr ""

#: ../../library/typing.rst:3385
msgid ""
"If :attr:`Format.VALUE <annotationlib.Format.VALUE>` is used and any forward "
"references in the annotations of *obj* are not resolvable, a :exc:"
"`NameError` exception is raised. For example, this can happen with names "
"imported under :data:`if TYPE_CHECKING <TYPE_CHECKING>`. More generally, any "
"kind of exception can be raised if an annotation contains invalid Python "
"code."
msgstr ""

#: ../../library/typing.rst:3394
msgid ""
"Calling :func:`get_type_hints` on an instance is not supported. To retrieve "
"annotations for an instance, call :func:`get_type_hints` on the instance's "
"class instead (for example, ``get_type_hints(type(obj))``)."
msgstr ""

#: ../../library/typing.rst:3399
msgid ""
"Added ``include_extras`` parameter as part of :pep:`593`. See the "
"documentation on :data:`Annotated` for more information."
msgstr ""
"新增 ``include_extras`` 參數（如 :pep:`593` 中所述）。更多資訊請見 :data:"
"`Annotated` 的文件。"

#: ../../library/typing.rst:3403
msgid ""
"Previously, ``Optional[t]`` was added for function and method annotations if "
"a default value equal to ``None`` was set. Now the annotation is returned "
"unchanged."
msgstr ""

#: ../../library/typing.rst:3408
msgid ""
"Added the ``format`` parameter. See the documentation on :func:"
"`annotationlib.get_annotations` for more information."
msgstr ""
"新增 ``format`` 參數。更多資訊請見 :func:`annotationlib.get_annotations` 的文"
"件。"

#: ../../library/typing.rst:3412
msgid ""
"Calling :func:`get_type_hints` on instances is no longer supported. Some "
"instances were accepted in earlier versions as an undocumented "
"implementation detail."
msgstr ""

#: ../../library/typing.rst:3419
msgid ""
"Get the unsubscripted version of a type: for a typing object of the form "
"``X[Y, Z, ...]`` return ``X``."
msgstr ""

#: ../../library/typing.rst:3422
msgid ""
"If ``X`` is a typing-module alias for a builtin or :mod:`collections` class, "
"it will be normalized to the original class. If ``X`` is an instance of :"
"class:`ParamSpecArgs` or :class:`ParamSpecKwargs`, return the underlying :"
"class:`ParamSpec`. Return ``None`` for unsupported objects."
msgstr ""

#: ../../library/typing.rst:3428 ../../library/typing.rst:3452
msgid "Examples:"
msgstr "舉例："

#: ../../library/typing.rst:3430
msgid ""
"assert get_origin(str) is None\n"
"assert get_origin(Dict[str, int]) is dict\n"
"assert get_origin(Union[int, str]) is Union\n"
"assert get_origin(Annotated[str, \"metadata\"]) is Annotated\n"
"P = ParamSpec('P')\n"
"assert get_origin(P.args) is P\n"
"assert get_origin(P.kwargs) is P"
msgstr ""
"assert get_origin(str) is None\n"
"assert get_origin(Dict[str, int]) is dict\n"
"assert get_origin(Union[int, str]) is Union\n"
"assert get_origin(Annotated[str, \"metadata\"]) is Annotated\n"
"P = ParamSpec('P')\n"
"assert get_origin(P.args) is P\n"
"assert get_origin(P.kwargs) is P"

#: ../../library/typing.rst:3444
msgid ""
"Get type arguments with all substitutions performed: for a typing object of "
"the form ``X[Y, Z, ...]`` return ``(Y, Z, ...)``."
msgstr ""

#: ../../library/typing.rst:3447
msgid ""
"If ``X`` is a union or :class:`Literal` contained in another generic type, "
"the order of ``(Y, Z, ...)`` may be different from the order of the original "
"arguments ``[Y, Z, ...]`` due to type caching. Return ``()`` for unsupported "
"objects."
msgstr ""

#: ../../library/typing.rst:3454
msgid ""
"assert get_args(int) == ()\n"
"assert get_args(Dict[int, str]) == (int, str)\n"
"assert get_args(Union[int, str]) == (int, str)"
msgstr ""
"assert get_args(int) == ()\n"
"assert get_args(Dict[int, str]) == (int, str)\n"
"assert get_args(Union[int, str]) == (int, str)"

#: ../../library/typing.rst:3464
msgid "Return the set of members defined in a :class:`Protocol`."
msgstr ""

#: ../../library/typing.rst:3466
msgid ""
">>> from typing import Protocol, get_protocol_members\n"
">>> class P(Protocol):\n"
"...     def a(self) -> str: ...\n"
"...     b: int\n"
">>> get_protocol_members(P) == frozenset({'a', 'b'})\n"
"True"
msgstr ""
">>> from typing import Protocol, get_protocol_members\n"
">>> class P(Protocol):\n"
"...     def a(self) -> str: ...\n"
"...     b: int\n"
">>> get_protocol_members(P) == frozenset({'a', 'b'})\n"
"True"

#: ../../library/typing.rst:3475
msgid "Raise :exc:`TypeError` for arguments that are not Protocols."
msgstr ""

#: ../../library/typing.rst:3481
msgid "Determine if a type is a :class:`Protocol`."
msgstr "確定一個型別是否 :class:`Protocol`。"

#: ../../library/typing.rst:3485
msgid ""
"class P(Protocol):\n"
"    def a(self) -> str: ...\n"
"    b: int\n"
"\n"
"assert is_protocol(P)\n"
"assert not is_protocol(int)"
msgstr ""
"class P(Protocol):\n"
"    def a(self) -> str: ...\n"
"    b: int\n"
"\n"
"assert is_protocol(P)\n"
"assert not is_protocol(int)"

#: ../../library/typing.rst:3494
msgid ""
"This function only returns true for ``Protocol`` classes, not for :ref:"
"`generic aliases <types-genericalias>` of them:"
msgstr ""

#: ../../library/typing.rst:3497
msgid ""
"class GenericP[T](Protocol):\n"
"    def a(self) -> T: ...\n"
"    b: int\n"
"\n"
"assert not is_protocol(GenericP[int])"
msgstr ""
"class GenericP[T](Protocol):\n"
"    def a(self) -> T: ...\n"
"    b: int\n"
"\n"
"assert not is_protocol(GenericP[int])"

#: ../../library/typing.rst:3509
msgid "Check if a type is a :class:`TypedDict`."
msgstr ""

#: ../../library/typing.rst:3513
msgid ""
"class Film(TypedDict):\n"
"    title: str\n"
"    year: int\n"
"\n"
"assert is_typeddict(Film)\n"
"assert not is_typeddict(list | str)\n"
"\n"
"# TypedDict is a factory for creating typed dicts,\n"
"# not a typed dict itself\n"
"assert not is_typeddict(TypedDict)"
msgstr ""

#: ../../library/typing.rst:3526
msgid ""
"This function only returns true for ``TypedDict`` classes, not for :ref:"
"`generic aliases <types-genericalias>` of them:"
msgstr ""

#: ../../library/typing.rst:3529
msgid ""
"class GenericFilm[T](TypedDict):\n"
"    title: str\n"
"    year: T\n"
"\n"
"assert not is_typeddict(GenericFilm[int])"
msgstr ""

#: ../../library/typing.rst:3541
msgid ""
"Class used for internal typing representation of string forward references."
msgstr ""

#: ../../library/typing.rst:3543
msgid ""
"For example, ``List[\"SomeClass\"]`` is implicitly transformed into "
"``List[ForwardRef(\"SomeClass\")]``.  :class:`!ForwardRef` should not be "
"instantiated by a user, but may be used by introspection tools."
msgstr ""

#: ../../library/typing.rst:3548
msgid ""
":pep:`585` generic types such as ``list[\"SomeClass\"]`` will not be "
"implicitly transformed into ``list[ForwardRef(\"SomeClass\")]`` and thus "
"will not automatically resolve to ``list[SomeClass]``."
msgstr ""

#: ../../library/typing.rst:3554
msgid ""
"This is now an alias for :class:`annotationlib.ForwardRef`. Several "
"undocumented behaviors of this class have been changed; for example, after a "
"``ForwardRef`` has been evaluated, the evaluated value is no longer cached."
msgstr ""

#: ../../library/typing.rst:3561
msgid "Evaluate an :class:`annotationlib.ForwardRef` as a :term:`type hint`."
msgstr ""

#: ../../library/typing.rst:3563
msgid ""
"This is similar to calling :meth:`annotationlib.ForwardRef.evaluate`, but "
"unlike that method, :func:`!evaluate_forward_ref` also recursively evaluates "
"forward references nested within the type hint."
msgstr ""

#: ../../library/typing.rst:3567
msgid ""
"See the documentation for :meth:`annotationlib.ForwardRef.evaluate` for the "
"meaning of the *owner*, *globals*, *locals*, *type_params*, and *format* "
"parameters."
msgstr ""

#: ../../library/typing.rst:3579
msgid ""
"A sentinel object used to indicate that a type parameter has no default "
"value. For example:"
msgstr ""

#: ../../library/typing.rst:3582
msgid ""
">>> T = TypeVar(\"T\")\n"
">>> T.__default__ is typing.NoDefault\n"
"True\n"
">>> S = TypeVar(\"S\", default=None)\n"
">>> S.__default__ is None\n"
"True"
msgstr ""
">>> T = TypeVar(\"T\")\n"
">>> T.__default__ is typing.NoDefault\n"
"True\n"
">>> S = TypeVar(\"S\", default=None)\n"
">>> S.__default__ is None\n"
"True"

#: ../../library/typing.rst:3594
msgid "Constant"
msgstr "常數"

#: ../../library/typing.rst:3598
msgid ""
"A special constant that is assumed to be ``True`` by static type checkers. "
"It's ``False`` at runtime."
msgstr ""

#: ../../library/typing.rst:3601
msgid ""
"A module which is expensive to import, and which only contain types used for "
"typing annotations, can be safely imported inside an ``if TYPE_CHECKING:`` "
"block.  This prevents the module from actually being imported at runtime; "
"annotations aren't eagerly evaluated (see :pep:`649`) so using undefined "
"symbols in annotations is harmless--as long as you don't later examine them. "
"Your static type analysis tool will set ``TYPE_CHECKING`` to ``True`` during "
"static type analysis, which means the module will be imported and the types "
"will be checked properly during such analysis."
msgstr ""

#: ../../library/typing.rst:3613
msgid ""
"if TYPE_CHECKING:\n"
"    import expensive_mod\n"
"\n"
"def fun(arg: expensive_mod.SomeType) -> None:\n"
"    local_var: expensive_mod.AnotherType = other_fun()"
msgstr ""
"if TYPE_CHECKING:\n"
"    import expensive_mod\n"
"\n"
"def fun(arg: expensive_mod.SomeType) -> None:\n"
"    local_var: expensive_mod.AnotherType = other_fun()"

#: ../../library/typing.rst:3619
msgid ""
"If you occasionally need to examine type annotations at runtime which may "
"contain undefined symbols, use :meth:`annotationlib.get_annotations` with a "
"``format`` parameter of :attr:`annotationlib.Format.STRING` or :attr:"
"`annotationlib.Format.FORWARDREF` to safely retrieve the annotations without "
"raising :exc:`NameError`."
msgstr ""

#: ../../library/typing.rst:3632
msgid "Deprecated aliases"
msgstr "棄用的別名"

#: ../../library/typing.rst:3634
msgid ""
"This module defines several deprecated aliases to pre-existing standard "
"library classes. These were originally included in the :mod:`!typing` module "
"in order to support parameterizing these generic classes using ``[]``. "
"However, the aliases became redundant in Python 3.9 when the corresponding "
"pre-existing classes were enhanced to support ``[]`` (see :pep:`585`)."
msgstr ""

#: ../../library/typing.rst:3641
msgid ""
"The redundant types are deprecated as of Python 3.9. However, while the "
"aliases may be removed at some point, removal of these aliases is not "
"currently planned. As such, no deprecation warnings are currently issued by "
"the interpreter for these aliases."
msgstr ""

#: ../../library/typing.rst:3646
msgid ""
"If at some point it is decided to remove these deprecated aliases, a "
"deprecation warning will be issued by the interpreter for at least two "
"releases prior to removal. The aliases are guaranteed to remain in the :mod:"
"`!typing` module without deprecation warnings until at least Python 3.14."
msgstr ""

#: ../../library/typing.rst:3651
msgid ""
"Type checkers are encouraged to flag uses of the deprecated types if the "
"program they are checking targets a minimum Python version of 3.9 or newer."
msgstr ""

#: ../../library/typing.rst:3657
msgid "Aliases to built-in types"
msgstr "內建型別的別名"

#: ../../library/typing.rst:3661
msgid "Deprecated alias to :class:`dict`."
msgstr "棄用 :class:`dict` 的別名。"

#: ../../library/typing.rst:3663
msgid ""
"Note that to annotate arguments, it is preferred to use an abstract "
"collection type such as :class:`~collections.abc.Mapping` rather than to "
"use :class:`dict` or :class:`!typing.Dict`."
msgstr ""

#: ../../library/typing.rst:3667
msgid ""
":class:`builtins.dict <dict>` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3673
msgid "Deprecated alias to :class:`list`."
msgstr "棄用 :class:`list` 的別名。"

#: ../../library/typing.rst:3675
msgid ""
"Note that to annotate arguments, it is preferred to use an abstract "
"collection type such as :class:`~collections.abc.Sequence` or :class:"
"`~collections.abc.Iterable` rather than to use :class:`list` or :class:`!"
"typing.List`."
msgstr ""

#: ../../library/typing.rst:3680
msgid ""
":class:`builtins.list <list>` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3686
msgid "Deprecated alias to :class:`builtins.set <set>`."
msgstr "棄用 :class:`builtins.set <set>` 的別名。"

#: ../../library/typing.rst:3688
msgid ""
"Note that to annotate arguments, it is preferred to use an abstract "
"collection type such as :class:`collections.abc.Set` rather than to use :"
"class:`set` or :class:`typing.Set`."
msgstr ""

#: ../../library/typing.rst:3692
msgid ""
":class:`builtins.set <set>` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3698
msgid "Deprecated alias to :class:`builtins.frozenset <frozenset>`."
msgstr "棄用 :class:`builtins.frozenset <frozenset>` 的別名。"

#: ../../library/typing.rst:3700
msgid ""
":class:`builtins.frozenset <frozenset>` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3707
msgid "Deprecated alias for :class:`tuple`."
msgstr "棄用 :class:`tuple` 的別名。"

#: ../../library/typing.rst:3709
msgid ""
":class:`tuple` and ``Tuple`` are special-cased in the type system; see :ref:"
"`annotating-tuples` for more details."
msgstr ""

#: ../../library/typing.rst:3712
msgid ""
":class:`builtins.tuple <tuple>` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3718
msgid "Deprecated alias to :class:`type`."
msgstr "棄用 :class:`type` 的別名。"

#: ../../library/typing.rst:3720
msgid ""
"See :ref:`type-of-class-objects` for details on using :class:`type` or "
"``typing.Type`` in type annotations."
msgstr ""

#: ../../library/typing.rst:3725
msgid ""
":class:`builtins.type <type>` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3732
msgid "Aliases to types in :mod:`collections`"
msgstr ":mod:`collections` 中型別的別名"

#: ../../library/typing.rst:3736
msgid "Deprecated alias to :class:`collections.defaultdict`."
msgstr "棄用 :class:`collections.defaultdict` 的別名。"

#: ../../library/typing.rst:3740
msgid ""
":class:`collections.defaultdict` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3746
msgid "Deprecated alias to :class:`collections.OrderedDict`."
msgstr "棄用 :class:`collections.OrderedDict` 的別名。"

#: ../../library/typing.rst:3750
msgid ""
":class:`collections.OrderedDict` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3756
msgid "Deprecated alias to :class:`collections.ChainMap`."
msgstr "棄用 :class:`collections.ChainMap` 的別名。"

#: ../../library/typing.rst:3760
msgid ""
":class:`collections.ChainMap` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3766
msgid "Deprecated alias to :class:`collections.Counter`."
msgstr "棄用 :class:`collections.Counter` 的別名。"

#: ../../library/typing.rst:3770
msgid ""
":class:`collections.Counter` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3776
msgid "Deprecated alias to :class:`collections.deque`."
msgstr "棄用 :class:`collections.deque` 的別名。"

#: ../../library/typing.rst:3780
msgid ""
":class:`collections.deque` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3787
msgid "Aliases to other concrete types"
msgstr ""

#: ../../library/typing.rst:3792
msgid ""
"Deprecated aliases corresponding to the return types from :func:`re.compile` "
"and :func:`re.match`."
msgstr ""

#: ../../library/typing.rst:3795
msgid ""
"These types (and the corresponding functions) are generic over :data:"
"`AnyStr`. ``Pattern`` can be specialised as ``Pattern[str]`` or "
"``Pattern[bytes]``; ``Match`` can be specialised as ``Match[str]`` or "
"``Match[bytes]``."
msgstr ""

#: ../../library/typing.rst:3800
msgid ""
"Classes ``Pattern`` and ``Match`` from :mod:`re` now support ``[]``. See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3806
msgid "Deprecated alias for :class:`str`."
msgstr "棄用 :class:`str` 的別名。"

#: ../../library/typing.rst:3808
msgid ""
"``Text`` is provided to supply a forward compatible path for Python 2 code: "
"in Python 2, ``Text`` is an alias for ``unicode``."
msgstr ""

#: ../../library/typing.rst:3812
msgid ""
"Use ``Text`` to indicate that a value must contain a unicode string in a "
"manner that is compatible with both Python 2 and Python 3::"
msgstr ""

#: ../../library/typing.rst:3815
msgid ""
"def add_unicode_checkmark(text: Text) -> Text:\n"
"    return text + u' \\u2713'"
msgstr ""
"def add_unicode_checkmark(text: Text) -> Text:\n"
"    return text + u' \\u2713'"

#: ../../library/typing.rst:3820
msgid ""
"Python 2 is no longer supported, and most type checkers also no longer "
"support type checking Python 2 code. Removal of the alias is not currently "
"planned, but users are encouraged to use :class:`str` instead of ``Text``."
msgstr ""

#: ../../library/typing.rst:3830
msgid "Aliases to container ABCs in :mod:`collections.abc`"
msgstr ":mod:`collections.abc` 中容器 ABC 的別名"

#: ../../library/typing.rst:3834
msgid "Deprecated alias to :class:`collections.abc.Set`."
msgstr "棄用 :class:`collections.abc.Set` 的別名。"

#: ../../library/typing.rst:3836
msgid ""
":class:`collections.abc.Set` now supports subscripting (``[]``). See :pep:"
"`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3842
msgid "Deprecated alias to :class:`collections.abc.ByteString`."
msgstr "棄用 :class:`collections.abc.ByteString` 的別名。"

#: ../../library/typing.rst:3844
msgid ""
"Use ``isinstance(obj, collections.abc.Buffer)`` to test if ``obj`` "
"implements the :ref:`buffer protocol <bufferobjects>` at runtime. For use in "
"type annotations, either use :class:`~collections.abc.Buffer` or a union "
"that explicitly specifies the types your code supports (e.g., ``bytes | "
"bytearray | memoryview``)."
msgstr ""
"使用 ``isinstance(obj, collections.abc.Buffer)`` 來測試 ``obj`` 是否在 "
"runtime 實作了\\ :ref:`緩衝區協定 <bufferobjects>`。在型別註解的使用中，請"
"用 :class:`~collections.abc.Buffer` 或明確指定你的程式碼所支援型別的聯集（例"
"如 ``bytes | bytearray | memoryview``）。"

#: ../../library/typing.rst:3850
msgid ""
":class:`!ByteString` was originally intended to be an abstract class that "
"would serve as a supertype of both :class:`bytes` and :class:`bytearray`. "
"However, since the ABC never had any methods, knowing that an object was an "
"instance of :class:`!ByteString` never actually told you anything useful "
"about the object. Other common buffer types such as :class:`memoryview` were "
"also never understood as subtypes of :class:`!ByteString` (either at runtime "
"or by static type checkers)."
msgstr ""
":class:`!ByteString` 最初被設計為一個抽象類別，以作為 :class:`bytes` 和 :"
"class:`bytearray` 的超型別 (supertype)。然而由於 ABC 從未擁有任何方法，知道一"
"個物件是 :class:`!ByteString` 的實例從未真正告訴你任何關於該物件的有用資訊。"
"其他常見的緩衝區型別如 :class:`memoryview` 也從未被理解為 :class:`!"
"ByteString` 的子型別（無論是在 runtime 還是由靜態型別檢查器）。"

#: ../../library/typing.rst:3858
msgid "See :pep:`PEP 688 <688#current-options>` for more details."
msgstr "更多細節請見 :pep:`PEP 688 <688#current-options>`。"

#: ../../library/typing.rst:3864
msgid "Deprecated alias to :class:`collections.abc.Collection`."
msgstr "棄用 :class:`collections.abc.Collection` 的別名。"

#: ../../library/typing.rst:3868
msgid ""
":class:`collections.abc.Collection` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3874
msgid "Deprecated alias to :class:`collections.abc.Container`."
msgstr "棄用 :class:`collections.abc.Container` 的別名。"

#: ../../library/typing.rst:3876
msgid ""
":class:`collections.abc.Container` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3882
msgid "Deprecated alias to :class:`collections.abc.ItemsView`."
msgstr "棄用 :class:`collections.abc.ItemsView` 的別名。"

#: ../../library/typing.rst:3884
msgid ""
":class:`collections.abc.ItemsView` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3890
msgid "Deprecated alias to :class:`collections.abc.KeysView`."
msgstr "棄用 :class:`collections.abc.KeysView` 的別名。"

#: ../../library/typing.rst:3892
msgid ""
":class:`collections.abc.KeysView` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3898
msgid "Deprecated alias to :class:`collections.abc.Mapping`."
msgstr "棄用 :class:`collections.abc.Mapping` 的別名。"

#: ../../library/typing.rst:3900
msgid ""
":class:`collections.abc.Mapping` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3906
msgid "Deprecated alias to :class:`collections.abc.MappingView`."
msgstr "棄用 :class:`collections.abc.MappingView` 的別名。"

#: ../../library/typing.rst:3908
msgid ""
":class:`collections.abc.MappingView` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3914
msgid "Deprecated alias to :class:`collections.abc.MutableMapping`."
msgstr "棄用 :class:`collections.abc.MutableMapping` 的別名。"

#: ../../library/typing.rst:3916
msgid ""
":class:`collections.abc.MutableMapping` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3923
msgid "Deprecated alias to :class:`collections.abc.MutableSequence`."
msgstr "棄用 :class:`collections.abc.MutableSequence` 的別名。"

#: ../../library/typing.rst:3925
msgid ""
":class:`collections.abc.MutableSequence` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3932
msgid "Deprecated alias to :class:`collections.abc.MutableSet`."
msgstr "棄用 :class:`collections.abc.MutableSet` 的別名。"

#: ../../library/typing.rst:3934
msgid ""
":class:`collections.abc.MutableSet` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3940
msgid "Deprecated alias to :class:`collections.abc.Sequence`."
msgstr "棄用 :class:`collections.abc.Sequence` 的別名。"

#: ../../library/typing.rst:3942
msgid ""
":class:`collections.abc.Sequence` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3948
msgid "Deprecated alias to :class:`collections.abc.ValuesView`."
msgstr "棄用 :class:`collections.abc.ValuesView` 的別名。"

#: ../../library/typing.rst:3950
msgid ""
":class:`collections.abc.ValuesView` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3957
msgid "Aliases to asynchronous ABCs in :mod:`collections.abc`"
msgstr ":mod:`collections.abc` 中非同步 ABC 的別名"

#: ../../library/typing.rst:3961
msgid "Deprecated alias to :class:`collections.abc.Coroutine`."
msgstr "棄用 :class:`collections.abc.Coroutine` 的別名。"

#: ../../library/typing.rst:3963
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`collections.abc.Coroutine` and ``typing.Coroutine`` in type annotations."
msgstr ""

#: ../../library/typing.rst:3969
msgid ""
":class:`collections.abc.Coroutine` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3975
msgid "Deprecated alias to :class:`collections.abc.AsyncGenerator`."
msgstr "棄用 :class:`collections.abc.AsyncGenerator` 的別名。"

#: ../../library/typing.rst:3977
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`collections.abc.AsyncGenerator` and ``typing.AsyncGenerator`` in type "
"annotations."
msgstr ""

#: ../../library/typing.rst:3983
msgid ""
":class:`collections.abc.AsyncGenerator` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:3988
msgid "The ``SendType`` parameter now has a default."
msgstr "``SendType`` 參數現在有預設值。"

#: ../../library/typing.rst:3993
msgid "Deprecated alias to :class:`collections.abc.AsyncIterable`."
msgstr "棄用 :class:`collections.abc.AsyncIterable` 的別名。"

#: ../../library/typing.rst:3997
msgid ""
":class:`collections.abc.AsyncIterable` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4003
msgid "Deprecated alias to :class:`collections.abc.AsyncIterator`."
msgstr "棄用 :class:`collections.abc.AsyncIterator` 的別名。"

#: ../../library/typing.rst:4007
msgid ""
":class:`collections.abc.AsyncIterator` now supports subscripting (``[]``). "
"See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4013
msgid "Deprecated alias to :class:`collections.abc.Awaitable`."
msgstr "棄用 :class:`collections.abc.Awaitable` 的別名。"

#: ../../library/typing.rst:4017
msgid ""
":class:`collections.abc.Awaitable` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4024
msgid "Aliases to other ABCs in :mod:`collections.abc`"
msgstr ""

#: ../../library/typing.rst:4028
msgid "Deprecated alias to :class:`collections.abc.Iterable`."
msgstr "棄用 :class:`collections.abc.Iterable` 的別名。"

#: ../../library/typing.rst:4030
msgid ""
":class:`collections.abc.Iterable` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4036
msgid "Deprecated alias to :class:`collections.abc.Iterator`."
msgstr "棄用 :class:`collections.abc.Iterator` 的別名。"

#: ../../library/typing.rst:4038
msgid ""
":class:`collections.abc.Iterator` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4044
msgid "Deprecated alias to :class:`collections.abc.Callable`."
msgstr "棄用 :class:`collections.abc.Callable` 的別名。"

#: ../../library/typing.rst:4046
msgid ""
"See :ref:`annotating-callables` for details on how to use :class:"
"`collections.abc.Callable` and ``typing.Callable`` in type annotations."
msgstr ""

#: ../../library/typing.rst:4049
msgid ""
":class:`collections.abc.Callable` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4059
msgid "Deprecated alias to :class:`collections.abc.Generator`."
msgstr "棄用 :class:`collections.abc.Generator` 的別名。"

#: ../../library/typing.rst:4061
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`collections.abc.Generator` and ``typing.Generator`` in type annotations."
msgstr ""

#: ../../library/typing.rst:4065
msgid ""
":class:`collections.abc.Generator` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4069
msgid "Default values for the send and return types were added."
msgstr ""

#: ../../library/typing.rst:4074
msgid "Deprecated alias to :class:`collections.abc.Hashable`."
msgstr "棄用 :class:`collections.abc.Hashable` 的別名。"

#: ../../library/typing.rst:4076
msgid "Use :class:`collections.abc.Hashable` directly instead."
msgstr "改為直接使用 :class:`collections.abc.Hashable`。"

#: ../../library/typing.rst:4081
msgid "Deprecated alias to :class:`collections.abc.Reversible`."
msgstr "棄用 :class:`collections.abc.Reversible` 的別名。"

#: ../../library/typing.rst:4083
msgid ""
":class:`collections.abc.Reversible` now supports subscripting (``[]``). See :"
"pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4089
msgid "Deprecated alias to :class:`collections.abc.Sized`."
msgstr "棄用 :class:`collections.abc.Sized` 的別名。"

#: ../../library/typing.rst:4091
msgid "Use :class:`collections.abc.Sized` directly instead."
msgstr "改為直接使用 :class:`collections.abc.Sized`。"

#: ../../library/typing.rst:4097
msgid "Aliases to :mod:`contextlib` ABCs"
msgstr ":mod:`contextlib` ABC 的別名"

#: ../../library/typing.rst:4101
msgid "Deprecated alias to :class:`contextlib.AbstractContextManager`."
msgstr ""

#: ../../library/typing.rst:4103
msgid ""
"The first type parameter, ``T_co``, represents the type returned by the :"
"meth:`~object.__enter__` method. The optional second type parameter, "
"``ExitT_co``, which defaults to ``bool | None``, represents the type "
"returned by the :meth:`~object.__exit__` method."
msgstr ""

#: ../../library/typing.rst:4110
msgid ""
":class:`contextlib.AbstractContextManager` now supports subscripting "
"(``[]``). See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4115
msgid "Added the optional second type parameter, ``ExitT_co``."
msgstr ""

#: ../../library/typing.rst:4120
msgid "Deprecated alias to :class:`contextlib.AbstractAsyncContextManager`."
msgstr ""

#: ../../library/typing.rst:4122
msgid ""
"The first type parameter, ``T_co``, represents the type returned by the :"
"meth:`~object.__aenter__` method. The optional second type parameter, "
"``AExitT_co``, which defaults to ``bool | None``, represents the type "
"returned by the :meth:`~object.__aexit__` method."
msgstr ""

#: ../../library/typing.rst:4129
msgid ""
":class:`contextlib.AbstractAsyncContextManager` now supports subscripting "
"(``[]``). See :pep:`585` and :ref:`types-genericalias`."
msgstr ""

#: ../../library/typing.rst:4134
msgid "Added the optional second type parameter, ``AExitT_co``."
msgstr ""

#: ../../library/typing.rst:4138
msgid "Deprecation Timeline of Major Features"
msgstr "主要功能的棄用時程表"

#: ../../library/typing.rst:4140
msgid ""
"Certain features in ``typing`` are deprecated and may be removed in a future "
"version of Python. The following table summarizes major deprecations for "
"your convenience. This is subject to change, and not all deprecations are "
"listed."
msgstr ""

#: ../../library/typing.rst:4147
msgid "Feature"
msgstr ""

#: ../../library/typing.rst:4148
msgid "Deprecated in"
msgstr "棄用於"

#: ../../library/typing.rst:4149
msgid "Projected removal"
msgstr ""

#: ../../library/typing.rst:4150
msgid "PEP/issue"
msgstr ""

#: ../../library/typing.rst:4151
msgid "``typing`` versions of standard collections"
msgstr ""

#: ../../library/typing.rst:4152 ../../library/typing.rst:4156
msgid "3.9"
msgstr "3.9"

#: ../../library/typing.rst:4153
msgid "Undecided (see :ref:`deprecated-aliases` for more information)"
msgstr ""

#: ../../library/typing.rst:4154
msgid ":pep:`585`"
msgstr ":pep:`585`"

#: ../../library/typing.rst:4155
msgid ":class:`typing.ByteString`"
msgstr ":class:`typing.ByteString`"

#: ../../library/typing.rst:4157
msgid "3.17"
msgstr "3.17"

#: ../../library/typing.rst:4158
msgid ":gh:`91896`"
msgstr ":gh:`91896`"

#: ../../library/typing.rst:4159
msgid ":data:`typing.Text`"
msgstr ":data:`typing.Text`"

#: ../../library/typing.rst:4160
msgid "3.11"
msgstr "3.11"

#: ../../library/typing.rst:4161 ../../library/typing.rst:4165
#: ../../library/typing.rst:4169
msgid "Undecided"
msgstr ""

#: ../../library/typing.rst:4162
msgid ":gh:`92332`"
msgstr ":gh:`92332`"

#: ../../library/typing.rst:4163
msgid ":class:`typing.Hashable` and :class:`typing.Sized`"
msgstr ":class:`typing.Hashable` 和 :class:`typing.Sized`"

#: ../../library/typing.rst:4164 ../../library/typing.rst:4168
msgid "3.12"
msgstr "3.12"

#: ../../library/typing.rst:4166
msgid ":gh:`94309`"
msgstr ":gh:`94309`"

#: ../../library/typing.rst:4167
msgid ":data:`typing.TypeAlias`"
msgstr ":data:`typing.TypeAlias`"

#: ../../library/typing.rst:4170
msgid ":pep:`695`"
msgstr ":pep:`695`"

#: ../../library/typing.rst:4171
msgid ":func:`@typing.no_type_check_decorator <no_type_check_decorator>`"
msgstr ":func:`@typing.no_type_check_decorator <no_type_check_decorator>`"

#: ../../library/typing.rst:4172 ../../library/typing.rst:4176
msgid "3.13"
msgstr "3.13"

#: ../../library/typing.rst:4173
msgid "3.15"
msgstr "3.15"

#: ../../library/typing.rst:4174
msgid ":gh:`106309`"
msgstr ":gh:`106309`"

#: ../../library/typing.rst:4175
msgid ":data:`typing.AnyStr`"
msgstr ":data:`typing.AnyStr`"

#: ../../library/typing.rst:4177
msgid "3.18"
msgstr "3.18"

#: ../../library/typing.rst:4178
msgid ":gh:`105578`"
msgstr ":gh:`105578`"

#: ../../library/typing.rst:233 ../../library/typing.rst:380
#: ../../library/typing.rst:1170
msgid "..."
msgstr "..."

#: ../../library/typing.rst:233 ../../library/typing.rst:380
#: ../../library/typing.rst:1170
msgid "ellipsis literal"
msgstr "ellipsis literal（刪節號字面值）"