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

単純文とは、単一の論理行内に収められる文です。単一の行内には、複数の単
純文をセミコロンで区切って入れることができます。単純文の構文は以下の通
りです:

   simple_stmt: expression_stmt
                | assert_stmt
                | assignment_stmt
                | augmented_assignment_stmt
                | annotated_assignment_stmt
                | pass_stmt
                | del_stmt
                | return_stmt
                | yield_stmt
                | raise_stmt
                | break_stmt
                | continue_stmt
                | import_stmt
                | future_stmt
                | global_stmt
                | nonlocal_stmt
                | type_stmt


7.1. 式文 (expression statement)
================================

式文は、(主に対話的な使い方では) 値を計算して出力するために使ったり、(
通常は) プロシジャ (procedure: 有意な結果を返さない関数のことです;
Python では、プロシジャは値 "None" を返します) を呼び出すために使いま
す。その他の使い方でも式文を使うことができますし、有用なこともあります
。式文の構文は以下の通りです:

   expression_stmt: starred_expression

式文は式のリスト (単一の式のこともあります) を値評価します。

対話モードでは、値が "None" でなければ、値を組み込み関数 "repr()" で文
字列に変換して、その結果の文字列を標準出力に一行使って書き出します。
("None" になる式文の値は書き出されないので、プロシジャの呼び出しを行っ
ても出力は得られません。)


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

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

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

(*attributeref*, *subscription*, *slicing* の構文については プライマリ
節を参照してください。)

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

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

ターゲットリストは、丸括弧や角括弧で囲まれていてもよく、それに対するオ
ブジェクトの代入は、以下のように再帰的に定義されています。

* ターゲットリストのターゲットが1つだけでコンマが続いておらず、任意に
  丸括弧で囲われている場合、オブジェクトはそのターゲットに代入されます
  。

* その他:

  * "星付き"のターゲットと呼ばれる、頭にアスタリスクが一つ付いたターゲ
    ットがターゲットリストに一つだけ含まれている場合: オブジェクトはイ
    テラブルで、少なくともターゲットリストのターゲットの数よりも一つ少
    ない要素を持たなければなりません。 星付きのターゲットより前のター
    ゲットに、イテラブルの先頭の要素が左から右へ代入されます。 星付き
    のターゲットより後ろのターゲットに、イテラブルの末尾の要素が代入さ
    れます。 星付きのターゲットに、イテラブルの残った要素のリストが代
    入されます (リスト空でもかまいません)。

  * そうでない場合: オブジェクトは、ターゲットリストのターゲットと同じ
    数の要素を持つイテラブルでなければならず、要素は左から右へ対応する
    ターゲットに代入されます。

単一のターゲットへの単一のオブジェクトの代入は、以下のようにして再帰的
に定義されています。

* ターゲットが識別子 (名前) の場合:

  * 名前が現在のコードブロック内の "global" や "nonlocal" 文に書かれて
    いないければ: 名前は現在のローカル名前空間内のオブジェクトに束縛さ
    れます。

  * そうでなければ: 名前はそれぞれグローバル名前空間内か、 "nonlocal"
    で決められた外側の名前空間内のオブジェクトに束縛されます。

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

* ターゲットが属性参照の場合: 参照されている一次語の式が値評価されます
  。値は代入可能な属性を伴うオブジェクトでなければなりません; そうでな
  ければ、 "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()" で作成されたプロパティのようなデスクリプタ
  属性に対しては、必ずしもあてはまるとは限りません。

* ターゲットが添字表記なら: 参照されている一次語式が評価されます。参照
  から (リストのような) ミュータブルなシーケンスオブジェクトか、(辞書
  のような) マッピングオブジェクトが得られなければなりません。次に、添
  字表記の表す式が評価されます。

  一次語が (リストのような) ミュータブルなシーケンスオブジェクトであれ
  ば、添字表記は整数を与えなければなりません。整数が負なら、シーケンス
  の長さが加算されます。整数は最終的に、シーケンスの長さよりも小さな非
  負の整数でなくてはならず、シーケンスは、そのインデクスに持つ要素に被
  代入オブジェクトを代入してよいか問い合わせられます。インデクスが範囲
  外なら、 "IndexError" が送出されます (添字指定されたシーケンスに代入
  を行っても、リスト要素の新たな追加はできません)。

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

  For user-defined objects, the "__setitem__()" method is called with
  appropriate arguments.

* ターゲットがスライスなら: 参照されている一次語式が評価されます。一次
  語式は、(リストのような) ミュータブルなシーケンスオブジェクトを与え
  なければなりません。被代入オブジェクトは同じ型のシーケンスオブジェク
  トでなければなりません。次に、スライスの下限と上限を示す式があれば評
  価されます; デフォルト値はそれぞれ 0 とシーケンスの長さです。上限と
  下限の評価は整数でなければなりません。いずれかの境界が負数なら、シー
  ケンスの長さが加算されます。最終的に、境界は 0 からシーケンスの長さ
  までに収まるように刈りこまれます。最後に、スライスを被代入オブジェク
  トで置き換えてよいかシーケンスオブジェクトに問い合わせます。ターゲッ
  トシーケンスで許されている限り、スライスの長さは被代入シーケンスの長
  さと異なっていてよく、この場合にはターゲットシーケンスの長さが変更さ
  れます。

現在の実装では、ターゲットの構文は式の構文と同じであるとみなされており
、無効な構文はコード生成フェーズ中に詳細なエラーメッセージを伴って拒否
されます。

代入の定義によれば、左辺と右辺のオーバーラップは '同時 (simultaneous)'
です (例えば "a, b = b, a" は二つの変数を入れ替えます) が、代入対象と
なる変数群 *どうし* のオーバーラップは左から右へ起こり、混乱の元です。
例えば、以下のプログラムは "[0, 2]" を出力してしまいます:

   x = [0, 1]
   i = 0
   i, x[i] = 1, 2         # i is updated, then x[i] is updated
   print(x)

参考:

  **PEP 3132** - Extended Iterable Unpacking
     "*target" の指定機能。


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

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

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

(最後の3つの構文定義については プライマリ を参照してください。)

累算代入文は、ターゲット (通常の代入文と違って、アンパックは起こりませ
ん) と式リストを評価し、それら二つの被演算子間で特定の累算代入型の二項
演算を行い、結果をもとのターゲットに代入します。ターゲットは一度しか評
価されません。

An augmented assignment statement 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.

通常の代入とは違い、累算代入文は右辺を評価する *前に* 左辺を評価します
。たとえば、"a[i] += f(x)" はまず "a[i]" を調べ、"f(x)" を評価して加算
を行い、最後に結果を "a[i]" に割り当てます。

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

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


7.2.2. 注釈付き代入文 (annotated assignment statements)
-------------------------------------------------------

*注釈* 代入は、1 つの文の中で変数や属性のアノテーションとオプションの
代入文を組み合わせたものです:

   annotated_assignment_stmt: augtarget ":" expression
                              ["=" (starred_expression | yield_expression)]

通常の 代入文 (assignment statement) との違いは、代入先が 1 つに限定さ
れることだけです。

The assignment target is considered "simple" if it consists of a
single name that is not enclosed in parentheses. For simple assignment
targets, if in class or module scope, the annotations are gathered in
a lazily evaluated annotation scope. The annotations can be evaluated
using the "__annotations__" attribute of a class or module, or using
the facilities in the "annotationlib" module.

If the assignment target is not simple (an attribute, subscript node,
or parenthesized name), the annotation is never evaluated.

関数スコープで名前に注釈が付いていた場合は、その名前はその関数スコープ
でローカルなものになります。 注釈は絶対に評価されず、関数スコープにも
格納されません。

If the right hand side is present, an annotated assignment performs
the actual assignment as if there was no annotation present. If the
right hand side is not present for an expression target, then the
interpreter evaluates the target except for the last "__setitem__()"
or "__setattr__()" call.

参考:

  **PEP 526** - Syntax for Variable Annotations
     (クラス変数やインスタンス変数を含んだ) 変数の型注釈を付ける、コメ
     ントで表現するのではない文法の追加提案。

  **PEP 484** - Type hints
     "typing" モジュールを追加し、静的解析ツールや IDE で使える型アノ
     テーションの標準的な文法を提供する提案。

バージョン 3.8 で変更: Now annotated assignments allow the same
expressions in the right hand side as regular assignments. Previously,
some expressions (like un-parenthesized tuple expressions) caused a
syntax error.

バージョン 3.14 で変更: Annotations are now lazily evaluated in a
separate annotation scope. If the assignment target is not simple,
annotations are never evaluated.


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

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__" への代入は不正な操作です。組み込み変数の値は、インタプリタ
が開始するときに決定されます。


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


7.5. "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.  Trying to delete an unbound name
raises a "NameError" exception.

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

バージョン 3.2 で変更: 以前は、ある名前がネストしたブロックの自由変数
として表れる場合は、ローカル名前空間からその名前を削除することは不正な
処理でした。


7.6. "return" 文
================

   return_stmt: "return" [expression_list]

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

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

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

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

ジェネレータ関数では、 "return" 文はジェネレータの終わりを示し、
"StopIteration" 例外を送出させます。返された値は (あれば)、
"StopIteration" を構成する引数に使われ、 "StopIteration.value" 属性に
なります。

非同期ジェネレータ関数では、引数無しの "return" 文は非同期ジェネレータ
の終わりを示し、 "StopAsyncIteration" を送出させます。 引数ありの
"return" 文は、非同期ジェネレータ関数では文法エラーです。


7.7. "yield" 文
===============

   yield_stmt: yield_expression

A "yield" statement is semantically equivalent to a yield expression.
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

   yield <expr>
   yield from <expr>

は以下の yield 式文と等価です

   (yield <expr>)
   (yield from <expr>)

Yield expressions and statements are only used when defining a
*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.

"yield" の意味の完全な説明は、 Yield 式 節を参照してください。


7.8. "raise" 文
===============

   raise_stmt: "raise" [expression ["from" expression]]

If no expressions are present, "raise" re-raises the exception that is
currently being handled, which is also known as the *active
exception*. If there isn't currently an active exception, a
"RuntimeError" exception is raised indicating that this is an error.

そうでなければ、 "raise" は最初の式を、例外オブジェクトとして評価しま
す。これは、 "BaseException" のサブクラスまたはインスタンスでなければ
なりません。クラスなら、例外インスタンスが必要なとき、クラスを無引数で
インスタンス化することで得られます。

例外の *型* は例外インスタンスのクラスで、 *値* はインスタンスそのもの
です。

A traceback object is normally created automatically when an exception
is raised and attached to it as the "__traceback__" attribute. You can
create an exception and set your own traceback in one step using the
"with_traceback()" exception method (which returns the same exception
instance, with its traceback set to its argument), like so:

   raise Exception("foo occurred").with_traceback(tracebackobj)

The "from" clause is used for exception chaining: if given, the second
*expression* must be another exception class or instance. If the
second expression is an exception instance, it will be attached to the
raised exception as the "__cause__" attribute (which is writable). If
the expression is an exception class, the class will be instantiated
and the resulting exception instance will be attached to the raised
exception as the "__cause__" attribute. If the raised exception is not
handled, both exceptions will be printed:

   >>> try:
   ...     print(1 / 0)
   ... except Exception as exc:
   ...     raise RuntimeError("Something bad happened") from exc
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       print(1 / 0)
             ~~^~~
   ZeroDivisionError: division by zero

   The above exception was the direct cause of the following exception:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError("Something bad happened") from exc
   RuntimeError: Something bad happened

A similar mechanism works implicitly if a new exception is raised when
an exception is already being handled.  An exception may be handled
when an "except" or "finally" clause, or a "with" statement, is used.
The previous exception is then attached as the new exception's
"__context__" attribute:

   >>> try:
   ...     print(1 / 0)
   ... except:
   ...     raise RuntimeError("Something bad happened")
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       print(1 / 0)
             ~~^~~
   ZeroDivisionError: division by zero

   During handling of the above exception, another exception occurred:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError("Something bad happened")
   RuntimeError: Something bad happened

Exception chaining can be explicitly suppressed by specifying "None"
in the "from" clause:

   >>> try:
   ...     print(1 / 0)
   ... except:
   ...     raise RuntimeError("Something bad happened") from None
   ...
   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
   RuntimeError: Something bad happened

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

バージョン 3.3 で変更: "None" が "raise X from Y" の "Y" として使える
ようになりました。Added the "__suppress_context__" attribute to
suppress automatic display of the exception context.

バージョン 3.11 で変更: If the traceback of the active exception is
modified in an "except" clause, a subsequent "raise" statement re-
raises the exception with the modified traceback. Previously, the
exception was re-raised with the traceback it had when it was caught.


7.9. "break" 文
===============

   break_stmt: "break"

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

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

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

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


7.10. "continue" 文
===================

   continue_stmt: "continue"

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

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


7.11. "import" 文
=================

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

("from" 節が無い) 基本の import 文は 2 つのステップで実行されます:

1. モジュールを見付け出し、必要であればロードし初期化する

2. "import" 文が表れるスコープのローカル名前空間で名前を定義する。

文が (カンマで区切られた) 複数の節を含んでいるときは、ちょうどその節が
個別の import 文に分割されたかのように、2つのステップが節ごとに個別に
実行されます。

モジュールを見付け、ロードする 1 つ目のステップの詳細については、 イン
ポートシステム の節により詳しく書かれています。そこでは、インポートシ
ステムの動作をカスタマイズするのに使える全てのフックの仕組みだけでなく
、様々な種類のインポートできるパッケージとモジュールについても解説され
ています。このステップが失敗するということは、おそらくモジュールが見付
からないか、 *あるいは* モジュールにあるコードの実行を含め、モジュール
の初期化の途中でエラーが起きるかのどちらかが起きていることに注意してく
ださい。

要求したモジュールが無事に取得できた場合、次の 3 つのうちの 1 つの方法
でローカル名前空間で使えるようになります:

* モジュール名の後に "as" が続いていた場合は、 "as" の後ろの名前を直接
  、インポートされたモジュールが束縛します。

* 他の名前が指定されておらず、インポートされているモジュールが最上位の
  モジュールだった場合、そのモジュール名がインポートされたモジュールへ
  の参照として、ローカル名前空間で束縛されます

* インポートされているモジュールが最上位のモジュール *でない* 場合、モ
  ジュールを含む最上位のパッケージ名が、そのパッケージへの参照として、
  ローカル名前空間で束縛されます。インポートされたモジュールには、直接
  ではなく完全修飾名を使ってアクセスしなければなりません

"from" 形式ではもう少し複雑な手順を踏みます:

1. "from" 節で指定されたモジュールを見付け出し、必要であればロードし初
   期化する;

2. "import" 節で指定されたそれぞれの識別子に対し以下の処理を行う:

   1. インポートされたモジュールがその識別子名の属性を持っているかを確
      認する

   2. その識別子名の属性を持っていなかった場合は、その識別子名でサブモ
      ジュールのインポートを試み、インポートされたモジュールにその属性
      があるか再度確認する

   3. 属性が見付からない場合は、 "ImportError" を送出する。

   4. 属性が見付かった場合は、 "as" 節があるならそこの名前、そうでない
      なら属性名を使って、その値への参照がローカル名前空間に保存される

例:

   import foo                 # foo imported and bound locally
   import foo.bar.baz         # foo, foo.bar, and foo.bar.baz imported, foo bound locally
   import foo.bar.baz as fbb  # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as fbb
   from foo.bar import baz    # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as baz
   from foo import attr       # foo imported and foo.attr bound as attr

識別子のリストが星 ("'*'") に置き換わっている場合は、モジュールで定義
されている公開された全ての名前が、 "import" 文がいるスコープのローカル
名前空間に束縛されます。

モジュールで定義される *公開された名前* は、モジュールの名前空間にある
"__all__" という名前の変数を調べることで決定されます; その変数が定義さ
れている場合は、それはモジュールで定義されたかインポートされた名前から
なる、文字列のシーケンスでなければいけません。"__all__" で列挙された名
前は、全て公開されていると見なされ、存在することが要求されます。
"__all__" が定義されていない場合、公開された名前とは、モジュールの名前
空間で見付かった、アンダースコア文字 ("'_'") で始まらない全ての名前の
ことです。"__all__" は全ての公開 API を含むべきです。これは API の一部
でないもの (そのモジュールでインポートされ使われているライブラリモジュ
ールなど) をうっかり外部に公開してしまわないための仕組みです。

インポートのワイルドカード形式 --- "from module import *" --- は、モジ
ュールレベルでのみ許されます。クラスや関数定義でこの形式を使おうとする
と、 "SyntaxError" が送出されます。

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

どのモジュールがロードされるべきかを動的に決めたいアプリケーションのた
めに、組み込み関数 "importlib.import_module()" が提供されています。

Raises an auditing event "import" with arguments "module", "filename",
"sys.path", "sys.meta_path", "sys.path_hooks".


7.11.1. future 文 (future statement)
------------------------------------

*future 文* は、将来の特定の新たな機能が標準化された Python のリリース
で利用可能になるような構文や意味付けを使って、特定のモジュールをコンパ
イルさせるための、コンパイラに対する指示句 (directive) です。

future 文は互換性のない変更がされた将来の Python のバージョンに容易に
移行するためのものです。future 文によって新機能が標準となるリリースの
前にそれをモジュール単位で使用することが出来ます。

   future_stmt: "from" "__future__" "import" feature ["as" identifier]
                ("," feature ["as" identifier])*
                | "from" "__future__" "import" "(" feature ["as" identifier]
                ("," feature ["as" identifier])* [","] ")"
   feature:     identifier

future 文は、モジュールの先頭周辺に書かなければなりません。 future 文
の前に書いてよい内容は以下です :

* モジュールのドキュメンテーション文字列 ( あれば )

* コメント ,

* 空行 ,

* その他の future 文。

future 文を使う必要がある唯一の機能は "annotations" です (**PEP 563**
を参照してください)。

future 文で有効にできる歴史的な機能は、今でも Python 3 が認識します。
そのリストは "absolute_import", "division", "generator_stop",
"generators", "unicode_literals", "print_function", "nested_scopes",
"with_statement" です。 これらは既に全てが有効になっていて、後方互換性
のためだけに残されているため、冗長なだけです。

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

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

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

future 文の実行時における特別な意味付けは、 future 文で有効化される特
定の機能によって変わります。

以下の文には、何ら特殊な意味はないので注意してください:

   import __future__ [as name]

これは future 文ではありません; この文は通常の import 文であり、その他
の特殊な意味付けや構文的な制限はありません。

Code compiled by calls to the built-in functions "exec()" and
"compile()" 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 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__ 機構の原案


7.12. "global" 文
=================

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

The "global" statement causes the listed identifiers 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.

The "global" statement applies to the entire current scope (module,
function body or class definition). A "SyntaxError" is raised if a
variable is used or assigned to prior to its global declaration in the
scope.

At the module level, all variables are global, so a "global" statement
has no effect. However, variables must still not be used or assigned
to prior to their "global" declaration. This requirement is relaxed in
the interactive prompt (*REPL*).

**プログラマのための注意点:** "global" はパーザに対する指示句
(directive) です。この指示句は、 "global" 文と同時に読み込まれたコード
に対してのみ適用されます。特に、組み込みの "exec()" 関数内に入っている
"global" 文は、関数の呼び出しを *含んでいる* コードブロック内に効果を
及ぼすことはなく、そのような文字列に含まれているコードは、関数の呼び出
しを含むコード内の "global" 文に影響を受けません。同様のことが、関数
"eval()" および "compile()" にも当てはまります。


7.13. "nonlocal" 文
===================

   nonlocal_stmt: "nonlocal" identifier ("," identifier)*

When the definition of a function or class is nested (enclosed) within
the definitions of other functions, its nonlocal scopes are the local
scopes of the enclosing functions. The "nonlocal" statement causes the
listed identifiers to refer to names previously bound in nonlocal
scopes. It allows encapsulated code to rebind such nonlocal
identifiers.  If a name is bound in more than one nonlocal scope, the
nearest binding is used. If a name is not bound in any nonlocal scope,
or if there is no nonlocal scope, a "SyntaxError" is raised.

The "nonlocal" statement applies to the entire scope of a function or
class body. A "SyntaxError" is raised if a variable is used or
assigned to prior to its nonlocal declaration in the scope.

参考:

  **PEP 3104** - Access to Names in Outer Scopes
     "nonlocal" 文の詳細。

**Programmer's note:** "nonlocal" is a directive to the parser and
applies only to code parsed along with it.  See the note for the
"global" statement.


7.14. The "type" statement
==========================

   type_stmt: 'type' identifier [type_params] "=" expression

The "type" statement declares a type alias, which is an instance of
"typing.TypeAliasType".

For example, the following statement creates a type alias:

   type Point = tuple[float, float]

This code is roughly equivalent to:

   annotation-def VALUE_OF_Point():
       return tuple[float, float]
   Point = typing.TypeAliasType("Point", VALUE_OF_Point())

"annotation-def" indicates an annotation scope, which behaves mostly
like a function, but with several small differences.

The value of the type alias is evaluated in the annotation scope. It
is not evaluated when the type alias is created, but only when the
value is accessed through the type alias's "__value__" attribute (see
Lazy evaluation). This allows the type alias to refer to names that
are not yet defined.

Type aliases may be made generic by adding a type parameter list after
the name. See Generic type aliases for more.

"type" is a soft keyword.

Added in version 3.12.

参考:

  **PEP 695** - Type Parameter Syntax
     Introduced the "type" statement and syntax for generic classes
     and functions.
