# SOME DESCRIPTIVE TITLE.

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

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

# Translators:

# Steven Hsu <hsuhaochun@gmail.com>, 2021

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2021-10-26 16:30+0000\n"

"PO-Revision-Date: 2021-10-27 00:04+0800\n"

"Last-Translator: Steven Hsu <hsuhaochun@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 2.4.3\n"

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

msgid "Glossary"

msgstr "術語表"

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

msgid "``>>>``"

msgstr "``>>>``"

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

msgid ""

"The default Python prompt of the interactive shell. Often seen for code "

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

msgstr ""

"互動式 shell 的預設 Python 提示字元。常見於能在直譯器中以互動方式被執行的程式"

"碼範例。"

#: ../../glossary.rst:14

msgid "``...``"

msgstr "``...``"

#: ../../glossary.rst:16

msgid "Can refer to:"

msgstr "可以表示："

#: ../../glossary.rst:18

msgid ""

"The default Python prompt of the 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) 之後，要輸入程式碼"

"時，互動式 shell 顯示的預設 Python 提示字元。"

#: ../../glossary.rst:23

msgid "The :const:`Ellipsis` built-in constant."

msgstr "內建常數 :const:`Ellipsis`\\ 。"

#: ../../glossary.rst:24

msgid "2to3"

msgstr "2to3"

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

msgid ""

"A tool that tries to convert Python 2.x code to Python 3.x code by handling "

"most of the incompatibilities which can be detected by parsing the source "

"and traversing the parse tree."

msgstr ""

"一個試著將 Python 2.x 程式碼轉換為 Python 3.x 程式碼的工具，它是透過處理大部"

"分的不相容性來達成此目的，而這些不相容性能夠透過剖析原始碼和遍歷剖析樹而被檢"

"測出來。"

#: ../../glossary.rst:30

msgid ""

"2to3 is available in the standard library as :mod:`lib2to3`; a standalone "

"entry point is provided as :file:`Tools/scripts/2to3`. See :ref:`2to3-"

"reference`."

msgstr ""

"2to3 在可以標準函式庫中以 :mod:`lib2to3` 被使用；它提供了一個獨立的入口點，"

"在 :file:`Tools/scripts/2to3`\\ 。請參閱 :ref:`2to3-reference`。"

#: ../../glossary.rst:33

msgid "abstract base class"

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

#: ../../glossary.rst:35

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: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 are stored "

"in the :attr:`__annotations__` special attribute of modules, classes, and "

"functions, respectively."

msgstr ""

"在運行時 (runtime)，區域變數的註釋無法被存取，但全域變數、class 屬性和函式的"

"註解，會分別被儲存在模組、class 和函式的 :attr:`__annotations__` 特殊屬性中。"

#: ../../glossary.rst:58

msgid ""

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

"and :pep:`526`, which describe this functionality."

msgstr ""

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

"\\ 、\\ :pep:`484` 和 :pep:`526`，這些章節皆有此功能的說明。"

#: ../../glossary.rst:60

msgid "argument"

msgstr "argument（引數）"

#: ../../glossary.rst:62

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:65

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` 呼叫中的關鍵字引"

"數：\n"

"\n"

"::"

#: ../../glossary.rst:73

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`` 都是以下呼叫中的位置引數：\n"

"\n"

"::"

#: ../../glossary.rst:82

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:87

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:90

msgid "asynchronous context manager"

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

#: ../../glossary.rst:92

msgid ""

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

"statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods. "

"Introduced by :pep:`492`."

msgstr ""

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

"meth:`__aenter__` 和 :meth:`__aexit__` method（方法）來控制的。由 :pep:`492` "

"引入。"

#: ../../glossary.rst:95

msgid "asynchronous generator"

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

#: ../../glossary.rst:97

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:102

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:106

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:109

msgid "asynchronous generator iterator"

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

#: ../../glossary.rst:111

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

msgstr ""

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

#: ../../glossary.rst:113

msgid ""

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

"`__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:"

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

"將執行非同步產生器的函式主體，直到遇到下一個 :keyword:`yield` 運算式。"

#: ../../glossary.rst:118

msgid ""

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

"location execution state (including local variables and pending try-"

"statements). When the *asynchronous generator iterator* effectively resumes "

"with another awaitable returned by :meth:`__anext__`, it picks up where it "

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

msgstr ""

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

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

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

"和 :pep:`525`。"

#: ../../glossary.rst:123

msgid "asynchronous iterable"

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

#: ../../glossary.rst:125

msgid ""

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

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

"Introduced by :pep:`492`."

msgstr ""

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

"`__aiter__` method 回傳一個 :term:`asynchronous iterator`\\ （非同步疊代"

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

#: ../../glossary.rst:128

msgid "asynchronous iterator"

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

#: ../../glossary.rst:130

msgid ""

"An object that implements the :meth:`__aiter__` and :meth:`__anext__` "

"methods. ``__anext__`` must return an :term:`awaitable` object. :keyword:"

"`async for` resolves the awaitables returned by an asynchronous iterator's :"

"meth:`__anext__` method until it raises a :exc:`StopAsyncIteration` "

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

msgstr ""

"一個實作 :meth:`__aiter__` 和 :meth:`__anext__` method 的物件。\\ "

"``__anext__`` 必須回傳一個 :term:`awaitable`\\ （可等待物件）。\\ :keyword:"

"`async for` 會解析非同步疊代器的 :meth:`__anext__` method 所回傳的可等待物"

"件，直到它引發 :exc:`StopAsyncIteration` 例外。由 :pep:`492` 引入。"

#: ../../glossary.rst:135

msgid "attribute"

msgstr "attribute（屬性）"

#: ../../glossary.rst:137

msgid ""

"A value associated with an object which is 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:140

msgid "awaitable"

msgstr "awaitable（可等待物件）"

#: ../../glossary.rst:142

msgid ""

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

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

"pep:`492`."

msgstr ""

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

"`coroutine`\\ （協程），或是一個有 :meth:`__await__` method 的物件。另請參"

"閱 :pep:`492`。"

#: ../../glossary.rst:145

msgid "BDFL"

msgstr "BDFL"

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

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:149

msgid "binary file"

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

#: ../../glossary.rst:151

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`, :data:`sys."

"stdout.buffer`, 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`、\\ :data:`sys.stdout.buffer`，以及 :class:`io.BytesIO` 和 :class:"

"`gzip.GzipFile` 實例。"

#: ../../glossary.rst:158

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:160

msgid "bytes-like object"

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

#: ../../glossary.rst:162

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:169

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:177

msgid "bytecode"

msgstr "bytecode（位元組碼）"

#: ../../glossary.rst:179

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:189

msgid ""

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

"`the dis module <bytecodes>`."

msgstr ""

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

#: ../../glossary.rst:191

msgid "callback"

msgstr "callback（回呼）"

#: ../../glossary.rst:193

msgid ""

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

"point in the future."

msgstr ""

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

#: ../../glossary.rst:195

msgid "class"

msgstr "class（類別）"

#: ../../glossary.rst:197

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:200

msgid "class variable"

msgstr "class variable（類別變數）"

#: ../../glossary.rst:202

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:204

msgid "coercion"

msgstr "coercion（強制轉型）"

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

msgid ""

"The implicit conversion of an instance of one type to another during an "

"operation which involves two arguments of the same type. For example, "

"``int(3.15)`` converts the floating point number to the integer ``3``, but "

"in ``3+4.5``, each argument is of a different type (one int, one float), and "

"both must be converted to the same type before they can be added or it will "

"raise a :exc:`TypeError`. Without coercion, all arguments of even "

"compatible types would have to be normalized to the same value by the "

"programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``."

msgstr ""

"在涉及兩個不同型別引數的操作過程中，將某一種型別的實例換為另一種型別的隱式轉"

"換 (implicit conversion) 過程。例如，``int(3.15)`` 會將浮點數轉換為整數 "

"``3``，但在 ``3+4.5`` 中，每個引數是不同的型別（一個 int，一個 float），而這"

"兩個引數必須在被轉換為相同的型別之後才能相加，否則就會引發 :exc:`TypeError`"

"\\ 。如果沒有強制轉型，即使所有的引數型別皆相容，它們都必須要由程式設計師正規"

"化 (normalize) 為相同的值，例如，要用 ``float(3)+4.5`` 而不能只是 ``3+4.5``。"

#: ../../glossary.rst:214

msgid "complex number"

msgstr "complex number（複數）"

#: ../../glossary.rst:216

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:226

msgid "context manager"

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

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

msgid ""

"An object which controls the environment seen in a :keyword:`with` statement "

"by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`."

msgstr ""

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

"`__enter__` 和 :meth:`__exit__` method 來控制的。請參閱 :pep:`343`\\ 。"

#: ../../glossary.rst:231

msgid "context variable"

msgstr "context variable（情境變數）"

#: ../../glossary.rst:233

msgid ""

"A variable which can have different values depending on its context. This is "

"similar to Thread-Local Storage in which each execution thread may have a "

"different value for a variable. However, with context variables, there may "

"be several contexts in one execution thread and the main usage for context "

"variables is to keep track of variables in concurrent asynchronous tasks. "

"See :mod:`contextvars`."

msgstr ""

"一個變數，其值可以根據上下文的情境而有所不同。這類似執行緒區域儲存區 (Thread-"

"Local Storage)，在其中，一個變數在每個執行緒可能具有不同的值。然而，關於情境"

"變數，在一個執行緒中可能會有多個情境，而情境變數的主要用途，是在並行的非同步"

"任務 (concurrent asynchronous task) 中，對於變數狀態的追蹤。請參閱 :mod:"

"`contextvars`\\ 。"

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

msgid "contiguous"

msgstr "contiguous（連續的）"

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

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:252

msgid "coroutine"

msgstr "coroutine（協程）"

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

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:259

msgid "coroutine function"

msgstr "coroutine function（協程函式）"

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

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:266

msgid "CPython"

msgstr "CPython"

#: ../../glossary.rst:268

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:272

msgid "decorator"

msgstr "decorator（裝飾器）"

#: ../../glossary.rst:274

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:278

msgid ""

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

"definitions are semantically equivalent::"

msgstr ""

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

"\n"

"::"

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

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:292

msgid "descriptor"

msgstr "descriptor（描述器）"

#: ../../glossary.rst:294

msgid ""

"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :"

"meth:`__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:`__get__`\\ 、\\ :meth:`__set__` 或 :meth:`__delete__` "

"method 的物件。當一個 class 屬性是一個描述器時，它的特殊連結行為會在屬性查找"

"時被觸發。通常，使用 *a.b* 來取得、設定或刪除某個屬性時，會在 *a* 的 class 字"

"典中查找名稱為 *b* 的物件，但如果 *b* 是一個描述器，則相對應的描述器 method "

"會被呼叫。對描述器的理解是深入理解 Python 的關鍵，因為它們是許多功能的基礎，"

"這些功能包括函式、method、屬性 (property)、class method、靜態 method，以及對 "

"super class（父類別）的參照。"

#: ../../glossary.rst:304

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:306

msgid "dictionary"

msgstr "dictionary（字典）"

#: ../../glossary.rst:308

msgid ""

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

"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a "

"hash in Perl."

msgstr ""

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

"有 :meth:`__hash__` 和 :meth:`__eq__` method 的物件。在 Perl 中被稱為雜湊 "

"(hash)。"

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

msgid "dictionary comprehension"

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

#: ../../glossary.rst:313

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:317

msgid "dictionary view"

msgstr "dictionary view（字典檢視）"

#: ../../glossary.rst:319

msgid ""

"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:"

"`dict.items` are called dictionary views. They provide a dynamic view on the "

"dictionary’s entries, which means that when the dictionary changes, the view "

"reflects these changes. To force the dictionary view to become a full list "

"use ``list(dictview)``. See :ref:`dict-views`."

msgstr ""

"從 :meth:`dict.keys`\\ 、\\ :meth:`dict.values` 及 :meth:`dict.items` 回傳的"

"物件被稱為字典檢視。它們提供了字典中項目的動態檢視，這表示當字典有變動時，該"

"檢視會反映這些變動。若要強制將字典檢視轉為完整的 list（串列），須使用 "

"``list(dictview)``。請參閱\\ :ref:`dict-views`\\ 。"

#: ../../glossary.rst:325

msgid "docstring"

msgstr "docstring（說明字串）"

#: ../../glossary.rst:327

msgid ""

"A string literal which appears as the first expression in a class, function "

"or module. While ignored when the suite is executed, it is recognized by "

"the compiler and put into the :attr:`__doc__` attribute of the enclosing "

"class, function or module. Since it is available via introspection, it is "

"the canonical place for documentation of the object."

msgstr ""

"一個在 class、函式或模組中，作為第一個運算式出現的字串文本。雖然它在套件執行"

"時會被忽略，但它會被編譯器辨識，並被放入所屬 class、函式或模組的 :attr:"

"`__doc__` 屬性中。由於說明字串可以透過內省 (introspection) 來瀏覽，因此它是物"

"件的說明文件存放的標準位置。"

#: ../../glossary.rst:333

msgid "duck-typing"

msgstr "duck-typing（鴨子型別）"

#: ../../glossary.rst:335

msgid ""

"A programming style which does not look at an object's type to determine if "

"it has the right interface; instead, the method or attribute is simply "

"called or used (\"If it looks like a duck and quacks like a duck, it must be "

"a duck.\") By emphasizing interfaces rather than specific types, well-"

"designed code improves its flexibility by allowing polymorphic "

"substitution. Duck-typing avoids tests using :func:`type` or :func:"

"`isinstance`. (Note, however, that duck-typing can be complemented with :"

"term:`abstract base classes <abstract base class>`.) Instead, it typically "

"employs :func:`hasattr` tests or :term:`EAFP` programming."

msgstr ""

"一種程式設計風格，它不是藉由檢查一個物件的型別來確定它是否具有正確的介面；取"

"而代之的是，method 或屬性會單純地被呼叫或使用。（「如果它看起來像一隻鴨子而且"

"叫起來像一隻鴨子，那麼它一定是一隻鴨子。」）因為強調介面而非特定型別，精心設"

"計的程式碼能讓多形替代 (polymorphic substitution) 來增進它的靈活性。鴨子型別"

"要避免使用 :func:`type` 或 :func:`isinstance` 進行測試。（但是請注意，鴨子型"

"別可以用\\ :term:`抽象基底類別 (abstract base class) <abstract base class>` "

"來補充。）然而，它通常會採用 :func:`hasattr` 測試，或是 :term:`EAFP` 程式設計"

"風格。"

#: ../../glossary.rst:344

msgid "EAFP"

msgstr "EAFP"

#: ../../glossary.rst:346

msgid ""

"Easier to ask for forgiveness than permission. This common Python coding "

"style assumes the existence of valid keys or attributes and catches "

"exceptions if the assumption proves false. This clean and fast style is "

"characterized by the presence of many :keyword:`try` and :keyword:`except` "

"statements. The technique contrasts with the :term:`LBYL` style common to "

"many other languages such as C."

msgstr ""

"Easier to ask for forgiveness than permission.（請求寬恕比請求許可更容易。）"

"這種常見的 Python 編碼風格會先假設有效的鍵或屬性的存在，並在該假設被推翻時再"

"捕獲例外。這種乾淨且快速的風格，其特色是存在許多的 :keyword:`try` 和 :"

"keyword:`except` 陳述式。該技術與許多其他語言（例如 C）常見的 :term:`LBYL` 風"

"格形成了對比。"

#: ../../glossary.rst:352

msgid "expression"

msgstr "expression（運算式）"

#: ../../glossary.rst:354

msgid ""

"A piece of syntax which can be evaluated to some value. In other words, an "

"expression is an accumulation of expression elements like literals, names, "

"attribute access, operators or function calls which all return a value. In "

"contrast to many other languages, not all language constructs are "

"expressions. There are also :term:`statement`\\s which cannot be used as "

"expressions, such as :keyword:`while`. Assignments are also statements, not "

"expressions."

msgstr ""

"一段可以被評估並求值的語法。換句話說，一個運算式就是文字、名稱、屬性存取、運"

"算子或函式呼叫等運算式元件的累積，而這些元件都能回傳一個值。與許多其他語言不"

"同的是，並非所有的 Python 語言構造都是運算式。另外有一些 :term:`statement`\\ "

"（陳述式）不能被用作運算式，例如 :keyword:`while`\\ 。賦值 (assignment) 也是"

"陳述式，而不是運算式。"

#: ../../glossary.rst:361

msgid "extension module"

msgstr "extension module（擴充模組）"

#: ../../glossary.rst:363

msgid ""

"A module written in C or C++, using Python's C API to interact with the core "

"and with user code."

msgstr ""

"一個以 C 或 C++ 編寫的模組，它使用 Python 的 C API 來與核心及使用者程式碼進行"

"互動。"

#: ../../glossary.rst:365

msgid "f-string"

msgstr "f-string（f 字串）"

#: ../../glossary.rst:367

msgid ""

"String literals prefixed with ``'f'`` or ``'F'`` are commonly called \"f-"

"strings\" which is short for :ref:`formatted string literals <f-strings>`. "

"See also :pep:`498`."

msgstr ""

"以 ``'f'`` 或 ``'F'`` 為前綴的字串文本通常被稱為「f 字串」，它是\\ :ref:`格式"

"化的字串文本 <f-strings>`\\ 的縮寫。另請參閱 :pep:`498`\\ 。"

#: ../../glossary.rst:370

msgid "file object"

msgstr "file object（檔案物件）"

#: ../../glossary.rst:372

msgid ""

"An object exposing a file-oriented API (with methods such as :meth:`read()` "

"or :meth:`write()`) to an underlying resource. Depending on the way it was "

"created, a file object can mediate access to a real on-disk file or to "

"another type of storage or communication device (for example standard input/"

"output, in-memory buffers, sockets, pipes, etc.). File objects are also "

"called :dfn:`file-like objects` or :dfn:`streams`."

msgstr ""

"一個讓使用者透過檔案導向 (file-oriented) API（如 :meth:`read()` 或 :meth:"

"`write()` 等 method）來操作底層資源的物件。根據檔案物件被建立的方式，它能夠協"

"調對真實磁碟檔案或是其他類型的儲存器或通訊裝置（例如標準輸入／輸出、記憶體內"

"緩衝區、socket（插座）、管線 (pipe) 等）的存取。檔案物件也被稱為\\ :dfn:`類檔"

"案物件 (file-like object)` 或\\ :dfn:`串流 (stream)`\\ 。"

#: ../../glossary.rst:380

msgid ""

"There are actually three categories of file objects: raw :term:`binary files "

"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "

"files <text file>`. Their interfaces are defined in the :mod:`io` module. "

"The canonical way to create a file object is by using the :func:`open` "

"function."

msgstr ""

"實際上，有三種檔案物件：原始的\\ :term:`二進制檔案 <binary file>`\\ 、緩衝的"

"\\ :term:`二進制檔案 <binary file>`\\ 和\\ :term:`文字檔案 <text file>`\\ 。"

"它們的介面在 :mod:`io` 模組中被定義。建立檔案物件的標準方法是使用 :func:"

"`open` 函式。"

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

msgid "file-like object"

msgstr "file-like object（類檔案物件）"

#: ../../glossary.rst:387

msgid "A synonym for :term:`file object`."

msgstr ":term:`file object`\\ （檔案物件）的同義字。"

#: ../../glossary.rst:388

msgid "finder"

msgstr "finder（尋檢器）"

#: ../../glossary.rst:390

msgid ""

"An object that tries to find the :term:`loader` for a module that is being "

"imported."

msgstr ""

"一個物件，它會嘗試為正在被 import 的模組尋找 :term:`loader`\\ （載入器）。"

#: ../../glossary.rst:393

msgid ""

"Since Python 3.3, there are two types of finder: :term:`meta path finders "

"<meta path finder>` for use with :data:`sys.meta_path`, and :term:`path "

"entry finders <path entry finder>` for use with :data:`sys.path_hooks`."

msgstr ""

"從 Python 3.3 開始，有兩種類型的尋檢器：\\ :term:`元路徑尋檢器 (meta path "

"finder) <meta path finder>` 會使用 :data:`sys.meta_path`\\ ，而\\ :term:`路徑"

"項目尋檢器 (path entry finder) <path entry finder>` 會使用 :data:`sys."

"path_hooks`\\ 。"

#: ../../glossary.rst:397

msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail."

msgstr "請參閱 :pep:`302`\\ 、\\ :pep:`420` 和 :pep:`451` 以了解更多細節。"

#: ../../glossary.rst:398

msgid "floor division"

msgstr "floor division（向下取整除法）"

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

msgid ""

"Mathematical division that rounds down to nearest integer. The floor "

"division operator is ``//``. For example, the expression ``11 // 4`` "

"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "

"division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "

"rounded *downward*. See :pep:`238`."

msgstr ""

"向下無條件捨去到最接近整數的數學除法。向下取整除法的運算子是 ``//``。例如，運"

"算式 ``11 // 4`` 的計算結果為 ``2``，與 float（浮點數）真除法所回傳的 "

"``2.75`` 不同。請注意，``(-11) // 4`` 的結果是 ``-3``，因為是 ``-2.75`` 被\\ "

"*向下*\\ 無條件捨去。請參閱 :pep:`238`\\ 。"

#: ../../glossary.rst:405

msgid "function"

msgstr "function（函式）"

#: ../../glossary.rst:407

msgid ""

"A series of statements which returns some value to a caller. It can also be "

"passed zero or more :term:`arguments <argument>` which may be used in the "

"execution of the body. See also :term:`parameter`, :term:`method`, and the :"

"ref:`function` section."

msgstr ""

"一連串的陳述式，它能夠向呼叫者回傳一些值。它也可以被傳遞零個或多個\\ :term:`"

"引數 <argument>`\\ ，這些引數可被使用於函式本體的執行。另請參閱 :term:"

"`parameter`\\ （參數）、\\ :term:`method`\\ （方法），以及\\ :ref:`function`"

"\\ 章節。"

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

msgid "function annotation"

msgstr "function annotation（函式註釋）"

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

msgid "An :term:`annotation` of a function parameter or return value."

msgstr "函式參數或回傳值的一個 :term:`annotation`\\ （註釋）。"

#: ../../glossary.rst:415

msgid ""

"Function annotations are usually used for :term:`type hints <type hint>`: "

"for example, this function is expected to take two :class:`int` arguments "

"and is also expected to have an :class:`int` return value::"

msgstr ""

"函式註釋通常被使用於\\ :term:`型別提示 <type hint>`\\ ：例如，這個函式預期會"

"得到兩個 :class:`int` 引數，並會有一個 :class:`int` 回傳值：\n"

"\n"

"::"

#: ../../glossary.rst:423

msgid "Function annotation syntax is explained in section :ref:`function`."

msgstr "函式註釋的語法在\\ :ref:`function`\\ 章節有詳細解釋。"

#: ../../glossary.rst:425

msgid ""

"See :term:`variable annotation` and :pep:`484`, which describe this "

"functionality."

msgstr ""

"請參閱 :term:`variable annotation` 和 :pep:`484`\\ ，皆有此功能的描述。"

#: ../../glossary.rst:427

msgid "__future__"

msgstr "__future__"

#: ../../glossary.rst:429

msgid ""

"A :ref:`future statement <future>`, ``from __future__ import <feature>``, "

"directs the compiler to compile the current module using syntax or semantics "

"that will become standard in a future release of Python. The :mod:"

"`__future__` module documents the possible values of *feature*. By "

"importing this module and evaluating its variables, you can see when a new "

"feature was first added to the language and when it will (or did) become the "

"default::"

msgstr ""

":ref:`future 陳述式 <future>`\\ ：``from __future__ import <feature>``，會指"

"示編譯器使用那些在 Python 未來的發布版本中將成為標準的語法或語義，來編譯當前"

"的模組。而 :mod:`__future__` 模組則記錄了 *feature（功能）*\\ 可能的值。透過 "

"import 此模組並對其變數求值，你可以看見一個新的功能是何時首次被新增到此語言"

"中，以及它何時將會（或已經）成為預設的功能：\n"

"\n"

"::"

#: ../../glossary.rst:440

msgid "garbage collection"

msgstr "garbage collection（垃圾回收）"

#: ../../glossary.rst:442

msgid ""

"The process of freeing memory when it is not used anymore. Python performs "

"garbage collection via reference counting and a cyclic garbage collector "

"that is able to detect and break reference cycles. The garbage collector "

"can be controlled using the :mod:`gc` module."

msgstr ""

"當記憶體不再被使用時，將其釋放的過程。Python 執行垃圾回收，是透過參照計數 "

"(reference counting)，以及一個能夠檢測和中斷參照循環 (reference cycle) 的循環"

"垃圾回收器 (cyclic garbage collector) 來完成。垃圾回收器可以使用 :mod:`gc` 模"

"組對其進行控制。"