Python Decorator



Decorator (ตัวห่อฟังก์ชัน) คือฟังก์ชันที่รับฟังก์ชันเข้าไป แล้วคืนฟังก์ชันใหม่ที่ทำงานเพิ่มเติมรอบ ๆ ฟังก์ชันเดิม ใช้เพิ่มพฤติกรรม เช่น จับเวลา บันทึก log ตรวจสิทธิ์ แคชผลลัพธ์ โดยไม่ต้องแก้โค้ดในฟังก์ชันเดิม

พื้นฐานที่ต้องรู้ก่อน: ฟังก์ชันเป็นค่าได้

ใน Python ฟังก์ชันก็เป็นอ็อบเจกต์ ส่งเป็นอาร์กิวเมนต์ได้ คืนจากฟังก์ชันได้ เก็บในตัวแปรได้

def shout(text):
    return text.upper()

yell = shout             # เก็บฟังก์ชันในตัวแปร
print(yell("hello"))     # HELLO

def apply(func, value):
    return func(value)

print(apply(shout, "hi"))   # HI

สร้าง decorator ตัวแรก

def logged(func):
    def wrapper(*args, **kwargs):
        print(f"เรียก {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} คืนค่า {result}")
        return result
    return wrapper


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

add = logged(add)        # ห่อ add ด้วย logged
print(add(3, 5))

ผลลัพธ์:

เรียก add
add คืนค่า 8
8

ไวยากรณ์ @

add = logged(add) เขียนย่อได้ด้วย @ วางเหนือ def

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


print(add(3, 5))   # ทำงานเหมือนเดิม

@logged เหนือ def add มีความหมายเดียวกับ add = logged(add) เป๊ะ

ตัวอย่างใช้จริง: จับเวลาการทำงาน

import time
import functools


def timed(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} ใช้เวลา {elapsed:.4f} วินาที")
        return result
    return wrapper


@timed
def slow_sum(n):
    return sum(range(n))


slow_sum(10_000_000)
# slow_sum ใช้เวลา 0.1523 วินาที

functools.wraps สำคัญยังไง

ถ้าไม่ใส่ @functools.wraps(func) ฟังก์ชันที่ถูกห่อจะเสียข้อมูลตัวเอง

def logged(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@logged
def greet():
    """ทักทายผู้ใช้"""
    print("สวัสดี")

print(greet.__name__)   # wrapper   ← ผิด! ควรเป็น greet
print(greet.__doc__)    # None      ← หาย docstring

ใส่ @functools.wraps(func) บน wrapper แล้วมันจะก๊อปชื่อ docstring และข้อมูลอื่นของฟังก์ชันเดิมมาให้ ใส่ทุกครั้งที่เขียน decorator

Decorator ที่รับพารามิเตอร์

ต้องเพิ่มชั้นฟังก์ชันอีกหนึ่งชั้น

import functools


def repeat(times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator


@repeat(times=3)
def greet(name):
    print(f"สวัสดี {name}")


greet("สมชาย")
# สวัสดี สมชาย
# สวัสดี สมชาย
# สวัสดี สมชาย

อ่านจากในออกนอก: repeat(3) คืน decorator, decorator(greet) คืน wrapper

Decorator ที่มีมากับ Python

functools.lru_cache — แคชผลลัพธ์

import functools


@functools.lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)


print(fib(50))   # เร็วมาก เพราะผลลัพธ์ที่คำนวณแล้วถูกจำไว้

ถ้าไม่มี lru_cache การคำนวณ fib(50) แบบ recursion จะช้ามากเพราะคำนวณค่าเดิมซ้ำนับล้านครั้ง

@property, @classmethod, @staticmethod

เราเจอมาแล้วในบท OOP — พวกนี้ก็เป็น decorator

ตัวอย่างรวม: ตรวจสิทธิ์ก่อนเรียกฟังก์ชัน

import functools

current_user = {"name": "สมชาย", "role": "editor"}


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


@require_role("admin")
def delete_all_posts():
    print("ลบโพสต์ทั้งหมด")


@require_role("editor")
def edit_post(post_id):
    print(f"แก้ไขโพสต์ {post_id}")


edit_post(42)          # แก้ไขโพสต์ 42
delete_all_posts()     # PermissionError: ต้องเป็น admin เท่านั้น

โค้ดตรวจสิทธิ์อยู่ที่เดียว ฟังก์ชันแต่ละตัวไม่ต้องเขียน if role != ... ซ้ำ

เช็คความเข้าใจก่อนข้ามบท

  • อธิบายได้ว่าฟังก์ชันใน Python ส่งต่อเป็นค่าได้
  • เข้าใจว่า decorator คือฟังก์ชันที่รับฟังก์ชัน แล้วคืนฟังก์ชันใหม่
  • ลองเขียน decorator ที่พิมพ์ข้อความก่อนและหลังเรียกฟังก์ชันจริง

สรุป

  • decorator รับฟังก์ชัน คืนฟังก์ชันใหม่ที่ทำงานเพิ่มรอบ ๆ ของเดิม
  • @decorator เหนือ def f = f = decorator(f)
  • ใส่ @functools.wraps(func) บน wrapper เสมอ เพื่อรักษาชื่อ/docstring
  • decorator ที่รับพารามิเตอร์ต้องมี 3 ชั้น; functools.lru_cache แคชผลลัพธ์ให้ฟรี

บทถัดไปว่าด้วย context manager และคำสั่ง with