Prerequisites
- Basic understanding of programming concepts 📝
- Python installation (3.8+) 🐍
- VS Code or preferred IDE 💻
What you'll learn
- Understand the concept fundamentals 🎯
- Apply the concept in real projects 🏗️
- Debug common issues 🐛
- Write clean, Pythonic code ✨
🎯 Introduction
Welcome to the magical world of Python decorators! 🎉 In this tutorial, we’ll explore how decorators can transform your functions with a functional programming approach.
Have you ever wanted to add superpowers to your functions without modifying their code? 🦸♂️ That’s exactly what decorators do! They’re like gift wrappers 🎁 that add extra functionality to your functions, making them more powerful, reusable, and elegant.
By the end of this tutorial, you’ll be creating your own decorators with confidence and applying functional programming principles like a pro! Let’s dive in! 🏊♂️
📚 Understanding Decorators
🤔 What are Decorators?
Decorators are like magical enhancements 🪄 that you can apply to functions. Think of them as Instagram filters for your code - they take your original function and add extra features without changing its core purpose!
In Python terms, decorators are higher-order functions that take a function as input and return an enhanced version of that function. This means you can:
- ✨ Add logging to any function
- 🚀 Measure performance automatically
- 🛡️ Validate inputs before processing
- 🔒 Add authentication checks
- ⏰ Implement caching for expensive operations
💡 Why Use the Functional Approach?
Here’s why the functional approach to decorators is powerful:
- Pure Functions 🔒: Create decorators without side effects
- Composability 🏗️: Chain multiple decorators easily
- Immutability 📖: Preserve original function behavior
- Testability 🧪: Easy to test in isolation
- Reusability ♻️: Apply the same decorator to many functions
Real-world example: Imagine building a web API 🌐. With decorators, you can add authentication, logging, and rate limiting to any endpoint with just a simple @ symbol!
🔧 Basic Syntax and Usage
📝 Simple Decorator Example
Let’s start with a friendly example:
# 👋 Hello, decorators!
def greet_decorator(func):
"""A decorator that adds a greeting! 🎉"""
def wrapper(*args, **kwargs):
print("🌟 Welcome! Let me help you with that...")
result = func(*args, **kwargs) # 🎯 Call original function
print("✨ All done! Have a great day!")
return result
return wrapper
# 🎨 Using the decorator
@greet_decorator
def calculate_sum(a, b):
"""Calculate the sum of two numbers 🔢"""
result = a + b
print(f"📊 The sum of {a} and {b} is {result}")
return result
# 🎮 Let's try it!
calculate_sum(5, 3)💡 Explanation: The @greet_decorator syntax is syntactic sugar for calculate_sum = greet_decorator(calculate_sum). It’s Python’s way of making decorators beautiful! 🎨
🎯 Common Decorator Patterns
Here are patterns you’ll use daily:
# 🏗️ Pattern 1: Timing decorator
import time
from functools import wraps
def time_it(func):
"""Measure function execution time ⏱️"""
@wraps(func) # 🛡️ Preserve function metadata
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"⏰ {func.__name__} took {end - start:.4f} seconds")
return result
return wrapper
# 🎨 Pattern 2: Memoization decorator
def memoize(func):
"""Cache function results for efficiency 🚀"""
cache = {}
@wraps(func)
def wrapper(*args):
if args in cache:
print(f"💫 Found in cache!")
return cache[args]
result = func(*args)
cache[args] = result
return result
return wrapper
# 🔄 Pattern 3: Decorator with parameters
def repeat(times):
"""Repeat function execution 🔄"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for i in range(times):
print(f"🎯 Attempt {i + 1}/{times}")
result = func(*args, **kwargs)
return result
return wrapper
return decorator💡 Practical Examples
🛒 Example 1: E-commerce Order Processing
Let’s build something real:
# 🛍️ E-commerce order processing with decorators
from functools import wraps
import json
from datetime import datetime
def log_transaction(func):
"""Log all transactions 📝"""
@wraps(func)
def wrapper(*args, **kwargs):
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"📋 [{timestamp}] Starting {func.__name__}")
try:
result = func(*args, **kwargs)
print(f"✅ [{timestamp}] {func.__name__} completed successfully")
return result
except Exception as e:
print(f"❌ [{timestamp}] {func.__name__} failed: {str(e)}")
raise
return wrapper
def validate_order(func):
"""Validate order data 🛡️"""
@wraps(func)
def wrapper(order_data, *args, **kwargs):
# 🔍 Check required fields
required = ['customer_id', 'items', 'total']
missing = [field for field in required if field not in order_data]
if missing:
raise ValueError(f"❌ Missing required fields: {missing}")
if not order_data['items']:
raise ValueError("🛒 Order must contain at least one item!")
if order_data['total'] <= 0:
raise ValueError("💰 Order total must be positive!")
print("✅ Order validation passed!")
return func(order_data, *args, **kwargs)
return wrapper
def discount(percentage):
"""Apply discount to order 🏷️"""
def decorator(func):
@wraps(func)
def wrapper(order_data, *args, **kwargs):
original_total = order_data['total']
discount_amount = original_total * (percentage / 100)
order_data['total'] = original_total - discount_amount
order_data['discount_applied'] = percentage
print(f"🎁 Applied {percentage}% discount!")
print(f"💵 Original: ${original_total:.2f} → New: ${order_data['total']:.2f}")
return func(order_data, *args, **kwargs)
return wrapper
return decorator
# 🎮 Using our decorators!
@log_transaction
@validate_order
@discount(20) # 20% off sale! 🎉
def process_order(order_data):
"""Process an e-commerce order 📦"""
print(f"🛍️ Processing order for customer {order_data['customer_id']}")
print(f"📦 Items: {len(order_data['items'])} products")
print(f"💳 Final total: ${order_data['total']:.2f}")
# Simulate processing
order_data['status'] = 'processed'
order_data['order_id'] = f"ORD-{datetime.now().strftime('%Y%m%d%H%M%S')}"
return order_data
# 🎯 Try it yourself!
order = {
'customer_id': 'CUST-123',
'items': ['📱 iPhone', '🎧 AirPods', '⌚ Apple Watch'],
'total': 1500.00
}
processed_order = process_order(order)
print(f"🎊 Order {processed_order['order_id']} processed successfully!")🎯 Try it yourself: Add a @retry decorator that retries failed orders!
🎮 Example 2: Game Achievement System
Let’s make it fun:
# 🏆 Achievement system with functional decorators
from functools import wraps, reduce
import time
def achievement_tracker(achievement_name, points):
"""Track player achievements 🏆"""
def decorator(func):
@wraps(func)
def wrapper(player, *args, **kwargs):
result = func(player, *args, **kwargs)
# 🎯 Award achievement
if 'achievements' not in player:
player['achievements'] = []
achievement = {
'name': achievement_name,
'points': points,
'timestamp': time.time(),
'emoji': '🏆'
}
player['achievements'].append(achievement)
player['total_points'] = player.get('total_points', 0) + points
print(f"🎊 Achievement unlocked: {achievement_name} (+{points} points)!")
return result
return wrapper
return decorator
def combo_multiplier(multiplier):
"""Apply combo multiplier to scores 🔥"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
if isinstance(result, (int, float)):
combo_result = result * multiplier
print(f"🔥 Combo x{multiplier}! Score: {result} → {combo_result}")
return combo_result
return result
return wrapper
return decorator
def performance_bonus(threshold):
"""Add bonus for high performance ⚡"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
execution_time = time.time() - start_time
if execution_time < threshold:
bonus = int(100 * (threshold - execution_time))
print(f"⚡ Speed bonus! Completed in {execution_time:.3f}s (+{bonus} points)")
return result + bonus if isinstance(result, (int, float)) else result
return result
return wrapper
return decorator
# 🎮 Create our game functions
@achievement_tracker("First Blood", 100)
@combo_multiplier(2)
@performance_bonus(0.5)
def defeat_enemy(player, enemy_type):
"""Defeat an enemy and earn points 🗡️"""
base_points = {
'🧟 Zombie': 10,
'🐉 Dragon': 50,
'👹 Boss': 100
}
points = base_points.get(enemy_type, 5)
print(f"💥 Defeated {enemy_type}! Base points: {points}")
# Simulate combat time
time.sleep(0.3)
return points
# 🎯 Compose multiple decorators functionally
def compose(*decorators):
"""Compose multiple decorators functionally 🎨"""
def decorator(func):
return reduce(lambda f, d: d(f), reversed(decorators), func)
return decorator
# 🏗️ Create a super-powered function
super_combo = compose(
achievement_tracker("Combo Master", 500),
combo_multiplier(5),
performance_bonus(0.2)
)
@super_combo
def ultimate_attack(player):
"""Unleash ultimate attack! 💫"""
print("🌟 ULTIMATE ATTACK ACTIVATED!")
time.sleep(0.1) # Fast execution for bonus
return 1000
# 🎮 Let's play!
player = {'name': 'PyMaster', 'total_points': 0}
# Battle sequence
score1 = defeat_enemy(player, '🧟 Zombie')
score2 = defeat_enemy(player, '🐉 Dragon')
score3 = ultimate_attack(player)
print(f"\n🏆 Final Stats for {player['name']}:")
print(f"💯 Total Points: {player['total_points']}")
print(f"🎖️ Achievements: {len(player['achievements'])}")🚀 Advanced Concepts
🧙♂️ Functional Decorator Composition
When you’re ready to level up, try this advanced pattern:
# 🎯 Advanced functional composition
from functools import wraps, partial
from typing import Callable, Any
def curry_decorator(decorator: Callable) -> Callable:
"""Make decorators curryable 🍛"""
@wraps(decorator)
def curried(*args, **kwargs):
if len(args) == 1 and callable(args[0]) and not kwargs:
# Direct decoration
return decorator(args[0])
else:
# Partial application
return partial(decorator, *args, **kwargs)
return curried
@curry_decorator
def rate_limit(func: Callable, calls: int = 1, period: float = 1.0) -> Callable:
"""Rate limit function calls 🚦"""
call_times = []
@wraps(func)
def wrapper(*args, **kwargs):
current_time = time.time()
# Remove old calls outside the period
call_times[:] = [t for t in call_times if current_time - t < period]
if len(call_times) >= calls:
wait_time = period - (current_time - call_times[0])
raise Exception(f"🛑 Rate limit exceeded! Wait {wait_time:.1f}s")
call_times.append(current_time)
return func(*args, **kwargs)
return wrapper
# 🪄 Using curried decorators
@rate_limit(calls=3, period=10.0)
def api_call(endpoint):
"""Simulate API call 🌐"""
print(f"📡 Calling {endpoint}")
return f"Response from {endpoint}"
# Or use it functionally
limited_func = rate_limit(calls=2)(lambda x: x * 2)🏗️ Monadic Decorators
For the brave developers:
# 🚀 Monadic decorator pattern
from typing import TypeVar, Generic, Callable, Optional
T = TypeVar('T')
U = TypeVar('U')
class Maybe(Generic[T]):
"""Maybe monad for safe operations 🛡️"""
def __init__(self, value: Optional[T]):
self._value = value
def bind(self, func: Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
if self._value is None:
return Maybe(None)
return func(self._value)
def map(self, func: Callable[[T], U]) -> 'Maybe[U]':
if self._value is None:
return Maybe(None)
return Maybe(func(self._value))
@property
def value(self) -> Optional[T]:
return self._value
def maybe_decorator(func: Callable) -> Callable:
"""Wrap function result in Maybe monad 🎁"""
@wraps(func)
def wrapper(*args, **kwargs):
try:
result = func(*args, **kwargs)
return Maybe(result)
except Exception as e:
print(f"⚠️ Operation failed: {e}")
return Maybe(None)
return wrapper
@maybe_decorator
def divide(a: float, b: float) -> float:
"""Safe division 🔢"""
return a / b
# 🎮 Chain operations safely
result = (divide(10, 2)
.map(lambda x: x * 2)
.map(lambda x: x + 10)
.bind(lambda x: divide(x, 2)))
if result.value:
print(f"✨ Result: {result.value}")
else:
print("❌ Computation failed somewhere in the chain")⚠️ Common Pitfalls and Solutions
😱 Pitfall 1: Losing Function Metadata
# ❌ Wrong way - metadata gets lost!
def bad_decorator(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper # 😰 Lost __name__, __doc__, etc.
@bad_decorator
def my_function():
"""Important documentation"""
pass
print(my_function.__name__) # 💥 Prints 'wrapper', not 'my_function'!
# ✅ Correct way - preserve metadata!
from functools import wraps
def good_decorator(func):
@wraps(func) # 🛡️ Preserves function metadata
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@good_decorator
def my_function():
"""Important documentation"""
pass
print(my_function.__name__) # ✅ Prints 'my_function'
print(my_function.__doc__) # ✅ Prints 'Important documentation'🤯 Pitfall 2: Decorator Order Matters
# ❌ Wrong order - authentication happens after logging!
@log_transaction # 2️⃣ This runs second
@authenticate # 1️⃣ This runs first
def sensitive_operation():
pass
# ✅ Correct order - authenticate first, then log
@authenticate # 1️⃣ Check auth first
@log_transaction # 2️⃣ Only log if authenticated
def sensitive_operation():
pass
# 💡 Remember: decorators apply bottom-to-top!🛠️ Best Practices
- 🎯 Use @wraps: Always preserve function metadata
- 📝 Document Decorators: Explain what they do and when to use them
- 🛡️ Handle Exceptions: Don’t let decorators hide errors
- 🎨 Keep It Simple: One decorator, one responsibility
- ✨ Make Them Composable: Design decorators to work together
- 🚀 Consider Performance: Cache when appropriate
- 🧪 Test Thoroughly: Test decorators in isolation
🧪 Hands-On Exercise
🎯 Challenge: Build a Caching System
Create a functional caching system with these features:
📋 Requirements:
- ✅ LRU (Least Recently Used) cache with size limit
- 🏷️ TTL (Time To Live) support for cache entries
- 👤 Cache statistics (hits, misses, evictions)
- 📊 Cache warming capability
- 🎨 Decorator parameters for configuration
🚀 Bonus Points:
- Add cache invalidation patterns
- Implement distributed cache support
- Create cache performance metrics
- Add async function support
💡 Solution
🔍 Click to see solution
# 🎯 Advanced caching system with functional approach!
from functools import wraps, lru_cache
from datetime import datetime, timedelta
from collections import OrderedDict
import asyncio
from typing import Any, Callable, Optional
class FunctionalCache:
"""Functional caching system 🚀"""
def __init__(self, maxsize: int = 128, ttl: Optional[float] = None):
self.maxsize = maxsize
self.ttl = ttl
self.cache = OrderedDict()
self.stats = {
'hits': 0,
'misses': 0,
'evictions': 0
}
def get(self, key: Any) -> Optional[Any]:
"""Get item from cache 📦"""
if key in self.cache:
value, expiry = self.cache[key]
if expiry and datetime.now() > expiry:
# ⏰ Expired entry
del self.cache[key]
return None
# 🎯 Move to end (LRU)
self.cache.move_to_end(key)
self.stats['hits'] += 1
return value
self.stats['misses'] += 1
return None
def set(self, key: Any, value: Any) -> None:
"""Set item in cache 💾"""
expiry = None
if self.ttl:
expiry = datetime.now() + timedelta(seconds=self.ttl)
if key in self.cache:
# Update existing
self.cache.move_to_end(key)
elif len(self.cache) >= self.maxsize:
# 🗑️ Evict oldest
self.cache.popitem(last=False)
self.stats['evictions'] += 1
self.cache[key] = (value, expiry)
def invalidate(self, pattern: Optional[Callable] = None) -> int:
"""Invalidate cache entries 🧹"""
if pattern is None:
# Clear all
count = len(self.cache)
self.cache.clear()
return count
# Clear matching pattern
keys_to_remove = [k for k in self.cache if pattern(k)]
for key in keys_to_remove:
del self.cache[key]
return len(keys_to_remove)
def get_stats(self) -> dict:
"""Get cache statistics 📊"""
total = self.stats['hits'] + self.stats['misses']
hit_rate = self.stats['hits'] / total if total > 0 else 0
return {
**self.stats,
'size': len(self.cache),
'hit_rate': f"{hit_rate * 100:.1f}%",
'capacity': f"{len(self.cache)}/{self.maxsize}"
}
def cached(maxsize: int = 128, ttl: Optional[float] = None):
"""Functional cache decorator 🎨"""
cache = FunctionalCache(maxsize=maxsize, ttl=ttl)
def decorator(func: Callable) -> Callable:
@wraps(func)
def sync_wrapper(*args, **kwargs):
# 🔑 Create cache key
key = (args, tuple(sorted(kwargs.items())))
# 📦 Check cache
result = cache.get(key)
if result is not None:
print(f"💫 Cache hit for {func.__name__}!")
return result
# 🎯 Execute function
result = func(*args, **kwargs)
cache.set(key, result)
return result
@wraps(func)
async def async_wrapper(*args, **kwargs):
# 🔑 Create cache key
key = (args, tuple(sorted(kwargs.items())))
# 📦 Check cache
result = cache.get(key)
if result is not None:
print(f"💫 Cache hit for {func.__name__}!")
return result
# 🎯 Execute async function
result = await func(*args, **kwargs)
cache.set(key, result)
return result
# 🎁 Add cache control methods
wrapper = async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
wrapper.cache = cache
wrapper.invalidate = cache.invalidate
wrapper.stats = cache.get_stats
return wrapper
return decorator
# 🎮 Test our caching system!
@cached(maxsize=10, ttl=5.0)
def expensive_calculation(n: int) -> int:
"""Simulate expensive calculation 🧮"""
print(f"🔧 Computing factorial of {n}...")
result = 1
for i in range(1, n + 1):
result *= i
return result
@cached(maxsize=5)
async def fetch_data(url: str) -> str:
"""Simulate async data fetching 🌐"""
print(f"📡 Fetching from {url}...")
await asyncio.sleep(1) # Simulate network delay
return f"Data from {url}"
# 🎯 Demo time!
print("🚀 Testing synchronous caching:")
print(f"Result: {expensive_calculation(5)}") # Miss
print(f"Result: {expensive_calculation(5)}") # Hit!
print(f"Result: {expensive_calculation(6)}") # Miss
print(f"\n📊 Cache stats: {expensive_calculation.stats()}")
# 🧹 Invalidate specific entries
expensive_calculation.invalidate(lambda key: key[0][0] > 5)
print("\n🌐 Testing async caching:")
async def test_async():
await fetch_data("api.example.com") # Miss
await fetch_data("api.example.com") # Hit!
print(f"📊 Async cache stats: {fetch_data.stats()}")
# Run async test
asyncio.run(test_async())🎓 Key Takeaways
You’ve learned so much! Here’s what you can now do:
- ✅ Create functional decorators with confidence 💪
- ✅ Compose decorators for powerful combinations 🛡️
- ✅ Apply functional principles to decorator design 🎯
- ✅ Debug decorator issues like a pro 🐛
- ✅ Build reusable decorator libraries with Python! 🚀
Remember: Decorators are just functions that transform functions. Keep them simple, pure, and composable! 🤝
🤝 Next Steps
Congratulations! 🎉 You’ve mastered decorators with a functional approach!
Here’s what to do next:
- 💻 Practice with the caching exercise above
- 🏗️ Build a decorator library for your projects
- 📚 Explore functools and decorator modules
- 🌟 Share your decorator creations with the community!
Remember: Every Python expert started with simple decorators. Keep experimenting, keep learning, and most importantly, have fun with functional programming! 🚀
Happy decorating! 🎉🚀✨