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

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

#

# Translators:

# jerrychen <[email protected]>, 2016

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

# Matt Wang <[email protected]>, 2021

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-03-19 00:14+0000\n"

"PO-Revision-Date: 2022-10-24 14:54+0800\n"

"Last-Translator: Steven Hsu <[email protected]>\n"

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

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

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

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

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

"X-Generator: Poedit 3.2\n"

#: ../../tutorial/errors.rst:5

msgid "Errors and Exceptions"

msgstr "錯誤和例外"

#: ../../tutorial/errors.rst:7

msgid ""

"Until now error messages haven't been more than mentioned, but if you have "

"tried out the examples you have probably seen some. There are (at least) "

"two distinguishable kinds of errors: *syntax errors* and *exceptions*."

msgstr ""

"到目前為止還沒有提到錯誤訊息，但如果你嘗試運行範例，你可能會發現一些錯誤訊"

"息。常見的（至少）兩種不同的錯誤類別為：*語法錯誤 (syntax error)* 和\\ *例外 "

"(exception)*。"

#: ../../tutorial/errors.rst:15

msgid "Syntax Errors"

msgstr "語法錯誤 (Syntax Error)"

#: ../../tutorial/errors.rst:17

msgid ""

"Syntax errors, also known as parsing errors, are perhaps the most common "

"kind of complaint you get while you are still learning Python::"

msgstr ""

"語法錯誤又稱剖析錯誤 (parsing error)，它或許是學習 Python 的過程最常聽見的抱"

"怨： ::"

#: ../../tutorial/errors.rst:20

msgid ""

">>> while True print('Hello world')\n"

" File \"<stdin>\", line 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> while True print('Hello world')\n"

" File \"<stdin>\", line 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

#: ../../tutorial/errors.rst:26

msgid ""

"The parser repeats the offending line and displays little arrows pointing at "

"the place where the error was detected. Note that this is not always the "

"place that needs to be fixed. In the example, the error is detected at the "

"function :func:`print`, since a colon (``':'``) is missing just before it."

msgstr ""

"剖析器 (parser) 會重複犯錯的那一行，並用一個小箭頭指向該行檢測到錯誤的地方，"

"但請注意這並非都會是應該去修改的地方。此例中，錯誤是在 :func:`print` 函式中被"

"檢測到，因為在它前面少了一個冒號 (``':'``)。"

#: ../../tutorial/errors.rst:31

msgid ""

"The file name (``<stdin>`` in our example) and line number are printed so "

"you know where to look in case the input came from a file."

msgstr ""

"檔案名稱（此例中為 ``<stdin>``）和列號會被印出來，所以如果訊息是來自一個檔案"

"時，就可以知道去哪裡找問題。"

#: ../../tutorial/errors.rst:38

msgid "Exceptions"

msgstr "例外 (Exception)"

#: ../../tutorial/errors.rst:40

msgid ""

"Even if a statement or expression is syntactically correct, it may cause an "

"error when an attempt is made to execute it. Errors detected during "

"execution are called *exceptions* and are not unconditionally fatal: you "

"will soon learn how to handle them in Python programs. Most exceptions are "

"not handled by programs, however, and result in error messages as shown "

"here::"

msgstr ""

"即使一段陳述式或運算式使用了正確的語法，嘗試執行時仍可能導致錯誤。執行時檢測"

"到的錯誤稱為\\ *例外*，例外不一定都很嚴重：你很快就能學會在 Python 程式中如何"

"處理它們。不過大多數的例外不會被程式處理，並且會顯示如下的錯誤訊息： ::"

#: ../../tutorial/errors.rst:46

msgid ""

">>> 10 * (1/0)\n"

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

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

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

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

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

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

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

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

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: can only concatenate str (not \"int\") to str"

msgstr ""

">>> 10 * (1/0)\n"

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

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

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

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

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

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

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

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

" '2' + 2\n"

" ~~~~^~~\n"

"TypeError: can only concatenate str (not \"int\") to str"

#: ../../tutorial/errors.rst:65

msgid ""

"The last line of the error message indicates what happened. Exceptions come "

"in different types, and the type is printed as part of the message: the "

"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` "

"and :exc:`TypeError`. The string printed as the exception type is the name "

"of the built-in exception that occurred. This is true for all built-in "

"exceptions, but need not be true for user-defined exceptions (although it is "

"a useful convention). Standard exception names are built-in identifiers (not "

"reserved keywords)."

msgstr ""

"錯誤訊息的最後一行指示發生了什麼事。例外有不同的類型，而類型名稱會作為訊息的"

"一部份被印出。範例中的例外類型為：:exc:`ZeroDivisionError`、:exc:`NameError` "

"和 :exc:`TypeError`。作為例外類型被印出的字串，就是發生的內建例外 (built-in "

"exception) 的名稱。所有的內建例外都是如此運作，但對於使用者自定的例外則不一定"

"需要遵守（雖然這是一個有用的慣例）。標準例外名稱是內建的識別字 (identifier)，"

"不是保留關鍵字 (reserved keyword)。"

#: ../../tutorial/errors.rst:73

msgid ""

"The rest of the line provides detail based on the type of exception and what "

"caused it."

msgstr "此行其餘部分，根據例外的類型及導致例外的原因，說明例外的細節。"

#: ../../tutorial/errors.rst:76

msgid ""

"The preceding part of the error message shows the context where the "

"exception occurred, in the form of a stack traceback. In general it contains "

"a stack traceback listing source lines; however, it will not display lines "

"read from standard input."

msgstr ""

"錯誤訊息的開頭，用堆疊回溯 (stack traceback) 的形式顯示發生例外的語境。一般來"

"說，它含有一個列出源程式碼行 (source line) 的堆疊回溯；但它不會顯示從標準輸入"

"中讀取的程式碼。"

#: ../../tutorial/errors.rst:81

msgid ""

":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."

msgstr ":ref:`bltin-exceptions`\\ 章節列出內建的例外及它們的意義。"

#: ../../tutorial/errors.rst:87

msgid "Handling Exceptions"

msgstr "處理例外"

#: ../../tutorial/errors.rst:89

msgid ""

"It is possible to write programs that handle selected exceptions. Look at "

"the following example, which asks the user for input until a valid integer "

"has been entered, but allows the user to interrupt the program "

"(using :kbd:`Control-C` or whatever the operating system supports); note "

"that a user-generated interruption is signalled by raising "

"the :exc:`KeyboardInterrupt` exception. ::"

msgstr ""

"編寫程式處理選定的例外是可行的。以下範例會要求使用者輸入內容，直到有效的整數"

"被輸入為止，但它允許使用者中斷程式（使用 :kbd:`Control-C` 或作業系統支援的指"

"令）；請注意，由使用者產生的程式中斷會引發 :exc:`KeyboardInterrupt` 例外信"

"號。 ::"

#: ../../tutorial/errors.rst:95

msgid ""

">>> while True:\n"

"... try:\n"

"... x = int(input(\"Please enter a number: \"))\n"

"... break\n"

"... except ValueError:\n"

"... print(\"Oops! That was no valid number. Try again...\")\n"

"..."

msgstr ""

">>> while True:\n"

"... try:\n"

"... x = int(input(\"Please enter a number: \"))\n"

"... break\n"

"... except ValueError:\n"

"... print(\"Oops! That was no valid number. Try again...\")\n"

"..."

#: ../../tutorial/errors.rst:103

msgid "The :keyword:`try` statement works as follows."

msgstr ":keyword:`try` 陳述式運作方式如下。"

#: ../../tutorial/errors.rst:105

msgid ""

"First, the *try clause* (the statement(s) between the :keyword:`try` "

"and :keyword:`except` keywords) is executed."

msgstr ""

"首先，執行 *try 子句*\\ （:keyword:`try` 和 :keyword:`except` 關鍵字之間的陳"

"述式）。"

#: ../../tutorial/errors.rst:108

msgid ""

"If no exception occurs, the *except clause* is skipped and execution of "

"the :keyword:`try` statement is finished."

msgstr ""

"如果沒有發生例外，則 *except 子句*\\ 會被跳過，:keyword:`try` 陳述式執行完"

"畢。"

#: ../../tutorial/errors.rst:111

msgid ""

"If an exception occurs during execution of the :keyword:`try` clause, the "

"rest of the clause is skipped. Then, if its type matches the exception "

"named after the :keyword:`except` keyword, the *except clause* is executed, "

"and then execution continues after the try/except block."

msgstr ""

"如果執行 :keyword:`try` 子句時發生了例外，則該子句中剩下的部分會被跳過。如果"

"例外的類型與 :keyword:`except` 關鍵字後面的例外名稱相符，則 *except 子句*\\ "

"被執行，然後，繼續執行 try/except 區塊之後的程式碼。"

#: ../../tutorial/errors.rst:116

msgid ""

"If an exception occurs which does not match the exception named in the "

"*except clause*, it is passed on to outer :keyword:`try` statements; if no "

"handler is found, it is an *unhandled exception* and execution stops with an "

"error message."

msgstr ""

"如果發生的例外未符合 *except 子句* 中的例外名稱，則將其傳遞到外層"

"的 :keyword:`try` 陳述式；如果仍無法找到處理者，則它是一個\\ *未處理例外 "

"(unhandled exception)*，執行將停止，並顯示錯誤訊息。"

#: ../../tutorial/errors.rst:120

msgid ""

"A :keyword:`try` statement may have more than one *except clause*, to "

"specify handlers for different exceptions. At most one handler will be "

"executed. Handlers only handle exceptions that occur in the corresponding "

"*try clause*, not in other handlers of the same :keyword:`!try` statement. "

"An *except clause* may name multiple exceptions as a parenthesized tuple, "

"for example::"

msgstr ""

":keyword:`try` 陳述式可以有不只一個 *except 子句*，為不同的例外指定處理者，而"

"最多只有一個處理者會被執行。處理者只處理對應的 try 子句中發生的例外，而不會處"

"理同一 :keyword:`!try` 陳述式裡其他處理者內的例外。一個 *except 子句*\\ 可以"

"用一組括號內的 tuple 列舉多個例外，例如： ::"

#: ../../tutorial/errors.rst:126

msgid ""

"... except (RuntimeError, TypeError, NameError):\n"

"... pass"

msgstr ""

"... except (RuntimeError, TypeError, NameError):\n"

"... pass"

#: ../../tutorial/errors.rst:129

msgid ""

"A class in an :keyword:`except` clause matches exceptions which are "

"instances of the class itself or one of its derived classes (but not the "

"other way around --- an *except clause* listing a derived class does not "

"match instances of its base classes). For example, the following code will "

"print B, C, D in that order::"

msgstr ""

":keyword:`except` 子句中的一個類別符合該類別本身或它的衍生類別的例外（但不是"

"反過來 -- 列出一個衍生類別的 *except 子句*\\ 不會符合它的基底類別的例外）。例"

"如，以下程式碼會按照 B、C、D 的順序印出： ::"

#: ../../tutorial/errors.rst:134

msgid ""

"class B(Exception):\n"

" pass\n"

"\n"

"class C(B):\n"

" pass\n"

"\n"

"class D(C):\n"

" pass\n"

"\n"

"for cls in [B, C, D]:\n"

" try:\n"

" raise cls()\n"

" except D:\n"

" print(\"D\")\n"

" except C:\n"

" print(\"C\")\n"

" except B:\n"

" print(\"B\")"

msgstr ""

"class B(Exception):\n"

" pass\n"

"\n"

"class C(B):\n"

" pass\n"

"\n"

"class D(C):\n"

" pass\n"

"\n"

"for cls in [B, C, D]:\n"

" try:\n"

" raise cls()\n"

" except D:\n"

" print(\"D\")\n"

" except C:\n"

" print(\"C\")\n"

" except B:\n"

" print(\"B\")"

#: ../../tutorial/errors.rst:153

msgid ""

"Note that if the *except clauses* were reversed (with ``except B`` first), "

"it would have printed B, B, B --- the first matching *except clause* is "

"triggered."

msgstr ""

"請注意，如果 *except 子句*\\ 的順序被反轉（把 ``except B`` 放到第一個），則會"

"印出 B、B、B ­­——第一個符合的 *except 子句*\\ 會被觸發。"

#: ../../tutorial/errors.rst:156

msgid ""

"When an exception occurs, it may have associated values, also known as the "

"exception's *arguments*. The presence and types of the arguments depend on "

"the exception type."

msgstr ""

"當例外發生時，它可能有相關聯的值，也就是例外的\\ *引數*。引數的存在與否及它的"

"類型，是取決於例外的類型。"

#: ../../tutorial/errors.rst:160

msgid ""

"The *except clause* may specify a variable after the exception name. The "

"variable is bound to the exception instance which typically has an ``args`` "

"attribute that stores the arguments. For convenience, builtin exception "

"types define :meth:`~object.__str__` to print all the arguments without "

"explicitly accessing ``.args``. ::"

msgstr ""

"*except 子句*\\ 可以在例外名稱後面指定一個變數。這個變數被綁定到一個例外實例 "

"(instance)，其引數通常儲存在 ``args`` 屬性中。為了方便，內建例外型別定義"

"了 :meth:`~object.__str__` 以印出所有引數而不需顯式地取用 ``.args``： ::"

#: ../../tutorial/errors.rst:166

msgid ""

">>> try:\n"

"... raise Exception('spam', 'eggs')\n"

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

"... print(type(inst)) # the exception type\n"

"... print(inst.args) # arguments stored in .args\n"

"... print(inst) # __str__ allows args to be printed directly,\n"

"... # but may be overridden in exception "

"subclasses\n"

"... x, y = inst.args # unpack args\n"

"... print('x =', x)\n"

"... print('y =', y)\n"

"...\n"

"<class 'Exception'>\n"

"('spam', 'eggs')\n"

"('spam', 'eggs')\n"

"x = spam\n"

"y = eggs"

msgstr ""

">>> try:\n"

"... raise Exception('spam', 'eggs')\n"

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

"... print(type(inst)) # 例外的型別\n"

"... print(inst.args) # 儲存在 .args 中的引數\n"

"... print(inst) # __str__ 使得引數可以直接被印出，\n"

"... # 但可能在例外的子類別中被覆蓋\n"

"... x, y = inst.args # 解包引數\n"

"... print('x =', x)\n"

"... print('y =', y)\n"

"...\n"

"<class 'Exception'>\n"

"('spam', 'eggs')\n"

"('spam', 'eggs')\n"

"x = spam\n"

"y = eggs"

#: ../../tutorial/errors.rst:183

msgid ""

"The exception's :meth:`~object.__str__` output is printed as the last part "

"('detail') of the message for unhandled exceptions."

msgstr ""

"例外的 :meth:`~object.__str__` 輸出會被印在未處理例外訊息的最後一部分（「細"

"節」）。"

#: ../../tutorial/errors.rst:186

msgid ""

":exc:`BaseException` is the common base class of all exceptions. One of its "

"subclasses, :exc:`Exception`, is the base class of all the non-fatal "

"exceptions. Exceptions which are not subclasses of :exc:`Exception` are not "

"typically handled, because they are used to indicate that the program should "

"terminate. They include :exc:`SystemExit` which is raised "

"by :meth:`sys.exit` and :exc:`KeyboardInterrupt` which is raised when a user "

"wishes to interrupt the program."

msgstr ""

":exc:`BaseException` 是由全部的例外所共用的 base class。它的 subclass（子類"

"別）之一，:exc:`Exception`，則是所有非嚴重例外 (non-fatal exception) 的 base "

"class。有些例外不是 :exc:`Exception` 的 subclass，而它們通常不會被處理，因為"

"它們是用來指示程式應該終止。這些例外包括了由 :meth:`sys.exit` 所引發"

"的 :exc:`SystemExit`，以及當使用者想要中斷程式時所引發"

"的 :exc:`KeyboardInterrupt`。"

#: ../../tutorial/errors.rst:194

msgid ""

":exc:`Exception` can be used as a wildcard that catches (almost) everything. "

"However, it is good practice to be as specific as possible with the types of "

"exceptions that we intend to handle, and to allow any unexpected exceptions "

"to propagate on."

msgstr ""

":exc:`Exception` 可以用作通配符 (wildcard) 來捕獲（幾乎）所有的例外。然而，比"

"較好的做法是盡可能具體地說明我們打算處理的例外類型，並容許任何非預期例外的傳"

"遞 (propagate)。"

#: ../../tutorial/errors.rst:199

msgid ""

"The most common pattern for handling :exc:`Exception` is to print or log the "

"exception and then re-raise it (allowing a caller to handle the exception as "

"well)::"

msgstr ""

"處理 :exc:`Exception` 的最常見模式，是先將該例外印出或記錄，然後再重新引發它"

"（也允許一個呼叫函式 (caller) 來處理該例外）： ::"

#: ../../tutorial/errors.rst:203

msgid ""

"import sys\n"

"\n"

"try:\n"

" f = open('myfile.txt')\n"

" s = f.readline()\n"

" i = int(s.strip())\n"

"except OSError as err:\n"

" print(\"OS error:\", err)\n"

"except ValueError:\n"

" print(\"Could not convert data to an integer.\")\n"

"except Exception as err:\n"

" print(f\"Unexpected {err=}, {type(err)=}\")\n"

" raise"

msgstr ""

"import sys\n"

"\n"

"try:\n"

" f = open('myfile.txt')\n"

" s = f.readline()\n"

" i = int(s.strip())\n"

"except OSError as err:\n"

" print(\"OS error:\", err)\n"

"except ValueError:\n"

" print(\"Could not convert data to an integer.\")\n"

"except Exception as err:\n"

" print(f\"Unexpected {err=}, {type(err)=}\")\n"

" raise"

#: ../../tutorial/errors.rst:217

msgid ""

"The :keyword:`try` ... :keyword:`except` statement has an optional *else "

"clause*, which, when present, must follow all *except clauses*. It is "

"useful for code that must be executed if the *try clause* does not raise an "

"exception. For example::"

msgstr ""

":keyword:`try` ... :keyword:`except` 陳述式有一個選擇性的 *else 子句*，使用"

"時，該子句必須放在所有 *except 子句*\\ 之後。如果一段程式碼必須被執行，但 "

"*try 子句*\\ 又沒有引發例外時，這個子句很有用。例如： ::"

#: ../../tutorial/errors.rst:222

msgid ""

"for arg in sys.argv[1:]:\n"

" try:\n"

" f = open(arg, 'r')\n"

" except OSError:\n"

" print('cannot open', arg)\n"

" else:\n"

" print(arg, 'has', len(f.readlines()), 'lines')\n"

" f.close()"

msgstr ""

"for arg in sys.argv[1:]:\n"

" try:\n"

" f = open(arg, 'r')\n"

" except OSError:\n"

" print('cannot open', arg)\n"

" else:\n"

" print(arg, 'has', len(f.readlines()), 'lines')\n"

" f.close()"

#: ../../tutorial/errors.rst:231

msgid ""

"The use of the :keyword:`!else` clause is better than adding additional code "

"to the :keyword:`try` clause because it avoids accidentally catching an "

"exception that wasn't raised by the code being protected by the :keyword:`!"

"try` ... :keyword:`!except` statement."

msgstr ""

"使用 :keyword:`!else` 子句比向 :keyword:`try` 子句添加額外的程式碼要好，因為"

"這可以避免意外地捕獲不是由 :keyword:`!try` ... :keyword:`!except` 陳述式保護"

"的程式碼所引發的例外。"

#: ../../tutorial/errors.rst:236

msgid ""

"Exception handlers do not handle only exceptions that occur immediately in "

"the *try clause*, but also those that occur inside functions that are called "

"(even indirectly) in the *try clause*. For example::"

msgstr ""

"例外的處理者不僅處理 *try 子句*\\ 內立即發生的例外，還處理 *try 子句*\\ 內"

"（即使是間接地）呼叫的函式內部發生的例外。例如： ::"

#: ../../tutorial/errors.rst:240

msgid ""

">>> def this_fails():\n"

"... x = 1/0\n"

"...\n"

">>> try:\n"

"... this_fails()\n"

"... except ZeroDivisionError as err:\n"

"... print('Handling run-time error:', err)\n"

"...\n"

"Handling run-time error: division by zero"

msgstr ""

">>> def this_fails():\n"

"... x = 1/0\n"

"...\n"

">>> try:\n"

"... this_fails()\n"

"... except ZeroDivisionError as err:\n"

"... print('Handling run-time error:', err)\n"

"...\n"

"Handling run-time error: division by zero"

#: ../../tutorial/errors.rst:254

msgid "Raising Exceptions"

msgstr "引發例外"

#: ../../tutorial/errors.rst:256

msgid ""

"The :keyword:`raise` statement allows the programmer to force a specified "

"exception to occur. For example::"

msgstr ":keyword:`raise` 陳述式可讓程式設計師強制引發指定的例外。例如： ::"

#: ../../tutorial/errors.rst:259

msgid ""

">>> raise NameError('HiThere')\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> raise NameError('HiThere')\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

#: ../../tutorial/errors.rst:265

msgid ""

"The sole argument to :keyword:`raise` indicates the exception to be raised. "

"This must be either an exception instance or an exception class (a class "

"that derives from :class:`BaseException`, such as :exc:`Exception` or one of "

"its subclasses). If an exception class is passed, it will be implicitly "

"instantiated by calling its constructor with no arguments::"

msgstr ""

":keyword:`raise` 唯一的引數就是要引發的例外。該引數必須是一個例外實例或例外 "

"class（衍生自 :class:`BaseException` 的 class，例如 :class:`Exception` 與它"

"的 subclass）。如果一個例外 class 被傳遞，它會不含引數地呼叫它的建構函式 "

"(constructor) ，使它被自動建立實例 (implicitly instantiated)： ::"

#: ../../tutorial/errors.rst:271

msgid "raise ValueError # shorthand for 'raise ValueError()'"

msgstr "raise ValueError # 'raise ValueError()' 的簡寫"

#: ../../tutorial/errors.rst:273

msgid ""

"If you need to determine whether an exception was raised but don't intend to "

"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"

"raise the exception::"

msgstr ""

"如果你只想判斷是否引發了例外，但並不打算處理它，則可以使用簡單"

"的 :keyword:`raise` 陳述式來重新引發該例外： ::"

#: ../../tutorial/errors.rst:277

msgid ""

">>> try:\n"

"... raise NameError('HiThere')\n"

"... except NameError:\n"

"... print('An exception flew by!')\n"

"... raise\n"

"...\n"

"An exception flew by!\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> try:\n"

"... raise NameError('HiThere')\n"

"... except NameError:\n"

"... print('An exception flew by!')\n"

"... raise\n"

"...\n"

"An exception flew by!\n"

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

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

" raise NameError('HiThere')\n"

"NameError: HiThere"

#: ../../tutorial/errors.rst:293

msgid "Exception Chaining"

msgstr "例外鏈接 (Exception Chaining)"

#: ../../tutorial/errors.rst:295

msgid ""

"If an unhandled exception occurs inside an :keyword:`except` section, it "

"will have the exception being handled attached to it and included in the "

"error message::"

msgstr ""

"如果在 :keyword:`except` 段落內部發生了一個未處理的例外，則它會讓這個將要被處"

"理的例外附加在後，並將其包含在錯誤訊息中： ::"

#: ../../tutorial/errors.rst:299

msgid ""

">>> try:\n"

"... open(\"database.sqlite\")\n"

"... except OSError:\n"

"... raise RuntimeError(\"unable to handle error\")\n"

"...\n"

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

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

" open(\"database.sqlite\")\n"

" ~~~~^^^^^^^^^^^^^^^^^^^\n"

"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\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(\"unable to handle error\")\n"

"RuntimeError: unable to handle error"

msgstr ""

">>> try:\n"

"... open(\"database.sqlite\")\n"

"... except OSError:\n"

"... raise RuntimeError(\"unable to handle error\")\n"

"...\n"

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

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

" open(\"database.sqlite\")\n"

" ~~~~^^^^^^^^^^^^^^^^^^^\n"

"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\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(\"unable to handle error\")\n"

"RuntimeError: unable to handle error"

#: ../../tutorial/errors.rst:317

msgid ""

"To indicate that an exception is a direct consequence of another, "

"the :keyword:`raise` statement allows an optional :keyword:`from<raise>` "

"clause::"

msgstr ""

"為了表明一個例外是另一個例外直接造成的結果，:keyword:`raise` 陳述式容許一個選"

"擇性的 :keyword:`from<raise>` 子句： ::"

#: ../../tutorial/errors.rst:320

msgid ""

"# exc must be exception instance or None.\n"

"raise RuntimeError from exc"

msgstr ""

"# exc 必須是例外實例或 None。\n"

"raise RuntimeError from exc"

#: ../../tutorial/errors.rst:323

msgid "This can be useful when you are transforming exceptions. For example::"

msgstr "要變換例外時，這種方式很有用。例如： ::"

#: ../../tutorial/errors.rst:325

msgid ""

">>> def func():\n"

"... raise ConnectionError\n"

"...\n"

">>> try:\n"

"... func()\n"

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

"... raise RuntimeError('Failed to open database') from exc\n"

"...\n"

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

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

" func()\n"

" ~~~~^^\n"

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

"ConnectionError\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('Failed to open database') from exc\n"

"RuntimeError: Failed to open database"

msgstr ""

">>> def func():\n"

"... raise ConnectionError\n"

"...\n"

">>> try:\n"

"... func()\n"

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

"... raise RuntimeError('Failed to open database') from exc\n"

"...\n"

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

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

" func()\n"

" ~~~~^^\n"

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

"ConnectionError\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('Failed to open database') from exc\n"

"RuntimeError: Failed to open database"

#: ../../tutorial/errors.rst:347

msgid ""

"It also allows disabling automatic exception chaining using the ``from "

"None`` idiom::"

msgstr "它也容許使用慣用語 ``from None`` 來停用自動例外鏈接： ::"

#: ../../tutorial/errors.rst:350

msgid ""

">>> try:\n"

"... open('database.sqlite')\n"

"... except OSError:\n"

"... raise RuntimeError from None\n"

"...\n"

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

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

" raise RuntimeError from None\n"

"RuntimeError"

msgstr ""

">>> try:\n"

"... open('database.sqlite')\n"

"... except OSError:\n"

"... raise RuntimeError from None\n"

"...\n"

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

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

" raise RuntimeError from None\n"

"RuntimeError"

#: ../../tutorial/errors.rst:360

msgid ""

"For more information about chaining mechanics, see :ref:`bltin-exceptions`."

msgstr "更多關於鏈接機制的資訊，詳見\\ :ref:`bltin-exceptions`。"

#: ../../tutorial/errors.rst:366

msgid "User-defined Exceptions"

msgstr "使用者自定的例外"

#: ../../tutorial/errors.rst:368

msgid ""

"Programs may name their own exceptions by creating a new exception class "

"(see :ref:`tut-classes` for more about Python classes). Exceptions should "

"typically be derived from the :exc:`Exception` class, either directly or "

"indirectly."

msgstr ""

"程式可以透過建立新的例外 class 來命名自己的例外（深入了解 Python class，詳見"

"\\ :ref:`tut-classes`\\ ）。不論是直接還是間接地，例外通常應該"

"從 :exc:`Exception` class 衍生出來。"

#: ../../tutorial/errors.rst:372

msgid ""

"Exception classes can be defined which do anything any other class can do, "

"but are usually kept simple, often only offering a number of attributes that "

"allow information about the error to be extracted by handlers for the "

"exception."

msgstr ""

"例外 class 可被定義來做任何其他 class 能夠做的事，但通常會讓它維持簡單，只提"

"供一些屬性，讓關於錯誤的資訊可被例外的處理者抽取出來。"

#: ../../tutorial/errors.rst:376

msgid ""

"Most exceptions are defined with names that end in \"Error\", similar to the "

"naming of the standard exceptions."

msgstr "大多數的例外定義，都會以「Error」作為名稱結尾，類似於標準例外的命名。"

#: ../../tutorial/errors.rst:379

msgid ""

"Many standard modules define their own exceptions to report errors that may "

"occur in functions they define."

msgstr "許多標準模組會定義它們自己的例外，以報告在其定義的函式中發生的錯誤。"

#: ../../tutorial/errors.rst:386

msgid "Defining Clean-up Actions"

msgstr "定義清理動作"

#: ../../tutorial/errors.rst:388

msgid ""

"The :keyword:`try` statement has another optional clause which is intended "

"to define clean-up actions that must be executed under all circumstances. "

"For example::"

msgstr ""

":keyword:`try` 陳述式有另一個選擇性子句，用於定義在所有情況下都必須被執行的清"

"理動作。例如： ::"

#: ../../tutorial/errors.rst:392

msgid ""

">>> try:\n"

"... raise KeyboardInterrupt\n"

"... finally:\n"

"... print('Goodbye, world!')\n"

"...\n"

"Goodbye, world!\n"

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

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

" raise KeyboardInterrupt\n"

"KeyboardInterrupt"

msgstr ""

">>> try:\n"

"... raise KeyboardInterrupt\n"

"... finally:\n"

"... print('Goodbye, world!')\n"

"...\n"

"Goodbye, world!\n"

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

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

" raise KeyboardInterrupt\n"

"KeyboardInterrupt"

#: ../../tutorial/errors.rst:403

msgid ""

"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "

"will execute as the last task before the :keyword:`try` statement completes. "

"The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "

"statement produces an exception. The following points discuss more complex "

"cases when an exception occurs:"

msgstr ""

"如果 :keyword:`finally` 子句存在，則 :keyword:`!finally` 子句會"

"是 :keyword:`try` 陳述式結束前執行的最後一項任務。不論 :keyword:`!try` 陳述式"

"是否產生例外，都會執行 :keyword:`!finally` 子句。以下幾點將探討例外發生時，比"

"較複雜的情況："

#: ../../tutorial/errors.rst:409

msgid ""

"If an exception occurs during execution of the :keyword:`!try` clause, the "

"exception may be handled by an :keyword:`except` clause. If the exception is "

"not handled by an :keyword:`!except` clause, the exception is re-raised "

"after the :keyword:`!finally` clause has been executed."

msgstr ""

"若一個例外發生於 :keyword:`!try` 子句的執行過程，則該例外會被某"

"個 :keyword:`except` 子句處理。如果該例外沒有被 :keyword:`!except` 子句處理，"

"它會在 :keyword:`!finally` 子句執行後被重新引發。"

#: ../../tutorial/errors.rst:415

msgid ""

"An exception could occur during execution of an :keyword:`!except` "

"or :keyword:`!else` clause. Again, the exception is re-raised after "

"the :keyword:`!finally` clause has been executed."

msgstr ""

"一個例外可能發生於 :keyword:`!except` 或 :keyword:`!else` 子句的執行過程。同"

"樣地，該例外會在 :keyword:`!finally` 子句執行後被重新引發。"

#: ../../tutorial/errors.rst:419

msgid ""

"If the :keyword:`!finally` clause executes "

"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement, "

"exceptions are not re-raised."

msgstr ""

"如果 :keyword:`!finally` 子句執行 :keyword:`break`、:keyword:`continue` "

"或 :keyword:`return` 陳述式，則例外不會被重新引發。"

#: ../../tutorial/errors.rst:423

msgid ""

"If the :keyword:`!try` statement reaches "

"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement, "

"the :keyword:`!finally` clause will execute just prior to the :keyword:`!"

"break`, :keyword:`!continue` or :keyword:`!return` statement's execution."

msgstr ""

"如果 :keyword:`!try` 陳述式遇到 :keyword:`break`、:keyword:`continue` "

"或 :keyword:`return` 陳述式，則 :keyword:`!finally` 子句會在執行 :keyword:`!"

"break`、:keyword:`!continue` 或 :keyword:`!return` 陳述式之前先執行。"

#: ../../tutorial/errors.rst:429

msgid ""

"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the "

"returned value will be the one from the :keyword:`!finally` "

"clause's :keyword:`!return` statement, not the value from the :keyword:`!"

"try` clause's :keyword:`!return` statement."

msgstr ""

"如果 :keyword:`!finally` 子句中包含 :keyword:`!return` 陳述式，則回傳值會是來"

"自 :keyword:`!finally` 子句的 :keyword:`!return` 陳述式的回傳值，而不是來"

"自 :keyword:`!try` 子句的 :keyword:`!return` 陳述式的回傳值。"

#: ../../tutorial/errors.rst:435

msgid "For example::"

msgstr "例如： ::"

#: ../../tutorial/errors.rst:437

msgid ""

">>> def bool_return():\n"

"... try:\n"

"... return True\n"

"... finally:\n"

"... return False\n"

"...\n"

">>> bool_return()\n"

"False"

msgstr ""

">>> def bool_return():\n"

"... try:\n"

"... return True\n"

"... finally:\n"

"... return False\n"

"...\n"

">>> bool_return()\n"

"False"

#: ../../tutorial/errors.rst:446

msgid "A more complicated example::"

msgstr "另一個比較複雜的範例： ::"

#: ../../tutorial/errors.rst:448

msgid ""

">>> def divide(x, y):\n"

"... try:\n"

"... result = x / y\n"

"... except ZeroDivisionError:\n"

"... print(\"division by zero!\")\n"

"... else:\n"

"... print(\"result is\", result)\n"

"... finally:\n"

"... print(\"executing finally clause\")\n"

"...\n"

">>> divide(2, 1)\n"

"result is 2.0\n"

"executing finally clause\n"

">>> divide(2, 0)\n"

"division by zero!\n"

"executing finally clause\n"

">>> divide(\"2\", \"1\")\n"

"executing finally clause\n"

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

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

" divide(\"2\", \"1\")\n"

" ~~~~~~^^^^^^^^^^\n"

" File \"<stdin>\", line 3, in divide\n"

" result = x / y\n"

" ~~^~~\n"

"TypeError: unsupported operand type(s) for /: 'str' and 'str'"

msgstr ""

">>> def divide(x, y):\n"

"... try:\n"

"... result = x / y\n"

"... except ZeroDivisionError:\n"

"... print(\"division by zero!\")\n"

"... else:\n"

"... print(\"result is\", result)\n"

"... finally:\n"

"... print(\"executing finally clause\")\n"

"...\n"

">>> divide(2, 1)\n"

"result is 2.0\n"

"executing finally clause\n"

">>> divide(2, 0)\n"

"division by zero!\n"

"executing finally clause\n"

">>> divide(\"2\", \"1\")\n"

"executing finally clause\n"

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

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

" divide(\"2\", \"1\")\n"

" ~~~~~~^^^^^^^^^^\n"

" File \"<stdin>\", line 3, in divide\n"

" result = x / y\n"

" ~~^~~\n"

"TypeError: unsupported operand type(s) for /: 'str' and 'str'"

#: ../../tutorial/errors.rst:475

msgid ""

"As you can see, the :keyword:`finally` clause is executed in any event. "

"The :exc:`TypeError` raised by dividing two strings is not handled by "

"the :keyword:`except` clause and therefore re-raised after the :keyword:`!"