# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-01-03 15:28+0000\n"

"PO-Revision-Date: 2025-09-22 16:51+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\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 ""

"至此，本教程还未深入介绍错误信息，但如果您尝试过本教程前文中的例子，应该已经看到过一些错误信息。错误可（至少）被分为两种：*语法错误* 和 *异常*。"

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

msgid "Syntax Errors"

msgstr "语法错误"

#: ../../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 "语法错误又称解析错误，是学习 Python 时最常见的错误："

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

msgid ""

"The parser repeats the offending line and displays little 'arrow's pointing "

"at the token in the line where the error was detected. The error may be "

"caused by the absence of a token *before* the indicated token. In the "

"example, the error is detected at the function :func:`print`, since a colon "

"(``':'``) is missing before it. File name and line number are printed so "

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

msgstr ""

"解析器会重复存在错误的行并显示一个指向该行中检测到错误的词元的‘箭头’。 错误可能是由于所指向的词元 *之前* 缺少某个词元而导致的。 "

"在这个例子中，错误是在函数 :func:`print` 上检测到的，原因是在它之前缺少一个冒号 (``':'``)。 "

"文件名和行号也会被打印出来以便你在输入是来自脚本时可以知道要去哪里查找问题。"

#: ../../tutorial/errors.rst:37

msgid "Exceptions"

msgstr "异常"

#: ../../tutorial/errors.rst:39

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

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`。作为异常类型打印的字符串是发生的内置异常的名称。对于所有内置异常都是如此，但对于用户定义的异常则不一定如此（虽然这种规范很有用）。标准的异常类型是内置的标识符（不是保留关键字）。"

#: ../../tutorial/errors.rst:66

msgid ""

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

" caused it."

msgstr "此行其余部分根据异常类型，结合出错原因，说明错误细节。"

#: ../../tutorial/errors.rst:69

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 "错误信息开头用堆栈回溯形式展示发生异常的语境。一般会列出源代码行的堆栈回溯；但不会显示从标准输入读取的行。"

#: ../../tutorial/errors.rst:74

msgid ""

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

msgstr ":ref:`bltin-exceptions` 列出了内置异常及其含义。"

#: ../../tutorial/errors.rst:80

msgid "Handling Exceptions"

msgstr "异常的处理"

#: ../../tutorial/errors.rst:82

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

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

msgstr ":keyword:`try` 语句的工作原理如下："

#: ../../tutorial/errors.rst:98

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

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

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

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` 语句中；如果没有找到处理器，则它是一个"

" *未处理异常* 且执行将停止并输出一条错误消息。"

#: ../../tutorial/errors.rst:113

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 子句*"

" 可以用带圆括号的元组来指定多个异常，例如::"

#: ../../tutorial/errors.rst:122

msgid ""

"A class in an :keyword:`except` clause is compatible with an exception if it"

" is the same class or a base class thereof (but not the other way around ---"

" an *except clause* listing a derived class is not compatible with a base "

"class). For example, the following code will print B, C, D in that order::"

msgstr ""

"如果发生的异常与 :keyword:`except` 子句中的类是同一个类或是它的基类时，则该类与该异常相兼容（反之则不成立 --- 列出派生类的 "

"*except 子句* 与基类不兼容）。 例如，下面的代码将依次打印 B, C, D::"

#: ../../tutorial/errors.rst:146

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

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

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 子句* 可能会在异常名称后面指定一个变量。 这个变量将被绑定到异常实例，该实例通常会有一个存储参数的 ``args`` 属性。 "

"为了方便起见，内置异常类型定义了 :meth:`~object.__str__` 来打印所有参数而不必显式地访问 ``.args``。 ::"

#: ../../tutorial/errors.rst:176

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__` 输出会被打印为该异常消息的最后部分 ('detail')。"

#: ../../tutorial/errors.rst:179

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` 是所有异常的共同基类。它的一个子类， :exc:`Exception` ，是所有非致命异常的基类。不是 "

":exc:`Exception` 的子类的异常通常不被处理，因为它们被用来指示程序应该终止。它们包括由 :meth:`sys.exit` 引发的 "

":exc:`SystemExit` ，以及当用户希望中断程序时引发的 :exc:`KeyboardInterrupt` 。"

#: ../../tutorial/errors.rst:187

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

"可以被用作通配符，捕获（几乎）一切。然而，好的做法是，尽可能具体地说明我们打算处理的异常类型，并允许任何意外的异常传播下去。"

#: ../../tutorial/errors.rst:192

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` 最常见的模式是打印或记录异常，然后重新提出（允许调用者也处理异常）::"

#: ../../tutorial/errors.rst:210

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

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

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

msgid "Raising Exceptions"

msgstr "触发异常"

#: ../../tutorial/errors.rst:249

msgid ""

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

"exception to occur. For example::"

msgstr ":keyword:`raise` 语句支持强制触发指定的异常。例如："

#: ../../tutorial/errors.rst:257

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

"类，例如 :exc:`Exception` 或其子类）。如果传递的是异常类，将通过调用没有参数的构造函数来隐式实例化："

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

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

msgid "Exception Chaining"

msgstr "异常链"

#: ../../tutorial/errors.rst:286

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

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

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

msgstr "转换异常时，这种方式很有用。例如："

#: ../../tutorial/errors.rst:332

msgid ""

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

"None`` idiom::"

msgstr "它还允许使用 ``from None`` 表达禁用自动异常链::"

#: ../../tutorial/errors.rst:344

msgid ""

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

msgstr "异常链机制详见 :ref:`bltin-exceptions`。"

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

msgid "User-defined Exceptions"

msgstr "用户自定义异常"

#: ../../tutorial/errors.rst:352

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 ""

"程序可以通过创建新的异常类命名自己的异常（Python 类的内容详见 :ref:`tut-classes`）。不论是以直接还是间接的方式，异常都应从 "

":exc:`Exception` 类派生。"

#: ../../tutorial/errors.rst:356

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 "异常类可以被定义成能做其他类所能做的任何事，但通常应当保持简单，它往往只提供一些属性，允许相应的异常处理程序提取有关错误的信息。"

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

msgid ""

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

" naming of the standard exceptions."

msgstr "大多数异常命名都以 “Error” 结尾，类似标准异常的命名。"

#: ../../tutorial/errors.rst:363

msgid ""

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

"occur in functions they define."

msgstr "许多标准模块定义了自己的异常，以报告他们定义的函数中可能出现的错误。"

#: ../../tutorial/errors.rst:370

msgid "Defining Clean-up Actions"

msgstr "定义清理操作"

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

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

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

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

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

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

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

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

msgid "For example::"

msgstr "例如："

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

msgid "A more complicated example::"

msgstr "这是一个比较复杂的例子："

#: ../../tutorial/errors.rst:454

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:`!finally` clause has been executed."

msgstr ""

"如上所示，任何情况下都会执行 :keyword:`finally` 子句。:keyword:`except` 子句不处理两个字符串相除触发的 "

":exc:`TypeError`，因此会在 :keyword:`!finally` 子句执行后被重新触发。"

#: ../../tutorial/errors.rst:459

msgid ""

"In real world applications, the :keyword:`finally` clause is useful for "

"releasing external resources (such as files or network connections), "

"regardless of whether the use of the resource was successful."

msgstr "在实际应用程序中，:keyword:`finally` 子句对于释放外部资源（例如文件或者网络连接）非常有用，无论是否成功使用资源。"

#: ../../tutorial/errors.rst:467

msgid "Predefined Clean-up Actions"

msgstr "预定义的清理操作"

#: ../../tutorial/errors.rst:469

msgid ""

"Some objects define standard clean-up actions to be undertaken when the "

"object is no longer needed, regardless of whether or not the operation using"

" the object succeeded or failed. Look at the following example, which tries "

"to open a file and print its contents to the screen. ::"

msgstr ""

"某些对象定义了不需要该对象时要执行的标准清理操作。无论使用该对象的操作是否成功，都会执行清理操作。比如，下例要打开一个文件，并输出文件内容："

#: ../../tutorial/errors.rst:477

msgid ""

"The problem with this code is that it leaves the file open for an "

"indeterminate amount of time after this part of the code has finished "

"executing. This is not an issue in simple scripts, but can be a problem for "

"larger applications. The :keyword:`with` statement allows objects like files"

" to be used in a way that ensures they are always cleaned up promptly and "

"correctly. ::"

msgstr ""

"这个代码的问题在于，执行完代码后，文件在一段不确定的时间内处于打开状态。在简单脚本中这没有问题，但对于较大的应用程序来说可能会出问题。:keyword:`with`"

" 语句支持以及时、正确的清理的方式使用文件对象："

#: ../../tutorial/errors.rst:487

msgid ""

"After the statement is executed, the file *f* is always closed, even if a "

"problem was encountered while processing the lines. Objects which, like "

"files, provide predefined clean-up actions will indicate this in their "

"documentation."

msgstr "语句执行完毕后，即使在处理行时遇到问题，都会关闭文件 *f*。和文件一样，支持预定义清理操作的对象会在文档中指出这一点。"

#: ../../tutorial/errors.rst:495

msgid "Raising and Handling Multiple Unrelated Exceptions"

msgstr "引发和处理多个不相关的异常"

#: ../../tutorial/errors.rst:497

msgid ""

"There are situations where it is necessary to report several exceptions that"

" have occurred. This is often the case in concurrency frameworks, when "

"several tasks may have failed in parallel, but there are also other use "

"cases where it is desirable to continue execution and collect multiple "

"errors rather than raise the first exception."

msgstr ""

"在有些情况下，有必要报告几个已经发生的异常。这通常是在并发框架中当几个任务并行失败时的情况，但也有其他的用例，有时需要是继续执行并收集多个错误而不是引发第一个异常。"

#: ../../tutorial/errors.rst:503

msgid ""

"The builtin :exc:`ExceptionGroup` wraps a list of exception instances so "

"that they can be raised together. It is an exception itself, so it can be "

"caught like any other exception. ::"

msgstr ""

"内置的 :exc:`ExceptionGroup` "

"打包了一个异常实例的列表，这样它们就可以一起被引发。它本身就是一个异常，所以它可以像其他异常一样被捕获。"

#: ../../tutorial/errors.rst:529

msgid ""

"By using ``except*`` instead of ``except``, we can selectively handle only "

"the exceptions in the group that match a certain type. In the following "

"example, which shows a nested exception group, each ``except*`` clause "

"extracts from the group exceptions of a certain type while letting all other"

" exceptions propagate to other clauses and eventually to be reraised. ::"

msgstr ""

"通过使用 ``except*`` 代替 ``except`` "

"，我们可以有选择地只处理组中符合某种类型的异常。在下面的例子中，显示了一个嵌套的异常组，每个 ``except*`` "

"子句都从组中提取了某种类型的异常，而让所有其他的异常传播到其他子句，并最终被重新引发。"

#: ../../tutorial/errors.rst:572

msgid ""

"Note that the exceptions nested in an exception group must be instances, not"

" types. This is because in practice the exceptions would typically be ones "

"that have already been raised and caught by the program, along the following"

" pattern::"

msgstr "注意，嵌套在一个异常组中的异常必须是实例，而不是类型。这是因为在实践中，这些异常通常是那些已经被程序提出并捕获的异常，其模式如下::"

#: ../../tutorial/errors.rst:592

msgid "Enriching Exceptions with Notes"

msgstr "用注释细化异常情况"

#: ../../tutorial/errors.rst:594

msgid ""

"When an exception is created in order to be raised, it is usually "

"initialized with information that describes the error that has occurred. "

"There are cases where it is useful to add information after the exception "

"was caught. For this purpose, exceptions have a method ``add_note(note)`` "

"that accepts a string and adds it to the exception's notes list. The "

"standard traceback rendering includes all notes, in the order they were "

"added, after the exception. ::"

msgstr ""

"当一个异常被创建以引发时，它通常被初始化为描述所发生错误的信息。在有些情况下，在异常被捕获后添加信息是很有用的。为了这个目的，异常有一个 "

"``add_note(note)`` 方法接受一个字符串，并将其添加到异常的注释列表。标准的回溯在异常之后按照它们被添加的顺序呈现包括所有的注释。 ::"

#: ../../tutorial/errors.rst:615

msgid ""

"For example, when collecting exceptions into an exception group, we may want"

" to add context information for the individual errors. In the following each"

" exception in the group has a note indicating when this error has occurred. "

"::"

msgstr ""

"例如，当把异常收集到一个异常组时，我们可能想为各个错误添加上下文信息。在下文中，组中的每个异常都有一个说明，指出这个错误是什么时候发生的。 ::"