【Python】try exceptエラー処理パターン集｜よくある落とし穴とベストプラクティス

# 基本的なtry except構文の例

try:
    # 例外(エラー)が起きるかもしれない処理
    x = int(input("整数を入力してください: "))
    result = 10 / x
    print("計算結果:", result)

except ZeroDivisionError:
    # 0で割ったときのエラー処理
    print("0で割ることはできません")

except ValueError:
    # 整数に変換できない入力のエラー処理
    print("整数を入力してください")

# ここはエラーの有無に関わらず実行される
print("プログラム終了")

# さまざまな例外クラスを意図的に発生させる例

def cause_exceptions():
    # ValueError: intに変換できない文字列
    int("abc")

    # TypeError: 整数と文字列を足そうとする
    1 + "2"

    # IndexError: 存在しないインデックスにアクセス
    lst = [1, 2, 3]
    lst[5]

    # KeyError: 存在しないキーにアクセス
    d = {"a": 1}
    d["b"]

# 実行してみると、最初のValueErrorで処理が止まります
try:
    cause_exceptions()
except Exception as e:
    print("何らかの例外が発生しました:", type(e).__name__, e)

# elseとfinallyの動きを確認する例

def divide(a, b):
    try:
        print("try: 計算を開始します")
        result = a / b
    except ZeroDivisionError:
        print("except: 0では割れません")
    else:
        # 例外が発生しなかったときだけ実行される
        print("else: 正常に計算できました。結果:", result)
    finally:
        # 例外の有無にかかわらず必ず実行される
        print("finally: 後処理を行います")

print("------ 1回目 (正常) ------")
divide(10, 2)

print("------ 2回目 (0で割る) ------")
divide(10, 0)

# 単純なtry/exceptパターンの例

def read_int():
    s = input("整数を入力してください: ")
    try:
        value = int(s)
    except ValueError:
        # 不正な入力だった場合のフォールバック
        print("整数ではないため、0を返します")
        value = 0
    return value

num = read_int()
print("読み取った整数:", num)

# try/except/elseパターンの例

def load_config(path):
    try:
        # ファイルを開く(ここで例外が起きる可能性が高い)
        f = open(path, "r", encoding="utf-8")
    except FileNotFoundError:
        print("設定ファイルが見つかりません:", path)
        return {}
    else:
        # ファイルが正常に開けたときだけ実行される処理
        with f:
            import json
            return json.load(f)

config = load_config("config.json")
print("設定:", config)

# try/except/finallyパターンの例

def write_log(path, text):
    f = None
    try:
        f = open(path, "a", encoding="utf-8")
        f.write(text + "\n")
    except OSError as e:
        print("ログの書き込みに失敗しました:", e)
    finally:
        # ファイルオブジェクトが存在する場合のみ閉じる
        if f is not None:
            f.close()

write_log("app.log", "アプリケーションを開始しました")

import requests

def fetch_json(url, timeout=5.0):
    try:
        # タイムアウト付きでGETリクエストを送信
        response = requests.get(url, timeout=timeout)

        # HTTPステータスコードが4xx/5xxなら例外を発生させる
        response.raise_for_status()

        # JSONとして解析
        return response.json()

    except requests.exceptions.Timeout:
        print("タイムアウトしました:", url)
        return None

    except requests.exceptions.ConnectionError:
        print("接続エラーが発生しました:", url)
        return None

    except requests.exceptions.HTTPError as e:
        # ステータスコードによってメッセージを変えるなども可能
        print("HTTPエラー:", e.response.status_code, e)
        return None

    except ValueError:
        # response.json() でJSONデコードに失敗した場合
        print("レスポンスをJSONとして解析できませんでした")
        return None

data = fetch_json("https://api.example.com/data")
print("取得データ:", data)

# 安全な整数変換関数の例

def to_int(value, default=0):
    """
    与えられた値をintに変換します。
    変換できない場合はdefaultを返します。
    """
    try:
        return int(value)
    except (ValueError, TypeError):
        # ValueError: "abc" のような文字列
        # TypeError: None やリストなど、int()できない型
        return default

print(to_int("123"))     # 123
print(to_int("abc"))     # 0 (default)
print(to_int(None))      # 0 (default)
print(to_int(3.14))      # 3

# 複数の例外をひとまとめに処理する例

data = {"num": "100"}

try:
    # 存在しないキーでKeyErrorの可能性
    raw = data["value"]
    # 不正な文字列でValueErrorの可能性
    num = int(raw)
    print("結果:", num)

except (KeyError, ValueError, TypeError) as e:
    # どの例外でも同じメッセージとフォールバックを行う
    print("データが不正なため、0として扱います")
    print("詳細な例外クラス:", type(e).__name__)
    num = 0

print("最終的な値:", num)

# カスタム例外クラスの定義と利用例

class AppError(Exception):
    """アプリケーション共通の例外の基底クラス"""
    pass

class ConfigError(AppError):
    """設定ファイルに関するエラー"""
    pass

class ValidationError(AppError):
    """入力値検証に関するエラー"""
    pass


def load_config(path):
    import json
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        # より意味のあるAppError系の例外として包み直す
        raise ConfigError(f"設定ファイルが見つかりません: {path}")
    except json.JSONDecodeError as e:
        raise ConfigError(f"設定ファイルが不正なJSONです: {e}") from e


def process_user_input(name, age_str):
    if not name:
        raise ValidationError("名前は必須です")

    try:
        age = int(age_str)
    except ValueError as e:
        raise ValidationError("年齢は整数で指定してください") from e

    if age < 0:
        raise ValidationError("年齢は0以上である必要があります")

    return {"name": name, "age": age}


def main():
    try:
        config = load_config("config.json")
        print("設定:", config)

        user = process_user_input("Taro", "20")
        print("ユーザー:", user)

    except ValidationError as e:
        print("入力エラー:", e)

    except ConfigError as e:
        print("設定エラー:", e)

    except AppError as e:
        # その他のアプリ固有エラー
        print("アプリケーションエラー:", e)

if __name__ == "__main__":
    main()

# 悪い例: 例外クラスを指定していないexcept

try:
    # 何らかの処理
    do_something()
except:
    # 何が起きてもここに来てしまう
    print("エラーが発生しましたが、無視して続行します")

# まだマシな例: Exceptionを明示的に指定

try:
    do_something()
except Exception as e:
    print("予期せぬエラー:", type(e).__name__, e)
    # 必要に応じてログを出力したり、再送出したりする
    # raise

# 問題になりがちな広すぎるexceptの例

def calculate_discount(price, rate):
    try:
        return price * rate
    except Exception:
        # どんなエラーでも一律0割引にしてしまう
        return 0

print(calculate_discount("1000", 0.1))  # 本来はTypeError

# 最悪の例: 例外を完全に握りつぶす

try:
    risky_operation()
except Exception:
    pass  # 何もせずに黙って無視

import logging

logger = logging.getLogger(__name__)

try:
    risky_operation()
except Exception:
    logger.exception("risky_operationで予期せぬエラーが発生しました")
    # 必要なら再送出も検討
    # raise

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def bad_logging():
    try:
        1 / 0
    except ZeroDivisionError as e:
        # 悪い例: 例外メッセージだけでスタックトレースが残らない
        logger.error("エラーが発生しました: %s", e)

def good_logging():
    try:
        1 / 0
    except ZeroDivisionError:
        # 良い例: logger.exception() は自動的にスタックトレースを含める
        logger.exception("エラーが発生しました")

bad_logging()
good_logging()

# 悪い例: ネストしすぎたtry/except構造

try:
    connect_db()
    try:
        user = load_user()
        try:
            update_user(user)
        except UpdateError as e:
            print("更新エラー:", e)
    except LoadError as e:
        print("読み込みエラー:", e)
except ConnectionError as e:
    print("接続エラー:", e)

# 良い例: 関数に分割し、try/exceptをフラットにする

def connect_and_load():
    connect_db()
    return load_user()

def update_user_safely(user):
    try:
        update_user(user)
    except UpdateError as e:
        print("更新エラー:", e)

def main():
    try:
        user = connect_and_load()
    except ConnectionError as e:
        print("接続エラー:", e)
        return
    except LoadError as e:
        print("読み込みエラー:", e)
        return

    update_user_safely(user)

main()

# 悪い例: 例外時にファイルが閉じられない可能性がある

def write_file(path, text):
    f = open(path, "w", encoding="utf-8")
    try:
        f.write(text)
        risky_operation()  # ここで例外が出るかもしれない
    except Exception as e:
        print("エラー:", e)
        # f.close() を書き忘れるとファイルが開きっぱなしに

# 良い例: finallyで確実にファイルを閉じる

def write_file_safely(path, text):
    f = open(path, "w", encoding="utf-8")
    try:
        f.write(text)
        risky_operation()
    except Exception as e:
        print("エラー:", e)
        # 必要に応じて再送出など
        # raise
    finally:
        f.close()

def inner():
    try:
        dangerous()
    except SpecificError as e:
        log_error(e)
        # ログだけ残して、同じ例外を上へ投げ直す
        raise

def outer():
    try:
        inner()
    except SpecificError:
        handle_error()

class ServiceError(Exception):
    pass

def call_service():
    try:
        low_level_call()
    except TimeoutError as e:
        # より抽象的な例外に包み直す
        raise ServiceError("サービス呼び出しがタイムアウトしました") from e

# with文がない場合

f = open("data.txt", "r", encoding="utf-8")
try:
    data = f.read()
finally:
    f.close()

# with文を使った場合

with open("data.txt", "r", encoding="utf-8") as f:
    data = f.read()

import contextlib
import logging

logger = logging.getLogger(__name__)

@contextlib.contextmanager
def log_exceptions(msg):
    """
    ブロック内で発生した例外をログに残し、再送出するコンテキストマネージャ
    """
    try:
        yield
    except Exception:
        logger.exception(msg)
        raise  # 例外は握りつぶさずにそのまま再送出

def process():
    with log_exceptions("process中にエラーが発生しました"):
        risky_operation()
        another_risky_operation()

import logging

logger = logging.getLogger(__name__)

def low_level():
    try:
        risky_io()
    except OSError:
        # 下位層では詳細なログを残す
        logger.exception("IOエラーが発生しました")
        raise  # 上位層へ再送出

def service():
    try:
        low_level()
    except OSError as e:
        # 必要に応じて業務例外に変換
        raise ServiceError("サービス処理中にエラーが発生しました") from e

def controller():
    try:
        service()
    except ServiceError as e:
        # ユーザー向けに分かりやすいメッセージを表示しつつ、ログも残す
        logger.error("リクエスト処理に失敗しました: %s", e)
        print("しばらくしてから再度お試しください")

# my_module.py
def divide(a, b):
    if b == 0:
        raise ValueError("bは0以外である必要があります")
    return a / b

# test_my_module.py
import unittest
from my_module import divide

class TestDivide(unittest.TestCase):

    def test_divide_normal(self):
        self.assertEqual(divide(10, 2), 5)

    def test_divide_zero_raises(self):
        # ValueErrorが発生することを確認
        with self.assertRaises(ValueError) as cm:
            divide(10, 0)

        # 例外メッセージの内容も確認可能
        self.assertIn("0以外", str(cm.exception))

if __name__ == "__main__":
    unittest.main()