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

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

#

# Translators:

# Adrian Liaw <[email protected]>, 2018

# Kisaragi Hiu <[email protected]>, 2024

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-09-04 00:15+0000\n"

"PO-Revision-Date: 2024-09-24 19:03+0900\n"

"Last-Translator: Kisaragi Hiu <[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: Lokalize 24.08.1\n"

#: ../../reference/datamodel.rst:6

msgid "Data model"

msgstr "資料模型"

#: ../../reference/datamodel.rst:12

msgid "Objects, values and types"

msgstr "物件、數值和型別"

#: ../../reference/datamodel.rst:18

msgid ""

":dfn:`Objects` are Python's abstraction for data. All data in a Python "

"program is represented by objects or by relations between objects. (In a "

"sense, and in conformance to Von Neumann's model of a \"stored program "

"computer\", code is also represented by objects.)"

msgstr ""

":dfn:`物件` 是 Python 為資料的抽象表示方式。一個 Python 程式當中的所有資料皆"

"由物件或物件之間的關係來呈現。（某種意義上，同時符合 Von Neumann 對於「儲存程"

"式型電腦」(\"stored program computer\") 的模型，程式碼也是以物件呈現的。）"

#: ../../reference/datamodel.rst:35

msgid ""

"Every object has an identity, a type and a value. An object's *identity* "

"never changes once it has been created; you may think of it as the object's "

"address in memory. The :keyword:`is` operator compares the identity of two "

"objects; the :func:`id` function returns an integer representing its "

"identity."

msgstr ""

"每個物件都有一個識別性、型別，和數值。物件的\\ *識別性*\\ 在物件建立後永遠不"

"會改變；你也可以把它想成是該物件在記憶體中的位址。:keyword:`is` 運算子會比較"

"兩個物件的識別性是否相同；:func:`id` 函式則會回傳代表一個該物件的識別性的整"

"數。"

#: ../../reference/datamodel.rst:42

msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."

msgstr "在 CPython 當中，``id(x)`` 就是 ``x`` 所儲存在的記憶體位址。"

#: ../../reference/datamodel.rst:44

msgid ""

"An object's type determines the operations that the object supports (e.g., "

"\"does it have a length?\") and also defines the possible values for objects "

"of that type. The :func:`type` function returns an object's type (which is "

"an object itself). Like its identity, an object's :dfn:`type` is also "

"unchangeable. [#]_"

msgstr ""

"一個物件的型別決定了該物件所支援的操作（例如「它有長度嗎？」），也同時定義該"

"型別的物件能夠擁有的數值。:func:`type` 函式會回傳一個物件的型別（而該型別本身"

"也是一個物件）。如同它的識別性，一個物件的型別 (:dfn:`type`) 也是不可變"

"的。\\ [#]_"

#: ../../reference/datamodel.rst:50

msgid ""

"The *value* of some objects can change. Objects whose value can change are "

"said to be *mutable*; objects whose value is unchangeable once they are "

"created are called *immutable*. (The value of an immutable container object "

"that contains a reference to a mutable object can change when the latter's "

"value is changed; however the container is still considered immutable, "

"because the collection of objects it contains cannot be changed. So, "

"immutability is not strictly the same as having an unchangeable value, it is "

"more subtle.) An object's mutability is determined by its type; for "

"instance, numbers, strings and tuples are immutable, while dictionaries and "

"lists are mutable."

msgstr ""

"某些物件的\\ *數值*\\ 可被改變，這種物件稱作「可變的」(*mutable*)；建立後數值"

"不能變更的物件則稱作「不可變的」(*immutable*)。（不可變的容器物件中如果包含對"

"於可變物件的參照，則後者的數值改變的時候前者的數值也會跟著一起改變；這種時候"

"該容器仍會被當成是不可變的，因為它包含的物件集合仍然無法變更。因此可變或不可"

"變嚴格說起並不等同於數值是否能被改變，它的定義有其他不明顯的細節。）一個物件"

"是否為可變取決於它的型別；舉例來說，數字、字串和 tuple 是不可變的，而字典與串"

"列則是可變的。"

#: ../../reference/datamodel.rst:65

msgid ""

"Objects are never explicitly destroyed; however, when they become "

"unreachable they may be garbage-collected. An implementation is allowed to "

"postpone garbage collection or omit it altogether --- it is a matter of "

"implementation quality how garbage collection is implemented, as long as no "

"objects are collected that are still reachable."

msgstr ""

"物件永遠不會被明示的摧毀；但當它們變得不再能夠存取的時候可能會被作為垃圾回"

"收。每個實作都能延後垃圾回收或是乾脆忽略它 --- 垃圾回收如何進行完全取決於各個"

"實作，只要沒有被回收的物件仍是可達的。"

#: ../../reference/datamodel.rst:73

msgid ""

"CPython currently uses a reference-counting scheme with (optional) delayed "

"detection of cyclically linked garbage, which collects most objects as soon "

"as they become unreachable, but is not guaranteed to collect garbage "

"containing circular references. See the documentation of the :mod:`gc` "

"module for information on controlling the collection of cyclic garbage. "

"Other implementations act differently and CPython may change. Do not depend "

"on immediate finalization of objects when they become unreachable (so you "

"should always close files explicitly)."

msgstr ""

"CPython 目前使用一種參照計數的方案，並提供可選的循環連結垃圾延遲偵測，這個方"

"案會在大部分物件變得不可存取時馬上回收它們，但不保證能夠回收包含循環參照的垃"

"圾。關於控制循環垃圾回收的資訊請見 :mod:`gc` 模組的說明文件。其他實作的行為不"

"會相同，CPython 也有可能改變，因此請不要仰賴物件在變得不可存取時能夠馬上被最"

"終化（亦即你應該總是明確關閉檔案）。"

#: ../../reference/datamodel.rst:82

msgid ""

"Note that the use of the implementation's tracing or debugging facilities "

"may keep objects alive that would normally be collectable. Also note that "

"catching an exception with a :keyword:`try`...\\ :keyword:`except` statement "

"may keep objects alive."

msgstr ""

"請注意，使用一個實作的追蹤或除錯工具可能會讓原本能夠回收的物件被維持存活。也"

"請注意，使用 :keyword:`try`...\\ :keyword:`except` 陳述式來抓捕例外也可能會讓"

"物件維持存活。"

#: ../../reference/datamodel.rst:87

msgid ""

"Some objects contain references to \"external\" resources such as open files "

"or windows. It is understood that these resources are freed when the object "

"is garbage-collected, but since garbage collection is not guaranteed to "

"happen, such objects also provide an explicit way to release the external "

"resource, usually a :meth:`!close` method. Programs are strongly recommended "

"to explicitly close such objects. The :keyword:`try`...\\ :keyword:"

"`finally` statement and the :keyword:`with` statement provide convenient "

"ways to do this."

msgstr ""

"某些物件包含對於「外部」資源的參照，像是開啟的檔案或是視窗。基本上這些資源會"

"在物件被回收時釋放，但因為垃圾回收不保證會發生，這種物件也會提供明確釋放外部"

"資源的方式 --- 通常是 :meth:`!close` method。強烈建議各個程式明確關閉這種物"

"件。:keyword:`try`...\\ :keyword:`finally` 陳述式與 :keyword:`with` 陳述式提"

"供進行明確關閉的方便手段。"

#: ../../reference/datamodel.rst:97

msgid ""

"Some objects contain references to other objects; these are called "

"*containers*. Examples of containers are tuples, lists and dictionaries. "

"The references are part of a container's value. In most cases, when we talk "

"about the value of a container, we imply the values, not the identities of "

"the contained objects; however, when we talk about the mutability of a "

"container, only the identities of the immediately contained objects are "

"implied. So, if an immutable container (like a tuple) contains a reference "

"to a mutable object, its value changes if that mutable object is changed."

msgstr ""

"某些物件包含對於其他物件的參照；這種物件被叫做「容器」。容器的範例有 tuple、"

"串列與字典。這些參照是容器的數值的一部分。通常當我們提到容器的數值的時候，我"

"們指的是其中包含的物件的數值，而不是它們的識別性；但當我們提到容器是否可變的"

"時候，我們指的是直接包含在其中的物件的識別性。因此，如果一個不可變的容器（像"

"一個 tuple）包含對於可變物件的參照，該可變物件被變更時該容器的數值也會跟著變"

"更。"

#: ../../reference/datamodel.rst:106

msgid ""

"Types affect almost all aspects of object behavior. Even the importance of "

"object identity is affected in some sense: for immutable types, operations "

"that compute new values may actually return a reference to any existing "

"object with the same type and value, while for mutable objects this is not "

"allowed. For example, after ``a = 1; b = 1``, *a* and *b* may or may not "

"refer to the same object with the value one, depending on the "

"implementation. This is because :class:`int` is an immutable type, so the "

"reference to ``1`` can be reused. This behaviour depends on the "

"implementation used, so should not be relied upon, but is something to be "

"aware of when making use of object identity tests. However, after ``c = []; "

"d = []``, *c* and *d* are guaranteed to refer to two different, unique, "

"newly created empty lists. (Note that ``e = f = []`` assigns the *same* "

"object to both *e* and *f*.)"

msgstr ""

"型別幾乎影響物件行為的所有面向。就連物件識別性的重要性某種程度上也受型別影"

"響：對於不可變的型別，計算新數值的操作可能其實會回傳一個某個相同型別且相同數"

"值的現存物件的參照；對於可變型別這則不會發生。舉例來說，在進行 ``a = 1; b = "

"1`` 之後，*a* 和 *b* 可能會參照同一個物件，也可能不會，取決於所使用的實作。這"

"是因為 :class:`int` 是不可變的型別，因此 ``1`` 的參照可以重複利用。這個行為取"

"決於所使用的實作，因此不應該依賴它，但在進行物件識別性測試的時候還是需要注意"

"有這件事情。而在進行 ``c = []; d = []`` 之後，*c* 和 *d* 則保證會參照兩個不"

"同、獨特、且新建立的空白串列。（請注意，``e = f = []`` 則會將同一個物件同時指"

"派給 *e* 和 *f*。）"

#: ../../reference/datamodel.rst:124

msgid "The standard type hierarchy"

msgstr "標準型別階層"

#: ../../reference/datamodel.rst:133

msgid ""

"Below is a list of the types that are built into Python. Extension modules "

"(written in C, Java, or other languages, depending on the implementation) "

"can define additional types. Future versions of Python may add types to the "

"type hierarchy (e.g., rational numbers, efficiently stored arrays of "

"integers, etc.), although such additions will often be provided via the "

"standard library instead."

msgstr ""

#: ../../reference/datamodel.rst:144

msgid ""

"Some of the type descriptions below contain a paragraph listing 'special "

"attributes.' These are attributes that provide access to the implementation "

"and are not intended for general use. Their definition may change in the "

"future."

msgstr ""

#: ../../reference/datamodel.rst:150 ../../reference/datamodel.rst:152

msgid "None"

msgstr "None"

#: ../../reference/datamodel.rst:154

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name ``None``. It is used to "

"signify the absence of a value in many situations, e.g., it is returned from "

"functions that don't explicitly return anything. Its truth value is false."

msgstr ""

"這個型別只有一個數值。只有一個物件有這個數值。這個物件由內建名稱 ``None`` 存"

"取。它用來在許多情況下代表數值不存在，例如沒有明確回傳任何東西的函式就會回傳"

"這個物件。它的真值是 false。"

#: ../../reference/datamodel.rst:161 ../../reference/datamodel.rst:163

msgid "NotImplemented"

msgstr "NotImplemented"

#: ../../reference/datamodel.rst:165

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name :data:`NotImplemented`. "

"Numeric methods and rich comparison methods should return this value if they "

"do not implement the operation for the operands provided. (The interpreter "

"will then try the reflected operation, or some other fallback, depending on "

"the operator.) It should not be evaluated in a boolean context."

msgstr ""

"這個型別只有一個數值。只有一個物件有這個數值。這個物件由內建名稱 :data:"

"`NotImplemented` 存取。數字方法和 rich comparison 方法應該在沒有為所提供的運"

"算元實作該操作的時候回傳這個數值。（直譯器接下來則會依運算子嘗試反轉的操作或"

"是其他的後備方案。）它不應該在預期布林值的情境中被計算。"

#: ../../reference/datamodel.rst:172

msgid "See :ref:`implementing-the-arithmetic-operations` for more details."

msgstr "更多細節請見 :ref:`implementing-the-arithmetic-operations`。"

#: ../../reference/datamodel.rst:176

msgid ""

"Evaluating :data:`NotImplemented` in a boolean context is deprecated. While "

"it currently evaluates as true, it will emit a :exc:`DeprecationWarning`. It "

"will raise a :exc:`TypeError` in a future version of Python."

msgstr ""

"在預期布林值的情境中計算 :data:`NotImplemented` 的行為已棄用。雖然目前它會計"

"算為 true，它也會同時發出 :exc:`DeprecationWarning`。從某個未來 Python 版本開"

"始這將會引發 :exc:`TypeError`。"

#: ../../reference/datamodel.rst:183 ../../reference/datamodel.rst:184

msgid "Ellipsis"

msgstr "Ellipsis"

#: ../../reference/datamodel.rst:188

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the literal ``...`` or the built-in name "

"``Ellipsis``. Its truth value is true."

msgstr ""

"這個型別只有一個數值。只有一個物件有這個數值。這個物件由文本 ``...`` 或內建名"

"稱 ``Ellipsis`` 存取。它的真值是 true。"

#: ../../reference/datamodel.rst:194

msgid ":class:`numbers.Number`"

msgstr ":class:`numbers.Number`"

#: ../../reference/datamodel.rst:198

msgid ""

"These are created by numeric literals and returned as results by arithmetic "

"operators and arithmetic built-in functions. Numeric objects are immutable; "

"once created their value never changes. Python numbers are of course "

"strongly related to mathematical numbers, but subject to the limitations of "

"numerical representation in computers."

msgstr ""

#: ../../reference/datamodel.rst:204

msgid ""

"The string representations of the numeric classes, computed by :meth:"

"`~object.__repr__` and :meth:`~object.__str__`, have the following "

"properties:"

msgstr ""

#: ../../reference/datamodel.rst:208

msgid ""

"They are valid numeric literals which, when passed to their class "

"constructor, produce an object having the value of the original numeric."

msgstr ""

#: ../../reference/datamodel.rst:212

msgid "The representation is in base 10, when possible."

msgstr ""

#: ../../reference/datamodel.rst:214

msgid ""

"Leading zeros, possibly excepting a single zero before a decimal point, are "

"not shown."

msgstr ""

#: ../../reference/datamodel.rst:217

msgid ""

"Trailing zeros, possibly excepting a single zero after a decimal point, are "

"not shown."

msgstr ""

#: ../../reference/datamodel.rst:220

msgid "A sign is shown only when the number is negative."

msgstr ""

#: ../../reference/datamodel.rst:222

msgid ""

"Python distinguishes between integers, floating-point numbers, and complex "

"numbers:"

msgstr ""

#: ../../reference/datamodel.rst:227

msgid ":class:`numbers.Integral`"

msgstr ":class:`numbers.Integral`"

#: ../../reference/datamodel.rst:231

msgid ""

"These represent elements from the mathematical set of integers (positive and "

"negative)."

msgstr ""

#: ../../reference/datamodel.rst:237

msgid ""

"The rules for integer representation are intended to give the most "

"meaningful interpretation of shift and mask operations involving negative "

"integers."

msgstr ""

#: ../../reference/datamodel.rst:240

msgid "There are two types of integers:"

msgstr ""

#: ../../reference/datamodel.rst:242

msgid "Integers (:class:`int`)"

msgstr ""

#: ../../reference/datamodel.rst:243

msgid ""

"These represent numbers in an unlimited range, subject to available "

"(virtual) memory only. For the purpose of shift and mask operations, a "

"binary representation is assumed, and negative numbers are represented in a "

"variant of 2's complement which gives the illusion of an infinite string of "

"sign bits extending to the left."

msgstr ""

#: ../../reference/datamodel.rst:249

msgid "Booleans (:class:`bool`)"

msgstr ""

#: ../../reference/datamodel.rst:255

msgid ""

"These represent the truth values False and True. The two objects "

"representing the values ``False`` and ``True`` are the only Boolean objects. "

"The Boolean type is a subtype of the integer type, and Boolean values behave "

"like the values 0 and 1, respectively, in almost all contexts, the exception "

"being that when converted to a string, the strings ``\"False\"`` or "

"``\"True\"`` are returned, respectively."

msgstr ""

#: ../../reference/datamodel.rst:263

msgid ":class:`numbers.Real` (:class:`float`)"

msgstr ":class:`numbers.Real` (:class:`float`)"

#: ../../reference/datamodel.rst:271

msgid ""

"These represent machine-level double precision floating-point numbers. You "

"are at the mercy of the underlying machine architecture (and C or Java "

"implementation) for the accepted range and handling of overflow. Python does "

"not support single-precision floating-point numbers; the savings in "

"processor and memory usage that are usually the reason for using these are "

"dwarfed by the overhead of using objects in Python, so there is no reason to "

"complicate the language with two kinds of floating-point numbers."

msgstr ""

#: ../../reference/datamodel.rst:281

msgid ":class:`numbers.Complex` (:class:`complex`)"

msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: ../../reference/datamodel.rst:287

msgid ""

"These represent complex numbers as a pair of machine-level double precision "

"floating-point numbers. The same caveats apply as for floating-point "

"numbers. The real and imaginary parts of a complex number ``z`` can be "

"retrieved through the read-only attributes ``z.real`` and ``z.imag``."

msgstr ""

#: ../../reference/datamodel.rst:294

msgid "Sequences"

msgstr ""

#: ../../reference/datamodel.rst:303

msgid ""

"These represent finite ordered sets indexed by non-negative numbers. The "

"built-in function :func:`len` returns the number of items of a sequence. "

"When the length of a sequence is *n*, the index set contains the numbers 0, "

"1, ..., *n*-1. Item *i* of sequence *a* is selected by ``a[i]``. Some "

"sequences, including built-in sequences, interpret negative subscripts by "

"adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, the "

"second to last item of sequence a with length ``n``."

msgstr ""

#: ../../reference/datamodel.rst:313

msgid ""

"Sequences also support slicing: ``a[i:j]`` selects all items with index *k* "

"such that *i* ``<=`` *k* ``<`` *j*. When used as an expression, a slice is "

"a sequence of the same type. The comment above about negative indexes also "

"applies to negative slice positions."

msgstr ""

#: ../../reference/datamodel.rst:318

msgid ""

"Some sequences also support \"extended slicing\" with a third \"step\" "

"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "

"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."

msgstr ""

#: ../../reference/datamodel.rst:322

msgid "Sequences are distinguished according to their mutability:"

msgstr ""

#: ../../reference/datamodel.rst:326

msgid "Immutable sequences"

msgstr ""

#: ../../reference/datamodel.rst:332

msgid ""

"An object of an immutable sequence type cannot change once it is created. "

"(If the object contains references to other objects, these other objects may "

"be mutable and may be changed; however, the collection of objects directly "

"referenced by an immutable object cannot change.)"

msgstr ""

#: ../../reference/datamodel.rst:337

msgid "The following types are immutable sequences:"

msgstr ""

#: ../../reference/datamodel.rst:342

msgid "Strings"

msgstr "字串 (String)"

#: ../../reference/datamodel.rst:350

msgid ""

"A string is a sequence of values that represent Unicode code points. All the "

"code points in the range ``U+0000 - U+10FFFF`` can be represented in a "

"string. Python doesn't have a :c:expr:`char` type; instead, every code "

"point in the string is represented as a string object with length ``1``. "

"The built-in function :func:`ord` converts a code point from its string form "

"to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer "

"in the range ``0 - 10FFFF`` to the corresponding length ``1`` string "

"object. :meth:`str.encode` can be used to convert a :class:`str` to :class:"

"`bytes` using the given text encoding, and :meth:`bytes.decode` can be used "

"to achieve the opposite."

msgstr ""

#: ../../reference/datamodel.rst:362

msgid "Tuples"

msgstr "Tuple（元組）"

#: ../../reference/datamodel.rst:368

msgid ""

"The items of a tuple are arbitrary Python objects. Tuples of two or more "

"items are formed by comma-separated lists of expressions. A tuple of one "

"item (a 'singleton') can be formed by affixing a comma to an expression (an "

"expression by itself does not create a tuple, since parentheses must be "

"usable for grouping of expressions). An empty tuple can be formed by an "

"empty pair of parentheses."

msgstr ""

#: ../../reference/datamodel.rst:375

msgid "Bytes"

msgstr "位元組"

#: ../../reference/datamodel.rst:378

msgid ""

"A bytes object is an immutable array. The items are 8-bit bytes, "

"represented by integers in the range 0 <= x < 256. Bytes literals (like "

"``b'abc'``) and the built-in :func:`bytes` constructor can be used to create "

"bytes objects. Also, bytes objects can be decoded to strings via the :meth:"

"`~bytes.decode` method."

msgstr ""

#: ../../reference/datamodel.rst:386

msgid "Mutable sequences"

msgstr "可變序列"

#: ../../reference/datamodel.rst:395

msgid ""

"Mutable sequences can be changed after they are created. The subscription "

"and slicing notations can be used as the target of assignment and :keyword:"

"`del` (delete) statements."

msgstr ""

#: ../../reference/datamodel.rst:403

msgid ""

"The :mod:`collections` and :mod:`array` module provide additional examples "

"of mutable sequence types."

msgstr ""

#: ../../reference/datamodel.rst:406

msgid "There are currently two intrinsic mutable sequence types:"

msgstr ""

#: ../../reference/datamodel.rst:408

msgid "Lists"

msgstr "List（串列）"

#: ../../reference/datamodel.rst:411

msgid ""

"The items of a list are arbitrary Python objects. Lists are formed by "

"placing a comma-separated list of expressions in square brackets. (Note that "

"there are no special cases needed to form lists of length 0 or 1.)"

msgstr ""

#: ../../reference/datamodel.rst:415

msgid "Byte Arrays"

msgstr "位元組陣列"

#: ../../reference/datamodel.rst:418

msgid ""

"A bytearray object is a mutable array. They are created by the built-in :"

"func:`bytearray` constructor. Aside from being mutable (and hence "

"unhashable), byte arrays otherwise provide the same interface and "

"functionality as immutable :class:`bytes` objects."

msgstr ""

#: ../../reference/datamodel.rst:425

msgid "Set types"

msgstr "Set（集合）型別"

#: ../../reference/datamodel.rst:431

msgid ""

"These represent unordered, finite sets of unique, immutable objects. As "

"such, they cannot be indexed by any subscript. However, they can be iterated "

"over, and the built-in function :func:`len` returns the number of items in a "

"set. Common uses for sets are fast membership testing, removing duplicates "

"from a sequence, and computing mathematical operations such as intersection, "

"union, difference, and symmetric difference."

msgstr ""

#: ../../reference/datamodel.rst:438

msgid ""

"For set elements, the same immutability rules apply as for dictionary keys. "

"Note that numeric types obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "

"contained in a set."

msgstr ""

#: ../../reference/datamodel.rst:443

msgid "There are currently two intrinsic set types:"

msgstr ""

#: ../../reference/datamodel.rst:446

msgid "Sets"

msgstr "Set（集合）"

#: ../../reference/datamodel.rst:449

msgid ""

"These represent a mutable set. They are created by the built-in :func:`set` "

"constructor and can be modified afterwards by several methods, such as :meth:"

"`~set.add`."

msgstr ""

#: ../../reference/datamodel.rst:454

msgid "Frozen sets"

msgstr "Frozen set（凍結集合）"

#: ../../reference/datamodel.rst:457

msgid ""

"These represent an immutable set. They are created by the built-in :func:"

"`frozenset` constructor. As a frozenset is immutable and :term:`hashable`, "

"it can be used again as an element of another set, or as a dictionary key."

msgstr ""

#: ../../reference/datamodel.rst:464

msgid "Mappings"

msgstr "對映"

#: ../../reference/datamodel.rst:471

msgid ""

"These represent finite sets of objects indexed by arbitrary index sets. The "

"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "

"mapping ``a``; this can be used in expressions and as the target of "

"assignments or :keyword:`del` statements. The built-in function :func:`len` "

"returns the number of items in a mapping."

msgstr ""

#: ../../reference/datamodel.rst:477

msgid "There is currently a single intrinsic mapping type:"

msgstr ""

#: ../../reference/datamodel.rst:481

msgid "Dictionaries"

msgstr "字典"

#: ../../reference/datamodel.rst:485

msgid ""

"These represent finite sets of objects indexed by nearly arbitrary values. "

"The only types of values not acceptable as keys are values containing lists "

"or dictionaries or other mutable types that are compared by value rather "

"than by object identity, the reason being that the efficient implementation "

"of dictionaries requires a key's hash value to remain constant. Numeric "

"types used for keys obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "

"interchangeably to index the same dictionary entry."

msgstr ""

#: ../../reference/datamodel.rst:494

msgid ""

"Dictionaries preserve insertion order, meaning that keys will be produced in "

"the same order they were added sequentially over the dictionary. Replacing "

"an existing key does not change the order, however removing a key and re-"

"inserting it will add it to the end instead of keeping its old place."

msgstr ""

#: ../../reference/datamodel.rst:499

msgid ""

"Dictionaries are mutable; they can be created by the ``{}`` notation (see "

"section :ref:`dict`)."

msgstr ""

#: ../../reference/datamodel.rst:506

msgid ""

"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "

"examples of mapping types, as does the :mod:`collections` module."

msgstr ""

#: ../../reference/datamodel.rst:510

msgid ""

"Dictionaries did not preserve insertion order in versions of Python before "

"3.6. In CPython 3.6, insertion order was preserved, but it was considered an "

"implementation detail at that time rather than a language guarantee."

msgstr ""

#: ../../reference/datamodel.rst:517

msgid "Callable types"

msgstr "可呼叫型別"

#: ../../reference/datamodel.rst:525

msgid ""

"These are the types to which the function call operation (see section :ref:"

"`calls`) can be applied:"

msgstr ""

#: ../../reference/datamodel.rst:532

msgid "User-defined functions"

msgstr "自訂函式"

#: ../../reference/datamodel.rst:539

msgid ""

"A user-defined function object is created by a function definition (see "

"section :ref:`function`). It should be called with an argument list "

"containing the same number of items as the function's formal parameter list."

msgstr ""

#: ../../reference/datamodel.rst:545 ../../reference/datamodel.rst:1395

#: ../../reference/datamodel.rst:1594

msgid "Special read-only attributes"

msgstr "特殊唯讀屬性"

#: ../../reference/datamodel.rst:555 ../../reference/datamodel.rst:590

#: ../../reference/datamodel.rst:1170

msgid "Attribute"

msgstr "屬性"

#: ../../reference/datamodel.rst:556 ../../reference/datamodel.rst:591

#: ../../reference/datamodel.rst:1171

msgid "Meaning"

msgstr "含義"

#: ../../reference/datamodel.rst:559

msgid ""

"A reference to the :class:`dictionary <dict>` that holds the function's :ref:"

"`global variables <naming>` -- the global namespace of the module in which "

"the function was defined."

msgstr ""

#: ../../reference/datamodel.rst:564

msgid ""

"``None`` or a :class:`tuple` of cells that contain bindings for the names "

"specified in the :attr:`~codeobject.co_freevars` attribute of the "

"function's :attr:`code object <function.__code__>`."

msgstr ""

#: ../../reference/datamodel.rst:568

msgid ""

"A cell object has the attribute ``cell_contents``. This can be used to get "

"the value of the cell, as well as set the value."

msgstr ""

#: ../../reference/datamodel.rst:572 ../../reference/datamodel.rst:1636

msgid "Special writable attributes"

msgstr "特殊可寫屬性"

#: ../../reference/datamodel.rst:585

msgid "Most of these attributes check the type of the assigned value:"

msgstr ""

#: ../../reference/datamodel.rst:594

msgid "The function's documentation string, or ``None`` if unavailable."

msgstr "函式的文件字串，若不可用則為 ``None``。"

#: ../../reference/datamodel.rst:597

msgid ""

"The function's name. See also: :attr:`__name__ attributes <definition."

"__name__>`."

msgstr ""

#: ../../reference/datamodel.rst:601

msgid ""

"The function's :term:`qualified name`. See also: :attr:`__qualname__ "

"attributes <definition.__qualname__>`."

msgstr ""

#: ../../reference/datamodel.rst:607

msgid ""

"The name of the module the function was defined in, or ``None`` if "

"unavailable."

msgstr ""

#: ../../reference/datamodel.rst:611

msgid ""

"A :class:`tuple` containing default :term:`parameter` values for those "

"parameters that have defaults, or ``None`` if no parameters have a default "

"value."

msgstr ""

#: ../../reference/datamodel.rst:616

msgid ""

"The :ref:`code object <code-objects>` representing the compiled function "

"body."

msgstr "代表編譯函式主體的\\ :ref:`程式碼物件 <code-objects>`。"

#: ../../reference/datamodel.rst:620

msgid ""

"The namespace supporting arbitrary function attributes. See also: :attr:"

"`__dict__ attributes <object.__dict__>`."

msgstr ""

#: ../../reference/datamodel.rst:624

msgid ""

"A :class:`dictionary <dict>` containing annotations of :term:`parameters "

"<parameter>`. The keys of the dictionary are the parameter names, and "

"``'return'`` for the return annotation, if provided. See also: :ref:"

"`annotations-howto`."

msgstr ""

#: ../../reference/datamodel.rst:631

msgid ""

"A :class:`dictionary <dict>` containing defaults for keyword-only :term:"

"`parameters <parameter>`."

msgstr ""

#: ../../reference/datamodel.rst:635

msgid ""

"A :class:`tuple` containing the :ref:`type parameters <type-params>` of a :"

"ref:`generic function <generic-functions>`."

msgstr ""

#: ../../reference/datamodel.rst:640

msgid ""

"Function objects also support getting and setting arbitrary attributes, "

"which can be used, for example, to attach metadata to functions. Regular "

"attribute dot-notation is used to get and set such attributes."

msgstr ""

#: ../../reference/datamodel.rst:646

msgid ""

"CPython's current implementation only supports function attributes on user-"

"defined functions. Function attributes on :ref:`built-in functions <builtin-"

"functions>` may be supported in the future."

msgstr ""

#: ../../reference/datamodel.rst:651

msgid ""

"Additional information about a function's definition can be retrieved from "

"its :ref:`code object <code-objects>` (accessible via the :attr:`~function."

"__code__` attribute)."

msgstr ""

#: ../../reference/datamodel.rst:659

msgid "Instance methods"

msgstr "實例方法"

#: ../../reference/datamodel.rst:666

msgid ""

"An instance method object combines a class, a class instance and any "

"callable object (normally a user-defined function)."

msgstr ""

#: ../../reference/datamodel.rst:676 ../../reference/datamodel.rst:1732

msgid "Special read-only attributes:"

msgstr "特殊唯讀屬性："

#: ../../reference/datamodel.rst:681

msgid ""

"Refers to the class instance object to which the method is :ref:`bound "

"<method-binding>`"

msgstr ""

#: ../../reference/datamodel.rst:685

msgid "Refers to the original :ref:`function object <user-defined-funcs>`"

msgstr ""

#: ../../reference/datamodel.rst:688

msgid ""

"The method's documentation (same as :attr:`method.__func__.__doc__ <function."

"__doc__>`). A :class:`string <str>` if the original function had a "

"docstring, else ``None``."

msgstr ""

#: ../../reference/datamodel.rst:694

msgid ""

"The name of the method (same as :attr:`method.__func__.__name__ <function."

"__name__>`)"

msgstr ""

#: ../../reference/datamodel.rst:698

msgid ""

"The name of the module the method was defined in, or ``None`` if unavailable."

msgstr ""

#: ../../reference/datamodel.rst:701

msgid ""

"Methods also support accessing (but not setting) the arbitrary function "

"attributes on the underlying :ref:`function object <user-defined-funcs>`."

msgstr ""

#: ../../reference/datamodel.rst:704

msgid ""

"User-defined method objects may be created when getting an attribute of a "

"class (perhaps via an instance of that class), if that attribute is a user-"

"defined :ref:`function object <user-defined-funcs>` or a :class:"

"`classmethod` object."

msgstr ""

#: ../../reference/datamodel.rst:711

msgid ""

"When an instance method object is created by retrieving a user-defined :ref:"

"`function object <user-defined-funcs>` from a class via one of its "

"instances, its :attr:`~method.__self__` attribute is the instance, and the "

"method object is said to be *bound*. The new method's :attr:`~method."

"__func__` attribute is the original function object."

msgstr ""

#: ../../reference/datamodel.rst:717

msgid ""

"When an instance method object is created by retrieving a :class:"

"`classmethod` object from a class or instance, its :attr:`~method.__self__` "

"attribute is the class itself, and its :attr:`~method.__func__` attribute is "

"the function object underlying the class method."

msgstr ""

#: ../../reference/datamodel.rst:722

msgid ""

"When an instance method object is called, the underlying function (:attr:"

"`~method.__func__`) is called, inserting the class instance (:attr:`~method."

"__self__`) in front of the argument list. For instance, when :class:`!C` is "

"a class which contains a definition for a function :meth:`!f`, and ``x`` is "

"an instance of :class:`!C`, calling ``x.f(1)`` is equivalent to calling ``C."

"f(x, 1)``."

msgstr ""

#: ../../reference/datamodel.rst:729

msgid ""

"When an instance method object is derived from a :class:`classmethod` "

"object, the \"class instance\" stored in :attr:`~method.__self__` will "

"actually be the class itself, so that calling either ``x.f(1)`` or ``C."

"f(1)`` is equivalent to calling ``f(C,1)`` where ``f`` is the underlying "

"function."

msgstr ""

#: ../../reference/datamodel.rst:734

msgid ""

"It is important to note that user-defined functions which are attributes of "

"a class instance are not converted to bound methods; this *only* happens "

"when the function is an attribute of the class."

msgstr ""

#: ../../reference/datamodel.rst:741

msgid "Generator functions"

msgstr "產生器函式"

#: ../../reference/datamodel.rst:747

msgid ""

"A function or method which uses the :keyword:`yield` statement (see section :"

"ref:`yield`) is called a :dfn:`generator function`. Such a function, when "

"called, always returns an :term:`iterator` object which can be used to "

"execute the body of the function: calling the iterator's :meth:`iterator."

"__next__` method will cause the function to execute until it provides a "

"value using the :keyword:`!yield` statement. When the function executes a :"

"keyword:`return` statement or falls off the end, a :exc:`StopIteration` "

"exception is raised and the iterator will have reached the end of the set of "

"values to be returned."

msgstr ""

#: ../../reference/datamodel.rst:759

msgid "Coroutine functions"

msgstr "Coroutine（協程）函式"

#: ../../reference/datamodel.rst:764

msgid ""

"A function or method which is defined using :keyword:`async def` is called "

"a :dfn:`coroutine function`. Such a function, when called, returns a :term:"

"`coroutine` object. It may contain :keyword:`await` expressions, as well "

"as :keyword:`async with` and :keyword:`async for` statements. See also the :"

"ref:`coroutine-objects` section."

msgstr ""

#: ../../reference/datamodel.rst:772

msgid "Asynchronous generator functions"

msgstr "非同步產生器函式"

#: ../../reference/datamodel.rst:778

msgid ""

"A function or method which is defined using :keyword:`async def` and which "

"uses the :keyword:`yield` statement is called a :dfn:`asynchronous generator "

"function`. Such a function, when called, returns an :term:`asynchronous "

"iterator` object which can be used in an :keyword:`async for` statement to "

"execute the body of the function."

msgstr ""

#: ../../reference/datamodel.rst:784

msgid ""

"Calling the asynchronous iterator's :meth:`aiterator.__anext__ <object."

"__anext__>` method will return an :term:`awaitable` which when awaited will "

"execute until it provides a value using the :keyword:`yield` expression. "

"When the function executes an empty :keyword:`return` statement or falls off "

"the end, a :exc:`StopAsyncIteration` exception is raised and the "

"asynchronous iterator will have reached the end of the set of values to be "

"yielded."

msgstr ""

#: ../../reference/datamodel.rst:797

msgid "Built-in functions"

msgstr "內建函式"

#: ../../reference/datamodel.rst:804

msgid ""

"A built-in function object is a wrapper around a C function. Examples of "

"built-in functions are :func:`len` and :func:`math.sin` (:mod:`math` is a "

"standard built-in module). The number and type of the arguments are "

"determined by the C function. Special read-only attributes:"

msgstr ""

"一個內建函式物件是一個 C 函式的 wrapper。內建函式的範例有 :func:`len` 和 :"

"func:`math.sin`\\ （\\ :mod:`math` 是一個標準的內建模組）。內建函式的引數數量"

"與其型別由其包裝的 C 函式所決定。特殊唯讀屬性："

#: ../../reference/datamodel.rst:809

msgid ""

":attr:`!__doc__` is the function's documentation string, or ``None`` if "

"unavailable. See :attr:`function.__doc__`."

msgstr ""

":attr:`!__doc__` 是函式的文件字串，若不可用則為 ``None``。請見 :attr:"

"`function.__doc__`。"

#: ../../reference/datamodel.rst:811

msgid ""

":attr:`!__name__` is the function's name. See :attr:`function.__name__`."

msgstr ":attr:`!__name__` 是函式的名稱。請見 :attr:`function.__name__`。"

#: ../../reference/datamodel.rst:812

msgid ":attr:`!__self__` is set to ``None`` (but see the next item)."

msgstr ""

#: ../../reference/datamodel.rst:813

msgid ""

":attr:`!__module__` is the name of the module the function was defined in or "

"``None`` if unavailable. See :attr:`function.__module__`."

msgstr ""

#: ../../reference/datamodel.rst:821

msgid "Built-in methods"

msgstr "內建方法"

#: ../../reference/datamodel.rst:828

msgid ""

"This is really a different disguise of a built-in function, this time "

"containing an object passed to the C function as an implicit extra "

"argument. An example of a built-in method is ``alist.append()``, assuming "

"*alist* is a list object. In this case, the special read-only attribute :"

"attr:`!__self__` is set to the object denoted by *alist*. (The attribute has "

"the same semantics as it does with :attr:`other instance methods <method."

"__self__>`.)"

msgstr ""