stdtypes.po

# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Leon H., 2017
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
# Matt Wang <mattwang44@gmail.com>, 2021
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-14 00:21+0000\n"
"PO-Revision-Date: 2022-06-12 15:22+0800\n"
"Last-Translator: Matt Wang <mattwang44@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"

#: ../../builtins/stdtypes.rst:8
msgid "Built-in Types"
msgstr "內建型別"

#: ../../builtins/stdtypes.rst:10
msgid ""
"The following sections describe the standard types that are built into the "
"interpreter."
msgstr "以下章節描述了直譯器中內建的標準型別。"

#: ../../builtins/stdtypes.rst:15
msgid ""
"The principal built-in types are numerics, sequences, mappings, classes, "
"instances and exceptions."
msgstr "主要內建型別為數字、序列、對映、class（類別）、實例和例外。"

#: ../../builtins/stdtypes.rst:18
msgid ""
"Some collection classes are mutable.  The methods that add, subtract, or "
"rearrange their members in place, and don't return a specific item, never "
"return the collection instance itself but ``None``."
msgstr ""
"有些集合類別是 mutable（可變的）。那些用於原地 (in-place) 加入、移除或重新排"
"列其成員且不回傳特定項的 method（方法），也只會回傳 ``None`` 而非集合實例自"
"己。"

#: ../../builtins/stdtypes.rst:22
msgid ""
"Some operations are supported by several object types; in particular, "
"practically all objects can be compared for equality, tested for truth "
"value, and converted to a string (with the :func:`repr` function or the "
"slightly different :func:`str` function).  The latter function is implicitly "
"used when an object is written by the :func:`print` function."
msgstr ""
"某些操作已被多種物件型別支援；特別是實務上所有物件都已經可以做相等性比較、真"
"值檢測及被轉換為字串（使用 :func:`repr` 函式或稍有差異的 :func:`str` 函式），"
"後者為當物件傳入 :func:`print` 函式印出時在背後被呼叫的函式。"

#: ../../builtins/stdtypes.rst:32
msgid "Truth Value Testing"
msgstr "真值檢測"

#: ../../builtins/stdtypes.rst:41
msgid ""
"Any object can be tested for truth value, for use in an :keyword:`if` "
"or :keyword:`while` condition or as operand of the Boolean operations below."
msgstr ""
"任何物件都可以進行檢測以判斷是否為真值，以便在 :keyword:`if` "
"或 :keyword:`while` 條件中使用，或是作為如下所述 boolean（布林）運算之運算元"
"所用。"

#: ../../builtins/stdtypes.rst:46
msgid ""
"By default, an object is considered true unless its class defines either "
"a :meth:`~object.__bool__` method that returns ``False`` or "
"a :meth:`~object.__len__` method that returns zero, when called with the "
"object. [1]_ If one of the methods raises an exception when called, the "
"exception is propagated and the object does not have a truth value (for "
"example, :data:`NotImplemented`). Here are most of the built-in objects "
"considered false:"
msgstr ""
"預設情況下，一個物件會被視為真值，除非它的 class 定義了會回傳 ``False`` "
"的 :meth:`~object.__bool__` method 或是定義了會回傳零"
"的 :meth:`~object.__len__` method。[1]_ 如果其中一個 method 在被呼叫時引發例"
"外，該例外將會被傳播，且該物件不具有真值（例如 :data:`NotImplemented`）。以下"
"列出了大部分會被視為 false 的內建物件："

#: ../../builtins/stdtypes.rst:58
msgid "constants defined to be false: ``None`` and ``False``"
msgstr "定義為 false 之常數：``None`` 與 ``False``"

#: ../../builtins/stdtypes.rst:60
msgid ""
"zero of any numeric type: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, "
"``Fraction(0, 1)``"
msgstr ""
"任何數值型別的零：``0``、``0.0``、``0j``、``Decimal(0)``、``Fraction(0, 1)``"

#: ../../builtins/stdtypes.rst:63
msgid ""
"empty sequences and collections: ``''``, ``()``, ``[]``, ``{}``, ``set()``, "
"``range(0)``"
msgstr ""
"空的序列和集合：``''``、``()``、``[]``、``{}``、``set()``、``range(0)``"

#: ../../builtins/stdtypes.rst:72
msgid ""
"Operations and built-in functions that have a Boolean result always return "
"``0`` or ``False`` for false and ``1`` or ``True`` for true, unless "
"otherwise stated. (Important exception: the Boolean operations ``or`` and "
"``and`` always return one of their operands.)"
msgstr ""
"除非另有特別說明，產生 boolean 結果的操作或內建函式都會回傳 ``0`` 或 "
"``False`` 作為假值、``1`` 或 ``True`` 作為真值。（重要例外： boolean 運算 "
"``or`` 和 ``and`` 回傳的是其中一個運算元。）"

#: ../../builtins/stdtypes.rst:81
msgid "Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`"
msgstr ""
"Boolean（布林）運算 --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`"

#: ../../builtins/stdtypes.rst:85
msgid "These are the Boolean operations, ordered by ascending priority:"
msgstr "下方為 Boolean 運算，按優先順序排序："

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:146
#: ../../builtins/stdtypes.rst:292 ../../builtins/stdtypes.rst:382
#: ../../builtins/stdtypes.rst:432 ../../builtins/stdtypes.rst:1018
#: ../../builtins/stdtypes.rst:1242
msgid "Operation"
msgstr "運算"

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:292
#: ../../builtins/stdtypes.rst:382 ../../builtins/stdtypes.rst:432
#: ../../builtins/stdtypes.rst:1018 ../../builtins/stdtypes.rst:1242
msgid "Result"
msgstr "結果"

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:292
#: ../../builtins/stdtypes.rst:432 ../../builtins/stdtypes.rst:1018
#: ../../builtins/stdtypes.rst:1242 ../../builtins/stdtypes.rst:3201
#: ../../builtins/stdtypes.rst:4475
msgid "Notes"
msgstr "註解"

#: ../../builtins/stdtypes.rst:90
msgid "``x or y``"
msgstr "``x or y``"

#: ../../builtins/stdtypes.rst:90
msgid "if *x* is true, then *x*, else *y*"
msgstr "假如 *x* 為真，則 *x*，否則 *y*"

#: ../../builtins/stdtypes.rst:90 ../../builtins/stdtypes.rst:1020
#: ../../builtins/stdtypes.rst:1023 ../../builtins/stdtypes.rst:1257
#: ../../builtins/stdtypes.rst:3207 ../../builtins/stdtypes.rst:4481
msgid "\\(1)"
msgstr "\\(1)"

#: ../../builtins/stdtypes.rst:93
msgid "``x and y``"
msgstr "``x and y``"

#: ../../builtins/stdtypes.rst:93
msgid "if *x* is false, then *x*, else *y*"
msgstr "假如 *x* 為假，則 *x*，否則 *y*"

#: ../../builtins/stdtypes.rst:93 ../../builtins/stdtypes.rst:305
#: ../../builtins/stdtypes.rst:325 ../../builtins/stdtypes.rst:1268
#: ../../builtins/stdtypes.rst:3211 ../../builtins/stdtypes.rst:3213
#: ../../builtins/stdtypes.rst:4485 ../../builtins/stdtypes.rst:4487
msgid "\\(2)"
msgstr "\\(2)"

#: ../../builtins/stdtypes.rst:96
msgid "``not x``"
msgstr "``not x``"

#: ../../builtins/stdtypes.rst:96
msgid "if *x* is false, then ``True``, else ``False``"
msgstr "假如 *x* 為假，則 ``True``，否則 ``False``"

#: ../../builtins/stdtypes.rst:96 ../../builtins/stdtypes.rst:3215
#: ../../builtins/stdtypes.rst:3217 ../../builtins/stdtypes.rst:3219
#: ../../builtins/stdtypes.rst:3221 ../../builtins/stdtypes.rst:4489
#: ../../builtins/stdtypes.rst:4491 ../../builtins/stdtypes.rst:4493
#: ../../builtins/stdtypes.rst:4495
msgid "\\(3)"
msgstr "\\(3)"

#: ../../builtins/stdtypes.rst:105 ../../builtins/stdtypes.rst:336
#: ../../builtins/stdtypes.rst:450 ../../builtins/stdtypes.rst:1062
#: ../../builtins/stdtypes.rst:1272 ../../builtins/stdtypes.rst:3251
#: ../../builtins/stdtypes.rst:4525
msgid "Notes:"
msgstr "註解："

#: ../../builtins/stdtypes.rst:108
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is false."
msgstr ""
"這是一個短路運算子，所以他只有在第一個引數為假時，才會對第二個引數求值。"

#: ../../builtins/stdtypes.rst:112
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is true."
msgstr ""
"這是一個短路運算子，所以他只有在第一個引數為真時，才會對第二個引數求值。"

#: ../../builtins/stdtypes.rst:116
msgid ""
"``not`` has a lower priority than non-Boolean operators, so ``not a == b`` "
"is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error."
msgstr ""
"``not`` 比非 Boolean 運算子有較低的優先權，因此 ``not a == b`` 可直譯為 "
"``not (a == b)``，而 ``a == not b`` 會導致語法錯誤。"

#: ../../builtins/stdtypes.rst:123
msgid "Comparisons"
msgstr "比較運算"

#: ../../builtins/stdtypes.rst:137
msgid ""
"There are eight comparison operations in Python.  They all have the same "
"priority (which is higher than that of the Boolean operations).  Comparisons "
"can be chained arbitrarily; for example, ``x < y <= z`` is equivalent to ``x "
"< y and y <= z``, except that *y* is evaluated only once (but in both cases "
"*z* is not evaluated at all when ``x < y`` is found to be false)."
msgstr ""
"在 Python 裡共有 8 種比較運算。他們的優先順序都相同（皆優先於 Boolean 運"
"算）。比較運算可以任意的串連；例如，``x < y <= z`` 等同於 ``x < y and y <= "
"z``，差異只在於前者的 *y* 只有被求值一次（但在這兩個例子中，當 ``x < y`` 為假"
"時，*z* 皆不會被求值）。"

#: ../../builtins/stdtypes.rst:143
msgid "This table summarizes the comparison operations:"
msgstr "這個表格統整所有比較運算："

#: ../../builtins/stdtypes.rst:146 ../../builtins/stdtypes.rst:3178
#: ../../builtins/stdtypes.rst:3201 ../../builtins/stdtypes.rst:4452
#: ../../builtins/stdtypes.rst:4475
msgid "Meaning"
msgstr "含義"

#: ../../builtins/stdtypes.rst:148
msgid "``<``"
msgstr "``<``"

#: ../../builtins/stdtypes.rst:148
msgid "strictly less than"
msgstr "小於"

#: ../../builtins/stdtypes.rst:150
msgid "``<=``"
msgstr "``<=``"

#: ../../builtins/stdtypes.rst:150
msgid "less than or equal"
msgstr "小於等於"

#: ../../builtins/stdtypes.rst:152
msgid "``>``"
msgstr "``>``"

#: ../../builtins/stdtypes.rst:152
msgid "strictly greater than"
msgstr "大於"

#: ../../builtins/stdtypes.rst:154
msgid "``>=``"
msgstr "``>=``"

#: ../../builtins/stdtypes.rst:154
msgid "greater than or equal"
msgstr "大於等於"

#: ../../builtins/stdtypes.rst:156
msgid "``==``"
msgstr "``==``"

#: ../../builtins/stdtypes.rst:156
msgid "equal"
msgstr "等於"

#: ../../builtins/stdtypes.rst:158
msgid "``!=``"
msgstr "``!=``"

#: ../../builtins/stdtypes.rst:158
msgid "not equal"
msgstr "不等於"

#: ../../builtins/stdtypes.rst:160
msgid "``is``"
msgstr "``is``"

#: ../../builtins/stdtypes.rst:160
msgid "object identity"
msgstr "物件識別性"

#: ../../builtins/stdtypes.rst:162
msgid "``is not``"
msgstr "``is not``"

#: ../../builtins/stdtypes.rst:162
msgid "negated object identity"
msgstr "否定的物件識別性"

#: ../../builtins/stdtypes.rst:169
msgid ""
"Unless stated otherwise, objects of different types never compare equal. The "
"``==`` operator is always defined but for some object types (for example, "
"class objects) is equivalent to :keyword:`is`. The ``<``, ``<=``, ``>`` and "
"``>=`` operators are only defined where they make sense; for example, they "
"raise a :exc:`TypeError` exception when one of the arguments is a complex "
"number."
msgstr ""
"除非有另外聲明，不同型別的物件不能進行相等比較。運算子 ``==`` 總有定義，但在"
"某些物件型別（例如，class 物件）時，運算子會等同於 :keyword:`is`。其他運算子 "
"``<``、``<=``、``>`` 及 ``>=`` 皆僅在有意義的部分有所定義；例如，當其中一個引"
"數為複數時，將引發一個 :exc:`TypeError` 的例外。"

#: ../../builtins/stdtypes.rst:183
msgid ""
"Non-identical instances of a class normally compare as non-equal unless the "
"class defines the :meth:`~object.__eq__` method."
msgstr ""
"一個 class 的非相同實例通常會比較為不相等，除非 class 有定"
"義 :meth:`~object.__eq__` method。"

#: ../../builtins/stdtypes.rst:186
msgid ""
"Instances of a class cannot be ordered with respect to other instances of "
"the same class, or other types of object, unless the class defines enough of "
"the "
"methods :meth:`~object.__lt__`, :meth:`~object.__le__`, :meth:`~object.__gt__`, "
"and :meth:`~object.__ge__` (in general, :meth:`~object.__lt__` "
"and :meth:`~object.__eq__` are sufficient, if you want the conventional "
"meanings of the comparison operators)."
msgstr ""
"一個 class 的實例不可以與其他相同 class 的實例或其他物件型別進行排序，除非 "
"class 定義足夠的 method ，包"
"含 :meth:`~object.__lt__`、:meth:`~object.__le__`、:meth:`~object.__gt__` "
"及 :meth:`~object.__ge__`\\ （一般來說，使用 :meth:`~object.__lt__` "
"及 :meth:`~object.__eq__` 就可以滿足常規意義上的比較運算子）。"

#: ../../builtins/stdtypes.rst:193
msgid ""
"The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be "
"customized; also they can be applied to any two objects and never raise an "
"exception."
msgstr ""
"無法自訂 :keyword:`is` 與 :keyword:`is not` 運算子的行為；這兩個運算子也可以"
"運用在任意兩個物件且不會引發例外。"

#: ../../builtins/stdtypes.rst:201
msgid ""
"Two more operations with the same syntactic priority, :keyword:`in` "
"and :keyword:`not in`, are supported by types that are :term:`iterable` or "
"implement the :meth:`~object.__contains__` method."
msgstr ""
"此外，擁有相同的語法優先序的 :keyword:`in` 及 :keyword:`not in` 兩種運算皆被"
"\\ :term:`可疊代物件 <iterable>`\\ 或者有實作 :meth:`~object.__contains__` "
"method 的型別所支援。"

#: ../../builtins/stdtypes.rst:208
msgid "Numeric Types --- :class:`int`, :class:`float`, :class:`complex`"
msgstr "數值型別 --- :class:`int`、:class:`float`、:class:`complex`"

#: ../../builtins/stdtypes.rst:218
msgid ""
"There are three distinct numeric types: :dfn:`integers`, :dfn:`floating-"
"point numbers`, and :dfn:`complex numbers`.  In addition, Booleans are a "
"subtype of integers.  Integers have unlimited precision.  Floating-point "
"numbers are usually implemented using :c:expr:`double` in C; information "
"about the precision and internal representation of floating-point numbers "
"for the machine on which your program is running is available "
"in :data:`sys.float_info`.  Complex numbers have a real and imaginary part, "
"which are each a floating-point number.  To extract these parts from a "
"complex number *z*, use ``z.real`` and ``z.imag``. (The standard library "
"includes the additional numeric types :mod:`fractions.Fraction`, for "
"rationals, and :mod:`decimal.Decimal`, for floating-point numbers with user-"
"definable precision.)"
msgstr ""
"數值型別共有三種：:dfn:`整數`、:dfn:`浮點數` 及 :dfn:`複數`。此外，Boolean 為"
"整數中的一個子型別。整數有無限的精度。浮點數通常使用 C 裡面"
"的 :c:expr:`double` 實作。關於在你程式所運作的機器上之浮點數的精度及內部表示"
"法可以在 :data:`sys.float_info` 進行查找。複數包含實數及虛數的部分，這兩部分"
"各自是一個浮點數。若要從一個複數 *z* 提取這兩部分，需使用 ``z.real`` 及 "
"``z.imag``。（標準函式庫包含額外的數值型別，像是 :mod:`fractions.Fraction` 表"
"示有理數，而 :mod:`decimal.Decimal` 表示可由使用者制定精度的浮點數。）"

#: ../../builtins/stdtypes.rst:240
msgid ""
"Numbers are created by numeric literals or as the result of built-in "
"functions and operators.  Unadorned integer literals (including hex, octal "
"and binary numbers) yield integers.  Numeric literals containing a decimal "
"point or an exponent sign yield floating-point numbers.  Appending ``'j'`` "
"or ``'J'`` to a numeric literal yields an imaginary number (a complex number "
"with a zero real part) which you can add to an integer or float to get a "
"complex number with real and imaginary parts."
msgstr ""
"數字是由字面數值或內建公式及運算子的結果所產生的。未經修飾的字面數值（含十六"
"進位、八進位及二進位數值）會 yield 整數。包含小數點或指數符號的字面數值會 "
"yield 浮點數。在數值後面加上 ``'j'`` 或是 ``'J'`` 會 yield 一個虛數（意即一個"
"實數為 0 的複數）。你也可以將整數與浮點數相加以得到一個有實部與虛部的複數。"

#: ../../builtins/stdtypes.rst:248
msgid ""
"The constructors :func:`int`, :func:`float`, and :func:`complex` can be used "
"to produce numbers of a specific type."
msgstr ""
"建構函式： :func:`int`、:func:`float` 及 :func:`complex` 可以用來產生特定型別"
"的數字。"

#: ../../builtins/stdtypes.rst:270
msgid ""
"Python fully supports mixed arithmetic: when a binary arithmetic operator "
"has operands of different built-in numeric types, the operand with the "
"\"narrower\" type is widened to that of the other:"
msgstr ""
"Python 完全支援混和運算：當一個二元運算子的運算元有不同內建數值型別時，「較"
"窄」型別的運算元會被拓寬到另一個型別的運算元："

#: ../../builtins/stdtypes.rst:274
msgid "If both arguments are complex numbers, no conversion is performed;"
msgstr ""

#: ../../builtins/stdtypes.rst:275
msgid ""
"if either argument is a complex or a floating-point number, the other is "
"converted to a floating-point number;"
msgstr ""

#: ../../builtins/stdtypes.rst:277
msgid "otherwise, both must be integers and no conversion is necessary."
msgstr ""

#: ../../builtins/stdtypes.rst:279
msgid ""
"Arithmetic with complex and real operands is defined by the usual "
"mathematical formula, for example::"
msgstr ""

#: ../../builtins/stdtypes.rst:282
msgid ""
"x + complex(u, v) = complex(x + u, v)\n"
"x * complex(u, v) = complex(x * u, x * v)"
msgstr ""
"x + complex(u, v) = complex(x + u, v)\n"
"x * complex(u, v) = complex(x * u, x * v)"

#: ../../builtins/stdtypes.rst:285
msgid ""
"A comparison between numbers of different types behaves as though the exact "
"values of those numbers were being compared. [2]_"
msgstr "不同型別的數值之間進行比較時，其行為就像是在比較這些數值的實際值 [2]_"

#: ../../builtins/stdtypes.rst:288
msgid ""
"All numeric types (except complex) support the following operations (for "
"priorities of the operations, see :ref:`operator-summary`):"
msgstr ""
"所有數值型別（除複數外）皆支援以下的運算（有關運算的先後順序，詳"
"見 :ref:`operator-summary`）："

#: ../../builtins/stdtypes.rst:292
msgid "Full documentation"
msgstr "完整文件"

#: ../../builtins/stdtypes.rst:294
msgid "``x + y``"
msgstr "``x + y``"

#: ../../builtins/stdtypes.rst:294
msgid "sum of *x* and *y*"
msgstr "*x* 及 *y* 的加總"

#: ../../builtins/stdtypes.rst:296
msgid "``x - y``"
msgstr "``x - y``"

#: ../../builtins/stdtypes.rst:296
msgid "difference of *x* and *y*"
msgstr "*x* 及 *y* 的相減"

#: ../../builtins/stdtypes.rst:298
msgid "``x * y``"
msgstr "``x * y``"

#: ../../builtins/stdtypes.rst:298
msgid "product of *x* and *y*"
msgstr "*x* 及 *y* 的相乘"

#: ../../builtins/stdtypes.rst:300
msgid "``x / y``"
msgstr "``x / y``"

#: ../../builtins/stdtypes.rst:300
msgid "quotient of *x* and *y*"
msgstr "*x* 及 *y* 相除之商"

#: ../../builtins/stdtypes.rst:302
msgid "``x // y``"
msgstr "``x // y``"

#: ../../builtins/stdtypes.rst:302
msgid "floored quotient of *x* and *y*"
msgstr "*x* 及 *y* 的整數除法"

#: ../../builtins/stdtypes.rst:302
msgid "\\(1)\\(2)"
msgstr "\\(1)\\(2)"

#: ../../builtins/stdtypes.rst:305
msgid "``x % y``"
msgstr "``x % y``"

#: ../../builtins/stdtypes.rst:305
msgid "remainder of ``x / y``"
msgstr "``x / y`` 的餘數"

#: ../../builtins/stdtypes.rst:307
msgid "``-x``"
msgstr "``-x``"

#: ../../builtins/stdtypes.rst:307
msgid "*x* negated"
msgstr "*x* 的負數"

#: ../../builtins/stdtypes.rst:309
msgid "``+x``"
msgstr "``+x``"

#: ../../builtins/stdtypes.rst:309
msgid "*x* unchanged"
msgstr "*x* 不變"

#: ../../builtins/stdtypes.rst:311
msgid "``abs(x)``"
msgstr "``abs(x)``"

#: ../../builtins/stdtypes.rst:311
msgid "absolute value or magnitude of *x*"
msgstr "*x* 的絕對值或量 (magnitude)"

#: ../../builtins/stdtypes.rst:311
msgid ":func:`abs`"
msgstr ":func:`abs`"

#: ../../builtins/stdtypes.rst:314
msgid "``int(x)``"
msgstr "``int(x)``"

#: ../../builtins/stdtypes.rst:314
msgid "*x* converted to integer"
msgstr "將 *x* 轉為整數"

#: ../../builtins/stdtypes.rst:314
msgid "\\(3)\\(6)"
msgstr "\\(3)\\(6)"

#: ../../builtins/stdtypes.rst:314
msgid ":func:`int`"
msgstr ":func:`int`"

#: ../../builtins/stdtypes.rst:316
msgid "``float(x)``"
msgstr "``float(x)``"

#: ../../builtins/stdtypes.rst:316
msgid "*x* converted to floating point"
msgstr "將 *x* 轉為浮點數"

#: ../../builtins/stdtypes.rst:316
msgid "\\(4)\\(6)"
msgstr "\\(4)\\(6)"

#: ../../builtins/stdtypes.rst:316
msgid ":func:`float`"
msgstr ":func:`float`"

#: ../../builtins/stdtypes.rst:318
msgid "``complex(re, im)``"
msgstr "``complex(re, im)``"

#: ../../builtins/stdtypes.rst:318
msgid ""
"a complex number with real part *re*, imaginary part *im*. *im* defaults to "
"zero."
msgstr "一個複數，其實部為 *re*，虛部為 *im*。*im* 預設為零。"

#: ../../builtins/stdtypes.rst:318 ../../builtins/stdtypes.rst:3209
#: ../../builtins/stdtypes.rst:4512
msgid "\\(6)"
msgstr "\\(6)"

#: ../../builtins/stdtypes.rst:318
msgid ":func:`complex`"
msgstr ":func:`complex`"

#: ../../builtins/stdtypes.rst:322
msgid "``c.conjugate()``"
msgstr "``c.conjugate()``"

#: ../../builtins/stdtypes.rst:322
msgid "conjugate of the complex number *c*"
msgstr "為複數 *c* 的共軛複數"

#: ../../builtins/stdtypes.rst:325
msgid "``divmod(x, y)``"
msgstr "``divmod(x, y)``"

#: ../../builtins/stdtypes.rst:325
msgid "the pair ``(x // y, x % y)``"
msgstr "一對 ``(x // y, x % y)``"

#: ../../builtins/stdtypes.rst:325
msgid ":func:`divmod`"
msgstr ":func:`divmod`"

#: ../../builtins/stdtypes.rst:327
msgid "``pow(x, y)``"
msgstr "``pow(x, y)``"

#: ../../builtins/stdtypes.rst:327 ../../builtins/stdtypes.rst:329
msgid "*x* to the power *y*"
msgstr "*x* 的 *y* 次方"

#: ../../builtins/stdtypes.rst:327 ../../builtins/stdtypes.rst:329
#: ../../builtins/stdtypes.rst:3234 ../../builtins/stdtypes.rst:3237
#: ../../builtins/stdtypes.rst:3240 ../../builtins/stdtypes.rst:4508
#: ../../builtins/stdtypes.rst:4515
msgid "\\(5)"
msgstr "\\(5)"

#: ../../builtins/stdtypes.rst:327
msgid ":func:`pow`"
msgstr ":func:`pow`"

#: ../../builtins/stdtypes.rst:329
msgid "``x ** y``"
msgstr "``x ** y``"

#: ../../builtins/stdtypes.rst:339
msgid ""
"Also referred to as integer division.  For operands of type :class:`int`, "
"the result has type :class:`int`.  For operands of type :class:`float`, the "
"result has type :class:`float`.  In general, the result is a whole integer, "
"though the result's type is not necessarily :class:`int`.  The result is "
"always rounded towards minus infinity: ``1//2`` is ``0``, ``(-1)//2`` is "
"``-1``, ``1//(-2)`` is ``-1``, and ``(-1)//(-2)`` is ``0``."
msgstr ""
"也被稱為整數除法。對於型別為 :class:`int` 的運算元來說，結果之型別會"
"是 :class:`int`。對於型別為 :class:`float` 的運算元來說，結果之型別會"
"是 :class:`float`。一般來說，結果會是一個整數，但其型別不一定會"
"是 :class:`int`。結果總是會往負無窮大的方向取整數值： ``1//2`` 為 ``0``、"
"``(-1)//2`` 為 ``-1``、``1//(-2)`` 為 ``-1`` 及 ``(-1)//(-2)`` 為 ``0``。"

#: ../../builtins/stdtypes.rst:347
msgid ""
"Not for complex numbers.  Instead convert to floats using :func:`abs` if "
"appropriate."
msgstr "不可用於複數。在適當情形下，可使用 :func:`abs` 轉換為浮點數。"

#: ../../builtins/stdtypes.rst:358
msgid ""
"Conversion from :class:`float` to :class:`int` truncates, discarding the "
"fractional part. See functions :func:`math.floor` and :func:`math.ceil` for "
"alternative conversions."
msgstr ""
"從 :class:`float` 轉換為 :class:`int` 會導致截斷並排除小數部分。詳"
"見 :func:`math.floor` 及 :func:`math.ceil` 以了解更多轉換方式。"

#: ../../builtins/stdtypes.rst:363
msgid ""
"float also accepts the strings \"nan\" and \"inf\" with an optional prefix "
"\"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity."
msgstr ""
"浮點數也接受帶有可選的前綴 \"+\" 及 \"-\" 的 \"nan\" 及  \"inf\" 字串，其分別"
"代表非數字（NaN）及正負無窮。"

#: ../../builtins/stdtypes.rst:367
msgid ""
"Python defines ``pow(0, 0)`` and ``0 ** 0`` to be ``1``, as is common for "
"programming languages."
msgstr ""
"Python 將 ``pow(0, 0)`` 及 ``0 ** 0`` 定義為 ``1`` 這是程式語言的普遍做法。"

#: ../../builtins/stdtypes.rst:371
msgid ""
"The numeric literals accepted include the digits ``0`` to ``9`` or any "
"Unicode equivalent (code points with the ``Nd`` property)."
msgstr ""
"字面數值接受包含數字 ``0`` 到 ``9`` 或任何等效的 Unicode 字元（具有 ``Nd`` 屬"
"性的 code points（編碼位置））。"

#: ../../builtins/stdtypes.rst:374
msgid ""
"See `the Unicode Standard <https://unicode.org/Public/UNIDATA/extracted/"
"DerivedNumericType.txt>`_ for a complete list of code points with the ``Nd`` "
"property."
msgstr ""
"請參閱 `Unicode 標準 <https://unicode.org/Public/UNIDATA/extracted/"
"DerivedNumericType.txt>`_\\ 以了解具有 ``Nd`` 屬性的 code points 完整列表。"

#: ../../builtins/stdtypes.rst:378
msgid ""
"All :class:`numbers.Real` types (:class:`int` and :class:`float`) also "
"include the following operations:"
msgstr ""
"所有 :class:`numbers.Real` 型別（:class:`int` 及 :class:`float`）也適用下列運"
"算："

#: ../../builtins/stdtypes.rst:384
msgid ":func:`math.trunc(\\ x) <math.trunc>`"
msgstr ":func:`math.trunc(\\ x) <math.trunc>`"

#: ../../builtins/stdtypes.rst:384
msgid "*x* truncated to :class:`~numbers.Integral`"
msgstr "*x* 截斷為 :class:`~numbers.Integral`"

#: ../../builtins/stdtypes.rst:387
msgid ":func:`round(x[, n]) <round>`"
msgstr ":func:`round(x[, n]) <round>`"

#: ../../builtins/stdtypes.rst:387
msgid ""
"*x* rounded to *n* digits, rounding half to even. If *n* is omitted, it "
"defaults to 0."
msgstr "*x* 進位至小數點後第 *n* 位，使用偶數捨入法。若省略 *n* ，則預設為 0。"

#: ../../builtins/stdtypes.rst:391
msgid ":func:`math.floor(\\ x) <math.floor>`"
msgstr ":func:`math.floor(\\ x) <math.floor>`"

#: ../../builtins/stdtypes.rst:391
msgid "the greatest :class:`~numbers.Integral` <= *x*"
msgstr "小於等於 *x* 的最大 :class:`~numbers.Integral`"

#: ../../builtins/stdtypes.rst:394
msgid ":func:`math.ceil(x) <math.ceil>`"
msgstr ":func:`math.ceil(x) <math.ceil>`"

#: ../../builtins/stdtypes.rst:394
msgid "the least :class:`~numbers.Integral` >= *x*"
msgstr "大於等於 *x* 的最小 :class:`~numbers.Integral`"

#: ../../builtins/stdtypes.rst:398
msgid ""
"For additional numeric operations see the :mod:`math` and :mod:`cmath` "
"modules."
msgstr "關於其他數值運算請詳見 :mod:`math` 及 :mod:`cmath` modules（模組）。"

#: ../../builtins/stdtypes.rst:407
msgid "Bitwise Operations on Integer Types"
msgstr "整數型別的位元運算"

#: ../../builtins/stdtypes.rst:421
msgid ""
"Bitwise operations only make sense for integers. The result of bitwise "
"operations is calculated as though carried out in two's complement with an "
"infinite number of sign bits."
msgstr ""
"位元運算只對整數有意義。位元運算的計算結果就如同對二的補數執行無窮多個符號位"
"元。"

#: ../../builtins/stdtypes.rst:425
msgid ""
"The priorities of the binary bitwise operations are all lower than the "
"numeric operations and higher than the comparisons; the unary operation "
"``~`` has the same priority as the other unary numeric operations (``+`` and "
"``-``)."
msgstr ""
"二元位元運算的優先順序皆低於數字運算，但高於比較運算；一元運算 ``~`` 與其他一"
"元數值運算有一致的優先順序（``+`` 及 ``-``）。"

#: ../../builtins/stdtypes.rst:429
msgid "This table lists the bitwise operations sorted in ascending priority:"
msgstr "這個表格列出所有位元運算並以優先順序由先至後排序。"

#: ../../builtins/stdtypes.rst:434
msgid "``x | y``"
msgstr "``x | y``"

#: ../../builtins/stdtypes.rst:434
msgid "bitwise :dfn:`or` of *x* and *y*"
msgstr "*x* 及 *y* 的位元 :dfn:`或`"

#: ../../builtins/stdtypes.rst:434 ../../builtins/stdtypes.rst:437
#: ../../builtins/stdtypes.rst:440 ../../builtins/stdtypes.rst:3223
#: ../../builtins/stdtypes.rst:3227 ../../builtins/stdtypes.rst:4497
#: ../../builtins/stdtypes.rst:4501
msgid "\\(4)"
msgstr "\\(4)"

#: ../../builtins/stdtypes.rst:437
msgid "``x ^ y``"
msgstr "``x ^ y``"

#: ../../builtins/stdtypes.rst:437
msgid "bitwise :dfn:`exclusive or` of *x* and *y*"
msgstr "*x* 及 *y* 的位元 :dfn:`邏輯互斥或`"

#: ../../builtins/stdtypes.rst:440
msgid "``x & y``"
msgstr "``x & y``"

#: ../../builtins/stdtypes.rst:440
msgid "bitwise :dfn:`and` of *x* and *y*"
msgstr "*x* 及 *y* 的位元 :dfn:`與`"

#: ../../builtins/stdtypes.rst:443
msgid "``x << n``"
msgstr "``x << n``"

#: ../../builtins/stdtypes.rst:443
msgid "*x* shifted left by *n* bits"
msgstr "*x* 往左移動 *n* 個位元"

#: ../../builtins/stdtypes.rst:443
msgid "(1)(2)"
msgstr "(1)(2)"

#: ../../builtins/stdtypes.rst:445
msgid "``x >> n``"
msgstr "``x >> n``"

#: ../../builtins/stdtypes.rst:445
msgid "*x* shifted right by *n* bits"
msgstr "*x* 往右移動 *n* 個位元"

#: ../../builtins/stdtypes.rst:445
msgid "(1)(3)"
msgstr "(1)(3)"

#: ../../builtins/stdtypes.rst:447
msgid "``~x``"
msgstr "``~x``"

#: ../../builtins/stdtypes.rst:447
msgid "the bits of *x* inverted"
msgstr "反轉 *x* 的位元"

#: ../../builtins/stdtypes.rst:453
msgid ""
"Negative shift counts are illegal and cause a :exc:`ValueError` to be raised."
msgstr "負數位移是不被允許並會引發 :exc:`ValueError` 的錯誤。"

#: ../../builtins/stdtypes.rst:456
msgid ""
"A left shift by *n* bits is equivalent to multiplication by ``pow(2, n)``."
msgstr "向左移動 *n* 個位元等同於乘以 ``pow(2, n)``。"

#: ../../builtins/stdtypes.rst:459
msgid ""
"A right shift by *n* bits is equivalent to floor division by ``pow(2, n)``."
msgstr "向右移動 *n* 個位元等同於向下除法除以 ``pow(2, n)``。"

#: ../../builtins/stdtypes.rst:462
msgid ""
"Performing these calculations with at least one extra sign extension bit in "
"a finite two's complement representation (a working bit-width of ``1 + "
"max(x.bit_length(), y.bit_length())`` or more) is sufficient to get the same "
"result as if there were an infinite number of sign bits."
msgstr ""
"在有限的二的補數表示法中執行這些計算（一個有效位元寬度為 ``1 + "
"max(x.bit_length(), y.bit_length())`` 或以上）並至少有一個額外的符號擴展位"
"元，便足以得到與無窮多個符號位元相同的結果。"

#: ../../builtins/stdtypes.rst:469
msgid "Additional Methods on Integer Types"
msgstr "整數型別的附加方法"

#: ../../builtins/stdtypes.rst:471
msgid ""
"The int type implements the :class:`numbers.Integral` :term:`abstract base "
"class`. In addition, it provides a few more methods:"
msgstr ""
"整數型別實作了 :class:`numbers.Integral` :term:`抽象基底類別 <abstract base "
"class>`。此外，它提供了一些方法："

#: ../../builtins/stdtypes.rst:476
msgid ""
"Return the number of bits necessary to represent an integer in binary, "
"excluding the sign and leading zeros::"
msgstr "回傳以二進位表示一個整數所需要的位元數，不包括符號及首位的零： ::"

#: ../../builtins/stdtypes.rst:479
msgid ""
">>> n = -37\n"
">>> bin(n)\n"
"'-0b100101'\n"
">>> n.bit_length()\n"
"6"
msgstr ""
">>> n = -37\n"
">>> bin(n)\n"
"'-0b100101'\n"
">>> n.bit_length()\n"
"6"

#: ../../builtins/stdtypes.rst:485
msgid ""
"More precisely, if ``x`` is nonzero, then ``x.bit_length()`` is the unique "
"positive integer ``k`` such that ``2**(k-1) <= abs(x) < 2**k``. "
"Equivalently, when ``abs(x)`` is small enough to have a correctly rounded "
"logarithm, then ``k = 1 + int(log(abs(x), 2))``. If ``x`` is zero, then "
"``x.bit_length()`` returns ``0``."
msgstr ""
"更準確來說，若 ``x`` 非為零，則 ``x.bit_length()`` 會得出滿足 ``2**(k-1) <= "
"abs(x) < 2**k`` 的單一正整數 ``k``。同樣地，當 ``abs(x)`` 足夠小到能正確地取"
"得捨入的對數，則 ``k = 1 + int(log(abs(x), 2))``。若 ``x`` 為零，則 "
"``x.bit_length()`` 會回傳 ``0``。"

#: ../../builtins/stdtypes.rst:491 ../../builtins/stdtypes.rst:514
#: ../../builtins/stdtypes.rst:559 ../../builtins/stdtypes.rst:603
msgid "Equivalent to::"
msgstr "等同於： ::"

#: ../../builtins/stdtypes.rst:493
msgid ""
"def bit_length(self):\n"
"    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'\n"
"    s = s.lstrip('-0b') # remove leading zeros and minus sign\n"
"    return len(s)       # len('100101') --> 6"
msgstr ""
"def bit_length(self):\n"
"    s = bin(self)       # 二進位表示:  bin(-37) --> '-0b100101'\n"
"    s = s.lstrip('-0b') # 去除開頭的零和負號\n"
"    return len(s)       # len('100101') --> 6"

#: ../../builtins/stdtypes.rst:502
msgid ""
"Return the number of ones in the binary representation of the absolute value "
"of the integer. This is also known as the population count. Example::"
msgstr "回傳在絕對值表示的二進位中 1 的個數。這也被稱作母體計數。舉例來說： ::"

#: ../../builtins/stdtypes.rst:506
msgid ""
">>> n = 19\n"
">>> bin(n)\n"
"'0b10011'\n"
">>> n.bit_count()\n"
"3\n"
">>> (-n).bit_count()\n"
"3"
msgstr ""
">>> n = 19\n"
">>> bin(n)\n"
"'0b10011'\n"
">>> n.bit_count()\n"
"3\n"
">>> (-n).bit_count()\n"
"3"

#: ../../builtins/stdtypes.rst:516
msgid ""
"def bit_count(self):\n"
"    return bin(self).count(\"1\")"
msgstr ""
"def bit_count(self):\n"
"    return bin(self).count(\"1\")"

#: ../../builtins/stdtypes.rst:523
msgid "Return an array of bytes representing an integer."
msgstr "回傳表示一個整數的一列位元組。"

#: ../../builtins/stdtypes.rst:535
msgid ""
"The integer is represented using *length* bytes, and defaults to 1.  "
"An :exc:`OverflowError` is raised if the integer is not representable with "
"the given number of bytes."
msgstr ""
"此整數會使用 *length* 位元組表示，並且預設為 1。如果該整數無法用給定的位元組"
"數來表示，則會引發 :exc:`OverflowError`。"

#: ../../builtins/stdtypes.rst:539
msgid ""
"The *byteorder* argument determines the byte order used to represent the "
"integer, and defaults to ``\"big\"``.  If *byteorder* is ``\"big\"``, the "
"most significant byte is at the beginning of the byte array.  If *byteorder* "
"is ``\"little\"``, the most significant byte is at the end of the byte array."
msgstr ""
"*byteorder* 引數決定了用來表示整數的位元組順序並且預設為 ``\"big\"``。如果 "
"byteorder 是 ``\"big\"``，最重要的位元組位於位元組陣列的開頭。如果 byteorder "
"是 ``\"little\"``，最重要的位元組位於位元組陣列的結尾。"

#: ../../builtins/stdtypes.rst:545
msgid ""
"The *signed* argument determines whether two's complement is used to "
"represent the integer.  If *signed* is ``False`` and a negative integer is "
"given, an :exc:`OverflowError` is raised. The default value for *signed* is "
"``False``."
msgstr ""
"*signed* 引數決定是否使用二的補數來表示整數。如果 *signed* 是 ``False`` 並且"
"給定了一個負整數，則會引發 :exc:`OverflowError`。*signed* 的預設值是 "