Python の演算子と式

Python の演算子は、何らかの計算タイプを指定する特殊な記号、記号の組み合わせ、またはキーワードです。オブジェクトと演算子を組み合わせて、 実際の計算を実行する式を構築できます。したがって、演算子は式の構成要素であり、データを操作するために使用できます。したがって、Python で演算子がどのように機能するかを理解することは、プログラマーにとって不可欠です。

このチュートリアルでは、Python が現在サポートしている演算子について学びます。また、これらの演算子を使用して式を作成する方法の基本も学習します。

このチュートリアルでは、次のことを行います。

• Python の算術演算子を理解し、それらを使用して算術式を構築します。
• Python の比較、ブール、アイデンティティ、およびメンバーシップ演算子を調べます。
• 比較演算子、ブール演算子、アイデンティティ演算子、およびメンバーシップ演算子を使用して式を作成します。
• Python のビット単位演算子とその使用方法について学びます。
• 連結演算子と繰り返し演算子を使用してシーケンスを結合および繰り返します。
• 拡張代入演算子とその仕組みを理解する

このチュートリアルを最大限に活用するには、変数、代入、組み込みデータ型など、Python プログラミングの概念を基本的に理解している必要があります。

演算子と式の入門

プログラミングにおける演算子は通常、特定の演算を実行できるようにする記号または記号の組み合わせです。この操作は 1 つ以上のオペランドに作用します。演算に単一のオペランドが含まれる場合、 演算子は単項になります。演算子に 2 つのオペランドが含まれる場合、 演算子は二項演算子になります。

たとえば、Python では、マイナス記号 (-) を単項演算子として使用して、負の数値を宣言できます。これを使用して 2 つの数値を減算することもできます。

>>> -273.15
-273.15

>>> 5 - 2
3

このコード スニペットでは、最初の例のマイナス記号 (-) は単項演算子で、数値 273.15 がオペランドです。 2 番目の例では、同じシンボルが二項演算子であり、数値 5 と 2 がその左オペランドと右オペランドです。

プログラミング言語には通常、構文の一部として演算子が組み込まれています。 Python を含む多くの言語では、独自の演算子を作成したり、既存の演算子の動作を変更したりすることもできます。これは、強力で高度な機能です。

実際には、演算子は、データの操作、数学的計算の実行、値の比較、ブール テストの実行、変数への値の割り当てなどを行うための簡単なショートカットを提供します。 Python では、扱う演算子の種類に応じて、演算子は記号、記号の組み合わせ、またはキーワードになります。

たとえば、減算演算子はすでに見たように、単一のマイナス記号 (-) で表されます。等価演算子は 2 つの等号 (==) です。つまり、次のような記号の組み合わせになります。

>>> 42 == 42
True

この例では、Python 等価演算子 (==) を使用して 2 つの数値を比較します。結果として、Python のブール値の 1 つである True が得られます。

ブール値について言えば、ブール演算子と式に関するセクションで説明するように、Python のブール演算子または論理演算子は記号ではなくキーワードです。そのため、他の多くのプログラミング言語で使用されている ||、&&、! などの奇妙な記号の代わりに、Python では or を使用します。 、および、およびnot。

奇妙な記号の代わりにキーワードを使用することは、Python がコードの可読性を重視し奨励しているという事実と一致する、非常に優れた設計上の決定です。

Python には演算子のいくつかのカテゴリまたはグループがあります。これらのカテゴリの簡単なリストは次のとおりです。

• 代入演算子
• 算術演算子
• 比較演算子
• ブール または論理演算子
• アイデンティティ演算子
• メンバーシップオペレーター
• 連結演算子と繰り返し演算子
• ビット単位演算子

これらすべてのタイプの演算子は、特定のタイプの計算とデータ処理タスクを処理します。このチュートリアルを通じて、これらのカテゴリについて詳しく学習します。ただし、より実践的な議論に入る前に、演算子の最も基本的な目的は式の一部であることを知っておく必要があります。オペレーター自体はあまり多くのことを行いません。

>>> -
  File "<input>", line 1
    -
    ^
SyntaxError: incomplete input

>>> ==
  File "<input>", line 1
    ==
    ^^
SyntaxError: incomplete input

>>> or
  File "<input>", line 1
    or
    ^^
SyntaxError: incomplete input

このコード スニペットからわかるように、必要なオペランドを指定せずに演算子を使用すると、構文エラーが発生します。したがって、演算子は式の一部である必要があり、Python オブジェクトをオペランドとして使用して構築できます。

それで、そもそも式とは何でしょうか？ Python には単純なステートメントと複合ステートメントがあります。単純なステートメントは、代入ステートメントと同様に、単一の論理行を占める構造です。複合ステートメントは、for ループや条件ステートメントなど、複数の論理行を占める構造です。 式は、値を生成して返す単純なステートメントです。

多くの式で演算子が見つかります。以下にいくつかの例を示します。

>>> 7 + 5
12

>>> 42 / 2
21.0

>>> 5 == 5
True

最初の 2 つの例では、加算演算子と除算演算子を使用して、オペランドが整数である 2 つの算術式を作成します。最後の例では、等価演算子を使用して比較式を作成します。いずれの場合も、式を実行すると特定の値が得られます。

すべての式が演算子を使用するわけではないことに注意してください。たとえば、裸の関数呼び出しは演算子を必要としない式です。

>>> abs(-7)
7

>>> pow(2, 8)
256

>>> print("Hello, World!")
Hello, World!

最初の例では、組み込みの abs() 関数を呼び出して、-7 の絶対値を取得します。次に、組み込みの pow() 関数を使用して、2 の 8 乗を計算します。これらの関数呼び出しは 1 つの論理行を占め、値を返します。つまり、それらは表現なのです。

最後に、組み込みの print() 関数の呼び出しは別の式です。今回、関数は有効な値を返しませんが、それでも Python の null 型である None を返します。したがって、呼び出しは技術的には式です。

すべての式はステートメントですが、すべてのステートメントが式であるわけではありません。たとえば、後で説明するように、純粋な代入ステートメントは値を返しません。したがって、それらは表現ではありません。代入演算子は、式ではなくステートメントを作成する特別な演算子です。

わかった！以上、Python の演算子と式についての簡単な紹介でした。今度は、このトピックをさらに深く掘り下げてみましょう。まず、代入演算子とステートメントから始めます。

代入演算子とステートメント

代入演算子は、Python で最も頻繁に使用される演算子の 1 つです。演算子は 1 つの等号 (=) で構成され、2 つのオペランドを操作します。通常、左側のオペランドは変数であり、右側のオペランドは式です。

代入演算子を使用すると変数に値を代入できます。厳密に言うと、Python では、この演算子は変数または名前がコンピューターのメモリ内の特定のオブジェクトを参照するようにします。言い換えれば、代入は具体的なオブジェクトへの参照を作成し、その参照をターゲット変数に添付します。

たとえば、以下のすべてのステートメントは、特定のオブジェクトへの参照を保持する新しい変数を作成します。

>>> number = 42
>>> day = "Friday"
>>> digits = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> letters = ["a", "b", "c"]

最初のステートメントでは、コンピュータのメモリ内の数値 42 への参照を保持する number 変数を作成します。名前 number は具体的なオブジェクトである 42 を指しているとも言えます。

残りの例では、それぞれ文字列、タプル、リストなどの他のタイプのオブジェクトを指す他の変数を作成します。

このチュートリアル全体で記述する例の多くで代入演算子を使用します。さらに重要なのは、この演算子を独自のコードで何度も使用することになります。それはあなたの永遠の友達になるでしょう。これで、他の Python 演算子に飛び込むことができます。

Python の算術演算子と式

算術演算子は、 数値に対して算術演算を実行できる演算子です。はい、これらは数学から来ており、ほとんどの場合、通常の数学記号で表します。次の表は、Python が現在サポートしている算術演算子のリストです。

オペレーター:

+

タイプ: 単項

動作: 肯定的

式の例:

	+a

結果: これは単なる否定の補数であるため、変換は行われません。

オペレーター:

+

タイプ: バイナリ

演算: 加算

式の例:

a + b

結果: a と b の算術合計

オペレーター:

-

タイプ: 単項

操作: 否定

式の例:

-a

結果: 符号が反対の a の値

オペレーター:

-

タイプ: バイナリ

演算: 減算

式の例:

a - b

結果: a から b を減算します。

オペレーター:

*

タイプ: バイナリ

演算: 乗算

式の例:

a * b

結果: a と b の積

オペレーター:

/

タイプ: バイナリ

オペレーション: 部門

式の例:

a / b

結果: a を b で割った商。浮動小数点として表現されます。

オペレーター:

%

タイプ: バイナリ

演算: モジュロ

式の例:

a % b

結果: a を b で割った余り

オペレーター:

//

タイプ: バイナリ

演算: フロア除算または整数除算

式の例:

a // b

結果: a を b で割った商を次に小さい整数に四捨五入したもの

オペレーター:

**

タイプ: バイナリ

演算: べき乗

式の例:

a**b

結果: a の b 乗

[サンプル式] 列の a と b は、整数、浮動小数点、複素数、有理数、10 進数などの数値を表すことに注意してください。 。

これらの演算子の使用例をいくつか示します。

>>> a = 5
>>> b = 2

>>> +a
5
>>> -b
-2
>>> a + b
7
>>> a - b
3
>>> a * b
10
>>> a / b
2.5
>>> a % b
1
>>> a // b
2
>>> a**b
25

このコード スニペットでは、最初に 2 つの新しい変数 a と b を作成し、それぞれ 5 と 2 を保持します。 。次に、これらの変数を使用して、各式で特定の演算子を使用するさまざまな算術式を作成します。

繰り返しますが、標準の除算演算子 (/) は、被除数が除数で割り切れる場合でも、常に浮動小数点数を返します。

>>> 10 / 5
2.0

>>> 10.0 / 5
2.0

最初の例では、10 は 5 で均等に割り切れます。したがって、この操作は整数 2 を返す可能性があります。ただし、浮動小数点数 2.0 を返します。 2 番目の例では、10.0 は浮動小数点数、5 は整数です。この場合、Python は内部的に 5 を 5.0 にプロモートし、除算を実行します。結果も浮動小数点数になります。

>>> 10 / 5j
-2j

ここでは、整数と複素数の間の除算を実行します。この場合、標準の除算演算子は複素数を返します。

最後に、フロア分割 (//) 演算子の使用例を以下に示します。

>>> 10 // 4
2
>>> -10 // -4
2

>>> 10 // -4
-3
>>> -10 // 4
-3

フロア区分は常に切り捨てられます。これは、結果が商以下の最大の整数であることを意味します。正の数値の場合、小数部分が切り捨てられ、整数部分だけが残るのと同じです。

Python の比較演算子と式

Python の比較演算子を使用すると、数値とそれをサポートする他のオブジェクトを比較できます。以下の表は、Python で現在使用可能なすべての比較演算子を示しています。

オペレーター:

==

操作: と等しい

式の例:

a == b

結果:
• a の値が b の値と等しい場合は True
• それ以外の場合は False

オペレーター:

!=

操作: と等しくない

式の例:

a != b

結果:
• a が b に等しくない場合は True
• それ以外の場合は False

オペレーター:

<

操作: 以下

式の例:

a < b

結果:
• a が b より小さい場合は True
• それ以外の場合は False

オペレーター:

<=

操作: 以下

式の例:

a <= b

結果:
• a が b 以下の場合は True
• それ以外の場合は False

オペレーター:

>

操作: より大きい

式の例:

a > b

結果:
• a が b より大きい場合は True、それ以外の場合は False

オペレーター:

>=

演算: 以上

式の例:

a >= b

結果:
• a が b 以上の場合は True
• False

比較演算子はすべてバイナリです。これは、左オペランドと右オペランドが必要であることを意味します。これらの演算子は常に、現在の比較の真の値に応じてブール値 (True または False) を返します。

異なるデータ型のオブジェクト間の比較は意味をなさないことが多く、Python では許可されない場合があることに注意してください。たとえば、== 演算子を使用して、数値と文字列が等しいかどうかを比較できます。ただし、結果として False が返されます。

>>> 2 == "2"
False

整数 2 は文字列 "2" と等しくありません。したがって、結果として False が返されます。上記の式で != 演算子を使用することもできます。その場合、結果として True が得られます。

異なるデータ型のオペランド間で等価でない比較を行うと、TypeError 例外が発生します。

>>> 5 < "7"
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'int' and 'str'

この例では、整数と文字列の間では小なり比較 (<) が意味をなさないため、Python は TypeError 例外を発生させます。したがって、操作は許可されていません。

比較のコンテキストでは、整数値と浮動小数点値には互換性があり、それらを比較できることに注意することが重要です。

通常、比較演算子は、条件ステートメントや while ループなどのブール コンテキストで使用および検索されます。これにより、意思決定を行い、プログラムの制御フローを定義できるようになります。

比較演算子は、数値、文字列、タプル、リストなど、いくつかのタイプのオペランドに作用します。次のセクションでは、その違いを見ていきます。

整数値の比較

おそらく、Python と数学におけるより単純な比較は、整数を含む比較です。これらを使用すると、日常的な作業である実際の物体を数えることができます。実際、負でない整数は自然数とも呼ばれます。したがって、この種の数値の比較はおそらく非常に直感的であり、Python での比較も例外ではありません。

整数を比較する次の例を考えてみましょう。

>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a < b
True
>>> a <= b
True
>>> a > b
False
>>> a >= b
False

>>> x = 30
>>> y = 30
>>> x == y
True
>>> x != y
False
>>> x < y
False
>>> x <= y
True
>>> x > y
False
>>> x >= y
True

最初の例セットでは、2 つの変数 a と b を定義して、それらの間でいくつかの比較を実行します。 a の値は b の値より小さいです。したがって、すべての比較式は期待されるブール値を返します。 2 番目の例セットでは、等しい 2 つの値を使用しており、やはり期待どおりの結果が得られます。

浮動小数点値の比較

浮動小数点数の比較は、整数の比較よりも少し複雑です。 float オブジェクトに格納される値は、あなたが想像しているものと正確に一致しない場合があります。そのため、== 演算子を使用して浮動小数点値が完全に等しいかどうかを比較することは推奨されません。

以下の例を考えてみましょう。

>>> x = 1.1 + 2.2
>>> x == 3.3
False

>>> 1.1 + 2.2
3.3000000000000003

うわぁ！最後の例でわかるように、この追加の内部表現は 3.3 とまったく同じではありません。したがって、等価演算子を使用して x と 3.3 を比較すると、False が返されます。

浮動小数点数が等しいかどうかを比較するには、別のアプローチを使用する必要があります。 2 つの浮動小数点値が等しいかどうかを判断するための推奨される方法は、ある程度の許容差を与えて、それらが互いに近いかどうかを判断することです。

標準ライブラリの math モジュールには、float の比較に役立つ isclose() という便利な関数が用意されています。この関数は 2 つの数値を受け取り、それらがほぼ等しいかどうかをテストします。

>>> from math import isclose

>>> x = 1.1 + 2.2

>>> isclose(x, 3.3)
True

この例では、isclose() 関数を使用して、x と 3.3 がほぼ等しいかどうかを比較します。今回は、両方の数値が等しいと見なせるほど近いため、結果として True が得られます。

isclose() の使用方法の詳細については、Python math モジュールの「Python isclose() を使用して数値の近さを見つける」セクションを参照してください。知っておくべきことすべて。

文字列の比較

比較演算子を使用して、コード内の Python 文字列を比較することもできます。このコンテキストでは、Python が内部で文字列オブジェクトをどのように比較するかを認識する必要があります。実際には、Python は各文字の Unicode のコード ポイントを使用して文字列を 1 文字ずつ比較します。 Unicode は Python のデフォルトの文字セットです。

組み込みの ord() 関数を使用して、Python の任意の文字の Unicode コード ポイントを学習できます。次の例を考えてみましょう。

>>> ord("A")
65
>>> ord("a")
97

>>> "A" == "a"
False
>>> "A" > "a"
False
>>> "A" < "a"
True

大文字の "A" は、小文字の "a" よりも低い Unicode ポイントを持ちます。したがって、"A" は "a" より小さくなります。最終的に、Python は整数を使用して文字を比較します。したがって、Python が整数を比較するために使用するのと同じルールが文字列比較にも適用されます。

複数の文字を含む文字列の場合、Python はループ内で 1 文字ずつ比較を実行します。

比較では辞書編集順が使用されます。つまり、Python は各文字列の最初の項目を比較します。 Unicode コード ポイントが異なる場合、この違いによって比較結果が決まります。 Unicode コード ポイントが等しい場合、Python は次の 2 文字を比較し、どちらかの文字列がなくなるまで比較します。

>>> "Hello" > "HellO"
True

>>> ord("o")
111
>>> ord("O")
79

この例では、Python は両方のオペランドを文字ごとに比較します。文字列の終わりに達すると、"o" と "O" が比較されます。小文字の方が Unicode コード ポイントが大きいため、文字列の最初のバージョンは 2 番目のバージョンよりも大きくなります。

異なる長さの文字列を比較することもできます。

>>> "Hello" > "Hello, World!"
False

この例では、Python は通常どおり文字ごとの比較を実行します。文字数が足りない場合は、短い文字列の方が長い文字列よりも少なくなります。これは、空の文字列が可能な限り最小の文字列であることも意味します。

リストとタプルの比較

Python を学ぶ中で、リストと他のリスト、タプルと他のタプルを比較する必要に直面することもあります。これらのデータ型は、標準の比較演算子もサポートしています。文字列の場合と同様、比較演算子を使用して 2 つのリストまたは 2 つのタプルを比較すると、Python は項目ごとの比較を実行します。

Python は、含まれる項目のタイプに応じて特定のルールを適用することに注意してください。整数値のリストとタプルを比較する例をいくつか示します。

>>> [2, 3] == [2, 3]
True
>>> (2, 3) == (2, 3)
True

>>> [5, 6, 7] < [7, 5, 6]
True
>>> (5, 6, 7) < (7, 5, 6)
True

>>> [4, 3, 2] < [4, 3, 2]
False
>>> (4, 3, 2) < (4, 3, 2)
False

これらの例では、標準の比較演算子を使用して数値のリストとタプルを比較します。これらのデータ型を比較するとき、Python は項目ごとの比較を実行します。

たとえば、上記の最初の式では、Python は左側のオペランドの 2 と右側のオペランドの 2 を比較します。これらは等しいため、Python は 3 と 3 の比較を続けて、両方のリストが等しいと結論付けます。 2 番目の例でも同じことが起こり、同じデータを含むタプルを比較します。

== 演算子と != 演算子を使用して、実際にリストをタプルと比較できることに注意することが重要です。ただし、<、>、<=、および できません。 >>= 演算子:

>>> [2, 3] == (2, 3)
False
>>> [2, 3] != (2, 3)
True

>>> [2, 3] > (2, 3)
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'list' and 'tuple'

>>> [2, 3] <= (2, 3)
Traceback (most recent call last):
    ...
TypeError: '<=' not supported between instances of 'list' and 'tuple'

Python はリストとタプル間の等価比較をサポートしています。ただし、最後の 2 つの例からわかるように、残りの比較演算子はサポートされていません。これらを使用しようとすると、操作がサポートされていないことを示す TypeError が表示されます。

異なる長さのリストとタプルを比較することもできます。

>>> [5, 6, 7] < [8]
True
>>> (5, 6, 7) < (8,)
True

>>> [5, 6, 7] == [5]
False
>>> (5, 6, 7) == (5,)
False

>>> [5, 6, 7] > [5]
True
>>> (5, 6, 7) > (5,)
True

最初の 2 つの例では、5 が 8 より小さいため、結果として True が得られます。この事実は、Python が比較を解決するのに十分です。 2 番目の例では、False が返されます。比較されたシーケンスの長さが同じではないため、等しくなることはあり得ないため、この結果は理にかなっています。

最後のペアの例では、Python は 5 と 5 を比較します。それらは等しいので、比較が続きます。右側のオペランドには比較する値がもうないため、Python は左側のオペランドの方が大きいと結論付けます。

ご覧のとおり、リストとタプルの比較は難しい場合があります。また、これはコストのかかる操作であり、最悪の場合、2 つのシーケンス全体を走査する必要があります。含まれる項目もシーケンスである場合、処理はより複雑になり、コストがかかります。このような状況では、Python は項目を値ごとに比較する必要があるため、操作にコストがかかります。

Python のブール演算子と式

Python には、and、or、および not という 3 つのブール演算子または論理演算子があります。これらは、汎用演算子 AND、OR、および NOT で示される一連の操作を定義します。これらの演算子を使用して、複合条件を作成できます。

次のセクションでは、Python のブール演算子がどのように機能するかを学習します。特に、ブール値または通常のオブジェクトをオペランドとして使用した場合、一部の関数は異なる動作をすることがわかります。

ブール オペランドを含むブール式

ブール型、つまり Python でこの型と呼ばれる bool のオブジェクトや式が多数見つかります。つまり、多くのオブジェクトは、Python のブール値である True または False として評価されます。

たとえば、比較演算子を使用して式を評価する場合、その式の結果は常に bool 型になります。

>>> age = 20

>>> is_adult = age > 18
>>> is_adult
True

>>> type(is_adult)
<class 'bool'>

この例では、式 age > 18 はブール値を返し、それを is_social 変数に保存します。組み込みの type() 関数を呼び出した後にわかるように、is_social は bool 型になります。

ブール値を返す Python の組み込み関数やカスタム関数も見つかります。このタイプの関数は述語関数として知られています。組み込みの all()、any()、callable()、および isinstance() 関数は次のとおりです。どれもこの実践の良い例です。

次の例を考えてみましょう。

>>> number = 42

>>> validation_conditions = (
...     isinstance(number, int),
...     number % 2 == 0,
... )

>>> all(validation_conditions)
True

>>> callable(number)
False
>>> callable(print)
True

このコード スニペットでは、最初に、古くからの代入演算子を使用して number という変数を定義します。次に、validation_conditions という別の変数を作成します。この変数は式のタプルを保持します。最初の式は、isinstance() を使用して、number が整数値かどうかを確認します。

2 つ目は、モジュロ演算子 (%) と等価演算子 (==) を組み合わせて、入力値が偶数かどうかをチェックする条件を作成する複合式です。この条件では、モジュロ演算子は number を 2 で割った余りを返し、等価演算子はその結果を 0 と比較して を返します。 >True または False を比較の結果として返します。

次に、all() 関数を使用して、すべての条件が true かどうかを判断します。この例では、number=42 であるため、条件は true であり、all() は True を返します。少し試してみたい場合は、number の値を試してみることができます。

最後の 2 つの例では、callable() 関数を使用します。その名前が示すように、この関数を使用すると、 オブジェクトが呼び出し可能かどうかを判断できます。呼び出し可能であるということは、他の Python 関数を呼び出すのと同じように、かっこのペアと適切な引数を使用してオブジェクトを呼び出すことができることを意味します。

number 変数は呼び出し可能ではないため、関数は False を返します。対照的に、print() 関数は呼び出し可能であるため、callable() は True を返します。

これまでの説明はすべて、Python 論理演算子がブール オペランドでどのように機能するかを理解するための基礎となります。

and、or、および not を含む論理式は、オペランドがブール値の場合は単純です。概要は次のとおりです。 x と y はブール オペランドを表すことに注意してください。

オペレーター:

and

式の例:

x and y

結果: • x と y の両方が True の場合、True
•それ以外の場合は False

オペレーター:

or

式の例:

x or y

結果: • x または y のいずれかが True の場合、True
•それ以外の場合は False

オペレーター:

not

式の例:

not x

結果: • x が False の場合は True
• < の場合は Falsex は True です

この表は、ブール オペランドを含む論理演算子を使用して作成できる式の真理値をまとめたものです。このまとめには注目すべき点があります。二項演算子である and や or とは異なり、not 演算子は単項演算子であり、1 つのオペランドに対して動作します。このオペランドは常に右側になければなりません。

ここで、オペレーターが実際にどのように動作するかを見てみましょう。ブール型オペランドで and 演算子を使用する例をいくつか示します。

>>> 5 < 7 and 3 == 3
True

>>> 5 < 7 and 3 != 3
False

>>> 5 > 7 and 3 == 3
False

>>> 5 > 7 and 3 != 3
False

最初の例では、両方のオペランドが True を返します。したがって、and 式は結果として True を返します。 2 番目の例では、左側のオペランドは True ですが、右側のオペランドは False です。このため、and 演算子は False を返します。

3 番目の例では、左側のオペランドは False です。この場合、and 演算子はすぐに False を返し、3 == 3 条件を評価しません。この動作は短絡評価と呼ばれます。詳細については、後ほど説明します。

最後の例では、両方の条件が False を返します。繰り返しますが、and は結果として False を返します。ただし、短絡評価のため、右辺の式は評価されません。

or 演算子はどうでしょうか?これがどのように機能するかを示すいくつかの例を次に示します。

>>> 5 < 7 or 3 == 3
True

>>> 5 < 7 or 3 != 3
True

>>> 5 > 7 or 3 == 3
True

>>> 5 > 7 or 3 != 3
False

最初の 3 つの例では、少なくとも 1 つの条件が True を返します。すべての場合において、or 演算子は True を返します。左側のオペランドが True の場合、or は短絡評価を適用し、右側のオペランドは評価しないことに注意してください。意味あり。左側のオペランドが True の場合、or は最終結果をすでに知っています。結果が変わらないのに、なぜ評価を続ける必要があるのでしょうか?

最後の例では、両方のオペランドが False であり、or が False を返す唯一の状況です。左側のオペランドが False の場合、最終的な結論に達するには、or が右側のオペランドを評価する必要があることに注意することが重要です。

最後に、オブジェクトまたは式の現在の真理値を否定する not 演算子があります。

>>> 5 < 7
True

>>> not 5 < 7
False

式の前に not を置くと、逆の真理値が得られます。式が True を返すと、False が返されます。式が False と評価されると、True が返されます。

not と他の 2 つのブール演算子の間には、基本的な動作の違いがあります。 not 式では、結果として常にブール値を取得します。 「他のタイプのオペランドを含むブール式」セクションで学習するように、これは常に and および or 式を管理する規則であるとは限りません。

ブール値コンテキストでの通常のオブジェクトの評価

実際には、ほとんどの Python オブジェクトと式はブール値ではありません。つまり、ほとんどのオブジェクトや式には True や False の値はなく、異なるタイプの値が含まれます。ただし、条件ステートメントや while ループなど、ブール値コンテキストでは任意の Python オブジェクトを使用できます。

Python では、すべてのオブジェクトが特定の真理値を持ちます。したがって、論理演算子はすべてのタイプのオペランドで使用できます。

Python には、オブジェクトをブールコンテキストで使用するとき、または論理演算子で構築された式のオペランドとして使用するときに、そのオブジェクトの真理値を決定するためのルールが確立されています。このトピックについてドキュメントに記載されている内容は次のとおりです。

デフォルトでは、オブジェクトは、そのクラスが False を返す __bool__() メソッドまたは __len__() メソッドを定義しない限り true とみなされます。オブジェクトで呼び出された場合はゼロ。 false とみなされる組み込みオブジェクトのほとんどを以下に示します。

• false として定義されている定数: None と False。
• 任意の数値型のゼロ: 0、0.0、0j、Decimal(0)、Fraction( 0, 1)
• 空のシーケンスとコレクション: ''、()、[]、{}、set( )、range(0)

（ソース）

オブジェクトの真理値を判定するには、そのオブジェクトを引数として組み込みの bool() 関数を呼び出します。 bool() が True を返す場合、オブジェクトは真実です。 bool() が False を返す場合、それは偽です。

数値の場合、ゼロ値は偽であり、ゼロ以外の値は真であることがわかります。

>>> bool(0), bool(0.0), bool(0.0+0j)
(False, False, False)

>>> bool(-3), bool(3.14159), bool(1.0+1j)
(True, True, True)

Python は、すべての数値型のゼロ値を偽とみなします。他のすべての値は、どれだけゼロに近いかに関係なく、真実です。

文字列の評価に関しては、空の文字列は常に偽であり、空でない文字列は真であることがわかります。

>>> bool("")
False

>>> bool(" ")
True

>>> bool("Hello")
True

空白を含む文字列も Python の目には真実であることに注意してください。したがって、空の文字列と空白文字列を混同しないでください。

最後に、リスト、タプル、セット、辞書などの組み込みコンテナ データ型は、空の場合は false になります。それ以外の場合、Python はそれらを真のオブジェクトと見なします。

>>> bool([])
False
>>> bool([1, 2, 3])
True

>>> bool(())
False
>>> bool(("John", 25, "Python Dev"))
True

>>> bool(set())
False
>>> bool({"square", "circle", "triangle"})
True

>>> bool({})
False
>>> bool({"name": "John", "age": 25, "job": "Python Dev"})
True

コンテナ データ型の真の値を判断するために、Python は .__len__() 特殊メソッドに依存します。このメソッドは、組み込みの len() 関数のサポートを提供します。この関数を使用して、特定のコンテナ内のアイテムの数を決定できます。

一般に、.__len__() が 0 を返す場合、Python はコンテナを偽のオブジェクトと見なします。これは、前に学んだ一般規則と一致します。

このセクションの Python オブジェクトの真理値に関するすべての議論は、論理演算子が任意のオブジェクトをオペランドとして受け取るときにどのように動作するかを理解するための鍵となります。

他のタイプのオペランドを含むブール式

数値や文字列などのオブジェクトを、and、or、および not のオペランドとして使用することもできます。ブール オブジェクトと通常のオブジェクトを組み合わせて使用することもできます。このような状況では、結果はオペランドの真理値に依存します。

Python がオブジェクトの真理値を決定する方法についてはすでに学習しました。これで、論理演算子と通常のオブジェクトを使用した式の作成に入る準備が整いました。

まず、and 式で 2 つのオブジェクト x と y を使用したときに得られる結果をまとめた表を以下に示します。

Truthy

y

Falsy

x

上の表の微妙な詳細を強調することが重要です。式で and を使用すると、結果として常に True または False が得られるわけではありません。代わりに、オペランドの 1 つを取得します。返されたオペランドにこれらの値のいずれかが含まれる場合、True または False のみが返されます。

以下に、整数値を使用するコード例をいくつか示します。 Python では、数値型のゼロ値は false であることに注意してください。残りの値は真実です。

>>> 3 and 4
4

>>> 0 and 4
0

>>> 3 and 0
0

最初の式では、左側のオペランド (3) が true です。したがって、結果として右側のオペランド (4) が得られます。

2 番目の例では、左側のオペランド (0) が false であり、結果としてそれが得られます。この場合、Python は短絡評価手法を適用します。 0 が false であるため、式全体が false であることがすでにわかっているため、Python は右側のオペランドを評価せずにすぐに 0 を返します。

最後の式では、左側のオペランド (3) が true になります。したがって、Python は結論を得るために右側のオペランドを評価する必要があります。その結果、真理値がどのようなものであっても、右側のオペランドが得られます。

or 演算子を使用すると、結果としてオペランドの 1 つも取得されます。これは、2 つの任意のオブジェクト x と y で起こることです。

Truthy

x

Falsy

y

繰り返しますが、式 x または y は True または False のいずれにも評価されません。代わりに、オペランドの 1 つである x または y を返します。

上の表から結論付けられるように、左側のオペランドが真であれば、結果としてそれが得られます。それ以外の場合は、2 番目のオペランドを取得します。この動作を示す例をいくつか示します。

>>> 3 or 4
3

>>> 0 or 4
4

>>> 3 or 0
3

最初の例では、左側のオペランドは true であり、or はすぐにそれを返します。この場合、Python は最終結果をすでに知っているため、2 番目のオペランドを評価しません。 2 番目の例では、左側のオペランドが false であるため、Python は右側のオペランドを評価して結果を決定する必要があります。

最後の例では、左側のオペランドは true であり、その事実によって式の結果が定義されます。右側のオペランドを評価する必要はありません。

x または y のような式は、x または y のいずれかが真である場合は真であり、x と y の両方が真である場合は偽です。 y は false です。このタイプの式は、最初に見つかった真のオペランドを返します。両方のオペランドが false の場合、式は右側のオペランドを返します。後者の動作を実際に確認するには、次の例を考えてみましょう。

>>> 0 or []
[]

この特定の式では、両方のオペランドが false です。したがって、or 演算子は右側のオペランドを返し、結果として式全体が false になります。

最後に、not 演算子があります。これを任意のオブジェクトでオペランドとして使用することもできます。何が起こるかというと、次のとおりです。

Truthy

偽

Falsy

真

not 演算子には統一された動作があります。常にブール値を返します。この動作は、兄弟演算子である and および or とは異なります。

いくつかのコード例を次に示します。

>>> not 3
False

>>> not 0
True

最初の例では、オペランド 3 は Python の観点からは真実です。したがって、演算子は False を返します。 2 番目の例では、オペランドは false で、not は True を返します。

要約すると、Python の not 演算子はオブジェクトの真理値を否定し、常にブール値を返します。この後者の動作は、ブール値ではなくオペランドを返す兄弟演算子 and および or の動作とは異なります。

複合論理式と短絡評価

これまで、単一の or または and 演算子と 2 つのオペランドのみを含む式を見てきました。ただし、複数の論理演算子とオペランドを使用して複合論理式を作成することもできます。

or を使用して複合式を作成する方法を説明するために、次のおもちゃの例を考えてみましょう。

x1 or x2 or x3 or ... or xn

この式は最初の真の値を返します。先行するすべての x 変数が false の場合、式は最後の値 xn を返します。

短絡評価を説明するために、次のように動作する恒等関数 f() があると仮定します。

• 引数を 1 つ受け取ります
• 関数とその引数を画面に表示します
• 引数を戻り値として返します

この関数を定義するコードと、その動作の例をいくつか示します。

>>> def f(arg):
...     print(f"-> f({arg}) = {arg}")
...     return arg
...

>>> f(0)
-> f(0) = 0
0

>>> f(False)
-> f(False) = False
False

>>> f(1.5)
-> f(1.5) = 1.5
1.5

f() 関数は引数を表示し、関数を呼び出したかどうかを視覚的に確認します。また、呼び出しで渡された引数も返します。この動作のため、arg にそれぞれ true または false の値を指定することで、式 f(arg) を true または false にすることができます。

ここで、次の複合論理式を考えてみましょう。

>>> f(0) or f(False) or f(1) or f(2) or f(3)
-> f(0) = 0
-> f(False) = False
-> f(1) = 1
1

この例では、Python は最初に f(0) を評価し、0 を返します。この値は誤りです。式はまだ true ではないため、評価は左から右に続きます。次のオペランド f(False) は、False を返します。その値も偽りであるため、評価は継続されます。

次は f(1) です。これは 1 と評価され、これは真実です。その時点で、Python は式全体が真実であることをすでに知っているため、評価を停止します。したがって、Python は式の値として 1 を返し、残りのオペランド f(2) と f(3) は評価しません。出力から、f(2) および f(3) 呼び出しが発生していないことが確認できます。

同様の動作は、次のような複数の and 演算子を含む式でも発生します。

x1 and x2 and x3 and ... and xn

すべてのオペランドが真であれば、この式は真です。少なくとも 1 つのオペランドが false の場合、式も false になります。

この例では、短絡評価により、オペランドが false になるとすぐに Python が評価を停止するように指示されます。その時点で、式全体が false であることがわかります。その場合、Python はオペランドの評価を停止し、評価を終了した false オペランドを返します。

以下に、短絡動作を確認する 2 つの例を示します。

>>> f(1) and f(False) and f(2) and f(3)
-> f(1) = 1
-> f(False) = False
False

>>> f(1) and f(0.0) and f(2) and f(3)
-> f(1) = 1
-> f(0.0) = 0.0
0.0

どちらの例でも、評価は最初の偽項 (最初のケースでは f(False)、2 番目のケースでは f(0.0)) で停止します。 も>f(2) も、f(3) 呼び出しも発生しません。最終的に、式はそれぞれ False と 0.0 を返します。

すべてのオペランドが真である場合、Python はそれらをすべて評価し、最後の (右端) ものを式の値として返します。

>>> f(1) and f(2.2) and f("Hello")
-> f(1) = 1
-> f(2.2) = 2.2
-> f(Hello) = Hello
'Hello'

>>> f(1) and f(2.2) and f(0)
-> f(1) = 1
-> f(2.2) = 2.2
-> f(0) = 0
0

最初の例では、すべてのオペランドが true です。この式も真実であり、最後のオペランドを返します。 2 番目の例では、最後のオペランドを除くすべてのオペランドが true です。式は false であり、最後のオペランドを返します。

短絡評価を悪用するイディオム

Python を詳しく調べていくと、表現の簡潔さ、パフォーマンス、安全性のために短絡評価を利用する一般的な慣用的なパターンがいくつかあることがわかります。たとえば、このタイプの評価は次の目的で利用できます。

• 例外の回避
• デフォルト値の指定
• コストのかかる操作を省略する

最初の点を説明するために、2 つの変数 a と b があり、b を で除算するかどうかを知りたいとします。 >a は 0 より大きい数値になります。この場合、次の式または条件を実行できます。

>>> a = 3
>>> b = 1

>>> (b / a) > 0
True

このコードは機能します。ただし、a が 0 である可能性を考慮する必要があります。その場合は例外が発生します。

>>> a = 0
>>> b = 1

>>> (b / a) > 0
Traceback (most recent call last):
    ...
ZeroDivisionError: division by zero

この例では、除数は 0 であるため、Python は ZeroDivisionError 例外を発生させます。この例外によりコードが壊れます。次のような式を使用して、このエラーをスキップできます。

>>> a = 0
>>> b = 1

>>> a != 0 and (b / a) > 0
False

a が 0 の場合、a != 0 は false になります。 Python の短絡評価では、評価がその時点で確実に停止します。つまり、(b/a) は実行されず、エラーも発生しません。

この手法を使用すると、整数が別の整数で割り切れるかどうかを判断する関数を実装できます。

def is_divisible(a, b):
    return b != 0 and a % b == 0

この関数では、b が 0 の場合、a/b は定義されていません。したがって、数字は割り切れません。 b が 0 と異なる場合、結果は除算の余りによって異なります。

指定された値が false の場合にデフォルト値を選択することも、Python の論理演算子の短絡評価機能を利用するイディオムです。

たとえば、国の名前を含む変数があるとします。ある時点で、この変数は空の文字列を保持することになる可能性があります。その場合は、変数にデフォルトの郡名を保持したいとします。 or 演算子を使用してこれを行うこともできます。

>>> country = "Canada"
>>> default_country = "United States"

>>> country or default_country
'Canada'

>>> country = ""
>>> country or default_country
'United States'

country が空でない場合、それは真実です。このシナリオでは、式は最初の真の値を返します。これは、最初の or 式の country です。評価は停止し、結果として "Canada" が得られます。

一方、country が空の文字列の場合、それは false です。評価は次のオペランド default_country に続きますが、これは真実です。最後に、結果としてデフォルトの国が取得されます。

短絡評価のもう 1 つの興味深い使用例は、複合論理式を作成する際にコストのかかる操作を回避することです。たとえば、特定の条件が false の場合にのみ実行する必要がある高コストの操作がある場合は、次のスニペットのように or を使用できます。

data_is_clean or clean_data(data)

この構造では、clean_data() 関数はコストのかかる操作を表します。短絡評価のため、この関数は data_is_clean が false の場合、つまりデータがクリーンではない場合にのみ実行されます。

この手法のもう 1 つのバリエーションは、特定の条件が true の場合にコストのかかる操作を実行する場合です。この場合、and 演算子を使用できます。

data_is_updated and process_data(data)

この例では、and 演算子は data_is_updated を評価します。この変数が true の場合、評価は続行され、process_data() 関数が実行されます。それ以外の場合、評価は停止し、process_data() は実行されません。

複合式と連鎖式

and 演算子を使用して比較式を結合する複合式がある場合があります。たとえば、数値が指定された間隔内にあるかどうかを確認したいとします。この問題は、次のような複合式を使用して解決できます。

>>> number = 5
>>> number >= 0 and number <= 10
True

>>> number = 42
>>> number >= 0 and number <= 10
False

この例では、and 演算子を使用して 2 つの比較式を結合し、number が 0 から 0 までの範囲内にあるかどうかを確認できます。 10、両方が含まれます。

Python では、比較演算子を連鎖させることで、この複合式をより簡潔にすることができます。たとえば、次の連鎖式は、前の複合式と同等です。

>>> number = 5
>>> 0 <= number <= 10
True

この式は、元の式よりも簡潔で読みやすくなっています。このコードは、数値が 0 と 10 の間にあるかどうかをチェックしていることがすぐにわかります。ほとんどのプログラミング言語では、この連鎖式は意味をなさないことに注意してください。 Python では、それは魔法のように機能します。

他のプログラミング言語では、この式はおそらく 0 <=number を評価することから始まりますが、これは当てはまります。この true 値は 10 と比較されますが、これにはあまり意味がないため、式は失敗します。

Python は、このタイプの式を同等の and 式 (0 <= number および number <= 10 など) として内部的に処理します。そのため、上記の例では正しい結果が得られます。

条件式または三項演算子

Python には条件式と呼ばれるものがあります。これらの種類の式は、a ? のような三項演算子からインスピレーションを得ています。 b : c は他のプログラミング言語で使用されます。この構造は、a の値が true の場合は b と評価され、それ以外の場合は c と評価されます。このため、同等の Python 構文が三項演算子としても知られることがあります。

ただし、Python では、式はより読みやすくなります。

variable = expression_1 if condition else expression_2

この式は、条件が true の場合は expression_1 を返し、それ以外の場合は expression_2 を返します。この式は、次のような通常の条件式と同等であることに注意してください。

if condition:
    variable = expression_1
else:
    variable = expression_2

では、なぜ Python にこの構文が必要なのでしょうか? PEP 308 では、式内で and および or 演算子を使用して従来の三項演算子と同じ効果を達成しようとするエラーが発生しやすい試みの蔓延を避けるための取り組みとして、条件式が導入されました。次のような:

variable = condition and expression_1 or expression_2

ただし、この式は期待どおりに機能せず、expression_1 が false の場合は expression_2 を返します。

Python 開発者の中には、条件式の構文を避け、通常の条件文を使用する人もいます。いずれの場合でも、この構文は双方向の条件文を記述するための簡潔なツールを提供するため、状況によっては便利です。

コードで条件式構文を使用する方法の例を次に示します。

>>> day = "Sunday"
>>> open_time = "11AM" if day == "Sunday" else "9AM"
>>> open_time
'11AM'

>>> day = "Monday"
>>> open_time = "11AM" if day == "Sunday" else "9AM"
>>> open_time
'9AM'

day が "Sunday" と等しい場合、条件は true となり、結果として最初の式 "11AM" が得られます。条件が false の場合、2 番目の式 "9AM" が取得されます。 and 演算子や or 演算子と同様に、条件式はブール値ではなく、いずれかの式の値を返すことに注意してください。

Python の恒等演算子と式

Python には、is と is not という 2 つの演算子が用意されており、2 つのオペランドが同じ同一性を持つかどうかを判断できます。つまり、オペランドが同じオブジェクトを参照しているかどうかを確認できます。アイデンティティと平等は同じではないことに注意してください。後者は、2 つのオペランドに同じデータが含まれているかどうかを確認することを目的としています。

以下は Python の恒等演算子の概要です。 x と y はオブジェクトを指す変数であることに注意してください。

オペレーター:

is

式の例:

x is y

結果: • x と y が同じメモリ内オブジェクトへの参照を保持している場合、True
•それ以外の場合は False

オペレーター:

is not

式の例:

x is not y

結果: • x が y が指すオブジェクトとは異なるオブジェクトを指している場合、True
•それ以外の場合は False

これら 2 つの Python 演算子は、奇妙な記号ではなくキーワードです。これは、構文の読みやすさを重視する Python の目標の一部です。

以下は、等しいが同一ではないオブジェクトを参照する 2 つの変数 x と y の例です。

>>> x = 1001
>>> y = 1001

>>> x == y
True

>>> x is y
False

この例では、x と y は、値が 1001 であるオブジェクトを参照します。つまり、彼らは平等なのです。ただし、これらは同じオブジェクトを参照しません。そのため、is 演算子は False を返します。組み込みの id() 関数を使用してオブジェクトの ID を確認できます。

>>> id(x)
4417772080

>>> id(y)
4417766416

id() の出力から結論付けられるように、x と y は同じ ID を持ちません。したがって、これらは異なるオブジェクトであり、そのため、式 x is y は False を返します。つまり、コンピュータのメモリに 1001 の 2 つの異なるインスタンスが保存されているため、False が返されます。

y=x のような代入を行うと、Python は同じオブジェクトへの 2 番目の参照を作成します。繰り返しますが、 id() 関数または is 演算子を使用して確認できます。

>>> a = "Hello, Pythonista!"
>>> b = a

>>> id(a)
4417651936
>>> id(b)
4417651936

>>> a is b
True

この例では、a と b は同じオブジェクト、文字列 "Hello, Pythonista!" への参照を保持します。したがって、id() 関数は、a と b を使用して呼び出した場合に同じ ID を返します。同様に、is 演算子は True を返します。

最後に、is not 演算子は is の逆です。したがって、is not を使用して、2 つの名前が同じオブジェクトを参照していないかどうかを判断できます。

>>> x = 1001
>>> y = 1001
>>> x is not y
True

>>> a = "Hello, Pythonista!"
>>> b = a
>>> a is not b
False

最初の例では、x と y がコンピュータのメモリ内の異なるオブジェクトを指しているため、is not 演算子は True を返します。code>。 2 番目の例では、a と b は同じオブジェクトへの参照であるため、is not 演算子は False を返します。 。

繰り返しますが、is not 演算子は、Python の可読性の目標を強調しています。一般に、両方の ID 演算子を使用すると、平易な英語として読み取れる小切手を作成できます。

Python のメンバーシップ演算子と式

場合によっては、リスト、タプル、セットなどのコンテナー データ型に値が存在するかどうかを判断する必要があります。言い換えれば、 指定された値が値のコレクションのメンバーであるかかどうかを確認する必要がある場合があります。 Python では、この種のチェックをメンバーシップ テストと呼びます。

メンバーシップ テストは非常に一般的であり、プログラミングに役立ちます。他の多くの一般的な操作と同様、Python にはメンバーシップ テスト専用の演算子があります。以下の表に、Python のメンバーシップ演算子を示します。

オペレーター:

in

式の例:

value in collection

結果: • value が collection に存在する場合、True
•<それ以外の場合はFalse

オペレーター:

not in

式の例:

alue not in collection

結果: • value が値の コレクション に存在しない場合、True
>• それ以外の場合は False

いつものように、Python は、混乱を招く可能性のある記号や記号の組み合わせの代わりに、英単語を演算子として使用することで読みやすさを重視しています。

Python の in 演算子と not in 演算子はバイナリです。これは、2 つのオペランドをいずれかの演算子で接続することでメンバーシップ式を作成できることを意味します。ただし、メンバーシップ式のオペランドには次のような特別な特徴があります。

• 左オペランド: 値のコレクション内で検索する値
• 右オペランド: ターゲット値が見つかる可能性のある値のコレクション

in 演算子をより深く理解するために、値がリストに含まれるかどうかを判断する 2 つの例を以下に示します。

>>> 5 in [2, 3, 5, 9, 7]
True

>>> 8 in [2, 3, 5, 9, 7]
False

5 が数値リストに含まれているため、最初の式は True を返します。 8 がリストにないため、2 番目の式は False を返します。

not in メンバーシップ演算子は、in 演算子と逆のテストを実行します。これにより、整数値が値のコレクションに存在しないかどうかを確認できます。

>>> 5 not in [2, 3, 5, 9, 7]
False

>>> 8 not in [2, 3, 5, 9, 7]
True

最初の例では、ターゲット リストに 5 が含まれているため、False が返されます。 2 番目の例では、8 が値のリストにないため、True が返されます。否定論理のため、早口言葉のように聞こえるかもしれません。混乱を避けるために、値が特定の値のコレクションの一部ではないかどうかを判断しようとしていることに注意してください。

連結演算子と繰り返し演算子と式

Python には 2 つの演算子があり、リスト、タプル、文字列などのシーケンス データ型で使用すると、若干異なる意味になります。これらのタイプのオペランドでは、+ 演算子は連結演算子を定義し、* 演算子は繰り返し演算子を表します。 :

オペレーター:

+

操作: 連結

式の例:

seq_1 + seq_2

結果: 両方のオペランドのすべての項目を含む新しいシーケンス

オペレーター:

*

操作: 繰り返し

式の例:

seq * n

結果: n 回繰り返された seq の項目を含む新しいシーケンス

どちらの演算子も二項演算子です。連結演算子は 2 つのシーケンスをオペランドとして受け取り、同じタイプの新しいシーケンスを返します。繰り返し演算子は、シーケンスと整数をオペランドとして受け取ります。通常の乗算と同様、オペランドの順序によって繰り返しの結果が変わることはありません。

連結演算子が実際にどのように機能するかを示す例をいくつか示します。

>>> "Hello, " + "World!"
'Hello, World!'

>>> ("A", "B", "C") + ("D", "E", "F")
('A', 'B', 'C', 'D', 'E', 'F')

>>> [0, 1, 2, 3] + [4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]

最初の例では、連結演算子 (+) を使用して 2 つの文字列を結合します。演算子は、2 つの元の文字列を結合した完全に新しい文字列オブジェクトを返します。

2 番目の例では、2 つの文字タプルを連結します。ここでも、演算子は、元のオペランドのすべての項目を含む新しいタプル オブジェクトを返します。最後の例では、同様のことを行いますが、今回は 2 つのリストを使用します。

繰り返し演算子の考え方は、指定されたシーケンスの内容を一定回数繰り返すことです。以下にいくつかの例を示します。

>>> "Hello" * 3
'HelloHelloHello'
>>> 3 * "World!"
'World!World!World!'

>>> ("A", "B", "C") * 3
('A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C')

>>> 3 * [1, 2, 3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]

最初の例では、繰り返し演算子 (*) を使用して、"Hello" 文字列を 3 回繰り返します。 2 番目の例では、整数を左側に、ターゲット文字列を右側に配置して、オペランドの順序を変更します。この例は、オペランドの順序が結果に影響しないことを示しています。

次の例では、それぞれタプルとリストで繰り返し演算子を使用します。どちらの場合も、元のシーケンス内の項目を 3 回繰り返した同じタイプの新しいオブジェクトが取得されます。

Walrus 演算子と代入式

すでに学習したように、= 演算子を使用した通常の代入ステートメントには戻り値がありません。代わりに、代入演算子が変数を作成または更新します。このため、演算子を式の一部にすることはできません。

Python 3.8 以降、新しいタイプの代入を可能にする新しい演算子にアクセスできるようになりました。この新しい割り当ては割り当て式または名前付き式と呼ばれます。新しい演算子はセイウチ演算子 と呼ばれ、コロンと等号の組み合わせ (:=) です。

通常の代入とは異なり、代入式には戻り値があり、 それが式である理由です。したがって、オペレーターは 2 つのタスクを実行します。

1. 式の結果を返します
2. 結果を変数に代入します

セイウチ演算子も二項演算子です。左側のオペランドは変数名である必要があり、右側のオペランドは任意の Python 式にすることができます。演算子は式を評価し、その値をターゲット変数に割り当て、その値を返します。

代入式の一般的な構文は次のとおりです。

(variable := expression)

この式は通常の割り当てのように見えます。ただし、代入演算子 (=) を使用する代わりに、セイウチ演算子 (:=) を使用します。式が正しく機能するには、ほとんどの使用例で括弧で囲む必要があります。ただし、状況によっては、それらが必要ない場合もあります。いずれにせよ、害はありませんので、安心してご使用ください。

代入式は、事前にこの値を取得するための専用の代入を使用せずに、式の結果または式の一部を再利用したい場合に便利です。これは、条件ステートメントのコンテキストで特に便利です。説明のために、以下の例は、文字列オブジェクトの長さをチェックするおもちゃの関数を示しています。

>>> def validate_length(string):
...     if (n := len(string)) < 8:
...         print(f"Length {n} is too short, needs at least 8")
...     else:
...         print(f"Length {n} is okay!")
...

>>> validate_length("Pythonista")
Length 10 is okay!

>>> validate_length("Python")
Length 6 is too short, needs at least 8

この例では、条件ステートメントを使用して、入力文字列の文字数が 8 未満かどうかを確認します。

代入式 (n := len(string)) は文字列の長さを計算し、それを n に割り当てます。次に、len() を呼び出した結果の値を返し、最終的に 8 と比較されます。こうすることで、以降の操作で使用する文字列長への参照が確実に得られます。

Python のビット演算子と式

ビット演算子はオペランドを 2 進数のシーケンスとして扱い、ビットごとに演算します。現在、Python は次のビット単位の演算子をサポートしています。

オペレーター:

&

演算: ビット単位の AND

式の例:

a & b

結果: • 結果の各ビット位置は、オペランドの対応する位置にあるビットの論理積です。
• 両方のビットが の場合、1 1、それ以外の場合は 0

オペレーター:

|

演算: ビット単位の OR

式の例:

a | b

結果: • 結果の各ビット位置は、オペランドの対応する位置のビットの論理 OR です。
• 1いずれかのビットが 1 の場合、それ以外の場合は 0

オペレーター:

~

演算: ビット単位の NOT

式の例:

~a

結果: • 結果の各ビット位置は、オペランドの対応する位置のビットの論理否定です。
• ビットが の場合、1 0 およびビットが 1 の場合は 0

オペレーター:

^

演算: ビットごとの XOR (排他的 OR)

式の例:

a ^ b

結果: • 結果の各ビット位置は、オペランドの対応する位置にあるビットの論理 XOR です。
• 1オペランドのビットが異なる場合は、等しい場合は 0

オペレーター:

>>

演算: ビット単位の右シフト

式の例:

a >> n

結果: 各ビットは右に n 桁シフトされます。

オペレーター:

<<

演算: ビット単位の左シフト

式の例:

a << n

結果: 各ビットは左に n 桁シフトされます。

この表からわかるように、ほとんどのビット演算子は 2 項演算子です。つまり、2 つのオペランドが必要です。ビット単位の NOT 演算子 (~) は、単一のオペランドを予期するため、唯一の単項演算子であり、常に式の右側に出現する必要があります。

Python のビット演算子を使用すると、最も粒度の高いビットレベルでデータを操作できます。これらの演算子は、圧縮や暗号化などの低レベルのアルゴリズムを作成する場合に一般的に役立ちます。

以下に、いくつかのビット単位演算子が実際にどのように機能するかを示す例をいくつか示します。

>>> # Bitwise AND
>>> #   0b1100    12
>>> # & 0b1010    10
>>> # --------
>>> # = 0b1000     8
>>> bin(0b1100 & 0b1010)
'0b1000'
>>> 12 & 10
8

>>> # Bitwise OR
>>> #   0b1100    12
>>> # | 0b1010    10
>>> # --------
>>> # = 0b1110    14
>>> bin(0b1100 | 0b1010)
'0b1110'
>>> 12 | 10
14

最初の例では、ビットごとの AND 演算子を使用します。コメント行は # で始まり、ビット レベルで何が起こっているかを視覚的に表現します。結果の各ビットが、オペランドの対応する位置にあるビットの論理 AND であることに注目してください。

2 番目の例は、ビット単位の OR 演算子がどのように機能するかを示しています。この場合、結果のビットは、オペランド内の対応するビットの論理 OR テストです。

すべての例で、組み込みの bin() 関数を使用して、結果をバイナリ オブジェクトとして表示しました。 bin() への呼び出しで式をラップしない場合、出力の整数表現が取得されます。

Python における演算子の優先順位

ここまで、主に 1 つまたは 2 つの異なるタイプの演算子を使用するサンプル式をコーディングしてきました。ただし、比較、算術、ブール演算など、複数の異なる種類の演算子を使用する複合式を作成する必要がある場合はどうすればよいでしょうか? Python はどの操作を最初に実行するかをどのように決定するのでしょうか?

次の数式を考えてみましょう。

>>> 20 + 4 * 10
60

この表現には曖昧な点があるかもしれません。 Python は最初に加算 20 + 4 を実行してから、その結果に 10 を乗算する必要がありますか? Python は最初に乗算 4 * 10 を実行し、次に加算を実行する必要がありますか?

結果は 60 であるため、Python は後者のアプローチを選択したと結論付けることができます。前者を選択した場合、結果は 240 になります。これは、事実上すべてのプログラミング言語で見られる標準的な代数規則に従います。

Python がサポートするすべての演算子は、他の演算子と比べて優先されます。この優先順位により、Python が複合式内の演算子を実行する順序が定義されます。

式では、Python は優先順位の最も高い演算子を最初に実行します。これらの結果を取得した後、Python は次に高い優先順位の演算子を実行します。このプロセスは、式が完全に評価されるまで続きます。優先順位が等しい演算子は、左から右の順序で実行されます。

これまでに説明した Python 演算子の優先順位は、高いものから低いものまで次のとおりです。

**

べき乗

+x, -x, ~x

単項正、単項否定、ビットごとの否定

*, /, //, %

乗算、除算、フロア除算、モジュロ

+, -

足し算、引き算

<<, >>

ビット単位のシフト

&

ビットごとの AND

^

ビットごとの XOR

|

ビットごとの OR

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

比較、アイデンティティ、メンバーシップ

not

ブール値 NOT

and

ブール演算子 AND

or

ブールOR

:=

セイウチ

テーブルの上部にある演算子の優先順位が最も高く、テーブルの下部にある演算子の優先順位が最も低くなります。テーブルの同じ行にある演算子の優先順位は同じです。

最初の例に戻ると、乗算演算子は加算演算子よりも優先順位が高いため、Python は乗算を実行します。

別の説明的な例を次に示します。

>>> 2 * 3 ** 4 * 5
810

上の例では、Python はまず 3 の 4 乗、つまり 81 を計算します。次に、左から右の順に、2 * 81=162 と 162 * 5=810 の乗算を実行します。

数学の場合と同様に、括弧を使用して項をグループ化することで、デフォルトの演算子の優先順位をオーバーライドできます。括弧内の部分式は、括弧内にない式の前に実行されます。

以下に、かっこのペアが式の結果にどのような影響を与えるかを示す例をいくつか示します。

>>> (20 + 4) * 10
240

>>> 2 * 3 ** (4 * 5)
6973568802

最初の例では、式 20 + 4 がかっこで囲まれているため、Python は最初に式 20 + 4 を計算します。次に、Python は結果に 10 を乗算し、式は 240 を返します。この結果は、このセクションの冒頭で得られた結果とはまったく異なります。

2 番目の例では、Python は最初に 4 * 5 を評価します。次に、3 を結果の値で累乗します。最後に、Python は結果を 2 で乗算し、6973568802 を返します。

評価の順序を変更する必要がない場合でも、かっこを自由に使用することに問題はありません。括弧を使用すると、コードの可読性が向上し、読者が演算子の優先順位を記憶から呼び出す必要がなくなるため、場合によっては括弧を使用することをお勧めします。

次の例を考えてみましょう。

(a < 10) and (b > 30)

比較演算子は and よりも優先されるため、ここでは括弧は不要です。ただし、括弧なしのバージョンよりも括弧で囲まれたバージョンの方がわかりやすいと感じる人もいるかもしれません。

a < 10 and b > 30

一方、開発者の中には、この後者のバージョンの式を好む人もいるかもしれません。それは個人的な好みの問題です。重要なのは、括弧を使用するとコードが読みやすくなると思われる場合は、評価の順序を変更する必要がない場合でも、いつでも括弧を使用できるということです。

拡張された代入演算子と式

ここまでは、単一の等号 (=) が代入演算子を表し、値を変数に代入できることを学びました。これまでに学んだように、右側のオペランドに他の変数を含めることは完全に有効です。特に、代入演算子の右側の式には、オペランドの左側にあるのと同じ変数を含めることができます。

最後の文はわかりにくいかもしれないので、要点を明確にする例を次に示します。

>>> total = 10
>>> total = total + 5
>>> total
15

この例では、 total は、連続する値を累積するために使用するアキュムレータ変数です。 total は、total に 5 を加えた現在の値に等しいため、この例を読んでください。この式により、total の値が効果的に増加し、15 になります。

このタイプの代入は、対象の変数にすでに値がある場合にのみ意味があることに注意してください。未定義の変数を使用して代入を試みると、エラーが発生します。

>>> count = count + 1
Traceback (most recent call last):
    ...
NameError: name 'count' is not defined. Did you mean: 'round'?

この例では、count 変数は代入前に定義されていないため、現在の値はありません。その結果、Python は NameError 例外を発生させて、問題について知らせます。

このタイプの割り当ては、アキュムレータやカウンタ変数などの作成に役立ちます。したがって、これはプログラミングにおいて非常に一般的なタスクです。多くの同様のケースと同様に、Python はより便利なソリューションを提供します。これは、拡張代入と呼ばれる短縮構文をサポートしています。

>>> total = 10
>>> total += 5
>>> total
15

強調表示された行では、拡張加算演算子 (+=) を使用します。この演算子を使用すると、total=total + 5 と完全に同等の代入を作成できます。

Python は多くの拡張代入演算子をサポートしています。一般に、このタイプの代入の構文は次のようになります。

variable $= expression

ドル記号 ($) は有効な Python 演算子ではないことに注意してください。この例では、これは汎用演算子のプレースホルダーです。上記のステートメントは次のように機能します。

1. expression を評価して値を生成します。
2. variable の現在の値と expression の戻り値を使用して、代入演算子 (=) にプレフィックスを付ける演算子で定義された操作を実行します。オペランド。
3. 結果の値を variable に割り当てます。

以下の表は、算術演算の拡張演算子の概要を示しています。

オペレーター:

+=

説明: 右オペランドを左オペランドに加算し、結果を左オペランドに格納します。

式の例:

x += y

同等の表現:

x = x + y

オペレーター:

-=

説明: 左オペランドから右オペランドを減算し、結果を左オペランドに格納します。

式の例:

x -= y

同等の表現:

x = x - y

オペレーター:

*=

説明: 右オペランドと左オペランドを乗算し、結果を左オペランドに格納します。

式の例:

x *= y

同等の表現:

x = x * y

オペレーター:

/=

説明: 左オペランドを右オペランドで除算し、結果を左オペランドに格納します。

式の例:

x /= y

同等の表現:

x = x / y

オペレーター:

//=

説明: 左オペランドを右オペランドでフロア除算し、結果を左オペランドに格納します。

式の例:

x //= y

同等の表現:

x = x // y

オペレーター:

%=

説明: 左オペランドを右オペランドで割った余りを求め、結果を左オペランドに格納します

式の例:

x %= y

同等の表現:

x = x % y

オペレーター:

**=

説明: 左のオペランドを右のオペランドで累乗し、結果を左のオペランドに格納します。

式の例:

x **= y

同等の表現:

x = x**y

この表から結論付けられるように、すべての算術演算子には Python の拡張バージョンがあります。これらの拡張演算子は、アキュムレータ、カウンタ、および同様のオブジェクトを作成するときにショートカットとして使用できます。

拡張算術演算子はすっきりしていて便利だと思いましたか?良いニュースは、他にもたくさんあるということです。 Python には拡張ビット演算子もあります。

オペレーター:

&=

演算: 拡張ビット単位 AND (論理積)

例:

x &= y

同等:

x = x & y

オペレーター:

|=

演算: 拡張ビット単位 OR (論理和)

例:

x |= y

同等:

x = x | y

オペレーター:

^=

演算: 拡張ビット単位 XOR (排他的論理和)

例:

x ^= y

同等:

x = x ^ y

オペレーター:

>>=

演算: 拡張ビット単位右シフト

例:

x >>= y

同等:

x = x >> y

オペレーター:

<<=

演算: 拡張ビット単位左シフト

例:

x <<= y

同等:

x = x << y

最後に、連結演算子と繰り返し演算子にもバリエーションが追加されました。これらのバリエーションは、可変データ型と不変データ型で動作が異なります。

オペレーター:

+=

説明: • ターゲット シーケンスに対して拡張連結操作を実行します。
• 変更可能なシーケンスはその場で更新されます。
• シーケンスが不変の場合は、新しいシーケンスが作成され、再度割り当てられます。ターゲット名に。

例:

seq_1 += seq_2

オペレーター:

*=

説明: • seq をそれ自体に n 回追加します。
• 可変シーケンスはその場で更新されます。
• シーケンスが不変の場合は、新しいシーケンスが作成され、ターゲット名に割り当てられます。

例:

seq *= n

拡張連結演算子は 2 つのシーケンスに作用するのに対し、拡張繰り返し演算子は 1 つのシーケンスと整数に作用することに注意してください。

結論

これで、Python がサポートする演算子とその使用方法がわかりました。演算子は、コード内でさまざまな種類の式を作成し、計算を実行するために Python オブジェクトと一緒に使用できる記号、記号の組み合わせ、またはキーワードです。

このチュートリアルでは次のことを学習しました:

• Python の算術演算子とは何か、およびそれらを算術式で使用する方法
• Python の比較、ブール、アイデンティティ、メンバーシップ演算子とは何ですか
• 比較演算子、ブール演算子、恒等演算子、およびメンバーシップ演算子を使用した式を記述する方法
• Python がサポートするビット単位演算子とその使用方法
• 連結演算子と繰り返し演算子を使用してシーケンスを結合および繰り返す方法
• 拡張代入演算子とは何か、およびその仕組み

言い換えれば、あなたは非常に多くの領域をカバーしてきたということです。学んだことすべてを思い出させる便利なチートシートが必要な場合は、以下のリンクをクリックしてください。

演算子に関するこれだけの知識があれば、Python 開発者としての準備が整います。コード内でより優れた、より堅牢な式を作成できるようになります。