Python 演算子とは？種類と使い方を徹底解説

プログラミング言語において、演算子は処理の基本となる要素です。Pythonも例外ではなく、算術計算、値の比較、論理判断、ビット操作、代入など、さまざまな処理を演算子を使って行います。演算子を理解することは、Pythonで意図したとおりのプログラムを書く上で不可欠です。

この記事では、Pythonにおける演算子とは何か、その種類、それぞれの使い方、そして知っておくべき注意点や応用例まで、約5000語をかけて徹底的に解説します。Python初心者の方から、さらに理解を深めたい方まで、この記事が演算子マスターへの一助となれば幸いです。

1. 演算子とは？Pythonにおける役割

演算子（Operator）とは、一つまたは複数の値（オペランド、Operand）に対して特定の操作を行う記号やキーワードのことです。例えば、+ は加算を行う演算子、= は代入を行う演算子です。

“`python

演算子とオペランドの例

a = 10 # = は代入演算子、a と 10 はオペランド
b = 20
c = a + b # + は加算演算子、a と b はオペランド
print(c) # 結果: 30
“`

オペランドが一つだけの演算子を単項演算子（Unary Operator）、オペランドが二つの演算子を二項演算子（Binary Operator）と呼びます。ほとんどの演算子は二項演算子ですが、例えば負の符号（-）やビット否定（~）は単項演算子です。

演算子は、プログラムの実行においてデータの変換、評価、判断など、多岐にわたる処理の根幹を担います。Pythonの豊富な標準ライブラリやフレームワークも、内部ではこれらの基本的な演算子を組み合わせて複雑な処理を実現しています。演算子を使いこなすことは、効率的で読みやすいコードを書くための第一歩と言えるでしょう。

2. Pythonの演算子の種類

Pythonには、機能に応じて様々な種類の演算子があります。主な分類は以下の通りです。

算術演算子 (Arithmetic Operators): 数値計算を行います。
代入演算子 (Assignment Operators): 変数に値を代入します。
比較演算子 (Comparison Operators): 値の大小や等価性を比較します。
論理演算子 (Logical Operators): 論理値に対する操作を行います。
ビット演算子 (Bitwise Operators): 整数をビット列として扱い操作します。
メンバシップ演算子 (Membership Operators): シーケンスやコレクションに特定の値が含まれているかを調べます。
アイデンティティ演算子 (Identity Operators): オブジェクトが同一であるかを調べます。
その他の演算子: 三項演算子、ウォルラス演算子など。

これらの演算子について、それぞれ詳しく見ていきましょう。

3. 各演算子の詳細解説

3.1. 算術演算子 (Arithmetic Operators)

算術演算子は、数値データに対して数学的な計算を行うための演算子です。

演算子	名称	説明	例	結果
`+`	加算	オペランドを加算します。文字列やリストなどの結合にも使われます。	`10 + 5`	`15`
`-`	減算	左オペランドから右オペランドを減算します。単項演算子として負の数も表せます。	`10 - 5`	`5`
`*`	乗算	オペランドを乗算します。文字列やリストの繰り返しにも使われます。	`10 * 5`	`50`
`/`	除算	左オペランドを右オペランドで除算します。結果は常に浮動小数点数になります。	`10 / 5`	`2.0`
`%`	剰余	左オペランドを右オペランドで割った余りを計算します。	`10 % 3`	`1`
`**`	累乗	左オペランドを右オペランドで指定された回数だけ累乗します。	`2 ** 3`	`8`
`//`	フロア除算	左オペランドを右オペランドで除算し、小数点以下を切り捨てて最も近い整数を返します。	`10 // 3`	`3`

詳細と使い方:

加算 (+):
数値の加算はもちろん、文字列の連結やリスト、タプルなどのシーケンス型の結合にも使われます。
python print(10 + 5) # 数値の加算: 15 print("Hello" + " " + "World") # 文字列の連結: Hello World print([1, 2] + [3, 4]) # リストの結合: [1, 2, 3, 4] print((10, 20) + (30, 40)) # タプルの結合: (10, 20, 30, 40) # 異なる型の結合は通常エラーになります # print(10 + "Hello") # TypeError
異なる数値型（intとfloatなど）の間で加算を行う場合、結果はより広い範囲を表現できる型（通常はfloat）になります。
python print(10 + 5.5) # intとfloatの加算: 15.5 (float型)
減算 (-):
数値の減算を行います。また、単項演算子として使用すると、数値の符号を反転させます。
python print(10 - 5) # 数値の減算: 5 print(-10) # 単項演算子としての使用: -10 a = 10 print(-a) # 変数に対しても使用可能: -10
加算と同様、異なる数値型を含む場合は結果はfloatになります。
乗算 (*):
数値の乗算を行います。また、文字列やリストなどのシーケンス型を指定された回数だけ繰り返す操作にも使われます。
python print(10 * 5) # 数値の乗算: 50 print("abc" * 3) # 文字列の繰り返し: abcabcabc print([0] * 5) # リストの繰り返し: [0, 0, 0, 0, 0]
シーケンス型の繰り返しは、要素自体がコピーされるわけではない点に注意が必要です。特にミュータブルなリストなどのオブジェクトを含むリストを繰り返す場合は、予期しない結果になることがあります。
python # リストを繰り返す際の注意点 nested_list = [[0]] * 3 print(nested_list) # [[0], [0], [0]] nested_list[0][0] = 99 print(nested_list) # [[99], [99], [99]] - 全ての内部リストが同じオブジェクトを参照しているため
除算 (/):
一般的な除算を行います。Python 3では、整数の除算であっても結果は常に浮動小数点数 (float) になります。ゼロで割ると ZeroDivisionError となります。
python print(10 / 5) # 結果はfloat: 2.0 print(10 / 3) # 結果はfloat: 3.3333333333333335 print(10 // 5) # フロア除算はint: 2 # print(10 / 0) # ZeroDivisionError
剰余 (%):
除算の余りを計算します。符号付きのオペランドの場合、結果の符号は通常、右オペランドではなく左オペランドの符号に従います。
python print(10 % 3) # 10 = 3 * 3 + 1 -> 1 print(-10 % 3) # -10 = 3 * (-4) + 2 -> 2 (左オペランドが負でも右オペランドが正なら結果は非負) print(10 % -3) # 10 = (-3) * (-3) + 1 -> 1 (右オペランドが負なら結果の符号は左オペランドに従う) print(-10 % -3) # -10 = (-3) * 4 + 2 -> 2 (左オペランドが負なら結果の符号は左オペランドに従う)
ゼロで割る剰余計算も ZeroDivisionError となります。
累乗 (**):
x ** y は x の y 乗を計算します。
python print(2 ** 3) # 2の3乗: 8 print(9 ** 0.5) # 平方根: 3.0 (float型) print(-2 ** 3) # -(2 ** 3) と解釈される: -8 print((-2) ** 3)# (-2)を3乗: -8 print((-2) ** 2)# (-2)を2乗: 4 print(-2 ** 2) # -(2 ** 2) と解釈される: -4
** 演算子は他の算術演算子よりも優先順位が高いですが、単項の - よりは優先順位が低いです。そのため -x ** y は -(x ** y) と解釈されます。
フロア除算 (//):
除算の結果の小数点以下を切り捨てます。結果の型は、オペランドが両方とも整数の場合は整数 (int)、一方でも浮動小数点数の場合は浮動小数点数 (float) になりますが、値は整数部分のみです。
python print(10 // 3) # int // int -> int: 3 print(-10 // 3) # -10 / 3 = -3.33... を切り捨て -> -4 print(10 // -3) # 10 / -3 = -3.33... を切り捨て -> -4 print(-10 // -3) # -10 / -3 = 3.33... を切り捨て -> 3 print(10.0 // 3) # float // int -> float: 3.0 print(10 // 3.0) # int // float -> float: 3.0 print(-10.0 // 3) # float // int -> float: -4.0
通常の除算と同様にゼロでのフロア除算は ZeroDivisionError となります。フロア除算の結果の符号は、数学的な除算の結果の小数点以下を「負の無限大方向へ」切り捨てることで決定されます。

3.2. 代入演算子 (Assignment Operators)

代入演算子は、変数を宣言したり、変数に値を格納したり、既存の変数の値を更新したりするために使用されます。最も基本的な代入演算子は = です。

演算子	例	説明	等価な表現
`=`	`x = 10`	x に 10 を代入	–
`+=`	`x += 5`	x に x + 5 を代入	`x = x + 5`
`-=`	`x -= 5`	x に x – 5 を代入	`x = x - 5`
`*=`	`x *= 5`	x に x * 5 を代入	`x = x * 5`
`/=`	`x /= 5`	x に x / 5 を代入	`x = x / 5`
`%=`	`x %= 5`	x に x % 5 を代入	`x = x % 5`
`**=`	`x **= 5`	x に x ** 5 を代入	`x = x ** 5`
`//=`	`x //= 5`	x に x // 5 を代入	`x = x // 5`
`&=`	`x &= y`	x に x & y を代入	`x = x & y`
`\|=`	`x \|= y`	x に x	y を代入
`^=`	`x ^= y`	x に x ^ y を代入	`x = x ^ y`
`<<=`	`x <<= y`	x に x << y を代入	`x = x << y`
`>>=`	`x >>= y`	x に x >> y を代入	`x = x >> y`

詳細と使い方:

単純代入 (=):
最も基本的な演算子です。右辺の式の評価結果を左辺の変数に代入します。左辺は変数名である必要があります。
python age = 30 name = "Alice" score = 85.5
複数の変数に同じ値を代入することも可能です。
python x = y = z = 0 # x, y, z の全てに 0 を代入
複数の変数に異なる値を一度に代入することも可能です（多重代入）。タプルやリストのアンパックを利用します。
python a, b = 10, 20 # aに10、bに20を代入 data = [1, 2, 3] x, y, z = data # xに1, yに2, zに3を代入
変数の値を交換する際にも便利です。
python a = 10 b = 20 a, b = b, a # aは20, bは10になる
複合代入演算子 (+=, -=, *= など):
算術演算子やビット演算子と組み合わされて使用されます。 variable op= value は variable = variable op value の糖衣構文（Syntactic Sugar）であり、より短く記述できます。
“`python
count = 0
count += 1 # count = count + 1 と同じ。count は 1 になる

total = 100
total -= 20 # total = total – 20 と同じ。total は 80 になる

price = 50
price *= 1.1 # price = price * 1.1 と同じ。price は 55.0 になる

ratio = 10
ratio /= 2 # ratio = ratio / 2 と同じ。ratio は 5.0 になる

remainder = 17
remainder %= 5 # remainder = 17 % 5 と同じ。remainder は 2 になる

power = 2
power **= 3 # power = 2 ** 3 と同じ。power は 8 になる

length = 10
length //= 3 # length = 10 // 3 と同じ。length は 3 になる
これらの複合代入演算子は、特に同じ変数に対して連続して演算を行う場合にコードを簡潔に記述できます。リストや文字列などのミュータブルなオブジェクトに対して `+=` を使用する場合、通常は新しいオブジェクトを作成するのではなく、元のオブジェクトに対して変更が行われることに注意してください（ただし、これはオブジェクトの実装によります。リストの `+=` は `list.extend()` に相当し、インプレースで変更されます）。python
list1 = [1, 2]
list2 = [3, 4]
list1 += list2 # list1は [1, 2, 3, 4] になる。元のlist1が変更される。
print(list1) # [1, 2, 3, 4]

str1 = “Hello”
str2 = “World”
str1 += str2 # str1 = str1 + str2 と同じ。str1は “HelloWorld” になる。
# 文字列はイミュータブルなので、これは新しい文字列オブジェクトが作成される。
print(str1) # HelloWorld
“`

3.3. 比較演算子 (Comparison Operators)

比較演算子は、二つの値を比較し、その関係が真であるか偽であるかを示す真偽値 (True または False) を返します。

演算子	名称	説明	例	結果
`==`	等しい	オペランドの値が等しい場合に `True`	`10 == 10`	`True`
`!=`	等しくない	オペランドの値が等しくない場合に `True`	`10 != 20`	`True`
`>`	より大きい	左オペランドが右オペランドより大きい場合に `True`	`10 > 5`	`True`
`<`	より小さい	左オペランドが右オペランドより小さい場合に `True`	`5 < 10`	`True`
`>=`	以上	左オペランドが右オペランド以上の場合に `True`	`10 >= 10`	`True`
`<=`	以下	左オペランドが右オペランド以下の場合に `True`	`5 <= 10`	`True`

詳細と使い方:

等しい (==):
二つのオペランドの値が等しいかを比較します。異なる型のオブジェクトでも、値が等しければ True を返す場合があります（例: 1 == 1.0 は True）。ただし、文字列やリストなどでは型と内容の両方が一致する必要があります。
python print(5 == 5) # True print(5 == 10) # False print(5 == 5.0) # True (異なる型でも値が等しければTrue) print("Hello" == "Hello") # True print("Hello" == "hello") # False (大文字小文字を区別) print([1, 2] == [1, 2]) # True print([1, 2] == [2, 1]) # False (順序も重要) print((1, 2) == (1, 2)) # True
等しくない (!=):
二つのオペランドの値が等しくないかを比較します。== の結果が False なら True、True なら False を返します。
python print(5 != 10) # True print(5 != 5) # False print("Hello" != "World") # True
より大きい (>) / より小さい (<) / 以上 (>=) / 以下 (<=):
数値の大小比較を行います。文字列やリストなどのシーケンス型に対しても使用できますが、その場合は辞書順や要素の順序に基づいて比較が行われます。
“`python
print(10 > 5) # True
print(5 < 10) # True
print(10 >= 10) # True
print(5 <= 10) # True
print(10 >= 5) # True
print(5 <= 5) # True

文字列の比較 (辞書順)

print(“apple” < “banana”) # True
print(“Apple” < “apple”) # True (大文字は小文字より前に来る)

リストの比較 (要素を順に比較)

print([1, 2] < [1, 3]) # True (最初の要素が等しい場合、次の要素を比較)
print([1, 2] < [1, 2, 3]) # True (短い方が長い方より小さいとみなされる)
print([1, 5] > [2, 1]) # False (最初の要素で[1, 5] < [2, 1]がFalseになるため)

異なる型の比較は基本的にエラー (TypeError)

print(10 > “Hello”) # TypeError

“`

比較演算子の連鎖:
Pythonでは、比較演算子を数学のように連鎖させることができます。a < b < c は a < b and b < c と同じ意味になります。
python age = 25 print(18 <= age < 65) # ageが18以上かつ65未満かをチェック -> True print(0 < 10 < 20 < 30) # True print(0 < 10 < 5 < 30) # False (10 < 5 がFalseのため)
この機能は非常に便利で、複数の条件を簡潔に記述できます。

注意点:
* 浮動小数点数の比較は、内部的な表現誤差により予期しない結果になることがあります。厳密な比較が必要な場合は、許容誤差を考慮するか、decimalモジュールを使用することを検討してください。
python print(0.1 + 0.2 == 0.3) # False になることがある
* is 演算子（後述）はオブジェクトの同一性を比較するのに対し、== 演算子はオブジェクトの値の等価性を比較します。この違いを理解することが重要です。

3.4. 論理演算子 (Logical Operators)

論理演算子は、ブール値 (True または False) を操作するために使用されます。条件式や制御フロー（if文、while文など）で頻繁に利用されます。Pythonの論理演算子はキーワードで表されます。

演算子	名称	説明	例
`and`	論理積	左オペランドと右オペランドの両方が真の場合に真を返します。	`True and False`
`or`	論理和	左オペランドまたは右オペランドの少なくとも一方が真の場合に真を返します。	`True or False`
`not`	論理否定	オペランドが真の場合に偽を、偽の場合に真を返します。	`not True`

詳細と使い方:

論理積 (and):
expr1 and expr2 の形式で使われます。
- expr1 が偽 (False) と評価される場合、expr2 は評価されず、expr1 の値が返されます。
- expr1 が真 (True) と評価される場合、expr2 が評価され、expr2 の値が返されます。
  これは短絡評価 (Short-circuit evaluation) と呼ばれる重要な特性です。
  “`python
  print(True and True) # True
  print(True and False) # False
  print(False and True) # False (False の時点で評価終了)
  print(False and False) # False (False の時点で評価終了)
短絡評価の例

def func1():
print(“func1 called”)
return True
def func2():
print(“func2 called”)
return True

print(False and func1()) # func1は呼び出されない

出力: False

print(True and func2()) # func2が呼び出される

出力: func2 called

True

True/False以外の値に対するand

Pythonでは、以下の値は論理的にFalseとみなされます:

None, False, 数値の 0 (int, float, complex), 空のシーケンス (”, [], ()), 空のマップ ({}), 空のセット (set())

上記以外の値は論理的にTrueとみなされます。

print(0 and “Hello”) # 0 (左がFalseなので左の値を返す)
print(1 and “Hello”) # Hello (左がTrueなので右の値を返す)
print(“” and “World”) # “” (左がFalseなので左の値を返す)
print(“Hello” and “”) # “” (左がTrueなので右が評価され、右の値を返す)
``and` 演算子は、特に複数の条件がすべて満たされる必要がある場合に便利です。
論理和 (or):
expr1 or expr2 の形式で使われます。
- expr1 が真 (True) と評価される場合、expr2 は評価されず、expr1 の値が返されます。
- expr1 が偽 (False) と評価される場合、expr2 が評価され、expr2 の値が返されます。
  これも短絡評価が行われます。
  “`python
  print(True or True) # True (True の時点で評価終了)
  print(True or False) # True (True の時点で評価終了)
  print(False or True) # True
  print(False or False) # False
短絡評価の例

def func3():
print(“func3 called”)
return False
def func4():
print(“func4 called”)
return False

print(True or func3()) # func3は呼び出されない

出力: True

print(False or func4()) # func4が呼び出される

出力: func4 called

False

True/False以外の値に対するor

print(0 or “Hello”) # Hello (左がFalseなので右が評価され、右の値を返す)
print(1 or “Hello”) # 1 (左がTrueなので左の値を返す)
print(“” or “World”) # World (左がFalseなので右が評価され、右の値を返す)
print(“Hello” or “”) # Hello (左がTrueなので左の値を返す)
``or演算子は、複数の条件のうち少なくとも一つが満たされればよい場合に便利です。また、デフォルト値の設定などにも応用できます（例:value or default_value`）。
論理否定 (not):
not expr の形式で使われる単項演算子です。expr の論理値を反転させます。
python print(not True) # False print(not False) # True print(not 0) # True (0 は論理的にFalseとみなされるため) print(not 10) # False (10 は論理的にTrueとみなされるため) print(not "") # True ("" は論理的にFalseとみなされるため) print(not "abc") # False ("abc" は論理的にTrueとみなされるため)
not 演算子は、条件を反転させたい場合に使用します。

3.5. ビット演算子 (Bitwise Operators)

ビット演算子は、整数を二進数のビット列として扱い、各ビットに対して論理操作やシフト操作を行います。主に低レベルな操作や特定のアルゴリズム（例: ビットマスク、暗号化、データ圧縮）で使用されます。

演算子	名称	説明	例	10進結果
`&`	ビット論理積	両方のビットが 1 の場合に 1	`5 & 3`	`1`
`\|`	ビット論理和	どちらかのビットが 1 の場合に 1	`5 \| 3`	`7`
`^`	ビット排他的論理和	いずれか一方のビットが 1 の場合に 1 (両方同じなら 0)	`5 ^ 3`	`6`
`~`	ビット否定	各ビットを反転 (0 は 1 に, 1 は 0 に)。符号付き整数では補数表現に依存。	`~5`	`-6`
`<<`	左シフト	ビットを指定された数だけ左にシフト。右側は 0 で埋められる。	`5 << 1`	`10`
`>>`	右シフト	ビットを指定された数だけ右にシフト。左側の埋め方は符号によって異なる。	`5 >> 1`	`2`

例 (5 & 3 の計算):
– 5 の二進数表現 (例えば 8ビットで考える): 0000 0101
– 3 の二進数表現 (例えば 8ビットで考える): 0000 0011
– 各ビットごとに AND を適用:
– 0 & 0 = 0
– 0 & 0 = 0
– 0 & 0 = 0
– 0 & 0 = 0
– 0 & 0 = 0
– 1 & 0 = 0
– 0 & 1 = 0
– 1 & 1 = 1
– 結果の二進数: 0000 0001 -> 10進数で 1

詳細と使い方:

ビット論理積 (&):
対応する両方のビットが 1 の場合にのみ結果のビットが 1 になります。
python print(5 & 3) # 1 ( 0101 & 0011 -> 0001 ) print(10 & 12) # 8 ( 1010 & 1100 -> 1000 )
ビット論理和 (|):
対応するどちらかのビットが 1 の場合に結果のビットが 1 になります。
python print(5 | 3) # 7 ( 0101 | 0011 -> 0111 ) print(10 | 12) # 14 ( 1010 | 1100 -> 1110 )
ビット排他的論理和 (^):
対応するビットがいずれか一方のみ 1 の場合に結果のビットが 1 になります（両方同じ場合は 0）。
python print(5 ^ 3) # 6 ( 0101 ^ 0011 -> 0110 ) print(10 ^ 12) # 6 ( 1010 ^ 1100 -> 0110 )
ビット否定 (~):
オペランドの各ビットを反転させます。Pythonでは符号付き整数は通常2の補数表現で扱われます。したがって、~x の結果は -(x + 1) となります。
python print(~5) # -(5 + 1) = -6 print(~-10) # -(-10 + 1) = -(-9) = 9
この挙動は、基盤となるシステムの整数表現に依存しますが、Pythonでは一貫して -(x + 1) の結果を返します。
左シフト (<<):
オペランドのビットを指定された数だけ左にシフトします。右側にシフトする数だけ 0 が埋められます。これはオペランドに 2 ** シフト数 を乗算することと等価です (x << y は x * (2 ** y))。
python print(5 << 1) # 10 ( 0101 << 1 -> 1010 ) print(5 << 2) # 20 ( 0101 << 2 -> 10100 ) print(-10 << 1) # -20 ( -10 * 2**1 = -20 )
負の数に対する左シフトは、数学的な乗算と同じ結果になります。
右シフト (>>):
オペランドのビットを指定された数だけ右にシフトします。正の数の場合、左側には 0 が埋められます。負の数の場合、左側の埋め方は実装依存ですが、通常は符号ビット（最左ビット）がコピーされます（算術右シフト）。これはオペランドを 2 ** シフト数 でフロア除算することとほぼ等価です (x >> y は x // (2 ** y))。
python print(10 >> 1) # 5 ( 1010 >> 1 -> 0101 ) print(10 >> 2) # 2 ( 1010 >> 2 -> 0010 ) print(-10 >> 1) # -5 ( -10 // 2**1 = -5 ) print(-10 >> 2) # -3 ( -10 // 2**2 = -3 )
負の数に対する右シフトは、数学的な除算とは異なり、結果が負の無限大方向に切り捨てられるフロア除算と同じ挙動になります。

ビット演算子は、フラグの管理（各ビットを特定の状態を表すフラグとして使用）、ビットマスクによる特定ビットの抽出や設定、パフォーマンスが重要な計算などに利用されることがあります。

3.6. メンバシップ演算子 (Membership Operators)

メンバシップ演算子は、特定のシーケンス（リスト、タプル、文字列など）やコレクション（セット、辞書）に、特定の値が含まれているかどうかを確認するために使用されます。

演算子	名称	説明	例
`in`	含まれる	左オペランドの値が右オペランドのメンバーである場合に `True`	`'a' in 'abc'`
`not in`	含まれない	左オペランドの値が右オペランドのメンバーでない場合に `True`	`'d' not in 'abc'`

詳細と使い方:

in:
左オペランドの値が、右オペランドで指定されたコレクション内に存在するかどうかをチェックします。
“`python
# 文字列の場合
print(‘H’ in ‘Hello’) # True
print(‘z’ in ‘Hello’) # False
print(‘lo’ in ‘Hello’) # True (部分文字列のチェック)

リストの場合

my_list = [1, 2, 3, 4, 5]
print(3 in my_list) # True
print(10 in my_list) # False

タプルの場合

my_tuple = (10, 20, 30)
print(20 in my_tuple) # True

セットの場合 (高速な検索)

my_set = {1, 2, 3, 4, 5}
print(3 in my_set) # True

辞書の場合 (キーのチェック)

my_dict = {‘a’: 1, ‘b’: 2}
print(‘a’ in my_dict) # True (キー ‘a’ が存在するか)
print(1 in my_dict) # False (値 1 が存在するかではない)
print(‘c’ in my_dict) # False
`` 辞書に対してinを使う場合、キーの存在をチェックします。値の存在をチェックしたい場合は、value in my_dict.values()` を使用しますが、これは辞書のサイズによっては効率が悪い場合があります。
not in:
in 演算子の結果を反転させます。左オペランドの値が右オペランドのコレクション内に存在しない場合に True を返します。
python print('z' not in 'Hello') # True print(10 not in [1, 2, 3]) # True print('a' not in {'a': 1}) # False

メンバシップ演算子は、特定の要素の存在確認を行う際に非常に直感的で読みやすいコードを書くことができます。セットに対する in 演算子はハッシュテーブルの仕組みを利用しているため、リストやタプルよりも高速に要素の存在確認ができます。

3.7. アイデンティティ演算子 (Identity Operators)

アイデンティティ演算子は、二つの変数が同じオブジェクトを参照しているかどうかを調べます。これは値が等しいか (==) を調べるのとは異なります。

演算子	名称	説明	例
`is`	同一である	左オペランドと右オペランドが同じオブジェクトを参照している場合に `True`	`x is y`
`is not`	同一でない	左オペランドと右オペランドが異なるオブジェクトを参照している場合に `True`	`x is not y`

詳細と使い方:

is:
二つの変数がメモリ上で全く同じオブジェクトを指しているかを確認します。Pythonでは、数値や文字列などの特定のイミュータブル（変更不能）なオブジェクトは、値が同じであれば同じオブジェクトとして扱われることがあります（インターニングやキャッシュ）。一方、リストや辞書などのミュータブル（変更可能）なオブジェクトは、たとえ内容が全く同じでも、通常は別々のオブジェクトとして扱われます。
“`python
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b) # True (値は等しい)
print(a is b) # False (aとbは異なるリストオブジェクトを参照)
print(a is c) # True (aとcは同じリストオブジェクトを参照)

x = 10
y = 10
z = 256 # 小さい整数はインターニングされることが多い
w = 257 # 大きい整数は通常インターニングされない

print(x == y) # True
print(x is y) # True (Pythonの実装によっては、小さい整数はインターニングされる)

print(z == 256) # True
print(z is 256) # True (多くの場合)

print(w == 257) # True
print(w is 257) # False (多くの場合、新しいオブジェクトが作られる)

s1 = “Hello”
s2 = “Hello”
s3 = “World”

print(s1 == s2) # True
print(s1 is s2) # True (文字列リテラルもインターニングされることが多い)
print(s1 == s3) # False
print(s1 is s3) # False

n1 = None
n2 = None
print(n1 is n2) # True (Noneはシングルトンなので常に同じオブジェクト)

b1 = True
b2 = True
print(b1 is b2) # True (True/Falseもシングルトン)
``isは、オブジェクトがNoneであるかどうかのチェックによく使われます (if variable is None:のように)。これはvariable == None` よりも推奨される慣用句です。
is not:
is 演算子の結果を反転させます。二つの変数が異なるオブジェクトを参照している場合に True を返します。
python a = [1, 2, 3] b = [1, 2, 3] print(a is not b) # True (aとbは異なるオブジェクト) print(a is not a) # False (a自身とは同じオブジェクト)

3.8. その他の演算子

Pythonには上記以外にも特定の用途で使われる演算子があります。

三項演算子 (Conditional Expression):
条件に基づいて二つの値のうち一方を選択する際に使用します。構文は value_if_true if condition else value_if_false です。これは他の言語の三項演算子（condition ? value_if_true : value_if_false）に相当します。
“`python
age = 20
status = “Adult” if age >= 18 else “Minor”
print(status) # Adult

score = 75
result = “Pass” if score >= 60 else “Fail”
print(result) # Pass
“`
if-else文よりも簡潔に記述できますが、複雑な条件や処理には向きません。可読性を損なわない範囲で使用するのが良いでしょう。
ウォルラス演算子 (Walrus Operator / Assignment Expression) :=:
Python 3.8で導入された新しい演算子です。式の内部で変数に値を代入することができます。構文は name := expression です。これは name = expression と同時に expression の値を返します。
“`python
# 通常のif文
data = [1, 2, 3, 4, 5]
n = len(data)
if n > 3:
print(f”List is too long ({n} elements)”)

ウォルラス演算子を使った場合

data = [1, 2, 3, 4, 5]
if (n := len(data)) > 3: # len(data) を n に代入しつつ、その値が3より大きいか判定
print(f”List is too long ({n} elements)”)

whileループでの使用例

通常

while True:
line = input(“Enter something (or ‘quit’): “)
if line == ‘quit’:
break
print(f”You entered: {line}”)

ウォルラス演算子

while (line := input(“Enter something (or ‘quit’): “)) != ‘quit’:
print(f”You entered: {line}”)

リスト内包表記での使用例 (Python 3.8+)

通常

filtered_data = []
for x in range(10):
y = x * 2
if y > 10:
filtered_data.append(y)
print(filtered_data)

ウォルラス演算子

filtered_data_walrus = [y for x in range(10) if (y := x * 2) > 10]
print(filtered_data_walrus) # [12, 14, 16, 18]
“`
ウォルラス演算子は、代入と同時に条件判定や値の使用を行いたい場合にコードをより短く、時には効率的に記述できます。ただし、濫用すると可読性を損なう可能性があるため、適切に使用することが推奨されます。

4. 演算子の優先順位と結合規則 (Operator Precedence and Associativity)

複数の演算子が一つの式に含まれる場合、Pythonは演算子の優先順位に従って評価の順番を決定します。優先順位が高い演算子ほど先に評価されます。優先順位が同じ演算子が連続する場合は、結合規則（左結合または右結合）に従って評価されます。

以下は、一般的なPython演算子の優先順位を高いものから低いものへ並べた表です（完全なリストではありませんが、よく使われるものを網羅しています）。同じ行にある演算子は同じ優先順位を持ちます。

優先順位	演算子	説明	結合規則
最も高い	`()`	括弧 (式をグループ化)	–
	`[]`, `.`	リスト、タプルなどのインデックス/スライス、属性参照	左
	`f(args...)`	関数呼び出し	左
	`**`	累乗	右
	`+x`, `-x`, `~x`	単項プラス、マイナス、ビット否定	右
	`*`, `/`, `//`, `%`	乗算、除算、フロア除算、剰余	左
	`+`, `-`	加算、減算	左
	`<<`, `>>`	ビット左シフト、右シフト	左
	`&`	ビット論理積	左
	`^`	ビット排他的論理和	左
	`\|`	ビット論理和	左
	`==`, `!=`, `>`, `<`, `>=`, `<=`	比較演算子	左
	`is`, `is not`	アイデンティティ演算子	左
	`in`, `not in`	メンバシップ演算子	左
	`not`	論理否定	右
	`and`	論理積	左
	`or`	論理和	左
最も低い	`=`	代入 (+=, -= など複合代入も含む)	右
	`:=`	ウォルラス演算子 (代入式)	右

優先順位の例:

python print(2 + 3 * 4) # 乗算 (*) が加算 (+) より優先 -> 2 + (3 * 4) = 2 + 12 = 14 print((2 + 3) * 4) # 括弧 () で加算を先に評価 -> (5) * 4 = 20 print(10 / 2 + 3) # 除算 (/) が加算 (+) より優先 -> (10 / 2) + 3 = 5.0 + 3 = 8.0 print(2 ** 3 ** 2) # 累乗 (**) は右結合 -> 2 ** (3 ** 2) = 2 ** 9 = 512 print(-2 ** 2) # 単項マイナス (-) は累乗 (**) より優先順位が低い -> -(2 ** 2) = -(4) = -4 print((-2) ** 2) # 括弧で優先順位を変更 -> (-2) * (-2) = 4 print(True or False and True) # 論理積 (and) が論理和 (or) より優先 -> True or (False and True) -> True or False -> True

結合規則:

同じ優先順位を持つ演算子が連続する場合、結合規則によって評価順序が決まります。
* 左結合: 式は左から右へと評価されます。例えば、a - b - c は (a - b) - c と解釈されます。算術演算子のほとんど、比較演算子、ビット論理演算子、メンバシップ演算子、アイデンティティ演算子は左結合です。
* 右結合: 式は右から左へと評価されます。例えば、a ** b ** c は a ** (b ** c) と解釈されます。累乗 (**)、単項演算子 (-, +, ~, not)、代入演算子 (=, += など)、ウォルラス演算子 (:=) は右結合です。

注意点:
* 演算子の優先順位を暗記するよりも、括弧 (()) を使用して意図を明確にすることを強く推奨します。括弧は最も高い優先順位を持つため、評価順序を自由に制御できます。括弧を使うことで、コードの可読性が向上し、間違いを防ぐことができます。
* 特に複雑な式では、迷わず括弧を使用しましょう。

5. 演算子のオーバーロード (Operator Overloading)

Pythonでは、クラスを定義する際に特殊メソッド（マジックメソッドやダンダーメソッドとも呼ばれます）を定義することで、組み込みの演算子をカスタムオブジェクトに対して使用できるようになります。これを演算子のオーバーロードと呼びます。

例えば、二つのカスタムオブジェクトを加算したい場合に、そのクラスに __add__ という名前の特殊メソッドを定義することで、+ 演算子をそのクラスのインスタンスに対して使えるようになります。

演算子	特殊メソッド
`+`	`__add__(self, other)`
`-`	`__sub__(self, other)`
`*`	`__mul__(self, other)`
`/`	`__truediv__(self, other)`
`//`	`__floordiv__(self, other)`
`%`	`__mod__(self, other)`
`**`	`__pow__(self, other[, modulo])`
`<<`	`__lshift__(self, other)`
`>>`	`__rshift__(self, other)`
`&`	`__and__(self, other)`
`\|`	`__or__(self, other)`
`^`	`__xor__(self, other)`
`~`	`__invert__(self)`
`<`	`__lt__(self, other)`
`<=`	`__le__(self, other)`
`==`	`__eq__(self, other)`
`!=`	`__ne__(self, other)`
`>`	`__gt__(self, other)`
`>=`	`__ge__(self, other)`
`+=`	`__iadd__(self, other)` (インプレース加算)
`=`	`__setitem__` (`obj[key] = value`) / `__setattr__` (`obj.attr = value`) など
`in`	`__contains__(self, item)`
`len()`	`__len__(self)` (組み込み関数だが演算子的な挙動)
`str()`	`__str__(self)` / `__repr__(self)`

演算子オーバーロードの簡単な例:

座標を表すクラスを作成し、+ 演算子を使って二つの座標を加算できるようにします。

“`python
class Point:
def init(self, x, y):
self.x = x
self.y = y

# + 演算子をオーバーロード
def __add__(self, other):
    if isinstance(other, Point):
        # Pointオブジェクト同士の加算
        return Point(self.x + other.x, self.y + other.y)
    elif isinstance(other, (int, float)):
        # 数値との加算 (各座標に数値を加算)
        return Point(self.x + other, self.y + other)
    else:
        # サポートされていない型との演算
        return NotImplemented # または TypeError を発生させる

# 文字列変換 (print() などで表示される形式)
def __str__(self):
    return f"Point({self.x}, {self.y})"

# 開発者向けの文字列変換 (REPLなどで表示される形式)
def __repr__(self):
    return f"Point({self.x}, {self.y})"

Pointオブジェクトを作成

p1 = Point(1, 2)
p2 = Point(3, 4)

+ 演算子で加算 (add メソッドが呼び出される)

p3 = p1 + p2
print(p3) # Point(4, 6)

数値との加算

p4 = p1 + 5
print(p4) # Point(6, 7)

異なる型の加算 (エラーまたはNotImplemented)

p5 = p1 + “abc” # TypeError が発生する

“`
このように、特殊メソッドを定義することで、カスタムオブジェクトに対してもPythonの標準的な演算子を自然な形で適用できるようになります。これは、数学的なオブジェクト（ベクトル、行列など）、単位を持つ値、カスタムコンテナなど、様々なデータ型を扱う際に非常に強力な機能です。

6. よくある間違いと注意点

Pythonの演算子を使う上で、特に初心者が陥りやすい間違いや知っておくべき注意点があります。

= (代入) と == (比較) の混同:
これは非常に一般的な間違いです。= は変数に値を割り当てるものであり、== は二つの値が等しいかを比較するものです。
python x = 10 # xに10を代入 if x == 10: # xが10と等しいか比較 print("x is 10")
間違えて if x = 10: と書いてしまうと、PythonではSyntaxErrorになるため、コンパイル時に検出されますが、他の言語ではバグの原因となることがあります。Pythonの場合はエラーになるので比較的安全ですが、意識しておくことは重要です。
浮動小数点数の比較:
前述の通り、浮動小数点数は内部的に正確に表現できない場合があるため、== を使った厳密な等価性比較は避けるべきです。
“`python
result = 0.1 + 0.2
print(result == 0.3) # False になる可能性がある

許容誤差を考慮した比較

epsilon = 1e-9 # 非常に小さい値
print(abs(result – 0.3) < epsilon) # True になる
“`
decimalモジュールを使うか、許容誤差を設けるなどの対策が必要です。
ミュータブルオブジェクトに対する is の使用:
リストや辞書のようなミュータブルなオブジェクトに対して is を使うと、内容が全く同じでも別のオブジェクトであれば False になります。オブジェクトの同一性を確認したいのか、それとも値の等価性を確認したいのかを明確にすることが重要です。
“`python
list1 = [1, 2, 3]
list2 = list1 # 同じオブジェクトを参照
list3 = list([1, 2, 3]) # 別の新しいオブジェクトを作成

print(list1 is list2) # True
print(list1 is list3) # False (内容が同じでも別オブジェクト)
print(list1 == list3) # True (内容は等しい)
“`
短絡評価の理解不足:
and や or の短絡評価は、意図しない副作用を引き起こす可能性があります。特に、関数の呼び出しや複雑な式の評価が含まれる場合に注意が必要です。
“`python
def process_data(data):
if data is not None and len(data) > 0: # dataがNoneでないことを確認してからlen()を呼び出す
print(“Processing data…”)
# データの処理
else:
print(“No data to process.”)

process_data(None) # data is not None が False なので len(data) は呼び出されない
process_data([]) # data is not None が True だが len([]) > 0 が False なので処理は行われない
process_data([1, 2]) # 両方 True なので処理が実行される
``andの左辺がFalse、orの左辺がTrue` と評価される場合、右辺は評価されません。この挙動を利用して、エラーを防いだり、不必要な処理をスキップさせたりすることができます。
演算子の優先順位の間違い:
前述の優先順位の表は重要ですが、全てを暗記するよりも、括弧を使って評価順序を明示する習慣をつけましょう。特に算術演算子と論理演算子が混在する式では注意が必要です。
“`python
# 誤解しやすい例
# x and y or z は (x and y) or z と解釈される (andがorより高いため)
# x or y and z は x or (y and z) と解釈される

意図を明確にするために括弧を使う

if (a > 10 and b < 20) or c == 0:
pass
“`
ミュータブルなオブジェクトに対する *= や += の注意:
リストに対する *= は list.extend(list * n) に相当し、新しいリストオブジェクトは作成されません。また、+= も list.extend() に相当し、元のリストを変更します。文字列などのイミュータブルなオブジェクトの場合は常に新しいオブジェクトが作成されます。この違いを理解していないと、予期しない結果になることがあります。

“`python
list_a = [1, 2]
list_b = list_a # 同じオブジェクトを参照
list_a += [3, 4] # list_aが変更される (extend)
print(list_a) # [1, 2, 3, 4]
print(list_b) # [1, 2, 3, 4] (list_bも同じオブジェクトを見ているため影響を受ける)

str_a = “Hello”
str_b = str_a
str_a += “World” # 新しい文字列オブジェクトが作成され、str_aがそれを参照
print(str_a) # HelloWorld
print(str_b) # Hello (str_bは元のオブジェクトを参照し続けている)
“`

これらの注意点を意識することで、より堅牢で理解しやすいPythonコードを書くことができます。

7. まとめ

この記事では、Pythonにおける様々な演算子について、その種類、使い方、そして重要な注意点まで詳しく解説しました。

算術演算子で数値計算を行い、文字列やリストの結合・繰り返しもできます。
代入演算子で変数に値を格納・更新します。複合代入演算子でコードを簡潔にできます。
比較演算子で値の関係を判定し、結果はブール値になります。比較演算子は連鎖させることが可能です。
論理演算子 (and, or, not) でブール値を操作し、条件分岐や繰り返し処理の判断に使われます。短絡評価の挙動を理解することが重要です。
ビット演算子で整数のビットレベルの操作を行います。
メンバシップ演算子 (in, not in) でコレクション内の要素の存在を確認します。
アイデンティティ演算子 (is, is not) でオブジェクトの同一性を確認します。== との違いを理解しましょう。
三項演算子で簡単な条件分岐を一行で記述できます。
ウォルラス演算子 (:=) で式の途中で代入を行うことができます (Python 3.8以降)。
複数の演算子を含む式では、演算子の優先順位と結合規則に従って評価順序が決まりますが、迷う場合は積極的に括弧 () を使用して意図を明確にしましょう。
演算子のオーバーロードにより、カスタムオブジェクトに対して組み込み演算子を適用させることができます。

演算子はPythonプログラミングの基礎であり、これらの要素を適切に組み合わせることで、あらゆる種類のプログラムを記述することができます。この記事で学んだ知識を活かして、より表現力豊かで効率的なPythonコードを作成できるようになることを願っています。

実際に様々な演算子を使ったコードを書いて、それぞれの挙動を体験してみてください。特に、異なるデータ型に対する演算や、優先順位に関する実験は、理解を深めるのに役立ちます。Pythonの演算子の世界を探求し、コーディングスキルをさらに向上させましょう！

Python 演算子とは？種類と使い方を徹底解説

1. 演算子とは？Pythonにおける役割

演算子とオペランドの例

2. Pythonの演算子の種類

3. 各演算子の詳細解説

3.1. 算術演算子 (Arithmetic Operators)

3.2. 代入演算子 (Assignment Operators)

3.3. 比較演算子 (Comparison Operators)

文字列の比較 (辞書順)

リストの比較 (要素を順に比較)

異なる型の比較は基本的にエラー (TypeError)

print(10 > “Hello”) # TypeError

3.4. 論理演算子 (Logical Operators)

短絡評価の例

出力: False

出力: func2 called

True

True/False以外の値に対するand

Pythonでは、以下の値は論理的にFalseとみなされます:

None, False, 数値の 0 (int, float, complex), 空のシーケンス (”, [], ()), 空のマップ ({}), 空のセット (set())

上記以外の値は論理的にTrueとみなされます。

短絡評価の例

出力: True

出力: func4 called

False

True/False以外の値に対するor

3.5. ビット演算子 (Bitwise Operators)

3.6. メンバシップ演算子 (Membership Operators)

リストの場合

タプルの場合

セットの場合 (高速な検索)

辞書の場合 (キーのチェック)

3.7. アイデンティティ演算子 (Identity Operators)

3.8. その他の演算子

ウォルラス演算子を使った場合

whileループでの使用例

通常

ウォルラス演算子

リスト内包表記での使用例 (Python 3.8+)

通常

ウォルラス演算子

4. 演算子の優先順位と結合規則 (Operator Precedence and Associativity)

5. 演算子のオーバーロード (Operator Overloading)

Pointオブジェクトを作成

+ 演算子で加算 (add メソッドが呼び出される)

数値との加算

異なる型の加算 (エラーまたはNotImplemented)

p5 = p1 + “abc” # TypeError が発生する

6. よくある間違いと注意点

許容誤差を考慮した比較

意図を明確にするために括弧を使う

7. まとめ

コメントする 返信をキャンセル

コメントする返信をキャンセル