# 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: 2018-12-25 10:27+0900\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.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* 는 항상 닫힙니다. 파일과 같이, 미리 정의된 뒷정리 "
"동작들을 제공하는 객체들은 그들의 설명서에서 이 사실을 설명합니다."