पायथन में डेकोरेटर्स

यह लेख पायथन में डेकोरेटर्स की व्याख्या करता है।

YouTube Video

पायथन में डेकोरेटर्स

पायथन डेकोरेटर्स एक शक्तिशाली सुविधा है जो फ़ंक्शन्स या मेथड्स में अतिरिक्त कार्यक्षमता जोड़ने के लिए उपयोग की जाती है। डेकोरेटर्स आपको मौजूदा कोड को बदले बिना नई कार्यक्षमता जोड़ने की अनुमति देते हैं, जिससे कोड की पुन: उपयोगिता और रखरखाव में सुधार होता है।

डेकोरेटर्स की मूल बातें

पायथन डेकोरेटर्स किसी फ़ंक्शन को एक आर्गुमेंट के रूप में लेते हैं और अतिरिक्त कार्यक्षमता के साथ एक नया फ़ंक्शन लौटाते हैं। डेकोरेटर्स का उपयोग करके, आप आसानी से फ़ंक्शन्स में प्री-प्रोसेसिंग या पोस्ट-प्रोसेसिंग जोड़ सकते हैं।

डेकोरेटर्स के बिना, किसी फ़ंक्शन का व्यवहार बदलने के लिए फ़ंक्शन को सीधे संपादित करना आवश्यक होता है। डेकोरेटर्स के साथ, आप मूल कार्यान्वयन को बदले बिना कार्यक्षमता बढ़ा सकते हैं।

डेकोरेटर की मूल संरचना

 1def my_decorator(func):
 2    def wrapper():
 3        print("Before the function call")
 4        func()
 5        print("After the function call")
 6    return wrapper
 7
 8@my_decorator
 9def say_hello():
10    print("Hello!")
11
12say_hello()

इस उदाहरण में, my_decorator फ़ंक्शन एक डेकोरेटर के रूप में कार्य करता है, जो say_hello फ़ंक्शन को रैप करता है। @my_decorator सिंटैक्स का उपयोग करके डेकोरेटर लागू किया जाता है, और जब say_hello() को कॉल किया जाता है, तो डेकोरेटर द्वारा प्रदान की गई प्री- और पोस्ट-प्रोसेसिंग स्वचालित रूप से निष्पादित हो जाती है।

डेकोरेटर्स कैसे काम करते हैं

डेकोरेटर निम्नलिखित चरणों में काम करते हैं।

1. डेकोरेटर एक फ़ंक्शन (या मेथड) को आर्गुमेंट के रूप में लेता है।

2. यह मूल फ़ंक्शन को निष्पादित करने के लिए एक रैपर फ़ंक्शन परिभाषित करता है।

3. रैपर फ़ंक्शन मूल फ़ंक्शन को निष्पादित करने से पहले या बाद में अतिरिक्त प्रोसेसिंग करता है।

4. डेकोरेटर रैपर फ़ंक्शन को लौटाता है। परिणामस्वरूप, मूल फ़ंक्शन को एक नए, डेकोरेटेड फ़ंक्शन से बदल दिया जाता है।

आर्गुमेंट्स वाले फ़ंक्शन्स के लिए डेकोरेटर्स

जब आर्गुमेंट्स वाले फ़ंक्शन पर डेकोरेटर लागू किया जाता है, तो रैपर फ़ंक्शन को उन आर्गुमेंट्स को स्वीकार करने के लिए समायोजित करना चाहिए।

 1def my_decorator(func):
 2    def wrapper(*args, **kwargs):
 3        print("Before the function call")
 4        result = func(*args, **kwargs)
 5        print("After the function call")
 6        return result
 7    return wrapper
 8
 9@my_decorator
10def greet(name):
11    print(f"Hello, {name}!")
12
13greet("Alice")

*args और **kwargs का उपयोग करके, उन फ़ंक्शन्स को हैंडल करना संभव है जो किसी भी संख्या के आर्गुमेंट्स और कीवर्ड आर्गुमेंट्स को स्वीकार करते हैं। यह डेकोरेटर्स को किसी भी प्रकार के आर्गुमेंट्स वाले फ़ंक्शन्स पर सामान्य रूप से लागू करने की अनुमति देता है।

डेकोरेटर लगाने के उदाहरण

लॉगिंग के लिए डेकोरेटर

डेकोरेटर का उपयोग अक्सर लॉगिंग कार्यक्षमता जोड़ने के लिए किया जाता है। उदाहरण के लिए, एक ऐसा डेकोरेटर बनाकर जो किसी फ़ंक्शन को निष्पादित करने से पहले और बाद में लॉग करता है, आप रिकॉर्ड कर सकते हैं कि कब फ़ंक्शन को कॉल किया गया और इसे निष्पादित करने में कितना समय लगा।

 1import time
 2
 3def log_time(func):
 4    def wrapper(*args, **kwargs):
 5        start_time = time.time()
 6        print(f"Calling function '{func.__name__}'...")
 7        result = func(*args, **kwargs)
 8        end_time = time.time()
 9        print(f"Function '{func.__name__}' completed in {end_time - start_time} seconds")
10        return result
11    return wrapper
12
13@log_time
14def long_task(duration):
15    time.sleep(duration)
16    print("Task completed!")
17
18long_task(2)

इस उदाहरण में, log_time डेकोरेटर किसी फ़ंक्शन के निष्पादन समय को मापता है और उसे लॉग के रूप में आउटपुट करता है। long_task फ़ंक्शन को डेकोरेटर के साथ लपेटा गया है, और इसका निष्पादन समय रनटाइम के दौरान रिकॉर्ड किया जाता है।

अनुमति प्रबंधन के लिए डेकोरेटर

डेकोरेटर का उपयोग अनुमति प्रबंधन के लिए भी किया जा सकता है। उदाहरण के लिए, आप जांच कर सकते हैं कि उपयोगकर्ता के पास विशिष्ट अनुमति है या नहीं, और इसके आधार पर प्रक्रिया को सीमित कर सकते हैं।

 1def requires_permission(user_role):
 2    def decorator(func):
 3        def wrapper(*args, **kwargs):
 4            if user_role != "admin":
 5                print("Permission denied!")
 6                return
 7            return func(*args, **kwargs)
 8        return wrapper
 9    return decorator
10
11@requires_permission("admin")
12def delete_user(user_id):
13    print(f"User {user_id} has been deleted.")
14
15delete_user(123)  # Executed
16delete_user = requires_permission("guest")(delete_user)
17delete_user(456)  # Permission denied!

requires_permission डेकोरेटर उपयोगकर्ता की भूमिका के आधार पर फ़ंक्शन के निष्पादन को प्रतिबंधित करता है। ऐसी लॉजिक को डेकोरेटर में समेकित करके, आप अनुमति प्रबंधन लॉजिक को अपने कोड में बिखरने से रोक सकते हैं, जिससे पठनीयता बढ़ती है।

डेकोरेटर को नेस्ट करना

कई डेकोरेटर लागू करना संभव है। जब एक ही फ़ंक्शन पर कई डेकोरेटर लागू किए जाते हैं, तो वे ऊपर से नीचे के क्रम में निष्पादित होते हैं।

 1def uppercase(func):
 2    def wrapper(*args, **kwargs):
 3        result = func(*args, **kwargs)
 4        return result.upper()
 5    return wrapper
 6
 7def exclaim(func):
 8    def wrapper(*args, **kwargs):
 9        result = func(*args, **kwargs)
10        return result + "!"
11    return wrapper
12
13@uppercase
14@exclaim
15def greet(name):
16    return f"Hello, {name}"
17
18print(greet("Alice"))  # "HELLO, ALICE!"

इस उदाहरण में, greet फ़ंक्शन पर दो डेकोरेटर लागू किए गए हैं। @exclaim डेकोरेटर स्ट्रिंग के अंत में विस्मयादिबोधक चिह्न जोड़ता है, और फिर @uppercase स्ट्रिंग को अपरकेस में बदलता है।

क्लास विधियों के लिए डेकोरेटर

डेकोरेटर का उपयोग क्लास विधियों के साथ भी किया जा सकता है। यह विशेष रूप से तब उपयोगी होता है जब आप किसी क्लास के भीतर विधियों के व्यवहार को नियंत्रित करना चाहते हैं। क्लास विधियों पर डेकोरेटर लागू करते समय, आपको self या cls जैसे तर्कों का ध्यान रखना होगा।

 1def log_method_call(func):
 2    def wrapper(self, *args, **kwargs):
 3        print(f"Calling method '{func.__name__}'...")
 4        return func(self, *args, **kwargs)
 5    return wrapper
 6
 7class MyClass:
 8    @log_method_call
 9    def greet(self, name):
10        print(f"Hello, {name}")
11
12obj = MyClass()
13obj.greet("Bob")

इस उदाहरण में, log_method_call डेकोरेटर को greet विधि पर लागू किया गया है ताकि विधि को कॉल करने पर एक लॉग आउटपुट हो।

डेकोरेटर के साथ सतर्कताएँ

डेकोरेटर का उपयोग करते समय कुछ बातों पर विचार करना चाहिए। डेकोरेटर संभावित रूप से मूल फ़ंक्शन के नाम और दस्तावेज़ीकरण स्ट्रिंग (जैसे, __name__ या __doc__) को बदल सकते हैं, इसलिए इस जानकारी को संरक्षित करने के लिए functools.wraps का उपयोग करने की सिफारिश की जाती है।

1import functools
2
3def my_decorator(func):
4    @functools.wraps(func)
5    def wrapper(*args, **kwargs):
6        print("Before the function call")
7        return func(*args, **kwargs)
8    return wrapper

@functools.wraps का उपयोग यह सुनिश्चित करता है कि मूल फ़ंक्शन का मेटाडेटा सही ढंग से रैपर फ़ंक्शन को पास किया गया है।

सारांश

पायथन डेकोरेटर एक बहुत ही शक्तिशाली उपकरण हैं जो आपको संक्षेप में कार्यों और विधियों में अतिरिक्त कार्यक्षमता जोड़ने की अनुमति देते हैं। इन्हें विभिन्न परिस्थितियों में कोड की पुनरावृत्ति को कम करने और संधारणीयता और पुन: उपयोगिता में सुधार के लिए उपयोग किया जा सकता है। डेकोरेटर कैसे काम करते हैं यह समझकर, आप अधिक कुशल और लचीला कोड लिख सकते हैं।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video