पायथन टाइप एनोटेशन का परिचय

परिचय

मैग्डेलेना टोम्ज़ेक द्वारा चित्रण

दूसरा भाग

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

पायथन (3.6+) के आधुनिक संस्करणों में डायनामिक डक टाइपिंग का विचार रखते हुए, यह चर प्रकारों, वर्ग क्षेत्रों, तर्कों और कार्यों के रिटर्न मानों के एनोटेशन का समर्थन करता है:

• पीईपी 3107 - फंक्शन एनोटेशन
• पीईपी 484 - टाइप संकेत
• पीईपी 526 - परिवर्तनीय एनोटेशन के लिए सिंटैक्स
• typing

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

मेरा नाम एंड्री तिखोनोव है और मैं लमोडा में बैकएंड डेवलपमेंट में लगा हूं।

इस लेख में, मैं प्रकार एनोटेशन का उपयोग करने की मूल बातें समझाना चाहता हूं और typing एनोटेशन द्वारा लागू किए गए विशिष्ट उदाहरणों पर विचार करना चाहता हूं।

एनोटेशन उपकरण

टाइप एनोटेशन कई पायथन आईडीई द्वारा समर्थित होते हैं जो गलत कोड को उजागर करते हैं या आपके द्वारा टाइप किए जाने पर संकेत प्रदान करते हैं।

उदाहरण के लिए, यह वही है जो Pycharm में दिखता है:

हाइलाइट करने में त्रुटि

टिप्स:

टाइप एनोटेशन को कंसोल लिंटर द्वारा भी संसाधित किया जाता है।

यहाँ pylint का उत्पादन है:

 $ pylint example.py ************* Module example example.py:7:6: E1101: Instance of 'int' has no 'startswith' member (no-member) 

लेकिन उसी फ़ाइल के लिए जिसे mypy मिला:

 $ mypy example.py example.py:7: error: "int" has no attribute "startswith" example.py:10: error: Unsupported operand types for // ("str" and "int") 

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

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

मूल बातें

पायथन के पुराने संस्करणों के विपरीत, टाइप एनोटेशन टिप्पणियों या डॉकस्ट्रिंग में नहीं लिखे जाते हैं, लेकिन सीधे कोड में। एक तरफ, यह नीचे की ओर संगतता को तोड़ता है, दूसरी ओर, इसका स्पष्ट रूप से मतलब है कि यह कोड का हिस्सा है और तदनुसार संसाधित किया जा सकता है

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

पहचान के बाद बृहदान्त्र के बाद चर के लिए एनोटेशन लिखा जाता है। इसके बाद, मूल्य को इनिशियलाइज़ किया जा सकता है। उदाहरण के लिए

 price: int = 5 title: str 

फ़ंक्शन पैरामीटर को चर के समान तरीके से एनोटेट किया जाता है, और वापसी मान को तीर के बाद -> और अंतिम बृहदान्त्र से पहले इंगित किया जाता है। उदाहरण के लिए

 def indent_right(s: str, width: int) -> str: return " " * (max(0, width - len(s))) + s 

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

 class Book: title: str author: str def __init__(self, title: str, author: str) -> None: self.title = title self.author = author b: Book = Book(title='Fahrenheit 451', author='Bradbury') 

वैसे, डेटासाल का उपयोग करते समय, वर्ग प्रकार को कक्षा में निर्दिष्ट किया जाना चाहिए। डेटाकॉल के बारे में अधिक

अंतर्निहित प्रकार

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

ऐच्छिक

यदि आप चर को int प्रकार से चिह्नित करते हैं और इसे None को भी असाइन करने का प्रयास None , तो एक त्रुटि होगी:

Incompatible types in assignment (expression has type "None", variable has type "int")

ऐसे मामलों के लिए, टाइपिंग मॉड्यूल में एक विशिष्ट प्रकार के साथ एक Optional एनोटेशन प्रदान किया जाता है। कृपया ध्यान दें कि वैकल्पिक चर का प्रकार वर्ग कोष्ठक में इंगित किया गया है।

 from typing import Optional amount: int amount = None # Incompatible types in assignment (expression has type "None", variable has type "int") price: Optional[int] price = None 

कोई

कभी-कभी आप संभव प्रकार के चर को सीमित नहीं करना चाहते हैं। उदाहरण के लिए, यदि यह वास्तव में महत्वपूर्ण नहीं है, या यदि आप स्वयं विभिन्न प्रकार के प्रसंस्करण करने की योजना बनाते हैं। इस स्थिति में, आप Any एनोटेशन का उपयोग कर सकते हैं। Mypy निम्नलिखित कोड पर शपथ नहीं लेगा:

 unknown_item: Any = 1 print(unknown_item) print(unknown_item.startswith("hello")) print(unknown_item // 0) 

सवाल उठ सकता है कि object उपयोग क्यों न किया जाए? हालांकि, इस मामले में, यह माना जाता है कि यद्यपि किसी भी वस्तु को स्थानांतरित किया जा सकता है, इसे केवल object उदाहरण के रूप में ही एक्सेस किया जा सकता है।

 unknown_object: object print(unknown_object) print(unknown_object.startswith("hello")) # error: "object" has no attribute "startswith" print(unknown_object // 0) # error: Unsupported operand types for // ("object" and "int") 

संघ

ऐसे मामलों के लिए जब न केवल किसी भी प्रकार के उपयोग की अनुमति देना आवश्यक है, बल्कि केवल कुछ, आप typing.Union उपयोग कर सकते हैं। वर्ग कोष्ठक में प्रकारों की सूची के साथ एक एनोटेशन।

 def hundreds(x: Union[int, float]) -> int: return (int(x) // 100) % 10 hundreds(100.0) hundreds(100) hundreds("100") # Argument 1 to "hundreds" has incompatible type "str"; expected "Union[int, float]" 

वैसे, Optional[T] एनोटेशन Union[T, None] बराबर है, हालांकि ऐसी प्रविष्टि की सिफारिश नहीं की जाती है।

संग्रह

प्रकार एनोटेशन तंत्र सामान्य तंत्र ( जेनरिक , लेख के दूसरे भाग में अधिक) का समर्थन करता है, जो कंटेनरों के लिए उनमें संग्रहीत तत्वों के प्रकार को निर्दिष्ट करने की अनुमति देता है।

सूचियों

यह दर्शाने के लिए कि एक चर में एक सूची है, आप सूची प्रकार का उपयोग एनोटेशन के रूप में कर सकते हैं। हालांकि, यदि आप यह निर्दिष्ट करना चाहते हैं कि सूची में कौन से तत्व शामिल हैं, तो इस तरह की टिप्पणी अब उपयुक्त नहीं होगी। typing.List लिए typing.List है। हमने वैकल्पिक वैरिएबल के प्रकार को कैसे निर्दिष्ट किया, इसके समान, हम वर्गाकार कोष्ठकों में सूची प्रकारों को निर्दिष्ट करते हैं।

 titles: List[str] = ["hello", "world"] titles.append(100500) # Argument 1 to "append" of "list" has incompatible type "int"; expected "str" titles = ["hello", 1] # List item 1 has incompatible type "int"; expected "str" items: List = ["hello", 1] 

यह माना जाता है कि सूची में एक ही प्रकार के तत्वों की अनिश्चित संख्या शामिल है। लेकिन किसी तत्व के एनोटेशन पर कोई प्रतिबंध नहीं है: आप Any , Optional , List और अन्य का उपयोग कर सकते हैं। यदि आइटम प्रकार निर्दिष्ट नहीं है, तो इसे Any माना जाता है।

सूची के अलावा, समान एनोटेशन सेट के लिए हैं: typing.FrozenSet । सेट और typing.FrozenSet । typing.FrozenSet ।

tuples

टुपल्स, सूचियों के विपरीत, अक्सर विषम तत्वों के लिए उपयोग किया जाता है। सिंटैक्स एक अंतर के साथ समान है: वर्ग ब्रैकेट व्यक्तिगत रूप से टपल के प्रत्येक तत्व के प्रकार को इंगित करते हैं।

यदि आप सूची के समान ट्यूपल का उपयोग करने की योजना बनाते हैं: एक ही प्रकार के तत्वों की एक अज्ञात संख्या को संग्रहीत करें, तो आप दीर्घवृत्त ( ... ) का उपयोग कर सकते हैं।

तत्व प्रकारों को निर्दिष्ट किए बिना एनोटेशन Tuple समान कार्य करता है Tuple[Any, ...]

 price_container: Tuple[int] = (1,) price_container = ("hello") # Incompatible types in assignment (expression has type "str", variable has type "Tuple[int]") price_container = (1, 2) # Incompatible types in assignment (expression has type "Tuple[int, int]", variable has type "Tuple[int]") price_with_title: Tuple[int, str] = (1, "hello") prices: Tuple[int, ...] = (1, 2) prices = (1, ) prices = (1, "str") # Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "Tuple[int, ...]") something: Tuple = (1, 2, "hello") 

शब्दकोशों

शब्दकोशों के लिए, typing.Dict । typing.Dict उपयोग किया जाता है। मुख्य प्रकार और मूल्य प्रकार को अलग से एनोटेट किया गया है:

 book_authors: Dict[str, str] = {"Fahrenheit 451": "Bradbury"} book_authors["1984"] = 0 # Incompatible types in assignment (expression has type "int", target has type "str") book_authors[1984] = "Orwell" # Invalid index type "int" for "Dict[str, str]"; expected type "str" 

इसी प्रकार typing.DefaultDict उपयोग किया जाता है

परिणाम परिणाम

फ़ंक्शन परिणाम के प्रकार को इंगित करने के लिए आप किसी भी एनोटेशन का उपयोग कर सकते हैं। लेकिन कुछ विशेष मामले हैं।

यदि कोई फ़ंक्शन कुछ भी नहीं देता है (उदाहरण के लिए, print तरह), तो इसका परिणाम हमेशा None । एनोटेशन के लिए हम None भी उपयोग None ।

इस तरह के एक समारोह को समाप्त करने के लिए वैध विकल्प होंगे: स्पष्ट रूप से None लौटना, एक मूल्य निर्दिष्ट किए बिना वापस लौटना, और बिना कॉल किए return समाप्त करना।

 def nothing(a: int) -> None: if a == 1: return elif a == 2: return None elif a == 3: return "" # No return value expected else: pass 

यदि फ़ंक्शन कभी नहीं लौटता है (उदाहरण के लिए, जैसे sys.exit ), तो आपको NoReturn एनोटेशन का उपयोग करना चाहिए:

 def forever() -> NoReturn: while True: pass 

यदि यह एक जनरेटर फ़ंक्शन है, अर्थात, इसके शरीर में एक yield , तो आप लौटे फ़ंक्शन के लिए Iterable[T] या Generator[YT, ST, RT] एनोटेशन का उपयोग कर सकते हैं:

 def generate_two() -> Iterable[int]: yield 1 yield "2" # Incompatible types in "yield" (actual type "str", expected type "int") 

एक निष्कर्ष के बजाय

कई स्थितियों के लिए, टाइपिंग मॉड्यूल में उपयुक्त प्रकार हैं, हालांकि मैं सब कुछ पर विचार नहीं करूंगा, क्योंकि व्यवहार उन लोगों के समान है।
उदाहरण के लिए, collections.abc.Iterator लिए सामान्य संस्करण के रूप में एक Iterator typing.SupportsInt , typing.SupportsInt यह इंगित करने के लिए कि ऑब्जेक्ट __int__ विधि का समर्थन करता है, या फ़ंक्शन और ऑब्जेक्ट के लिए __call__ जो __call__ विधि का समर्थन करता है

मानक टिप्पणियों और स्टब फ़ाइलों के रूप में एनोटेशन के प्रारूप को भी परिभाषित करता है जिसमें केवल स्थैतिक विश्लेषणकर्ताओं के लिए जानकारी होती है।

अगले लेख में मैं रनटाइम में जेनरिक और प्रोसेसिंग एनोटेशन के काम के तंत्र पर ध्यान देना चाहूंगा।