演算子（算術・比較・論理）

# 算術演算子
結果 = 左辺 + 右辺   # 加算
結果 = 左辺 - 右辺   # 減算
結果 = 左辺 * 右辺   # 乗算
結果 = 左辺 / 右辺   # 除算（結果は常に float）
結果 = 左辺 // 右辺  # 切り捨て除算（結果は int）
結果 = 左辺 % 右辺   # 剰余（余り）
結果 = 左辺 ** 右辺  # べき乗

# 比較演算子（結果は True または False）
左辺 == 右辺    # 等値
左辺 != 右辺    # 非等値
左辺 >  右辺    # より大きい
左辺 >= 右辺   # 以上
左辺 <  右辺    # より小さい
左辺 <= 右辺   # 以下
左辺 is 右辺    # 同一オブジェクト
左辺 is not 右辺  # 異なるオブジェクト
値 in シーケンス      # 含まれる
値 not in シーケンス  # 含まれない

# チェーン比較（Python固有）
下限 <= 値 <= 上限   # 範囲チェックを1行で書けます。

# 論理演算子
条件A and 条件B  # 両方が真のとき True
条件A or 条件B   # どちらかが真のとき True
not 条件         # 真偽を反転

演算子	名称	概要
+	加算	左辺と右辺の和を返します。文字列・リストには連結として働きます。
-	減算	左辺から右辺を引いた値を返します。
*	乗算	左辺と右辺の積を返します。文字列・リストには繰り返しとして働きます。
/	除算	左辺を右辺で割った値を返します。整数同士でも結果は常に float になります。
//	切り捨て除算	除算の結果を小数点以下切り捨て（床関数）で返します。負数でも切り捨て方向はゼロではなく負の無限大です。
%	剰余	左辺を右辺で割った余りを返します。
**	べき乗	左辺を右辺乗した値を返します。pow(x, y) と同等です。

演算子	名称	概要
==	等値	左辺と右辺の値が等しいとき True を返します。
!=	非等値	左辺と右辺の値が異なるとき True を返します。
>	より大きい	左辺が右辺より大きいとき True を返します。
>=	以上	左辺が右辺以上のとき True を返します。
<	より小さい	左辺が右辺より小さいとき True を返します。
<=	以下	左辺が右辺以下のとき True を返します。
is	同一性	左辺と右辺が同一のオブジェクトのとき True を返します。値の等値比較には == を使ってください。
is not	非同一性	左辺と右辺が異なるオブジェクトのとき True を返します。
in	包含	値がシーケンス（リスト・文字列・辞書など）に含まれるとき True を返します。
not in	非包含	値がシーケンスに含まれないとき True を返します。

演算子	概要
and	左辺が Falsy なら左辺を、そうでなければ右辺を返します。両辺が True のとき全体が True になります。
or	左辺が Truthy なら左辺を、そうでなければ右辺を返します。どちらかが True のとき全体が True になります。
not	オペランドの真偽を反転して True / False を返します。

算術演算子の基本的な使い方を確認します。/ と // の違いに注目してください。

arithmetic.py

# ドラゴンボールのキャラクターの戦闘力を使って算術演算子を確認します。
goku_power = 9000
vegeta_power = 8000

print(goku_power + vegeta_power)   # 17000（加算）
print(goku_power - vegeta_power)   # 1000（減算）
print(goku_power * 2)              # 18000（乗算）

# /（除算）の結果は整数同士でも float になります。
print(goku_power / vegeta_power)   # 1.125

# //（切り捨て除算）は小数点以下を切り捨てた整数（または float）を返します。
print(goku_power // vegeta_power)  # 1

# %（剰余）で割り切れるかどうかを調べられます。
total_fighters = 23
team_size = 3
print(total_fighters % team_size)  # 2（3で割り切れない）
print(total_fighters // team_size) # 7（チーム数）

# **（べき乗）でスーパーサイヤ人の倍率を計算します。
base_power = 1000
multiplier = 50
super_power = base_power * (multiplier ** 2)
print(super_power)  # 2500000

python3 arithmetic.py
17000
1000
18000
1.125
1
2
7
2500000

比較演算子の基本的な使い方と、== と is の違いを確認します。

comparison.py

# ドラゴンボールのキャラクターの戦闘力を比較します。
goku_power = 9000
frieza_power = 120000

# == と != で値を比較します。
print(goku_power == frieza_power)   # False
print(goku_power != frieza_power)   # True

# > / >= / < / <= で大小を比較します。
print(frieza_power > goku_power)    # True
print(goku_power >= 9000)          # True
print(goku_power < frieza_power)    # True

# is と == の違いを確認します。
# == は値の等値を比較します。is は同一オブジェクトかを確認します。
name_a = "悟空"
name_b = "悟空"
print(name_a == name_b)   # True（値が等しい）
print(name_a is name_b)   # True（短い文字列はPythonが同じオブジェクトを再利用するため）

# None の比較には is を使うのが推奨されます。
hidden_power = None
print(hidden_power is None)      # True（推奨）
print(hidden_power == None)      # True（動くが非推奨）

# in / not in でリストへの包含を確認します。
z_fighters = ["悟空", "ベジータ", "ピッコロ", "クリリン", "トランクス"]
print("悟空" in z_fighters)      # True
print("フリーザ" not in z_fighters)  # True

python3 comparison.py
False
True
True
True
True
True
True
True
True
True

Python固有のチェーン比較を確認します。複数の比較を連続して書くことができます。

chained_comparison.py

# Python では比較演算子をチェーンして範囲チェックを1行で書けます。
# 他の言語では「x >= 1000 and x <= 9000」のように書く必要があります。
goku_power = 5000

# 1行で範囲に含まれるかチェックします。
if 1000 <= goku_power <= 9000:
    print("通常の戦士レベルです")

# 3つ以上の比較もチェーンできます。
a, b, c = 100, 200, 300
print(a < b < c)   # True（100 < 200 かつ 200 < 300）
print(a < b > c)   # False（100 < 200 は True だが 200 > 300 は False）

# 戦闘力によってランクを判定します。
def check_rank(power):
    if power < 1000:
        return "一般人"
    elif 1000 <= power < 10000:
        return "戦士"
    elif 10000 <= power < 100000:
        return "エリート戦士"
    else:
        return "神の領域"

print(check_rank(530))     # 一般人
print(check_rank(8500))    # 戦士
print(check_rank(53000))   # エリート戦士
print(check_rank(150000))  # 神の領域

python3 chained_comparison.py
通常の戦士レベルです
True
False
一般人
戦士
エリート戦士
神の領域

論理演算子の動作を確認します。and / or は短絡評価（ショートサーキット）を行います。

logical.py

# ドラゴンボールの出場資格を論理演算子で判定します。
name = "ベジータ"
power = 8000
is_registered = True

# and: 両方が True のとき True になります。
if power >= 5000 and is_registered:
    print(name, "は天下一武道会に出場できます")

# or: どちらかが True のとき True になります。
is_saiyan = True
is_namekian = False
if is_saiyan or is_namekian:
    print(name, "は異星人です")

# not: 真偽を反転します。
is_villain = False
if not is_villain:
    print(name, "は現在は悪役ではありません")

# 短絡評価（ショートサーキット）の動作を確認します。
# and: 左辺が Falsy なら右辺は評価されません。
# or: 左辺が Truthy なら右辺は評価されません。
# or を使ったデフォルト値パターン
nickname = ""
display_name = nickname or name   # nickname が空文字（Falsy）なので name が使われます。
print("表示名:", display_name)   # 表示名: ベジータ

# and を使った安全なアクセスパターン
stats = {"power": 8000, "speed": 7500}
label = "power" in stats and stats["power"]
print("戦闘力:", label)  # 戦闘力: 8000

python3 logical.py
ベジータ は天下一武道会に出場できます
ベジータ は異星人です
ベジータ は現在は悪役ではありません
表示名: ベジータ
戦闘力: 8000

複合代入演算子（+=, -= など）と演算子の優先順位を確認します。

compound_precedence.py

# 複合代入演算子はよく使うので覚えておくと便利です。
power = 1000
power += 500    # power = power + 500
print(power)    # 1500

power *= 3      # power = power * 3
print(power)    # 4500

power //= 2     # power = power // 2
print(power)    # 2250

power **= 2     # power = power ** 2
print(power)    # 5062500

# 演算子の優先順位: ** が最も高く、論理演算子が最も低い。
# 括弧を使って意図を明確にするのが読みやすいコードの書き方です。
result = 2 + 3 * 4      # 14（* が + より先に計算される）
result2 = (2 + 3) * 4   # 20（括弧内が先に計算される）
print(result, result2)

# 比較演算子は算術演算子より優先度が低い。
# 以下の2行は同じ意味です。
print(3 + 2 >= 5)          # True（5 >= 5）
print((3 + 2) >= 5)        # True（括弧で意図を明示）

python3 compound_precedence.py
1500
4500
2250
5062500
14 20
True
True

よくあるミス1: /と//の混同

/ は浮動小数点除算で、整数同士を割っても必ず float が返ります。// は切り捨て除算で整数が返ります。どちらを使うかを明確にしないと、意図しない float が計算に混入します。

ng_division.py

goku_power = 9000
vegeta_power = 8000

# NG: 整数の商を期待しているが / は float を返す
ratio = goku_power / vegeta_power
print(ratio)        # 1.125（floatが返る）
print(type(ratio))  # <class 'float'>

# インデックスや個数の計算に / を使うとエラーになることがある
total = 23
team_size = 3
teams = total / team_size   # 7.666...
# range(teams) はエラー（float をrangeに渡せない）

python3 ng_division.py
1.125
<class 'float'>

ok_division.py

total = 23
team_size = 3

# 整数の商が欲しいときは // を使います。
teams = total // team_size
remainder = total % team_size
print("チーム数:", teams)     # 7
print("余り:", remainder)     # 2

# rangeに渡せます。
for i in range(teams):
    print("チーム", i + 1)

python3 ok_division.py
チーム数: 7
余り: 2
チーム 1
チーム 2
チーム 3
チーム 4
チーム 5
チーム 6
チーム 7

よくあるミス2: 浮動小数点数の比較で==を使う

浮動小数点数は2進数で近似表現されるため、計算結果がわずかにずれます。0.1 + 0.2 は厳密には 0.3 にならないため、== で比較すると False になります。

ng_float_compare.py

# NG: 浮動小数点数の == 比較
result = 0.1 + 0.2
print(result)          # 0.30000000000000004
print(result == 0.3)   # False（意図と違う）

python3 ng_float_compare.py
0.30000000000000004
False

ok_float_compare.py

import math

result = 0.1 + 0.2

# 許容誤差（epsilon）を使って比較します。
print(abs(result - 0.3) < 1e-9)         # True

# math.isclose() を使う方法もあります。
print(math.isclose(result, 0.3))         # True

# 整数に変換してから比較する方法もあります。
goku_power = 9000.0
print(int(goku_power) == 9000)           # True

python3 ok_float_compare.py
True
True
True

よくあるミス3: 演算子の優先順位ミス

* は + より優先度が高いため、2 + 3 * 4 は (2 + 3) * 4 = 20 ではなく 2 + (3 * 4) = 14 になります。意図した順序で計算させるには括弧を使います。

ng_precedence.py

base_power = 1000
multiplier = 2
bonus = 500

# NG: 優先順位を誤解すると計算結果が変わる
result = base_power + multiplier * bonus   # 1000 + (2 * 500) = 2000（意図が曖昧）
print(result)   # 2000

# 意図が (base_power + multiplier) * bonus なら
intended = (base_power + multiplier) * bonus   # (1000 + 2) * 500 = 501000
print(intended)   # 501000

python3 ng_precedence.py
2000
501000

ok_precedence.py

base_power = 1000
multiplier = 2
bonus = 500

# 括弧を使って意図を明確にします。
result = base_power + (multiplier * bonus)   # 明示的に書く
print(result)   # 2000

result2 = (base_power + multiplier) * bonus
print(result2)  # 501000

# ** は右結合で最も優先度が高い。
print(2 ** 3 ** 2)    # 512（2 ** (3 ** 2) = 2 ** 9）
print((2 ** 3) ** 2)  # 64

python3 ok_precedence.py
2000
501000
512
64

Pythonの算術演算子で特に注意が必要なのは / と // の違いです。/ は整数同士でも必ず float を返します（例: 7 / 2 は 3.5）。整数の商が欲しいときは // を使ってください。また、// は負数に対して「ゼロ方向への切り捨て」ではなく「負の無限大方向への切り捨て」を行います（例: -7 // 2 は -4）。

== と is の使い分けは重要です。値の等値比較には == を使い、is は None との比較や同一オブジェクトの確認に限定して使うのが推奨されます。短い文字列や小さな整数はPythonが内部でキャッシュするため is が True になる場合がありますが、これは実装の詳細であり保証されません。

and / or は True / False を返すのではなく、どちらかのオペランドをそのまま返します。たとえば "" or "デフォルト" は "デフォルト" を返します。この短絡評価の性質を活かして、デフォルト値の設定や安全なアクセスパターンを書くことができます。演算子の優先順位については、複雑な式では括弧を使って意図を明確にしておくと可読性が上がります。