単純文 (simple statement)
*************************

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
                   | global_stmt
                   | exec_stmt


式文 (expression statement)
===========================

式文は、(主に対話的な使い方では) 値を計算して出力するために使ったり、(
通常は) プロシジャ (procedure: 有意な結果を返さない関数のことです;
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.)


代入文 (assignment statement)
=============================

代入文は、名前を値に (再) 束縛したり、変更可能なオブジェクトの属性や要
素を変更したりするために使われます:

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

代入文は式のリスト (これは単一の式でも、カンマで区切られた式リストでも
よく、後者はタプルになることを思い出してください) を評価し、得られた単
一の結果オブジェクトをターゲット (target) のリストに対して左から右へと
代入してゆきます。

代入はターゲット (リスト) の形式に従って再帰的に行われます。ターゲット
が変更可能なオブジェクト (属性参照、添字表記、またはスライス) の一部で
ある場合、この変更可能なオブジェクトは最終的に代入を実行して、その代入
が有効な操作であるか判断しなければなりません。代入が不可能な場合には例
外を発行することもできます。型ごとにみられる規則や、送出される例外は、
そのオブジェクト型定義で与えられています (標準型の階層 節を参照してく
ださい).

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.

  名前がすでに束縛済みの場合、再束縛 (rebind) がおこなわれます。再束縛
  によって、以前その名前に束縛されていたオブジェクトの参照カウント
  (reference count) がゼロになった場合、オブジェクトは解放
  (deallocate) され、デストラクタ  (destructor) が (存在すれば) 呼び出
  されます。

* 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


累算代入文 (augmented assignment statement)
-------------------------------------------

累算代入文は、二項演算と代入文を組み合わせて一つの文にしたものです:

   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"
は一度しか評価されません。また、実際の処理として、可能ならば *インプレ
ース (in-place)* 演算が実行されます。これは、代入時に新たなオブジェク
トを生成してターゲットに代入するのではなく、以前のオブジェクトの内容を
変更するということです。

累算代入文で行われる代入は、タプルへの代入や、一文中に複数のターゲット
が存在する場合を除き、通常の代入と同じように扱われます。同様に、累算代
入で行われる二項演算は、場合によって *インプレース演算* が行われること
を除き、通常の二項演算と同じです。

属性参照のターゲットの場合、 クラス属性とインスタンス属性についての注
意 と同様に通常の代入が適用されます。


"assert" 文
===========

assert 文は、プログラム内にデバッグ用アサーション (debugging
assertion) を仕掛けるための便利な方法です:

   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)

上記の等価関係は、 "__debug__" と "AssertionError" が、同名の組み込み
変数を参照しているという前提の上に成り立っています。現在の実装では、組
み込み変数 "__debug__" は通常の状況では "True" であり、最適化がリクエ
ストされた場合（コマンドラインオプション -O）は "False" です。現状のコ
ード生成器は、コンパイル時に最適化が要求されていると assert 文に対する
コードを全く出力しません。実行に失敗した式のソースコードをエラーメッセ
ージ内に入れる必要はありません; コードはスタックトレース内で表示されま
す。

"__debug__" への代入は不正な操作です。組み込み変数の値は、インタプリタ
が開始するときに決定されます。


"pass" 文
=========

   pass_stmt ::= "pass"

"pass" はヌル操作 (null operation) です — "pass" が実行されても、何も
起きません。 "pass" は、構文法的には文が必要だが、コードとしては何も実
行したくない場合のプレースホルダとして有用です。例えば:

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

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


"del" 文
========

   del_stmt ::= "del" target_list

オブジェクトの削除 (deletion) は、代入の定義と非常に似た方法で再帰的に
定義されています。ここでは完全な詳細は記述せず、いくつかのヒントを述べ
るにとどめます。

ターゲットリストに対する削除は、各々のターゲットを左から右へと順に再帰
的に削除します。

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.

属性参照、添字表記、およびスライスの削除操作は、対象となる一次語オブジ
ェクトに渡されます; スライスの削除は一般的には適切な型の空のスライスを
代入するのと等価です (が、この仕様自体もスライスされるオブジェクトで決
定されています)。


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.


"return" 文
===========

   return_stmt ::= "return" [expression_list]

"return" は、関数定義内で構文法的にネストして現れますが、ネストしたク
ラス定義内には現れません。

式リストがある場合、リストが値評価されます。それ以外の場合は "None" で
置き換えられます。

"return" を使うと、式リスト (または "None") を戻り値として、現在の関数
呼び出しから抜け出します。

"return" によって、 "finally" 節をともなう "try" 文の外に処理が引き渡
されると、実際に関数から抜ける前に "finally" 節が実行されます。

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.


"yield" 文
==========

   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.


"raise" 文
==========

   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.

例外に関する追加情報は 例外 節にあります。また、例外処理に関する情報は
try 文 節にあります。


"break" 文
==========

   break_stmt ::= "break"

"break" 文は、構文としては "for" ループや "while" ループの内側でのみ出
現することができますが、ループ内の関数定義やクラス定義の内側には出現で
きません。

"break" 文は、文を囲う最も内側のループを終了させ、ループにオプションの
"else" 節がある場合にはそれをスキップします。

"for" ループを "break" によって終了すると、ループ制御ターゲットはその
時の値を保持します。

"break" が "finally" 節を伴う "try" 文の外側に処理を渡す際には、ループ
を実際に抜ける前にその "finally" 節が実行されます。


"continue" 文
=============

   continue_stmt ::= "continue"

"continue" 文は "for" ループや "while" ループ内のネストで構文法的にの
み現れますが、ループ内の関数定義やクラス定義、 "finally" 句の中には現
れません。 "continue" 文は、文を囲う最も内側のループの次の周期に処理を
継続します。

"continue" が "finally" 句を持った "try" 文を抜けるとき、その
"finally" 句が次のループサイクルを始める前に実行されます。


"import" 文
===========

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

インポートするモジュールを指定するとき、そのモジュールの絶対名
(absolute name) を指定する必要はありません。モジュールやパッケージが他
のパッケージに含まれている場合、共通のトップパッケージからそのパッケー
ジ名を記述することなく相対インポートすることができます。 "from" の後に
指定されるモジュールやパッケージの先頭に複数個のドットを付けることで、
正確な名前を指定することなしに現在のパッケージ階層からいくつ上の階層へ
行くかを指定することができます。先頭のドットが 1 つの場合、 import を
おこなっているモジュールが存在する現在のパッケージを示します。 3 つの
ドットは 2 つ上のレベルを示します。なので、 "pkg" パッケージの中のモジ
ュールで "from . import mod" を実行すると、 "pkg.mod" をインポートする
ことになります。 "pkg.subpkg1" の中から "from ..subpkg2 import mod" を
実行すると、 "pkg.subpkg2.mod" をインポートします。相対インポートの仕
様は **PEP 328** に含まれています。

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


future 文 (future statement)
----------------------------

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 文は、コンパイル時に特別なやり方で認識され、扱われます: 言語の
中核をなす構文構成 (construct) に対する意味付けが変更されている場合、
変更部分はしばしば異なるコードを生成することで実現されています。新たな
機能によって、(新たな予約語のような) 互換性のない新たな構文が取り入れ
られることさえあります。この場合、コンパイラはモジュールを別のやりかた
で解析する必要があるかもしれません。こうしたコード生成に関する決定は、
実行時まで先延ばしすることはできません。

これまでの全てのリリースにおいて、コンパイラはどの機能が定義済みかを知
っており、 future 文に未知の機能が含まれている場合にはコンパイル時エラ
ーを送出します。

future 文の実行時における直接的な意味付けは、 import 文と同じです。標
準モジュール "__future__" があり、これについては後で述べます。
"__future__" は、 future 文が実行される際に通常の方法で import されま
す。

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** - Back to the __future__
     __future__ 機構の原案


"global" 文
===========

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

"global" 文は、現在のコードブロック全体で維持される宣言文です。
"global" 文は、列挙した識別子をグローバル変数として解釈するよう指定す
ることを意味します。 "global" を使わずにグローバル変数に代入を行うこと
は不可能ですが、自由変数を使えばその変数をグローバルであると宣言せずに
グローバル変数を参照することができます。

"global" 文で列挙する名前は、同じコードブロック中で、プログラムテキス
ト上 "global" 文より前に使ってはなりません。

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.


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.
