पायथन प्रकार के एनोटेशन का परिचय। विस्तार

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

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

अग्रिम घोषणा

आमतौर पर आप इसे बनाने से पहले एक प्रकार का उपयोग नहीं कर सकते। उदाहरण के लिए, निम्न कोड भी शुरू नहीं होगा:

class LinkedList: data: Any next: LinkedList # NameError: name 'LinkedList' is not defined 

इसे ठीक करने के लिए, एक स्ट्रिंग शाब्दिक का उपयोग करने की अनुमति है। इस मामले में, एनोटेशन की गणना आस्थगित की जाएगी।

 class LinkedList: data: Any next: 'LinkedList' 

आप अन्य मॉड्यूल से भी कक्षाओं तक पहुंच सकते हैं (निश्चित रूप से, यदि मॉड्यूल आयात किया गया है): some_variable: 'somemodule.SomeClass'

 def get_next_type(arg=None): if arg: return LinkedList else: return Any class LinkedList: data: Any next: 'get_next_type()' # error: invalid type comment or annotation 

UPD : पायथन 4.0 में, यह आस्थगित प्रकार एनोटेशन गणना ( PEP 563 ) को शामिल करने की योजना है, जो इस तकनीक से स्ट्रिंग शाब्दिकों से छुटकारा दिलाएगा। अजगर 3.7 के साथ आप from __future__ import annotations निर्माण from __future__ import annotations नए व्यवहार को सक्षम कर सकते हैं

कार्य और कॉल की गई वस्तुएँ

ऐसी स्थितियों के लिए जब किसी फ़ंक्शन या किसी अन्य ऑब्जेक्ट को स्थानांतरित करना आवश्यक होता है (उदाहरण के लिए, कॉलबैक के रूप में), आपको कॉल करने योग्य एनोटेशन का उपयोग करने की आवश्यकता है [[ArgType1, ArgType2, ...], ReturnType]
उदाहरण के लिए

 def help() -> None: print("This is help string") def render_hundreds(num: int) -> str: return str(num // 100) def app(helper: Callable[[], None], renderer: Callable[[int], str]): helper() num = 12345 print(renderer(num)) app(help, render_hundreds) app(help, help) # error: Argument 2 to "app" has incompatible type "Callable[[], None]"; expected "Callable[[int], str]" 

अपने मापदंडों को निर्दिष्ट किए बिना केवल वापसी प्रकार को निर्दिष्ट करने की अनुमति है। इस मामले में, दीर्घवृत्त का उपयोग किया जाता है: Callable[..., ReturnType] । ध्यान दें कि दीर्घवृत्त के आसपास कोई वर्ग कोष्ठक नहीं हैं।

फिलहाल, एक निश्चित प्रकार के मापदंडों की निर्दिष्ट संख्या या नामित तर्कों के साथ फ़ंक्शन हस्ताक्षर का वर्णन करना असंभव है।

सामान्य प्रकार

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

लिस्ट या कॉल करने योग्य जैसे प्रकार, जो हमने पहले देखे थे, केवल जेनेरिक तंत्र का उपयोग करें। लेकिन मानक प्रकारों के अलावा, आप अपने स्वयं के सामान्य प्रकार बना सकते हैं। ऐसा करने के लिए, सबसे पहले, TypeVar वैरिएबल प्राप्त करें, जो जेनेरिक की एक विशेषता होगी, और दूसरी बात, सीधे एक जेनेरिक प्रकार की घोषणा करें:

 T = TypeVar("T") class LinkedList(Generic[T]): data: T next: "LinkedList[T]" def __init__(self, data: T): self.data = data head_int: LinkedList[int] = LinkedList(1) head_int.next = LinkedList(2) head_int.next = 2 # error: Incompatible types in assignment (expression has type "int", variable has type "LinkedList[int]") head_int.data += 1 head_int.data.replace("0", "1") # error: "int" has no attribute "replace" head_str: LinkedList[str] = LinkedList("1") head_str.data.replace("0", "1") head_str = LinkedList[str](1) # error: Argument 1 to "LinkedList" has incompatible type "int"; expected "str" 

जैसा कि आप देख सकते हैं, जेनेरिक प्रकारों के लिए, पैरामीटर प्रकार कार्यों का स्वत: प्रवेश।

यदि आवश्यक हो, तो एक जेनेरिक में कई पैरामीटर हो सकते हैं: Generic[T1, T2, T3] ।

टाइपवर्कर को परिभाषित करते समय, आप मान्य प्रकारों को प्रतिबंधित कर सकते हैं:

 T2 = TypeVar("T2", int, float) class SomethingNumeric(Generic[T2]): pass x = SomethingNumeric[str]() # error: Value of type variable "T2" of "SomethingNumeric" cannot be "str" 

कास्ट

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

 from typing import List, cast def find_first_str(a: List[object]) -> str: index = next(i for i, x in enumerate(a) if isinstance(x, str)) return cast(str, a[index]) 

यह डेकोरेटर्स के लिए भी उपयोगी हो सकता है:

 MyCallable = TypeVar("MyCallable", bound=Callable) def logged(func: MyCallable) -> MyCallable: @wraps(func) def wrapper(*args, **kwargs): print(func.__name__, args, kwargs) return func(*args, **kwargs) return cast(MyCallable, wrapper) @logged def mysum(a: int, b: int) -> int: return a + b mysum(a=1) # error: Missing positional argument "b" in call to "mysum" 

रनटाइम एनोटेशन के साथ काम करें

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

 def render_int(num: int) -> str: return str(num) print(render_int.annotations) # {'num': <class 'int'>, 'return': <class 'str'>} 

get_type_hints भी उपलब्ध है - यह इसके पास दिए गए ऑब्जेक्ट के लिए एनोटेशन देता है, कई स्थितियों में यह __annotations__ की सामग्री से मेल खाता है, लेकिन इसमें अंतर भी हैं: यह मूल वस्तुओं के एनोटेशन ( __mro__ के रिवर्स ऑर्डर में) को भी जोड़ता है, और स्ट्रिंग के रूप में निर्दिष्ट प्रकार की प्रारंभिक घोषणाओं की भी अनुमति देता है।

 T = TypeVar("T") class LinkedList(Generic[T]): data: T next: "LinkedList[T]" print(LinkedList.__annotations__) # {'data': ~T, 'next': 'LinkedList[T]'} print(get_type_hints(LinkedList)) # {'data': ~T, 'next': __main__.LinkedList[~T]} 

जेनेरिक प्रकारों के लिए, __origin__ और __args__ माध्यम से स्वयं और उसके मापदंडों के बारे में जानकारी उपलब्ध है, लेकिन यह मानक का हिस्सा नहीं है और व्यवहार पहले से ही 3.6 और 3.7 संस्करणों के बीच बदल गया है