6. 简单语句
***********

Simple statements are comprised within a single logical line. Several
simple statements may occur on a single line separated by semicolons.
The syntax for simple statements is:

   simple_stmt ::= expression_stmt
                   | assert_stmt
                   | assignment_stmt
                   | augmented_assignment_stmt
                   | pass_stmt
                   | del_stmt
                   | print_stmt
                   | return_stmt
                   | yield_stmt
                   | raise_stmt
                   | break_stmt
                   | continue_stmt
                   | import_stmt
                   | future_stmt
                   | global_stmt
                   | exec_stmt


6.1. 表达式语句
===============

表达式语句用于计算和写入值（大多是在交互模式下），或者（通常情况）调用
一个过程 (过程就是不返回有意义结果的函数；在 Python 中，过程的返回值为
"None")。 表达式语句的其他使用方式也是允许且有特定用处的。 表达式语句
的句法为:

   expression_stmt ::= expression_list

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

In interactive mode, if the value is not "None", it is converted to a
string using the built-in "repr()" function and the resulting string
is written to standard output (see section The print statement) on a
line by itself.  (Expression statements yielding "None" are not
written, so that procedure calls do not cause any output.)


6.2. 赋值语句
=============

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

   assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)
   target_list     ::= target ("," target)* [","]
   target          ::= identifier
              | "(" target_list ")"
              | "[" [target_list] "]"
              | attributeref
              | subscription
              | slicing

(See section 原型 for the syntax definitions for the last three
symbols.)

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

赋值是根据目标（列表）的格式递归地定义的。 当目标为一个可变对象（属性
引用、抽取或切片）的组成部分时，该可变对象必须最终执行赋值并决定其有效
性，如果赋值操作不可接受也可能引发异常。 各种类型可用的规则和引发的异
常通过对象类型的定义给出（参见 标准类型层级结构 一节）。

Assignment of an object to a target list is recursively defined as
follows.

* If the target list is a single target: The object is assigned to
  that target.

* If the target list is a comma-separated list of targets: 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.

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

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

  * If the name does not occur in a "global" statement in the
    current code block: the name is bound to the object in the current
    local namespace.

  * Otherwise: the name is bound to the object in the current global
    namespace.

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

* If the target is a target list enclosed in parentheses or in
  square brackets: The object must be an iterable with the same number
  of items as there are targets in the target list, and its items are
  assigned, from left to right, to the corresponding targets.

* 如果该对象为属性引用：引用中的原型表达式会被求值。 它应该产生一个
  具 有可赋值属性的对象；否则将引发 "TypeError"。 该对象会被要求将可赋
  值 对象赋值给指定的属性；如果它无法执行赋值，则会引发异常 (通常应为
  "AttributeError" 但并不强制要求)。

  注意：如果该对象为类实例并且属性引用在赋值运算符的两侧都出现，则右侧
  表达式 "a.x" 可以访问实例属性或（如果实例属性不存在）类属性。 左侧目
  标 "a.x" 将总是设定为实例属性，并在必要时创建该实例属性。 因此，
  "a.x" 的两次出现不一定指向相同的属性：如果右侧表达式指向一个类属性，
  则左侧表达式会创建一个新的实例属性作为赋值的目标:

     class Cls:
         x = 3             # class variable
     inst = Cls()
     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

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

* 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.

  If the primary is a mutable sequence object (such as a list), the
  subscript must yield a plain 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, "IndexError" is raised
  (assignment to a subscripted sequence cannot add new items to a
  list).

  如果原型为一个映射对象（例如字典），抽取必须具有与该映射的键类型相兼
  容的类型，然后映射中会创建一个将抽取映射到被赋值对象的键/值对。 这可
  以是替换一个现有键/值对并保持相同键值，也可以是插入一个新键/值对（如
  果具有相同值的键不存在）。

* 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 (small) 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
  object allows it.

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

WARNING: Although the definition of assignment implies that overlaps
between the left-hand side and the right-hand side are ‘safe’ (for
example "a, b = b, a" swaps two variables), overlaps *within* the
collection of assigned-to variables are not safe!  For instance, the
following program prints "[0, 2]":

   x = [0, 1]
   i = 0
   i, x[i] = 1, 2
   print x


6.2.1. 增强赋值语句
-------------------

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

   augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)
   augtarget                 ::= identifier | attributeref | subscription | slicing
   augop                     ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
             | ">>=" | "<<=" | "&=" | "^=" | "|="

(See section 原型 for the syntax definitions for the last three
symbols.)

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

增强赋值语句例如 "x += 1" 可以改写为 "x = x + 1" 获得类似但并非完全等
价的效果。 在增强赋值的版本中，"x" 仅会被求值一次。 而且，在可能的情况
下，实际的运算是 *原地* 执行的，也就是说并不是创建一个新对象并将其赋值
给目标，而是直接修改原对象。

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

对于属性引用类目标，针对常规赋值的 关于类和实例属性的警告 也同样适用。


6.3. The "assert" statement
===========================

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

   assert_stmt ::= "assert" expression ["," expression]

简单形式 "assert expression" 等价于

   if __debug__:
       if not expression: raise AssertionError

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

   if __debug__:
       if not expression1: raise AssertionError(expression2)

These equivalences assume that "__debug__" and "AssertionError" refer
to the built-in variables with those names.  In the current
implementation, the built-in variable "__debug__" is "True" under
normal circumstances, "False" when optimization is requested (command
line 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.

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


6.4. The "pass" statement
=========================

   pass_stmt ::= "pass"

"pass" 是一个空操作 — 当它被执行时，什么都不发生。 它适合当语法上需要
一条语句但并不需要执行任何代码时用来临时占位，例如:

   def f(arg): pass    # a function that does nothing (yet)

   class C: pass       # a class with no methods (yet)


6.5. The "del" statement
========================

   del_stmt ::= "del" target_list

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

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

Deletion of a name removes the binding of that name  from the local or
global namespace, depending on whether the name occurs in a "global"
statement in the same code block.  If the name is unbound, a
"NameError" exception will be raised.

It is illegal to delete a name from the local namespace if it occurs
as a free variable in a nested block.

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


6.6. The "print" statement
==========================

   print_stmt ::= "print" ([expression ("," expression)* [","]]
                  | ">>" expression [("," expression)+ [","]])

"print" evaluates each expression in turn and writes the resulting
object to standard output (see below).  If an object is not a string,
it is first converted to a string using the rules for string
conversions.  The (resulting or original) string is then written.  A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line.  This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is a whitespace character except "' '", or (3) when the last
write operation on standard output was not a "print" statement. (In
some cases it may be functional to write an empty string to standard
output for this reason.)

注解: Objects which act like file objects but which are not the
  built-in file objects often do not properly emulate this aspect of
  the file object’s behavior, so it is best not to rely on this.

A "'\n'" character is written at the end, unless the "print" statement
ends with a comma.  This is the only action if the statement contains
just the keyword "print".

Standard output is defined as the file object named "stdout" in the
built-in module "sys".  If no such object exists, or if it does not
have a "write()" method, a "RuntimeError" exception is raised.

"print" also has an extended form, defined by the second portion of
the syntax described above. This form is sometimes referred to as
“"print" chevron.” In this form, the first expression after the ">>"
must evaluate to a “file-like” object, specifically an object that has
a "write()" method as described above.  With this extended form, the
subsequent expressions are printed to this file object.  If the first
expression evaluates to "None", then "sys.stdout" is used as the file
for output.


6.7. The "return" statement
===========================

   return_stmt ::= "return" [expression_list]

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

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

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

When "return" passes control out of a "try" statement with a "finally"
clause, that "finally" clause is executed before really leaving the
function.

In a generator function, the "return" statement is not allowed to
include an "expression_list".  In that context, a bare "return"
indicates that the generator is done and will cause "StopIteration" to
be raised.


6.8. The "yield" statement
==========================

   yield_stmt ::= yield_expression

The "yield" statement is only used when defining a generator function,
and is only used in the body of the generator function. Using a
"yield" statement in a function definition is sufficient to cause that
definition to create a generator function instead of a normal
function.

When a generator function is called, it returns an iterator known as a
generator iterator, or more commonly, a generator.  The body of the
generator function is executed by calling the generator’s "next()"
method repeatedly until it raises an exception.

When a "yield" statement is executed, the state of the generator is
frozen and the value of "expression_list" is returned to "next()"’s
caller.  By “frozen” we mean that all local state is retained,
including the current bindings of local variables, the instruction
pointer, and the internal evaluation stack: enough information is
saved so that the next time "next()" is invoked, the function can
proceed exactly as if the "yield" statement were just another external
call.

As of Python version 2.5, the "yield" statement is now allowed in the
"try" clause of a "try" …  "finally" construct.  If the generator is
not resumed before it is finalized (by reaching a zero reference count
or by being garbage collected), the generator-iterator’s "close()"
method will be called, allowing any pending "finally" clauses to
execute.

有关 "yield" 语义的完整细节请参看 yield 表达式 一节。

注解: In Python 2.2, the "yield" statement was only allowed when the
  "generators" feature has been enabled.  This "__future__" import
  statement was used to enable the feature:

     from __future__ import generators

参见:

  **PEP 255** - Simple Generators
     The proposal for adding generators and the "yield" statement to
     Python.

  **PEP 342** - Coroutines via Enhanced Generators
     The proposal that, among other generator enhancements, proposed
     allowing "yield" to appear inside a "try" … "finally" block.


6.9. The "raise" statement
==========================

   raise_stmt ::= "raise" [expression ["," expression ["," expression]]]

If no expressions are present, "raise" re-raises the last exception
that was active in the current scope.  If no exception is active in
the current scope, a "TypeError" exception is raised indicating that
this is an error (if running under IDLE, a "Queue.Empty" exception is
raised instead).

Otherwise, "raise" evaluates the expressions to get three objects,
using "None" as the value of omitted expressions.  The first two
objects are used to determine the *type* and *value* of the exception.

If the first object is an instance, the type of the exception is the
class of the instance, the instance itself is the value, and the
second object must be "None".

If the first object is a class, it becomes the type of the exception.
The second object is used to determine the exception value: If it is
an instance of the class, the instance becomes the exception value. If
the second object is a tuple, it is used as the argument list for the
class constructor; if it is "None", an empty argument list is used,
and any other object is treated as a single argument to the
constructor.  The instance so created by calling the constructor is
used as the exception value.

If a third object is present and not "None", it must be a traceback
object (see section 标准类型层级结构), and it is substituted instead
of the current location as the place where the exception occurred.  If
the third object is present and not a traceback object or "None", a
"TypeError" exception is raised.  The three-expression form of "raise"
is useful to re-raise an exception transparently in an except clause,
but "raise" with no expressions should be preferred if the exception
to be re-raised was the most recently active exception in the current
scope.

有关异常的更多信息可在 异常 一节查看，有关处理异常的信息可在 The try
statement 一节查看。


6.10. The "break" statement
===========================

   break_stmt ::= "break"

"break" 在语法上只会出现于 "for" 或 "while" 循环所嵌套的代码，但不会出
现于该循环内部的函数或类定义所嵌套的代码。

It terminates the nearest enclosing loop, skipping the optional "else"
clause if the loop has one.

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

When "break" passes control out of a "try" statement with a "finally"
clause, that "finally" clause is executed before really leaving the
loop.


6.11. The "continue" statement
==============================

   continue_stmt ::= "continue"

"continue" 在语法上只会出现于 "for" 或 "while" 循环所嵌套的代码，但不
会出现于该循环内部的函数或类定义或者 "finally" 子句所嵌套的代码。 它会
继续执行最近的外层循环的下一个轮次。

When "continue" passes control out of a "try" statement with a
"finally" clause, that "finally" clause is executed before really
starting the next loop cycle.


6.12. The "import" statement
============================

   import_stmt     ::= "import" module ["as" name] ( "," module ["as" name] )*
                   | "from" relative_module "import" identifier ["as" name]
                   ( "," identifier ["as" name] )*
                   | "from" relative_module "import" "(" identifier ["as" name]
                   ( "," identifier ["as" name] )* [","] ")"
                   | "from" module "import" "*"
   module          ::= (identifier ".")* identifier
   relative_module ::= "."* module | "."+
   name            ::= identifier

Import statements are executed in two steps: (1) find a module, and
initialize it if necessary; (2) define a name or names in the local
namespace (of the scope where the "import" statement occurs). The
statement comes in two forms differing on whether it uses the "from"
keyword. The first form (without "from") repeats these steps for each
identifier in the list. The form with "from" performs step (1) once,
and then performs step (2) repeatedly.

To understand how step (1) occurs, one must first understand how
Python handles hierarchical naming of modules. To help organize
modules and provide a hierarchy in naming, Python has a concept of
packages. A package can contain other packages and modules while
modules cannot contain other modules or packages. From a file system
perspective, packages are directories and modules are files.

Once the name of the module is known (unless otherwise specified, the
term “module” will refer to both packages and modules), searching for
the module or package can begin. The first place checked is
"sys.modules", the cache of all modules that have been imported
previously. If the module is found there then it is used in step (2)
of import.

If the module is not found in the cache, then "sys.meta_path" is
searched (the specification for "sys.meta_path" can be found in **PEP
302**). The object is a list of *finder* objects which are queried in
order as to whether they know how to load the module by calling their
"find_module()" method with the name of the module. If the module
happens to be contained within a package (as denoted by the existence
of a dot in the name), then a second argument to "find_module()" is
given as the value of the "__path__" attribute from the parent package
(everything up to the last dot in the name of the module being
imported). If a finder can find the module it returns a *loader*
(discussed later) or returns "None".

If none of the finders on "sys.meta_path" are able to find the module
then some implicitly defined finders are queried. Implementations of
Python vary in what implicit meta path finders are defined. The one
they all do define, though, is one that handles "sys.path_hooks",
"sys.path_importer_cache", and "sys.path".

The implicit finder searches for the requested module in the “paths”
specified in one of two places (“paths” do not have to be file system
paths). If the module being imported is supposed to be contained
within a package then the second argument passed to "find_module()",
"__path__" on the parent package, is used as the source of paths. If
the module is not contained in a package then "sys.path" is used as
the source of paths.

Once the source of paths is chosen it is iterated over to find a
finder that can handle that path. The dict at
"sys.path_importer_cache" caches finders for paths and is checked for
a finder. If the path does not have a finder cached then
"sys.path_hooks" is searched by calling each object in the list with a
single argument of the path, returning a finder or raises
"ImportError". If a finder is returned then it is cached in
"sys.path_importer_cache" and then used for that path entry. If no
finder can be found but the path exists then a value of "None" is
stored in "sys.path_importer_cache" to signify that an implicit, file-
based finder that handles modules stored as individual files should be
used for that path. If the path does not exist then a finder which
always returns "None" is placed in the cache for the path.

If no finder can find the module then "ImportError" is raised.
Otherwise some finder returned a loader whose "load_module()" method
is called with the name of the module to load (see **PEP 302** for the
original definition of loaders). A loader has several responsibilities
to perform on a module it loads. First, if the module already exists
in "sys.modules" (a possibility if the loader is called outside of the
import machinery) then it is to use that module for initialization and
not a new module. But if the module does not exist in "sys.modules"
then it is to be added to that dict before initialization begins. If
an error occurs during loading of the module and it was added to
"sys.modules" it is to be removed from the dict. If an error occurs
but the module was already in "sys.modules" it is left in the dict.

The loader must set several attributes on the module. "__name__" is to
be set to the name of the module. "__file__" is to be the “path” to
the file unless the module is built-in (and thus listed in
"sys.builtin_module_names") in which case the attribute is not set. If
what is being imported is a package then "__path__" is to be set to a
list of paths to be searched when looking for modules and packages
contained within the package being imported. "__package__" is optional
but should be set to the name of package that contains the module or
package (the empty string is used for module not contained in a
package). "__loader__" is also optional but should be set to the
loader object that is loading the module.

If an error occurs during loading then the loader raises "ImportError"
if some other exception is not already being propagated. Otherwise the
loader returns the module that was loaded and initialized.

When step (1) finishes without raising an exception, step (2) can
begin.

The first form of "import" statement binds the module name in the
local namespace to the module object, and then goes on to import the
next identifier, if any.  If the module name is followed by "as", the
name following "as" is used as the local name for the module.

The "from" form does not bind the module name: it goes through the
list of identifiers, looks each one of them up in the module found in
step (1), and binds the name in the local namespace to the object thus
found.  As with the first form of "import", an alternate local name
can be supplied by specifying “"as" localname”.  If a name is not
found, "ImportError" is raised.  If the list of identifiers is
replaced by a star ("'*'"), all public names defined in the module are
bound in the local namespace of the "import" statement..

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).

The "from" form with "*" may only occur in a module scope.  If the
wild card form of import — "import *" — is used in a function and the
function contains or is a nested block with free variables, the
compiler will raise a "SyntaxError".

当指定要导入哪个模块时，你不必指定模块的绝对名称。 当一个模块或包包含
在另一个包内时，可以在同一个最高层级包中进行相对导入，而不必提及包名称
。 通过在 "from" 之后指定的模块或包中使用前缀点号，你可以在不指定确切
名称的情况下指明在当前包层级结构中要上溯多少级。 一个前缀点号表示是执
行导入的模块所在的当前包。 两个点号表示上溯一个包层级。 三个点号表示上
溯两级，依此类推。 因此如果你执行 "from . import mod" 时所处位置为
"pkg" 包内的一个模块，则最终你将导入 "pkg.mod"。 如果你执行 "from
..subpkg2 import mod" 时所处位置为 "pkg.subpkg1" 则你将导入
"pkg.subpkg2.mod"。 有关相对导入的规范说明包含在 **PEP 328** 当中。

"importlib.import_module()" is provided to support applications that
determine which modules need to be loaded dynamically.


6.12.1. future 语句
-------------------

A *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.  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.

   future_statement ::= "from" "__future__" "import" feature ["as" name]
                        ("," feature ["as" name])*
                        | "from" "__future__" "import" "(" feature ["as" name]
                        ("," feature ["as" name])* [","] ")"
   feature          ::= identifier
   name             ::= identifier

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

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

* 注释，

* 空行，以及

* 其他 future 语句。

The features recognized by Python 2.6 are "unicode_literals",
"print_function", "absolute_import", "division", "generators",
"nested_scopes" and "with_statement".  "generators", "with_statement",
"nested_scopes" are redundant in Python version 2.6 and above because
they are always enabled.

future 语句在编译时会被识别并做特殊对待：对核心构造语义的改变常常是通
过生成不同的代码来实现。 新的特性甚至可能会引入新的不兼容语法（例如新
的保留字），在这种情况下编译器可能需要以不同的方式来解析模块。 这样的
决定不能推迟到运行时方才作出。

对于任何给定的发布版本，编译器要知道哪些特性名称已被定义，如果某个
future 语句包含未知的特性则会引发编译时错误。

直接运行时的语义与任何 import 语句相同：存在一个后文将详细说明的标准模
块 "__future__"，它会在执行 future 语句时以通常的方式被导入。

相应的运行时语义取决于 future 语句所启用的指定特性。

请注意以下语句没有任何特别之处:

   import __future__ [as name]

这并非 future 语句；它只是一条没有特殊语义或语法限制的普通 import 语句
。

Code compiled by an "exec" statement or calls to the built-in
functions "compile()" and "execfile()" that occur in a module "M"
containing a future statement will, by default, use the new  syntax or
semantics associated with the future statement.  This can, starting
with Python 2.2 be controlled by optional arguments to "compile()" —
see the documentation of that function for details.

在交互式解释器提示符中键入的 future 语句将在解释器会话此后的交互中有效
。 如果一个解释器的启动使用了 "-i" 选项启动，并传入了一个脚本名称来执
行，且该脚本包含 future 语句，它将在交互式会话开始执行脚本之后保持有效
。

参见:

  **PEP 236** - 回到 __future__
     有关 __future__ 机制的最初提议。


6.13. The "global" statement
============================

   global_stmt ::= "global" identifier ("," identifier)*

The "global" statement is a declaration which holds for the entire
current code block.  It means that the listed identifiers are to be
interpreted as globals.  It would be impossible to assign to a global
variable without "global", although free variables may refer to
globals without being declared global.

Names listed in a "global" statement must not be used in the same code
block textually preceding that "global" statement.

Names listed in a "global" statement must not be defined as formal
parameters or in a "for" loop control target, "class" definition,
function definition, or "import" statement.

**CPython implementation detail:** The current implementation does not
enforce the latter two restrictions, but programs should not abuse
this freedom, as future implementations may enforce them or silently
change the meaning of the program.

**Programmer’s note:** "global" is a directive to the parser.  It
applies only to code parsed at the same time as the "global"
statement. In particular, a "global" statement contained in an "exec"
statement does not affect the code block *containing* the "exec"
statement, and code contained in an "exec" statement is unaffected by
"global" statements in the code containing the "exec" statement.  The
same applies to the "eval()", "execfile()" and "compile()" functions.


6.14. The "exec" statement
==========================

   exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]

This statement supports dynamic execution of Python code.  The first
expression should evaluate to either a Unicode string, a *Latin-1*
encoded string, an open file object, a code object, or a tuple.  If it
is a string, the string is parsed as a suite of Python statements
which is then executed (unless a syntax error occurs). [1] If it is an
open file, the file is parsed until EOF and executed. If it is a code
object, it is simply executed.  For the interpretation of a tuple, see
below.  In all cases, the code that’s executed is expected to be valid
as file input (see section 文件输入).  Be aware that the "return" and
"yield" statements may not be used outside of function definitions
even within the context of code passed to the "exec" statement.

In all cases, if the optional parts are omitted, the code is executed
in the current scope.  If only the first expression after "in" is
specified, it should be a dictionary, which will be used for both the
global and the local variables.  If two expressions are given, they
are used for the global and local variables, respectively. If
provided, *locals* can be any mapping object. Remember that at module
level, globals and locals are the same dictionary. If two separate
objects are given as *globals* and *locals*, the code will be executed
as if it were embedded in a class definition.

The first expression may also be a tuple of length 2 or 3.  In this
case, the optional parts must be omitted.  The form "exec(expr,
globals)" is equivalent to "exec expr in globals", while the form
"exec(expr, globals, locals)" is equivalent to "exec expr in globals,
locals".  The tuple form of "exec" provides compatibility with Python
3, where "exec" is a function rather than a statement.

在 2.4 版更改: Formerly, *locals* was required to be a dictionary.

As a side effect, an implementation may insert additional keys into
the dictionaries given besides those corresponding to variable names
set by the executed code.  For example, the current implementation may
add a reference to the dictionary of the built-in module "__builtin__"
under the key "__builtins__" (!).

**Programmer’s hints:** dynamic evaluation of expressions is supported
by the built-in function "eval()".  The built-in functions "globals()"
and "locals()" return the current global and local dictionary,
respectively, which may be useful to pass around for use by "exec".

-[ Footnotes ]-

[1] Note that the parser only accepts the Unix-style end of line
    convention. If you are reading the code from a file, make sure to
    use *universal newlines* mode to convert Windows or Mac-style
    newlines.
