# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Shengjing Zhu <zsj950618@gmail.com>, 2019

# nick <2330458484@qq.com>, 2019

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2021-01-01 16:02+0000\n"

"PO-Revision-Date: 2019-09-01 03:43+0000\n"

"Last-Translator: Freesand Leo <yuqinju@163.com>, 2021\n"

"Language-Team: Chinese (China) (https://www.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/simple_stmts.rst:6

msgid "Simple statements"

msgstr "简单语句"

#: ../../reference/simple_stmts.rst:10

msgid ""

"A simple statement is comprised within a single logical line. Several simple"

" statements may occur on a single line separated by semicolons. The syntax "

"for simple statements is:"

msgstr "简单语句由一个单独的逻辑行构成。 多条简单语句可以存在于同一行内并以分号分隔。 简单语句的句法为:"

#: ../../reference/simple_stmts.rst:36

msgid "Expression statements"

msgstr "表达式语句"

#: ../../reference/simple_stmts.rst:43

msgid ""

"Expression statements are used (mostly interactively) to compute and write a"

" value, or (usually) to call a procedure (a function that returns no "

"meaningful result; in Python, procedures return the value ``None``). Other "

"uses of expression statements are allowed and occasionally useful. The "

"syntax for an expression statement is:"

msgstr ""

"表达式语句用于计算和写入值（大多是在交互模式下），或者（通常情况）调用一个过程 (过程就是不返回有意义结果的函数；在 Python 中，过程的返回值为 "

"``None``)。 表达式语句的其他使用方式也是允许且有特定用处的。 表达式语句的句法为:"

#: ../../reference/simple_stmts.rst:52

msgid ""

"An expression statement evaluates the expression list (which may be a single"

" expression)."

msgstr "表达式语句会对指定的表达式列表（也可能为单一表达式）进行求值。"

#: ../../reference/simple_stmts.rst:64

msgid ""

"In interactive mode, if the value is not ``None``, it is converted to a "

"string using the built-in :func:`repr` function and the resulting string is "

"written to standard output on a line by itself (except if the result is "

"``None``, so that procedure calls do not cause any output.)"

msgstr ""

"在交互模式下，如果结果值不为 ``None``，它会通过内置的 :func:`repr` "

"函数转换为一个字符串，该结果字符串将以单独一行的形式写入标准输出（例外情况是如果结果为 ``None``，则该过程调用不产生任何输出。）"

#: ../../reference/simple_stmts.rst:72

msgid "Assignment statements"

msgstr "赋值语句"

#: ../../reference/simple_stmts.rst:82

msgid ""

"Assignment statements are used to (re)bind names to values and to modify "

"attributes or items of mutable objects:"

msgstr "赋值语句用于将名称（重）绑定到特定值，以及修改属性或可变对象的成员项:"

#: ../../reference/simple_stmts.rst:96

msgid ""

"(See section :ref:`primaries` for the syntax definitions for *attributeref*,"

" *subscription*, and *slicing*.)"

msgstr "(请参阅 :ref:`primaries` 一节了解 *属性引用*, *抽取* 和 *切片* 的句法定义。)"

#: ../../reference/simple_stmts.rst:99

msgid ""

"An assignment statement evaluates the expression list (remember that this "

"can be a single expression or a comma-separated list, the latter yielding a "

"tuple) and assigns the single resulting object to each of the target lists, "

"from left to right."

msgstr ""

"赋值语句会对指定的表达式列表进行求值（注意这可能为单一表达式或是由逗号分隔的列表，后者将产生一个元组）并将单一结果对象从左至右逐个赋值给目标列表。"

#: ../../reference/simple_stmts.rst:108

msgid ""

"Assignment is defined recursively depending on the form of the target "

"(list). When a target is part of a mutable object (an attribute reference, "

"subscription or slicing), the mutable object must ultimately perform the "

"assignment and decide about its validity, and may raise an exception if the "

"assignment is unacceptable. The rules observed by various types and the "

"exceptions raised are given with the definition of the object types (see "

"section :ref:`types`)."

msgstr ""

"赋值是根据目标（列表）的格式递归地定义的。 "

"当目标为一个可变对象（属性引用、抽取或切片）的组成部分时，该可变对象必须最终执行赋值并决定其有效性，如果赋值操作不可接受也可能引发异常。 "

"各种类型可用的规则和引发的异常通过对象类型的定义给出（参见 :ref:`types` 一节）。"

#: ../../reference/simple_stmts.rst:121

msgid ""

"Assignment of an object to a target list, optionally enclosed in parentheses"

" or square brackets, is recursively defined as follows."

msgstr "对象赋值的目标对象可以包含于圆括号或方括号内，具体操作按以下方式递归地定义。"

#: ../../reference/simple_stmts.rst:124

msgid ""

"If the target list is a single target with no trailing comma, optionally in "

"parentheses, the object is assigned to that target."

msgstr "如果目标列表为后面不带逗号、可以包含于圆括号内的单一目标，则将对象赋值给该目标。"

#: ../../reference/simple_stmts.rst:127 ../../reference/simple_stmts.rst:139

msgid ""

"Else: The object must be an iterable with the same number of items as there "

"are targets in the target list, and the items are assigned, from left to "

"right, to the corresponding targets."

msgstr "否则：该对象必须为具有与目标列表相同项数的可迭代对象，这些项将按从左至右的顺序被赋值给对应的目标。"

#: ../../reference/simple_stmts.rst:131

msgid ""

"If the target list contains one target prefixed with an asterisk, called a "

"\"starred\" target: The object must be an iterable with at least as many "

"items as there are targets in the target list, minus one. The first items "

"of the iterable are assigned, from left to right, to the targets before the "

"starred target. The final items of the iterable are assigned to the targets"

" after the starred target. A list of the remaining items in the iterable is"

" then assigned to the starred target (the list can be empty)."

msgstr ""

"如果目标列表包含一个带有星号前缀的目标，这称为“加星”目标：则该对象至少必须为与目标列表项数减一相同项数的可迭代对象。 "

"该可迭代对象前面的项将按从左至右的顺序被赋值给加星目标之前的目标。 该可迭代对象末尾的项将被赋值给加星目标之后的目标。 "

"然后该可迭代对象中剩余项的列表将被赋值给加星目标（该列表可以为空）。"

#: ../../reference/simple_stmts.rst:143

msgid ""

"Assignment of an object to a single target is recursively defined as "

"follows."

msgstr "对象赋值给单个目标的操作按以下方式递归地定义。"

#: ../../reference/simple_stmts.rst:145

msgid "If the target is an identifier (name):"

msgstr "如果目标为标识符（名称）:"

#: ../../reference/simple_stmts.rst:147

msgid ""

"If the name does not occur in a :keyword:`global` or :keyword:`nonlocal` "

"statement in the current code block: the name is bound to the object in the "

"current local namespace."

msgstr ""

"如果该名称未出现于当前代码块的 :keyword:`global` 或 :keyword:`nonlocal` "

"语句中：该名称将被绑定到当前局部命名空间的对象。"

#: ../../reference/simple_stmts.rst:151

msgid ""

"Otherwise: the name is bound to the object in the global namespace or the "

"outer namespace determined by :keyword:`nonlocal`, respectively."

msgstr "否则：该名称将被分别绑定到全局命名空间或由 :keyword:`nonlocal` 所确定的外层命名空间的对象。"

#: ../../reference/simple_stmts.rst:156

msgid ""

"The name is rebound if it was already bound. This may cause the reference "

"count for the object previously bound to the name to reach zero, causing the"

" object to be deallocated and its destructor (if it has one) to be called."

msgstr ""

"如果该名称已经被绑定则将被重新绑定。 这可能导致之前被绑定到该名称的对象的引用计数变为零，造成该对象进入释放过程并调用其析构器（如果存在）。"

#: ../../reference/simple_stmts.rst:162

msgid ""

"If the target is an attribute reference: The primary expression in the "

"reference is evaluated. It should yield an object with assignable "

"attributes; if this is not the case, :exc:`TypeError` is raised. That "

"object is then asked to assign the assigned object to the given attribute; "

"if it cannot perform the assignment, it raises an exception (usually but not"

" necessarily :exc:`AttributeError`)."

msgstr ""

"如果该对象为属性引用：引用中的原型表达式会被求值。 它应该产生一个具有可赋值属性的对象；否则将引发 :exc:`TypeError`。 "

"该对象会被要求将可赋值对象赋值给指定的属性；如果它无法执行赋值，则会引发异常 (通常应为 :exc:`AttributeError` 但并不强制要求)。"

#: ../../reference/simple_stmts.rst:171

msgid ""

"Note: If the object is a class instance and the attribute reference occurs "

"on both sides of the assignment operator, the RHS expression, ``a.x`` can "

"access either an instance attribute or (if no instance attribute exists) a "

"class attribute. The LHS target ``a.x`` is always set as an instance "

"attribute, creating it if necessary. Thus, the two occurrences of ``a.x`` "

"do not necessarily refer to the same attribute: if the RHS expression refers"

" to a class attribute, the LHS creates a new instance attribute as the "

"target of the assignment::"

msgstr ""

"注意：如果该对象为类实例并且属性引用在赋值运算符的两侧都出现，则右侧表达式 ``a.x`` 可以访问实例属性或（如果实例属性不存在）类属性。 左侧目标 "

"``a.x`` 将总是设定为实例属性，并在必要时创建该实例属性。 因此，``a.x`` "

"的两次出现不一定指向相同的属性：如果右侧表达式指向一个类属性，则左侧表达式会创建一个新的实例属性作为赋值的目标::"

#: ../../reference/simple_stmts.rst:185

msgid ""

"This description does not necessarily apply to descriptor attributes, such "

"as properties created with :func:`property`."

msgstr "此描述不一定作用于描述器属性，例如通过 :func:`property` 创建的特征属性。"

#: ../../reference/simple_stmts.rst:192

msgid ""

"If the target is a subscription: The primary expression in the reference is "

"evaluated. It should yield either a mutable sequence object (such as a "

"list) or a mapping object (such as a dictionary). Next, the subscript "

"expression is evaluated."

msgstr ""

"如果目标为一个抽取项：引用中的原型表达式会被求值。 它应当产生一个可变序列对象（例如列表）或一个映射对象（例如字典）。 接下来，该抽取表达式会被求值。"

#: ../../reference/simple_stmts.rst:201

msgid ""

"If the primary is a mutable sequence object (such as a list), the subscript "

"must yield an integer. If it is negative, the sequence's length is added to"

" it. The resulting value must be a nonnegative integer less than the "

"sequence's length, and the sequence is asked to assign the assigned object "

"to its item with that index. If the index is out of range, "

":exc:`IndexError` is raised (assignment to a subscripted sequence cannot add"

" new items to a list)."

msgstr ""

"如果原型为一个可变序列对象（例如列表），抽取应产生一个整数。 如其为负值，则再加上序列长度。 "

"结果值必须为一个小于序列长度的非负整数，序列将把被赋值对象赋值给该整数指定索引号的项。 如果索引超出范围，将会引发 :exc:`IndexError` "

"(给被抽取序列赋值不能向列表添加新项)。"

#: ../../reference/simple_stmts.rst:212

msgid ""

"If the primary is a mapping object (such as a dictionary), the subscript "

"must have a type compatible with the mapping's key type, and the mapping is "

"then asked to create a key/datum pair which maps the subscript to the "

"assigned object. This can either replace an existing key/value pair with "

"the same key value, or insert a new key/value pair (if no key with the same "

"value existed)."

msgstr ""

"如果原型为一个映射对象（例如字典），抽取必须具有与该映射的键类型相兼容的类型，然后映射中会创建一个将抽取映射到被赋值对象的键/值对。 "

"这可以是替换一个现有键/值对并保持相同键值，也可以是插入一个新键/值对（如果具有相同值的键不存在）。"

#: ../../reference/simple_stmts.rst:218

msgid ""

"For user-defined objects, the :meth:`__setitem__` method is called with "

"appropriate arguments."

msgstr "对于用户定义对象，会调用 :meth:`__setitem__` 方法并附带适当的参数。"

#: ../../reference/simple_stmts.rst:223

msgid ""

"If the target is a slicing: The primary expression in the reference is "

"evaluated. It should yield a mutable sequence object (such as a list). The"

" assigned object should be a sequence object of the same type. Next, the "

"lower and upper bound expressions are evaluated, insofar they are present; "

"defaults are zero and the sequence's length. The bounds should evaluate to "

"integers. If either bound is negative, the sequence's length is added to it."

" The resulting bounds are clipped to lie between zero and the sequence's "

"length, inclusive. Finally, the sequence object is asked to replace the "

"slice with the items of the assigned sequence. The length of the slice may "

"be different from the length of the assigned sequence, thus changing the "

"length of the target sequence, if the target sequence allows it."

msgstr ""

"如果目标为一个切片：引用中的原型表达式会被求值。 它应当产生一个可变序列对象（例如列表）。 被赋值对象应当是一个相同类型的序列对象。 "

"接下来，下界与上界表达式如果存在的话将被求值；默认值分别为零和序列长度。 上下边界值应当为整数。 如果某一边界为负值，则会加上序列长度。 "

"求出的边界会被裁剪至介于零和序列长度的开区间中。 最后，将要求序列对象以被赋值序列的项替换该切片。 "

"切片的长度可能与被赋值序列的长度不同，这会在目标序列允许的情况下改变目标序列的长度。"

#: ../../reference/simple_stmts.rst:237

msgid ""

"In the current implementation, the syntax for targets is taken to be the "

"same as for expressions, and invalid syntax is rejected during the code "

"generation phase, causing less detailed error messages."

msgstr "在当前实现中，目标的句法被当作与表达式的句法相同，无效的句法会在代码生成阶段被拒绝，导致不太详细的错误信息。"

#: ../../reference/simple_stmts.rst:241

msgid ""

"Although the definition of assignment implies that overlaps between the "

"left-hand side and the right-hand side are 'simultaneous' (for example ``a, "

"b = b, a`` swaps two variables), overlaps *within* the collection of "

"assigned-to variables occur left-to-right, sometimes resulting in confusion."

" For instance, the following program prints ``[0, 2]``::"

msgstr ""

"虽然赋值的定义意味着左手边与右手边的重叠是“同时”进行的（例如 ``a, b = b, a`` 会交换两个变量的值），但在赋值给变量的多项集 *之内* "

"的重叠是从左至右进行的，这有时会令人混淆。 例如，以下程序将会打印出 ``[0, 2]``::"

#: ../../reference/simple_stmts.rst:255

msgid ":pep:`3132` - Extended Iterable Unpacking"

msgstr ":pep:`3132` - 扩展的可迭代对象拆包"

#: ../../reference/simple_stmts.rst:256

msgid "The specification for the ``*target`` feature."

msgstr "对 ``*target`` 特性的规范说明。"

#: ../../reference/simple_stmts.rst:262

msgid "Augmented assignment statements"

msgstr "增强赋值语句"

#: ../../reference/simple_stmts.rst:280

msgid ""

"Augmented assignment is the combination, in a single statement, of a binary "

"operation and an assignment statement:"

msgstr "增强赋值语句就是在单个语句中将二元运算和赋值语句合为一体:"

#: ../../reference/simple_stmts.rst:289

msgid ""

"(See section :ref:`primaries` for the syntax definitions of the last three "

"symbols.)"

msgstr "（请参阅 :ref:`primaries` 一节了解最后三种符号的句法定义。）"

#: ../../reference/simple_stmts.rst:292

msgid ""

"An augmented assignment evaluates the target (which, unlike normal "

"assignment statements, cannot be an unpacking) and the expression list, "

"performs the binary operation specific to the type of assignment on the two "

"operands, and assigns the result to the original target. The target is only"

" evaluated once."

msgstr ""

"增强赋值语句将对目标和表达式列表求值（与普通赋值语句不同的是，前者不能为可迭代对象拆包），对两个操作数相应类型的赋值执行指定的二元运算，并将结果赋值给原始目标。"

" 目标仅会被求值一次。"

#: ../../reference/simple_stmts.rst:297

msgid ""

"An augmented assignment expression like ``x += 1`` can be rewritten as ``x ="

" x + 1`` to achieve a similar, but not exactly equal effect. In the "

"augmented version, ``x`` is only evaluated once. Also, when possible, the "

"actual operation is performed *in-place*, meaning that rather than creating "

"a new object and assigning that to the target, the old object is modified "

"instead."

msgstr ""

"增强赋值语句例如 ``x += 1`` 可以改写为 ``x = x + 1`` 获得类似但并非完全等价的效果。 在增强赋值的版本中，``x`` "

"仅会被求值一次。 而且，在可能的情况下，实际的运算是 *原地* 执行的，也就是说并不是创建一个新对象并将其赋值给目标，而是直接修改原对象。"

#: ../../reference/simple_stmts.rst:303

msgid ""

"Unlike normal assignments, augmented assignments evaluate the left-hand side"

" *before* evaluating the right-hand side. For example, ``a[i] += f(x)`` "

"first looks-up ``a[i]``, then it evaluates ``f(x)`` and performs the "

"addition, and lastly, it writes the result back to ``a[i]``."

msgstr ""

"不同于普通赋值，增强赋值会在对右手边求值 *之前* 对左手边求值。 例如，``a[i] += f(x)`` 首先查找 ``a[i]``，然后对 "

"``f(x)`` 求值并执行加法操作，最后将结果写回到 ``a[i]``。"

#: ../../reference/simple_stmts.rst:308

msgid ""

"With the exception of assigning to tuples and multiple targets in a single "

"statement, the assignment done by augmented assignment statements is handled"

" the same way as normal assignments. Similarly, with the exception of the "

"possible *in-place* behavior, the binary operation performed by augmented "

"assignment is the same as the normal binary operations."

msgstr ""

"除了在单个语句中赋值给元组和多个目标的例外情况，增强赋值语句的赋值操作处理方式与普通赋值相同。 类似地，除了可能存在 *原地* "

"操作行为的例外情况，增强赋值语句执行的二元运算也与普通二元运算相同。"

#: ../../reference/simple_stmts.rst:314

msgid ""

"For targets which are attribute references, the same :ref:`caveat about "

"class and instance attributes <attr-target-note>` applies as for regular "

"assignments."

msgstr "对于属性引用类目标，针对常规赋值的 :ref:`关于类和实例属性的警告 <attr-target-note>` 也同样适用。"

#: ../../reference/simple_stmts.rst:321

msgid "Annotated assignment statements"

msgstr "带标注的赋值语句"

#: ../../reference/simple_stmts.rst:328

msgid ""

":term:`Annotation <variable annotation>` assignment is the combination, in a"

" single statement, of a variable or attribute annotation and an optional "

"assignment statement:"

msgstr ":term:`标注 <variable annotation>` 赋值就是在单个语句中将变量或属性标注和可选的赋值语句合为一体:"

#: ../../reference/simple_stmts.rst:334

msgid ""

"The difference from normal :ref:`assignment` is that only single target and "

"only single right hand side value is allowed."

msgstr "与普通 :ref:`assignment` 的差别在于仅有单个目标且仅有单个右手边的值才被允许。"

#: ../../reference/simple_stmts.rst:337

msgid ""

"For simple names as assignment targets, if in class or module scope, the "

"annotations are evaluated and stored in a special class or module attribute "

":attr:`__annotations__` that is a dictionary mapping from variable names "

"(mangled if private) to evaluated annotations. This attribute is writable "

"and is automatically created at the start of class or module body execution,"

" if annotations are found statically."

msgstr ""

"对于将简单名称作为赋值目标的情况，如果是在类或模块作用域中，标注会被求值并存入一个特殊的类或模块属性 :attr:`__annotations__` "

"中，这是一个将变量名称（如为私有会被移除）映射到被求值标注的字典。 此属性为可写并且在类或模块体开始执行时如果静态地发现标注就会自动创建。"

#: ../../reference/simple_stmts.rst:345

msgid ""

"For expressions as assignment targets, the annotations are evaluated if in "

"class or module scope, but not stored."

msgstr "对于将表达式作为赋值目标的情况，如果是在类或模块作用域中，标注会被求值，但不会保存。"

#: ../../reference/simple_stmts.rst:348

msgid ""

"If a name is annotated in a function scope, then this name is local for that"

" scope. Annotations are never evaluated and stored in function scopes."

msgstr "如果一个名称在函数作用域内被标注，则该名称为该作用域的局部变量。 标注绝不会在函数作用域内被求值和保存。"

#: ../../reference/simple_stmts.rst:351

msgid ""

"If the right hand side is present, an annotated assignment performs the "

"actual assignment before evaluating annotations (where applicable). If the "

"right hand side is not present for an expression target, then the "

"interpreter evaluates the target except for the last :meth:`__setitem__` or "

":meth:`__setattr__` call."

msgstr ""

"如果存在右手边，带标注的赋值会在对标注求值之前（如果适用）执行实际的赋值。 如果用作表达式目标的右手边不存在，则解释器会对目标求值，但最后的 "

":meth:`__setitem__` 或 :meth:`__setattr__` 调用除外。"

#: ../../reference/simple_stmts.rst:362

msgid ":pep:`526` - Syntax for Variable Annotations"

msgstr ":pep:`526` - 变量标注的语法"

#: ../../reference/simple_stmts.rst:360

msgid ""

"The proposal that added syntax for annotating the types of variables "

"(including class variables and instance variables), instead of expressing "

"them through comments."

msgstr "该提议增加了标注变量（也包括类变量和实例变量）类型的语法，而不再是通过注释来进行表达。"

#: ../../reference/simple_stmts.rst:366

msgid ":pep:`484` - Type hints"

msgstr ":pep:`484` - 类型提示"

#: ../../reference/simple_stmts.rst:365

msgid ""

"The proposal that added the :mod:`typing` module to provide a standard "

"syntax for type annotations that can be used in static analysis tools and "

"IDEs."

msgstr "该提议增加了 :mod:`typing` 模块以便为类型标注提供标准句法，可被静态分析工具和 IDE 所使用。"

#: ../../reference/simple_stmts.rst:373

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

msgstr ":keyword:`!assert` 语句"

#: ../../reference/simple_stmts.rst:380

msgid ""

"Assert statements are a convenient way to insert debugging assertions into a"

" program:"

msgstr "assert 语句是在程序中插入调试性断言的简便方式:"

#: ../../reference/simple_stmts.rst:386

msgid "The simple form, ``assert expression``, is equivalent to ::"

msgstr "简单形式 ``assert expression`` 等价于 ::"

#: ../../reference/simple_stmts.rst:391

msgid ""

"The extended form, ``assert expression1, expression2``, is equivalent to ::"

msgstr "扩展形式 ``assert expression1, expression2`` 等价于 ::"

#: ../../reference/simple_stmts.rst:400

msgid ""

"These equivalences assume that :const:`__debug__` and :exc:`AssertionError` "

"refer to the built-in variables with those names. In the current "

"implementation, the built-in variable :const:`__debug__` is ``True`` under "

"normal circumstances, ``False`` when optimization is requested (command line"

" option :option:`-O`). The current code generator emits no code for an "

"assert statement when optimization is requested at compile time. Note that "

"it is unnecessary to include the source code for the expression that failed "

"in the error message; it will be displayed as part of the stack trace."

msgstr ""

"以上等价形式假定 :const:`__debug__` 和 :exc:`AssertionError` 指向具有指定名称的内置变量。 "

"在当前实现中，内置变量 :const:`__debug__` 在正常情况下为 ``True``，在请求优化时为 ``False`` (对应命令行选项为 "

":option:`-O`)。 如果在编译时请求优化，当前代码生成器不会为 assert 语句发出任何代码。 "

"请注意不必在错误信息中包含失败表达式的源代码；它会被作为栈追踪的一部分被显示。"

#: ../../reference/simple_stmts.rst:409

msgid ""

"Assignments to :const:`__debug__` are illegal. The value for the built-in "

"variable is determined when the interpreter starts."

msgstr "赋值给 :const:`__debug__` 是非法的。 该内置变量的值会在解释器启动时确定。"

#: ../../reference/simple_stmts.rst:416

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

msgstr ":keyword:`!pass` 语句"

#: ../../reference/simple_stmts.rst:426

msgid ""

":keyword:`pass` is a null operation --- when it is executed, nothing "

"happens. It is useful as a placeholder when a statement is required "

"syntactically, but no code needs to be executed, for example::"

msgstr ""

":keyword:`pass` 是一个空操作 --- 当它被执行时，什么都不发生。 "

"它适合当语法上需要一条语句但并不需要执行任何代码时用来临时占位，例如::"

#: ../../reference/simple_stmts.rst:438

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

msgstr ":keyword:`!del` 语句"

#: ../../reference/simple_stmts.rst:448

msgid ""

"Deletion is recursively defined very similar to the way assignment is "

"defined. Rather than spelling it out in full details, here are some hints."

msgstr "删除是递归定义的，与赋值的定义方式非常类似。 此处不再详细说明，只给出一些提示。"

#: ../../reference/simple_stmts.rst:451

msgid ""

"Deletion of a target list recursively deletes each target, from left to "

"right."

msgstr "目标列表的删除将从左至右递归地删除每一个目标。"

#: ../../reference/simple_stmts.rst:457

msgid ""

"Deletion of a name removes the binding of that name from the local or global"

" namespace, depending on whether the name occurs in a :keyword:`global` "

"statement in the same code block. If the name is unbound, a "

":exc:`NameError` exception will be raised."

msgstr ""

"名称的删除将从局部或全局命名空间中移除该名称的绑定，具体作用域的确定是看该名称是否有在同一代码块的 :keyword:`global` 语句中出现。 "

"如果该名称未被绑定，将会引发 :exc:`NameError`。"

#: ../../reference/simple_stmts.rst:464

msgid ""

"Deletion of attribute references, subscriptions and slicings is passed to "

"the primary object involved; deletion of a slicing is in general equivalent "

"to assignment of an empty slice of the right type (but even this is "

"determined by the sliced object)."

msgstr "属性引用、抽取和切片的删除会被传递给相应的原型对象；删除一个切片基本等价于赋值为一个右侧类型的空切片（但即便这一点也是由切片对象决定的）。"

#: ../../reference/simple_stmts.rst:469

msgid ""

"Previously it was illegal to delete a name from the local namespace if it "

"occurs as a free variable in a nested block."

msgstr "在之前版本中，如果一个名称作为被嵌套代码块中的自由变量出现，则将其从局部命名空间中删除是非法的。"

#: ../../reference/simple_stmts.rst:477

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

msgstr ":keyword:`!return` 语句"

#: ../../reference/simple_stmts.rst:487

msgid ""

":keyword:`return` may only occur syntactically nested in a function "

"definition, not within a nested class definition."

msgstr ":keyword:`return` 在语法上只会出现于函数定义所嵌套的代码，不会出现于类定义所嵌套的代码。"

#: ../../reference/simple_stmts.rst:490

msgid ""

"If an expression list is present, it is evaluated, else ``None`` is "

"substituted."

msgstr "如果提供了表达式列表，它将被求值，否则以 ``None`` 替代。"

#: ../../reference/simple_stmts.rst:492

msgid ""

":keyword:`return` leaves the current function call with the expression list "

"(or ``None``) as return value."

msgstr ":keyword:`return` 会离开当前函数调用，并以表达式列表 (或 ``None``) 作为返回值。"

#: ../../reference/simple_stmts.rst:497

msgid ""

"When :keyword:`return` passes control out of a :keyword:`try` statement with"

" a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "

"before really leaving the function."

msgstr ""

"当 :keyword:`return` 将控制流传出一个带有 :keyword:`finally` 子句的 :keyword:`try` 语句时，该 "

":keyword:`!finally` 子句会先被执行然后再真正离开该函数。"

#: ../../reference/simple_stmts.rst:501

msgid ""

"In a generator function, the :keyword:`return` statement indicates that the "

"generator is done and will cause :exc:`StopIteration` to be raised. The "

"returned value (if any) is used as an argument to construct "

":exc:`StopIteration` and becomes the :attr:`StopIteration.value` attribute."

msgstr ""

"在一个生成器函数中，:keyword:`return` 语句表示生成器已完成并将导致 :exc:`StopIteration` 被引发。 "

"返回值（如果有的话）会被当作一个参数用来构建 :exc:`StopIteration` 并成为 :attr:`StopIteration.value` "

"属性。"

#: ../../reference/simple_stmts.rst:506

msgid ""

"In an asynchronous generator function, an empty :keyword:`return` statement "

"indicates that the asynchronous generator is done and will cause "

":exc:`StopAsyncIteration` to be raised. A non-empty :keyword:`!return` "

"statement is a syntax error in an asynchronous generator function."

msgstr ""

"在一个异步生成器函数中，一个空的 :keyword:`return` 语句表示异步生成器已完成并将导致 "

":exc:`StopAsyncIteration` 被引发。 一个非空的 :keyword:`!return` 语句在异步生成器函数中会导致语法错误。"

#: ../../reference/simple_stmts.rst:514

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

msgstr ":keyword:`!yield` 语句"

#: ../../reference/simple_stmts.rst:526

msgid ""

"A :keyword:`yield` statement is semantically equivalent to a :ref:`yield "

"expression <yieldexpr>`. The yield statement can be used to omit the "

"parentheses that would otherwise be required in the equivalent yield "

"expression statement. For example, the yield statements ::"

msgstr ""

":keyword:`yield` 语句在语义上等同于 :ref:`yield 表达式 <yieldexpr>`。 yield 语句可用来省略在使用等效的"

" yield 表达式语句时所必须的圆括号。 例如，以下 yield 语句 ::"

#: ../../reference/simple_stmts.rst:534

msgid "are equivalent to the yield expression statements ::"

msgstr "等同于以下 yield 表达式语句 ::"

#: ../../reference/simple_stmts.rst:539

msgid ""

"Yield expressions and statements are only used when defining a "

":term:`generator` function, and are only used in the body of the generator "

"function. Using yield in a function definition is sufficient to cause that "

"definition to create a generator function instead of a normal function."

msgstr ""

"yield 表达式和语句仅在定义 :term:`generator` 函数时使用，并且仅被用于生成器函数的函数体内部。 在函数定义中使用 yield "

"就足以使得该定义创建的是生成器函数而非普通函数。"

#: ../../reference/simple_stmts.rst:544

msgid ""

"For full details of :keyword:`yield` semantics, refer to the "

":ref:`yieldexpr` section."

msgstr "有关 :keyword:`yield` 语义的完整细节请参看 :ref:`yieldexpr` 一节。"

#: ../../reference/simple_stmts.rst:550

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

msgstr ":keyword:`!raise` 语句"

#: ../../reference/simple_stmts.rst:561

msgid ""

"If no expressions are present, :keyword:`raise` re-raises the last exception"

" that was active in the current scope. If no exception is active in the "

"current scope, a :exc:`RuntimeError` exception is raised indicating that "

"this is an error."

msgstr ""

"如果不带表达式，:keyword:`raise` 会重新引发当前作用域内最后一个激活的异常。 如果当前作用域内没有激活的异常，将会引发 "

":exc:`RuntimeError` 来提示错误。"

#: ../../reference/simple_stmts.rst:566

msgid ""

"Otherwise, :keyword:`raise` evaluates the first expression as the exception "

"object. It must be either a subclass or an instance of "

":class:`BaseException`. If it is a class, the exception instance will be "

"obtained when needed by instantiating the class with no arguments."

msgstr ""

"否则的话，:keyword:`raise` 会将第一个表达式求值为异常对象。 它必须为 :class:`BaseException` 的子类或实例。 "

"如果它是一个类，当需要时会通过不带参数地实例化该类来获得异常的实例。"

#: ../../reference/simple_stmts.rst:571

msgid ""

"The :dfn:`type` of the exception is the exception instance's class, the "

":dfn:`value` is the instance itself."

msgstr "异常的 :dfn:`类型` 为异常实例的类，:dfn:`值` 为实例本身。"

#: ../../reference/simple_stmts.rst:576

msgid ""

"A traceback object is normally created automatically when an exception is "

"raised and attached to it as the :attr:`__traceback__` attribute, which is "

"writable. You can create an exception and set your own traceback in one step"

" using the :meth:`with_traceback` exception method (which returns the same "

"exception instance, with its traceback set to its argument), like so::"

msgstr ""

"当异常被引发时通常会自动创建一个回溯对象并将其关联到可写的 :attr:`__traceback__` 属性。 你可以创建一个异常并同时使用 "

":meth:`with_traceback` 异常方法（该方法将返回同一异常实例，并将回溯对象设为其参数）设置自己的回溯，就像这样::"

#: ../../reference/simple_stmts.rst:588

msgid ""

"The ``from`` clause is used for exception chaining: if given, the second "

"*expression* must be another exception class or instance, which will then be"

" attached to the raised exception as the :attr:`__cause__` attribute (which "

"is writable). If the raised exception is not handled, both exceptions will "

"be printed::"

msgstr ""

"``from`` 子句用于异常串连：如果有该子句，则第二个 *表达式* 必须为另一个异常或实例，它将作为可写的 :attr:`__cause__` "

"属性被关联到所引发的异常。 如果引发的异常未被处理，两个异常都将被打印出来::"

#: ../../reference/simple_stmts.rst:609

msgid ""

"A similar mechanism works implicitly if an exception is raised inside an "

"exception handler or a :keyword:`finally` clause: the previous exception is "

"then attached as the new exception's :attr:`__context__` attribute::"

msgstr ""

"如果一个异常在异常处理器或 :keyword:`finally` clause: 中被引发，类似的机制会隐式地发挥作用，之前的异常将被关联到新异常的 "

":attr:`__context__` 属性::"

#: ../../reference/simple_stmts.rst:628

msgid ""

"Exception chaining can be explicitly suppressed by specifying :const:`None` "

"in the ``from`` clause::"

msgstr "异常串连可通过在 ``from`` 子句中指定 :const:`None` 来显式地加以抑制::"

#: ../../reference/simple_stmts.rst:640

msgid ""

"Additional information on exceptions can be found in section "

":ref:`exceptions`, and information about handling exceptions is in section "

":ref:`try`."

msgstr "有关异常的更多信息可在 :ref:`exceptions` 一节查看，有关处理异常的信息可在 :ref:`try` 一节查看。"

#: ../../reference/simple_stmts.rst:643

msgid ":const:`None` is now permitted as ``Y`` in ``raise X from Y``."

msgstr ":const:`None` 现在允许被用作 ``raise X from Y`` 中的 ``Y``。"

#: ../../reference/simple_stmts.rst:646

msgid ""

"The ``__suppress_context__`` attribute to suppress automatic display of the "

"exception context."

msgstr "使用 ``__suppress_context__`` 属性来抑制异常上下文的自动显示。"

#: ../../reference/simple_stmts.rst:653

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

msgstr ":keyword:`!break` 语句"

#: ../../reference/simple_stmts.rst:664

msgid ""

":keyword:`break` may only occur syntactically nested in a :keyword:`for` or "

":keyword:`while` loop, but not nested in a function or class definition "

"within that loop."

msgstr ""

":keyword:`break` 在语法上只会出现于 :keyword:`for` 或 :keyword:`while` "

"循环所嵌套的代码，但不会出现于该循环内部的函数或类定义所嵌套的代码。"

#: ../../reference/simple_stmts.rst:671

msgid ""

"It terminates the nearest enclosing loop, skipping the optional "

":keyword:`!else` clause if the loop has one."

msgstr "它会终结最近的外层循环，如果循环有可选的 :keyword:`!else` 子句，也会跳过该子句。"

#: ../../reference/simple_stmts.rst:674

msgid ""

"If a :keyword:`for` loop is terminated by :keyword:`break`, the loop control"

" target keeps its current value."

msgstr "如果一个 :keyword:`for` 循环被 :keyword:`break` 所终结，该循环的控制目标会保持其当前值。"

#: ../../reference/simple_stmts.rst:679

msgid ""

"When :keyword:`break` passes control out of a :keyword:`try` statement with "

"a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "

"before really leaving the loop."

msgstr ""

"当 :keyword:`break` 将控制流传出一个带有 :keyword:`finally` 子句的 :keyword:`try` 语句时，该 "

":keyword:`!finally` 子句会先被执行然后再真正离开该循环。"

#: ../../reference/simple_stmts.rst:687

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

msgstr ":keyword:`!continue` 语句"

#: ../../reference/simple_stmts.rst:699

msgid ""

":keyword:`continue` may only occur syntactically nested in a :keyword:`for` "

"or :keyword:`while` loop, but not nested in a function or class definition "

"or :keyword:`finally` clause within that loop. It continues with the next "

"cycle of the nearest enclosing loop."

msgstr ""

":keyword:`continue` 在语法上只会出现于 :keyword:`for` 或 :keyword:`while` "

"循环所嵌套的代码，但不会出现于该循环内部的函数或类定义或者 :keyword:`finally` 子句所嵌套的代码。 "

"它会继续执行最近的外层循环的下一个轮次。"

#: ../../reference/simple_stmts.rst:704

msgid ""

"When :keyword:`continue` passes control out of a :keyword:`try` statement "

"with a :keyword:`finally` clause, that :keyword:`!finally` clause is "

"executed before really starting the next loop cycle."

msgstr ""

"当 :keyword:`continue` 将控制流传出一个带有 :keyword:`finally` 子句的 :keyword:`try` 语句时，该"

" :keyword:`!finally` 子句会先被执行然后再真正开始循环的下一个轮次。"

#: ../../reference/simple_stmts.rst:713

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

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

#: ../../reference/simple_stmts.rst:734

msgid ""

"The basic import statement (no :keyword:`from` clause) is executed in two "

"steps:"

msgstr "基本的 import 语句（不带 :keyword:`from` 子句）会分两步执行:"

#: ../../reference/simple_stmts.rst:737

msgid "find a module, loading and initializing it if necessary"

msgstr "查找一个模块，如果有必要还会加载并初始化模块。"

#: ../../reference/simple_stmts.rst:738

msgid ""

"define a name or names in the local namespace for the scope where the "

":keyword:`import` statement occurs."

msgstr "在局部命名空间中为 :keyword:`import` 语句发生位置所处的作用域定义一个或多个名称。"

#: ../../reference/simple_stmts.rst:741

msgid ""

"When the statement contains multiple clauses (separated by commas) the two "

"steps are carried out separately for each clause, just as though the clauses"

" had been separated out into individual import statements."

msgstr "当语句包含多个子句（由逗号分隔）时这两个步骤将对每个子句分别执行，如同这些子句被分成独立的 import 语句一样。"

#: ../../reference/simple_stmts.rst:746

msgid ""

"The details of the first step, finding and loading modules are described in "

"greater detail in the section on the :ref:`import system <importsystem>`, "

"which also describes the various types of packages and modules that can be "

"imported, as well as all the hooks that can be used to customize the import "

"system. Note that failures in this step may indicate either that the module "

"could not be located, *or* that an error occurred while initializing the "

"module, which includes execution of the module's code."

msgstr ""

"第一个步骤即查找和加载模块的详情 :ref:`导入系统 <importsystem>` "

"一节中有更详细的描述，其中也描述了可被导入的多种类型的包和模块，以及可用于定制导入系统的所有钩子对象。 "

"请注意这一步如果失败，则可能说明模块无法找到，*或者* 是在初始化模块，包括执行模块代码期间发生了错误。"

#: ../../reference/simple_stmts.rst:754

msgid ""

"If the requested module is retrieved successfully, it will be made available"

" in the local namespace in one of three ways:"

msgstr "如果成功获取到请求的模块，则可以通过以下三种方式一之在局部命名空间中使用它:"

#: ../../reference/simple_stmts.rst:759

msgid ""

"If the module name is followed by :keyword:`!as`, then the name following "

":keyword:`!as` is bound directly to the imported module."

msgstr "如果模块名称之后带有 :keyword:`!as`，则跟在 :keyword:`!as` 之后的名称将直接绑定到所导入的模块。"

#: ../../reference/simple_stmts.rst:761

msgid ""

"If no other name is specified, and the module being imported is a top level "

"module, the module's name is bound in the local namespace as a reference to "

"the imported module"

msgstr "如果没有指定其他名称，且被导入的模块为最高层级模块，则模块的名称将被绑定到局部命名空间作为对所导入模块的引用。"

#: ../../reference/simple_stmts.rst:764

msgid ""

"If the module being imported is *not* a top level module, then the name of "

"the top level package that contains the module is bound in the local "

"namespace as a reference to the top level package. The imported module must "

"be accessed using its full qualified name rather than directly"

msgstr ""

"如果被导入的模块 *不是* 最高层级模块，则包含该模块的最高层级包的名称将被绑定到局部命名空间作为对该最高层级包的引用。 "

"所导入的模块必须使用其完整限定名称来访问而不能直接访问。"

#: ../../reference/simple_stmts.rst:774

msgid "The :keyword:`from` form uses a slightly more complex process:"

msgstr ":keyword:`from` 形式使用的过程略微繁复一些:"

#: ../../reference/simple_stmts.rst:776

msgid ""

"find the module specified in the :keyword:`from` clause, loading and "

"initializing it if necessary;"

msgstr "查找 :keyword:`from` 子句中指定的模块，如有必要还会加载并初始化模块；"

#: ../../reference/simple_stmts.rst:778

msgid ""

"for each of the identifiers specified in the :keyword:`import` clauses:"

msgstr "对于 :keyword:`import` 子句中指定的每个标识符："

#: ../../reference/simple_stmts.rst:780

msgid "check if the imported module has an attribute by that name"

msgstr "检查被导入模块是否有该名称的属性"

#: ../../reference/simple_stmts.rst:781

msgid ""

"if not, attempt to import a submodule with that name and then check the "

"imported module again for that attribute"

msgstr "如果没有，尝试导入具有该名称的子模块，然后再次检查被导入模块是否有该属性"

#: ../../reference/simple_stmts.rst:783

msgid "if the attribute is not found, :exc:`ImportError` is raised."

msgstr "如果未找到该属性，则引发 :exc:`ImportError`。"

#: ../../reference/simple_stmts.rst:784

msgid ""

"otherwise, a reference to that value is stored in the local namespace, using"

" the name in the :keyword:`!as` clause if it is present, otherwise using the"

" attribute name"

msgstr "否则的话，将对该值的引用存入局部命名空间，如果有 :keyword:`!as` 子句则使用其指定的名称，否则使用该属性的名称"

#: ../../reference/simple_stmts.rst:788

msgid "Examples::"

msgstr "示例::"

#: ../../reference/simple_stmts.rst:798

msgid ""

"If the list of identifiers is replaced by a star (``'*'``), all public names"

" defined in the module are bound in the local namespace for the scope where "

"the :keyword:`import` statement occurs."

msgstr ""

"如果标识符列表改为一个星号 (``'*'``)，则在模块中定义的全部公有名称都将按 :keyword:`import` "

"语句所在的作用域被绑定到局部命名空间。"

#: ../../reference/simple_stmts.rst:804

msgid ""

"The *public names* defined by a module are determined by checking the "

"module's namespace for a variable named ``__all__``; if defined, it must be "

"a sequence of strings which are names defined or imported by that module. "

"The names given in ``__all__`` are all considered public and are required to"

" exist. If ``__all__`` is not defined, the set of public names includes all"

" names found in the module's namespace which do not begin with an underscore"

" character (``'_'``). ``__all__`` should contain the entire public API. It "

"is intended to avoid accidentally exporting items that are not part of the "

"API (such as library modules which were imported and used within the "

"module)."

msgstr ""

"一个模块所定义的 *公有名称* 是由在模块的命名空间中检测一个名为 ``__all__`` "

"的变量来确定的；如果有定义，它必须是一个字符串列表，其中的项为该模块所定义或导入的名称。 在 ``__all__`` "

"中所给出的名称都会被视为公有并且应当存在。 如果 ``__all__`` 没有被定义，则公有名称的集合将包含在模块的命名空间中找到的所有不以下划线字符 "

"(``'_'``) 打头的名称。 ``__all__`` 应当包括整个公有 API。 它的目标是避免意外地导出不属于 API "

"的一部分的项（例如在模块内部被导入和使用的库模块）。"

#: ../../reference/simple_stmts.rst:814

msgid ""

"The wild card form of import --- ``from module import *`` --- is only "

"allowed at the module level. Attempting to use it in class or function "

"definitions will raise a :exc:`SyntaxError`."

msgstr ""

"通配符形式的导入 --- ``from module import *`` --- 仅在模块层级上被允许。 尝试在类或函数定义中使用它将引发 "

":exc:`SyntaxError`。"

#: ../../reference/simple_stmts.rst:821

msgid ""

"When specifying what module to import you do not have to specify the "

"absolute name of the module. When a module or package is contained within "

"another package it is possible to make a relative import within the same top"

" package without having to mention the package name. By using leading dots "

"in the specified module or package after :keyword:`from` you can specify how"

" high to traverse up the current package hierarchy without specifying exact "

"names. One leading dot means the current package where the module making the"

" import exists. Two dots means up one package level. Three dots is up two "

"levels, etc. So if you execute ``from . import mod`` from a module in the "

"``pkg`` package then you will end up importing ``pkg.mod``. If you execute "

"``from ..subpkg2 import mod`` from within ``pkg.subpkg1`` you will import "

"``pkg.subpkg2.mod``. The specification for relative imports is contained in "

"the :ref:`relativeimports` section."

msgstr ""

"当指定要导入哪个模块时，你不必指定模块的绝对名称。 当一个模块或包被包含在另一个包之中时，可以在同一个最高层级包中进行相对导入，而不必提及包名称。 "

"通过在 :keyword:`from` 之后指定的模块或包中使用前缀点号，你可以在不指定确切名称的情况下指明在当前包层级结构中要上溯多少级。 "

"一个前缀点号表示是执行导入的模块所在的当前包，两个点号表示上溯一个包层级。 三个点号表示上溯两级，依此类推。 因此如果你执行 ``from . "

"import mod`` 时所处位置为 ``pkg`` 包内的一个模块，则最终你将导入 ``pkg.mod``。 如果你执行 ``from "

"..subpkg2 import mod`` 时所处位置为 ``pkg.subpkg1`` 则你将导入 ``pkg.subpkg2.mod``。 "

"有关相对导入的规范说明包含在 :ref:`relativeimports` 一节中。"

#: ../../reference/simple_stmts.rst:835

msgid ""

":func:`importlib.import_module` is provided to support applications that "

"determine dynamically the modules to be loaded."

msgstr ":func:`importlib.import_module` 被提供用来为动态地确定要导入模块的应用提供支持。"

#: ../../reference/simple_stmts.rst:842

msgid "Future statements"

msgstr "future 语句"

#: ../../reference/simple_stmts.rst:848

msgid ""

"A :dfn:`future statement` is a directive to the compiler that a particular "

"module should be compiled using syntax or semantics that will be available "

"in a specified future release of Python where the feature becomes standard."

msgstr ""

":dfn:`future 语句` 是一种针对编译器的指令，指明某个特定模块应当使用在特定的未来某个 Python 发行版中成为标准特性的语法或语义。"

#: ../../reference/simple_stmts.rst:852

msgid ""

"The future statement is intended to ease migration to future versions of "

"Python that introduce incompatible changes to the language. It allows use "

"of the new features on a per-module basis before the release in which the "

"feature becomes standard."

msgstr ""

"future 语句的目的是使得向在语言中引入了不兼容改变的 Python 未来版本的迁移更为容易。 "

"它允许基于每个模块在某种新特性成为标准之前的发行版中使用该特性。"

#: ../../reference/simple_stmts.rst:864

msgid ""

"A future statement must appear near the top of the module. The only lines "

"that can appear before a future statement are:"

msgstr "future 语句必须在靠近模块开头的位置出现。 可以出现在 future 语句之前行只有:"

#: ../../reference/simple_stmts.rst:867

msgid "the module docstring (if any),"

msgstr "模块的文档字符串（如果存在），"

#: ../../reference/simple_stmts.rst:868

msgid "comments,"

msgstr "注释，"

#: ../../reference/simple_stmts.rst:869

msgid "blank lines, and"

msgstr "空行，以及"

#: ../../reference/simple_stmts.rst:870

msgid "other future statements."

msgstr "其他 future 语句。"

#: ../../reference/simple_stmts.rst:872

msgid ""

"The only feature in Python 3.7 that requires using the future statement is "

"``annotations``."

msgstr "在 Python 3.7 中唯一需要使用 future 语句的特性是 ``标注``。"

#: ../../reference/simple_stmts.rst:875

msgid ""

"All historical features enabled by the future statement are still recognized"

" by Python 3. The list includes ``absolute_import``, ``division``, "

"``generators``, ``generator_stop``, ``unicode_literals``, "

"``print_function``, ``nested_scopes`` and ``with_statement``. They are all "

"redundant because they are always enabled, and only kept for backwards "

"compatibility."

msgstr ""

"future 语句所启用的所有历史特性仍然为 Python 3 所认可。 其中包括 ``absolute_import``, "

"``division``, ``generators``, ``generator_stop``, ``unicode_literals``, "

"``print_function``, ``nested_scopes`` 和 ``with_statement``。 "

"它们都已成为冗余项，因为它们总是为已启用状态，保留它们只是为了向后兼容。"

#: ../../reference/simple_stmts.rst:882

msgid ""

"A future statement is recognized and treated specially at compile time: "

"Changes to the semantics of core constructs are often implemented by "

"generating different code. It may even be the case that a new feature "

"introduces new incompatible syntax (such as a new reserved word), in which "