# 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"

#: ../../reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr "복합문(Compound statements)"

#: ../../reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general,"

" compound statements span multiple lines, although in simple incarnations"

" a whole compound statement may be contained in one line."

msgstr ""

"복합문은 다른 문장들(의 그룹들)을 포함합니다; 어떤 방법으로 그 다른 문장들의 실행에 영향을 주거나 제어합니다. 간단하게 표현할 "

"때, 전체 복합문을 한 줄로 쓸 수 있기는 하지만, 일반적으로 복합문은 여러 줄에 걸칩니다."

#: ../../reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements "

"implement traditional control flow constructs. :keyword:`try` specifies "

"exception handlers and/or cleanup code for a group of statements, while "

"the :keyword:`with` statement allows the execution of initialization and "

"finalization code around a block of code. Function and class definitions"

" are also syntactically compound statements."

msgstr ""

":keyword:`if`, :keyword:`while`, :keyword:`for` 문장은 전통적인 제어 흐름 구조를 구현합니다."

" 문장들의 그룹에 대해 :keyword:`try` 는 예외 처리기나 정리(cleanup) 코드 또는 그 둘 모두를 지정하는 반면, "

":keyword:`with` 문은 코드 블록 주변으로 초기화와 파이널리제이션 코드를 실행할 수 있도록 합니다. 함수와 클래스 정의 "

"또한 문법적으로 복합문입니다."

#: ../../reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause "

"consists of a header and a 'suite.' The clause headers of a particular "

"compound statement are all at the same indentation level. Each clause "

"header begins with a uniquely identifying keyword and ends with a colon."

" A suite is a group of statements controlled by a clause. A suite can "

"be one or more semicolon-separated simple statements on the same line as "

"the header, following the header's colon, or it can be one or more "

"indented statements on subsequent lines. Only the latter form of a suite"

" can contain nested compound statements; the following is illegal, mostly"

" because it wouldn't be clear to which :keyword:`if` clause a following "

":keyword:`else` clause would belong::"

msgstr ""

"복합문은 하나나 그 이상의 '절'로 구성됩니다. 절은 헤더와 '스위트(suite)'로 구성됩니다. 특정 복합문의 절 헤더들은 모두 "

"같은 들여쓰기 수준을 갖습니다. 각 절 헤더는 특별하게 식별되는 키워드로 시작하고 콜론으로 끝납니다. 스위트는 절에 의해 제어되는 "

"문장들의 그룹입니다. 스위트는 헤더의 콜론 뒤에서 같은 줄에 세미콜론으로 분리된 하나나 그 이상의 단순문일 수 있습니다. 또는 "

"그다음 줄에 들여쓰기 된 하나나 그 이상의 문장들일 수도 있습니다. 오직 후자의 형태만 중첩된 복합문을 포함할 수 있습니다; 다음과"

" 같은 것은 올바르지 않은데, 대체로 뒤따르는 :keyword:`else` 절이 있다면 어떤 :keyword:`if` 절에 속하는지"

" 명확하지 않기 때문입니다."

#: ../../reference/compound_stmts.rst:37

msgid "if test1: if test2: print(x)"

msgstr ""

#: ../../reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this "

"context, so that in the following example, either all or none of the "

":func:`print` calls are executed::"

msgstr ""

"또한, 이 문맥에서 세미콜론이 콜론보다 더 강하게 결합해서, 다음과 같은 예에서, :func:`print` 호출들은 모두 실행되거나"

" 어느 하나도 실행되지 않습니다는 것에 주의해야 합니다::"

#: ../../reference/compound_stmts.rst:43

msgid "if x < y < z: print(x); print(y); print(z)"

msgstr ""

#: ../../reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr "요약하면:"

#: ../../reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin "

"with a keyword that cannot start a statement, thus there are no "

"ambiguities (the 'dangling :keyword:`else`' problem is solved in Python "

"by requiring nested :keyword:`if` statements to be indented)."

msgstr ""

"문장들이 항상 ``NEWLINE`` 으로 끝나고 ``DEDENT`` 가 그 뒤를 따를 수 있음에 주목해야 합니다. 또한, 생략 "

"가능한 연결 절들이 항상 문장을 시작시킬 수 없는 키워드로 시작하기 때문에, 모호함이 없다는 것도 주목하세요 (파이썬에서는 중첩된 "

":keyword:`if` 문이 들여쓰기 되는 것을 요구함으로써 '매달린(dangling) :keyword:`else`' 문제를 "

"해결합니다)."

#: ../../reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each"

" clause on a separate line for clarity."

msgstr "명확함을 위해 다음에 오는 절들에서 나오는 문법 규칙들은 각 절을 별도의 줄에 놓도록 포매팅합니다."

#: ../../reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr ":keyword:`!if` 문"

#: ../../reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr ":keyword:`if` 문은 조건부 실행에 사용됩니다:"

#: ../../reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by"

" one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if "

"present, is executed."

msgstr ""

"참이 되는 것을 발견할 때까지 표현식들의 값을 하나씩 차례대로 구해서 정확히 하나의 스위트를 선택합니다 (참과 거짓의 정의는 "

":ref:`booleans` 섹션을 보세요); 그런 다음 그 스위트를 실행합니다 (그리고는 :keyword:`if` 문의 다른 어떤"

" 부분도 실행되거나 값이 구해지지 않습니다). 모든 표현식들이 거짓이면 :keyword:`else` 절의 스위트가 (있다면) "

"실행됩니다."

#: ../../reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr ":keyword:`!while` 문"

#: ../../reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as "

"an expression is true:"

msgstr ":keyword:`while` 문은 표현식이 참인 동안 실행을 반복하는 데 사용됩니다:"

#: ../../reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the "

"first suite; if the expression is false (which may be the first time it "

"is tested) the suite of the :keyword:`!else` clause, if present, is "

"executed and the loop terminates."

msgstr ""

"이것은 표현식을 반복적으로 검사하고, 참이면, 첫 번째 스위트를 실행합니다; 표현식이 거짓이면 (처음부터 거짓일 수도 있습니다) "

":keyword:`!else` 절의 스위트가 (있다면) 실행되고 루프를 종료합니다."

#: ../../reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the "

"loop without executing the :keyword:`!else` clause's suite. A "

":keyword:`continue` statement executed in the first suite skips the rest "

"of the suite and goes back to testing the expression."

msgstr ""

"첫 번째 스위트에서 실행되는 :keyword:`break` 문은 :keyword:`!else` 절을 실행하지 않고 루프를 "

"종료합니다. 첫 번째 스위트에서 실행되는 :keyword:`continue` 문은 스위트의 나머지 부분을 건너뛰고 표현식의 검사로 "

"돌아갑니다."

#: ../../reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr ":keyword:`!for` 문"

#: ../../reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ":keyword:`for` 문은 (문자열, 튜플, 리스트 같은) 시퀀스 나 다른 이터러블 객체의 요소들을 이터레이트하는데 사용됩니다:"

#: ../../reference/compound_stmts.rst:160

#, fuzzy

msgid ""

"The :token:`~python-grammar:starred_expression_list` expression is "

"evaluated once; it should yield an :term:`iterable` object. An "

":term:`iterator` is created for that iterable. The first item provided by"

" the iterator is then assigned to the target list using the standard "

"rules for assignments (see :ref:`assignment`), and the suite is executed."

" This repeats for each item provided by the iterator. When the iterator "

"is exhausted, the suite in the :keyword:`!else` clause, if present, is "

"executed, and the loop terminates."

msgstr ""

"표현식 목록은 한 번만 값이 구해집니다; 이터러블 객체가 나와야 합니다. ``expression_list`` 의 결과로 이터레이터가"

" 만들어집니다. 그런 다음 이터레이터가 제공하는 항목마다, 이터레이터가 돌려주는 순서대로, 스위트가 한 번씩 실행됩니다. 순환마다 "

"각 항목이 대입의 표준 규칙 (:ref:`assignment` 을 보세요) 으로 타깃 목록에 대입된 다음, 스위트가 실행됩니다. "

"항목들이 소진되었을 때 (이터레이터가 :exc:`StopIteration` 예외를 일으킬 때나 빈 시퀀스인 경우는 즉시 "

"발생합니다), the :keyword:`!else` 절의 스위트가 (있다면) 실행되고 루프를 종료합니다."

#: ../../reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the "

"loop without executing the :keyword:`!else` clause's suite. A "

":keyword:`continue` statement executed in the first suite skips the rest "

"of the suite and continues with the next item, or with the "

":keyword:`!else` clause if there is no next item."

msgstr ""

"첫 번째 스위트에서 실행되는 :keyword:`break` 문은 :keyword:`!else` 절을 실행하지 않고 루프를 "

"종료합니다. 첫 번째 스위트에서 실행되는 :keyword:`continue` 문은 스위트의 나머지 부분을 건너뛰고 다음 항목으로 "

"넘어가거나, 다음 항목이 없으면 :keyword:`!else` 절로 갑니다."

#: ../../reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those "

"made in the suite of the for-loop::"

msgstr ""

"for-루프는 타깃 목록의 변수들에 대입합니다. for-루프의 스위트에서 이루어진 것들도 포함해서, 그 변수에 앞서 대입된 값들을 "

"모두 덮어씁니다::"

#: ../../reference/compound_stmts.rst:183

msgid ""

"for i in range(10):\n"

" print(i)\n"

" i = 5 # this will not affect the for-loop\n"

" # because i will be overwritten with the next\n"

" # index in the range"

msgstr ""

#: ../../reference/compound_stmts.rst:193

#, fuzzy

msgid ""

"Names in the target list are not deleted when the loop is finished, but "

"if the sequence is empty, they will not have been assigned to at all by "

"the loop. Hint: the built-in type :func:`range` represents immutable "

"arithmetic sequences of integers. For instance, iterating ``range(3)`` "

"successively yields 0, 1, and then 2."

msgstr ""

"타깃 목록의 이름들은 루프가 종료될 때 삭제되지 않지만, 시퀀스가 비어있다면, 루프에 의해 전혀 대입이 일어나지 않을 수도 "

"있습니다. 힌트: 내장 함수 :func:`range` 는 파스칼의 ``for i := a to b do`` 의 효과를 흉내 내는데 "

"적합한 정수의 이터레이터를 돌려줍니다; 예를 들어, ``list(range(3))`` 는 리스트 ``[0, 1, 2]`` 를 "

"돌려줍니다."

#: ../../reference/compound_stmts.rst:198

msgid "Starred elements are now allowed in the expression list."

msgstr ""

#: ../../reference/compound_stmts.rst:205

msgid "The :keyword:`!try` statement"

msgstr ":keyword:`!try` 문"

#: ../../reference/compound_stmts.rst:215

#, fuzzy

msgid ""

"The :keyword:`!try` statement specifies exception handlers and/or cleanup"

" code for a group of statements:"

msgstr ""

":keyword:`try` 문은 문장 그룹에 대한 예외 처리기나 정리(cleanup) 코드 또는 그 둘 모두를 지정하는 데 "

"사용됩니다."

#: ../../reference/compound_stmts.rst:231

msgid ""

"Additional information on exceptions can be found in section "

":ref:`exceptions`, and information on using the :keyword:`raise` "

"statement to generate exceptions may be found in section :ref:`raise`."

msgstr ""

"예외에 관한 추가의 정보는 :ref:`exceptions` 섹션에서 찾을 수 있고, 예외를 일으키기 위해 "

":keyword:`raise` 문을 사용하는 것에 관한 정보는 :ref:`raise` 섹션에서 찾을 수 있습니다."

#: ../../reference/compound_stmts.rst:235

msgid ""

"Support for optionally dropping grouping parentheses when using multiple "

"exception types. See :pep:`758`."

msgstr ""

#: ../../reference/compound_stmts.rst:241

msgid ":keyword:`!except` clause"

msgstr ""

#: ../../reference/compound_stmts.rst:243

#, fuzzy

msgid ""

"The :keyword:`!except` clause(s) specify one or more exception handlers. "

"When no exception occurs in the :keyword:`try` clause, no exception "

"handler is executed. When an exception occurs in the :keyword:`!try` "

"suite, a search for an exception handler is started. This search inspects"

" the :keyword:`!except` clauses in turn until one is found that matches "

"the exception. An expression-less :keyword:`!except` clause, if present, "

"must be last; it matches any exception."

msgstr ""

":keyword:`except` 절(들)은 하나나 그 이상의 예외 처리기를 지정합니다. :keyword:`try` 절에서 예외가 "

"발생하지 않으면 아무런 예외 처리기도 실행되지 않습니다. :keyword:`!try` 스위트에서 예외가 발생할 때, 예외 처리기 "

"검색이 시작됩니다. 이 검색은 그 예외에 매치되는 것을 발견할 때까지 except 절을 차례대로 들여다봅니다. 표현식이 없는 "

"except 절이 있다면 가장 마지막에 와야 합니다; 모든 예외와 매치됩니다. 표현식이 있는 except 절의 경우, 표현식의 값을"

" 구하고, 결과 객체가 예외와 \"호환\" 되면 그 절이 예외에 매치됩니다. 객체는 예외 객체의 클래스나 베이스 클래스일 때, 또는"

" 예외 객체의 클래스나 베이스 클래스인 항목을 포함한 튜플일 때 예외와 호환됩니다."

#: ../../reference/compound_stmts.rst:251

msgid ""

"For an :keyword:`!except` clause with an expression, the expression must "

"evaluate to an exception type or a tuple of exception types. Parentheses "

"can be dropped if multiple exception types are provided and the ``as`` "

"clause is not used. The raised exception matches an :keyword:`!except` "

"clause whose expression evaluates to the class or a :term:`non-virtual "

"base class <abstract base class>` of the exception object, or to a tuple "

"that contains such a class."

msgstr ""

#: ../../reference/compound_stmts.rst:258

#, fuzzy

msgid ""

"If no :keyword:`!except` clause matches the exception, the search for an "

"exception handler continues in the surrounding code and on the invocation"

" stack. [#]_"

msgstr "except 절 중 어느 것도 예외와 매치되지 않으면, 예외 처리기 검색은 둘러싼 코드와 호출 스택에서 계속됩니다. [#]_"

#: ../../reference/compound_stmts.rst:262

#, fuzzy

msgid ""

"If the evaluation of an expression in the header of an :keyword:`!except`"

" clause raises an exception, the original search for a handler is "

"canceled and a search starts for the new exception in the surrounding "

"code and on the call stack (it is treated as if the entire :keyword:`try`"

" statement raised the exception)."

msgstr ""

"만약 except 절의 헤더에 있는 표현식의 값을 구할 때 예외가 발생하면, 원래의 처리기 검색은 취소되고 둘러싼 코드와 호출 "

"스택에서 새 예외에 대해 검사가 시작됩니다 (:keyword:`try` 문 전체가 예외를 일으킨 것으로 취급됩니다)."

#: ../../reference/compound_stmts.rst:270

#, fuzzy

msgid ""

"When a matching :keyword:`!except` clause is found, the exception is "

"assigned to the target specified after the :keyword:`!as` keyword in that"

" :keyword:`!except` clause, if present, and the :keyword:`!except` "

"clause's suite is executed. All :keyword:`!except` clauses must have an "

"executable block. When the end of this block is reached, execution "

"continues normally after the entire :keyword:`try` statement. (This means"

" that if two nested handlers exist for the same exception, and the "

"exception occurs in the :keyword:`!try` clause of the inner handler, the "

"outer handler will not handle the exception.)"

msgstr ""

"매치되는 except 절이 발견되면, 예외는 그 except 절에 있는 :keyword:`!as` 키워드 (가 있다면) 뒤에 지정된"

" 타깃에 대입되고, except 절의 스위트가 실행됩니다. 모든 except 절은 실행 가능한 블록을 가져야 합니다. 블록의 끝에 "

"도달하면, try 문 전체의 뒤에서 일반적인 실행이 계속됩니다. (이것은 같은 예외에 대해 두 개의 중첩된 처리기가 있고, 예외가 "

"안쪽 처리기의 try 절에서 발생했다면, 바깥 처리기는 예외를 처리하지 않게 된다는 뜻이 됩니다.)"

#: ../../reference/compound_stmts.rst:281

#, fuzzy

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at"

" the end of the :keyword:`!except` clause. This is as if ::"

msgstr "예외가 ``as target`` 을 사용해서 대입될 때, except 절 끝에서 삭제됩니다. 이것은 마치 ::"

#: ../../reference/compound_stmts.rst:284

msgid ""

"except E as N:\n"

" foo"

msgstr ""

#: ../../reference/compound_stmts.rst:287

msgid "was translated to ::"

msgstr "가 이렇게 변환되는 것과 같습니다 ::"

#: ../../reference/compound_stmts.rst:289

msgid ""

"except E as N:\n"

" try:\n"

" foo\n"

" finally:\n"

" del N"

msgstr ""

#: ../../reference/compound_stmts.rst:295

#, fuzzy

msgid ""

"This means the exception must be assigned to a different name to be able "

"to refer to it after the :keyword:`!except` clause. Exceptions are "

"cleared because with the traceback attached to them, they form a "

"reference cycle with the stack frame, keeping all locals in that frame "

"alive until the next garbage collection occurs."

msgstr ""

"이것은 except 절 후에 참조하려면 예외를 다른 이름에 대입해야 한다는 뜻입니다. 예외를 제거하는 이유는, 그것에 첨부된 "

"트레이스백으로 인해, 스택 프레임과 참조 순환을 형성해서 다음 가비지 수거가 일어나기 전까지 그 프레임의 모든 지역 변수들을 "

"잡아두기 때문입니다."

#: ../../reference/compound_stmts.rst:305

msgid ""

"Before an :keyword:`!except` clause's suite is executed, the exception is"

" stored in the :mod:`sys` module, where it can be accessed from within "

"the body of the :keyword:`!except` clause by calling "

":func:`sys.exception`. When leaving an exception handler, the exception "

"stored in the :mod:`sys` module is reset to its previous value::"

msgstr ""

#: ../../reference/compound_stmts.rst:311

msgid ""

">>> print(sys.exception())\n"

"None\n"

">>> try:\n"

"... raise TypeError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... try:\n"

"... raise ValueError\n"

"... except:\n"

"... print(repr(sys.exception()))\n"

"... print(repr(sys.exception()))\n"

"...\n"

"TypeError()\n"

"ValueError()\n"

"TypeError()\n"

">>> print(sys.exception())\n"

"None"

msgstr ""

#: ../../reference/compound_stmts.rst:336

msgid ":keyword:`!except*` clause"

msgstr ""

#: ../../reference/compound_stmts.rst:338

msgid ""

"The :keyword:`!except*` clause(s) specify one or more handlers for groups"

" of exceptions (:exc:`BaseExceptionGroup` instances). A :keyword:`try` "

"statement can have either :keyword:`except` or :keyword:`!except*` "

"clauses, but not both. The exception type for matching is mandatory in "

"the case of :keyword:`!except*`, so ``except*:`` is a syntax error. The "

"type is interpreted as in the case of :keyword:`!except`, but matching is"

" performed on the exceptions contained in the group that is being "

"handled. An :exc:`TypeError` is raised if a matching type is a subclass "

"of :exc:`!BaseExceptionGroup`, because that would have ambiguous "

"semantics."

msgstr ""

#: ../../reference/compound_stmts.rst:348

msgid ""

"When an exception group is raised in the try block, each "

":keyword:`!except*` clause splits (see :meth:`~BaseExceptionGroup.split`)"

" it into the subgroups of matching and non-matching exceptions. If the "

"matching subgroup is not empty, it becomes the handled exception (the "

"value returned from :func:`sys.exception`) and assigned to the target of "

"the :keyword:`!except*` clause (if there is one). Then, the body of the "

":keyword:`!except*` clause executes. If the non-matching subgroup is not "

"empty, it is processed by the next :keyword:`!except*` in the same "

"manner. This continues until all exceptions in the group have been "

"matched, or the last :keyword:`!except*` clause has run."

msgstr ""

#: ../../reference/compound_stmts.rst:358

msgid ""

"After all :keyword:`!except*` clauses execute, the group of unhandled "

"exceptions is merged with any exceptions that were raised or re-raised "

"from within :keyword:`!except*` clauses. This merged exception group "

"propagates on.::"

msgstr ""

#: ../../reference/compound_stmts.rst:362

#, python-brace-format

msgid ""

">>> try:\n"

"... raise ExceptionGroup(\"eg\",\n"

"... [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

"... except* TypeError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"... except* OSError as e:\n"

"... print(f'caught {type(e)} with nested {e.exceptions}')\n"

"...\n"

"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"

"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"

" + Exception Group Traceback (most recent call last):\n"

" | File \"<doctest default[0]>\", line 2, in <module>\n"

" | raise ExceptionGroup(\"eg\",\n"

" | [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"

" | ExceptionGroup: eg (1 sub-exception)\n"

" +-+---------------- 1 ----------------\n"

" | ValueError: 1\n"

" +------------------------------------"

msgstr ""

#: ../../reference/compound_stmts.rst:381

msgid ""

"If the exception raised from the :keyword:`try` block is not an exception"

" group and its type matches one of the :keyword:`!except*` clauses, it is"

" caught and wrapped by an exception group with an empty message string. "

"This ensures that the type of the target ``e`` is consistently "

":exc:`BaseExceptionGroup`::"

msgstr ""

#: ../../reference/compound_stmts.rst:386

msgid ""

">>> try:\n"

"... raise BlockingIOError\n"

"... except* BlockingIOError as e:\n"

"... print(repr(e))\n"

"...\n"

"ExceptionGroup('', (BlockingIOError()))"

msgstr ""

#: ../../reference/compound_stmts.rst:393

msgid ""

":keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear"

" in an :keyword:`!except*` clause."

msgstr ""

#: ../../reference/compound_stmts.rst:406

#, fuzzy

msgid ":keyword:`!else` clause"

msgstr ":keyword:`!while` 문"

#: ../../reference/compound_stmts.rst:408

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow "

"leaves the :keyword:`try` suite, no exception was raised, and no "

":keyword:`return`, :keyword:`continue`, or :keyword:`break` statement was"

" executed. Exceptions in the :keyword:`!else` clause are not handled by "

"the preceding :keyword:`except` clauses."

msgstr ""

"생략 가능한 :keyword:`!else` 절은 제어 흐름이 :keyword:`try` 스위트를 빠져나가고, 예외가 발생하지 "

"않았고, :keyword:`return`, :keyword:`continue` 또는 :keyword:`break` 문이 실행되지 "

"않으면 실행됩니다. :keyword:`!else` 절에서 발생하는 예외는 앞에 나오는 :keyword:`except` 절에서 "

"처리되지 않습니다."

#: ../../reference/compound_stmts.rst:420

msgid ":keyword:`!finally` clause"

msgstr ""

#: ../../reference/compound_stmts.rst:422

#, fuzzy

msgid ""

"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The"

" :keyword:`try` clause is executed, including any :keyword:`except` and "

":keyword:`else <except_else>` clauses. If an exception occurs in any of "

"the clauses and is not handled, the exception is temporarily saved. The "

":keyword:`!finally` clause is executed. If there is a saved exception it"

" is re-raised at the end of the :keyword:`!finally` clause. If the "

":keyword:`!finally` clause raises another exception, the saved exception "

"is set as the context of the new exception. If the :keyword:`!finally` "

"clause executes a :keyword:`return`, :keyword:`break` or "

":keyword:`continue` statement, the saved exception is discarded. For "

"example, this function returns 42."

msgstr ""

":keyword:`finally` 가 있으면, '정리(cleanup)' 처리기를 지정합니다. :keyword:`except` 와 "

":keyword:`!else` 절을 포함해서, 먼저 :keyword:`try` 절이 실행됩니다. 이 절들의 어디에서건 예외가 "

"일어나면, 예외는 임시 저장됩니다. :keyword:`!finally` 절이 실행됩니다. 만약 저장된 예외가 있으면, "

":keyword:`!finally` 절의 끝에서 다시 발생시킨다. :keyword:`!finally` 절이 다른 예외를 일으키면, "

"저장된 예외는 새 예외의 컨텍스트(context) 로 설정됩니다. :keyword:`!finally` 절이 "

":keyword:`return`, :keyword:`break` 또는 :keyword:`continue` 문을 실행하면, 저장된 "

"예외는 버립니다."

#: ../../reference/compound_stmts.rst:435

msgid ""

"def f():\n"

" try:\n"

" 1/0\n"

" finally:\n"

" return 42"

msgstr ""

#: ../../reference/compound_stmts.rst:443

#, fuzzy

msgid ""

"The exception information is not available to the program during "

"execution of the :keyword:`!finally` clause."

msgstr ":keyword:`finally` 절을 실행하는 동안 예외 정보는 프로그램에 제공되지 않습니다."

#: ../../reference/compound_stmts.rst:451

#, fuzzy

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` "

"statement is executed in the :keyword:`try` suite of a "

":keyword:`!try`...\\ :keyword:`!finally` statement, the "

":keyword:`!finally` clause is also executed 'on the way out.'"

msgstr ""

":keyword:`!try`...\\ :keyword:`!finally` 문의 :keyword:`try` 스위트에서 "

":keyword:`return`, :keyword:`break`, :keyword:`continue` 문이 실행될 때, "

":keyword:`finally` 절도 '나가는 길에' 실행됩니다."

#: ../../reference/compound_stmts.rst:455

#, fuzzy

msgid ""

"The return value of a function is determined by the last "

":keyword:`return` statement executed. Since the :keyword:`!finally` "

"clause always executes, a :keyword:`!return` statement executed in the "

":keyword:`!finally` clause will always be the last one executed. The "

"following function returns 'finally'."

msgstr ""

"함수의 반환 값은 마지막에 실행된 :keyword:`return` 문으로 결정됩니다. :keyword:`finally` 절이 항상 "

"실행되기 때문에, :keyword:`!finally` 절에서 실행되는 :keyword:`!return` 문이 항상 마지막에 실행되는"

" 것이 됩니다::"

#: ../../reference/compound_stmts.rst:460

msgid ""

"def foo():\n"

" try:\n"

" return 'try'\n"

" finally:\n"

" return 'finally'"

msgstr ""

#: ../../reference/compound_stmts.rst:468

#, fuzzy

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the "

":keyword:`!finally` clause due to a problem with the implementation."

msgstr ""

"파이썬 3.8 이전에는, :keyword:`continue` 문이 구현 문제로 인해 :keyword:`finally` 절에서 "

"유효하지 않았습니다."

#: ../../reference/compound_stmts.rst:472

msgid ""

"The compiler emits a :exc:`SyntaxWarning` when a :keyword:`return`, "

":keyword:`break` or :keyword:`continue` appears in a :keyword:`!finally` "

"block (see :pep:`765`)."

msgstr ""

#: ../../reference/compound_stmts.rst:482

msgid "The :keyword:`!with` statement"

msgstr ":keyword:`!with` 문"

#: ../../reference/compound_stmts.rst:491

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block "

"with methods defined by a context manager (see section :ref:`context-"

"managers`). This allows common :keyword:`try`...\\ :keyword:`except`...\\"

" :keyword:`finally` usage patterns to be encapsulated for convenient "

"reuse."

msgstr ""

":keyword:`with` 문은 블록의 실행을 컨텍스트 관리자 (:ref:`context-managers` 섹션을 보세요) 가 "

"정의한 메서드들로 감싸는 데 사용됩니다. 이것은 흔한 :keyword:`try`...\\ :keyword:`except`...\\ "

":keyword:`finally` 사용 패턴을 편리하게 재사용할 수 있도록 캡슐화할 수 있도록 합니다."

#: ../../reference/compound_stmts.rst:501

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds"

" as follows:"

msgstr "하나의 \"item\" 을 사용하는 :keyword:`with` 문의 실행은 다음과 같이 진행됩니다:"

#: ../../reference/compound_stmts.rst:503

#, fuzzy

msgid ""

"The context expression (the expression given in the :token:`~python-"

"grammar:with_item`) is evaluated to obtain a context manager."

msgstr "컨텍스트 관리자를 얻기 위해 컨텍스트 표현식 (:token:`with_item` 에 주어진 expression) 의 값을 구합니다."

#: ../../reference/compound_stmts.rst:506

#, fuzzy

msgid "The context manager's :meth:`~object.__enter__` is loaded for later use."

msgstr "나중에 사용하기 위해 컨텍스트 관리자의 :meth:`__enter__` 가 로드됩니다."

#: ../../reference/compound_stmts.rst:508

#, fuzzy

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."

msgstr "나중에 사용하기 위해 컨텍스트 관리자의 :meth:`__exit__` 가 로드됩니다."

#: ../../reference/compound_stmts.rst:510

#, fuzzy

msgid "The context manager's :meth:`~object.__enter__` method is invoked."

msgstr "컨텍스트 관리자의 :meth:`__enter__` 메서드를 호출합니다."

#: ../../reference/compound_stmts.rst:512

#, fuzzy

msgid ""

"If a target was included in the :keyword:`with` statement, the return "

"value from :meth:`~object.__enter__` is assigned to it."

msgstr ":keyword:`with` 문에 타깃이 포함되었으면, 그것에 :meth:`__enter__` 의 반환 값을 대입합니다."

#: ../../reference/compound_stmts.rst:517

#, fuzzy

msgid ""

"The :keyword:`with` statement guarantees that if the "

":meth:`~object.__enter__` method returns without an error, then "

":meth:`~object.__exit__` will always be called. Thus, if an error occurs "

"during the assignment to the target list, it will be treated the same as "

"an error occurring within the suite would be. See step 7 below."

msgstr ""

":keyword:`with` 문은 :meth:`__enter__` 메서드가 에러 없이 돌아왔을 때, :meth:`__exit__` "

"가 항상 호출됨을 보장합니다. 그래서, 타깃에 대입하는 동안 에러가 발생하면, 스위트 안에서 에러가 발생한 것과 같이 취급됩니다. "

"아래의 6단계를 보세요."

#: ../../reference/compound_stmts.rst:523

msgid "The suite is executed."

msgstr "스위트가 실행됩니다."

#: ../../reference/compound_stmts.rst:525

#, fuzzy

msgid ""

"The context manager's :meth:`~object.__exit__` method is invoked. If an "

"exception caused the suite to be exited, its type, value, and traceback "

"are passed as arguments to :meth:`~object.__exit__`. Otherwise, three "

":const:`None` arguments are supplied."

msgstr ""

"컨텍스트 관리자의 :meth:`__exit__` 메서드를 호출합니다. 예외가 스위트를 종료되도록 만들었다면, 그것의 형, 값, "

"트레이스백이 :meth:`__exit__` 의 인자로 전달됩니다. 그렇지 않으면 세 개의 :const:`None` 이 인자로 "

"공급됩니다."

#: ../../reference/compound_stmts.rst:530

#, fuzzy

msgid ""

"If the suite was exited due to an exception, and the return value from "

"the :meth:`~object.__exit__` method was false, the exception is reraised."

" If the return value was true, the exception is suppressed, and "

"execution continues with the statement following the :keyword:`with` "

"statement."

msgstr ""

"스위트가 예외 때문에 종료되었고, :meth:`__exit__` 메서드의 반환 값이 거짓이면, 그 예외를 다시 일으킨다. 반환 값이"

" 참이면, 예외를 억누르고, :keyword:`with` 문 뒤에 오는 문장으로 실행을 계속합니다. "

#: ../../reference/compound_stmts.rst:535

#, fuzzy

msgid ""

"If the suite was exited for any reason other than an exception, the "

"return value from :meth:`~object.__exit__` is ignored, and execution "

"proceeds at the normal location for the kind of exit that was taken."

msgstr ""

"스위트가 예외 이외의 이유로 종료되면, :meth:`__exit__` 의 반환 값은 무시되고, 해당 종료의 종류에 맞는 위치에서 "

"실행을 계속합니다."

#: ../../reference/compound_stmts.rst:539

#: ../../reference/compound_stmts.rst:1557

#: ../../reference/compound_stmts.rst:1598

msgid "The following code::"

msgstr "다음과 같은 코드는::"

#: ../../reference/compound_stmts.rst:541

msgid ""

"with EXPRESSION as TARGET:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:544

#: ../../reference/compound_stmts.rst:569

#: ../../reference/compound_stmts.rst:1603

msgid "is semantically equivalent to::"

msgstr "의미상으로 다음과 동등합니다::"

#: ../../reference/compound_stmts.rst:546

msgid ""

"manager = (EXPRESSION)\n"

"enter = type(manager).__enter__\n"

"exit = type(manager).__exit__\n"

"value = enter(manager)\n"

"hit_except = False\n"

"\n"

"try:\n"

" TARGET = value\n"

" SUITE\n"

"except:\n"

" hit_except = True\n"

" if not exit(manager, *sys.exc_info()):\n"

" raise\n"

"finally:\n"

" if not hit_except:\n"

" exit(manager, None, None, None)"

msgstr ""

#: ../../reference/compound_stmts.rst:563

msgid ""

"With more than one item, the context managers are processed as if "

"multiple :keyword:`with` statements were nested::"

msgstr "하나 보다 많은 항목을 주면, 컨텍스트 관리자는 :keyword:`with` 문이 중첩된 것처럼 진행합니다::"

#: ../../reference/compound_stmts.rst:566

msgid ""

"with A() as a, B() as b:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:571

msgid ""

"with A() as a:\n"

" with B() as b:\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:575

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

#: ../../reference/compound_stmts.rst:578

msgid ""

"with (\n"

" A() as a,\n"

" B() as b,\n"

"):\n"

" SUITE"

msgstr ""

#: ../../reference/compound_stmts.rst:584

msgid "Support for multiple context expressions."

msgstr "다중 컨텍스트 표현식의 지원"

#: ../../reference/compound_stmts.rst:587

msgid ""

"Support for using grouping parentheses to break the statement in multiple"

" lines."

msgstr ""

#: ../../reference/compound_stmts.rst:592

msgid ":pep:`343` - The \"with\" statement"

msgstr ":pep:`343` - \"with\" 문"

#: ../../reference/compound_stmts.rst:593

msgid ""

"The specification, background, and examples for the Python "

":keyword:`with` statement."

msgstr "파이썬 :keyword:`with` 문의 규격, 배경, 예."

#: ../../reference/compound_stmts.rst:600

#, fuzzy

msgid "The :keyword:`!match` statement"

msgstr ":keyword:`!with` 문"

#: ../../reference/compound_stmts.rst:614

msgid "The match statement is used for pattern matching. Syntax:"

msgstr ""

#: ../../reference/compound_stmts.rst:623

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

#: ../../reference/compound_stmts.rst:626

msgid ""

"Pattern matching takes a pattern as input (following ``case``) and a "

"subject value (following ``match``). The pattern (which may contain "

"subpatterns) is matched against the subject value. The outcomes are:"

msgstr ""

#: ../../reference/compound_stmts.rst:630

msgid "A match success or failure (also termed a pattern success or failure)."

msgstr ""

#: ../../reference/compound_stmts.rst:632

msgid ""

"Possible binding of matched values to a name. The prerequisites for this"

" are further discussed below."

msgstr ""

#: ../../reference/compound_stmts.rst:635

msgid ""

"The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

#: ../../reference/compound_stmts.rst:639

#: ../../reference/compound_stmts.rst:1196

msgid ":pep:`634` -- Structural Pattern Matching: Specification"

msgstr ""

#: ../../reference/compound_stmts.rst:640

#: ../../reference/compound_stmts.rst:1197

msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"

msgstr ""

#: ../../reference/compound_stmts.rst:644

msgid "Overview"

msgstr ""

#: ../../reference/compound_stmts.rst:646

msgid "Here's an overview of the logical flow of a match statement:"

msgstr ""

#: ../../reference/compound_stmts.rst:649

msgid ""

"The subject expression ``subject_expr`` is evaluated and a resulting "

"subject value obtained. If the subject expression contains a comma, a "

"tuple is constructed using :ref:`the standard rules <typesseq-tuple>`."

msgstr ""

#: ../../reference/compound_stmts.rst:653

msgid ""

"Each pattern in a ``case_block`` is attempted to match with the subject "

"value. The specific rules for success or failure are described below. The"

" match attempt can also bind some or all of the standalone names within "

"the pattern. The precise pattern binding rules vary per pattern type and "

"are specified below. **Name bindings made during a successful pattern "

"match outlive the executed block and can be used after the match "

"statement**."

msgstr ""

#: ../../reference/compound_stmts.rst:662

msgid ""

"During failed pattern matches, some subpatterns may succeed. Do not rely"

" on bindings being made for a failed match. Conversely, do not rely on "

"variables remaining unchanged after a failed match. The exact behavior "

"is dependent on implementation and may vary. This is an intentional "

"decision made to allow different implementations to add optimizations."

msgstr ""

#: ../../reference/compound_stmts.rst:669

msgid ""

"If the pattern succeeds, the corresponding guard (if present) is "

"evaluated. In this case all name bindings are guaranteed to have "

"happened."

msgstr ""

#: ../../reference/compound_stmts.rst:672

msgid ""

"If the guard evaluates as true or is missing, the ``block`` inside "

"``case_block`` is executed."

msgstr ""

#: ../../reference/compound_stmts.rst:675

msgid "Otherwise, the next ``case_block`` is attempted as described above."

msgstr ""

#: ../../reference/compound_stmts.rst:677

msgid "If there are no further case blocks, the match statement is completed."

msgstr ""

#: ../../reference/compound_stmts.rst:681

msgid ""

"Users should generally never rely on a pattern being evaluated. "

"Depending on implementation, the interpreter may cache values or use "

"other optimizations which skip repeated evaluations."

msgstr ""

#: ../../reference/compound_stmts.rst:685

msgid "A sample match statement::"

msgstr ""

#: ../../reference/compound_stmts.rst:687

#, python-brace-format

msgid ""

">>> flag = False\n"

">>> match (100, 200):\n"

"... case (100, 300): # Mismatch: 200 != 300\n"

"... print('Case 1')\n"

"... case (100, 200) if flag: # Successful match, but guard fails\n"

"... print('Case 2')\n"

"... case (100, y): # Matches and binds y to 200\n"

"... print(f'Case 3, y: {y}')\n"

"... case _: # Pattern not attempted\n"

"... print('Case 4, I match anything!')\n"

"...\n"

"Case 3, y: 200"

msgstr ""

#: ../../reference/compound_stmts.rst:701

msgid ""

"In this case, ``if flag`` is a guard. Read more about that in the next "

"section."

msgstr ""

#: ../../reference/compound_stmts.rst:704

msgid "Guards"

msgstr ""

#: ../../reference/compound_stmts.rst:711

msgid ""

"A ``guard`` (which is part of the ``case``) must succeed for code inside "

"the ``case`` block to execute. It takes the form: :keyword:`if` followed"

" by an expression."

msgstr ""

#: ../../reference/compound_stmts.rst:716

msgid "The logical flow of a ``case`` block with a ``guard`` follows:"

msgstr ""

#: ../../reference/compound_stmts.rst:718

msgid ""

"Check that the pattern in the ``case`` block succeeded. If the pattern "

"failed, the ``guard`` is not evaluated and the next ``case`` block is "

"checked."

msgstr ""

#: ../../reference/compound_stmts.rst:722

msgid "If the pattern succeeded, evaluate the ``guard``."

msgstr ""

#: ../../reference/compound_stmts.rst:724

msgid "If the ``guard`` condition evaluates as true, the case block is selected."

msgstr ""

#: ../../reference/compound_stmts.rst:727

msgid ""

"If the ``guard`` condition evaluates as false, the case block is not "

"selected."

msgstr ""

#: ../../reference/compound_stmts.rst:730

msgid ""

"If the ``guard`` raises an exception during evaluation, the exception "

"bubbles up."

msgstr ""

#: ../../reference/compound_stmts.rst:733

msgid ""

"Guards are allowed to have side effects as they are expressions. Guard "

"evaluation must proceed from the first to the last case block, one at a "

"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., "

"guard evaluation must happen in order.) Guard evaluation must stop once a"

" case block is selected."

msgstr ""

#: ../../reference/compound_stmts.rst:743

msgid "Irrefutable Case Blocks"

msgstr ""

#: ../../reference/compound_stmts.rst:747

msgid ""

"An irrefutable case block is a match-all case block. A match statement "

"may have at most one irrefutable case block, and it must be last."

msgstr ""

#: ../../reference/compound_stmts.rst:750

msgid ""

"A case block is considered irrefutable if it has no guard and its pattern"

" is irrefutable. A pattern is considered irrefutable if we can prove "