# 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: 2018-12-25 10:27+0900\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.6.0\n"
#: ../Doc/tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr " "
#: ../Doc/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 ""
" , . () "
" ; * * **."
#: ../Doc/tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr " "
#: ../Doc/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 ""
" , , "
"::"
#: ../Doc/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 ""
" '' . "
" * * ( ): , :func:`print` "
", (``':'``) . , "
" ."
#: ../Doc/tutorial/errors.rst:37
msgid "Exceptions"
msgstr ""
#: ../Doc/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 ""
" , . ** "
" : . "
" , ::"
#: ../Doc/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` ."
" . , "
" ( ) . ( )."
#: ../Doc/tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and "
"what caused it."
msgstr " ."
#: ../Doc/tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception happened, 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 ""
" . "
" ; , ."
#: ../Doc/tutorial/errors.rst:74
msgid ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ":ref:`bltin-exceptions` ."
#: ../Doc/tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr " "
#: ../Doc/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` ."
" ::"
#: ../Doc/tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr ":keyword:`try` ."
#: ../Doc/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` ) ."
#: ../Doc/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` ."
#: ../Doc/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 ""
"try , . :keyword:`except` "
" , except , :keyword:`try` "
"."
#: ../Doc/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` ; "
" , * * ."
#: ../Doc/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 , "
" ::"
#: ../Doc/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 ::"
#: ../Doc/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 --- "
" ."
#: ../Doc/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 ""
" except , . "
". ! "
" ( )::"
#: ../Doc/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 ""
":keyword:`try` ... :keyword:`except` *else * , "
"except . try . ::"
#: ../Doc/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` "
"."
#: ../Doc/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 ""
" , , ** . "
"."
#: ../Doc/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 ""
"except . ``instance.args`` "
" . , :meth:`__str__` , ``.args`` "
" . ."
" ::"
#: ../Doc/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 " , (' ') ."
#: ../Doc/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 ""
" try , try () "
" . ::"
#: ../Doc/tutorial/errors.rst:237
msgid "Raising Exceptions"
msgstr " "
#: ../Doc/tutorial/errors.rst:239
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified"
" exception to occur. For example::"
msgstr ":keyword:`raise` . ::"
#: ../Doc/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` ) . , "
" ::"
#: ../Doc/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` "
" ::"
#: ../Doc/tutorial/errors.rst:273
msgid "User-defined Exceptions"
msgstr " "
#: ../Doc/tutorial/errors.rst:275
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` ."
#: ../Doc/tutorial/errors.rst:279
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. When creating a module that can raise "
"several distinct errors, a common practice is to create a base class for "
"exceptions defined by that module, and subclass that to create specific "
"exception classes for different error conditions::"
msgstr ""
" , . "
" . "
" , , "
" ::"
#: ../Doc/tutorial/errors.rst:317
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to "
"the naming of the standard exceptions."
msgstr " , \"Error\" ."
#: ../Doc/tutorial/errors.rst:320
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` ."
#: ../Doc/tutorial/errors.rst:328
msgid "Defining Clean-up Actions"
msgstr " "
#: ../Doc/tutorial/errors.rst:330
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` "
". ::"
#: ../Doc/tutorial/errors.rst:344
msgid ""
"A *finally clause* is always executed before leaving the :keyword:`try` "
"statement, whether an exception has occurred or not. When an exception "
"has occurred in the :keyword:`!try` clause and has not been handled by an"
" :keyword:`except` clause (or it has occurred in an :keyword:`!except` or"
" :keyword:`!else` clause), it is re-raised after the :keyword:`finally` "
"clause has been executed. The :keyword:`!finally` clause is also "
"executed \"on the way out\" when any other clause of the :keyword:`!try` "
"statement is left via a :keyword:`break`, :keyword:`continue` or "
":keyword:`return` statement. A more complicated example::"
msgstr ""
"*finally * :keyword:`try` . "
":keyword:`!try` :keyword:`except` ( "
":keyword:`!except` :keyword:`!else` ), :keyword:`finally` "
" . :keyword:`!finally` :keyword:`!try` "
":keyword:`break`, :keyword:`continue`, :keyword:`return` \" "
"\" . ::"
#: ../Doc/tutorial/errors.rst:377
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` "
" ."
#: ../Doc/tutorial/errors.rst:382
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` , , "
" ( )."
#: ../Doc/tutorial/errors.rst:390
msgid "Predefined Clean-up Actions"
msgstr " "
#: ../Doc/tutorial/errors.rst:392
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 ""
" . "
". . ::"
#: ../Doc/tutorial/errors.rst:400
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` "
" . ::"
#: ../Doc/tutorial/errors.rst:410
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* . , "
" ."