6. 式 (expression)

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

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

name ::= othername

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

6.1. 算術変換 (arithmetic conversion)

When a description of an arithmetic operator below uses the phrase "the numeric arguments are converted to a common type", this means that the operator implementation for built-in types works as follows:

  • If either argument is a complex number, the other is converted to complex;

  • otherwise, if either argument is a floating-point number, the other is converted to floating point;

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

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

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 例外を送出します。

6.2.1.1. プライベート名のマングリング

クラス定義のテキスト内に現れる識別子が、2 個以上のアンダースコアで始まり、2 個以上のアンダースコアで終わらない場合、そのクラスの プライベート名 とみなされます。

参考

クラスの仕様。

より正確には、プライベート名はコードを生成する前に、より長い形式に変換されます。 変換後の名前が 255 文字を超える場合は、実装で定めた方法で切り詰められることがあります。

変換は識別子を使う構文上の文脈によらず行われますが、マングリングの対象は次のプライベートな識別子だけです。

  • 代入または読み取りを行う変数の名前と、アクセスする属性の名前。

    ただし、入れ子の関数、クラス、型エイリアスの __name__ 属性はマングリングされません。

  • import __spam の __spam など、インポートするモジュールの名前。 モジュールがパッケージの一部である場合 (名前にドットを含む場合) はマングリング されません。 例えば import __foo.bar の __foo はマングリングされません。

  • from spam import __f の __f など、インポートするメンバの名前。

変換規則は次のとおりです。

  • クラス名から先頭のアンダースコアを取り除き、先頭にアンダースコアを 1 個付けたものを、識別子の前に挿入します。 例えば Foo、_Foo、__Foo という名前のクラス内の識別子 __spam は、_Foo__spam に変換されます。

  • クラス名がアンダースコアだけからなる場合、変換しても名前は変わりません。 例えば _ や __ という名前のクラス内の識別子 __spam はそのままです。

6.2.2. リテラル

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

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

Evaluation of a literal yields an object of the given type (string, bytes, integer, floating-point number, complex number) with the given value. The value may be approximated in the case of floating-point and imaginary (complex) literals. See section リテラル for details.

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

6.2.3. 丸括弧形式 (parenthesized form)

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

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

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

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

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

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

リスト、集合、辞書を構築するために、 Python は "表示 (display)" と呼ばれる特別な構文を提供していて、次の二種類ずつがあります:

  • コンテナの内容を明示的に列挙する

  • 内包表記 (comprehension) と呼ばれる、ループ処理とフィルター処理の組み合わせを用いた計算結果

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

comprehension ::= assignment_expression comp_for
comp_for      ::= ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::= comp_for | comp_if
comp_if       ::= "if" or_test [comp_iter]

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

ただし、最も左にある for 節のイテラブル式を除いて、内包表記は暗黙的にネストされた個別のスコープで実行されます。 この仕組みのおかげで、対象のリスト内で代入された名前が外側のスコープに "漏れる" ことはありません。

最も左にある for 節のイテラブル式は、それを直接囲んでいるスコープでそのまま評価され、暗黙的な入れ子のスコープに引数として渡されます。 後に続く for 節と、最も左にある for 節のフィルター条件はイテラブル式を直接囲んでいるスコープでは評価できません。というのは、それらは最も左のイテラブルから得られる値に依存しているかもしれないからです。 例えば次の通りです: [x*y for x in range(10) for y in range(x, x+10)] 。

内包表記が常に適切な型のコンテナになるのを保証するために、 yield 式や yield from 式は暗黙的な入れ子のスコープでは禁止されています。

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 async for clauses, or if it contains await expressions or other asynchronous comprehensions anywhere except the iterable expression in the leftmost for clause, 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.

Added in version 3.6: 非同期内包表記が導入されました。

バージョン 3.8 で変更: yield および yield from は暗黙的な入れ子のスコープでは禁止となりました。

バージョン 3.11 で変更: 非同期関数の内包表記の中でも、非同期内包表記を使えるようになりました。 外側の内包表記も暗黙的に非同期になります。

6.2.5. リスト表示

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

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

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

6.2.6. 集合表示

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

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

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

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

6.2.7. 辞書表示

A dictionary display is a possibly empty series of dict items (key/value pairs) enclosed in curly braces:

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

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

If a comma-separated sequence of dict items is given, they are evaluated from left to right to define the entries of the dictionary: each key object is used as a key into the dictionary to store the corresponding value. This means that you can specify the same key multiple times in the dict item list, and the final dictionary's value for that key will be the last one given.

A double asterisk ** denotes dictionary unpacking. Its operand must be a mapping. Each mapping item is added to the new dictionary. Later values replace values already set by earlier dict items and earlier dictionary unpackings.

Added in version 3.5: 辞書表示のアンパックは最初に PEP 448 で提案されました。

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

Restrictions on the types of the key values are listed earlier in section 標準型の階層. (To summarize, the key type should be hashable, which excludes all mutable objects.) Clashes between duplicate keys are not detected; the last value (textually rightmost in the display) stored for a given key value prevails.

バージョン 3.8 で変更: Python 3.8 より前のバージョンでは、辞書内包表記において、キーと値の評価順序は明示されていませんでした。CPython では、値がキーより先に評価されていました。バージョン 3.8 からは PEP 572 で提案されているように、キーが値より先に評価されます。

6.2.8. ジェネレータ式

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

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

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

Variables used in the generator expression are evaluated lazily when the __next__() method is called for the generator object (in the same fashion as normal generators). However, the iterable expression in the leftmost for clause is immediately evaluated, and the iterator is immediately created for that iterable, so that an error produced while creating the iterator will be emitted at the point where the generator expression is defined, rather than at the point where the first value is retrieved. Subsequent for clauses and any filter condition in the leftmost for clause cannot be evaluated in the enclosing scope as they may depend on the values obtained from the leftmost iterable. For example: (x*y for x in range(10) for y in range(x, x+10)).

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

ジェネレータ式自身の期待される動作を妨げないために、 yield 式や yield from 式は暗黙的に定義されたジェネレータでは禁止されています。

ジェネレータ式が async for 節あるいは await 式を含んでいる場合、それは 非同期ジェネレータ式 と呼ばれます。 非同期ジェネレータ式は、非同期イテレータである新しい非同期ジェネレータオブジェクトを返します (非同期イテレータ (Asynchronous Iterator) を参照してください)。

Added in version 3.6: 非同期ジェネレータ式が導入されました。

バージョン 3.7 で変更: Python 3.7 より前では、非同期ジェネレータ式は async def コルーチンでしか使えませんでした。 3.7 からは、任意の関数で非同期ジェネレータ式が使えるようになりました。

バージョン 3.8 で変更: yield および yield from は暗黙的な入れ子のスコープでは禁止となりました。

6.2.9. Yield 式

yield_atom       ::= "(" yield_expression ")"
yield_from       ::= "yield" "from" expression
yield_expression ::= "yield" yield_list | yield_from

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

def gen():  # ジェネレータ関数を定義
    yield 123

async def agen(): # 非同期ジェネレータ関数を定義
    yield 123

内包表記やジェネレータ式を実装するために暗黙的に定義されるスコープ内では、yield 式を使えません。 これは、それを含むスコープに副作用を及ぼすためです。

バージョン 3.8 で変更: yield 式は、暗黙的な入れ子のスコープで内包表記やジェネレータ式を実装するための使用が禁止になりました。

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

ジェネレータ関数を呼び出すと、ジェネレータと呼ばれるイテレータを返します。 このジェネレータが、その後のジェネレータ関数の実行を制御します。 ジェネレータのメソッドのいずれかを呼ぶと実行が始まり、最初の yield 式まで進んで再び一時停止します。 このとき yield_list の値をジェネレータの呼び出し元に返します。 yield_list が省略されていれば None を返します。 一時停止とは、ローカル変数の現在の束縛、命令ポインタ、内部の評価スタック、例外処理の状態を含む、すべてのローカルな状態を保持することを意味します。 ジェネレータのメソッドを呼んで実行を再開すると、yield 式が通常の外部呼び出しであったかのように関数を続行できます。 再開後の yield 式の値は、実行を再開させたメソッドによって決まります。 __next__() を使った場合 (通常は for や組み込み関数 next() を通じて使います) は None になります。 send() を使った場合は、そのメソッドに渡した値になります。

このように、ジェネレータ関数はコルーチンとよく似ています。 何度も yield し、複数のエントリポイントを持ち、実行を一時停止できます。 唯一の違いは、ジェネレータ関数は 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 342 - 拡張されたジェネレータを用いたコルーチン

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

PEP 380 - サブジェネレータへの委譲構文

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

PEP 525 - 非同期ジェネレータ

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

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

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

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

generator.__next__()

Starts the execution of a generator function or resumes it at the last executed yield expression. When a generator function is resumed with a __next__() method, the current yield expression always evaluates to None. The execution then continues to the next yield expression, where the generator is suspended again, and the value of the yield_list is returned to __next__()'s caller. If the generator exits without yielding another value, a StopIteration exception is raised.

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

generator.send(value)

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

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

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

In typical use, this is called with a single exception instance similar to the way the raise keyword is used.

ただし、後方互換性のため、以前のバージョンの Python の慣例に従った2番目のシグネチャもサポートされています。 type 引数には例外クラスを、value には例外インスタンスを指定してください。 value を指定しない場合は、type のコンストラクタを呼び出してインスタンスを取得します。 traceback を指定した場合は例外に設定されます。 指定しない場合は、value に格納されている既存の __traceback__ 属性がクリアされることがあります。

バージョン 3.12 で変更: 2番目のシグネチャ (type[, value[, traceback]]) は非推奨となり、将来のバージョンの Python で削除される可能性があります。

generator.close()

Raises a GeneratorExit exception at the point where the generator function was paused (equivalent to calling throw(GeneratorExit)). The exception is raised by the yield expression where the generator was paused. If the generator function catches the exception and returns a value, this value is returned from close(). If the generator function is already closed, or raises GeneratorExit (by not catching the exception), close() returns None. If the generator yields a value, a RuntimeError is raised. If the generator raises any other exception, it is propagated to the caller. If the generator has already exited due to an exception or normal exit, close() returns None and has no other effect.

バージョン 3.13 で変更: If a generator returns a value upon being closed, the value is returned by 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 文で使われる様子に類似します。

非同期ジェネレータのメソッドのいずれかを呼ぶと awaitable オブジェクトを返し、このオブジェクトを await すると実行が始まります。 最初の yield 式まで進んで再び一時停止し、yield_list の値を、await しているコルーチンに返します。 ジェネレータと同様、一時停止中はローカル変数の現在の束縛、命令ポインタ、内部の評価スタック、例外処理の状態を含む、すべてのローカルな状態を保持します。 非同期ジェネレータのメソッドが次に返すオブジェクトを await して実行を再開すると、yield 式が通常の外部呼び出しであったかのように関数を続行できます。 再開後の yield 式の値は、実行を再開させたメソッドによって決まります。 __anext__() を使った場合は None になります。 asend() を使った場合は、そのメソッドに渡した値になります。

break、呼び出し元のタスクのキャンセル、その他の例外によって非同期ジェネレータの処理を途中で終了すると、 ジェネレータの非同期の後始末コードが予期しない文脈で実行され、例外を送出したりコンテキスト変数にアクセスしたりする場合があります。 例えば、依存するタスクの存続期間が終わった後や、イベントループの終了時に非同期ジェネレータのガベージコレクションフックが呼ばれたときに実行される可能性があります。 これを防ぐため、呼び出し元は aclose() メソッドで非同期ジェネレータを明示的に閉じ、終了処理を行って、最終的にイベントループから切り離す必要があります。

非同期ジェネレータ関数では、try 構造内のどこでも yield 式を使えます。 ただし、非同期ジェネレータが再開されないまま終了処理を迎えた場合 (参照カウントが 0 に達した場合やガベージコレクションされた場合)、 try 構造内の yield 式による一時停止のため、実行待ちの finally 節が実行されない可能性があります。 この場合、非同期ジェネレータを実行するイベントループやスケジューラが、 非同期ジェネレータイテレータの aclose() メソッドを呼び、返されたコルーチンオブジェクトを実行して、実行待ちの finally 節が実行されるようにする責任を持ちます。

To take care of finalization upon event loop termination, 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. 非同期ジェネレータイテレータメソッド

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

async 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 an __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 yield_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 a StopAsyncIteration exception, signalling that the asynchronous iteration has completed.

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

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

async agen.athrow(value)
async 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, a 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.

バージョン 3.12 で変更: 2番目のシグネチャ (type[, value[, traceback]]) は非推奨となり、将来のバージョンの Python で削除される可能性があります。

async 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

プライマリの評価結果は、属性参照をサポートする型のオブジェクトでなければなりません。 ほとんどのオブジェクトはこれをサポートします。 次に、このオブジェクトに対して、識別子を名前とする属性を取得するよう求めます。 得られる型と値はオブジェクトによって決まります。 同じ属性参照を複数回評価しても、別のオブジェクトが得られる場合があります。

この取得動作は、__getattribute__() メソッドや __getattr__() メソッドをオーバーライドしてカスタマイズできます。 最初に __getattribute__() メソッドが呼ばれ、値を返すか、属性がなければ AttributeError を送出します。

AttributeError が送出され、そのオブジェクトが __getattr__() メソッドを持っていれば、代わりにそのメソッドが呼ばれます。

6.3.2. 添字表記 (subscription)

The subscription of an instance of a container class will generally select an element from the container. The subscription of a generic class will generally return a GenericAlias object.

subscription ::= primary "[" flexible_expression_list "]"

When an object is subscripted, the interpreter will evaluate the primary and the expression list.

The primary must evaluate to an object that supports subscription. An object may support subscription through defining one or both of __getitem__() and __class_getitem__(). When the primary is subscripted, the evaluated result of the expression list will be passed to one of these methods. For more details on when __class_getitem__ is called instead of __getitem__, see __class_getitem__ と __getitem__ の違い.

If the expression list contains at least one comma, or if any of the expressions are starred, the expression list will evaluate to a tuple containing the items of the expression list. Otherwise, the expression list will evaluate to the value of the list's sole member.

バージョン 3.11 で変更: Expressions in an expression list may be starred. See PEP 646.

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

  1. マッピング。プライマリが マッピング であれば、式リストの値評価結果はマップ内のいずれかのキー値に相当するオブジェクトにならなければなりません。添字表記は、そのキーに対応するマッピング内の値 (value) を選択します。組み込みのマッピングクラスの例は dict クラスです。

  2. シーケンス。プライマリが シーケンス であれば、式リストの評価結果は int または slice (以下の節で論じます) でなければなりません。組み込みのシーケンスクラスの例には str、list、tuple クラスが含まれます。

The formal syntax makes no special provision for negative indices in sequences. However, built-in sequences all provide a __getitem__() method that interprets negative indices by adding the length of the sequence to the index so that, for example, x[-1] selects the last item of x. The resulting value must be a nonnegative integer less than the number of items in the sequence, and the subscription selects the item whose index is that value (counting from zero). Since the support for negative indices and slicing occurs in the object's __getitem__() method, subclasses overriding this method will need to explicitly add that support.

文字列 は文字 (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

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

The semantics for a slicing are as follows. The primary is indexed (using the same __getitem__() method as normal subscription) with a key that is constructed from the slice list, as follows. If the slice list contains at least one comma, the key is a tuple containing the conversion of the slice items; otherwise, the conversion of the lone slice item is the key. The conversion of a slice item that is an expression is that expression. The conversion of a proper slice is a slice object (see section 標準型の階層) whose start, stop and step attributes are the values of the expressions given as lower bound, upper bound and stride, respectively, substituting None for missing expressions.

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 ::= positional_item ("," positional_item)*
positional_item      ::= assignment_expression | "*" expression
starred_and_keywords ::= ("*" expression | keyword_item)
                         ("," "*" expression | "," keyword_item)*
keywords_arguments   ::= (keyword_item | "**" expression)
                         ("," keyword_item | "," "**" expression)*
keyword_item         ::= identifier "=" expression

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

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

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

実装によっては、位置引数の仮引数に名前がない組み込み関数を提供する場合があります。 ドキュメントのために「名前を付けて」いても、キーワードでは指定できません。 CPython では、引数の解析に PyArg_ParseTuple() を使う C 実装の関数がこれに当たります。

仮引数スロットの数よりも多くの位置引数がある場合、構文 *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 例外が送出されます。

**expression を使う場合、マッピングのキーはすべて文字列でなければなりません。 各値は、キーワードで値を指定でき、名前がキーと等しい最初の仮引数に代入されます。 キーが Python の識別子である必要はありません (例えば "max-temp °F" も使えますが、宣言可能な仮引数とは一致しません)。 一致する仮引数がなければ、** の仮引数がある場合はそこにキーと値のペアが集められ、ない場合は TypeError 例外を送出します。

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

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

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

各形態では---

ユーザ定義関数:

引数リストを渡して、関数のコードブロックを実行します。 コードブロックは最初に、渡された引数を仮引数に束縛します。 この処理は 関数定義 で説明しています。 コードブロック内で return 文を実行すると、それが関数呼び出しの戻り値を指定します。 return 文を実行せずにコードブロックの末尾に達した場合、戻り値は None です。

組み込み関数またはメソッド:

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

クラスオブジェクト:

そのクラスの新しいインスタンスが返されます。

クラスインスタンスメソッド:

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

クラスインスタンス:

クラスは __call__() メソッドを定義していなければなりません。 そのメソッドを呼び出したのと同じ動作になります。

6.4. Await 式

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

await_expr ::= "await" primary

Added in version 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 を送出していました)

この演算は、特殊メソッド __pow__() と __rpow__() でカスタマイズできます。

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

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

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

単項の - (マイナス) 演算子は、数値の引数の符号を反転した値を返します。 この演算は特殊メソッド __neg__() でオーバーライドできます。

単項の + (プラス) 演算子は、数値の引数をそのまま返します。 この演算は特殊メソッド __pos__() でオーバーライドできます。

単項の ~ (反転) 演算子は、整数の引数をビット単位で反転した値を返します。 x のビット単位の反転は -(x+1) と定義されます。 整数、または特殊メソッド __invert__() をオーバーライドした独自のオブジェクトだけに適用できます。

上記の三つはいずれも、引数が正しい型でない場合には 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

The * (multiplication) operator yields the product of its arguments. The arguments must either both be numbers, or one argument must be an integer and the other must be a sequence. In the former case, the numbers are converted to a common type and then multiplied together. In the latter case, sequence repetition is performed; a negative repetition factor yields an empty sequence.

この演算は、特殊メソッド __mul__() と __rmul__() でカスタマイズできます。

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

この演算は、特殊メソッド __matmul__() と __rmatmul__() でカスタマイズできます。

Added in version 3.5.

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

除算は特殊メソッド __truediv__() と __rtruediv__() でカスタマイズできます。 切り捨て除算は特殊メソッド __floordiv__() と __rfloordiv__() でカスタマイズできます。

The % (modulo) operator yields the remainder from the division of the first argument by the second. The numeric arguments are first converted to a common type. A zero right argument raises the ZeroDivisionError exception. The arguments may be floating-point numbers, e.g., 3.14%0.7 equals 0.34 (since 3.14 equals 4*0.7 + 0.34.) The modulo operator always yields a result with the same sign as its second operand (or zero); the absolute value of the result is strictly smaller than the absolute value of the second operand [1].

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

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

剰余 演算は、特殊メソッド __mod__() と __rmod__() でカスタマイズできます。

複素数には、切り捨て除算演算子、剰余演算子、divmod() 関数は定義されていません。 適切であれば、代わりに abs() 関数で浮動小数点数に変換してください。

The + (addition) operator yields the sum of its arguments. The arguments must either both be numbers or both be sequences of the same type. In the former case, the numbers are converted to a common type and then added together. In the latter case, the sequences are concatenated.

この演算は、特殊メソッド __add__() と __radd__() でカスタマイズできます。

The - (subtraction) operator yields the difference of its arguments. The numeric arguments are first converted to a common type.

この演算は、特殊メソッド __sub__() と __rsub__() でカスタマイズできます。

6.8. シフト演算 (shifting operation)

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

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

これらの演算子は整数を引数に取ります。 第 1 引数を、第 2 引数で指定したビット数だけ左または右にシフトします。

左シフト演算は特殊メソッド __lshift__() と __rlshift__() でカスタマイズできます。 右シフト演算は特殊メソッド __rshift__() と __rrshift__() でカスタマイズできます。

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

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 を返します。 引数は整数であるか、少なくとも一方が特殊メソッド __and__() または __rand__() をオーバーライドした独自のオブジェクトでなければなりません。

^ 演算子は、引数のビット単位の XOR (排他的 OR) を返します。 引数は整数であるか、少なくとも一方が特殊メソッド __xor__() または __rxor__() をオーバーライドした独自のオブジェクトでなければなりません。

| 演算子は、引数のビット単位の (包含的) OR を返します。 引数は整数であるか、少なくとも一方が特殊メソッド __or__() または __ror__() をオーバーライドした独自のオブジェクトでなければなりません。

6.10. 比較

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

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

比較はブール値 True または False を返します。 独自の 拡張比較メソッド は、ブール値以外を返す場合があります。 この場合、真偽値が必要な文脈では、Python はその値に bool() を呼び出します。

比較はいくらでも連鎖することができます。例えば 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 からデフォルトの比較動作を継承します。 型は 基本的なカスタマイズ で説明する __lt__() などの 拡張比較メソッド を実装して、比較動作をカスタマイズできます。

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

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

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

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

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

    非数値である float('NaN') と decimal.Decimal('NaN') は特別です。 数と非数値との任意の順序比較は偽です。 直観に反する帰結として、非数値は自分自身と等価ではないことになります。 例えば x = float('NaN') ならば、 3 < x, x < 3, x == x は全て偽で、x != x は真です。 この振る舞いは IEEE 754 に従ったものです。

  • None と NotImplemented はシングルトンです。 PEP 8 は、シングルトンの比較には等価演算子を使わず、常に is または is not を使うことを推奨しています。

  • バイナリシーケンス (bytes または bytearray のインスタンス) は、これらの型の範囲で異なる型とも比較できます。 比較は要素の数としての値を使った辞書式順序で行われます。

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

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

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

    シーケンスは、対応する要素を比較して辞書式に比較します。 組み込みコンテナは通常、同一のオブジェクトはそれ自身と等しいとみなします。 これにより、同一のオブジェクトに対する等価性の検査を省いて性能を高め、内部の不変条件を保てます。

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

    • 比較の結果が等価となる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 (全順序の場合)

    The last two expressions apply to totally ordered collections (e.g. to sequences, but not to sets or mappings). See also the @~functools.total_ordering decorator.

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

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

6.10.2. 所属検査演算

演算子 in および not in は所属関係を調べます。 x in s の評価は、 x が s の要素であれば True となり、そうでなければ False となります。 x not in s は x in s の否定を返します。 すべての組み込みのシーケンス型と集合型に加えて、辞書も in を辞書が与えられたキーを持っているかを調べる演算子としてサポートしています。 リスト、タプル、集合、凍結集合、辞書、 collections.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__() を定義したユーザー定義クラスでは、 y をイテレートしたときに x is z or x == z が真になる値 z が得られれば、x in y は True です。 イテレート中に例外が送出された場合は、in がその例外を送出したのと同じになります。

最後に、旧式のイテレーションプロトコルを試します。 クラスが __getitem__() を定義している場合、 x is y[i] or x == y[i] となる非負整数のインデックス i があり、それより小さいインデックスで IndexError 例外が送出されなければ、そのときに限り x in y は True です。 (その他の例外が送出された場合は、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、空の文字列とコンテナ (文字列、タプル、リスト、辞書、集合、凍結集合を含む) は偽と解釈されます。 その他の値はすべて真と解釈されます。 ユーザー定義オブジェクトは __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. 代入式

assignment_expression ::= [identifier ":="] expression

代入式 (「名前付き式」や「セイウチ」とも呼ばれます) は、expression を identifier に代入すると同時に、その expression の値を返します。

よくある用途の 1 つは、正規表現にマッチした結果の処理です。

if matching := pattern.search(data):
    do_something(matching)

ファイルストリームを一定量ずつ処理する場合にも使えます。

while chunk := file.read(9000):
    process(chunk)

代入式を式文として使う場合や、スライス、条件式、ラムダ式、キーワード引数、内包表記の if 条件の部分式として使う場合、 また assert 文、with 文、代入文の中で使う場合は、丸括弧で囲む必要があります。 使用できるその他の場所では、if 文や while 文を含め、丸括弧は不要です。

Added in version 3.8: 代入式に関してより詳しくは PEP 572 を参照してください。

6.13. 条件式 (Conditional Expressions)

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

A conditional expression (sometimes called a "ternary operator") is an alternative to the if-else statement. As it is an expression, it returns a value and can appear as a sub-expression.

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

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

6.14. ラムダ (lambda)

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

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

def <lambda>(parameters):
    return expression

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

6.15. 式のリスト

starred_expression       ::= ["*"] or_expr
flexible_expression      ::= assignment_expression | starred_expression
flexible_expression_list ::= flexible_expression ("," flexible_expression)* [","]
starred_expression_list  ::= starred_expression ("," starred_expression)* [","]
expression_list          ::= expression ("," expression)* [","]
yield_list               ::= expression_list | starred_expression "," [starred_expression_list]

リスト表示や集合表示の一部である場合を除き、少なくとも 1 個のカンマを含む式リストはタプルになります。 タプルの長さは式リストに含まれる式の数です。 式は左から右へ評価されます。

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

Added in version 3.5: 式リストでのイテラブルのアンパックは最初に PEP 448 で提案されました。

Added in version 3.11: 式リストのどの項目にもアスタリスクを付けられるようになりました。 PEP 646 を参照してください。

末尾のカンマが必須なのは、1, のような要素が 1 個のタプルを作る場合だけです。 その他の場合は省略できます。 1 個の式に末尾のカンマを付けなければ、タプルではなく、その式の値になります。 (空のタプルを作るには、空の丸括弧の組 () を使います。)

6.16. 評価順序

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.17. 演算子の優先順位

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

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

演算子

説明

(expressions...),

[expressions...], {key: value...}, {expressions...}

結合式または括弧式、リスト表示、辞書表示、集合表示

x[index], x[index:index], x(arguments...), x.attribute

添字指定、スライス操作、呼び出し、属性参照

await x

Await 式

**

べき乗 [5]

+x, -x, ~x

正数、負数、ビット単位 NOT

*, @, /, //, %

乗算、行列乗算、除算、切り捨て除算、剰余 [6]

+, -

加算および減算

<<, >>

シフト演算

&

ビット単位 AND

^

ビット単位 XOR

|

ビット単位 OR

in, not in, is, is not, <, <=, >, >=, !=, ==

所属や同一性のテストを含む比較

not x

ブール演算 NOT

and

ブール演算 AND

or

ブール演算 OR

if -- else

条件式

lambda

ラムダ式

:=

代入式

脚注