【Python】デコレータの使い方｜基礎から実装まで

def square(x):
    return x * x

# square 関数を引数として map に渡している
result = map(square, [1, 2, 3, 4])
print(list(result))  # [1, 4, 9, 16]

def my_decorator(func):
    def wrapper():
        print("前処理")
        result = func()
        print("後処理")
        return result
    return wrapper

# 1. @記法を使った書き方
@my_decorator
def hello():
    print("こんにちは")

# 2. @記法を使わない場合と等価な書き方
def hello2():
    print("こんにちは")

hello2 = my_decorator(hello2)  # ここでデコレータを適用している

hello()
hello2()

def simple_decorator(func):
    """最もシンプルなデコレータの例"""

    def wrapper(*args, **kwargs):
        # 前処理
        print("関数の前で何かをします")

        # 元の関数を実行
        result = func(*args, **kwargs)

        # 後処理
        print("関数の後で何かをします")

        return result

    return wrapper


@simple_decorator
def greet(name):
    print(f"こんにちは、{name}さん")


greet("太郎")

def debug_print(func):
    """関数の引数と戻り値を表示するデコレータ"""

    def wrapper(*args, **kwargs):
        print(f"[DEBUG] 呼び出し: {func.__name__} args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[DEBUG] 戻り値: {result}")
        return result

    return wrapper


@debug_print
def add(a, b):
    return a + b


add(3, 5)

def repeat(times):
    """指定回数だけ関数を繰り返し実行するデコレータ"""

    def decorator(func):
        def wrapper(*args, **kwargs):
            result = None
            for i in range(times):
                print(f"{i + 1}回目の実行")
                result = func(*args, **kwargs)
            return result

        return wrapper

    return decorator


@repeat(times=3)
def say(message):
    print(message)


say("こんにちは")

def deco1(func):
    def wrapper(*args, **kwargs):
        print("deco1: 前処理")
        result = func(*args, **kwargs)
        print("deco1: 後処理")
        return result
    return wrapper


def deco2(func):
    def wrapper(*args, **kwargs):
        print("deco2: 前処理")
        result = func(*args, **kwargs)
        print("deco2: 後処理")
        return result
    return wrapper


@deco1
@deco2
def process():
    print("メイン処理")


process()

def process():
    print("メイン処理")

process = deco1(deco2(process))

class MathUtil:
    @staticmethod
    def add(a, b):
        """インスタンスに依存しないユーティリティ関数"""
        return a + b


print(MathUtil.add(2, 3))  # 5

obj = MathUtil()
print(obj.add(4, 5))       # 9 (インスタンス経由でも呼べるが、selfは使わない)

class Person:
    default_country = "Japan"

    def __init__(self, name, country=None):
        self.name = name
        self.country = country or Person.default_country

    @classmethod
    def from_japan(cls, name):
        """日本出身のPersonを生成するファクトリメソッド"""
        return cls(name, country="Japan")


p1 = Person("Taro")
p2 = Person.from_japan("Hanako")  # クラスメソッドからインスタンスを生成

print(p1.name, p1.country)  # Taro Japan
print(p2.name, p2.country)  # Hanako Japan

class User:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    @property
    def full_name(self):
        """フルネームを返すプロパティ"""
        return f"{self.last_name} {self.first_name}"


u = User("太郎", "山田")
print(u.full_name)  # メソッド呼び出しではなく属性アクセスに見える

import functools


def no_wraps_decorator(func):
    def wrapper(*args, **kwargs):
        """ラップ用関数(メタデータが上書きされる)"""
        return func(*args, **kwargs)
    return wrapper


def with_wraps_decorator(func):
    @functools.wraps(func)  # ここがポイント
    def wrapper(*args, **kwargs):
        """ラップ用関数(メタデータは元の関数のものを引き継ぐ)"""
        return func(*args, **kwargs)
    return wrapper


@no_wraps_decorator
def original_func1():
    """元の関数1のドキュメンテーション"""
    pass


@with_wraps_decorator
def original_func2():
    """元の関数2のドキュメンテーション"""
    pass


print(original_func1.__name__, original_func1.__doc__)
print(original_func2.__name__, original_func2.__doc__)

import time
import functools


def log_and_time(func):
    """関数の開始・終了ログと実行時間を表示するデコレータ"""

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[LOG] 開始: {func.__name__}")
        start = time.time()

        result = func(*args, **kwargs)

        elapsed = time.time() - start
        print(f"[LOG] 終了: {func.__name__} (経過時間: {elapsed:.4f} 秒)")
        return result

    return wrapper


@log_and_time
def slow_task():
    """時間のかかる処理を模した関数"""
    time.sleep(1.2)
    print("重い処理が完了しました")


slow_task()

import functools


def ensure_positive(func):
    """すべての数値引数が0以上であることを確認するデコレータ"""

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 位置引数をチェック
        for value in args:
            if isinstance(value, (int, float)) and value < 0:
                raise ValueError(f"負の値は許可されていません: {value}")

        # キーワード引数をチェック
        for key, value in kwargs.items():
            if isinstance(value, (int, float)) and value < 0:
                raise ValueError(f"引数 {key} に負の値は許可されていません: {value}")

        return func(*args, **kwargs)

    return wrapper


@ensure_positive
def deposit(balance, amount):
    """残高に入金額を足して返す関数"""
    return balance + amount


print(deposit(100, 50))
# print(deposit(100, -10))  # これを有効にするとエラーが発生する

import functools


def simple_cache(func):
    """引数に対する戻り値をキャッシュする簡易デコレータ"""

    cache = {}

    @functools.wraps(func)
    def wrapper(*args):
        if args in cache:
            print(f"[CACHE HIT] args={args}")
            return cache[args]

        print(f"[CACHE MISS] args={args}")
        result = func(*args)
        cache[args] = result
        return result

    return wrapper


@simple_cache
def slow_add(a, b):
    """時間のかかる加算処理を模した関数"""
    import time
    time.sleep(1)  # わざと遅くする
    return a + b


print(slow_add(2, 3))  # 初回は遅い
print(slow_add(2, 3))  # 2回目はキャッシュから即返る

import functools


# 疑似的な「現在のユーザー情報」
class CurrentUser:
    def __init__(self, name, is_authenticated, role):
        self.name = name
        self.is_authenticated = is_authenticated
        self.role = role


current_user = CurrentUser("taro", is_authenticated=True, role="admin")


def login_required(func):
    """ログインしているユーザーだけが実行できるようにするデコレータ"""

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            raise PermissionError("ログインが必要です")
        return func(*args, **kwargs)

    return wrapper


def require_role(role):
    """特定の権限(ロール)を要求するデコレータ"""

    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if current_user.role != role:
                raise PermissionError(f"{role} 権限が必要です")
            return func(*args, **kwargs)

        return wrapper

    return decorator


@login_required
@require_role("admin")
def delete_user(user_id):
    """ユーザーを削除する管理者専用処理"""
    print(f"ユーザー {user_id} を削除しました")


delete_user(123)

def add_repr(cls):
    """__repr__ メソッドを自動実装するクラスデコレータ"""

    def __repr__(self):
        attrs = ", ".join(
            f"{name}={value!r}"
            for name, value in self.__dict__.items()
        )
        return f"{cls.__name__}({attrs})"

    # クラスに __repr__ メソッドを追加する
    setattr(cls, "__repr__", __repr__)
    return cls


@add_repr
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y


p = Point(1, 2)
print(p)  # __repr__ が自動で付与されている