Pythonのassert文でバグを早期発見する基本と使い方

# 0で割らないという前提をassertで明示する例
def inverse(n: float) -> float:
    assert n != 0, "nは0以外である必要があります"
    return 1 / n

print(inverse(2))
print(inverse(0))  # ここでAssertionError

# 例: 条件が成り立つ場合は何も起きずに先へ進みます
x = 5
assert x > 0, "xは正の数である必要があります"
print("OK")  # 到達します

# 例: 条件が偽だとAssertionError
y = -1
assert y > 0, f"yは正の数である必要がありますが、{y}でした"
print("この行は実行されません")

# 価格と割引率の前提をassertで明示
def apply_discount(price: float, rate: float) -> float:
    # 型や値域の前提
    assert isinstance(price, (int, float)), "priceは数値である必要があります"
    assert price >= 0, f"priceは0以上のはずですが、{price}でした"
    assert 0.0 <= rate <= 1.0, f"rateは0.0〜1.0のはずですが、{rate}でした"
    return float(price) * (1.0 - float(rate))

print(apply_discount(1000, 0.2))  # OK
print(apply_discount(-100, 0.2))  # 前提違反

# 戻り値が0.0〜1.0に収まることを後条件として保証
def clamp01(x: float) -> float:
    if x < 0.0:
        x = 0.0
    if x > 1.0:
        x = 1.0
    assert 0.0 <= x <= 1.0, "clamp01の戻り値は0.0〜1.0の範囲のはず"
    return x

print(clamp01(1.2))
print(clamp01(-0.5))

# ソート済みかつ重複なしという性質を後条件で確認
def sorted_unique(nums: list[int]) -> list[int]:
    result = sorted(set(nums))
    # ソート済みであること(恒真に見えるが、実装変更時の崩れ検知に効く)
    assert result == sorted(result), "戻り値は昇順である必要があります"
    return result

print(sorted_unique([3, 1, 2, 2]))

# 非負の数列を加算していくと合計は常に非負のはず、という不変条件
def sum_non_negative(seq: list[int]) -> int:
    total = 0
    for i, n in enumerate(seq, start=1):
        total += n
        assert total >= 0, f"合計は非負のはずが負になりました(index={i}, total={total})"
    return total

print(sum_non_negative([3, 2, 1]))      # OK
print(sum_non_negative([3, -5, 4]))     # 不変条件違反

def handle_status(status: str) -> str:
    if status == "ok":
        return "処理完了"
    elif status == "retry":
        return "再試行します"
    elif status == "fail":
        return "失敗しました"
    # ここに来るのは想定外
    assert False, f"未知のstatusを検知しました: {status}"

print(handle_status("ok"))
print(handle_status("unknown"))  # 想定外

def factorial(n: int) -> int:
    assert n >= 0, "nは0以上"
    result = 1
    for i in range(2, n + 1):
        result *= i
    # 後条件: 常に正の整数
    assert result > 0, "factorialの戻り値は正の整数のはず"
    return result

# 簡易自己検査
assert factorial(0) == 1
assert factorial(5) == 120

print("__debug__ =", __debug__)
assert False, "このassertはデフォルトでは発火します"
print("ここまで到達したらassertは無効化されています")

def read_age(text: str) -> int:
    if not text.isdecimal():
        raise ValueError(f"年齢は整数である必要があります: {text}")
    age = int(text)
    if not (0 <= age <= 130):
        raise ValueError(f"年齢の範囲が不正です: {age}")
    return age

print(read_age("25"))
print(read_age("二十"))  # ValueErrorで適切に通知

# ファイル読み込みは失敗が想定内 → try-exceptで処理
try:
    with open("config.json", "r", encoding="utf-8") as f:
        config = f.read()
except FileNotFoundError:
    config = "{}"  # 既定値で継続

# 一方で、到達不能分岐は想定外 → assertで停止
state = "unknown"
assert state in {"init", "running", "stopped"}, f"未知の状態: {state}"

# 悪い例: -Oだとinsertが呼ばれず、データが保存されません
def add_user_bad(db, user):
    assert db.insert(user) == 1, "1件だけ挿入されるはず"

# 良い例: 必須処理はassertの外で実行し、結果だけ検査する
def add_user_good(db, user):
    affected = db.insert(user)  # これは常に実行される
    assert affected == 1, f"挿入件数が想定外: {affected}"

def withdraw(balance: int, amount: int) -> int:
    assert amount > 0, f"amountは正の整数のはずですが、{amount}でした"
    assert balance >= amount, f"残高不足 balance={balance}, amount={amount}"
    return balance - amount

def process(data: list[int]) -> int:
    # 本処理
    total = sum(data)

    # デバッグ時のみ重い整合性検査を実行
    if __debug__:
        # 例えばO(n)の重い検査
        assert all(isinstance(x, int) for x in data), "dataにはintのみのはず"

    return total

# 常時必要な検証
def load_port(env: dict) -> int:
    port_s = env.get("PORT")
    if port_s is None:
        raise RuntimeError("PORTが設定されていません")
    port = int(port_s)
    if not (0 < port < 65536):
        raise ValueError(f"PORTの範囲が不正: {port}")
    return port

# 内部前提の検査
def start_server(port: int) -> None:
    assert 0 < port < 65536, f"無効なport: {port}"
    print(f"Listening on {port}")

start_server(load_port({"PORT": "8080"}))

import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")

def compute_ratio(part: int, whole: int) -> float:
    if whole == 0:
        logging.error("wholeが0。入力: part=%s, whole=%s", part, whole)
        raise ZeroDivisionError("wholeは0以外である必要があります")
    ratio = part / whole
    logging.debug("ratio=%s", ratio)
    # 内部前提(比は0.0〜1.0に収まる設計)を確認
    assert 0.0 <= ratio <= 1.0, f"比が範囲外: ratio={ratio}, part={part}, whole={whole}"
    return ratio

print(compute_ratio(2, 5))