Pythonのデコレーター構文

# Pythonのデコレーター入門
Pythonでこのような`@`がつく構文を見たことはありませんか？
```python
@my_tag('cat')
```
Pythonには、関数やメソッドに追加の機能を持たせるための「デコレーター」と呼ばれる構文があります。
コードをシンプルに保ちながら、共通の処理（ロギング、キャッシュ、認証など）を再利用可能にします。

## 基本的な使い方
デコレーターの仕組みと基本的な使い方
#### `@`で関数を装飾する例

デコレーターは、Pythonの関数に対して、追加の処理を簡単に付与する仕組みです。
`@`構文を使うことで、デコレーターが適用された関数をラップします。


#### 関数を装飾する

以下のコードでは、@を使って関数にデコレーターを適用する方法を示しています。
```python
def sample_function(func):
    def wrapper():
        print("関数の前処理を実行します...")
        func()  # 引数として受け取った関数を呼び出す
        print("関数の後処理を実行します...")
    return wrapper

@sample_function
def hello():
    print("こんにちは！")

hello()
```
実行結果
```
関数の前処理を実行します...
こんにちは！
関数の後処理を実行します...
```
1. `sample_function`関数が穴あきの型、
1. `@sample_function`で型を使うよーという宣言
1. `hello`関数で型の穴埋めして実行
このようなイメージです

#### デコレーターを使うメリット
- 再利用可能なコード
    - 共通の処理をデコレーターとして1つにまとめることで、複数の関数に使い回すことができる
- 本体の関数を変更せずに機能追加
    - 元の関数のコードに手を加えず、外から装飾することで新しい機能を付与できる


## 引数を持つデコレーターの応用
基本的なデコレーターでは、関数を装飾するだけでしたが、**引数**を持つデコレーターを使うことで、さらに柔軟な機能を付加できます。
ここでは、デコレーター自体が引数を受け取り、挙動を変える方法を解説します。

実例：関数の実行回数を制御するデコレーター
```python
def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator


@repeat(num_times=3)
def hello(name):
    print(f"こんにちは、{name}さん！")


hello("Naoya")

```
実行結果
```
こんにちは、Naoyaさん！
こんにちは、Naoyaさん！
こんにちは、Naoyaさん！
```
やっぱり関数の入れ子構造と関数をそのままreturnしてるのがあまり見慣れない感じがしますね
1.	repeat関数がデコレーターの役割を担う
    1.	repeatは、num_timesという引数を受け取り、さらに内部にdecorator_repeatという関数を定義します。
1.	`@repeat(num_times=3)`でデコレーターに引数を渡す
    1.	greet関数は、repeatによってラップされ、3回繰り返して実行されます
1.	可変長引数`*args`と`**kwargs`の利用
    1.	ラップする関数が任意の引数を取れるようにするため、wrapper関数では*argsと**kwargsを使用しています

#### メリット
- 柔軟な処理の追加
    - 同じデコレーターでも引数を変えることで、異なる挙動を実現できる
    - 例：ログレベルやリトライ回数などを指定するデコレーター

## 条件付き実行デコレーター
次のような条件付きで関数を実行するデコレーターも簡単に作成できます。
```python
def only_if(condition):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if condition:
                return func(*args, **kwargs)
            else:
                print("条件が満たされていません。")

        return wrapper

    return decorator


@only_if(condition=True)
def show_message():
    print("このメッセージは条件が満たされたときのみ表示されます。")

show_message()
```
実行結果
```
このメッセージは条件が満たされたときのみ表示されます。
```

## よく使われる実践的なデコレーター
デコレーターの強力なポイントは、特定の処理を簡潔に追加でき、コードの再利用性を高めることです。この章では、開発現場で頻繁に使われる2つのデコレーターを紹介します。

#### ロギングデコレーター

実行時間を計測して効率化を図る

ロギングデコレーターは、関数の実行時間を測定し、パフォーマンス改善のための指標を提供します。特に、重い処理やAPIの呼び出しなど、関数の実行時間を把握する必要がある場面で役立ちます。

ロギングデコレーターのコード例
```python
import time


def time_logger(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result

    return wrapper


@time_logger
def my_function():
    # 適当な処理
    time.sleep(2)  # 処理に2秒かかると仮定


my_function()
```

実行結果
```
my_function took 2.0051 seconds
```
1. `time.time()`で関数の実行開始と終了の時刻を記録
1. 関数名と実行時間をログに表示し、関数のパフォーマンスを把握
1. デコレーターのおかげで、関数の内部コードを変更せずに、実行時間の計測が可能

#### メモ化デコレーター

処理を高速化するキャッシュの活用

`メモ化（Memoization）`とは、同じ入力に対して計算結果をキャッシュし、再度同じ処理が必要なときにキャッシュから結果を取得することで、無駄な再計算を避ける手法です。再帰処理などで特に有効です。

メモ化デコレーターのコード例
```python
def memoize(func):
    cache = {}  # 結果をキャッシュする辞書

    def wrapper(*args):
        if args in cache:
            print(f"キャッシュから取得: {args}")
            return cache[args]  # キャッシュから結果を返す
        result = func(*args)  # 新しい結果を計算
        cache[args] = result  # 結果をキャッシュに保存
        return result

    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))
```
実行結果
```
キャッシュから取得: (1,)
キャッシュから取得: (2,)
キャッシュから取得: (3,)
キャッシュから取得: (4,)
キャッシュから取得: (5,)
キャッシュから取得: (6,)
キャッシュから取得: (7,)
キャッシュから取得: (8,)
55
```

この関数はフィボナッチ数列のn番目の項を取得する関数です
memoizeデコレーターを使うことで、計算済みの結果をキャッシュ
これにより、計算の無駄を省き、処理速度を向上する
この例では、再帰的なフィボナッチ数列の計算において、同じ引数での再計算を避けています

## デコレーターを使うときの注意点
#### デコレーターの重複適用に注意する
複数のデコレーターを同じ関数に適用すると、関数が何重にもラップされ、意図しない順序で処理が実行されることがあります

問題例
```python
def rep(count):
    def decorator_a(func):
        def wrapper(*args, **kwargs):
            print("decorator_a")
            for _ in range(count):
                func(*args, **kwargs)
        return wrapper
    return decorator_a


def rep2(count):
    def decorator_b(func):
        def wrapper(*args, **kwargs):
            print("decorator_b")
            for _ in range(count):
                func(*args, **kwargs)
        return wrapper
    return decorator_b


@rep(count=5)
@rep2(count=3)
def say_hello():
    print("Hello!")


say_hello()
```
実行結果
```
decorator_a
decorator_b
Hello!
Hello!
Hello!
decorator_b
Hello!
Hello!
Hello!
decorator_b
Hello!
Hello!
Hello!
decorator_b
Hello!
Hello!
Hello!
decorator_b
Hello!
Hello!
Hello!
```
カオスな感じになっちゃったっすね
デコレーターは複数適用することができ、下から上の順序で適用されます
二重for文のようなイメージかもしれません

対策
- デコレーターの順序に気を配る
- 特に理由がなければ、1つのデコレーターに統合する

#### 関数のメタデータが失われる問題

デコレーターで関数をラップすると、元の関数の名前やドキュメント文字列（docstring）などのメタデータが失われることがあります

問題例
```python
def simple_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper


@simple_decorator
def greet():
    """挨拶をする関数"""
    print("こんにちは！")


print(greet.__name__)
print(greet.__doc__)
```
実行結果
```
wrapper
None
```
元の関数greetの名前とドキュメント文字列がwrapperに置き換わってしまっています。

対策：functools.wrapsを使う
```python
from functools import wraps


def simple_decorator(func):
    @wraps(func)  # メタデータを引き継ぐ
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper


@simple_decorator
def greet():
    """挨拶をする関数"""
    print("こんにちは！")


print(greet.__name__)
print(greet.__doc__)
```
実行結果
```
greet
挨拶をする関数
```
**functools.wraps**を使うことで、元の関数のメタデータが維持されます。

#### 副作用に注意する

デコレーターは関数の振る舞いを変えるため、元の関数の期待される動作が変わることがあります。これにより、思わぬ副作用が発生することがあります。

問題例
```python
def increment_result(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + 1  # 元の戻り値を変更
    return wrapper

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

print(add(2, 3))  # 6 と表示される
```
この例では、add関数の戻り値に1を足してしまうため、元の意図した動作とは異なる結果になります。

#### 状態管理に注意する

デコレーター内で状態を持たせる場合、複数の関数やスレッドで使用すると予期せぬバグが発生することがあります。

問題例
```python
def counter():
    count = 0  # 状態を保持

    def decorator(func):
        def wrapper(*args, **kwargs):
            nonlocal count
            count += 1
            print(f"{func.__name__}が{count}回呼ばれました")
            return func(*args, **kwargs)
        return wrapper

    return decorator

@counter()
def greet():
    print("こんにちは！")

greet()
greet()
```
実行結果
```
greetが1回呼ばれました
こんにちは！
greetが2回呼ばれました
こんにちは！
```
この例では、デコレーター内で状態を持つことで、関数が呼ばれるたびにカウントが増加します。
複数の関数やスレッドで使うと、状態が予期せず共有され、バグの原因となることがあります。

#### デバッグの難しさ
デコレーターを多用すると、関数の振る舞いが複雑になり、バグの原因を特定するのが難しくなる場合があります
対策
- デバッグを容易にするために、デコレーター内でログを残すなどの工夫をします
- 適切にコメントを付け、デコレーターの用途や意図を明示しましょう

## まとめ
デコレーターめちゃくちゃ便利そうなのが伝わりましたかね？？
この機会にデコレーターについてちょっとでも理解できたってなってたら嬉しいです
デコレーターは非常に強力ですが、注意深く設計することでその効果を最大限に発揮できるので、これらのポイントを押さえて、安全で保守性の高いデコレーターを活用しましょう。


# 番外編 ~wrapperの存在意義~
ここまでのコードで、`wrapper`関数という、一見意味を持たなそうな関数でラップしていることに気づいた方も多いのではないでしょうか？
デコレーターにおいて、wrapper関数で関数をラップする理由は、デコレーターの本質的な仕組みとメリットに関わります。以下では、その理由をいくつかの観点から説明します。

#### 元の関数の動作を拡張するため

wrapper関数を使うことで、元の関数の実行前後や途中に処理を挿入することができます。これは、元の関数を直接変更せずに、挙動を拡張するための方法です。
例えば、以下のようにロギングの処理を追加する場合、wrapperなしでは同じような拡張が難しくなります。
```python
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("関数が呼ばれる前の処理")
        result = func(*args, **kwargs)  # 元の関数を実行
        print("関数が呼ばれた後の処理")
        return result
    return wrapper
```
- 元の関数を直接触らず、呼び出し前後に共通の処理を加えられるのが大きなメリットです。

#### 元の関数の引数や戻り値を柔軟に扱うため
Pythonの関数は様々な引数の組み合わせをサポートしますが、wrapper関数を使うことで、それらを柔軟に受け渡しできます。
```python
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"引数: {args}, キーワード引数: {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name, message="こんにちは"):
    print(f"{message}、{name}さん！")

greet("太郎", message="おはよう")
```
- `*args`と`**kwargs`を使うことで、元の関数が持つ引数に対応しながら、新たな処理を追加できます。

#### 再利用性と分離された責務を保つため
wrapper関数を使うことで、元の関数とデコレーターの処理を分離し、デコレーターを再利用しやすくします。
- たとえば、同じデコレーターを複数の関数に適用する場合、wrapperで処理を管理しているおかげで、関数ごとに特別な処理を書く必要がなくなります。

#### 元の関数の戻り値を操作するため

デコレーターは、元の関数の戻り値に基づいて、追加の処理を行ったり、戻り値そのものを変更することもできます。
```python
def double_result(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result * 2  # 元の戻り値を加工
    return wrapper

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

print(add(3, 5))  # 出力: 16
```
- wrapperがなければ、元の関数の戻り値に対して柔軟な操作を行うことができません。

#### クロージャ（closure）による状態の保持

デコレーターは、クロージャを使って、デコレーターが適用された関数のスコープを超えて状態を保持することができます。
```python
def counter():
    count = 0  # 状態を保持

    def decorator(func):
        def wrapper(*args, **kwargs):
            nonlocal count
            count += 1
            print(f"{func.__name__}が呼ばれた回数: {count}")
            return func(*args, **kwargs)
        return wrapper

    return decorator

@counter()
def greet():
    print("こんにちは！")

greet()
greet()
```
- この例では、countが関数の外側で保持され、greetが呼ばれるたびにインクリメントされます。wrapperがなければ、こうした状態の管理は難しくなります。

### まとめ
これらの理由から、デコレーターの仕組みではwrapper関数が非常に重要な役割を果たしています。wrapperを使うことで、元の関数を柔軟に拡張し、Pythonのプログラムをよりシンプルかつ強力にすることができます