Pythonデコレータ入門！簡単にクラスや関数を拡張するテクニック

@デコレータ名
def 関数名():
    # 関数の処理

def 関数名():
    # 関数の処理

関数名 = デコレータ名(関数名)

import time

def measure_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__}の実行時間: {end_time - start_time:.4f}秒")
        return result
    return wrapper

@measure_time
def slow_function():
    time.sleep(1)  # 1秒待機
    print("処理完了")

# 関数を呼び出し
slow_function()

処理完了
slow_functionの実行時間: 1.0012秒

import time

def measure_time_with_unit(unit='秒'):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            elapsed = end_time - start_time
            
            if unit == 'ミリ秒':
                elapsed *= 1000
                unit_str = 'ミリ秒'
            else:
                unit_str = '秒'
                
            print(f"{func.__name__}の実行時間: {elapsed:.4f}{unit_str}")
            return result
        return wrapper
    return decorator

@measure_time_with_unit(unit='ミリ秒')
def fast_function():
    time.sleep(0.1)  # 0.1秒待機
    print("処理完了")

# 関数を呼び出し
fast_function()

処理完了
fast_functionの実行時間: 100.2341ミリ秒

fast_function = measure_time_with_unit(unit='ミリ秒')(fast_function)

class Person:
    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.first_name} {self.last_name}"

# 使用例
person = Person("田邉", "佳祐")
print(person.full_name)  # メソッドのように()をつけずに呼び出せる

田邉 佳祐

import functools
import time

@functools.lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    print(f"fibonacci({n})を計算中...")
    time.sleep(0.1)  # 計算に時間がかかると仮定
    return fibonacci(n-1) + fibonacci(n-2)

# 最初の呼び出し
print("最初の呼び出し：")
result = fibonacci(10)
print(f"結果: {result}")

# 2回目の呼び出し
print("\n2回目の呼び出し：")
result = fibonacci(10)
print(f"結果: {result}")

最初の呼び出し：
fibonacci(10)を計算中...
fibonacci(9)を計算中...
fibonacci(8)を計算中...
...
結果: 55

2回目の呼び出し：
結果: 55

class MathOperations:
    @classmethod
    def add_numbers(cls, a, b):
        print(f"{cls.__name__}クラスのメソッドを使用中")
        return a + b
    
    @staticmethod
    def multiply_numbers(a, b):
        print("これはインスタンスに依存しないメソッドです")
        return a * b

# クラスから直接呼び出し可能
print(MathOperations.add_numbers(5, 3))
print(MathOperations.multiply_numbers(5, 3))

import logging
logging.basicConfig(level=logging.INFO)

def log_function_call(func):
    def wrapper(*args, **kwargs):
        logging.info(f"{func.__name__}が呼び出されました。引数: {args}, {kwargs}")
        try:
            result = func(*args, **kwargs)
            logging.info(f"{func.__name__}が正常に完了しました。戻り値: {result}")
            return result
        except Exception as e:
            logging.error(f"{func.__name__}でエラーが発生しました: {e}")
            raise
    return wrapper

@log_function_call
def divide(a, b):
    return a / b

# 関数の使用
try:
    result = divide(10, 2)
    print(f"結果: {result}")
    
    result = divide(10, 0)  # エラーが発生
    print(f"結果: {result}")  # ここは実行されない
except Exception as e:
    print(f"エラーをキャッチ: {e}")

def require_auth(func):
    def wrapper(request, *args, **kwargs):
        if not request.user.is_authenticated:
            return redirect('login')
        return func(request, *args, **kwargs)
    return wrapper

@require_auth
def user_profile(request):
    # ユーザープロファイルページの処理
    return render(request, 'profile.html')

import time
from functools import wraps

def rate_limit(max_calls, period=60):
    """
    指定された期間内の最大呼び出し回数を制限するデコレータ
    """
    calls = {}
    
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 呼び出し元を識別（簡易版）
            caller_id = str(args[0]) if args else "default"
            
            current_time = time.time()
            call_history = calls.get(caller_id, [])
            
            # 古い履歴を削除
            call_history = [t for t in call_history if current_time - t < period]
            
            if len(call_history) >= max_calls:
                raise Exception(f"レート制限を超えました。{period}秒あたり{max_calls}回までです。")
            
            call_history.append(current_time)
            calls[caller_id] = call_history
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(max_calls=3, period=10)
def api_request(user_id):
    print(f"ユーザー{user_id}のAPIリクエストを処理中...")
    # APIリクエストの処理

# テスト
for _ in range(5):
    try:
        api_request("user123")
        time.sleep(1)  # 1秒待機
    except Exception as e:
        print(f"エラー: {e}")

from functools import wraps

def my_decorator(func):
    @wraps(func)  # 元の関数のメタデータを保持
    def wrapper(*args, **kwargs):
        """これはwrapper関数です"""
        print("関数実行前の処理")
        result = func(*args, **kwargs)
        print("関数実行後の処理")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """挨拶を返す関数"""
    return f"こんにちは、{name}さん!"

# 関数情報の確認
print(say_hello.__name__)  # wrapsがないと "wrapper" になる
print(say_hello.__doc__)   # wrapsがないと wrapper のドキュメントになる

say_hello
挨拶を返す関数

@decorator1
@decorator2
def function():
    pass

def cache_result(func):
    """
    関数の結果をキャッシュするデコレータ。
    
    同じ引数で呼び出された場合に前回の結果を返し、
    計算を省略します。
    """
    cache = {}
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    
    return wrapper

def add_class_method(cls):
    def say_hello(self):
        return f"こんにちは、私は{self.__class__.__name__}のインスタンスです"
    
    cls.say_hello = say_hello
    return cls

@add_class_method
class Person:
    def __init__(self, name):
        self.name = name

# 使用例
person = Person("太郎")
print(person.say_hello())  # "こんにちは、私はPersonのインスタンスです"

@log_function_call
@functools.lru_cache(maxsize=None)
def expensive_operation(n):
    # 計算コストの高い処理
    return n ** 2