6. 式 (expression)
******************

この章では、Python の式における個々の要素の意味について解説します。

**表記法に関する注意:** この章と以降の章での拡張BNF (extended BNF) 表
記は、字句解析規則ではなく、構文規則を記述するために用いられています。
ある構文規則 (のある表現方法) が、以下の形式

   name ::= othername

で記述されていて、この構文特有の意味付け (semantics) が記述されていな
い場合、 "name" の形式をとる構文の意味付けは "othername" の意味付けと
同じになります。


6.1. 算術変換 (arithmetic conversion)
=====================================

以下の算術演算子の記述で、「数値引数は共通の型に変換されます」と書かれ
ているとき、組み込み型に対する演算子の実装は以下の通りに動作します:

* 片方の引数が複素数型であれば、他方は複素数型に変換されます;

* それ以外の場合で、片方の引数が浮動小数点数であれば、他方は浮動小数点
  型に変換されます;

* それ以外場合は、両方の引数は整数でなければならず、変換の必要はありま
  せん。

特定の演算子 ('%' 演算子の左引数としての文字列) には、さらに別の規則が
適用されます。拡張は、それ自身の型変換のふるまいを定義していなければな
りません。


6.2. アトム、原子的要素 (atom)
==============================

atom は、式の一番基本的な要素です。もっとも単純な atom は、識別子また
はリテラルです。丸括弧、角括弧、または波括弧で囲われた形式 (form) もま
た、構文上アトムに分類されます。atom の構文は以下のようになります:

   atom      ::= identifier | literal | enclosure
   enclosure ::= parenth_form | list_display | dict_display | set_display
                 | generator_expression | yield_atom


6.2.1. 識別子 (identifier、または名前 (name))
---------------------------------------------

アトムの形になっている識別子 (identifier) は名前 (name) です。字句定義
については 識別子 (identifier) およびキーワード (keyword) 節を、名前付
けや束縛については 名前づけと束縛 (naming and binding) 節を参照してく
ださい。

名前があるオブジェクトに束縛されている場合、名前 atom を評価するとその
オブジェクトになります。名前が束縛されていない場合、 atom を評価しよう
とすると "NameError" 例外を送出します。

**プライベートな名前のマングリング:** クラス定義内に書かれた識別子で、
2つ以上のアンダースコアから始まり、末尾が2つ以上のアンダースコアで終わ
っていないものは、そのクラスの *プライベートな名前* とみなされます。プ
ライベートな名前は、コードが生成される前により長い形式に変換されます。
この変換によって、クラス名の先頭にアンダースコアがあれば除去し、先頭に
アンダースコアを1つ付加し、名前の前に挿入されます。例えば、クラス名
"Ham" の中の識別子 "__spam" は、"_Ham__spam" に変換されます。変換は識
別子が使用されている構文のコンテキストからは独立しています。変換された
名前が非常に長い (255文字を超える) 場合、実装によっては名前の切り詰め
が行われるかもしれません。クラス名がアンダースコアのみから成る場合は変
換は行われません。


6.2.2. リテラル
---------------

Python では、文字列やバイト列リテラルと、様々な数値リテラルをサポート
しています:

   literal ::= stringliteral | bytesliteral
               | integer | floatnumber | imagnumber

リテラルの評価は、与えられた型 (文字列、バイト列、整数、浮動小数点数、
複素数) の与えられた値を持つオブジェクトを与えます。浮動小数点や虚数 (
複素数) リテラルの場合、値は近似値になる場合があります。詳しくは リテ
ラル を参照してください。

リテラルは全て変更不能なデータ型に対応します。このため、オブジェクトの
アイデンティティはオブジェクトの値ほど重要ではありません。同じ値を持つ
複数のリテラルを評価した場合、(それらのリテラルがプログラムの同じ場所
由来のものであっても、そうでなくても) 同じオブジェクトを指しているか、
まったく同じ値を持つ別のオブジェクトになります。


6.2.3. 丸括弧形式 (parenthesized form)
--------------------------------------

丸括弧形式とは、式リストの一形態で、丸括弧で囲ったものです:

   parenth_form ::= "(" [starred_expression] ")"

丸括弧で囲われた式のリストは、個々の式が表現するものになります: リスト
内に少なくとも一つのカンマが入っていた場合、タプルになります; そうでな
い場合、式のリストを構成している単一の式自体の値になります。

中身が空の丸括弧のペアは、空のタプルオブジェクトを表します。タプルは変
更不能なので、リテラルと同じ規則が適用されます (すなわち、空のタプルが
二箇所で使われると、それらは同じオブジェクトになることもあるし、ならな
いこともあります)。

タプルは丸括弧で作成されるのではなく、カンマによって作成されることに注
意してください。例外は空のタプルで、この場合には丸括弧が *必要です*
--- 丸括弧のつかない "何も記述しない式 (nothing)" を使えるようにしてし
まうと、文法があいまいなものになってしまい、よくあるタイプミスが検出さ
れなくなってしまいます。


6.2.4. リスト、集合、辞書の表示
-------------------------------

Python は、リスト、集合、または辞書を構成するために、 "表示 (display)"
と呼ばれる特殊な構文を、それぞれ二種類づつ提供していて、コンテナの内容
は:

* 明示的に列挙される、または

* *内包表記 (comprehension)* と呼ばれる、ループ処理とフィルター処理の
  命令の組み合わせを通じて計算されます。

内包表記の共通の構文要素はこの通りです:

   comprehension ::= expression comp_for
   comp_for      ::= [ASYNC] "for" target_list "in" or_test [comp_iter]
   comp_iter     ::= comp_for | comp_if
   comp_if       ::= "if" expression_nocond [comp_iter]

内包表記はまず単一の式、続いて少なくとも 1 個の "for" 節、さらに続いて
0 個以上の "for" 節あるいは "if" 節からなります。 この場合、各々の
"for" や "if" 節を、左から右へ深くなっていくネストしたブロックとみなし
、ネストの最内のブロックに到達するごとに内包表記の先頭にある式を評価し
た結果が、最終的にできあがるコンテナの各要素になります。

なお、これらの内包表記は別のスコープで実行されるので、対象のリスト内で
代入された名前が外側のスコープに "漏れる" ことはありません。

Since Python 3.6, in an "async def" function, an "async for" clause
may be used to iterate over a *asynchronous iterator*. A comprehension
in an "async def" function may consist of either a "for" or "async
for" clause following the leading expression, may contain additional
"for" or "async for" clauses, and may also use "await" expressions. If
a comprehension contains either "async for" clauses or "await"
expressions it is called an *asynchronous comprehension*.  An
asynchronous comprehension may suspend the execution of the coroutine
function in which it appears. See also **PEP 530**.


6.2.5. リスト表現
-----------------

リスト表現は、角括弧で囲われた式の系列です。系列は空の系列であってもか
まいません:

   list_display ::= "[" [starred_list | comprehension] "]"

リスト表示は、新しいリストオブジェクトを与えます。リストの内容は、式の
リストまたはリスト内包表記 (list comprehension) で指定されます。 カン
マで区切られた式のリストが与えられたときは、それらの各要素は左から右へ
と順に評価され、その順にリスト内に配置されます。 内包表記が与えられた
ときは、内包表記の結果の要素でリストが構成されます。


6.2.6. 集合表現
---------------

集合表現は波括弧で表され、キーと値を分けるコロンがないことで辞書表現と
区別されます:

   set_display ::= "{" (starred_list | comprehension) "}"

集合表示は、新しいミュータブルな集合オブジェクトを与えます。集合の内容
は、式の並びまたは内包表記によって指定されます。 カンマ区切りの式のリ
ストが与えられたときは、その要素は左から右へ順に評価され、集合オブジェ
クトに加えられます。 内包表記が与えられたときは、内包表記の結果の要素
で集合が構成されます。

空集合は "{}" で構成できません。このリテラルは空の辞書を構成します。


6.2.7. 辞書表現
---------------

辞書表現は、波括弧で囲われた、キーと値のペアからなる系列です。系列は空
の系列であってもかまいません:

   dict_display       ::= "{" [key_datum_list | dict_comprehension] "}"
   key_datum_list     ::= key_datum ("," key_datum)* [","]
   key_datum          ::= expression ":" expression | "**" or_expr
   dict_comprehension ::= expression ":" expression comp_for

辞書表現は、新たな辞書オブジェクトを表します。

キーとデータからなる対の並びがカンマ区切りで与えられたときは、その要素
は左から右へ評価され、辞書のエントリーを定義します。すなわち、それぞれ
のキーオブジェクトが、辞書内で対応するデータを保存するキーとして使われ
ます。 これにより、キーとデータのリストの中で同じキーを複数回指定する
ことができ、そのキーに対する最終的な辞書の値は、最後に与えられたものに
なります。

ダブルアスタリスク "**" は *辞書のアンパック* を表します。このとき被演
算子は *mapping* でなければなりません。それぞれのmappingの要素は、新た
な辞書に追加されます。キー/データの対もしくは辞書のアンパックによって
先に追加された値は、後から追加された値によって上書きされます。

バージョン 3.5 で追加: 辞書表示のアンパッキングは最初に **PEP 448** で
提案されました。

辞書内包表記は、リストや集合の内包表記とは対照的に、通常の "for" や
"if" 節の前に、コロンで分けられた 2 つの式が必要です。内包表記が起動す
ると、結果のキーと値の要素が、作られた順に新しい辞書に挿入されます。

キーの値として使える型に関する制限は 標準型の階層 節ですでに列挙してい
ます。(一言でいうと、キーは変更可能なオブジェクトを全て排除した
*hashable* でなければなりません。) 重複するキー間で衝突が起きても、衝
突が検出されることはありません; あるキーに対して、最後に渡されたデータ
(プログラムテキスト上では、辞書表記の最も右側値となるもの) が使われま
す。


6.2.8. ジェネレータ式
---------------------

ジェネレータ式 (generator expression) とは、丸括弧を使ったコンパクトな
ジェネレータ表記法です:

   generator_expression ::= "(" expression comp_for ")"

ジェネレータ式は新たなジェネレータオブジェクトを与えます。この構文は内
包表記とほぼ同じですが、角括弧や波括弧ではなく、丸括弧で囲まれます。

ジェネレータ式の中で使われている変数は、 (通常のジェネレータと同じよう
に) そのジェネレータオブジェクトに対して "__next__()" メソッドが呼ばれ
たときに遅延評価されます。ただし、最も左に位置する "for" 節は直ちに評
価されるため、そこで生じたエラーは、 ジェネレータ式を扱うコードの中で
起きる他のエラーよりも前に表示されます。前の "for" ループに依存するか
もしれないので、後の "for" 節は即座に評価することができません。例えば:
"(x*y for x in range(10) for y in bar(x))" 。

関数の唯一の引数として渡す場合には、丸括弧を省略できます。詳しくは 呼
び出し (call) 節を参照してください。

Since Python 3.6, if the generator appears in an "async def" function,
then "async for" clauses and "await" expressions are permitted as with
an asynchronous comprehension.  If a generator expression contains
either "async for" clauses or "await" expressions it is called an
*asynchronous generator expression*. An asynchronous generator
expression yields a new asynchronous generator object, which is an
asynchronous iterator (see 非同期イテレータ (Asynchronous Iterator)).


6.2.9. Yield 式
---------------

   yield_atom       ::= "(" yield_expression ")"
   yield_expression ::= "yield" [expression_list | "from" expression]

yield 式は *ジェネレータ* 関数や term:*非同期ジェネレータ
<asynchronous generator>* を定義するときに使われます。従って、関数定義
の本体でのみ使えます。 関数の本体で yield 式 を使用するとその関数はジ
ェネレータになり、 "async def" 関数の本体で使用するとそのコルーチン関
数は非同期ジェネレータになります。 例えば次のようになります:

   def gen():  # defines a generator function
       yield 123

   async def agen(): # defines an asynchronous generator function
       yield 123

ジェネレータ関数についてはすぐ下で説明されています。非同期ジェネレータ
関数は、 非同期ジェネレータ関数 (asynchronous generator function) 節に
分けて説明されています。

ジェネレータ関数が呼び出された時、ジェネレータとしてのイテレータを返し
ます。ジェネレータはその後ジェネレータ関数の実行を制御します。ジェネレ
ータのメソッドが呼び出されると実行が開始されます。開始されると、最初の
yield 式まで処理して一時停止し、呼び出し元へ "expression_list" の値を
返します。ここで言う一時停止とは、ローカル変数の束縛、命令ポインタや内
部の評価スタック、そして例外処理のを含むすべてのローカル状態が保持され
ることを意味します。再度、ジェネレータのメソッドが呼び出されて実行を再
開した時、ジェネレータは yield 式がただの外部呼び出しであったかのよう
に処理を継続します。再開後の yield 式の値は実行を再開するメソッドに依
存します。"__next__()" を使用した場合 (一般に "for" 文や組み込み関数
"next()" など) の結果は "None" となり、"send()" を使用した場合はそのメ
ソッドに渡された値が結果になります。

これまで説明した内容から、ジェネレータ関数はコルーチンにとてもよく似て
います。ジェネレータ関数は何度も生成し、1つ以上のエントリポイントを持
ち、その実行は一時停止されます。ジェネレータ関数は yield した後で実行
の継続を制御できないことが唯一の違いです。その制御は常にジェネレータの
呼び出し元へ移されます。

yield 式は "try" 構造内で使用できます。ジェネレータの (参照カウントが
ゼロに達するか、ガベージコレクションによる) 完了前に再開されない場合、
ジェネレータ-イテレータの "close()" メソッドが呼ばれ、"finally" 節が実
行されます。

"yield from <expr>" を使用した場合、与えられた式はサブイテレータとして
扱われます。サブイテレータによって生成されたすべての値は現在のジェネレ
ータのメソッドの呼び出し元へ直接渡されます。"send()" で渡されたあらゆ
る値と "throw()" で渡されたあらゆる例外は根底のイテレータに適切なメソ
ッドがあれば渡されます。適切なメソッドがない場合、"send()" は
"AttributeError" か "TypeError" を、"throw()" は渡された例外を即座に送
出します。

根底のイテレータの完了時、引き起こされた "StopIteration" インスタンス
の "value" 属性はその yield 式の値となります。 "StopIteration" を起こ
す際に明示的にセットされるか、サブイテレータがジェネレータであれば (サ
ブイテレータからかえる値で) 自動的にセットされるかのどちらかです。

   バージョン 3.3 で変更: サブイテレータに制御フローを委譲するために
   "yield from <expr>" が追加されました。

yield 式が代入文の単独の右辺式であるとき、括弧は省略できます。

参考:

  **PEP 255** - 単純なジェネレータ
     Python へのジェネレータと "yield" 文の導入提案。

  **PEP 0342** - 拡張されたジェネレータを用いたコルーチン
     シンプルなコルーチンとして利用できるように、ジェネレータの構文と
     API を拡張する提案です。

  **PEP 380** - サブジェネレータへの委譲構文
     サブジェネレータの委譲を簡単にするための、 "yield_from" 構文の導
     入提案。

  **PEP 525** - 非同期ジェネレータ
     コルーチン関数へのジェネレータの実装能力の追加による **PEP 492**
     の拡張提案。


6.2.9.1. ジェネレータ-イテレータメソッド
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

この説ではジェネレータイテレータのメソッドについて説明します。これらは
ジェネレータ関数の実行制御に使用できます。

以下のジェネレータメソッドの呼び出しは、ジェネレータが既に実行中の場合
"ValueError" 例外を送出する点に注意してください。

generator.__next__()

   ジェネレータ関数の実行を開始するか、最後に yield 式が実行されたとこ
   ろから再開します。ジェネレータ関数が "__next__()" メソッドによって
   再開された時、その時点の "yield" 式の値は常に "None" と評価されます
   。その後次の "yield" 式まで実行し、ジェネレータは一時停止し、
   "expression_list" の値を "__next__()" メソッドの呼び出し元に返しま
   す。ジェネレータが次の値を yield せずに終了した場合、
   "StopIteration" 例外が送出されます。

   このメソッドは通常、例えば "for" ループや組み込みの "next()" 関数に
   よって暗黙に呼び出されます。

generator.send(value)

   ジェネレータ関数の内部へ値を "送り"、実行を再開します。引数の
   *value* はその時点の yield 式の結果になります。 "send()" メソッドは
   次にジェネレータが生成した値を返し、ジェネレータが次の値を生成する
   ことなく終了すると "StopIteration" を送出します。 "send()" が呼び出
   されてジェネレータが開始するときは、値を受け取る yield 式が存在しな
   いので、 "None" を引数として呼び出さなければなりません。

generator.throw(type[, value[, traceback]])

   ジェネレータが中断した位置で "type" 型の例外を発生させて、そのジェ
   ネレータ関数が生成する次の値を返します。ジェネレータが値を生成する
   ことなく終了すると "StopIteration" が発生します。ジェネレータ関数が
   渡された例外を捕捉しない、もしくは違う例外を発生させるなら、その例
   外は呼び出し元へ伝搬されます。

generator.close()

   ジェネレータ関数が一時停止した時点で "GeneratorExit" を発生させます
   。 そして、ジェネレータ関数が無事に終了するか、既にクローズされてい
   るか、(例外が捕捉されなかったために) "GeneratorExit" が送出された場
   合、 close は呼び出し元へ戻ります。 ジェネレータが値を生成する場合
   "RuntimeError" が発生します。 "close()" はジェネレータが例外や正常
   な終了により既に終了している場合は何もしません。


6.2.9.2. 使用例
~~~~~~~~~~~~~~~

以下の簡単なサンプルはジェネレータとジェネレータ関数の振る舞いを実際に
紹介します:

   >>> def echo(value=None):
   ...     print("Execution starts when 'next()' is called for the first time.")
   ...     try:
   ...         while True:
   ...             try:
   ...                 value = (yield value)
   ...             except Exception as e:
   ...                 value = e
   ...     finally:
   ...         print("Don't forget to clean up when 'close()' is called.")
   ...
   >>> generator = echo(1)
   >>> print(next(generator))
   Execution starts when 'next()' is called for the first time.
   1
   >>> print(next(generator))
   None
   >>> print(generator.send(2))
   2
   >>> generator.throw(TypeError, "spam")
   TypeError('spam',)
   >>> generator.close()
   Don't forget to clean up when 'close()' is called.

"yield from" の使用例は、"What's New in Python." の PEP 380: サブジェ
ネレータへの委譲構文 を参照してください。


6.2.9.3. 非同期ジェネレータ関数 (asynchronous generator function)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"async def" を使用して定義された関数やメソッドに yield 式があると、そ
の関数は *非同期ジェネレータ* 関数として定義されます。

非同期ジェネレータ関数が呼び出されると、非同期ジェネレータオブジェクト
と呼ばれる非同期イテレータが返されます。そのオブジェクトは、ジェネレー
タ関数の実行を制御します。 通常、非同期ジェネレータオブジェクトは、コ
ルーチン関数の "async for" ステートメントで、ジェネレータオブジェクト
が "for" ステートメントで使用される方法と同様に使用されます。

非同期ジェネレータのメソッドの1つを呼び出すと *awaitable`オブジェクト
が返され、このオブジェクトが待機しているときに実行が開始されます。その
時点で、実行は最初の yield 式に進み、そこで再び中断され、
:token:`expression_list* の値を待機中のコルーチンに返します。 ジェネレ
ータと同様に、中断とは、ローカル変数の現在のバインディング、命令ポイン
タ、内部評価スタック、および例外処理の状態など、すべてのローカル状態が
保持されることを意味します。 非同期ジェネレータのメソッドによって返さ
れた次のオブジェクトで待機することによって実行が再開されると、関数は
yield式が単なる外部呼び出しであるかのように正確に処理を進めることがで
きます。 再開後の yield 式の値は、実行を再開したメソッドによって異なり
ます。"__anext__()" を使うと、結果は "None" になります。それ以外の場合
、 "asend()" が使用された場合、結果はそのメソッドに渡された値になりま
す。

In an asynchronous generator function, yield expressions are allowed
anywhere in a "try" construct. However, if an asynchronous generator
is not resumed before it is finalized (by reaching a zero reference
count or by being garbage collected), then a yield expression within a
"try" construct could result in a failure to execute pending "finally"
clauses.  In this case, it is the responsibility of the event loop or
scheduler running the asynchronous generator to call the asynchronous
generator-iterator's "aclose()" method and run the resulting coroutine
object, thus allowing any pending "finally" clauses to execute.

To take care of finalization, an event loop should define a
*finalizer* function which takes an asynchronous generator-iterator
and presumably calls "aclose()" and executes the coroutine. This
*finalizer* may be registered by calling "sys.set_asyncgen_hooks()".
When first iterated over, an asynchronous generator-iterator will
store the registered *finalizer* to be called upon finalization. For a
reference example of a *finalizer* method see the implementation of
"asyncio.Loop.shutdown_asyncgens" in Lib/asyncio/base_events.py.

"yield from <expr>" 式は、非同期ジェネレータ関数で使われると文法エラー
になります。


6.2.9.4. 非同期ジェネレータイテレータメソッド
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

この小節では、ジェネレータ関数の実行制御に使われる非同期ジェネレータイ
テレータのメソッドについて説明します。

coroutine agen.__anext__()

   Returns an awaitable which when run starts to execute the
   asynchronous generator or resumes it at the last executed yield
   expression.  When an asynchronous generator function is resumed
   with a "__anext__()" method, the current yield expression always
   evaluates to "None" in the returned awaitable, which when run will
   continue to the next yield expression. The value of the
   "expression_list" of the yield expression is the value of the
   "StopIteration" exception raised by the completing coroutine.  If
   the asynchronous generator exits without yielding another value,
   the awaitable instead raises an "StopAsyncIteration" exception,
   signalling that the asynchronous iteration has completed.

   このメソッドは通常、 "for" ループによって暗黙に呼び出されます。

coroutine agen.asend(value)

   Returns an awaitable which when run resumes the execution of the
   asynchronous generator. As with the "send()" method for a
   generator, this "sends" a value into the asynchronous generator
   function, and the *value* argument becomes the result of the
   current yield expression. The awaitable returned by the "asend()"
   method will return the next value yielded by the generator as the
   value of the raised "StopIteration", or raises "StopAsyncIteration"
   if the asynchronous generator exits without yielding another value.
   When "asend()" is called to start the asynchronous generator, it
   must be called with "None" as the argument, because there is no
   yield expression that could receive the value.

coroutine agen.athrow(type[, value[, traceback]])

   Returns an awaitable that raises an exception of type "type" at the
   point where the asynchronous generator was paused, and returns the
   next value yielded by the generator function as the value of the
   raised "StopIteration" exception.  If the asynchronous generator
   exits without yielding another value, an "StopAsyncIteration"
   exception is raised by the awaitable. If the generator function
   does not catch the passed-in exception, or raises a different
   exception, then when the awaitable is run that exception propagates
   to the caller of the awaitable.

coroutine agen.aclose()

   Returns an awaitable that when run will throw a "GeneratorExit"
   into the asynchronous generator function at the point where it was
   paused. If the asynchronous generator function then exits
   gracefully, is already closed, or raises "GeneratorExit" (by not
   catching the exception), then the returned awaitable will raise a
   "StopIteration" exception. Any further awaitables returned by
   subsequent calls to the asynchronous generator will raise a
   "StopAsyncIteration" exception.  If the asynchronous generator
   yields a value, a "RuntimeError" is raised by the awaitable.  If
   the asynchronous generator raises any other exception, it is
   propagated to the caller of the awaitable.  If the asynchronous
   generator has already exited due to an exception or normal exit,
   then further calls to "aclose()" will return an awaitable that does
   nothing.


6.3. プライマリ
===============

プライマリは、言語において最も結合の強い操作を表します。文法は以下のよ
うになります:

   primary ::= atom | attributeref | subscription | slicing | call


6.3.1. 属性参照
---------------

属性参照は、プライマリの後ろにピリオドと名前を連ねたものです:

   attributeref ::= primary "." identifier

プライマリの評価は、属性参照をサポートする型のオブジェクトでなければな
らず、これにはほとんどのオブジェクトが当てはまります。そしてこのオブジ
ェクトは、名前が指定した識別子名であるような属性を生成しなければなりま
せん。この生成は "__getattr__()" メソッドをオーバーライドすることでカ
スタマイズできます。その属性が得られなければ、例外 "AttributeError" が
送出されます。そうでなければ、生成されるオブジェクトの型と値は、属性を
生成したオブジェクトにより決まります。同じ属性参照を複数回評価すると、
互いに異なる属性オブジェクトが得られることがあります。


6.3.2. 添字表記 (subscription)
------------------------------

添字表記は、シーケンス (文字列、タプルまたはリスト) やマップ (辞書) オ
ブジェクトから、要素を一つ選択します:

   subscription ::= primary "[" expression_list "]"

プライマリの評価は、添字表記をサポートするオブジェクト (例えばリストや
辞書) でなければなりません。ユーザ定義のオブジェクトは、
"__getitem__()" メソッドを定義することで添字表記をサポートできます。

組み込みオブジェクトでは、添字表記をサポートするオブジェクトには 2 種
類あります:

プライマリがマップであれば、式リストの値評価結果はマップ内のいずれかの
キー値に相当するオブジェクトにならなければなりません。添字表記は、その
キーに対応するマップ内の値 (value) を選択します。 (式リストの要素が単
独である場合を除き、式リストはタプルでなければなりません。)

プライマリがシーケンスであれば、式リストの評価結果は整数またはスライス
(以下の節で論じます) でなければなりません。

形式的な構文はシーケンスの負のインデックスにいかなる特例も与えません。
しかし、すべての組み込みのシーケンスが与える "__getitem__()" メソッド
は、負のインデックスを、インデックスにシーケンスの長さを加えて解釈しま
す (つまり、 "x[-1]" は "x" の最後の要素を選択します)。結果の値はシー
ケンスの要素数より小さな非負の整数でなければなりません。添字表記は、(0
から数えた) インデックスを持つ要素を選択します。負のインデックスのサポ
ートは、オブジェクトの "__getitem__()" メソッドに現れるので、このメソ
ッドをオーバーライドするサブクラスは、明示的にこのサポートを追加する必
要があります。

文字列型の要素は文字 (character) です。文字は個別の型ではなく、 1 文字
だけからなる文字列です。


6.3.3. スライス表記 (slicing)
-----------------------------

スライス表記はシーケンスオブジェクト (文字列、タプルまたはリスト) にお
けるある範囲の要素を選択します。スライス表記は式として用いたり、代入や
"del" 文の対象として用いたりできます。スライス表記の構文は以下のように
なります:

   slicing      ::= primary "[" slice_list "]"
   slice_list   ::= slice_item ("," slice_item)* [","]
   slice_item   ::= expression | proper_slice
   proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
   lower_bound  ::= expression
   upper_bound  ::= expression
   stride       ::= expression

上記の形式的な構文法にはあいまいなところがあります: 式リストに見えるも
のは、スライスリストにも見えるため、添字表記はスライス表記としても解釈
されうるということです。(スライスリストが適切なスライスを含まない場合)
、これ以上の構文の複雑化はせず、スライス表記としての解釈よりも添字表記
としての解釈が優先されるように定義することで、あいまいさを取り除いてい
ます。

スライス表記に対する意味付けは、以下のようになります。プライマリの値評
価結果は、以下に述べるようにしてスライスリストから生成されたキーによっ
て (通常の添字表記と同じ "__getitem__()" メソッドを使って) インデクス
指定できなければなりません。スライスリストに一つ以上のカンマが含まれて
いる場合、キーは各スライス要素を値変換したものからなるタプルになります
; それ以外の場合、単一のスライス要素自体を値変換したものがキーになりま
す。一個の式であるスライス要素は、その式に変換されます。適切なスライス
は、スライスオブジェクト (標準型の階層 参照) に変換され、その "start",
"stop" および "step"  属性は、それぞれ指定した下境界、上境界、およびと
び幅 (stride) になります。式がない場所は "None" で置き換えられます。


6.3.4. 呼び出し (call)
----------------------

呼び出しは、呼び出し可能オブジェクト (例えば *function*) を
*arguments* の系列とともに呼び出します。系列は空の系列であってもかまい
ません:

   call                 ::= primary "(" [argument_list [","] | comprehension] ")"
   argument_list        ::= positional_arguments ["," starred_and_keywords]
                       ["," keywords_arguments]
                     | starred_and_keywords ["," keywords_arguments]
                     | keywords_arguments
   positional_arguments ::= ["*"] expression ("," ["*"] expression)*
   starred_and_keywords ::= ("*" expression | keyword_item)
                            ("," "*" expression | "," keyword_item)*
   keywords_arguments   ::= (keyword_item | "**" expression)
                          ("," keyword_item | "," "**" expression)*
   keyword_item         ::= identifier "=" expression

最後の位置引数やキーワード引数の後にカンマをつけてもかまいません。構文
の意味付けに影響を及ぼすことはありません。

プライマリの評価は呼び出し可能オブジェクトでなければなりません。 (ユー
ザ定義関数、組み込み関数、組み込みオブジェクトのメソッド、クラスオブジ
ェクト、クラスインスタンスのメソッド、および "__call__()" メソッドを持
つ全てのオブジェクトが呼び出し可能です)。引数式は全て、呼び出しを試み
る前に評価されます。仮引数 (formal *parameter*) リストの構文については
関数定義 を参照してください。

キーワード引数が存在する場合、以下のようにして最初に位置引数
(positional argument) に変換されます。まず、値の入っていないスロットが
仮引数に対して生成されます。N 個の位置引数がある場合、位置引数は先頭の
N スロットに配置されます。次に、各キーワード引数について、識別子を使っ
て対応するスロットを決定します (識別子が最初の仮引数名と同じなら、最初
のスロットを使う、といった具合です)。スロットがすでにすべて埋まってい
たなら "TypeError" 例外が送出されます。それ以外の場合、引数値をスロッ
トに埋めていきます。 (式が "None" であっても、その式でスロットを埋めま
す)。全ての引数が処理されたら、まだ埋められていないスロットをそれぞれ
に対応する関数定義時のデフォルト値で埋めます。(デフォルト値は、関数が
定義されたときに一度だけ計算されます; 従って、リストや辞書のような変更
可能なオブジェクトがデフォルト値として使われると、対応するスロットに引
数を指定しない限り、このオブジェクトが全ての呼び出しから共有されます;
このような状況は通常避けるべきです。) デフォルト値が指定されていない、
値の埋められていないスロットが残っている場合 "TypeError" 例外が送出さ
れます。そうでない場合、値の埋められたスロットからなるリストが呼び出し
の引数として使われます。

**CPython implementation detail:** 実装では、名前を持たない位置引数を
受け取る組み込み関数を提供されるかもしれません。そういった引数がドキュ
メント化のために '名付けられて' いたとしても、実際には名付けられていな
いのでキーワードでは提供されません。 CPython では、C 言語で実装された
関数の、名前を持たない位置引数をパースするために "PyArg_ParseTuple()"
を使用します。

仮引数スロットの数よりも多くの位置引数がある場合、構文 "*identifier"
を使って指定された仮引数がないかぎり、 "TypeError" 例外が送出されます;
仮引数 "*identifier" がある場合、この仮引数は余分な位置引数が入ったタ
プル (もしくは、余分な位置引数がない場合には空のタプル) を受け取ります
。

キーワード引数のいずれかが仮引数名に対応しない場合、構文
"**identifier" を使って指定された仮引数がない限り、 "TypeError" 例外が
送出されます; 仮引数 "**identifier" がある場合、この仮引数は余分なキー
ワード引数が入った (キーワードをキーとし、引数値をキーに対応する値とし
た) 辞書を受け取ります。余分なキーワード引数がない場合には、空の (新た
な) 辞書を受け取ります。

関数呼び出しに "*expression" という構文が現れる場合は、 "expression"
の評価結果は *イテラブル* でなければなりません。 そのイテラブルの要素
は、追加の位置引数であるかのように扱われます。 "f(x1, x2, *y, x3, x4)"
という呼び出しにおいて、 *y* の評価結果がシーケンス *y1*, ..., *yM* だ
った場合は、この呼び出しは M+4 個の位置引数 *x1*, *x2*, *y1*, ...,
*yM*, *x3*, *x4* での呼び出しと同じになります。

この結論としては、 "*expression" 構文がキーワード引数の *後ろ* に来る
こともありますが、キーワード引数 (と任意の "**expression" 引数 -- 下を
参照) よりも *前* にあるものとして処理されます。 従って、このような動
作になります:

   >>> def f(a, b):
   ...     print(a, b)
   ...
   >>> f(b=1, *(2,))
   2 1
   >>> f(a=1, *(2,))
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: f() got multiple values for keyword argument 'a'
   >>> f(1, *(2,))
   1 2

キーワード引数と "*expression" 構文を同じ呼び出しで一緒に使うことはあ
まりないので、実際に上記のような混乱が生じることはありません。

関数呼び出しで "**expression" 構文が使われた場合、 "expression" の評価
結果は *マッピング* でなければなりません。その内容は追加のキーワード引
数として扱われます。 キーワードが (明示的なキーワード引数として、ある
いは他のアンパッキングの中に) 既に存在する場合、 "TypeError" 例外が送
出されます。

"*identifier" や "**identifier" 構文を使った仮引数は、位置引数スロット
やキーワード引数名にすることができません。

バージョン 3.5 で変更: 関数呼び出しは任意の数の "*" アンパッキングと
"**" アンパッキングを受け取り、位置引数はイテラブルアンパッキング
("*") の後ろに置け、キーワード引数は辞書アンパッキング ("**") の後ろに
置けるようになりました。 最初に **PEP 448** で提案されました。

呼び出しを行うと、例外を送出しない限り、常に何らかの値を返します。
"None" を返す場合もあります。戻り値がどのように算出されるかは、呼び出
し可能オブジェクトの形態によって異なります。

各形態では---

ユーザ定義関数:
   関数のコードブロックに引数リストが渡され、実行されます。コードブロ
   ックは、まず仮引数を実引数に結合 (bind) します; この動作については
   関数定義 で記述しています。コードブロックで "return" 文が実行される
   際に、関数呼び出しの戻り値 (return value) が決定されます。

組み込み関数またはメソッド:
   結果はインタプリタに依存します; 組み込み関数やメソッドの詳細は 組み
   込み関数 を参照してください。

クラスオブジェクト:
   そのクラスの新しいインスタンスが返されます。

クラスインスタンスメソッド:
   対応するユーザ定義の関数が呼び出されます。このとき、呼び出し時の引
   数リストより一つ長い引数リストで呼び出されます: インスタンスが引数
   リストの先頭に追加されます。

クラスインスタンス:
   クラスで "__call__()" メソッドが定義されていなければなりません;
   "__call__()" メソッドが呼び出された場合と同じ効果をもたらします。


6.4. Await 式
=============

*awaitable* オブジェクトでの *coroutine* 実行を一時停止します。
*coroutine function* 内でのみ使用できます。

   await_expr ::= "await" primary

バージョン 3.5 で追加.


6.5. べき乗演算 (power operator)
================================

べき乗演算は、左側にある単項演算子よりも強い結合優先順位があります; 一
方、右側にある単項演算子よりは低い結合優先順位になっています。構文は以
下のようになります:

   power ::= (await_expr | primary) ["**" u_expr]

従って、べき乗演算子と単項演算子からなる演算列が丸括弧で囲われていない
場合、演算子は右から左へと評価されます (この場合は演算子の評価順序を強
制しません。つまり "-1**2" は "-1" になります)。

べき乗演算子の意味は、二つの引数で呼び出される組み込み関数 "pow()" と
同じで、左引数を右引数乗して与えます。数値引数はまず共通の型に変換され
、結果はその型です。

整数の被演算子では、第二引数が負でない限り、結果は被演算子と同じ型にな
ります; 第二引数が負の場合、全ての引数は浮動小数点型に変換され、浮動小
数点型が返されます。例えば "10**2" は "100" を返しますが、"10**-2" は
"0.01" を返します。

"0.0" を負の数でべき乗すると "ZeroDivisionError" を送出します。負の数
を小数でべき乗した結果は複素数 ("complex" number) になります。 (以前の
バージョンでは "ValueError" を送出していました)


6.6. 単項算術演算とビット単位演算 (unary arithmetic and bitwise operation)
==========================================================================

全ての単項算術演算とビット単位演算は、同じ優先順位を持っています:

   u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr

単項演算子 "-" (マイナス) は、引数となる数値の符号を反転 (negation) し
ます。

単項演算子 "+" (プラス) は、数値引数を変更しません。

単項演算子 "~" (反転) は、整数引数をビット単位反転 (bitwise invert) し
たものを与えます。"x" のビット単位反転は、"-(x+1)" として定義されてい
ます。この演算子は整数にのみ適用されます。

上記の三つはいずれも、引数が正しい型でない場合には "TypeError" 例外が
送出されます。


6.7. 二項算術演算 (binary arithmetic operation)
===============================================

二項算術演算は、慣習的な優先順位を踏襲しています。演算子のいずれかは、
特定の非数値型にも適用されるので注意してください。べき乗 (power) 演算
子を除き、演算子には二つのレベル、すなわち乗算的 (multiplicatie) 演算
子と加算的 (additie) 演算子しかありません:

   m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
              m_expr "//" u_expr | m_expr "/" u_expr |
              m_expr "%" u_expr
   a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr

"*" (乗算: multiplication) 演算子は、引数同士の積を与えます。引数は、
両方とも数値であるか、片方が整数で他方がシーケンスかのどちらかでなけれ
ばなりません。前者の場合、数値は共通の型に変換された後乗算されます。後
者の場合、シーケンスの繰り返し操作が行われます。繰り返し数を負にすると
、空のシーケンスを与えます。

"@" (at) 演算子は行列の乗算に対し使用されます。 Python の組み込み型は
この演算子を実装していません。

バージョン 3.5 で追加.

"/" (除算: division) および "//" (切り捨て除算: floor division) は、引
数同士の商を与えます。数値引数はまず共通の型に変換されます。整数の除算
結果は浮動小数点になりますが、整数の切り捨て除算結果は整数になります;
この場合、結果は数学的な除算に 'floor' 関数 を適用したものになります。
ゼロによる除算を行うと "ZeroDivisionError" 例外を送出します。

"%" (剰余: modulo) 演算は、第一引数を第二引数で除算したときの剰余にな
ります。数値引数はまず共通の型に変換されます。右引数値がゼロの場合には
"ZeroDivisionError" 例外が送出されます。引数値は浮動小数点でもよく。例
えば "3.14%0.7" は "0.34" になります ("3.14" は "4*0.7 + 0.34" だから
です)。剰余演算子は常に第二引数と同じ符号 (またはゼロ) の結果になりま
す; 剰余演算の結果の絶対値は、常に第二引数の絶対値よりも小さくなります
。 [1]

切り捨て除算演算と剰余演算は、恒等式: "x == (x//y)*y + (x%y)" の関係に
あります。切り捨て除算や剰余はまた、組み込み関数 "divmod()":
"divmod(x, y) == (x//y, x%y)" とも関係しています。 [2] 。

"%" 演算子は、数値に対する剰余演算を行うのに加えて、文字列 (string) オ
ブジェクトにオーバーロードされ、旧式の文字列の書式化 (いわゆる補間) を
行います。文字列の書式化の構文は Python ライブラリリファレンス printf
形式の文字列書式化 節を参照してください。

切り捨て除算演算子、剰余演算子、および "divmod()" 関数は、複素数に対し
ては定義されていません。目的に合うならば、代わりに "abs()" を使って浮
動小数点に変換してください。

"+" (加算) 演算は、引数同士の和を与えます。引数は双方とも数値型か、双
方とも同じ型のシーケンスでなければなりません。前者の場合、数値は共通の
型に変換され、加算されます。後者の場合、シーケンスは結合 (concatenate)
されます。

"-" (減算) 演算は、引数間で減算を行った値を返します。数値引数はまず共
通の型に変換されます。


6.8. シフト演算 (shifting operation)
====================================

シフト演算は、算術演算よりも低い優先順位を持っています:

   shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr

これらは整数を引数にとります。引数は共通の型に変換されます。シフト演算
は第一引数を、第二引数で与えられたビット数だけ、左または右にビットシフ
トします。

*n* ビットの右シフトは "pow(2,n)" による除算として定義されます。*n* ビ
ットの左シフトは "pow(2,n)" による乗算として定義されます。

注釈:

  現在の実装では、右辺被演算子は最大でも "sys.maxsize" でなければなり
  ません。右辺被演算子が "sys.maxsize" よりも大きいと、
  "OverflowError" 例外が送出されます。


6.9. ビット単位演算の二項演算 (binary bitwise operation)
========================================================

以下の三つのビット単位演算には、それぞれ異なる優先順位レベルがあります
:

   and_expr ::= shift_expr | and_expr "&" shift_expr
   xor_expr ::= and_expr | xor_expr "^" and_expr
   or_expr  ::= xor_expr | or_expr "|" xor_expr

"&" 演算子は、引数同士のビット単位の AND を与えます。引数は整数でなけ
ればなりません。

"^" 演算子は、引数同士のビット単位の XOR (排他的 OR) を与えます。引数
は整数でなければなりません。

"|" 演算子は、引数同士のビット単位の (包含的) OR を与えます。引数は整
数でなければなりません。


6.10. 比較
==========

C 言語と違って、Python における比較演算子は同じ優先順位をもっており、
全ての算術演算子、シフト演算子、ビット単位演算子よりも低くなっています
。また "a < b < c" が数学で伝統的に用いられているのと同じ解釈になる点
も C 言語と違います:

   comparison    ::= or_expr (comp_operator or_expr)*
   comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
                     | "is" ["not"] | ["not"] "in"

比較演算の結果はブール値: "True" または "False" になります。

比較はいくらでも連鎖することができます。例えば "x < y <= z" は "x < y
and y <= z" と等価になります。ただしこの場合、前者では "y" はただ一度
だけ評価される点が異なります (どちらの場合でも、 "x < y" が偽になると
"z" の値はまったく評価されません)。

形式的には、 *a*, *b*, *c*, ..., *y*, *z* が式で *op1*, *op2*, ...,
*opN* が比較演算子である場合、 "a op1 b op2 c ... y opN z" は "a op1 b
and b op2 c and ... y opN z" と等価になります。ただし、前者では各式は
多くても一度しか評価されません。

"a op1 b op2 c" と書いた場合、 *a* から *c* までの範囲にあるかどうかの
テストを指すのではないことに注意してください。例えば "x < y > z" は (
きれいな書き方ではありませんが) 完全に正しい文法です。


6.10.1. 値の比較
----------------

演算子 "<", ">", "==", ">=", "<=", および "!=" は2つのオブジェクトの値
を比較します。 オブジェクトが同じ型を持つ必要はりません。

オブジェクト、値、および型 の章では、オブジェクトは (型や id のに加え
て) 値を持つことを述べています。 オブジェクトの値は Python ではやや抽
象的な概念です: 例えば、オブジェクトの値にアクセスする正統な方法はあり
ません。 また、その全てのデータ属性から構成されるなどの特定の方法で、
オブジェクトの値を構築する必要性もありません。 比較演算子は、オブジェ
クトの値とは何かについての特定の概念を実装しています。 この比較の実装
によって、間接的にオブジェクトの値を定義している考えることもできます。

全ての型は (直接的あるいは間接的に) "object" のサブクラスとなっている
ので、デフォルトの比較の振る舞いを "object" から継承しています。 基本
的なカスタマイズ で解説されているように、型を使って *rich comparison
methods* である "__lt__()" などのメソッドを実装することで、 比較の振る
舞いをカスタマイズできます。

等価性比較 ("==" および "!=") のデフォルトの振る舞いは、オブジェクトの
同一性に基づいています。 従って、同一のインスタンスの等価性比較の結果
は等しいとなり、同一でないインスタンスの等価性比較の結果は等しくないと
なります。 デフォルトの振る舞いをこのようにしたのは、全てのオブジェク
トを反射的 (reflexive つまり "x is y" ならば "x == y") なものにしたか
ったからです。

デフォルトの順序比較 ("<", ">", "<=", ">=") は提供されません; 比較しよ
うとすると "TypeError" が送出されます。 この振る舞いをデフォルトの振る
舞いにした動機は、等価性と同じような不変性が欠けているからです。

同一でないインスタンスは常に等価でないとする等価性比較のデフォルトの振
る舞いは、型が必要とするオブジェクトの値や値に基づいた等価性の実用的な
定義とは対照的に思えるでしょう。 そのような型では比較の振る舞いをカス
タマイズする必要が出てきて、実際にたくさんの組み込み型でそれが行われて
います。

次のリストでは、最重要の組み込み型の比較の振る舞いを解説しています。

* いくつかの組み込みの数値型 (数値型 int, float, complex) と標準ライブ
  ラリの型 "fractions.Fraction" および "decimal.Decimal" は、同じ型や
  別の型どうしで比較できますが、複素数では順序比較がサポートされていな
  いという制限があります。 関わる型の制限の範囲内では、精度のロス無し
  に数学的に (アルゴリズム的に) 正しい比較が行われます。

  The not-a-number values "float('NaN')" and "Decimal('NaN')" are
  special.  They are identical to themselves ("x is x" is true) but
  are not equal to themselves ("x == x" is false).  Additionally,
  comparing any number to a not-a-number value will return "False".
  For example, both "3 < float('NaN')" and "float('NaN') < 3" will
  return "False".

* バイナリシーケンス ("bytes" または "bytearray" のインスタンス) は、
  同じ型どうしでも別の型とでも比較できます。 比較は要素の数としての値
  を使った辞書順で行われます。

* 文字列 ("str" のインスタンス) の比較は、文字の Unicode のコードポイ
  ントの数としての値 (組み込み関数 "ord()" の返り値) を使った辞書順で
  行われます。 [3]

  文字列とバイナリシーケンスは直接には比較できません。

* シーケンス ("tuple", "list", or "range" のインスタンス) の比較は、同
  じ型どうしでしか行えず、 range は順序比較をサポートしていません。 異
  なる型どうしの等価比較の結果は等価でないとなり、異なる型どうしの順序
  比較は "TypeError" を送出します。

  シーケンスの比較は、要素の反射性があるものとして、対応する要素どうし
  の比較を使って辞書順で行われます。

  要素の反射性が強制されていると、コレクションの比較ではコレクションの
  要素 "x" に対して "x == x" が常に真だと仮定します。 この仮定に基づい
  て、最初に要素の同一性が比較され、同一でない要素どうしに対してのみ要
  素の比較が行われます。 この手法は、比較される要素が反射的な場合、厳
  密な要素比較と同じ結果をもたらします。 反射的でない要素では厳密な要
  素比較と異なる結果になり、驚くかもしれません: 例えば、反射的でない非
  数値がリストで使われたとき、比較の振る舞いは次のような結果になります
  :

     >>> nan = float('NaN')
     >>> nan is nan
     True
     >>> nan == nan
     False                 <-- the defined non-reflexive behavior of NaN
     >>> [nan] == [nan]
     True                  <-- list enforces reflexivity and tests identity first

  組み込みのコレクションどうしの辞書式比較は次のように動作します:

  * 比較の結果が等価となる2つのコレクションは、同じ型、同じ長さ、対応
    する要素どうしの比較の結果が等価でなければなりません (例えば、
    "[1,2] == (1,2)" は型が同じでないので偽です)。

  * 順序比較をサポートしているコレクションの順序は、最初の等価でない要
    素の順序と同じになります (例えば、 "[1,2,x] <= [1,2,y]" は "x <=
    y" と同じ値になります)。 対応する要素が存在しない場合、短い方のコ
    レクションの方が先の順序となります (例えば、 "[1,2] < [1,2,3]" は
    真です)。

* マッピング ("dict" のインスタンス) の比較の結果が等価となるのは、同
  じ *(key, value)* を持っているときかつそのときに限ります。 キーと値
  の等価性比較では反射性が強制されます。

  順序比較 ("<", ">", "<=", ">=") は "TypeError" を送出します。

* 集合 ("set" または "frozenset" のインスタンス) の比較は、これらの型
  の範囲で異なる型とも行えます。

  集合には、部分集合あるいは上位集合かどうかを基準とする順序比較が定義
  されています。 この関係は全順序を定義しません (例えば、 "{1,2}" と
  "{2,3}" という2つの集合は片方がもう一方の部分集合でもなく上位集合で
  もありません)。 従って、集合は全順序性に依存する関数の引数として適切
  ではありません (例えば、 "min()", "max()", "sorted()" は集合のリスト
  を入力として与えると未定義な結果となります)。

  集合の比較では、その要素の反射性が強制されます。

* 他の組み込み型のほとんどは比較メソッドが実装されておらず、デフォルト
  の比較の振る舞いを継承します。

比較の振る舞いをカスタマイズしたユーザ定義クラスは、可能なら次の一貫性
の規則に従う必要があります:

* 等価比較は反射的でなければなりません。 つまり、同一のオブジェクトは
  等しくなければなりません:

     "x is y" は暗黙的に "x == y"

* 比較は対称でなければなりません。 つまり、以下の式の結果は同じでなけ
  ればなりません:

     "x == y" と "y == x"

     "x != y" と "y != x"

     "x < y" と "y > x"

     "x <= y" と "y >= x"

* 比較は推移的でなければなりません。 以下の (包括的でない) 例がその説
  明です:

     "x > y and y > z" は暗黙的に "x > z"

     "x < y and y <= z" は暗黙的に "x < z"

* 比較の逆はブールの否定でなければなりません。 つまり、以下の式の結果
  は同じでなければなりません:

     "x == y" と "not x != y"

     "x < y" と "not x >= y" (全順序の場合)

     "x > y" と "not x <= y" (全順序の場合)

  最後の2式は全順序の集まりに適用されます (たとえばシーケンスには適用
  されますがセットやマッピングには適用されません)。 "total_ordering()"
  デコレータも参照してください。

* "hash()" の結果は等価性と一貫している必要があります。 等価なオブジェ
  クトどうしは同じハッシュ値を持つか、ハッシュ値が計算できないものとさ
  れる必要があります。

Python はこの一貫性規則を強制しません。 事実、非数値がこの規則に従わな
い例となります。


6.10.2. 帰属検査演算
--------------------

演算子 "in" および "not in" は、帰属 (membership) を調べます。 "x in
s" の評価は、 *x* が *s* の要素であれば "True" となり、そうでなければ
"False" となります。 "x not in s" は "x in s" の否定 (negation) を返し
ます。すべての組み込みのシーケンスと集合型に加えて、辞書も、 "in" を辞
書が与えられたキーを持っているかを調べるものとしてサポートしています。
リスト、タプル、集合、凍結集合、辞書、あるいは collection.deque のよう
なコンテナ型について、式 "x in y" は "any(x is e or x == e for e in
y)" と等価です。

文字列やバイト列型については、 "x in y" は *x* が *y* の部分文字列であ
るとき、かつそのときに限り "True" になります。これは "y.find(x) != -1"
と等価です。空文字列は、他の任意の文字列の部分文字列とみなされます。従
って """ in "abc"" は "True" を返すことになります。

"__contains__()" メソッドを実装したユーザ定義クラスでは、
"y.__contains__(x)" の返り値が真となる場合に "x in y" の返り値は
"True" となり、そうでない場合は "False" となります。

"__contains__()" を定義していないが "__iter__()" は定義しているユーザ
定義クラスでは、 "x in y" は "x == z" となるようなある値 *z* が "y" 内
にわたる反復で生成された場合、 "True" となります。もし、反復の間に例外
が発生すれば、 "in" が例外を発生させたようにみえます。

最終的には、旧スタイルの反復プロトコルの実行を試みます: もしクラスが
"__getitem__()" を定義しているならば、 "x in y" は "x == y[i]" となる
ような非負整数のインデックス *i* が存在するとき、かつそのときにかぎり
"True" となります。インデックス *i* が負である場合に "IndexError" 例外
が送出されることはありません。 (他の何らかの例外が送出された場合、例外
は "in" から送出されたかのようになります)。

演算子 "not in" は "in" の真値を反転した値として定義されています。


6.10.3. 同一性の比較
--------------------

演算子 "is" および "is not" は、オブジェクトの同一性に対するテストを行
います: "x is y" は、 *x* と *y* が同じオブジェクトを指すとき、かつそ
のときに限り真になります。 オブジェクトの同一性は "id()" 関数を使って
判定されます。 "x is not y" は "is" の真値を反転したものになります。
[4]


6.11. ブール演算 (boolean operation)
====================================

   or_test  ::= and_test | or_test "or" and_test
   and_test ::= not_test | and_test "and" not_test
   not_test ::= comparison | "not" not_test

ブール演算のコンテキストや、式が制御フロー文中で使われる際には、以下の
値: "False" 、 "None" すべての型における数値の 0、空の文字列、空のコン
テナ (文字列、タプル、リスト、辞書、集合、凍結集合など) は偽 (false)
であると解釈されます。それ以外の値は真 (true) であると解釈されます。ユ
ーザ定義のメソッドは、 "__bool__()" メソッドを与えることで、真理値をカ
スタマイズできます。

演算子 "not" は、引数が偽である場合には "True" を、それ以外の場合には
"False" になります。

式 "x and y" は、まず *x* を評価します; *x* が偽なら *x* の値を返しま
す; それ以外の場合には、 *y* の値を評価し、その結果を返します。

式 "x or y" は、まず *x* を評価します; *x* が真なら *x* の値を返します
; それ以外の場合には、 *y* の値を評価し、その結果を返します。

なお、 "and" も "or" も、返す値を "True" や "False" に制限せず、最後に
評価した引数を返します。 この仕様が便利なときもあります。例えば "s" が
文字列で、空文字列ならデフォルトの値に置き換えたいとき、式 "s or
'foo'" は望んだ値を与えます。 "not" は必ず新しい値を作成するので、引数
の型に関係なくブール値を返します (例えば、 "not 'foo'" は "''" ではな
く "False" になります)。


6.12. 条件式 (Conditional Expressions)
======================================

   conditional_expression ::= or_test ["if" or_test "else" expression]
   expression             ::= conditional_expression | lambda_expr
   expression_nocond      ::= or_test | lambda_expr_nocond

条件式 (しばしば "三項演算子" と呼ばれます) は最も優先度が低いPython
の演算です。

"x if C else y" という式は最初に条件 *x* ではなく *C* を評価します;
*C* が true の場合 *x* が評価され値が返されます; それ以外の場合には
*y* が評価され返されます。

条件演算に関してより詳しくは **PEP 308** を参照してください。


6.13. ラムダ (lambda)
=====================

   lambda_expr        ::= "lambda" [parameter_list] ":" expression
   lambda_expr_nocond ::= "lambda" [parameter_list] ":" expression_nocond

ラムダ式 (ラムダ形式とも呼ばれます) は無名関数を作成するのに使います。
式 "lambda parameters: expression" は関数オブジェクトになります。 この
無名オブジェクトは以下に定義されている関数オブジェクト同様に動作します
:

   def <lambda>(parameters):
       return expression

引数の一覧の構文は 関数定義 を参照してください。ラムダ式で作成された関
数は文やアノテーションを含むことができない点に注意してください。


6.14. 式のリスト
================

   expression_list    ::= expression ("," expression)* [","]
   starred_list       ::= starred_item ("," starred_item)* [","]
   starred_expression ::= expression | (starred_item ",")* [starred_item]
   starred_item       ::= expression | "*" or_expr

リスト表示や辞書表示の一部になっているものを除き、少なくとも一つのカン
マを含む式のリストはタプルになります。 タプルの長さは、リストにある式
の数に等しくなります。 式は左から右へ評価されます。

アスタリスク "*" は *イテラブルのアンパック* を意味します。 この被演算
子は *イテラブル* でなければなりません。 このイテラブルはアンパックさ
れた位置で要素のシーケンスに展開され、新しいタプル、リスト、集合に入れ
込まれます。

バージョン 3.5 で追加: 式リストでのイテラブルのアンパックは最初に
**PEP 448** で提案されました。

単一要素のタプル (別名 *単集合 (singleton)* ) を作りたければ、末尾にカ
ンマが必要です。単一の式だけで、末尾にカンマをつけない場合には、タプル
ではなくその式の値になります (空のタプルを作りたいなら、中身が空の丸括
弧ペア: "()" を使います。)


6.15. 評価順序
==============

Python は、式を左から右へと順に評価します。 ただし、代入式を評価すると
きは、右辺が左辺よりも先に評価されます。

以下に示す実行文の各行での評価順序は、添え字の数字順序と同じになります
:

   expr1, expr2, expr3, expr4
   (expr1, expr2, expr3, expr4)
   {expr1: expr2, expr3: expr4}
   expr1 + expr2 * (expr3 - expr4)
   expr1(expr2, expr3, *expr4, **expr5)
   expr3, expr4 = expr1, expr2


6.16. 演算子の優先順位
======================

以下の表は Python における演算子の優先順位を要約したものです。優先順位
の最も低い (結合が最も弱い) ものから最も高い (結合が最も強い) ものに並
べてあります。同じボックス内の演算子の優先順位は同じです。構文が明示的
に示されていないものは二項演算子です。同じボックス内の演算子は、左から
右へとグループ化されます (例外として、べき乗は右から左にグループ化され
ます)。

比較 節で述べられているように、比較、帰属、同一性のテストは全てが同じ
優先順位を持っていて、左から右に連鎖するという特徴を持っていることに注
意してください。

+-------------------------------------------------+---------------------------------------+
| 演算子                                          | 説明                                  |
|=================================================|=======================================|
| "lambda"                                        | ラムダ式                              |
+-------------------------------------------------+---------------------------------------+
| "if" -- "else"                                  | 条件式                                |
+-------------------------------------------------+---------------------------------------+
| "or"                                            | ブール演算 OR                         |
+-------------------------------------------------+---------------------------------------+
| "and"                                           | ブール演算 AND                        |
+-------------------------------------------------+---------------------------------------+
| "not" "x"                                       | ブール演算 NOT                        |
+-------------------------------------------------+---------------------------------------+
| "in", "not in", "is", "is not", "<", "<=", ">", | 帰属や同一性のテストを含む比較        |
| ">=", "!=", "=="                                |                                       |
+-------------------------------------------------+---------------------------------------+
| "|"                                             | ビット単位 OR                         |
+-------------------------------------------------+---------------------------------------+
| "^"                                             | ビット単位 XOR                        |
+-------------------------------------------------+---------------------------------------+
| "&"                                             | ビット単位 AND                        |
+-------------------------------------------------+---------------------------------------+
| "<<", ">>"                                      | シフト演算                            |
+-------------------------------------------------+---------------------------------------+
| "+", "-"                                        | 加算および減算                        |
+-------------------------------------------------+---------------------------------------+
| "*", "@", "/", "//", "%"                        | 乗算、行列乗算、除算、切り捨て除算、  |
|                                                 | 剰余 [5]                              |
+-------------------------------------------------+---------------------------------------+
| "+x", "-x", "~x"                                | 正数、負数、ビット単位 NOT            |
+-------------------------------------------------+---------------------------------------+
| "**"                                            | べき乗 [6]                            |
+-------------------------------------------------+---------------------------------------+
| "await" "x"                                     | Await 式                              |
+-------------------------------------------------+---------------------------------------+
| "x[index]", "x[index:index]",                   | 添字指定、スライス操作、呼び出し、属  |
| "x(arguments...)", "x.attribute"                | 性参照                                |
+-------------------------------------------------+---------------------------------------+
| "(expressions...)", "[expressions...]", "{key:  | 式結合またはタプル表示、リスト表示、  |
| value...}", "{expressions...}"                  | 辞書表示、集合表示                    |
+-------------------------------------------------+---------------------------------------+

-[ 脚注 ]-

[1] "abs(x%y) < abs(y)" は数学的には真となりますが、浮動小数点に対する
    演算の場合には、値丸め (roundoff) のために数値計算的に真にならない
    場合があります。例えば、Python の浮動小数点型が IEEE754 倍精度数型
    になっているプラットフォームを仮定すると、 "-1e-100 % 1e100" は
    "1e100" と同じ符号になるはずなのに、計算結果は "-1e-100 + 1e100"
    となります。これは数値計算的には厳密に "1e100" と等価です。関数
    "math.fmod()" は、最初の引数と符号が一致するような値を返すので、上
    記の場合には "-1e-100" を返します。どちらのアプローチが適切かは、
    アプリケーションに依存します。

[2] x が y の正確な整数倍に非常に近いと、丸めのために "x//y" が
    "(x-x%y)//y" よりも 1 だけ大きくなる可能性があります。そのような場
    合、Python は "divmod(x,y)[0] * y + x % y" が "x" に非常に近くなる
    という関係を保つために、後者の値を返します。

[3] Unicode 標準では、 *コードポイント (code point)* (例えば、U+0041)
    と *抽象文字 (abstract character)* (例えば、"LATIN CAPITAL LETTER
    A") を区別します。 Unicode のほとんどの抽象文字は 1 つのコードポイ
    ントだけを使って表現されますが、複数のコードポイントの列を使っても
    表現できる抽象文字もたくさんあります。 例えば、抽象文字 "LATIN
    CAPITAL LETTER C WITH CEDILLA" はコード位置 U+00C7 にある *合成済
    み文字 (precomposed character)* 1 つだけでも表現できますし、コード
    位置 U+0043 (LATIN CAPITAL LETTER C) にある *基底文字 (base
    character)* の後ろに、コード位置 U+0327 (COMBINING CEDILLA) にある
    *結合文字 (combining character)* が続く列としても表現できます。

    文字列の比較操作は Unicode のコードポイントのレベルで行われます。
    これは人間にとっては直感的ではないかもしれません。 例えば、
    ""\u00C7" == "\u0043\u0327"" は、どちらの文字も同じ抽象文字 "LATIN
    CAPITAL LETTER C WITH CEDILLA" を表現しているにもかかわらず、その
    結果は "False" となります。

    抽象文字のレベルで (つまり、人間にとって直感的な方法で) 文字列を比
    較するには "unicodedata.normalize()" を使ってください。

[4] 自動的なガベージコレクション、フリーリスト、ディスクリプタの動的特
    性のために、インスタンスメソッドや定数の比較を行うようなときに
    "is" 演算子の利用は、一見すると普通ではない振る舞いだと気付くかも
    しれません。詳細はそれぞれのドキュメントを確認してください。

[5] "%" 演算子は文字列フォーマットにも使われ、同じ優先順位が当てはまり
    ます。

[6] べき乗演算子 "**" はその右側にある単項演算子かビット単位演算子より
    も優先して結合します。つまり "2**-1" は "0.5" になります。
