# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Freesand Leo <yuqinju@163.com>, 2025

# 99 <wh2099@pm.me>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-05-01 14:49+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: 99 <wh2099@pm.me>, 2026\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=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 ""

"Python 程序是由代码块构成的。 :dfn:`代码块` 是被作为一个单元来执行的一段 Python 程序文本。 "

"以下几个都属于代码块：模块、函数体和类定义。 交互式输入的每条命令都是代码块。 "

"一个脚本文件（作为标准输入发送给解释器或是作为命令行参数发送给解释器的文件）也是代码块。 一条脚本命令（通过 :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:`执行帧` 中被执行。 一个帧会包含某些管理信息（用于调试）并决定代码块执行完成后应前往何处以及如何继续执行。"

#: ../../reference/executionmodel.rst:40

msgid "Naming and binding"

msgstr "命名与绑定"

#: ../../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:`名称` 用于指代对象。 名称是通过名称绑定操作来引入的。"

#: ../../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 "如果在一个赋值中出现，则为标识符的 :ref:`目标 <assignment>` :"

#: ../../reference/executionmodel.rst:68

msgid ":keyword:`for` loop header,"

msgstr ":keyword:`for` 循环头,"

#: ../../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 ""

"在 :keyword:`with` 语句, :keyword:`except` 子句, :keyword:`except* <except_star>`"

" 子句，或结构化模式匹配的 as 模式的 :keyword:`!as` 之后，"

#: ../../reference/executionmodel.rst:71

msgid "in a capture pattern in structural pattern matching"

msgstr "在结构模式匹配中的捕获模式"

#: ../../reference/executionmodel.rst:73

msgid ":keyword:`import` statements."

msgstr ":keyword:`import` 语句。"

#: ../../reference/executionmodel.rst:74

msgid ":keyword:`type` statements."

msgstr ":keyword:`type` 语句。"

#: ../../reference/executionmodel.rst:75

msgid ":ref:`type parameter lists <type-params>`."

msgstr ":ref:`类型形参列表 <type-params>`。"

#: ../../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 ""

"形式为 ``from ... import *`` 的 :keyword:`!import` "

"语句绑定所有在导入的模块中定义的名字，除了那些以下划线开头的名字。这种形式只能在模块级别上使用。"

#: ../../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 "每个在程序文本中出现的名称是指由以下名称解析规则所建立的对该名称的 :dfn:`绑定`。"

#: ../../reference/executionmodel.rst:101

msgid "Resolution of names"

msgstr "名称的解析"

#: ../../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:`作用域` 定义了一个代码块中名称的可见性。 如果代码块中定义了一个局部变量，则其作用域包含该代码块。 "

"如果定义发生于函数代码块中，则其作用域会扩展到该函数所包含的任何代码块，除非有某个被包含代码块引入了对该名称的不同绑定。"

#: ../../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:`环境`。"

#: ../../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 ""

"如果一个代码块内的任何位置发生名称绑定操作，则代码块内所有对该名称的使用都会被视为对当前代码块的引用。 "

"当一个名称在其被绑定前就在代码块内被使用时将会导致错误。 这个规则是很微妙的。 Python 缺少声明语法并且允许名称绑定操作发生于代码块内的任何位置。"

" 一个代码块的局部变量可通过在整个代码块文本中扫描名称绑定操作来确定。 请参阅 :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` 语句出现在一个代码块中，则所有对该语句所指定名称的使用都是在最高层级命名空间内对该名称绑定的引用。 "

"名称在最高层级命名空间内的解析是通过搜索全局命名空间，也就是包含该代码块的模块的命名空间，以及内置命名空间即 :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 ""

":term:`标注 <annotation>`, :ref:`类型形参列表 <type-params>` 和 :keyword:`type` 语句引入了"

" *标注作用域*，其行为基本类似于函数作用域，但具有下文讨论的一些差异。"

#: ../../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 ":term:`函数标注 <function annotation>`。"

#: ../../reference/executionmodel.rst:201

msgid ":term:`Variable annotations <variable annotation>`."

msgstr ":term:`变量标注 <variable annotation>`。"

#: ../../reference/executionmodel.rst:202

msgid ""

"Type parameter lists for :ref:`generic type aliases <generic-type-aliases>`."

msgstr "针对 :ref:`泛型类型别名 <generic-type-aliases>` 的类型形参列表。"

#: ../../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 ""

"针对 :ref:`泛型函数 <generic-functions>` 的类型形参列表。 泛型函数的标注会在标注作用域内执行，但其默认值和装饰器则不会。"

#: ../../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 ""

"针对 :ref:`泛型类 <generic-classes>` 的类型形参列表。 泛型类的基类和关键字参数会在标注作用域内执行，但其装饰器则不会。"

#: ../../reference/executionmodel.rst:209

msgid ""

"The bounds, constraints, and default values for type parameters "

"(:ref:`lazily evaluated <lazy-evaluation>`)."

msgstr "针对类型形参的绑定、约束和默认值 (:ref:`惰性求值 <lazy-evaluation>`)。"

#: ../../reference/executionmodel.rst:211

msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."

msgstr "类型别名的值 (:ref:`惰性求值 <lazy-evaluation>`)。"

#: ../../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 ""

"标注作用域中的表达式不能包含 :keyword:`yield`, ``yield from``, :keyword:`await` 或 "

":token:`:= <python-grammar:assignment_expression>` 表达式。 "

"（这些表达式在包含于标注作用域之内的其他作用域中则是允许的。）"

#: ../../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 ""

"在标注作用域中定义的名称不能在内部作用域中通过 :keyword:`nonlocal` 语句来重新绑定。 "

"这只包括类型形参，因为没有其他可以在标注作用域内部出现的语法元素能够引入新的名称。"

#: ../../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 ""

"虽然标注作用域具有一个内部名称，但该名称不会反映在作用域内定义的对象的 :term:`qualified name` 中。 相反，这些对象的 "

":attr:`~definition.__qualname__` 就像它们是定义在包含作用域中的对象一样。"

#: ../../reference/executionmodel.rst:233

msgid ""

"Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."

msgstr "标注作用域是在 Python 3.12 中作为 :pep:`695` 的一部分引入的。"

#: ../../reference/executionmodel.rst:236

msgid ""

"Annotation scopes are also used for type parameter defaults, as introduced "

"by :pep:`696`."

msgstr "标注作用域也被用于类型形参默认值，这是由 :pep:`696` 引入的。"

#: ../../reference/executionmodel.rst:240

msgid ""

"Annotation scopes are now also used for annotations, as specified in "

":pep:`649` and :pep:`749`."

msgstr "标注作用域现在也被用于标注，如 :pep:`649` 和 :pep:`749` 所说明的。"

#: ../../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 ""

"大多数标注作用域采用 *惰性求值*。 这包括标注、通过 :keyword:`type` 语句创建的类型别名的值，以及通过 :ref:`类型形参语法 "

"<type-params>` 创建的类型变量的绑定、约束和默认值。 这意味着它们在类型别名或类型变量被创建时、或带有标注的对象被创建时不会被求值。 "

"作为替代行为，它们只有在需要时才会被求值，例如在一个类型别名上的 ``__value__`` 属性被访问的时候。"

#: ../../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 "此处的异常只有在类型别名的 ``__value__`` 属性或类型变量的 ``__bound__`` 属性被访问时才会被引发。"

#: ../../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 ""

"被惰性求值的值是在 :ref:`标注作用域 <annotation-scopes>` "

"内进行求值的，这意味着出现在被惰性求值的值内部的名称的查找范围就相当于它们是在紧邻的作用域中被使用。"

#: ../../reference/executionmodel.rst:297

msgid "Builtins and restricted execution"

msgstr "内置命名空间和受限的执行"

#: ../../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__``，严格说来它属于实现细节。 用户如果要重载内置命名空间中的值则应该 :keyword:`import` "

":mod:`builtins` 并相应地修改该模块中的属性。"

#: ../../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 ""

"异常是中断代码块的正常控制流程以便处理错误或其他异常条件的一种方式。 异常会在错误被检测到的位置 "

"*引发*，它可以被当前包围代码块或是任何直接或间接唤起发生错误的代码块的其他代码块所 *处理*。"

#: ../../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 ""

"Python 解释器会在检测到运行时错误（例如零作为被除数）的时候引发异常。 Python 程序也可以通过 :keyword:`raise` "

"语句显式地引发异常。 异常处理是通过 :keyword:`try` ... :keyword:`except` 语句来指定的。 该语句的 "

":keyword:`finally` 子句可被用来指定清理代码，它并不处理异常，而是无论之前的代码是否发生异常都会被执行。"

#: ../../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 ""

"Python "

"的错误处理采用的是“终止”模型：异常处理器可以找出发生了什么问题，并在外层继续执行，但它不能修复错误的根源并重试失败的操作（除非通过从顶层重新进入出错的代码片段）。"

#: ../../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:`非虚基类 "

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

"异常消息不是 Python API 的组成部分。 其内容可能在 Python "

"升级到新版本时不经警告地发生改变，不应该被需要在多版本解释器中运行的代码所依赖。"

#: ../../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

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

"Python 的执行模型并非是在真空中运作的。 它存在于一台主机并通过该主机的运行时环境运行，包括其中的操作系统 (OS)，如果有具体操作系统的话。 "

"当一个程序运行时，决定它如何在主机上运行的各个概念层大致是这样的："

#: ../../reference/executionmodel.rst:0

msgid "**host machine**"

msgstr "**主机**"

#: ../../reference/executionmodel.rst:0

msgid "**process** (global resources)"

msgstr "**进程** (全局资源)"

#: ../../reference/executionmodel.rst:0

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

"每个进程代表一个在主机上运行的程序。 可以将每个进程本身视作其程序的数据部分。 可以将进程的各个线程视为程序的执行部分。 这一区别对于理解 "

"Python 运行时的概念是很重要的。"

#: ../../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 ""

"从 Python 的角度来看，程序开始时总是只有一个线程。 但是，程序可能会发展为在多个线程中同时运行。 "

"并非所有主机都支持在每个进程中有多个线程，但多数确实如此。 与进程不同，进程中的线程并非相互隔离和独立的。 "

"具体来说，一个进程中的所有线程都共享进程的所有资源。"

#: ../../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 ""

"所谓非同步的速率意味着进程的任何内存都不保证对在任何给定线程中运行的代码是固定的。 因此多线程的程序必须小心协调对有意共享的资源的访问。 "

"类似地，它们也必须非常小心注意不要访问多线程中的任何 *其它* 资源；否则同时运行的两个线程可能会意外地干涉彼此对某些共享数据的使用。 这一点对于 "

"Python 程序和 Python 运行时来说都是如此。"

#: ../../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 "Python 运行时模型"

#: ../../reference/executionmodel.rst:471

msgid ""

"The same conceptual layers apply to each Python program, with some extra "

"data layers specific to Python:"

msgstr "相同的概念层级将应用于每个 Python 程序，并带有一些 Python 专属的数据层级："

#: ../../reference/executionmodel.rst:0

msgid "Python global runtime (*state*)"

msgstr "Python 全局运行时 (*状态*)"

#: ../../reference/executionmodel.rst:0

msgid "Python interpreter (*state*)"

msgstr "Python 解释器 (*状态*)"

#: ../../reference/executionmodel.rst:0

msgid "**thread** (runs Python bytecode and \"C-API\")"

msgstr "**线程** (运行 Python 字节码和 \"C-API\")"

#: ../../reference/executionmodel.rst:0

msgid "Python thread *state*"

msgstr "Python 线程 *状态*"

#: ../../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 ""

"在概念层级上：当一个 Python 程序启动时，它会完全符合上图的样子，每层各有一个。 "

"运行时可能发展为包括多个解释器，而每个解释器可能发展为包括多个线程状态。"

#: ../../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 ""

"一个 Python 具体实现不一定需要实现单独甚至实体的层级。 唯一的例外是将单独的层级直接指明或暴露给用户，例如通过 :mod:`threading`"

" 模块的情况。"

#: ../../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 "初始的解释器通常称为“主”解释器。 某些 Python 实现，像是 CPython，会给主解释器分配特殊角色。"

#: ../../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 ""

"类似地，运行时初始化所在的主机线程被称为“主”线程。 它可能不同于进程的初始线程，不过往往是同一个。 "

"在某些情况下“主线程”概念甚至可能更严格地限定为初始线程状态。 Python 运行时可能会赋予主线程一些专属任务，例如处理信号等。"

#: ../../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 ""

"作为一个整体，Python 运行时是由全局运行时状态、解释器和线程状态组成的。 "

"运行时会确保所有状态在其生命期内保持一致，特别是在使用多个主机线程的情况下。"

#: ../../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 ""

"作为对比，“解释器”在概念层级上就是我们通常认为是（具备完整功能的）“Python 运行时”。 当在一个主机线程中执行的机器码与 Python "

"运行时交互时，它将在特定的解释器上下文中对 Python 发起调用。"

#: ../../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 "这里使用的“解释器”一词不同于“字节码解释器”，后者通常运行于线程之中，执行已编译的 Python 代码。"

#: ../../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 ""

"在一个理想世界中，“Python 运行时”应该是指现在我们称为“解释器”的东西。 但是，它至少从 1997 年被引入开始就一直称为“解释器”了 "

"(`CPython:a027efa5b`_)。"

#: ../../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 ""

"每个解释器都完整地包裹了 Python 运行时工作所需的所有非进程全局、非线程专属的状态。 值得注意的是，解释器的状态在多次使用之间是持久的。 "

"它包括一些基础数据如 :data:`sys.modules`。 运行时会确保使用同一解释器的多个线程在它们之间安全地共享这些数据。"

#: ../../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 ""

"Python 的具体实现可能会支持在同一进程中同时使用多个解释器。 它们是彼此独立并且相互隔离的。 例如，每个解释器都有自己的 "

":data:`sys.modules`。"

#: ../../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 ""

"在概念层级上，每个线程状态都拥有解释器在一个主机线程中动作所需的所有线程专属运行时数据。 线程状态包括当前引发的异常和线程的 Python 调用栈。 "

"它还可能包括其他线程专属的资源。"

#: ../../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 "“Python 线程”一词有时是指一个线程状态，但通常它都表示使用 :mod:`threading` 模块创建的线程。"

#: ../../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 ""

"在一个程序运行的时候，可以（在支持线程的平台和 Python 实现上）使用 :mod:`threading` 模块创建新的 Python 线程。 "

"额外的进程可以使用 :mod:`os`, :mod:`subprocess` 和 :mod:`multiprocessing` 模块来创建。 "

"解释器可以通过 :mod:`~concurrent.interpreters` 模块来创建和使用。 （异步）协程可以在每个解释器中使用 "

":mod:`asyncio` 来运行，通常仅限于单个线程（往往是主线程）之中。"

#: ../../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 "code -- 代码"

#: ../../reference/executionmodel.rst:8 ../../reference/executionmodel.rst:17

msgid "block"

msgstr "block"

#: ../../reference/executionmodel.rst:31

#: ../../reference/executionmodel.rst:299

msgid "execution"

msgstr "执行"

#: ../../reference/executionmodel.rst:31