# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, 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 <flowdas@gmail.com>\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 \"<stdin>\", line 1\n"

" while True print('Hello world')\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> while True print('Hello world')\n"

" File \"<stdin>\", 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 (``<stdin>`` in our example) and line number are printed so"

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

msgstr "파일 이름(우리 예에서는 ``<stdin>``)과 줄 번호가 인쇄되어서, 입력이 파일로부터 올 때 찾을 수 있도록 합니다."

#: ../../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 \"<stdin>\", line 1, in <module>\n"

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\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 \"<stdin>\", line 1, in <module>\n"

" 10 * (1/0)\n"

" ~^~\n"

"ZeroDivisionError: division by zero\n"

">>> 4 + spam*3\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" 4 + spam*3\n"

" ^^^^\n"

"NameError: name 'spam' is not defined\n"

">>> '2' + 2\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\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"

"<class 'Exception'>\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"

"<class 'Exception'>\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 \"<stdin>\", line 1, in <module>\n"

" raise NameError('HiThere')\n"

"NameError: HiThere"

msgstr ""

">>> raise NameError('HiThere')\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 4, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 4, in <module>\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<raise>` "

"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 \"<stdin>\", line 2, in <module>\n"

" func()\n"

" ~~~~^^\n"

" File \"<stdin>\", 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 \"<stdin>\", line 4, in <module>\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 \"<stdin>\", line 2, in <module>\n"

" func()\n"

" ~~~~^^\n"

" File \"<stdin>\", 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 \"<stdin>\", line 4, in <module>\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 \"<stdin>\", line 4, in <module>\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 \"<stdin>\", line 4, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 2, in <module>\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 \"<stdin>\", line 1, in <module>\n"

" divide(\"2\", \"1\")\n"

" ~~~~~~^^^^^^^^^^\n"

" File \"<stdin>\", 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 \"<stdin>\", line 1, in <module>\n"

" divide(\"2\", \"1\")\n"

" ~~~~~~^^^^^^^^^^\n"

" File \"<stdin>\", 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