Python 3.0 में पेश किए गए फ़ंक्शन एनोटेशन एक ऐसी सुविधा जोड़ते हैं जो आपको फ़ंक्शन पैरामीटर और रिटर्न मान में मनमाना मेटाडेटा जोड़ने की अनुमति देता है। Python 3 के बाद से, फ़ंक्शन एनोटेशन को आधिकारिक तौर पर Python (PEP-3107) में जोड़ा गया है। प्राथमिक उद्देश्य फ़ंक्शन पैरामीटर और रिटर्न मान से मेटाडेटा को जोड़ने का एक मानक तरीका रखना था।
फ़ंक्शन एनोटेशन की मूल बातें
आइए फ़ंक्शन एनोटेशन की कुछ मूल बातें समझते हैं -
फ़ंक्शन एनोटेशन पैरामीटर और रिटर्न मान दोनों के लिए पूरी तरह से वैकल्पिक हैं।
फ़ंक्शन एनोटेशन फ़ंक्शन के विभिन्न भागों को संकलन समय पर मनमाने Python अभिव्यक्तियों के साथ जोड़ने का एक तरीका प्रदान करते हैं।
PEP-3107 बिल्ट-इन प्रकारों के लिए भी किसी भी प्रकार की मानक शब्दार्थ पेश करने का कोई प्रयास नहीं करता है। यह सारा काम थर्ड-पार्टी लाइब्रेरी पर छोड़ दिया गया है।
सिंटैक्स
सरल पैरामीटर के एनोटेशन
पैरामीटर के लिए एनोटेशन निम्न रूप लेते हैं -
def foo(x: expression, y: expression = 20):
...
जबकि अतिरिक्त पैरामीटर के लिए एनोटेशन इस प्रकार हैं -
def foo(**args: expression, **kwargs: expression):
.....
नेस्टेड पैरामीटर के मामले में, एनोटेशन हमेशा पैरामीटर के नाम का अनुसरण करते हैं न कि अंतिम पैरेंथेसिस तक। नेस्टेड पैरामीटर के सभी पैरामीटर को एनोटेट करना आवश्यक नहीं है।
def foo(x1, y1: expression), (x2: expression, y2: expression) = (None, None)):
......
यह समझना महत्वपूर्ण है कि Python एनोटेशन के साथ कोई शब्दार्थ प्रदान नहीं करता है। यह केवल मेटाडेटा को जोड़ने के लिए अच्छा सिंटैक्टिक समर्थन और साथ ही इसे एक्सेस करने का एक आसान तरीका प्रदान करता है। साथ ही, एनोटेशन अनिवार्य नहीं हैं।
>>> def func(x:'annotating x', y: 'annotating y', z: int) -> float: print(x + y + z)
उपरोक्त उदाहरण में, फ़ंक्शन func() तीन पैरामीटर x, y और z लेता है, अंत में उनका योग प्रिंट करता है। पहला तर्क x स्ट्रिंग 'annotating x' के साथ एनोटेटेड है, दूसरा तर्क y स्ट्रिंग 'annotating y' के साथ एनोटेटेड है, और तीसरा तर्क z प्रकार int के साथ एनोटेटेड है। रिटर्न मान प्रकार float के साथ एनोटेटेड है। यहां रिटर्न मान को एनोटेट करने के लिए '->' सिंटैक्स।
आउटपुट
>>> func(2,3,-4)
1
>>> func('Function','-','Annotation')
Function-Annotation
ऊपर हम func() को दो बार कॉल करते हैं, एक बार int तर्कों के साथ और एक बार स्ट्रिंग तर्कों के साथ। दोनों मामलों में, func() सही काम करता है और एनोटेशन को केवल नजरअंदाज कर दिया जाता है। तो, हम देखते हैं कि एनोटेशन का फ़ंक्शन func() के निष्पादन पर कोई प्रभाव नहीं पड़ता है।
फ़ंक्शन एनोटेशन तक पहुंचना
सभी एनोटेशन __annotations__ नामक एक डिक्शनरी में संग्रहीत होते हैं, जो स्वयं फ़ंक्शन का एक गुण है -
>>> def func(x:'annotating x', y: 'annotating y', z: int) -> float: print(x + y + z)
>>> func.__annotations__
{'x': 'annotating x', 'y': 'annotating y', 'z': , 'return': }
जैसा कि हम उपरोक्त कोड उदाहरण में देख सकते हैं, एनोटेशन टाइप घोषणाएं नहीं हैं, हालांकि वे निश्चित रूप से उस उद्देश्य के लिए उपयोग किए जा सकते हैं और वे कुछ अन्य भाषाओं में उपयोग किए जाने वाले टाइपिंग सिंटैक्स से मिलते-जुलते हैं, जैसा कि नीचे दिखाया गया है -
>>> def func(a: 'python', b: {'category: ' 'language'}) -> 'yep':
pass
>>> func.__annotations__
{'a': 'python', 'b': {'category: language'}, 'return': 'yep'}
>>>
वे मनमाने अभिव्यक्तियाँ हैं, जिसका अर्थ है कि मनमाने मान __annotations__ डिक्शनरी में संग्रहीत किए जा सकते हैं। हालांकि, वे Python में स्वयं अधिक महत्व नहीं जोड़ते हैं, सिवाय इसके कि उन्हें मान संग्रहीत करना चाहिए। उस ने कहा, पैरामीटर और रिटर्न प्रकार को परिभाषित करना फ़ंक्शन एनोटेशन का एक सामान्य उपयोग है।
@no_type_check डेकोरेटर
यदि आप अपने आप को एक ऐसे उपकरण का उपयोग करते हुए पाते हैं जो मानता है कि एनोटेशन टाइप घोषणाएं हैं लेकिन आप उन्हें किसी अन्य उद्देश्य के लिए उपयोग करना चाहते हैं, तो अपने फ़ंक्शन को ऐसे प्रसंस्करण से छूट देने के लिए मानक @no_type_check डेकोरेटर का उपयोग करें, जैसा कि यहां दिखाया गया है -
>>> from typing import no_type_check
>>> @no_type_check
def func(a: 'python', b: {'category: ' 'language'}) -> 'yep':
pass
>>>
आम तौर पर, इसकी आवश्यकता नहीं होती क्योंकि एनोटेशन का उपयोग करने वाले अधिकांश उपकरण में उनके लिए बने लोगों को पहचानने का एक तरीका होता है। डेकोरेटर उन कॉर्नर केस की रक्षा के लिए है जहां चीजें अस्पष्ट हैं।
फ़ंक्शन डेकोरेटर के इनपुट के रूप में एनोटेशन
एनोटेशन डेकोरेटर के साथ अच्छी तरह से जुड़ते हैं क्योंकि एनोटेशन मान डेकोरेटर को इनपुट प्रदान करने का एक अच्छा तरीका बनाते हैं, और डेकोरेटर-जनरेटेड रैपर एनोटेशन को अर्थ देने वाले कोड को रखने के लिए एक अच्छी जगह हैं।
from functools import wraps
def adapted(func):
@wraps(func)
def wrapper(**kwargs):
final_args = {}
for name, value in kwargs.items():
adapt = func.__annotations__.get(name)
if adapt is not None:
final_args[name] = adapt(value)
else:
final_args[name] = value
result = func(**final_args)
adapt = func.__annotations__.get('result')
if adapt is not None:
return adapt(result)
return result
return wrapper
@adapted
def func(a: int, b: repr) -> str:
return a
तो, अनुकूलित डेकोरेटर फ़ंक्शन को एक रैपर में संलग्न करता है। यह रैपर केवल कीवर्ड तर्क स्वीकार करता है, जिसका अर्थ है कि भले ही मूल फ़ंक्शन स्थितिगत तर्क स्वीकार कर सकता हो, उन्हें नाम से निर्दिष्ट करना होगा।
एक बार फ़ंक्शन रैप हो जाने पर, रैपर फ़ंक्शन के पैरामीटर एनोटेशन में एडेप्टर की तलाश करता है और वास्तविक फ़ंक्शन को तर्क पास करने से पहले उन्हें लागू करता है।
एक बार फ़ंक्शन रिटर्न हो जाने पर, रैपर रिटर्न मान एडेप्टर की जांच करता है; यदि यह एक पाता है, तो इसे अंत में वापस करने से पहले रिटर्न मान पर लागू करता है।
जब हम यहां जो हो रहा है उसके निहितार्थ पर विचार करते हैं, तो वे बहुत प्रभावशाली हैं। हमने वास्तव में संशोधित किया है कि किसी फ़ंक्शन को पैरामीटर पास करने या मान वापस करने का क्या मतलब है।
कीवर्ड तर्क
कभी-कभी, किसी विधि के एक या अधिक पैरामीटर को किसी प्रोसेसिंग की आवश्यकता नहीं होती है, सिवाय उन्हें self के एक गुण में निर्दिष्ट करने के। क्या हम डेकोरेटर और एनोटेशन का उपयोग करके इसे स्वचालित रूप से कर सकते हैं? बिल्कुल, हम कर सकते हैं।
from functools import wraps
def store_args(func):
@wraps(func)
def wrapper(self, **kwargs):
for name, value in kwargs.items():
attrib = func.__annotations__.get(name)
if attrib is True:
attrib = name
if isinstance(attrib, str):
setattr(self, attrib, value)
return func(self, **kwargs)
return wrapper
class A:
@store_args
def __init__(self, first: True, second: 'example'):
pass
a = A(first=5, second=6)
assert a.first == 5
assert a.example == 6