# 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.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-09-22 21:56+0000\n"
"PO-Revision-Date: 2025-09-22 17:56+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 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 :keyword:`try` statement."
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../tutorial/errors.rst:150
msgid ""
"The last except clause may omit the exception name(s), 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 ""

#: ../../tutorial/errors.rst:169
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 ""

#: ../../tutorial/errors.rst:183
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:188
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:192
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 ""

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

#: ../../tutorial/errors.rst:219
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 ""

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

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

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

#: ../../tutorial/errors.rst:275
msgid ""
"The :keyword:`raise` statement allows an optional :keyword:`from<raise>` "
"which enables chaining exceptions. For example::"
msgstr ""

#: ../../tutorial/errors.rst:281
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr "转换异常时，这种方式很有用。例如："

#: ../../tutorial/errors.rst:302
msgid ""
"Exception chaining happens automatically when an exception is raised inside "
"an :keyword:`except` or :keyword:`finally` section. Exception chaining can "
"be disabled by using ``from None`` idiom:"
msgstr ""

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

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

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

#: ../../tutorial/errors.rst:334
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:342
msgid "Defining Clean-up Actions"
msgstr "定义清理操作"

#: ../../tutorial/errors.rst:344
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:358
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:364
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:370
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:374
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:378
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:384
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:390
msgid "For example::"
msgstr "例如："

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

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

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