# Copyright (C) 2001 Python Software Foundation

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

# Translators:

# Steven Hsu <[email protected]>, 2021-2022

# Matt Wang <[email protected]>, 2021

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-12-17 17:02+0000\n"

"PO-Revision-Date: 2023-07-02 22:47+0800\n"

"Last-Translator: Matt Wang <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=1; plural=0;\n"

"X-Generator: Poedit 3.3.2\n"

#: ../../glossary.rst:5

msgid "Glossary"

msgstr "術語表"

#: ../../glossary.rst:10

msgid "``>>>``"

msgstr "``>>>``"

#: ../../glossary.rst:12

msgid ""

"The default Python prompt of the :term:`interactive` shell. Often seen for "

"code examples which can be executed interactively in the interpreter."

msgstr ""

":term:`互動式 <interactive>` shell 的預設 Python 提示字元。常見於能在直譯器中"

"以互動方式被執行的程式碼範例。"

#: ../../glossary.rst:15

msgid "``...``"

msgstr "``...``"

#: ../../glossary.rst:17

msgid "Can refer to:"

msgstr "可以表示："

#: ../../glossary.rst:19

msgid ""

"The default Python prompt of the :term:`interactive` shell when entering the "

"code for an indented code block, when within a pair of matching left and "

"right delimiters (parentheses, square brackets, curly braces or triple "

"quotes), or after specifying a decorator."

msgstr ""

"在一個被縮排的程式碼區塊、在一對匹配的左右定界符（delimiter，例如括號、方括"

"號、花括號或三引號）內部，或是在指定一個裝飾器 (decorator) 之後，要輸入程式碼"

"時，:term:`互動式 <interactive>` shell 顯示的預設 Python 提示字元。"

#: ../../glossary.rst:26

msgid ""

"The three dots form of the :ref:`Ellipsis <bltin-ellipsis-object>` object."

msgstr ""

#: ../../glossary.rst:27

msgid "abstract base class"

msgstr "abstract base class（抽象基底類別）"

#: ../../glossary.rst:29

msgid ""

"Abstract base classes complement :term:`duck-typing` by providing a way to "

"define interfaces when other techniques like :func:`hasattr` would be clumsy "

"or subtly wrong (for example with :ref:`magic methods <special-lookup>`). "

"ABCs introduce virtual subclasses, which are classes that don't inherit from "

"a class but are still recognized by :func:`isinstance` and :func:"

"`issubclass`; see the :mod:`abc` module documentation. Python comes with "

"many built-in ABCs for data structures (in the :mod:`collections.abc` "

"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "

"module), import finders and loaders (in the :mod:`importlib.abc` module). "

"You can create your own ABCs with the :mod:`abc` module."

msgstr ""

"抽象基底類別（又稱為 ABC）提供了一種定義介面的方法，作為 :term:`duck-"

"typing`\\ （鴨子型別）的補充。其他類似的技術，像是 :func:`hasattr`，則顯得笨"

"拙或是帶有細微的錯誤（例如使用\\ :ref:`魔術方法 (magic method) <special-"

"lookup>`\\ ）。ABC 採用虛擬的 subclass（子類別），它們並不繼承自另一個 class"

"（類別），但仍可被 :func:`isinstance` 及 :func:`issubclass` 辨識；請參閱 :"

"mod:`abc` 模組的說明文件。Python 有許多內建的 ABC，用於資料結構（在 :mod:"

"`collections.abc` 模組）、數字（在 :mod:`numbers` 模組）、串流（在 :mod:`io` "

"模組）及 import 尋檢器和載入器（在 :mod:`importlib.abc` 模組）。你可以使用 :"

"mod:`abc` 模組建立自己的 ABC。"

#: ../../glossary.rst:40

msgid "annotate function"

msgstr "annotate function（註釋函式）"

#: ../../glossary.rst:42

msgid ""

"A function that can be called to retrieve the :term:`annotations "

"<annotation>` of an object. This function is accessible as the :attr:"

"`~object.__annotate__` attribute of functions, classes, and modules. "

"Annotate functions are a subset of :term:`evaluate functions <evaluate "

"function>`."

msgstr ""

#: ../../glossary.rst:46

msgid "annotation"

msgstr "annotation（註釋）"

#: ../../glossary.rst:48

msgid ""

"A label associated with a variable, a class attribute or a function "

"parameter or return value, used by convention as a :term:`type hint`."

msgstr ""

"一個與變數、class 屬性、函式的參數或回傳值相關聯的標籤。照慣例，它被用來作"

"為 :term:`type hint`\\ （型別提示）。"

#: ../../glossary.rst:52

msgid ""

"Annotations of local variables cannot be accessed at runtime, but "

"annotations of global variables, class attributes, and functions can be "

"retrieved by calling :func:`annotationlib.get_annotations` on modules, "

"classes, and functions, respectively."

msgstr ""

"在 runtime 的區域變數註釋無法被存取，但全域變數、類別屬性和函式的註釋，分別能"

"夠以對模組、類別和函式呼叫 :func:`annotationlib.get_annotations` 來取得。"

#: ../../glossary.rst:57

msgid ""

"See :term:`variable annotation`, :term:`function annotation`, :pep:`484`, :"

"pep:`526`, and :pep:`649`, which describe this functionality. Also see :ref:"

"`annotations-howto` for best practices on working with annotations."

msgstr ""

"請參閱 :term:`variable annotation`、:term:`function annotation`、:pep:"

"`484`、:pep:`526` 和 :pep:`649`，這些章節皆有此功能的說明。關於註釋的最佳實踐"

"方法也請參閱 :ref:`annotations-howto`。"

#: ../../glossary.rst:61

msgid "argument"

msgstr "argument（引數）"

#: ../../glossary.rst:63

msgid ""

"A value passed to a :term:`function` (or :term:`method`) when calling the "

"function. There are two kinds of argument:"

msgstr ""

"呼叫函式時被傳遞給 :term:`function`\\ （或 :term:`method`\\ ）的值。引數有兩"

"種："

#: ../../glossary.rst:66

msgid ""

":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "

"``name=``) in a function call or passed as a value in a dictionary preceded "

"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the "

"following calls to :func:`complex`::"

msgstr ""

":dfn:`關鍵字引數 (keyword argument)`：在函式呼叫中，以識別字（identifier，例"

"如 ``name=``\\ ）開頭的引數，或是以 ``**`` 後面 dictionary（字典）內的值被傳"

"遞的引數。例如，``3`` 和 ``5`` 都是以下 :func:`complex` 呼叫中的關鍵字引"

"數： ::"

#: ../../glossary.rst:71

msgid ""

"complex(real=3, imag=5)\n"

"complex(**{'real': 3, 'imag': 5})"

msgstr ""

"complex(real=3, imag=5)\n"

"complex(**{'real': 3, 'imag': 5})"

#: ../../glossary.rst:74

msgid ""

":dfn:`positional argument`: an argument that is not a keyword argument. "

"Positional arguments can appear at the beginning of an argument list and/or "

"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "

"``3`` and ``5`` are both positional arguments in the following calls::"

msgstr ""

":dfn:`位置引數 (positional argument)`：不是關鍵字引數的引數。位置引數可在一個"

"引數列表的起始處出現，和（或）作為 ``*`` 之後的 :term:`iterable`\\ （可疊代物"

"件）中的元素被傳遞。例如，``3`` 和 ``5`` 都是以下呼叫中的位置引數： ::"

#: ../../glossary.rst:80

msgid ""

"complex(3, 5)\n"

"complex(*(3, 5))"

msgstr ""

"complex(3, 5)\n"

"complex(*(3, 5))"

#: ../../glossary.rst:83

msgid ""

"Arguments are assigned to the named local variables in a function body. See "

"the :ref:`calls` section for the rules governing this assignment. "

"Syntactically, any expression can be used to represent an argument; the "

"evaluated value is assigned to the local variable."

msgstr ""

"引數會被指定給函式主體中的附名區域變數。關於支配這個指定過程的規則，請參閱"

"\\ :ref:`calls`\\ 章節。在語法上，任何運算式都可以被用來表示一個引數；其評估"

"值會被指定給區域變數。"

#: ../../glossary.rst:88

msgid ""

"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "

"difference between arguments and parameters <faq-argument-vs-parameter>`, "

"and :pep:`362`."

msgstr ""

"另請參閱術語表的 :term:`parameter`\\ （參數）條目、常見問題中的\\ :ref:`引數"

"和參數之間的差異 <faq-argument-vs-parameter>`，以及 :pep:`362`。"

#: ../../glossary.rst:91

msgid "asynchronous context manager"

msgstr "asynchronous context manager（非同步情境管理器）"

#: ../../glossary.rst:93

msgid ""

"An object which controls the environment seen in an :keyword:`async with` "

"statement by defining :meth:`~object.__aenter__` and :meth:`~object."

"__aexit__` methods. Introduced by :pep:`492`."

msgstr ""

"一個可以控制 :keyword:`async with` 陳述式中所見環境的物件，而它是透過定義 :"

"meth:`~object.__aenter__` 和 :meth:`~object.__aexit__` method（方法）來控制"

"的。由 :pep:`492` 引入。"

#: ../../glossary.rst:96

msgid "asynchronous generator"

msgstr "asynchronous generator（非同步產生器）"

#: ../../glossary.rst:98

msgid ""

"A function which returns an :term:`asynchronous generator iterator`. It "

"looks like a coroutine function defined with :keyword:`async def` except "

"that it contains :keyword:`yield` expressions for producing a series of "

"values usable in an :keyword:`async for` loop."

msgstr ""

"一個會回傳 :term:`asynchronous generator iterator`\\ （非同步產生器疊代器）的"

"函式。它看起來像一個以 :keyword:`async def` 定義的協程函式 (coroutine "

"function)，但不同的是它包含了 :keyword:`yield` 運算式，能生成一系列可用於 :"

"keyword:`async for` 迴圈的值。"

#: ../../glossary.rst:103

msgid ""

"Usually refers to an asynchronous generator function, but may refer to an "

"*asynchronous generator iterator* in some contexts. In cases where the "

"intended meaning isn't clear, using the full terms avoids ambiguity."

msgstr ""

"這個術語通常用來表示一個非同步產生器函式，但在某些情境中，也可能是表示\\ *非"

"同步產生器疊代器 (asynchronous generator iterator)*。萬一想表達的意思不夠清"

"楚，那就使用完整的術語，以避免歧義。"

#: ../../glossary.rst:107

msgid ""

"An asynchronous generator function may contain :keyword:`await` expressions "

"as well as :keyword:`async for`, and :keyword:`async with` statements."

msgstr ""

"一個非同步產生器函式可能包含 :keyword:`await` 運算式，以及 :keyword:`async "

"for` 和 :keyword:`async with` 陳述式。"

#: ../../glossary.rst:110

msgid "asynchronous generator iterator"

msgstr "asynchronous generator iterator（非同步產生器疊代器）"

#: ../../glossary.rst:112

msgid "An object created by an :term:`asynchronous generator` function."

msgstr ""

"一個由 :term:`asynchronous generator`\\ （非同步產生器）函式所建立的物件。"

#: ../../glossary.rst:114

msgid ""

"This is an :term:`asynchronous iterator` which when called using the :meth:"

"`~object.__anext__` method returns an awaitable object which will execute "

"the body of the asynchronous generator function until the next :keyword:"

"`yield` expression."

msgstr ""

"這是一個 :term:`asynchronous iterator`\\ （非同步疊代器），當它以 :meth:"

"`~object.__anext__` method 被呼叫時，會回傳一個可等待物件 (awaitable "

"object)，該物件將執行非同步產生器的函式主體，直到遇到下一個 :keyword:`yield` "

"運算式。"

#: ../../glossary.rst:119

msgid ""

"Each :keyword:`yield` temporarily suspends processing, remembering the "

"execution state (including local variables and pending try-statements). "

"When the *asynchronous generator iterator* effectively resumes with another "

"awaitable returned by :meth:`~object.__anext__`, it picks up where it left "

"off. See :pep:`492` and :pep:`525`."

msgstr ""

"每個 :keyword:`yield` 會暫停處理程序，並記住執行狀態（包括區域變數及擱置中的 "

"try 陳述式）。當\\ *非同步產生器疊代器*\\ 以另一個被 :meth:`~object."

"__anext__` 回傳的可等待物件有效地回復時，它會從停止的地方繼續執行。請參閱 :"

"pep:`492` 和 :pep:`525`。"

#: ../../glossary.rst:124

msgid "asynchronous iterable"

msgstr "asynchronous iterable（非同步可疊代物件）"

#: ../../glossary.rst:126

msgid ""

"An object, that can be used in an :keyword:`async for` statement. Must "

"return an :term:`asynchronous iterator` from its :meth:`~object.__aiter__` "

"method. Introduced by :pep:`492`."

msgstr ""

"一個物件，它可以在 :keyword:`async for` 陳述式中被使用。必須從它的 :meth:"

"`~object.__aiter__` method 回傳一個 :term:`asynchronous iterator`\\ （非同步"

"疊代器）。由 :pep:`492` 引入。"

#: ../../glossary.rst:129

msgid "asynchronous iterator"

msgstr "asynchronous iterator（非同步疊代器）"

#: ../../glossary.rst:131

msgid ""

"An object that implements the :meth:`~object.__aiter__` and :meth:`~object."

"__anext__` methods. :meth:`~object.__anext__` must return an :term:"

"`awaitable` object. :keyword:`async for` resolves the awaitables returned by "

"an asynchronous iterator's :meth:`~object.__anext__` method until it raises "

"a :exc:`StopAsyncIteration` exception. Introduced by :pep:`492`."

msgstr ""

"一個實作 :meth:`~object.__aiter__` 和 :meth:`~object.__anext__` method 的物"

"件。:meth:`~object.__anext__` 必須回傳一個 :term:`awaitable`\\ （可等待物"

"件）。:keyword:`async for` 會解析非同步疊代器的 :meth:`~object.__anext__` "

"method 所回傳的可等待物件，直到它引發 :exc:`StopAsyncIteration` 例外。由 :"

"pep:`492` 引入。"

#: ../../glossary.rst:136

msgid "atomic operation"

msgstr ""

#: ../../glossary.rst:138

msgid ""

"An operation that appears to execute as a single, indivisible step: no other "

"thread can observe it half-done, and its effects become visible all at "

"once. Python does not guarantee that high-level statements are atomic (for "

"example, ``x += 1`` performs multiple bytecode operations and is not "

"atomic). Atomicity is only guaranteed where explicitly documented. See "

"also :term:`race condition` and :term:`data race`."

msgstr ""

#: ../../glossary.rst:144

msgid "attached thread state"

msgstr ""

#: ../../glossary.rst:147

msgid "A :term:`thread state` that is active for the current OS thread."

msgstr ""

#: ../../glossary.rst:149

msgid ""

"When a :term:`thread state` is attached, the OS thread has access to the "

"full Python C API and can safely invoke the bytecode interpreter."

msgstr ""

#: ../../glossary.rst:153

msgid ""

"Unless a function explicitly notes otherwise, attempting to call the C API "

"without an attached thread state will result in a fatal error or undefined "

"behavior. A thread state can be attached and detached explicitly by the "

"user through the C API, or implicitly by the runtime, including during "

"blocking C calls and by the bytecode interpreter in between calls."

msgstr ""

#: ../../glossary.rst:160

msgid ""

"On most builds of Python, having an attached thread state implies that the "

"caller holds the :term:`GIL` for the current interpreter, so only one OS "

"thread can have an attached thread state at a given moment. In :term:`free-"

"threaded <free threading>` builds of Python, threads can concurrently hold "

"an attached thread state, allowing for true parallelism of the bytecode "

"interpreter."

msgstr ""

#: ../../glossary.rst:166

msgid "attribute"

msgstr "attribute（屬性）"

#: ../../glossary.rst:168

msgid ""

"A value associated with an object which is usually referenced by name using "

"dotted expressions. For example, if an object *o* has an attribute *a* it "

"would be referenced as *o.a*."

msgstr ""

"一個與某物件相關聯的值，該值大多能透過使用點分隔運算式 (dotted expression) 的"

"名稱被參照。例如，如果物件 *o* 有一個屬性 *a*，則該屬性能以 *o.a* 被參照。"

#: ../../glossary.rst:173

msgid ""

"It is possible to give an object an attribute whose name is not an "

"identifier as defined by :ref:`identifiers`, for example using :func:"

"`setattr`, if the object allows it. Such an attribute will not be accessible "

"using a dotted expression, and would instead need to be retrieved with :func:"

"`getattr`."

msgstr ""

"如果一個物件允許，給予該物件一個名稱不是由\\ :ref:`identifiers`\\ 所定義之識"

"別符 (identifier) 的屬性是有可能的，例如使用 :func:`setattr`。像這樣的屬性將"

"無法使用點分隔運算式來存取，而是需要使用 :func:`getattr` 來取得它。"

#: ../../glossary.rst:178

msgid "awaitable"

msgstr "awaitable（可等待物件）"

#: ../../glossary.rst:180

msgid ""

"An object that can be used in an :keyword:`await` expression. Can be a :"

"term:`coroutine` or an object with an :meth:`~object.__await__` method. See "

"also :pep:`492`."

msgstr ""

"一個可以在 :keyword:`await` 運算式中被使用的物件。它可以是一個 :term:"

"`coroutine`\\ （協程），或是一個有 :meth:`~object.__await__` method 的物件。"

"另請參閱 :pep:`492`。"

#: ../../glossary.rst:183

msgid "BDFL"

msgstr "BDFL"

#: ../../glossary.rst:185

msgid ""

"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://gvanrossum."

"github.io/>`_, Python's creator."

msgstr ""

"Benevolent Dictator For Life（終身仁慈獨裁者），又名 `Guido van Rossum "

"<https://gvanrossum.github.io/>`_，Python 的創造者。"

#: ../../glossary.rst:187

msgid "binary file"

msgstr "binary file（二進位檔案）"

#: ../../glossary.rst:189

msgid ""

"A :term:`file object` able to read and write :term:`bytes-like objects "

"<bytes-like object>`. Examples of binary files are files opened in binary "

"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer <sys."

"stdin>`, :data:`sys.stdout.buffer <sys.stdout>`, and instances of :class:`io."

"BytesIO` and :class:`gzip.GzipFile`."

msgstr ""

"一個能夠讀取和寫入 :term:`bytes-like objects <bytes-like object>`\\ （類位元"

"組串物件）的 :term:`file object`\\ （檔案物件）。二進位檔案的例子有：以二進位"

"模式（``'rb'``、``'wb'`` 或 ``'rb+'``）開啟的檔案、:data:`sys.stdin.buffer "

"<sys.stdin>`、:data:`sys.stdout.buffer <sys.stdout>`，以及 :class:`io."

"BytesIO` 和 :class:`gzip.GzipFile` 實例。"

#: ../../glossary.rst:196

msgid ""

"See also :term:`text file` for a file object able to read and write :class:"

"`str` objects."

msgstr ""

"另請參閱 :term:`text file`\\ （文字檔案），它是一個能夠讀取和寫入 :class:"

"`str` 物件的檔案物件。"

#: ../../glossary.rst:198

msgid "borrowed reference"

msgstr "borrowed reference（借用參照）"

#: ../../glossary.rst:200

msgid ""

"In Python's C API, a borrowed reference is a reference to an object, where "

"the code using the object does not own the reference. It becomes a dangling "

"pointer if the object is destroyed. For example, a garbage collection can "

"remove the last :term:`strong reference` to the object and so destroy it."

msgstr ""

"在 Python 的 C API 中，借用參照是一個對物件的參照，其中使用該物件的程式碼並不"

"擁有這個參照。如果該物件被銷毀，它會成為一個迷途指標 (dangling pointer)。例"

"如，一次垃圾回收 (garbage collection) 可以移除對物件的最後一個 :term:`strong "

"reference`\\ （強參照），而將該物件銷毀。"

#: ../../glossary.rst:206

msgid ""

"Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended "

"to convert it to a :term:`strong reference` in-place, except when the object "

"cannot be destroyed before the last usage of the borrowed reference. The :c:"

"func:`Py_NewRef` function can be used to create a new :term:`strong "

"reference`."

msgstr ""

"對 :term:`borrowed reference` 呼叫 :c:func:`Py_INCREF` 以將它原地 (in-place) "

"轉換為 :term:`strong reference` 是被建議的做法，除非該物件不能在最後一次使用"

"借用參照之前被銷毀。:c:func:`Py_NewRef` 函式可用於建立一個新的 :term:`strong "

"reference`。"

#: ../../glossary.rst:211

msgid "bytes-like object"

msgstr "bytes-like object（類位元組串物件）"

#: ../../glossary.rst:213

msgid ""

"An object that supports the :ref:`bufferobjects` and can export a C-:term:"

"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, "

"and :class:`array.array` objects, as well as many common :class:`memoryview` "

"objects. Bytes-like objects can be used for various operations that work "

"with binary data; these include compression, saving to a binary file, and "

"sending over a socket."

msgstr ""

"一個支援\\ :ref:`bufferobjects`\\ 且能夠匯出 C-:term:`contiguous` 緩衝區的物"

"件。這包括所有的 :class:`bytes`、:class:`bytearray` 和 :class:`array.array` "

"物件，以及許多常見的 :class:`memoryview` 物件。類位元組串物件可用於處理二進位"

"資料的各種運算；這些運算包括壓縮、儲存至二進位檔案和透過 socket（插座）發送。"

#: ../../glossary.rst:220

msgid ""

"Some operations need the binary data to be mutable. The documentation often "

"refers to these as \"read-write bytes-like objects\". Example mutable "

"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :"

"class:`bytearray`. Other operations require the binary data to be stored in "

"immutable objects (\"read-only bytes-like objects\"); examples of these "

"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."

msgstr ""

"有些運算需要二進位資料是可變的。說明文件通常會將這些物件稱為「可讀寫的類位元"

"組串物件」。可變緩衝區的物件包括 :class:`bytearray`，以及 :class:`bytearray` "

"的 :class:`memoryview`。其他的運算需要讓二進位資料被儲存在不可變物件（「唯讀"

"的類位元組串物件」）中；這些物件包括 :class:`bytes`，以及 :class:`bytes` 物件"

"的 :class:`memoryview`。"

#: ../../glossary.rst:228

msgid "bytecode"

msgstr "bytecode（位元組碼）"

#: ../../glossary.rst:230

msgid ""

"Python source code is compiled into bytecode, the internal representation of "

"a Python program in the CPython interpreter. The bytecode is also cached in "

"``.pyc`` files so that executing the same file is faster the second time "

"(recompilation from source to bytecode can be avoided). This \"intermediate "

"language\" is said to run on a :term:`virtual machine` that executes the "

"machine code corresponding to each bytecode. Do note that bytecodes are not "

"expected to work between different Python virtual machines, nor to be stable "

"between Python releases."

msgstr ""

"Python 的原始碼會被編譯成位元組碼，它是 Python 程式在 CPython 直譯器中的內部"

"表示法。該位元組碼也會被暫存在 ``.pyc`` 檔案中，以便第二次執行同一個檔案時能"

"夠更快速（可以不用從原始碼重新編譯為位元組碼）。這種「中間語言 (intermediate "

"language)」據說是運行在一個 :term:`virtual machine`\\ （虛擬機器）上，該虛擬"

"機器會執行與每個位元組碼對應的機器碼 (machine code)。要注意的是，位元組碼理論"

"上是無法在不同的 Python 虛擬機器之間運作的，也不能在不同版本的 Python 之間保"

"持穩定。"

#: ../../glossary.rst:240

msgid ""

"A list of bytecode instructions can be found in the documentation for :ref:"

"`the dis module <bytecodes>`."

msgstr ""

"位元組碼的指令列表可以在 :ref:`dis 模組 <bytecodes>`\\ 的說明文件中找到。"

#: ../../glossary.rst:242

msgid "callable"

msgstr "callable（可呼叫物件）"

#: ../../glossary.rst:244

msgid ""

"A callable is an object that can be called, possibly with a set of arguments "

"(see :term:`argument`), with the following syntax::"

msgstr ""

"一個 callable 是可以被呼叫的物件，呼叫時可能以下列形式帶有一組引數（請見 :"

"term:`argument`）： ::"

#: ../../glossary.rst:247

msgid "callable(argument1, argument2, argumentN)"

msgstr "callable(argument1, argument2, argumentN)"

#: ../../glossary.rst:249

msgid ""

"A :term:`function`, and by extension a :term:`method`, is a callable. An "

"instance of a class that implements the :meth:`~object.__call__` method is "

"also a callable."

msgstr ""

"一個 :term:`function` 與其延伸的 :term:`method` 都是 callable。一個有實作 :"

"meth:`~object.__call__` 方法的 class 之實例也是個 callable。"

#: ../../glossary.rst:252

msgid "callback"

msgstr "callback（回呼）"

#: ../../glossary.rst:254

msgid ""

"A subroutine function which is passed as an argument to be executed at some "

"point in the future."

msgstr ""

"作為引數被傳遞的一個副程式 (subroutine) 函式，會在未來的某個時間點被執行。"

#: ../../glossary.rst:256

msgid "class"

msgstr "class（類別）"

#: ../../glossary.rst:258

msgid ""

"A template for creating user-defined objects. Class definitions normally "

"contain method definitions which operate on instances of the class."

msgstr ""

"一個用於建立使用者定義物件的模板。Class 的定義通常會包含 method 的定義，這些 "

"method 可以在 class 的實例上進行操作。"

#: ../../glossary.rst:261

msgid "class variable"

msgstr "class variable（類別變數）"

#: ../../glossary.rst:263

msgid ""

"A variable defined in a class and intended to be modified only at class "

"level (i.e., not in an instance of the class)."

msgstr ""

"一個在 class 中被定義，且應該只能在 class 層次（意即不是在 class 的實例中）被"

"修改的變數。"

#: ../../glossary.rst:265

msgid "closure variable"

msgstr "closure variable（閉包變數）"

#: ../../glossary.rst:267

msgid ""

"A :term:`free variable` referenced from a :term:`nested scope` that is "

"defined in an outer scope rather than being resolved at runtime from the "

"globals or builtin namespaces. May be explicitly defined with the :keyword:"

"`nonlocal` keyword to allow write access, or implicitly defined if the "

"variable is only being read."

msgstr ""

"從外部作用域中定義且從\\ :term:`巢狀作用域 <nested scope>`\\ 參照的\\ :term:`"

"自由變數 <free variable>`，不是於 runtime 從全域或內建命名空間解析。可以使"

"用 :keyword:`nonlocal` 關鍵字明確定義以允許寫入存取，或者如果僅需讀取變數則隱"

"式定義即可。"

#: ../../glossary.rst:272

msgid ""

"For example, in the ``inner`` function in the following code, both ``x`` and "

"``print`` are :term:`free variables <free variable>`, but only ``x`` is a "

"*closure variable*::"

msgstr ""

"例如在下面程式碼中的 ``inner`` 函式中，``x`` 和 ``print`` 都是\\ :term:`自由"

"變數 <free variable>`，但只有 ``x`` 是\\ *閉包變數*： ::"

#: ../../glossary.rst:275

msgid ""

"def outer():\n"

" x = 0\n"

" def inner():\n"

" nonlocal x\n"

" x += 1\n"

" print(x)\n"

" return inner"

msgstr ""

"def outer():\n"

" x = 0\n"

" def inner():\n"

" nonlocal x\n"

" x += 1\n"

" print(x)\n"

" return inner"

#: ../../glossary.rst:283

msgid ""

"Due to the :attr:`codeobject.co_freevars` attribute (which, despite its "

"name, only includes the names of closure variables rather than listing all "

"referenced free variables), the more general :term:`free variable` term is "

"sometimes used even when the intended meaning is to refer specifically to "

"closure variables."

msgstr ""

"由於 :attr:`codeobject.co_freevars` 屬性（儘管名稱如此，但它僅包含閉包變數的"

"名稱，而不是列出所有參照的自由變數），當預期含義是特指閉包變數時，有時候甚至"

"也會使用更通用的\\ :term:`自由變數 <free variable>`\\ 一詞。"

#: ../../glossary.rst:287

msgid "complex number"

msgstr "complex number（複數）"

#: ../../glossary.rst:289

msgid ""

"An extension of the familiar real number system in which all numbers are "

"expressed as a sum of a real part and an imaginary part. Imaginary numbers "

"are real multiples of the imaginary unit (the square root of ``-1``), often "

"written ``i`` in mathematics or ``j`` in engineering. Python has built-in "

"support for complex numbers, which are written with this latter notation; "

"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get "

"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. "

"Use of complex numbers is a fairly advanced mathematical feature. If you're "

"not aware of a need for them, it's almost certain you can safely ignore them."

msgstr ""

"一個我們熟悉的實數系統的擴充，在此所有數字都會被表示為一個實部和一個虛部之"

"和。虛數就是虛數單位（``-1`` 的平方根）的實數倍，此單位通常在數學中被寫為 "

"``i``，在工程學中被寫為 ``j``。Python 內建了對複數的支援，它是用後者的記法來"

"表示複數；虛部會帶著一個後綴的 ``j`` 被編寫，例如 ``3+1j``。若要將 :mod:"

"`math` 模組內的工具等效地用於複數，請使用 :mod:`cmath` 模組。複數的使用是一個"

"相當進階的數學功能。如果你沒有察覺到對它們的需求，那麼幾乎能確定你可以安全地"

"忽略它們。"

#: ../../glossary.rst:299

msgid "concurrency"

msgstr "concurrency（並行性）"

#: ../../glossary.rst:301

msgid ""

"The ability of a computer program to perform multiple tasks at the same "

"time. Python provides libraries for writing programs that make use of "

"different forms of concurrency. :mod:`asyncio` is a library for dealing "

"with asynchronous tasks and coroutines. :mod:`threading` provides access to "

"operating system threads and :mod:`multiprocessing` to operating system "

"processes. Multi-core processors can execute threads and processes on "

"different CPU cores at the same time (see :term:`parallelism`)."

msgstr ""

#: ../../glossary.rst:309

msgid "concurrent modification"

msgstr ""

#: ../../glossary.rst:311

msgid ""

"When multiple threads modify shared data at the same time. Concurrent "

"modification without proper synchronization can cause :term:`race conditions "

"<race condition>`, and might also trigger a :term:`data race <data race>`, "

"data corruption, or both."

msgstr ""

#: ../../glossary.rst:315

msgid "context"

msgstr "context（情境）"

#: ../../glossary.rst:317

msgid ""

"This term has different meanings depending on where and how it is used. Some "

"common meanings:"

msgstr ""

#: ../../glossary.rst:320

msgid ""

"The temporary state or environment established by a :term:`context manager` "

"via a :keyword:`with` statement."

msgstr ""

#: ../../glossary.rst:322

msgid ""

"The collection of key­value bindings associated with a particular :class:"

"`contextvars.Context` object and accessed via :class:`~contextvars."

"ContextVar` objects. Also see :term:`context variable`."

msgstr ""

#: ../../glossary.rst:326

msgid ""

"A :class:`contextvars.Context` object. Also see :term:`current context`."

msgstr ""

"一個 :class:`contextvars.Context` 物件。另請參閱 :term:`current context`。"

#: ../../glossary.rst:328

msgid "context management protocol"

msgstr "context management protocol（情境管理協定）"

#: ../../glossary.rst:330

msgid ""

"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "

"the :keyword:`with` statement. See :pep:`343`."

msgstr ""

"由 :keyword:`with` 陳述式所呼叫的 :meth:`~object.__enter__` 和 :meth:"

"`~object.__exit__` 方法。另請參閱 :pep:`343`。"

#: ../../glossary.rst:332

msgid "context manager"

msgstr "context manager（情境管理器）"

#: ../../glossary.rst:334

msgid ""

"An object which implements the :term:`context management protocol` and "

"controls the environment seen in a :keyword:`with` statement. See :pep:"

"`343`."

msgstr ""

#: ../../glossary.rst:337

msgid "context variable"

msgstr "context variable（情境變數）"

#: ../../glossary.rst:339

msgid ""

"A variable whose value depends on which context is the :term:`current "

"context`. Values are accessed via :class:`contextvars.ContextVar` objects. "

"Context variables are primarily used to isolate state between concurrent "

"asynchronous tasks."

msgstr ""

#: ../../glossary.rst:343

msgid "contiguous"

msgstr "contiguous（連續的）"

#: ../../glossary.rst:347

msgid ""

"A buffer is considered contiguous exactly if it is either *C-contiguous* or "

"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran "

"contiguous. In one-dimensional arrays, the items must be laid out in memory "

"next to each other, in order of increasing indexes starting from zero. In "

"multidimensional C-contiguous arrays, the last index varies the fastest when "

"visiting items in order of memory address. However, in Fortran contiguous "

"arrays, the first index varies the fastest."

msgstr ""

"如果一個緩衝區是 *C-contiguous* 或是 *Fortran contiguous*，則它會確切地被視為"

"是連續的。零維 (zero-dimensional) 的緩衝區都是 C 及 Fortran contiguous。在一"

"維 (one-dimensional) 陣列中，各項目必須在記憶體中彼此相鄰地排列，而其索引順序"

"是從零開始遞增。在多維的 (multidimensional) C-contiguous 陣列中，按記憶體位址"

"的順序瀏覽各個項目時，最後一個索引的變化最快。然而，在 Fortran contiguous 陣"

"列中，第一個索引的變化最快。"

#: ../../glossary.rst:355

msgid "coroutine"

msgstr "coroutine（協程）"

#: ../../glossary.rst:357

msgid ""

"Coroutines are a more generalized form of subroutines. Subroutines are "

"entered at one point and exited at another point. Coroutines can be "

"entered, exited, and resumed at many different points. They can be "

"implemented with the :keyword:`async def` statement. See also :pep:`492`."

msgstr ""

"協程是副程式 (subroutine) 的一種更為廣義的形式。副程式是在某個時間點被進入並"

"在另一個時間點被退出。協程可以在許多不同的時間點被進入、退出和回復。它們能夠"

"以 :keyword:`async def` 陳述式被實作。另請參閱 :pep:`492`。"

#: ../../glossary.rst:362

msgid "coroutine function"

msgstr "coroutine function（協程函式）"

#: ../../glossary.rst:364

msgid ""

"A function which returns a :term:`coroutine` object. A coroutine function "

"may be defined with the :keyword:`async def` statement, and may contain :"

"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. "

"These were introduced by :pep:`492`."

msgstr ""

"一個回傳 :term:`coroutine`\\ （協程）物件的函式。一個協程函式能以 :keyword:"

"`async def` 陳述式被定義，並可能會包含 :keyword:`await`、:keyword:`async "

"for` 和 :keyword:`async with` 關鍵字。這些關鍵字由 :pep:`492` 引入。"

#: ../../glossary.rst:369

msgid "CPython"

msgstr "CPython"

#: ../../glossary.rst:371

msgid ""

"The canonical implementation of the Python programming language, as "

"distributed on `python.org <https://www.python.org>`_. The term \"CPython\" "

"is used when necessary to distinguish this implementation from others such "

"as Jython or IronPython."

msgstr ""

"Python 程式語言的標準實作 (canonical implementation)，被發布在 `python.org "

"<https://www.python.org>`_ 上。「CPython」這個術語在必要時被使用，以區分此實"

"作與其它語言的實作，例如 Jython 或 IronPython。"

#: ../../glossary.rst:375

msgid "current context"

msgstr ""

#: ../../glossary.rst:377

msgid ""

"The :term:`context` (:class:`contextvars.Context` object) that is currently "

"used by :class:`~contextvars.ContextVar` objects to access (get or set) the "

"values of :term:`context variables <context variable>`. Each thread has its "

"own current context. Frameworks for executing asynchronous tasks (see :mod:"

"`asyncio`) associate each task with a context which becomes the current "

"context whenever the task starts or resumes execution."

msgstr ""

#: ../../glossary.rst:383

msgid "cyclic isolate"

msgstr ""

#: ../../glossary.rst:385

msgid ""

"A subgroup of one or more objects that reference each other in a reference "

"cycle, but are not referenced by objects outside the group. The goal of "

"the :term:`cyclic garbage collector <garbage collection>` is to identify "

"these groups and break the reference cycles so that the memory can be "

"reclaimed."

msgstr ""

#: ../../glossary.rst:389

msgid "data race"

msgstr ""

#: ../../glossary.rst:391

msgid ""

"A situation where multiple threads access the same memory location "

"concurrently, at least one of the accesses is a write, and the threads do "

"not use any synchronization to control their access. Data races lead to :"

"term:`non-deterministic` behavior and can cause data corruption. Proper use "

"of :term:`locks <lock>` and other :term:`synchronization primitives "

"<synchronization primitive>` prevents data races. Note that data races can "

"only happen in native code, but that :term:`native code` might be exposed in "

"a Python API. See also :term:`race condition` and :term:`thread-safe`."

msgstr ""

#: ../../glossary.rst:400

msgid "deadlock"

msgstr ""

#: ../../glossary.rst:402

msgid ""

"A situation in which two or more tasks (threads, processes, or coroutines) "

"wait indefinitely for each other to release resources or complete actions, "

"preventing any from making progress. For example, if thread A holds lock 1 "

"and waits for lock 2, while thread B holds lock 2 and waits for lock 1, both "

"threads will wait indefinitely. In Python this often arises from acquiring "

"multiple locks in conflicting orders or from circular join/await "

"dependencies. Deadlocks can be avoided by always acquiring multiple :term:"

"`locks <lock>` in a consistent order. See also :term:`lock` and :term:"

"`reentrant`."

msgstr ""

#: ../../glossary.rst:411

msgid "decorator"

msgstr "decorator（裝飾器）"

#: ../../glossary.rst:413

msgid ""

"A function returning another function, usually applied as a function "

"transformation using the ``@wrapper`` syntax. Common examples for "

"decorators are :func:`classmethod` and :func:`staticmethod`."

msgstr ""

"一個函式，它會回傳另一個函式，通常它會使用 ``@wrapper`` 語法，被應用為一種函"

"式的變換 (function transformation)。裝飾器的常見範例是 :func:`classmethod` "

"和 :func:`staticmethod`。"

#: ../../glossary.rst:417

msgid ""

"The decorator syntax is merely syntactic sugar, the following two function "

"definitions are semantically equivalent::"

msgstr "裝飾器語法只是語法糖。以下兩個函式定義在語義上是等效的： ::"

#: ../../glossary.rst:420

msgid ""

"def f(arg):\n"

" ...\n"

"f = staticmethod(f)\n"

"\n"

"@staticmethod\n"

"def f(arg):\n"

" ..."

msgstr ""

"def f(arg):\n"

" ...\n"

"f = staticmethod(f)\n"

"\n"

"@staticmethod\n"

"def f(arg):\n"

" ..."

#: ../../glossary.rst:428

msgid ""

"The same concept exists for classes, but is less commonly used there. See "

"the documentation for :ref:`function definitions <function>` and :ref:`class "

"definitions <class>` for more about decorators."

msgstr ""

"Class 也存在相同的概念，但在那裡比較不常用。關於裝飾器的更多內容，請參閱\\ :"

"ref:`函式定義 <function>`\\ 和 :ref:`class 定義 <class>`\\ 的說明文件。"

#: ../../glossary.rst:431

msgid "descriptor"

msgstr "descriptor（描述器）"

#: ../../glossary.rst:433

msgid ""

"Any object which defines the methods :meth:`~object.__get__`, :meth:`~object."

"__set__`, or :meth:`~object.__delete__`. When a class attribute is a "

"descriptor, its special binding behavior is triggered upon attribute "

"lookup. Normally, using *a.b* to get, set or delete an attribute looks up "

"the object named *b* in the class dictionary for *a*, but if *b* is a "

"descriptor, the respective descriptor method gets called. Understanding "

"descriptors is a key to a deep understanding of Python because they are the "

"basis for many features including functions, methods, properties, class "

"methods, static methods, and reference to super classes."

msgstr ""

"任何定義了 :meth:`~object.__get__`、:meth:`~object.__set__` 或 :meth:"

"`~object.__delete__` method 的物件。當一個 class 屬性是一個描述器時，它的特殊"

"連結行為會在屬性查找時被觸發。通常，使用 *a.b* 來取得、設定或刪除某個屬性時，"

"會在 *a* 的 class 字典中查找名稱為 *b* 的物件，但如果 *b* 是一個描述器，則相"

"對應的描述器 method 會被呼叫。對描述器的理解是深入理解 Python 的關鍵，因為它"

"們是許多功能的基礎，這些功能包括函式、method、屬性 (property)、class method、"

"靜態 method，以及對 super class（父類別）的參照。"

#: ../../glossary.rst:444

msgid ""

"For more information about descriptors' methods, see :ref:`descriptors` or "

"the :ref:`Descriptor How To Guide <descriptorhowto>`."

msgstr ""

"關於描述器 method 的更多資訊，請參閱\\ :ref:`descriptors`\\ 或\\ :ref:`描述器"

"使用指南 <descriptorhowto>`。"

#: ../../glossary.rst:446

msgid "dictionary"

msgstr "dictionary（字典）"

#: ../../glossary.rst:448

msgid ""

"An associative array, where arbitrary keys are mapped to values. The keys "

"can be any object with :meth:`~object.__hash__` and :meth:`~object.__eq__` "

"methods. Called a hash in Perl."

msgstr ""

"一個關聯陣列 (associative array)，其中任意的鍵會被對映到值。鍵可以是任何帶"

"有 :meth:`~object.__hash__` 和 :meth:`~object.__eq__` method 的物件。在 Perl "

"中被稱為雜湊 (hash)。"

#: ../../glossary.rst:452

msgid "dictionary comprehension"

msgstr "dictionary comprehension（字典綜合運算）"

#: ../../glossary.rst:454

msgid ""

"A compact way to process all or part of the elements in an iterable and "

"return a dictionary with the results. ``results = {n: n ** 2 for n in "

"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n "

"** 2``. See :ref:`comprehensions`."

msgstr ""

"一種緊密的方法，用來處理一個可疊代物件中的全部或部分元素，並將處理結果以一個"

"字典回傳。``results = {n: n ** 2 for n in range(10)}`` 會產生一個字典，它包含"

"了鍵 ``n`` 對映到值 ``n ** 2``。請參閱\\ :ref:`comprehensions`。"

#: ../../glossary.rst:458