errors.po

# 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.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-01-03 16:02+0000\n"
"PO-Revision-Date: 2025-09-22 15:58+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 a little 'arrow' pointing"
" at the earliest point in the line where the error was detected.  The error "
"is caused by (or at least detected at) the token *preceding* the arrow: 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 ""
"解析器会复现出现句法错误的代码行，并用小“箭头”指向行里检测到的第一个错误。错误是由箭头 *上方* 的 token "
"触发的（至少是在这里检测出的）：本例中，在 :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 a "
"message as shown above."
msgstr ""
"如果发生的异常与 *except 子句* 中指定的异常不匹配，则它会被传递到外部的 :keyword:`try` "
"语句中；如果没有找到处理程序，则它是一个 *未处理异常* 且执行将终止并输出如上所示的消息。"

#: ../../tutorial/errors.rst:114
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:123
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:147
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:150
msgid ""
"All exceptions inherit from :exc:`BaseException`, and so it can be used to "
"serve as a wildcard. Use this with extreme caution, since it is easy to mask"
" a real programming error in this way!  It can also be used to print an "
"error message and then re-raise the exception (allowing a caller to handle "
"the exception as well)::"
msgstr ""
"所有异常都继承自 :exc:`BaseException`，因此它可被用作通配符。 但这种用法要非常谨慎小心，因为它很容易掩盖真正的编程错误！  "
"它还可被用于打印错误消息然后重新引发异常（允许调用者再来处理该异常）::"

#: ../../tutorial/errors.rst:169
msgid ""
"Alternatively the last except clause may omit the exception name(s), however"
" the exception value must then be retrieved from ``sys.exc_info()[1]``."
msgstr "可以选择让最后一个 except 子句省略异常名称，但在此之后异常值必须从 ``sys.exc_info()[1]`` 获取。"

#: ../../tutorial/errors.rst:172
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:186
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:191
msgid ""
"When an exception occurs, it may have an associated value, also known as the"
" exception's *argument*. The presence and type of the argument depend on the"
" exception type."
msgstr "发生异常时，它可能具有关联值，即异常 *参数* 。是否需要参数，以及参数的类型取决于异常的类型。"

#: ../../tutorial/errors.rst:195
msgid ""
"The *except clause* may specify a variable after the exception name.  The "
"variable is bound to an exception instance with the arguments stored in "
"``instance.args``.  For convenience, the exception instance defines "
":meth:`__str__` so the arguments can be printed directly without having to "
"reference ``.args``.  One may also instantiate an exception first before "
"raising it and add any attributes to it as desired. ::"
msgstr ""
"*except 子句* 可以在异常名称后面指定一个变量。 这个变量会绑定到一个异常实例并将参数存储在 ``instance.args`` 中。 "
"为了方便起见，该异常实例定义了 :meth:`__str__` 以便能直接打印参数而无需引用 ``.args``。 "
"也可以在引发异常之前先实例化一个异常并根据需要向其添加任何属性。::"

#: ../../tutorial/errors.rst:219
msgid ""
"If an exception has arguments, they are printed as the last part ('detail') "
"of the message for unhandled exceptions."
msgstr "如果异常有参数，则它们将作为未处理异常的消息的最后一部分（'详细信息'）打印。"

#: ../../tutorial/errors.rst:222
msgid ""
"Exception handlers don't just handle exceptions if they occur immediately in"
" the *try clause*, but also if they occur inside functions that are called "
"(even indirectly) in the *try clause*. For example::"
msgstr "异常处理程序不仅会处理在 *try 子句* 中发生的异常，还会处理在 *try 子句* 中调用（包括间接调用）的函数。 例如::"

#: ../../tutorial/errors.rst:240
msgid "Raising Exceptions"
msgstr "触发异常"

#: ../../tutorial/errors.rst:242
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ":keyword:`raise` 语句支持强制触发指定的异常。例如："

#: ../../tutorial/errors.rst:250
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:`Exception`).  If an exception class is passed, it "
"will be implicitly instantiated by calling its constructor with no "
"arguments::"
msgstr ""
":keyword:`raise` 唯一的参数就是要触发的异常。这个参数必须是异常实例或异常类（派生自 :class:`Exception` "
"类）。如果传递的是异常类，将通过调用没有参数的构造函数来隐式实例化："

#: ../../tutorial/errors.rst:257
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:276
msgid "Exception Chaining"
msgstr "异常链"

#: ../../tutorial/errors.rst:278
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:297
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:303
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr "转换异常时，这种方式很有用。例如："

#: ../../tutorial/errors.rst:324
msgid ""
"It also allows disabling automatic exception chaining using the ``from "
"None`` idiom::"
msgstr "它还允许使用 ``from None`` 表达禁用自动异常链::"

#: ../../tutorial/errors.rst:336
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr "异常链机制详见 :ref:`bltin-exceptions`。"

#: ../../tutorial/errors.rst:342
msgid "User-defined Exceptions"
msgstr "用户自定义异常"

#: ../../tutorial/errors.rst:344
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:348
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:352
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the"
" naming of the standard exceptions."
msgstr "大多数异常命名都以 “Error” 结尾，类似标准异常的命名。"

#: ../../tutorial/errors.rst:355
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define.  More information on classes is presented in"
" chapter :ref:`tut-classes`."
msgstr "许多标准模块都需要自定义异常，以报告由其定义的函数中出现的错误。有关类的说明，详见 :ref:`tut-classes`。"

#: ../../tutorial/errors.rst:363
msgid "Defining Clean-up Actions"
msgstr "定义清理操作"

#: ../../tutorial/errors.rst:365
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:379
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:385
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:391
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:395
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:399
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:405
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:411
msgid "For example::"
msgstr "例如："

#: ../../tutorial/errors.rst:422
msgid "A more complicated example::"
msgstr "这是一个比较复杂的例子："

#: ../../tutorial/errors.rst:447
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:452
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:460
msgid "Predefined Clean-up Actions"
msgstr "预定义的清理操作"

#: ../../tutorial/errors.rst:462
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:470
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:480
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*。和文件一样，支持预定义清理操作的对象会在文档中指出这一点。"