# 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/executionmodel.rst:6
msgid "Execution model"
msgstr "실행 모델"

#: ../../reference/executionmodel.rst:15
msgid "Structure of a program"
msgstr "프로그램의 구조"

#: ../../reference/executionmodel.rst:19
msgid ""
"A Python program is constructed from code blocks. A :dfn:`block` is a "
"piece of Python program text that is executed as a unit. The following "
"are blocks: a module, a function body, and a class definition. Each "
"command typed interactively is a block.  A script file (a file given as "
"standard input to the interpreter or specified as a command line argument"
" to the interpreter) is a code block.  A script command (a command "
"specified on the interpreter command line with the :option:`-c` option) "
"is a code block. A module run as a top level script (as module "
"``__main__``) from the command line using a :option:`-m` argument is also"
" a code block. The string argument passed to the built-in functions "
":func:`eval` and :func:`exec` is a code block."
msgstr ""
"파이썬 프로그램은 코드 블록으로 만들어집니다. :dfn:`블록 (block)` 은 한 단위로 실행되는 한 조각의 파이썬 프로그램 "
"텍스트입니다. 다음과 같은 것들이 블록입니다: 모듈, 함수 바디, 클래스 정의. 대화형으로 입력되는 각 명령은 블록입니다. 스크립트"
" 파일(표준 입력을 통해 인터프리터로 제공되는 파일이나 인터프리터에 명령행 인자로 지정된 파일)은 코드 블록입니다. 스크립트 "
"명령(:option:`-c` 옵션으로 인터프리터 명령행에 지정된 명령)은 코드 블록입니다. :option:`-m` 인자를 사용하여 "
"명령 줄에서 최상위 수준 스크립트로 (모듈 ``__main__``\\으로) 실행되는 모듈도 코드 블록입니다. 내장함수 "
":func:`eval` 과 :func:`exec` 로 전달되는 문자열 인자도 코드 블록입니다."

#: ../../reference/executionmodel.rst:33
msgid ""
"A code block is executed in an :dfn:`execution frame`.  A frame contains "
"some administrative information (used for debugging) and determines where"
" and how execution continues after the code block's execution has "
"completed."
msgstr ""
"코드 블록은 :dfn:`실행 프레임 (execution frame)` 에서 실행됩니다. 프레임은 몇몇 관리를 위한 정보(디버깅에 "
"사용됩니다)를 포함하고, 코드 블록의 실행이 끝난 후에 어디서 어떻게 실행을 계속할 것인지를 결정합니다."

#: ../../reference/executionmodel.rst:40
msgid "Naming and binding"
msgstr "이름과 연결(binding)"

#: ../../reference/executionmodel.rst:49
msgid "Binding of names"
msgstr "이름의 연결"

#: ../../reference/executionmodel.rst:55
msgid ""
":dfn:`Names` refer to objects.  Names are introduced by name binding "
"operations."
msgstr ":dfn:`이름 (Names)` 은 객체를 가리킵니다. 이름은 이름 연결 연산 때문에 만들어집니다."

#: ../../reference/executionmodel.rst:59
msgid "The following constructs bind names:"
msgstr ""

#: ../../reference/executionmodel.rst:61
msgid "formal parameters to functions,"
msgstr ""

#: ../../reference/executionmodel.rst:62
msgid "class definitions,"
msgstr ""

#: ../../reference/executionmodel.rst:63
msgid "function definitions,"
msgstr ""

#: ../../reference/executionmodel.rst:64
msgid "assignment expressions,"
msgstr ""

#: ../../reference/executionmodel.rst:65
msgid ""
":ref:`targets <assignment>` that are identifiers if occurring in an "
"assignment:"
msgstr ""

#: ../../reference/executionmodel.rst:68
msgid ":keyword:`for` loop header,"
msgstr ""

#: ../../reference/executionmodel.rst:69
msgid ""
"after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` "
"clause, :keyword:`except* <except_star>` clause, or in the as-pattern in "
"structural pattern matching,"
msgstr ""

#: ../../reference/executionmodel.rst:71
msgid "in a capture pattern in structural pattern matching"
msgstr ""

#: ../../reference/executionmodel.rst:73
msgid ":keyword:`import` statements."
msgstr ""

#: ../../reference/executionmodel.rst:74
msgid ":keyword:`type` statements."
msgstr ""

#: ../../reference/executionmodel.rst:75
msgid ":ref:`type parameter lists <type-params>`."
msgstr ""

#: ../../reference/executionmodel.rst:77
msgid ""
"The :keyword:`!import` statement of the form ``from ... import *`` binds "
"all names defined in the imported module, except those beginning with an "
"underscore. This form may only be used at the module level."
msgstr ""

#: ../../reference/executionmodel.rst:81
msgid ""
"A target occurring in a :keyword:`del` statement is also considered bound"
" for this purpose (though the actual semantics are to unbind the name)."
msgstr ""
":keyword:`del` 문에 나오는 대상 역시 이 목적에서 연결된 것으로 간주합니다(실제 의미가 이름을 연결 해제하는 것이기는 "
"해도)."

#: ../../reference/executionmodel.rst:84
msgid ""
"Each assignment or import statement occurs within a block defined by a "
"class or function definition or at the module level (the top-level code "
"block)."
msgstr ""
"각 대입이나 임포트 문은 클래스나 함수 정의 때문에 정의되는 블록 내에 등장할 수 있고, 모듈 수준(최상위 코드 블록)에서 등장할 "
"수도 있습니다."

#: ../../reference/executionmodel.rst:89
msgid ""
"If a name is bound in a block, it is a local variable of that block, "
"unless declared as :keyword:`nonlocal` or :keyword:`global`.  If a name "
"is bound at the module level, it is a global variable.  (The variables of"
" the module code block are local and global.)  If a variable is used in a"
" code block but not defined there, it is a :term:`free variable`."
msgstr ""
"만약 이름이 블록 내에서 연결되면, :keyword:`nonlocal` 이나 :keyword:`global` 로 선언되지 않는 "
"이상, 그 블록의 지역 변수입니다. 만약 이름이 모듈 수준에서 연결되면, 전역 변수입니다. (모듈 코드 블록의 변수들 지역이면서 "
"전역입니다.) 만약 변수가 코드 블록에서 사용되지만, 거기에서 정의되지 않았으면 :term:`자유 변수 <free "
"variable>` 입니다."

#: ../../reference/executionmodel.rst:95
msgid ""
"Each occurrence of a name in the program text refers to the "
":dfn:`binding` of that name established by the following name resolution "
"rules."
msgstr ""
"프로그램 텍스트에 등장하는 각각의 이름들은 다음에 나오는 이름 검색(name resolution) 규칙에 따라 확정되는 이름의 "
":dfn:`연결 (binding)` 을 가리킵니다."

#: ../../reference/executionmodel.rst:101
msgid "Resolution of names"
msgstr "이름의 검색(resolution)"

#: ../../reference/executionmodel.rst:105
msgid ""
"A :dfn:`scope` defines the visibility of a name within a block.  If a "
"local variable is defined in a block, its scope includes that block.  If "
"the definition occurs in a function block, the scope extends to any "
"blocks contained within the defining one, unless a contained block "
"introduces a different binding for the name."
msgstr ""
":dfn:`스코프 (scope)` 는 블록 내에서 이름의 가시성(visibility)을 정의합니다. 지역 변수가 블록에서 정의되면,"
" 그것의 스코프는 그 블록을 포함합니다. 만약 정의가 함수 블록에서 이루어지면, 포함된 블록이 그 이름에 대해 다른 결합을 만들지 "
"않는 이상, 스코프는 정의하고 있는 것 안에 포함된 모든 블록으로 확대됩니다."

#: ../../reference/executionmodel.rst:113
msgid ""
"When a name is used in a code block, it is resolved using the nearest "
"enclosing scope.  The set of all such scopes visible to a code block is "
"called the block's :dfn:`environment`."
msgstr ""
"이름이 코드 블록 내에서 사용될 때, 가장 가깝게 둘러싸고 있는 스코프에 있는 것으로 검색됩니다. 코드 블록이 볼 수 있는 모든 "
"스코프의 집합을 블록의 :dfn:`환경 (environment)` 이라고 부릅니다."

#: ../../reference/executionmodel.rst:121
msgid ""
"When a name is not found at all, a :exc:`NameError` exception is raised. "
"If the current scope is a function scope, and the name refers to a local "
"variable that has not yet been bound to a value at the point where the "
"name is used, an :exc:`UnboundLocalError` exception is raised. "
":exc:`UnboundLocalError` is a subclass of :exc:`NameError`."
msgstr ""
"이름이 어디에서도 발견되지 않으면 :exc:`NameError` 예외가 발생합니다. 만약 현재 스코프가 함수 스코프이고, 그 이름이"
" 사용되는 시점에 아직 연결되지 않은 지역 변수면 :exc:`UnboundLocalError` 예외가 발생합니다. "
":exc:`UnboundLocalError` 는 :exc:`NameError` 의 서브 클래스입니다."

#: ../../reference/executionmodel.rst:127
msgid ""
"If a name binding operation occurs anywhere within a code block, all uses"
" of the name within the block are treated as references to the current "
"block.  This can lead to errors when a name is used within a block before"
" it is bound.  This rule is subtle.  Python lacks declarations and allows"
" name binding operations to occur anywhere within a code block.  The "
"local variables of a code block can be determined by scanning the entire "
"text of the block for name binding operations. See :ref:`the FAQ entry on"
" UnboundLocalError <faq-unboundlocalerror>` for examples."
msgstr ""
"만약 이름 연결 연산이 코드 블록 내의 어디에서 건 일어난다면, 그 블록 내에서 그 이름의 모든 사용은 현재 블록을 가리키는 것으로"
" 취급됩니다. 이것은 연결되기 전에 블록에서 사용될 때 에러로 이어질 수 있습니다. 이 규칙은 미묘합니다. 파이썬에는 "
"선언(declaration)이 없고, 이름 연결 연산이 코드 블록 내의 어디에서나 일어날 수 있도록 허락합니다. 코드 블록의 지역 "
"변수는 블록의 텍스트 전체에서 이름 연결 연산을 찾아야 결정될 수 있습니다. 예제는 :ref:`UnboundLocalError 에 "
"관한 FAQ 항목 <faq-unboundlocalerror>`\\을 참조하세요."

#: ../../reference/executionmodel.rst:136
msgid ""
"If the :keyword:`global` statement occurs within a block, all uses of the"
" names specified in the statement refer to the bindings of those names in"
" the top-level namespace.  Names are resolved in the top-level namespace "
"by searching the global namespace, i.e. the namespace of the module "
"containing the code block, and the builtins namespace, the namespace of "
"the module :mod:`builtins`.  The global namespace is searched first.  If "
"the names are not found there, the builtins namespace is searched next. "
"If the names are also not found in the builtins namespace, new variables "
"are created in the global namespace. The global statement must precede "
"all uses of the listed names."
msgstr ""
"만약 :keyword:`global` 문이 블록 내에서 나오면, 문장에서 지정한 이름의 모든 사용은 최상위 이름 공간(top-"
"level namespace)에 연결된 것을 가리키게 됩니다. 최상위 이름 공간에서 이름을 검색한다는 것은, 전역 이름 공간, 즉 "
"코드 블록을 포함하는 모듈의 이름 공간, 과 내장 이름 공간, 모듈 :mod:`builtins` 의 이름 공간, 을 검색한다는 "
"뜻입니다. 전역 이름 공간이 먼저 검색됩니다. 거기에서 이름이 발견되지 않으면, 내장 이름 공간을 다음에 검색합니다. 내장 이름 "
"공간에서도 이름이 발견되지 않으면, 전역 이름 공간에 새 변수가 만들어집니다. global 문은 나열된 이름을 사용하기 전에 나와야"
" 합니다."

#: ../../reference/executionmodel.rst:146
msgid ""
"The :keyword:`global` statement has the same scope as a name binding "
"operation in the same block.  If the nearest enclosing scope for a free "
"variable contains a global statement, the free variable is treated as a "
"global."
msgstr ""
":keyword:`global` 문은 같은 블록의 이름 연결 연산과 같은 스코프를 갖습니다. 자유 변수의 경우 가장 가까이서 "
"둘러싸는 스코프가 global 문을 포함한다면, 그 자유 변수는 전역으로 취급됩니다."

#: ../../reference/executionmodel.rst:152
msgid ""
"The :keyword:`nonlocal` statement causes corresponding names to refer to "
"previously bound variables in the nearest enclosing function scope. "
":exc:`SyntaxError` is raised at compile time if the given name does not "
"exist in any enclosing function scope. :ref:`Type parameters <type-"
"params>` cannot be rebound with the :keyword:`!nonlocal` statement."
msgstr ""
":keyword:`nonlocal` 문은 대응하는 이름이 가장 가까이서 둘러싸는 함수 스코프에서 이미 연결된 이름을 가리키도록 "
"만듭니다. 만약 주어진 이름이 둘러싸는 함수 스코프 어디에도 없다면 컴파일 시점에 :exc:`SyntaxError` 를 일으킵니다."
" :ref:`형 매개 변수 <type-params>`\\는 :keyword:`!nonlocal` 문으로 재연결할 수 없습니다."

#: ../../reference/executionmodel.rst:160
msgid ""
"The namespace for a module is automatically created the first time a "
"module is imported.  The main module for a script is always called "
":mod:`__main__`."
msgstr ""
"모듈의 이름 공간은 모듈이 처음 임포트될 때 자동으로 만들어집니다. 스크립트의 메인 모듈은 항상 :mod:`__main__` 이라고"
" 불립니다."

#: ../../reference/executionmodel.rst:163
msgid ""
"Class definition blocks and arguments to :func:`exec` and :func:`eval` "
"are special in the context of name resolution. A class definition is an "
"executable statement that may use and define names. These references "
"follow the normal rules for name resolution with an exception that "
"unbound local variables are looked up in the global namespace. The "
"namespace of the class definition becomes the attribute dictionary of the"
" class. The scope of names defined in a class block is limited to the "
"class block; it does not extend to the code blocks of methods. This "
"includes comprehensions and generator expressions, but it does not "
"include :ref:`annotation scopes <annotation-scopes>`, which have access "
"to their enclosing class scopes. This means that the following will "
"fail::"
msgstr ""
"클래스 정의 블록과 :func:`exec` 와 :func:`eval` 로 전달되는 인자는 특별한 이름 검색 문맥을 갖습니다. 클래스"
" 정의는 이름을 사용하고 정의할 수 있는 실행 가능한 문장입니다. 이 참조들은 연결되지 않은 지역 변수를 전역 이름 공간에서 "
"찾는다는 점을 제외하고는 이름 검색의 일반적인 규칙을 따릅니다. 클래스 정의의 이름 공간은 클래스의 어트리뷰트 딕셔너리가 됩니다. "
"클래스 블록에서 정의된 이름들의 스코프는 클래스 블록으로 제한됩니다; 메서드들의 코드 블록으로 확대되지 않습니다. 이것은 "
"컴프리헨션과 제너레이터 표현을 포함하지만, 둘러싸는 클래스 스코프에 액세스하는 :ref:`어노테이션 스코프 <annotation-"
"scopes>`\\는 포함하지 않습니다. 이것은 다음과 같은 것이 실패한다는 뜻입니다::"

#: ../../reference/executionmodel.rst:176
msgid ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"
msgstr ""
"class A:\n"
"    a = 42\n"
"    b = list(a + i for i in range(10))"

#: ../../reference/executionmodel.rst:180
msgid "However, the following will succeed::"
msgstr ""

#: ../../reference/executionmodel.rst:182
msgid ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"
msgstr ""
"class A:\n"
"    type Alias = Nested\n"
"    class Nested: pass\n"
"\n"
"print(A.Alias.__value__)  # <type 'A.Nested'>"

#: ../../reference/executionmodel.rst:191
msgid "Annotation scopes"
msgstr ""

#: ../../reference/executionmodel.rst:193
msgid ""
":term:`Annotations <annotation>`, :ref:`type parameter lists <type-"
"params>` and :keyword:`type` statements introduce *annotation scopes*, "
"which behave mostly like function scopes, but with some exceptions "
"discussed below."
msgstr ""

#: ../../reference/executionmodel.rst:198
msgid "Annotation scopes are used in the following contexts:"
msgstr ""

#: ../../reference/executionmodel.rst:200
msgid ":term:`Function annotations <function annotation>`."
msgstr ""

#: ../../reference/executionmodel.rst:201
msgid ":term:`Variable annotations <variable annotation>`."
msgstr ""

#: ../../reference/executionmodel.rst:202
msgid ""
"Type parameter lists for :ref:`generic type aliases <generic-type-"
"aliases>`."
msgstr ""

#: ../../reference/executionmodel.rst:203
msgid ""
"Type parameter lists for :ref:`generic functions <generic-functions>`. A "
"generic function's annotations are executed within the annotation scope, "
"but its defaults and decorators are not."
msgstr ""

#: ../../reference/executionmodel.rst:206
msgid ""
"Type parameter lists for :ref:`generic classes <generic-classes>`. A "
"generic class's base classes and keyword arguments are executed within "
"the annotation scope, but its decorators are not."
msgstr ""

#: ../../reference/executionmodel.rst:209
msgid ""
"The bounds, constraints, and default values for type parameters "
"(:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""

#: ../../reference/executionmodel.rst:211
msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""

#: ../../reference/executionmodel.rst:213
msgid "Annotation scopes differ from function scopes in the following ways:"
msgstr ""

#: ../../reference/executionmodel.rst:215
msgid ""
"Annotation scopes have access to their enclosing class namespace. If an "
"annotation scope is immediately within a class scope, or within another "
"annotation scope that is immediately within a class scope, the code in "
"the annotation scope can use names defined in the class scope as if it "
"were executed directly within the class body. This contrasts with regular"
" functions defined within classes, which cannot access names defined in "
"the class scope."
msgstr ""

#: ../../reference/executionmodel.rst:221
msgid ""
"Expressions in annotation scopes cannot contain :keyword:`yield`, ``yield"
" from``, :keyword:`await`, or :token:`:= <python-"
"grammar:assignment_expression>` expressions. (These expressions are "
"allowed in other scopes contained within the annotation scope.)"
msgstr ""

#: ../../reference/executionmodel.rst:225
msgid ""
"Names defined in annotation scopes cannot be rebound with "
":keyword:`nonlocal` statements in inner scopes. This includes only type "
"parameters, as no other syntactic elements that can appear within "
"annotation scopes can introduce new names."
msgstr ""

#: ../../reference/executionmodel.rst:228
msgid ""
"While annotation scopes have an internal name, that name is not reflected"
" in the :term:`qualified name` of objects defined within the scope. "
"Instead, the :attr:`~definition.__qualname__` of such objects is as if "
"the object were defined in the enclosing scope."
msgstr ""

#: ../../reference/executionmodel.rst:233
msgid "Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."
msgstr ""

#: ../../reference/executionmodel.rst:236
msgid ""
"Annotation scopes are also used for type parameter defaults, as "
"introduced by :pep:`696`."
msgstr ""

#: ../../reference/executionmodel.rst:240
msgid ""
"Annotation scopes are now also used for annotations, as specified in "
":pep:`649` and :pep:`749`."
msgstr ""

#: ../../reference/executionmodel.rst:247
msgid "Lazy evaluation"
msgstr ""

#: ../../reference/executionmodel.rst:249
msgid ""
"Most annotation scopes are *lazily evaluated*. This includes annotations,"
" the values of type aliases created through the :keyword:`type` "
"statement, and the bounds, constraints, and default values of type "
"variables created through the :ref:`type parameter syntax <type-params>`."
" This means that they are not evaluated when the type alias or type "
"variable is created, or when the object carrying annotations is created. "
"Instead, they are only evaluated when necessary, for example when the "
"``__value__`` attribute on a type alias is accessed."
msgstr ""

#: ../../reference/executionmodel.rst:258
msgid "Example:"
msgstr ""

#: ../../reference/executionmodel.rst:260
msgid ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"
msgstr ""
">>> type Alias = 1/0\n"
">>> Alias.__value__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero\n"
">>> def func[T: 1/0](): pass\n"
">>> T = func.__type_params__[0]\n"
">>> T.__bound__\n"
"Traceback (most recent call last):\n"
"  ...\n"
"ZeroDivisionError: division by zero"

#: ../../reference/executionmodel.rst:274
msgid ""
"Here the exception is raised only when the ``__value__`` attribute of the"
" type alias or the ``__bound__`` attribute of the type variable is "
"accessed."
msgstr ""

#: ../../reference/executionmodel.rst:278
msgid ""
"This behavior is primarily useful for references to types that have not "
"yet been defined when the type alias or type variable is created. For "
"example, lazy evaluation enables creation of mutually recursive type "
"aliases::"
msgstr ""

#: ../../reference/executionmodel.rst:282
msgid ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"
msgstr ""
"from typing import Literal\n"
"\n"
"type SimpleExpr = int | Parenthesized\n"
"type Parenthesized = tuple[Literal[\"(\"], Expr, Literal[\")\"]]\n"
"type Expr = SimpleExpr | tuple[SimpleExpr, Literal[\"+\", \"-\"], Expr]"

#: ../../reference/executionmodel.rst:288
msgid ""
"Lazily evaluated values are evaluated in :ref:`annotation scope "
"<annotation-scopes>`, which means that names that appear inside the "
"lazily evaluated value are looked up as if they were used in the "
"immediately enclosing scope."
msgstr ""

#: ../../reference/executionmodel.rst:297
msgid "Builtins and restricted execution"
msgstr "builtins 와 제한된 실행"

#: ../../reference/executionmodel.rst:303
msgid ""
"Users should not touch ``__builtins__``; it is strictly an implementation"
" detail.  Users wanting to override values in the builtins namespace "
"should :keyword:`import` the :mod:`builtins` module and modify its "
"attributes appropriately."
msgstr ""
"사용자는 ``__builtins__`` 를 건드리지 말아야 합니다; 이것은 구현 세부사항입니다. 내장 이름 공간의 값을 변경하고 "
"싶은 사용자는 :mod:`builtins` 모듈을 :keyword:`import` 하고 그것의 어트리뷰트를 적절하게 수정해야 "
"합니다."

#: ../../reference/executionmodel.rst:308
msgid ""
"The builtins namespace associated with the execution of a code block is "
"actually found by looking up the name ``__builtins__`` in its global "
"namespace; this should be a dictionary or a module (in the latter case "
"the module's dictionary is used).  By default, when in the "
":mod:`__main__` module, ``__builtins__`` is the built-in module "
":mod:`builtins`; when in any other module, ``__builtins__`` is an alias "
"for the dictionary of the :mod:`builtins` module itself."
msgstr ""
"코드 블록의 실행과 연관된 내장 이름 공간은, 사실 전역 이름 공간의 이름 ``__builtins__`` 를 조회함으로써 "
"발견됩니다. 이것은 딕셔너리나 모듈이어야 합니다(후자의 경우 모듈의 딕셔너리가 사용됩니다). 기본적으로, "
":mod:`__main__` 모듈에 있을 때는 ``__builtins__`` 가 내장 모듈 :mod:`builtins` 이고, 다른"
" 모듈에 있을 때는 ``__builtins__`` 는 :mod:`builtins` 모듈의 딕셔너리에 대한 별칭입니다."

#: ../../reference/executionmodel.rst:320
msgid "Interaction with dynamic features"
msgstr "동적 기능과의 상호작용"

#: ../../reference/executionmodel.rst:322
msgid ""
"Name resolution of free variables occurs at runtime, not at compile time."
" This means that the following code will print 42::"
msgstr ""
"자유 변수에 대해 이름 검색은 컴파일 시점이 아니라 실행 시점에 이루어집니다. 이것은 다음과 같은 코드가 42를 출력한다는 것을 "
"뜻합니다:"

#: ../../reference/executionmodel.rst:325
msgid ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"
msgstr ""
"i = 10\n"
"def f():\n"
"    print(i)\n"
"i = 42\n"
"f()"

#: ../../reference/executionmodel.rst:333
msgid ""
"The :func:`eval` and :func:`exec` functions do not have access to the "
"full environment for resolving names.  Names may be resolved in the local"
" and global namespaces of the caller.  Free variables are not resolved in"
" the nearest enclosing namespace, but in the global namespace.  [#]_ The "
":func:`exec` and :func:`eval` functions have optional arguments to "
"override the global and local namespace.  If only one namespace is "
"specified, it is used for both."
msgstr ""
":func:`eval` 과 :func:`exec` 함수는 이름 검색을 위한 완전한 환경에 대한 접근권이 없습니다. 이름은 호출자의 "
"지역과 전역 이름 공간에서 검색될 수 있습니다. 자유 변수는 가장 가까이 둘러싼 이름 공간이 아니라 전역 이름 공간에서 검색됩니다."
" [#]_ :func:`exec` 과 :func:`eval` 함수에는 전역과 지역 이름 공간을 재정의할 수 있는 생략 가능한 인자가"
" 있습니다. 만약 단지 한 이름 공간만 주어지면, 그것이 두 가지 모두로 사용됩니다."

#: ../../reference/executionmodel.rst:347
msgid "Exceptions"
msgstr "예외"

#: ../../reference/executionmodel.rst:358
msgid ""
"Exceptions are a means of breaking out of the normal flow of control of a"
" code block in order to handle errors or other exceptional conditions.  "
"An exception is *raised* at the point where the error is detected; it may"
" be *handled* by the surrounding code block or by any code block that "
"directly or indirectly invoked the code block where the error occurred."
msgstr ""
"예외는 에러나 예외적인 조건을 처리하기 위해 코드 블록의 일반적인 제어 흐름을 깨는 수단입니다. 에러가 감지된 지점에서 예외를 "
"*일으킵니다(raised)*; 둘러싼 코드 블록이나 직접적 혹은 간접적으로 에러가 발생한 코드 블록을 호출한 어떤 코드 블록에서건 "
"예외는 처리될 수 있습니다."

#: ../../reference/executionmodel.rst:364
msgid ""
"The Python interpreter raises an exception when it detects a run-time "
"error (such as division by zero).  A Python program can also explicitly "
"raise an exception with the :keyword:`raise` statement. Exception "
"handlers are specified with the :keyword:`try` ... :keyword:`except` "
"statement.  The :keyword:`finally` clause of such a statement can be used"
" to specify cleanup code which does not handle the exception, but is "
"executed whether an exception occurred or not in the preceding code."
msgstr ""
"파이썬 인터프리터는 실행 시간 에러(0으로 나누는 것 같은)를 감지할 때 예외를 일으킵니다. 파이썬 프로그램은 "
":keyword:`raise` 문을 사용해서 명시적으로 예외를 일으킬 수 있습니다. 예외 처리기는 :keyword:`try` ..."
" :keyword:`except` 문으로 지정됩니다. 그런 문장에서 :keyword:`finally` 구는 정리(cleanup) "
"코드를 지정하는 데 사용되는데, 예외를 처리하는 것이 아니라 앞선 코드에서 예외가 발생하건 그렇지 않건 실행됩니다."

#: ../../reference/executionmodel.rst:374
msgid ""
"Python uses the \"termination\" model of error handling: an exception "
"handler can find out what happened and continue execution at an outer "
"level, but it cannot repair the cause of the error and retry the failing "
"operation (except by re-entering the offending piece of code from the "
"top)."
msgstr ""
"파이썬은 에러 처리에 \"종결 (termination)\" 모델을 사용합니다; 예외 처리기가 뭐가 발생했는지 발견할 수 있고, 바깥"
" 단계에서 실행을 계속할 수는 있지만, 에러의 원인을 제거한 후에 실패한 연산을 재시도할 수는 없습니다(문제의 코드 조각을 처음부터"
" 다시 시작시키는 것은 예외입니다)."

#: ../../reference/executionmodel.rst:381
msgid ""
"When an exception is not handled at all, the interpreter terminates "
"execution of the program, or returns to its interactive main loop.  In "
"either case, it prints a stack traceback, except when the exception is "
":exc:`SystemExit`."
msgstr ""
"예외가 어디서도 처리되지 않을 때, 인터프리터는 프로그램의 실행을 종료하거나, 대화형 메인 루프로 돌아갑니다. 두 경우 모두, "
"예외가 :exc:`SystemExit` 인 경우를 제외하고, 스택 트레이스백을 인쇄합니다."

#: ../../reference/executionmodel.rst:385
msgid ""
"Exceptions are identified by class instances.  The :keyword:`except` "
"clause is selected depending on the class of the instance: it must "
"reference the class of the instance or a :term:`non-virtual base class "
"<abstract base class>` thereof. The instance can be received by the "
"handler and can carry additional information about the exceptional "
"condition."
msgstr ""
"예외는 클래스 인스턴스로 구분됩니다. :keyword:`except` 절은 인스턴스의 클래스에 따라 선택됩니다: 인스턴스의 클래스나"
" 그것의 :term:`비가상(non-virtual) 베이스 클래스 <abstract base class>`\\를 가리켜야 합니다. "
"인스턴스는 핸들러가 수신할 수 있고 예외적인 조건에 대한 추가적인 정보를 포함할 수 있습니다."

#: ../../reference/executionmodel.rst:393
msgid ""
"Exception messages are not part of the Python API.  Their contents may "
"change from one version of Python to the next without warning and should "
"not be relied on by code which will run under multiple versions of the "
"interpreter."
msgstr ""
"예외 메시지는 파이썬 API 일부가 아닙니다. 그 내용은 파이썬의 버전이 바뀔 때 경고 없이 변경될 수 있고, 코드는 여러 버전의 "
"인터프리터에서 실행될 수 있는 코드는 이것에 의존하지 말아야 합니다."

#: ../../reference/executionmodel.rst:397
msgid ""
"See also the description of the :keyword:`try` statement in section "
":ref:`try` and :keyword:`raise` statement in section :ref:`raise`."
msgstr ""
"섹션 :ref:`try` 에서 :keyword:`try` 문, :ref:`raise` 에서 :keyword:`raise` 문에 대한"
" 설명이 제공됩니다."

#: ../../reference/executionmodel.rst:404
msgid "Runtime Components"
msgstr ""

#: ../../reference/executionmodel.rst:407
#, fuzzy
msgid "General Computing Model"
msgstr "실행 모델"

#: ../../reference/executionmodel.rst:409
msgid ""
"Python's execution model does not operate in a vacuum.  It runs on a host"
" machine and through that host's runtime environment, including its "
"operating system (OS), if there is one.  When a program runs, the "
"conceptual layers of how it runs on the host look something like this:"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "**host machine**"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "**process** (global resources)"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "**thread** (runs machine code)"
msgstr ""

#: ../../reference/executionmodel.rst:419
msgid ""
"Each process represents a program running on the host.  Think of each "
"process itself as the data part of its program.  Think of the process' "
"threads as the execution part of the program.  This distinction will be "
"important to understand the conceptual Python runtime."
msgstr ""

#: ../../reference/executionmodel.rst:424
msgid ""
"The process, as the data part, is the execution context in which the "
"program runs.  It mostly consists of the set of resources assigned to the"
" program by the host, including memory, signals, file handles, sockets, "
"and environment variables."
msgstr ""

#: ../../reference/executionmodel.rst:429
msgid ""
"Processes are isolated and independent from one another.  (The same is "
"true for hosts.)  The host manages the process' access to its assigned "
"resources, in addition to coordinating between processes."
msgstr ""

#: ../../reference/executionmodel.rst:433
msgid ""
"Each thread represents the actual execution of the program's machine "
"code, running relative to the resources assigned to the program's "
"process.  It's strictly up to the host how and when that execution takes "
"place."
msgstr ""

#: ../../reference/executionmodel.rst:438
msgid ""
"From the point of view of Python, a program always starts with exactly "
"one thread.  However, the program may grow to run in multiple "
"simultaneous threads.  Not all hosts support multiple threads per "
"process, but most do.  Unlike processes, threads in a process are not "
"isolated and independent from one another.  Specifically, all threads in "
"a process share all of the process' resources."
msgstr ""

#: ../../reference/executionmodel.rst:445
msgid ""
"The fundamental point of threads is that each one does *run* "
"independently, at the same time as the others.  That may be only "
"conceptually at the same time (\"concurrently\") or physically (\"in "
"parallel\").  Either way, the threads effectively run at a non-"
"synchronized rate."
msgstr ""

#: ../../reference/executionmodel.rst:453
msgid ""
"That non-synchronized rate means none of the process' memory is "
"guaranteed to stay consistent for the code running in any given thread.  "
"Thus multi-threaded programs must take care to coordinate access to "
"intentionally shared resources.  Likewise, they must take care to be "
"absolutely diligent about not accessing any *other* resources in multiple"
" threads; otherwise two threads running at the same time might "
"accidentally interfere with each other's use of some shared data.  All "
"this is true for both Python programs and the Python runtime."
msgstr ""

#: ../../reference/executionmodel.rst:463
msgid ""
"The cost of this broad, unstructured requirement is the tradeoff for the "
"kind of raw concurrency that threads provide.  The alternative to the "
"required discipline generally means dealing with non-deterministic bugs "
"and data corruption."
msgstr ""

#: ../../reference/executionmodel.rst:469
msgid "Python Runtime Model"
msgstr ""

#: ../../reference/executionmodel.rst:471
msgid ""
"The same conceptual layers apply to each Python program, with some extra "
"data layers specific to Python:"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "Python global runtime (*state*)"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "Python interpreter (*state*)"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "**thread** (runs Python bytecode and \"C-API\")"
msgstr ""

#: ../../reference/executionmodel.rst
msgid "Python thread *state*"
msgstr ""

#: ../../reference/executionmodel.rst:481
msgid ""
"At the conceptual level: when a Python program starts, it looks exactly "
"like that diagram, with one of each.  The runtime may grow to include "
"multiple interpreters, and each interpreter may grow to include multiple "
"thread states."
msgstr ""

#: ../../reference/executionmodel.rst:488
msgid ""
"A Python implementation won't necessarily implement the runtime layers "
"distinctly or even concretely.  The only exception is places where "
"distinct layers are directly specified or exposed to users, like through "
"the :mod:`threading` module."
msgstr ""

#: ../../reference/executionmodel.rst:495
msgid ""
"The initial interpreter is typically called the \"main\" interpreter. "
"Some Python implementations, like CPython, assign special roles to the "
"main interpreter."
msgstr ""

#: ../../reference/executionmodel.rst:499
msgid ""
"Likewise, the host thread where the runtime was initialized is known as "
"the \"main\" thread.  It may be different from the process' initial "
"thread, though they are often the same.  In some cases \"main thread\" "
"may be even more specific and refer to the initial thread state. A Python"
" runtime might assign specific responsibilities to the main thread, such "
"as handling signals."
msgstr ""

#: ../../reference/executionmodel.rst:506
msgid ""
"As a whole, the Python runtime consists of the global runtime state, "
"interpreters, and thread states.  The runtime ensures all that state "
"stays consistent over its lifetime, particularly when used with multiple "
"host threads."
msgstr ""

#: ../../reference/executionmodel.rst:511
msgid ""
"The global runtime, at the conceptual level, is just a set of "
"interpreters.  While those interpreters are otherwise isolated and "
"independent from one another, they may share some data or other "
"resources.  The runtime is responsible for managing these global "
"resources safely.  The actual nature and management of these resources is"
" implementation-specific.  Ultimately, the external utility of the global"
" runtime is limited to managing interpreters."
msgstr ""

#: ../../reference/executionmodel.rst:519
msgid ""
"In contrast, an \"interpreter\" is conceptually what we would normally "
"think of as the (full-featured) \"Python runtime\".  When machine code "
"executing in a host thread interacts with the Python runtime, it calls "
"into Python in the context of a specific interpreter."
msgstr ""

#: ../../reference/executionmodel.rst:526
msgid ""
"The term \"interpreter\" here is not the same as the \"bytecode "
"interpreter\", which is what regularly runs in threads, executing "
"compiled Python code."
msgstr ""

#: ../../reference/executionmodel.rst:530
msgid ""
"In an ideal world, \"Python runtime\" would refer to what we currently "
"call \"interpreter\".  However, it's been called \"interpreter\" at least"
" since introduced in 1997 (`CPython:a027efa5b`_)."
msgstr ""

#: ../../reference/executionmodel.rst:536
msgid ""
"Each interpreter completely encapsulates all of the non-process-global, "
"non-thread-specific state needed for the Python runtime to work. Notably,"
" the interpreter's state persists between uses.  It includes fundamental "
"data like :data:`sys.modules`.  The runtime ensures multiple threads "
"using the same interpreter will safely share it between them."
msgstr ""

#: ../../reference/executionmodel.rst:543
msgid ""
"A Python implementation may support using multiple interpreters at the "
"same time in the same process.  They are independent and isolated from "
"one another.  For example, each interpreter has its own "
":data:`sys.modules`."
msgstr ""

#: ../../reference/executionmodel.rst:548
msgid ""
"For thread-specific runtime state, each interpreter has a set of thread "
"states, which it manages, in the same way the global runtime contains a "
"set of interpreters.  It can have thread states for as many host threads "
"as it needs.  It may even have multiple thread states for the same host "
"thread, though that isn't as common."
msgstr ""

#: ../../reference/executionmodel.rst:554
msgid ""
"Each thread state, conceptually, has all the thread-specific runtime data"
" an interpreter needs to operate in one host thread.  The thread state "
"includes the current raised exception and the thread's Python call stack."
"  It may include other thread-specific resources."
msgstr ""

#: ../../reference/executionmodel.rst:561
msgid ""
"The term \"Python thread\" can sometimes refer to a thread state, but "
"normally it means a thread created using the :mod:`threading` module."
msgstr ""

#: ../../reference/executionmodel.rst:564
msgid ""
"Each thread state, over its lifetime, is always tied to exactly one "
"interpreter and exactly one host thread.  It will only ever be used in "
"that thread and with that interpreter."
msgstr ""

#: ../../reference/executionmodel.rst:568
msgid ""
"Multiple thread states may be tied to the same host thread, whether for "
"different interpreters or even the same interpreter.  However, for any "
"given host thread, only one of the thread states tied to it can be used "
"by the thread at a time."
msgstr ""

#: ../../reference/executionmodel.rst:573
msgid ""
"Thread states are isolated and independent from one another and don't "
"share any data, except for possibly sharing an interpreter and objects or"
" other resources belonging to that interpreter."
msgstr ""

#: ../../reference/executionmodel.rst:577
msgid ""
"Once a program is running, new Python threads can be created using the "
":mod:`threading` module (on platforms and Python implementations that "
"support threads).  Additional processes can be created using the "
":mod:`os`, :mod:`subprocess`, and :mod:`multiprocessing` modules. "
"Interpreters can be created and used with the "
":mod:`~concurrent.interpreters` module.  Coroutines (async) can be run "
"using :mod:`asyncio` in each interpreter, typically only in a single "
"thread (often the main thread)."
msgstr ""

#: ../../reference/executionmodel.rst:588
msgid "Footnotes"
msgstr "각주"

#: ../../reference/executionmodel.rst:589
msgid ""
"This limitation occurs because the code that is executed by these "
"operations is not available at the time the module is compiled."
msgstr "이 한계는 이 연산들 때문에 실행되는 코드가 모듈이 컴파일되는 시점에는 존재하지 않았기 때문입니다."

#: ../../reference/executionmodel.rst:8
msgid "execution model"
msgstr "실행 모델"

#: ../../reference/executionmodel.rst:8
msgid "code"
msgstr "코드"

#: ../../reference/executionmodel.rst:8 ../../reference/executionmodel.rst:17
msgid "block"
msgstr "블록"

#: ../../reference/executionmodel.rst:31 ../../reference/executionmodel.rst:299
msgid "execution"
msgstr "실행"

#: ../../reference/executionmodel.rst:31
msgid "frame"
msgstr "프레임"

#: ../../reference/executionmodel.rst:42
msgid "namespace"
msgstr "이름 공간"

#: ../../reference/executionmodel.rst:42 ../../reference/executionmodel.rst:103
msgid "scope"
msgstr "스코프"

#: ../../reference/executionmodel.rst:51
msgid "name"
msgstr "이름"

#: ../../reference/executionmodel.rst:51
msgid "binding"
msgstr "연결"

#: ../../reference/executionmodel.rst:57
msgid "from"
msgstr "from"

#: ../../reference/executionmodel.rst:57
msgid "import statement"
msgstr "임포트 문"

#: ../../reference/executionmodel.rst:87
msgid "free"
msgstr "자유"

#: ../../reference/executionmodel.rst:87
msgid "variable"
msgstr "변수"

#: ../../reference/executionmodel.rst:111
msgid "environment"
msgstr "환경"

#: ../../reference/executionmodel.rst:117
msgid "NameError (built-in exception)"
msgstr "NameError (내장 예외)"

#: ../../reference/executionmodel.rst:117
msgid "UnboundLocalError"
msgstr "UnboundLocalError"

#: ../../reference/executionmodel.rst:158
msgid "module"
msgstr "모듈"

#: ../../reference/executionmodel.rst:158
msgid "__main__"
msgstr "__main__"

#: ../../reference/executionmodel.rst:299
msgid "restricted"
msgstr "제한된"

#: ../../reference/executionmodel.rst:349
msgid "exception"
msgstr "예외"

#: ../../reference/executionmodel.rst:351
msgid "raise an exception"
msgstr "예외를 발생시키다"

#: ../../reference/executionmodel.rst:351
msgid "handle an exception"
msgstr "예외를 처리하다"

#: ../../reference/executionmodel.rst:351
msgid "exception handler"
msgstr "예외 처리기"

#: ../../reference/executionmodel.rst:351
msgid "errors"
msgstr "에러"

#: ../../reference/executionmodel.rst:351
msgid "error handling"
msgstr "에러 처리"

#: ../../reference/executionmodel.rst:372
msgid "termination model"
msgstr "종료 모델"

#: ../../reference/executionmodel.rst:379
msgid "SystemExit (built-in exception)"
msgstr "SystemExit (내장 예외)"

#~ msgid ""
#~ "The following constructs bind names: "
#~ "formal parameters to functions, "
#~ ":keyword:`import` statements, class and "
#~ "function definitions (these bind the "
#~ "class or function name in the "
#~ "defining block), and targets that are"
#~ " identifiers if occurring in an "
#~ "assignment, :keyword:`for` loop header, or "
#~ "after :keyword:`!as` in a :keyword:`with` "
#~ "statement or :keyword:`except` clause. The "
#~ ":keyword:`!import` statement of the form "
#~ "``from ... import *`` binds all "
#~ "names defined in the imported module,"
#~ " except those beginning with an "
#~ "underscore.  This form may only be "
#~ "used at the module level."
#~ msgstr ""
#~ "다음과 같은 것들이 이름을 연결합니다: 함수로 전달되는 "
#~ "형식 매개변수, :keyword:`import` 문, 클래스와 함수"
#~ " 정의(이것들은 클래스나 함수 이름을 정의하고 있는 "
#~ "블록에 연결합니다), 그리고 다음과 같은 것들에 등장하는"
#~ " 식별자 대상들: 대입, :keyword:`for` 루프 헤더,"
#~ " :keyword:`with` 문이나 :keyword:`except` 절의 "
#~ ":keyword:`!as` 뒤. ``from ... import *``"
#~ " 형태의 :keyword:`!import` 문은 임포트되는 모듈에 "
#~ "정의된 모든 이름을 연결합니다, 밑줄로 시작하는 이름들은"
#~ " 예외입니다. 이 형태는 모듈 수준에서만 사용될 수"
#~ " 있습니다."

#~ msgid ""
#~ ":ref:`Type parameter lists <type-params>` "
#~ "and :keyword:`type` statements introduce "
#~ "*annotation scopes*, which behave mostly "
#~ "like function scopes, but with some "
#~ "exceptions discussed below. :term:`Annotations "
#~ "<annotation>` currently do not use "
#~ "annotation scopes, but they are expected"
#~ " to use annotation scopes in Python"
#~ " 3.13 when :pep:`649` is implemented."
#~ msgstr ""

#~ msgid ""
#~ "The values of type aliases created "
#~ "through the :keyword:`type` statement are "
#~ "*lazily evaluated*. The same applies to"
#~ " the bounds, constraints, and default "
#~ "values of type variables created through"
#~ " the :ref:`type parameter syntax <type-"
#~ "params>`. This means that they are "
#~ "not evaluated when the type alias "
#~ "or type variable is created. Instead,"
#~ " they are only evaluated when doing"
#~ " so is necessary to resolve an "
#~ "attribute access."
#~ msgstr ""