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