# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# Adrian Liaw <adrianliaw2000@gmail.com>, 2018

# Matt Wang <mattwang44@gmail.com>, 2026

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-02-27 02:51+0800\n"

"PO-Revision-Date: 2026-02-27 16:17+0800\n"

"Last-Translator: Adrian Liaw <adrianliaw2000@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"

#: ../../reference/simple_stmts.rst:6

msgid "Simple statements"

msgstr "簡單陳述式"

#: ../../reference/simple_stmts.rst:10

msgid ""

"A simple statement is comprised within a single logical line. Several simple "

"statements may occur on a single line separated by semicolons. The syntax "

"for simple statements is:"

msgstr ""

"一個簡單陳述式會被包含在一個單獨的邏輯列中。多個簡單陳述式用分號分隔就可以出"

"現在同一列中。簡單陳述式的語法如下："

#: ../../reference/simple_stmts.rst:37

msgid "Expression statements"

msgstr "運算式陳述式"

#: ../../reference/simple_stmts.rst:44

msgid ""

"Expression statements are used (mostly interactively) to compute and write a "

"value, or (usually) to call a procedure (a function that returns no "

"meaningful result; in Python, procedures return the value ``None``). Other "

"uses of expression statements are allowed and occasionally useful. The "

"syntax for an expression statement is:"

msgstr ""

"運算式陳述式（主要在互動模式下）用於計算並寫入一個值，或者（通常）用於呼叫一"

"個程序 (procedure)（一個不回傳有意義結果的函式；在 Python 中，程序會回傳 "

"``None`` 值）。運算式陳述式的其他用途也是被允許的，並且偶爾會很有用。運算式陳"

"述式的語法如下："

#: ../../reference/simple_stmts.rst:53

msgid ""

"An expression statement evaluates the expression list (which may be a single "

"expression)."

msgstr "運算式陳述式會對運算式串列（可能是單個運算式）進行求值 (evaluate)。"

#: ../../reference/simple_stmts.rst:65

msgid ""

"In interactive mode, if the value is not ``None``, it is converted to a "

"string using the built-in :func:`repr` function and the resulting string is "

"written to standard output on a line by itself (except if the result is "

"``None``, so that procedure calls do not cause any output.)"

msgstr ""

"在互動模式下，如果值不是 ``None``，就會以內建的 :func:`repr` 函式轉換成字串，"

"並將結果字串單獨寫入標準輸出的一列中（除非結果是 ``None``，則程序呼叫就不會產"

"生任何輸出）。"

#: ../../reference/simple_stmts.rst:73

msgid "Assignment statements"

msgstr "賦值陳述式"

#: ../../reference/simple_stmts.rst:83

msgid ""

"Assignment statements are used to (re)bind names to values and to modify "

"attributes or items of mutable objects:"

msgstr "賦值陳述式用於將名稱（重新）繫結到值，以及修改可變物件的屬性或項目："

#: ../../reference/simple_stmts.rst:96

msgid ""

"(See section :ref:`primaries` for the syntax definitions for *attributeref* "

"and *subscription*.)"

msgstr ""

"（關於 *attributeref* 和 *subscription* 的語法定義，請參閱 :ref:`primaries` "

"章節。）"

#: ../../reference/simple_stmts.rst:99

msgid ""

"An assignment statement evaluates the expression list (remember that this "

"can be a single expression or a comma-separated list, the latter yielding a "

"tuple) and assigns the single resulting object to each of the target lists, "

"from left to right."

msgstr ""

"賦值陳述式會對運算式串列進行求值（請記住，這可以是單個運算式或以逗號分隔的串"

"列，後者會產生一個元組），並將單個結果物件從左到右賦值給每個目標串列。"

#: ../../reference/simple_stmts.rst:108

msgid ""

"Assignment is defined recursively depending on the form of the target "

"(list). When a target is part of a mutable object (an attribute reference or "

"subscription), the mutable object must ultimately perform the assignment and "

"decide about its validity, and may raise an exception if the assignment is "

"unacceptable. The rules observed by various types and the exceptions raised "

"are given with the definition of the object types (see section :ref:`types`)."

msgstr ""

"賦值是根據目標（串列）的形式遞迴定義的。當目標是可變物件的一部分（屬性參照或"

"下標）時，該可變物件最終必須執行賦值並決定其有效性，如果賦值不被接受則可能會"

"引發例外。各種型別遵循的規則以及引發的例外在物件型別的定義中給定（請參"

"閱\\ :ref:`types`\\ 章節）。"

#: ../../reference/simple_stmts.rst:121

msgid ""

"Assignment of an object to a target list, optionally enclosed in parentheses "

"or square brackets, is recursively defined as follows."

msgstr ""

"將物件賦值給目標串列（可選擇性地用圓括號或方括號括起來）是以下列方式遞迴定義"

"的。"

#: ../../reference/simple_stmts.rst:124

msgid ""

"If the target list is a single target with no trailing comma, optionally in "

"parentheses, the object is assigned to that target."

msgstr ""

"如果目標串列是單個目標且沒有尾隨逗號（可選擇性地用圓括號括起來），則物件會被"

"賦值給該目標。"

#: ../../reference/simple_stmts.rst:127

msgid "Else:"

msgstr "否則："

#: ../../reference/simple_stmts.rst:129

msgid ""

"If the target list contains one target prefixed with an asterisk, called a "

"\"starred\" target: The object must be an iterable with at least as many "

"items as there are targets in the target list, minus one. The first items "

"of the iterable are assigned, from left to right, to the targets before the "

"starred target. The final items of the iterable are assigned to the targets "

"after the starred target. A list of the remaining items in the iterable is "

"then assigned to the starred target (the list can be empty)."

msgstr ""

"如果目標串列包含一個以星號為前綴的目標，稱為 \"starred\" 目標：該物件必須是一個"

"可疊代物件，其項目數量至少與目標串列中的目標數量減一一樣多。可疊代物件的前幾"

"個項目從左到右賦值給 starred 目標之前的目標。可疊代物件的最後幾個項目賦值給 "

"starred 目標之後的目標。然後可疊代物件中剩餘項目的串列會被賦值給 starred 目"

"標（該串列可以為空）。"

#: ../../reference/simple_stmts.rst:137

msgid ""

"Else: The object must be an iterable with the same number of items as there "

"are targets in the target list, and the items are assigned, from left to "

"right, to the corresponding targets."

msgstr ""

"否則：該物件必須是一個可疊代物件，其項目數量與目標串列中的目標數量相同，並且"

"這些項目從左到右賦值給對應的目標。"

#: ../../reference/simple_stmts.rst:141

msgid ""

"Assignment of an object to a single target is recursively defined as follows."

msgstr "將物件賦值給單個目標是以下列方式遞迴定義的。"

#: ../../reference/simple_stmts.rst:143

msgid "If the target is an identifier (name):"

msgstr "如果目標是一個識別字（名稱）："

#: ../../reference/simple_stmts.rst:145

msgid ""

"If the name does not occur in a :keyword:`global` or :keyword:`nonlocal` "

"statement in the current code block: the name is bound to the object in the "

"current local namespace."

msgstr ""

"如果該名稱沒有出現在當前程式碼區塊的 :keyword:`global` "

"或 :keyword:`nonlocal` 陳述式中：該名稱會被繫結到當前區域命名空間中的物件。"

#: ../../reference/simple_stmts.rst:149

msgid ""

"Otherwise: the name is bound to the object in the global namespace or the "

"outer namespace determined by :keyword:`nonlocal`, respectively."

msgstr ""

"否則：該名稱分別被繫結到全域命名空間或由 :keyword:`nonlocal` 決定的外層命名空"

"間中的物件。"

#: ../../reference/simple_stmts.rst:154

msgid ""

"The name is rebound if it was already bound. This may cause the reference "

"count for the object previously bound to the name to reach zero, causing the "

"object to be deallocated and its destructor (if it has one) to be called."

msgstr ""

"如果名稱已經被繫結，則會重新繫結。這可能導致先前繫結到該名稱的物件的參照計數"

"變為零，從而導致該物件被釋放並呼叫其解構函式（如果有的話）。"

#: ../../reference/simple_stmts.rst:160

msgid ""

"If the target is an attribute reference: The primary expression in the "

"reference is evaluated. It should yield an object with assignable "

"attributes; if this is not the case, :exc:`TypeError` is raised. That "

"object is then asked to assign the assigned object to the given attribute; "

"if it cannot perform the assignment, it raises an exception (usually but not "

"necessarily :exc:`AttributeError`)."

msgstr ""

"如果目標是屬性參照：參照中的主要運算式會被求值。它應該產生一個具有可賦值屬性"

"的物件；如果不是這種情況，則會引發 :exc:`TypeError`。然後要求該物件將被賦值的"

"物件賦值給指定的屬性；如果它無法執行賦值，則會引發例外（通常"

"是 :exc:`AttributeError` 但並非一定）。"

#: ../../reference/simple_stmts.rst:169

msgid ""

"Note: If the object is a class instance and the attribute reference occurs "

"on both sides of the assignment operator, the right-hand side expression, "

"``a.x`` can access either an instance attribute or (if no instance attribute "

"exists) a class attribute. The left-hand side target ``a.x`` is always set "

"as an instance attribute, creating it if necessary. Thus, the two "

"occurrences of ``a.x`` do not necessarily refer to the same attribute: if "

"the right-hand side expression refers to a class attribute, the left-hand "

"side creates a new instance attribute as the target of the assignment::"

msgstr ""

"注意：如果物件是類別實例，且屬性參照出現在賦值運算子的兩側，右側運算式 "

"``a.x`` 可以存取實例屬性或（如果不存在實例屬性）類別屬性。左側目標 ``a.x`` 總"

"是被設定為實例屬性，如有必要會建立它。因此，``a.x`` 的兩次出現不一定指向同一"

"個屬性：如果右側運算式參照的是類別屬性，左側會建立一個新的實例屬性作為賦值的"

"目標： ::"

#: ../../reference/simple_stmts.rst:178

msgid ""

"class Cls:\n"

" x = 3 # class variable\n"

"inst = Cls()\n"

"inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3"

msgstr ""

"class Cls:\n"

" x = 3 # 類別變數\n"

"inst = Cls()\n"

"inst.x = inst.x + 1 # 將 inst.x 寫為 4，Cls.x 保持為 3"

#: ../../reference/simple_stmts.rst:183

msgid ""

"This description does not necessarily apply to descriptor attributes, such "

"as properties created with :func:`property`."

msgstr ""

"此描述不一定適用於描述器屬性，例如使用 :func:`property` 建立的特性 "

"(property)。"

#: ../../reference/simple_stmts.rst:190

msgid ""

"If the target is a subscription: The primary expression in the reference is "

"evaluated. Next, the subscript expression is evaluated. Then, the primary's :"

"meth:`~object.__setitem__` method is called with two arguments: the "

"subscript and the assigned object."

msgstr ""

"如果目標是下標：參照中的主要運算式會被求值。接著，下標運算式會被求值。然後"

"會以兩個引數（下標和被賦值的物件）呼叫主要物件的 :meth:`~object.__setitem__` "

"方法。"

#: ../../reference/simple_stmts.rst:196

msgid ""

"Typically, :meth:`~object.__setitem__` is defined on mutable sequence "

"objects (such as lists) and mapping objects (such as dictionaries), and "

"behaves as follows."

msgstr ""

"通常 :meth:`~object.__setitem__` 被定義在可變序列物件（如串列）和對映物件（如字"

"典）上，其行為如下。"

#: ../../reference/simple_stmts.rst:204

msgid ""

"If the primary is a mutable sequence object (such as a list), the subscript "

"must yield an integer. If it is negative, the sequence's length is added to "

"it. The resulting value must be a nonnegative integer less than the "

"sequence's length, and the sequence is asked to assign the assigned object "

"to its item with that index. If the index is out of range, :exc:"

"`IndexError` is raised (assignment to a subscripted sequence cannot add new "

"items to a list)."

msgstr ""

"如果主要物件是可變序列物件（如串列），下標必須產生一個整數。如果它是負數，會"

"加上序列的長度。結果值必須是一個非負整數且小於序列的長度，然後要求該序列將"

"被賦值的物件賦值給具有該索引的項目。如果索引超出範圍，則會引"

"發 :exc:`IndexError`\\ （對下標序列的賦值無法向串列新增項目）。"

#: ../../reference/simple_stmts.rst:215

msgid ""

"If the primary is a mapping object (such as a dictionary), the subscript "

"must have a type compatible with the mapping's key type, and the mapping is "

"then asked to create a key/value pair which maps the subscript to the "

"assigned object. This can either replace an existing key/value pair with "

"the same key value, or insert a new key/value pair (if no key with the same "

"value existed)."

msgstr ""

"如果主要物件是對映物件（如字典），下標的型別必須與對映的鍵型別相容，然後要求該對"

"映建立一個將下標對映到被賦值物件的鍵／值對。這可以替換具有相同鍵值的現有鍵／"

"值對，或插入新的鍵／值對（如果不存在相同值的鍵）。"

#: ../../reference/simple_stmts.rst:223

msgid ""

"If the target is a slicing: The primary expression should evaluate to a "

"mutable sequence object (such as a list). The assigned object should be :"

"term:`iterable`. The slicing's lower and upper bounds should be integers; if "

"they are ``None`` (or not present), the defaults are zero and the sequence's "

"length. If either bound is negative, the sequence's length is added to it. "

"The resulting bounds are clipped to lie between zero and the sequence's "

"length, inclusive. Finally, the sequence object is asked to replace the "

"slice with the items of the assigned sequence. The length of the slice may "

"be different from the length of the assigned sequence, thus changing the "

"length of the target sequence, if the target sequence allows it."

msgstr ""

"如果目標是切片：主要運算式應該求值為一個可變序列物件（如串列）。被賦值的物件"

"應該是\\ :term:`可疊代的 <iterable>`。切片的下界和上界應該是整數；如果它們是 "

"``None``\\ （或不存在），預設值為零和序列的長度。如果任一邊界為負數，則會加上"

"序列的長度。結果邊界會被裁剪到零和序列長度之間（包含邊界）。最後，要求該序列"

"物件用被賦值序列的項目替換切片。切片的長度可能與被賦值序列的長度不同，因此會"

"改變目標序列的長度（如果目標序列允許的話）。"

#: ../../reference/simple_stmts.rst:235

msgid ""

"Although the definition of assignment implies that overlaps between the left-"

"hand side and the right-hand side are 'simultaneous' (for example ``a, b = "

"b, a`` swaps two variables), overlaps *within* the collection of assigned-to "

"variables occur left-to-right, sometimes resulting in confusion. For "

"instance, the following program prints ``[0, 2]``::"

msgstr ""

"雖然賦值的定義意味著左側和右側之間的重疊是「同時的」（例如 ``a, b = b, a`` 會"

"交換兩個變數），但被賦值變數集合\\ *內部*\\ 的重疊是從左到右發生的，有時會導"

"致混淆。例如，以下程式會印出 ``[0, 2]``： ::"

#: ../../reference/simple_stmts.rst:241

msgid ""

"x = [0, 1]\n"

"i = 0\n"

"i, x[i] = 1, 2 # i is updated, then x[i] is updated\n"

"print(x)"

msgstr ""

"x = [0, 1]\n"

"i = 0\n"

"i, x[i] = 1, 2 # i 先被更新，然後 x[i] 再被更新\n"

"print(x)"

#: ../../reference/simple_stmts.rst:249

msgid ":pep:`3132` - Extended Iterable Unpacking"

msgstr ":pep:`3132` - 擴充可疊代物件拆解"

#: ../../reference/simple_stmts.rst:250

msgid "The specification for the ``*target`` feature."

msgstr "``*target`` 功能的規格說明。"

#: ../../reference/simple_stmts.rst:256

msgid "Augmented assignment statements"

msgstr "擴增賦值陳述式"

#: ../../reference/simple_stmts.rst:274

msgid ""

"Augmented assignment is the combination, in a single statement, of a binary "

"operation and an assignment statement:"

msgstr "擴增賦值是將二元運算與賦值陳述式結合在單一陳述式中："

#: ../../reference/simple_stmts.rst:283

msgid ""

"(See section :ref:`primaries` for the syntax definitions of the last three "

"symbols.)"

msgstr "（關於最後三個符號的語法定義，請參閱 :ref:`primaries` 章節。）"

#: ../../reference/simple_stmts.rst:286

msgid ""

"An augmented assignment evaluates the target (which, unlike normal "

"assignment statements, cannot be an unpacking) and the expression list, "

"performs the binary operation specific to the type of assignment on the two "

"operands, and assigns the result to the original target. The target is only "

"evaluated once."

msgstr ""

"擴增賦值會對目標（與一般賦值陳述式不同，它不能是拆解運算）和運算式串列進行求"

"值，對這兩個運算元執行該賦值型別特定的二元運算，並將結果賦值給原始目標。目標"

"只會被求值一次。"

#: ../../reference/simple_stmts.rst:291

msgid ""

"An augmented assignment statement like ``x += 1`` can be rewritten as ``x = "

"x + 1`` to achieve a similar, but not exactly equal effect. In the augmented "

"version, ``x`` is only evaluated once. Also, when possible, the actual "

"operation is performed *in-place*, meaning that rather than creating a new "

"object and assigning that to the target, the old object is modified instead."

msgstr ""

"像 ``x += 1`` 這樣的擴增賦值陳述式可以改寫為 ``x = x + 1`` 來達到類似但不完全"

"相同的效果。在擴增版本中，``x`` 只會被求值一次。此外，在可能的情況下，實際的"

"運算會\\ *原地 (in-place)*\\ 執行，意即不是建立一個新物件並將其賦值給目標，而"

"是直接修改舊物件。"

#: ../../reference/simple_stmts.rst:297

msgid ""

"Unlike normal assignments, augmented assignments evaluate the left-hand side "

"*before* evaluating the right-hand side. For example, ``a[i] += f(x)`` "

"first looks-up ``a[i]``, then it evaluates ``f(x)`` and performs the "

"addition, and lastly, it writes the result back to ``a[i]``."

msgstr ""

"與一般賦值不同，擴增賦值會在求值右側\\ *之前*\\ 先求值左側。例如，``a[i] += "

"f(x)`` 會先查找 ``a[i]``，然後求值 ``f(x)`` 並執行加法，最後將結果寫回 "

"``a[i]``。"

#: ../../reference/simple_stmts.rst:302

msgid ""

"With the exception of assigning to tuples and multiple targets in a single "

"statement, the assignment done by augmented assignment statements is handled "

"the same way as normal assignments. Similarly, with the exception of the "

"possible *in-place* behavior, the binary operation performed by augmented "

"assignment is the same as the normal binary operations."

msgstr ""

"除了在單一陳述式中賦值給元組和多個目標的情況外，擴增賦值陳述式執行的賦值與一"

"般賦值的處理方式相同。同樣地，除了可能的\\ *原地*\\ 行為外，擴增賦值執行的二"

"元運算與一般二元運算相同。"

#: ../../reference/simple_stmts.rst:308

msgid ""

"For targets which are attribute references, the same :ref:`caveat about "

"class and instance attributes <attr-target-note>` applies as for regular "

"assignments."

msgstr ""

"對於屬性參照的目標，與一般賦值相同的\\ :ref:`關於類別和實例屬性的注意事項 "

"<attr-target-note>`\\ 也適用。"

#: ../../reference/simple_stmts.rst:315

msgid "Annotated assignment statements"

msgstr "註釋賦值陳述式"

#: ../../reference/simple_stmts.rst:322

msgid ""

":term:`Annotation <variable annotation>` assignment is the combination, in a "

"single statement, of a variable or attribute annotation and an optional "

"assignment statement:"

msgstr ""

":term:`註釋 <variable annotation>` 賦值是將變數或屬性註釋與可選的賦值陳述式結"

"合在一個陳述式中："

#: ../../reference/simple_stmts.rst:329

msgid ""

"The difference from normal :ref:`assignment` is that only a single target is "

"allowed."

msgstr "與一般\\ :ref:`賦值 <assignment>`\\ 的區別在於只允許單個目標。"

#: ../../reference/simple_stmts.rst:331

msgid ""

"The assignment target is considered \"simple\" if it consists of a single "

"name that is not enclosed in parentheses. For simple assignment targets, if "

"in class or module scope, the annotations are gathered in a lazily "

"evaluated :ref:`annotation scope <annotation-scopes>`. The annotations can "

"be evaluated using the :attr:`~object.__annotations__` attribute of a class "

"or module, or using the facilities in the :mod:`annotationlib` module."

msgstr ""

"如果賦值目標由一個未被圓括號括起來的單一名稱組成，則被視為「簡單的」。對於簡"

"單的賦值目標，如果在類別或模組作用域中，註釋會被收集在一個惰性求值的\\ :ref:`"

"註釋作用域 <annotation-scopes>`\\ 中。註釋可以使用類別或模組"

"的 :attr:`~object.__annotations__` 屬性來求值，或者使用 :mod:`annotationlib` "

"模組中的工具。"

#: ../../reference/simple_stmts.rst:340

msgid ""

"If the assignment target is not simple (an attribute, subscript node, or "

"parenthesized name), the annotation is never evaluated."

msgstr ""

"如果賦值目標不是簡單的（屬性、下標節點或被圓括號括起來的名稱），則註釋永遠不"

"會被求值。"

#: ../../reference/simple_stmts.rst:343

msgid ""

"If a name is annotated in a function scope, then this name is local for that "

"scope. Annotations are never evaluated and stored in function scopes."

msgstr ""

"如果一個名稱在函式作用域中被註釋，則該名稱對該作用域而言是區域的。註釋永遠不"

"會在函式作用域中被求值和儲存。"

#: ../../reference/simple_stmts.rst:346

msgid ""

"If the right hand side is present, an annotated assignment performs the "

"actual assignment as if there was no annotation present. If the right hand "

"side is not present for an expression target, then the interpreter evaluates "

"the target except for the last :meth:`~object.__setitem__` or :meth:`~object."

"__setattr__` call."

msgstr ""

"如果右側存在，註釋賦值會執行實際的賦值，就像沒有註釋一樣。如果運算式目標的右"

"側不存在，則直譯器會對目標進行求值，但不包括最後"

"的 :meth:`~object.__setitem__` 或 :meth:`~object.__setattr__` 呼叫。"

#: ../../reference/simple_stmts.rst:354

msgid ":pep:`526` - Syntax for Variable Annotations"

msgstr ":pep:`526` - 變數註釋的語法"

#: ../../reference/simple_stmts.rst:355

msgid ""

"The proposal that added syntax for annotating the types of variables "

"(including class variables and instance variables), instead of expressing "

"them through comments."

msgstr ""

"此提案新增了用於註釋變數型別（包括類別變數和實例變數）的語法，取代透過註解來"

"表達的方式。"

#: ../../reference/simple_stmts.rst:359

msgid ":pep:`484` - Type hints"

msgstr ":pep:`484` - 型別提示"

#: ../../reference/simple_stmts.rst:360

msgid ""

"The proposal that added the :mod:`typing` module to provide a standard "

"syntax for type annotations that can be used in static analysis tools and "

"IDEs."

msgstr ""

"新增了 :mod:`typing` 模組的提案，提供了可用於靜態分析工具和 IDE 的標準型別註"

"釋語法。"

#: ../../reference/simple_stmts.rst:364

msgid ""

"Now annotated assignments allow the same expressions in the right hand side "

"as regular assignments. Previously, some expressions (like un-parenthesized "

"tuple expressions) caused a syntax error."

msgstr ""

"現在註釋賦值允許右側與一般賦值相同的運算式。以前，某些運算式（如未加圓括號的"

"元組運算式）會導致語法錯誤。"

#: ../../reference/simple_stmts.rst:369

msgid ""

"Annotations are now lazily evaluated in a separate :ref:`annotation scope "

"<annotation-scopes>`. If the assignment target is not simple, annotations "

"are never evaluated."

msgstr ""

"註釋現在會在獨立的\\ :ref:`註釋作用域 <annotation-scopes>`\\ 中惰性求值。如果"

"賦值目標不是簡單的，則註釋永遠不會被求值。"

#: ../../reference/simple_stmts.rst:377

msgid "The :keyword:`!assert` statement"

msgstr ":keyword:`!assert` 陳述式"

#: ../../reference/simple_stmts.rst:384

msgid ""

"Assert statements are a convenient way to insert debugging assertions into a "

"program:"

msgstr "Assert 陳述式是將除錯斷言插入程式中的便捷方式："

#: ../../reference/simple_stmts.rst:390

msgid "The simple form, ``assert expression``, is equivalent to ::"

msgstr "簡單形式 ``assert expression`` 等價於： ::"

#: ../../reference/simple_stmts.rst:392

msgid ""

"if __debug__:\n"

" if not expression: raise AssertionError"

msgstr ""

"if __debug__:\n"

" if not expression: raise AssertionError"

#: ../../reference/simple_stmts.rst:395

msgid ""

"The extended form, ``assert expression1, expression2``, is equivalent to ::"

msgstr "擴展形式 ``assert expression1, expression2`` 等價於： ::"

#: ../../reference/simple_stmts.rst:397

msgid ""

"if __debug__:\n"

" if not expression1: raise AssertionError(expression2)"

msgstr ""

"if __debug__:\n"

" if not expression1: raise AssertionError(expression2)"

#: ../../reference/simple_stmts.rst:404

msgid ""

"These equivalences assume that :const:`__debug__` and :exc:`AssertionError` "

"refer to the built-in variables with those names. In the current "

"implementation, the built-in variable ``__debug__`` is ``True`` under normal "

"circumstances, ``False`` when optimization is requested (command line "

"option :option:`-O`). The current code generator emits no code for an :"

"keyword:`assert` statement when optimization is requested at compile time. "

"Note that it is unnecessary to include the source code for the expression "

"that failed in the error message; it will be displayed as part of the stack "

"trace."

msgstr ""

"這些等價關係假設 :const:`__debug__` 和 :exc:`AssertionError` 參照的是具有這些"

"名稱的內建變數。在目前的實作中，內建變數 ``__debug__`` 在正常情況下為 "

"``True``，在請求最佳化時（命令列選項 :option:`-O`）為 ``False``。當在編譯時請"

"求最佳化時，目前的程式碼產生器不會為 :keyword:`assert` 陳述式產生任何程式碼。"

"請注意，沒有必要在錯誤訊息中包含失敗運算式的原始碼；它會作為堆疊追蹤的一部分"

"顯示。"

#: ../../reference/simple_stmts.rst:413

msgid ""

"Assignments to :const:`__debug__` are illegal. The value for the built-in "

"variable is determined when the interpreter starts."

msgstr ""

"對 :const:`__debug__` 進行賦值是非法的。內建變數的值在直譯器啟動時決定。"

#: ../../reference/simple_stmts.rst:420

msgid "The :keyword:`!pass` statement"

msgstr ":keyword:`!pass` 陳述式"

#: ../../reference/simple_stmts.rst:430

msgid ""

":keyword:`pass` is a null operation --- when it is executed, nothing "

"happens. It is useful as a placeholder when a statement is required "

"syntactically, but no code needs to be executed, for example::"

msgstr ""

":keyword:`pass` 是一個空操作——當它被執行時，什麼事都不會發生。當語法上需要一"

"個陳述式但不需要執行任何程式碼時，它可以作為佔位符使用，例如： ::"

#: ../../reference/simple_stmts.rst:434

msgid ""

"def f(arg): pass # a function that does nothing (yet)\n"

"\n"

"class C: pass # a class with no methods (yet)"

msgstr ""

"def f(arg): pass # 一個（還）沒有實作的函式\n"

"\n"

"class C: pass # 一個（還）沒有方法的類別"

#: ../../reference/simple_stmts.rst:442

msgid "The :keyword:`!del` statement"

msgstr ":keyword:`!del` 陳述式"

#: ../../reference/simple_stmts.rst:452

msgid ""

"Deletion is recursively defined very similar to the way assignment is "

"defined. Rather than spelling it out in full details, here are some hints."

msgstr ""

"刪除的遞迴定義與賦值的定義方式非常相似。這裡提供一些提示，而不是詳細說明全部"

"細節。"

#: ../../reference/simple_stmts.rst:455

msgid ""

"Deletion of a target list recursively deletes each target, from left to "

"right."

msgstr "刪除目標串列會從左到右遞迴刪除每個目標。"

#: ../../reference/simple_stmts.rst:461

msgid ""

"Deletion of a name removes the binding of that name from the local or global "

"namespace, depending on whether the name occurs in a :keyword:`global` "

"statement in the same code block. Trying to delete an unbound name raises "

"a :exc:`NameError` exception."

msgstr ""

"刪除名稱會從區域或全域命名空間中移除該名稱的繫結，取決於該名稱是否出現在同一"

"程式碼區塊的 :keyword:`global` 陳述式中。嘗試刪除未繫結的名稱會引"

"發 :exc:`NameError` 例外。"

#: ../../reference/simple_stmts.rst:468

msgid ""

"Deletion of attribute references and subscriptions is passed to the primary "

"object involved; deletion of a slicing is in general equivalent to "

"assignment of an empty slice of the right type (but even this is determined "

"by the sliced object)."

msgstr ""

"屬性參照和下標的刪除會傳遞給涉及的主要物件；切片的刪除通常等價於賦值一個正確"

"型別的空切片（但這一點也是由被切片的物件決定的）。"

#: ../../reference/simple_stmts.rst:473

msgid ""

"Previously it was illegal to delete a name from the local namespace if it "

"occurs as a free variable in a nested block."

msgstr ""

"以前，如果一個名稱作為自由變數出現在巢狀區塊中，則從區域命名空間刪除該名稱是"

"非法的。"

#: ../../reference/simple_stmts.rst:481

msgid "The :keyword:`!return` statement"

msgstr ":keyword:`!return` 陳述式"

#: ../../reference/simple_stmts.rst:491

msgid ""

":keyword:`return` may only occur syntactically nested in a function "

"definition, not within a nested class definition."

msgstr ""

":keyword:`return` 只能在語法上出現在函式定義的巢狀結構中，不能出現在巢狀類別"

"定義中。"

#: ../../reference/simple_stmts.rst:494

msgid ""

"If an expression list is present, it is evaluated, else ``None`` is "

"substituted."

msgstr "如果運算式串列存在，則會對其求值，否則會以 ``None`` 替代。"

#: ../../reference/simple_stmts.rst:496

msgid ""

":keyword:`return` leaves the current function call with the expression list "

"(or ``None``) as return value."

msgstr ""

":keyword:`return` 會離開當前的函式呼叫，並以運算式串列（或 ``None``）作為回傳"

"值。"

#: ../../reference/simple_stmts.rst:501

msgid ""

"When :keyword:`return` passes control out of a :keyword:`try` statement with "

"a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "

"before really leaving the function."

msgstr ""

"當 :keyword:`return` 將控制權從帶有 :keyword:`finally` 子句的 :keyword:`try` "

"陳述式中傳出時，該 :keyword:`!finally` 子句會在真正離開函式之前被執行。"

#: ../../reference/simple_stmts.rst:505

msgid ""

"In a generator function, the :keyword:`return` statement indicates that the "

"generator is done and will cause :exc:`StopIteration` to be raised. The "

"returned value (if any) is used as an argument to construct :exc:"

"`StopIteration` and becomes the :attr:`StopIteration.value` attribute."

msgstr ""

"在產生器函式中，:keyword:`return` 陳述式表示產生器已完成，並會導致引"

"發 :exc:`StopIteration`。回傳值（如果有的話）會被用作建"

"構 :exc:`StopIteration` 的引數，並成為 :attr:`StopIteration.value` 屬性。"

#: ../../reference/simple_stmts.rst:510

msgid ""

"In an asynchronous generator function, an empty :keyword:`return` statement "

"indicates that the asynchronous generator is done and will cause :exc:"

"`StopAsyncIteration` to be raised. A non-empty :keyword:`!return` statement "

"is a syntax error in an asynchronous generator function."

msgstr ""

"在非同步產生器函式中，空的 :keyword:`return` 陳述式表示非同步產生器已完成，並"

"會導致引發 :exc:`StopAsyncIteration`。在非同步產生器函式中，非空"

"的 :keyword:`!return` 陳述式是語法錯誤。"

#: ../../reference/simple_stmts.rst:518

msgid "The :keyword:`!yield` statement"

msgstr ":keyword:`!yield` 陳述式"

#: ../../reference/simple_stmts.rst:530

msgid ""

"A :keyword:`yield` statement is semantically equivalent to a :ref:`yield "

"expression <yieldexpr>`. The ``yield`` statement can be used to omit the "

"parentheses that would otherwise be required in the equivalent yield "

"expression statement. For example, the yield statements ::"

msgstr ""

":keyword:`yield` 陳述式在語義上等價於\\ :ref:`yield 運算式 <yieldexpr>`。"

"``yield`` 陳述式可用於省略在等價的 yield 運算式陳述式中原本需要的圓括號。例"

"如，以下 yield 陳述式： ::"

#: ../../reference/simple_stmts.rst:535

msgid ""

"yield <expr>\n"

"yield from <expr>"

msgstr ""

"yield <expr>\n"

"yield from <expr>"

#: ../../reference/simple_stmts.rst:538

msgid "are equivalent to the yield expression statements ::"

msgstr "等價於以下 yield 運算式陳述式： ::"

#: ../../reference/simple_stmts.rst:540

msgid ""

"(yield <expr>)\n"

"(yield from <expr>)"

msgstr ""

"(yield <expr>)\n"

"(yield from <expr>)"

#: ../../reference/simple_stmts.rst:543

msgid ""

"Yield expressions and statements are only used when defining a :term:"

"`generator` function, and are only used in the body of the generator "

"function. Using :keyword:`yield` in a function definition is sufficient to "

"cause that definition to create a generator function instead of a normal "

"function."

msgstr ""

"Yield 運算式和陳述式只在定義\\ :term:`產生器 <generator>`\\ 函式時使用，且只"

"在產生器函式的主體中使用。在函式定義中使用 :keyword:`yield` 就足以使該定義建"

"立一個產生器函式而非一般函式。"

#: ../../reference/simple_stmts.rst:548

msgid ""

"For full details of :keyword:`yield` semantics, refer to the :ref:"

"`yieldexpr` section."

msgstr ""

"關於 :keyword:`yield` 語義的完整詳情，請參閱\\ :ref:`yieldexpr`\\ 章節。"

#: ../../reference/simple_stmts.rst:554

msgid "The :keyword:`!raise` statement"

msgstr ":keyword:`!raise` 陳述式"

#: ../../reference/simple_stmts.rst:565

msgid ""

"If no expressions are present, :keyword:`raise` re-raises the exception that "

"is currently being handled, which is also known as the *active exception*. "

"If there isn't currently an active exception, a :exc:`RuntimeError` "

"exception is raised indicating that this is an error."

msgstr ""

"如果沒有運算式，:keyword:`raise` 會重新引發當前正在處理的例外，這也稱為\\ *活"

"動例外*。如果當前沒有活動例外，則會引發 :exc:`RuntimeError` 例外，表示這是一"

"個錯誤。"

#: ../../reference/simple_stmts.rst:570

msgid ""

"Otherwise, :keyword:`raise` evaluates the first expression as the exception "

"object. It must be either a subclass or an instance of :class:"

"`BaseException`. If it is a class, the exception instance will be obtained "

"when needed by instantiating the class with no arguments."

msgstr ""

"否則，:keyword:`raise` 會將第一個運算式求值為例外物件。它必須"

"是 :class:`BaseException` 的子類別或實例。如果它是一個類別，則在需要時會透過"

"不帶引數地實例化該類別來獲得例外實例。"

#: ../../reference/simple_stmts.rst:575

msgid ""

"The :dfn:`type` of the exception is the exception instance's class, the :dfn:"

"`value` is the instance itself."

msgstr ""

"例外的\\ :dfn:`型別 (type)`\\ 是例外實例的類別，:dfn:`值 (value)`\\ 是實例本"

"身。"

#: ../../reference/simple_stmts.rst:580

msgid ""

"A traceback object is normally created automatically when an exception is "

"raised and attached to it as the :attr:`~BaseException.__traceback__` "

"attribute. You can create an exception and set your own traceback in one "

"step using the :meth:`~BaseException.with_traceback` exception method (which "

"returns the same exception instance, with its traceback set to its "

"argument), like so::"

msgstr ""

"通常在引發例外時會自動建立一個追蹤物件，並將其作"

"為 :attr:`~BaseException.__traceback__` 屬性附加到例外上。你可以使"

"用 :meth:`~BaseException.with_traceback` 例外方法（它會回傳同一個例外實例，並"

"將其追蹤設定為其引數）在一個步驟中建立例外並設定你自己的追蹤，如下所示： ::"

#: ../../reference/simple_stmts.rst:586

msgid "raise Exception(\"foo occurred\").with_traceback(tracebackobj)"

msgstr "raise Exception(\"foo occurred\").with_traceback(tracebackobj)"

#: ../../reference/simple_stmts.rst:592

msgid ""

"The ``from`` clause is used for exception chaining: if given, the second "

"*expression* must be another exception class or instance. If the second "

"expression is an exception instance, it will be attached to the raised "

"exception as the :attr:`~BaseException.__cause__` attribute (which is "

"writable). If the expression is an exception class, the class will be "

"instantiated and the resulting exception instance will be attached to the "

"raised exception as the :attr:`!__cause__` attribute. If the raised "

"exception is not handled, both exceptions will be printed:"

msgstr ""

"``from`` 子句用於例外鏈結：如果給定，第二個\\ *運算式*\\ 必須是另一個例外類別"

"或實例。如果第二個運算式是例外實例，它將作"

"為 :attr:`~BaseException.__cause__` 屬性（可寫入）附加到被引發的例外上。如果"

"運算式是例外類別，則會實例化該類別，並將產生的例外實例作為 :attr:`!"

"__cause__` 屬性附加到被引發的例外上。如果被引發的例外未被處理，則兩個例外都會"

"被印出："

#: ../../reference/simple_stmts.rst:601

msgid ""

">>> try:\n"

"... print(1 / 0)\n"

"... except Exception as exc:\n"

"... raise RuntimeError(\"Something bad happened\") from exc\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"The above exception was the direct cause of the following exception:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\") from exc\n"

"RuntimeError: Something bad happened"

msgstr ""

">>> try:\n"

"... print(1 / 0)\n"

"... except Exception as exc:\n"

"... raise RuntimeError(\"Something bad happened\") from exc\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"The above exception was the direct cause of the following exception:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\") from exc\n"

"RuntimeError: Something bad happened"

#: ../../reference/simple_stmts.rst:621

msgid ""

"A similar mechanism works implicitly if a new exception is raised when an "

"exception is already being handled. An exception may be handled when an :"

"keyword:`except` or :keyword:`finally` clause, or a :keyword:`with` "

"statement, is used. The previous exception is then attached as the new "

"exception's :attr:`~BaseException.__context__` attribute:"

msgstr ""

"如果在已經處理一個例外時引發了新的例外，類似的機制會隱式地運作。使"

"用 :keyword:`except` 或 :keyword:`finally` 子句，或 :keyword:`with` 陳述式"

"時，例外可能正在被處理。然後先前的例外會作為新例外"

"的 :attr:`~BaseException.__context__` 屬性附加："

#: ../../reference/simple_stmts.rst:627

msgid ""

">>> try:\n"

"... print(1 / 0)\n"

"... except:\n"

"... raise RuntimeError(\"Something bad happened\")\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\")\n"

"RuntimeError: Something bad happened"

msgstr ""

">>> try:\n"

"... print(1 / 0)\n"

"... except:\n"

"... raise RuntimeError(\"Something bad happened\")\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 2, in <module>\n"

" print(1 / 0)\n"

" ~~^~~\n"

"ZeroDivisionError: division by zero\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

" raise RuntimeError(\"Something bad happened\")\n"

"RuntimeError: Something bad happened"

#: ../../reference/simple_stmts.rst:647

msgid ""

"Exception chaining can be explicitly suppressed by specifying :const:`None` "

"in the ``from`` clause:"

msgstr "可以透過在 ``from`` 子句中指定 :const:`None` 來明確抑制例外鏈結："

#: ../../reference/simple_stmts.rst:650

msgid ""

">>> try:\n"

"... print(1 / 0)\n"

"... except:\n"

"... raise RuntimeError(\"Something bad happened\") from None\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

"RuntimeError: Something bad happened"

msgstr ""

">>> try:\n"

"... print(1 / 0)\n"

"... except:\n"

"... raise RuntimeError(\"Something bad happened\") from None\n"

"...\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 4, in <module>\n"

"RuntimeError: Something bad happened"

#: ../../reference/simple_stmts.rst:661

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information about handling exceptions is in section :ref:"

"`try`."

msgstr ""

"關於例外的更多資訊可以在\\ :ref:`exceptions`\\ 章節找到，關於處理例外的資訊可"

"以在\\ :ref:`try`\\ 章節找到。"

#: ../../reference/simple_stmts.rst:664

msgid ":const:`None` is now permitted as ``Y`` in ``raise X from Y``."

msgstr ":const:`None` 現在允許作為 ``raise X from Y`` 中的 ``Y``。"

#: ../../reference/simple_stmts.rst:667

msgid ""

"Added the :attr:`~BaseException.__suppress_context__` attribute to suppress "

"automatic display of the exception context."

msgstr ""

"新增了 :attr:`~BaseException.__suppress_context__` 屬性以抑制例外情境的自動顯"

"示。"

#: ../../reference/simple_stmts.rst:670

msgid ""

"If the traceback of the active exception is modified in an :keyword:`except` "

"clause, a subsequent ``raise`` statement re-raises the exception with the "

"modified traceback. Previously, the exception was re-raised with the "

"traceback it had when it was caught."

msgstr ""

"如果活動例外的追蹤在 :keyword:`except` 子句中被修改，則後續的 ``raise`` 陳述"

"式會使用修改後的追蹤重新引發例外。以前，例外會使用它被捕獲時的追蹤重新引發。"

#: ../../reference/simple_stmts.rst:679

msgid "The :keyword:`!break` statement"

msgstr ":keyword:`!break` 陳述式"

#: ../../reference/simple_stmts.rst:690

msgid ""

":keyword:`break` may only occur syntactically nested in a :keyword:`for` or :"

"keyword:`while` loop, but not nested in a function or class definition "

"within that loop."

msgstr ""

":keyword:`break` 只能在語法上出現在 :keyword:`for` 或 :keyword:`while` 迴圈的"

"巢狀結構中，但不能巢狀在該迴圈內的函式或類別定義中。"

#: ../../reference/simple_stmts.rst:697

msgid ""

"It terminates the nearest enclosing loop, skipping the optional :keyword:`!"

"else` clause if the loop has one."

msgstr ""

"它會終止最近的外層迴圈，如果迴圈有可選的 :keyword:`!else` 子句，則會跳過它。"

#: ../../reference/simple_stmts.rst:700

msgid ""