# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-10-11 20:40+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.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 ""
" , , "
"::"
#: ../../tutorial/errors.rst:20
msgid ""
">>> while True print('Hello world')\n"
" File \"\", line 1\n"
" while True print('Hello world')\n"
" ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> while True print('Hello world')\n"
" File \"\", 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 ""
" . "
" . , :func:`print` , "
"(``':'``) ."
#: ../../tutorial/errors.rst:31
msgid ""
"The file name (```` in our example) and line number are printed so"
" you know where to look in case the input came from a file."
msgstr " ( ````) , ."
#: ../../tutorial/errors.rst:38
msgid "Exceptions"
msgstr ""
#: ../../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 ""
" , . ** "
" : . "
" , ::"
#: ../../tutorial/errors.rst:46
msgid ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
" 10 * (1/0)\n"
" ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
" 4 + spam*3\n"
" ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \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 \"\", line 1, in \n"
" 10 * (1/0)\n"
" ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
" 4 + spam*3\n"
" ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \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` ."
" . , "
" ( ) . ( )."
#: ../../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 ""
" . "
" ; , ."
#: ../../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` "
"; , * * ."
#: ../../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 *\\ "
" , ::"
#: ../../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 ""
#: ../../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"
"\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__ args ,\n"
"... # \n"
"... x, y = inst.args # args \n"
"... print('x =', x)\n"
"... print('y =', y)\n"
"...\n"
"\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 ""
#: ../../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 ""
#: ../../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 ""
#: ../../tutorial/errors.rst:203
#, python-brace-format
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 \"\", line 1, in \n"
" raise NameError('HiThere')\n"
"NameError: HiThere"
msgstr ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \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:`BaseException` , :exc:`Exception`\\ ) "
" . , ::"
#: ../../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 \"\", line 2, in \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 \"\", line 2, in \n"
" raise NameError('HiThere')\n"
"NameError: HiThere"
#: ../../tutorial/errors.rst:293
msgid "Exception Chaining"
msgstr " "
#: ../../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 ""
#: ../../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 \"\", line 2, in \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 \"\", line 4, in \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 \"\", line 2, in \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 \"\", line 4, in \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` "
"clause::"
msgstr ""
#: ../../tutorial/errors.rst:320
msgid ""
"# exc must be exception instance or None.\n"
"raise RuntimeError from exc"
msgstr ""
#: ../../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 \"\", line 2, in \n"
" func()\n"
" ~~~~^^\n"
" File \"\", 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 \"\", line 4, in \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 \"\", line 2, in \n"
" func()\n"
" ~~~~^^\n"
" File \"\", 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 \"\", line 4, in \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 ""
#: ../../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 \"\", line 4, in \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 \"\", line 4, in \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 ""
" ( :ref"
":`tut-classes` ). :exc:`Exception` ."
#: ../../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 ""
" , . "
" ."
#: ../../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 \"\", line 2, in \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 \"\", line 2, in \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:`try` :keyword:`!finally` "
" . :keyword:`!finally` :keyword:`!try` "
" . :"
#: ../../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. This can be confusing and is therefore discouraged. From "
"version 3.14 the compiler emits a :exc:`SyntaxWarning` for it (see "
":pep:`765`)."
msgstr ""
#: ../../tutorial/errors.rst:425
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:431
#, fuzzy
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. This can be confusing and is "
"therefore discouraged. From version 3.14 the compiler emits a "
":exc:`SyntaxWarning` for it (see :pep:`765`)."
msgstr ""
":keyword:`!finally` :keyword:`!return` , :keyword:`!try` "
" :keyword:`!return` , :keyword:`!finally` "
":keyword:`!return` ."
#: ../../tutorial/errors.rst:439
msgid "For example::"
msgstr " ::"
#: ../../tutorial/errors.rst:441
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:450
msgid "A more complicated example::"
msgstr " ::"
#: ../../tutorial/errors.rst:452
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 \"\", line 1, in \n"
" divide(\"2\", \"1\")\n"
" ~~~~~~^^^^^^^^^^\n"
" File \"\", 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 \"\", line 1, in \n"
" divide(\"2\", \"1\")\n"
" ~~~~~~^^^^^^^^^^\n"
" File \"\", line 3, in divide\n"
" result = x / y\n"
" ~~^~~\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"
#: ../../tutorial/errors.rst:479
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` . "
":exc:`TypeError` :keyword:`except` :keyword:`!finally` "
" ."
#: ../../tutorial/errors.rst:484
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:492
msgid "Predefined Clean-up Actions"
msgstr " "
#: ../../tutorial/errors.rst:494
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:499
msgid ""
"for line in open(\"myfile.txt\"):\n"
" print(line, end=\"\")"
msgstr ""
"for line in open(\"myfile.txt\"):\n"
" print(line, end=\"\")"
#: ../../tutorial/errors.rst:502
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:508
msgid ""
"with open(\"myfile.txt\") as f:\n"
" for line in f:\n"
" print(line, end=\"\")"
msgstr ""
"with open(\"myfile.txt\") as f:\n"
" for line in f:\n"
" print(line, end=\"\")"
#: ../../tutorial/errors.rst:512
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:520
msgid "Raising and Handling Multiple Unrelated Exceptions"
msgstr ""
#: ../../tutorial/errors.rst:522
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:528
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 ""
#: ../../tutorial/errors.rst:532
#, python-brace-format
msgid ""
">>> def f():\n"
"... excs = [OSError('error 1'), SystemError('error 2')]\n"
"... raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 1, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 3, in f\n"
" | raise ExceptionGroup('there were problems', excs)\n"
" | ExceptionGroup: there were problems (2 sub-exceptions)\n"
" +-+---------------- 1 ----------------\n"
" | OSError: error 1\n"
" +---------------- 2 ----------------\n"
" | SystemError: error 2\n"
" +------------------------------------\n"
">>> try:\n"
"... f()\n"
"... except Exception as e:\n"
"... print(f'caught {type(e)}: e')\n"
"...\n"
"caught : e\n"
">>>"
msgstr ""
">>> def f():\n"
"... excs = [OSError('error 1'), SystemError('error 2')]\n"
"... raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 1, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 3, in f\n"
" | raise ExceptionGroup('there were problems', excs)\n"
" | ExceptionGroup: there were problems (2 sub-exceptions)\n"
" +-+---------------- 1 ----------------\n"
" | OSError: error 1\n"
" +---------------- 2 ----------------\n"
" | SystemError: error 2\n"
" +------------------------------------\n"
">>> try:\n"
"... f()\n"
"... except Exception as e:\n"
"... print(f'caught {type(e)}: e')\n"
"...\n"
"caught : e\n"
">>>"
#: ../../tutorial/errors.rst:557
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 ""
#: ../../tutorial/errors.rst:564
msgid ""
">>> def f():\n"
"... raise ExceptionGroup(\n"
"... \"group1\",\n"
"... [\n"
"... OSError(1),\n"
"... SystemError(2),\n"
"... ExceptionGroup(\n"
"... \"group2\",\n"
"... [\n"
"... OSError(3),\n"
"... RecursionError(4)\n"
"... ]\n"
"... )\n"
"... ]\n"
"... )\n"
"...\n"
">>> try:\n"
"... f()\n"
"... except* OSError as e:\n"
"... print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"... print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 2, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise ExceptionGroup(\n"
" | ......\n"
" | )\n"
" | ExceptionGroup: group1 (1 sub-exception)\n"
" +-+---------------- 1 ----------------\n"
" | ExceptionGroup: group2 (1 sub-exception)\n"
" +-+---------------- 1 ----------------\n"
" | RecursionError: 4\n"
" +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"... raise ExceptionGroup(\n"
"... \"group1\",\n"
"... [\n"
"... OSError(1),\n"
"... SystemError(2),\n"
"... ExceptionGroup(\n"
"... \"group2\",\n"
"... [\n"
"... OSError(3),\n"
"... RecursionError(4)\n"
"... ]\n"
"... )\n"
"... ]\n"
"... )\n"
"...\n"
">>> try:\n"
"... f()\n"
"... except* OSError as e:\n"
"... print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"... print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 2, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise ExceptionGroup(\n"
" | ......\n"
" | )\n"
" | ExceptionGroup: group1 (1 sub-exception)\n"
" +-+---------------- 1 ----------------\n"
" | ExceptionGroup: group2 (1 sub-exception)\n"
" +-+---------------- 1 ----------------\n"
" | RecursionError: 4\n"
" +------------------------------------\n"
">>>"
#: ../../tutorial/errors.rst:605
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:610
msgid ""
">>> excs = []\n"
"... for test in tests:\n"
"... try:\n"
"... test.run()\n"
"... except Exception as e:\n"
"... excs.append(e)\n"
"...\n"
">>> if excs:\n"
"... raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."
msgstr ""
">>> excs = []\n"
"... for test in tests:\n"
"... try:\n"
"... test.run()\n"
"... except Exception as e:\n"
"... excs.append(e)\n"
"...\n"
">>> if excs:\n"
"... raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."
#: ../../tutorial/errors.rst:625
msgid "Enriching Exceptions with Notes"
msgstr ""
#: ../../tutorial/errors.rst:627
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 ""
#: ../../tutorial/errors.rst:634
msgid ""
">>> try:\n"
"... raise TypeError('bad type')\n"
"... except Exception as e:\n"
"... e.add_note('Add some information')\n"
"... e.add_note('Add some more information')\n"
"... raise\n"
"...\n"
"Traceback (most recent call last):\n"
" File \"\", line 2, in \n"
" raise TypeError('bad type')\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"
msgstr ""
">>> try:\n"
"... raise TypeError('bad type')\n"
"... except Exception as e:\n"
"... e.add_note('Add some information')\n"
"... e.add_note('Add some more information')\n"
"... raise\n"
"...\n"
"Traceback (most recent call last):\n"
" File \"\", line 2, in \n"
" raise TypeError('bad type')\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"
#: ../../tutorial/errors.rst:649
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 ""
#: ../../tutorial/errors.rst:653
#, python-brace-format
msgid ""
">>> def f():\n"
"... raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"... try:\n"
"... f()\n"
"... except Exception as e:\n"
"... e.add_note(f'Happened in Iteration {i+1}')\n"
"... excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 1, in \n"
" | raise ExceptionGroup('We have some problems', excs)\n"
" | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
" +-+---------------- 1 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 1\n"
" +---------------- 2 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 2\n"
" +---------------- 3 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 3\n"
" +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"... raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"... try:\n"
"... f()\n"
"... except Exception as e:\n"
"... e.add_note(f'Happened in Iteration {i+1}')\n"
"... excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
" + Exception Group Traceback (most recent call last):\n"
" | File \"\", line 1, in \n"
" | raise ExceptionGroup('We have some problems', excs)\n"
" | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
" +-+---------------- 1 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 1\n"
" +---------------- 2 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 2\n"
" +---------------- 3 ----------------\n"
" | Traceback (most recent call last):\n"
" | File \"\", line 3, in \n"
" | f()\n"
" | ~^^\n"
" | File \"\", line 2, in f\n"
" | raise OSError('operation failed')\n"
" | OSError: operation failed\n"
" | Happened in Iteration 3\n"
" +------------------------------------\n"
">>>"
#~ 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 ""
#~ " except "
#~ ", . "
#~ " . "
#~ " ! "
#~ " "
#~ " ( )::"
#~ 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`` "
#~ " "
#~ ". "
#~ " . ::"
#~ msgid ""
#~ "The :keyword:`raise` statement allows an "
#~ "optional :keyword:`from` which enables "
#~ "chaining exceptions. For example::"
#~ msgstr ":keyword:`raise` :keyword:`from`\\ . ::"
#~ 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 ""
#~ ":keyword:`except`\\ :keyword:`finally` "
#~ " . ``from"
#~ " None`` "
#~ " :"
#~ msgid ""
#~ "If the :keyword:`!finally` clause executes "
#~ "a :keyword:`break`, :keyword:`continue` or "
#~ ":keyword:`return` statement, exceptions are "
#~ "not re-raised."
#~ msgstr ""