🤟🏽 🏦 🤶🏾 पायथन 3.8 में नए प्रकार के एनोटेशन (प्रोटोकॉल, फाइनल, टाइप्डडिक्ट, लिटरल) 🌊 🐬 📐

आज रात पायथन 3.8 बाहर आया और प्रकार के एनोटेशन को नई सुविधाएँ मिलीं:

प्रोटोकॉल
टाइप किए गए शब्दकोश
अंतिम विवरण
निश्चित मूल्य मिलान

यदि आप अभी तक एनोटेशन से परिचित नहीं हैं, तो मैं अपने पिछले लेखों पर ध्यान देने की सलाह देता हूं ( शुरुआत , निरंतरता )
और जब हर कोई वालरस के बारे में चिंतित है, मैं टाइपिंग मॉड्यूल में नवीनतम के बारे में संक्षेप में बात करना चाहता हूं

प्रोटोकॉल

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

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

यह ध्यान देने योग्य है कि, पायथन 3.6 के साथ शुरू, टाइपिंग मॉड्यूल में पहले से ही कई मानक प्रोटोकॉल शामिल हैं।
उदाहरण के लिए, SupportsInt (जिसमें __int__ विधि की आवश्यकता होती है), SupportsBytes ( __bytes__ आवश्यकता __bytes__ ), और कुछ अन्य।

प्रोटोकॉल विवरण

एक प्रोटोकॉल को प्रोटोकॉल से प्राप्त एक नियमित वर्ग के रूप में वर्णित किया गया है। इसकी विधियाँ (कार्यान्वयन सहित) और क्षेत्र हो सकते हैं।
प्रोटोकॉल को लागू करने वाली वास्तविक कक्षाएं इससे विरासत में मिल सकती हैं, लेकिन यह आवश्यक नहीं है।

 from abc import abstractmethod from typing import Protocol, Iterable class SupportsRoar(Protocol): @abstractmethod def roar(self) -> None: raise NotImplementedError class Lion(SupportsRoar): def roar(self) -> None: print("roar") class Tiger: def roar(self) -> None: print("roar") class Cat: def meow(self) -> None: print("meow") def roar_all(bigcats: Iterable[SupportsRoar]) -> None: for t in bigcats: t.roar() roar_all([Lion(), Tiger()]) # ok roar_all([Cat()]) # error: List item 0 has incompatible type "Cat"; expected "SupportsRoar"

हम वंशानुक्रम का उपयोग करके प्रोटोकॉल बना सकते हैं, नए बना सकते हैं।
हालाँकि, इस स्थिति में, आपको प्रोटोकॉल को मूल वर्ग के रूप में भी स्पष्ट रूप से निर्दिष्ट करना होगा।

 class BigCatProtocol(SupportsRoar, Protocol): def purr(self) -> None: print("purr")

सामान्य, स्व-टाइप, कॉल करने योग्य

प्रोटोकॉल, नियमित कक्षाओं की तरह, जेनरिक हो सकते हैं। Protocol और Generic[T, S,...] को माता-पिता के रूप में निर्दिष्ट करने के बजाय Generic[T, S,...] आप बस Protocol[T, S,...] निर्दिष्ट कर सकते हैं

एक अन्य महत्वपूर्ण प्रकार का प्रोटोकॉल स्व-टाइप किया गया है ( PEP 484 देखें)। उदाहरण के लिए

 C = TypeVar('C', bound='Copyable') class Copyable(Protocol): def copy(self: C) -> C: class One: def copy(self) -> 'One': ...

इसके अलावा, प्रोटोकॉल का उपयोग तब किया जा सकता है जब Callable एनोटेशन सिंटैक्स पर्याप्त नहीं होता है।
बस वांछित हस्ताक्षर के __call__ विधि के साथ प्रोटोकॉल का वर्णन करें

रनटाइम चेक

यद्यपि प्रोटोकॉल मुख्य रूप से स्थैतिक विश्लेषक द्वारा उपयोग के लिए डिज़ाइन किए गए हैं, कभी-कभी यह जांचना आवश्यक है कि क्या वर्ग वांछित प्रोटोकॉल से संबंधित है।
इसे संभव बनाने के लिए, प्रोटोकॉल के लिए @runtime_checkable डेकोरेटर लागू करें और प्रोटोकॉल के अनुपालन की जांच करने के लिए isinstance / issubclass चेक शुरू हो जाएगा

हालाँकि, इस सुविधा में कई उपयोग प्रतिबंध हैं। विशेष रूप से, जेनरिक समर्थित नहीं हैं

टाइप किए गए शब्दकोश

आमतौर पर संरचित डेटा का प्रतिनिधित्व करने के लिए कक्षाएं (विशेष रूप से, डेटा कक्षाएं ) या नामित ट्यूपल्स का उपयोग किया जाता है।
लेकिन कभी-कभी, उदाहरण के लिए, एक json संरचना विवरण के मामले में, कुछ कुंजियों के साथ एक शब्दकोश होना उपयोगी हो सकता है।
PEP 589 TypedDict की अवधारणा का परिचय TypedDict , जो पहले mypy से विस्तार में उपलब्ध था

डिटैचेलास या टाइप किए गए टुपल्स की तरह, टाइप किए गए शब्दकोश को घोषित करने के दो तरीके हैं। वंशानुक्रम या कारखाने का उपयोग करके:

 class Book(TypedDict): title: str author: str AlsoBook = TypedDict("AlsoBook", {"title": str, "author": str}) # same as Book book: Book = {"title": "Fareneheit 481", "author": "Bradbury"} # ok other_book: Book = {"title": "Highway to Hell", "artist": "AC/DC"} # error: Extra key 'artist' for TypedDict "Book" another_book: Book = {"title": "Fareneheit 481"} # error: Key 'author' missing for TypedDict "Book"

टाइप किए गए शब्दकोश समर्थन विरासत:

 class BookWithDesc(Book): desc: str

डिफ़ॉल्ट रूप से, सभी शब्दकोश कुंजियों की आवश्यकता होती है, लेकिन आप कक्षा बनाते समय total=False पास करके इसे अक्षम कर सकते हैं।
यह केवल वर्तमान बॉक्स ऑफिस में वर्णित कुंजियों पर लागू होता है और विरासत में प्रभावित नहीं होता है

 class SimpleBook(TypedDict, total=False): title: str author: str simple_book: SimpleBook = {"title": "Fareneheit 481"} # ok

TypedDict का उपयोग TypedDict की कई सीमाएँ हैं। विशेष रूप से:

आइंस्टीन के माध्यम से रनटाइम में चेक समर्थित नहीं हैं
चाबियाँ शाब्दिक या अंतिम मान होनी चाहिए

इसके अलावा, .clear या del जैसे असुरक्षित ऑपरेशन ऐसे शब्दकोश के साथ निषिद्ध del ।
एक कुंजी पर काम करना जो शाब्दिक नहीं है, उसे भी निषिद्ध किया जा सकता है, क्योंकि इस मामले में अपेक्षित प्रकार के मूल्य को निर्धारित करना असंभव है

अंतिम संशोधन करनेवाला

पीईपी 591 कई उद्देश्यों के लिए अंतिम संशोधक (एक डेकोरेटर और एनोटेशन के रूप में) का परिचय देता है

एक वर्ग का पदनाम जिसमें से विरासत में मिलना असंभव है:

 from typing import final @final class Childfree: ... class Baby(Childfree): # error: Cannot inherit from final class "Childfree" ...

ओवरराइडिंग से निषिद्ध विधि का पदनाम:

 from typing import final class Base: @final def foo(self) -> None: ... class Derived(Base): def foo(self) -> None: # error: Cannot override final attribute "foo" (previously declared in base class "Base") ...

एक चर (फ़ंक्शन पैरामीटर। क्लास फ़ील्ड) का पदनाम, जिसे पुन: असाइन करने के लिए मना किया गया है।

 ID: Final[float] = 1 ID = 2 # error: Cannot assign to final name "ID" SOME_STR: Final = "Hello" SOME_STR = "oops" # error: Cannot assign to final name "SOME_STR" letters: Final = ['a', 'b'] letters.append('c') # ok class ImmutablePoint: x: Final[int] y: Final[int] # error: Final name must be initialized with a value def __init__(self) -> None: self.x = 1 # ok ImmutablePoint().x = 2 # error: Cannot assign to final attribute "x"

इस स्थिति में, फॉर्म का एक कोड self.id: Final = 123 की अनुमति है, लेकिन केवल __init__ विधि में

शाब्दिक

Literal पीईपी 586 में परिभाषित प्रकार का उपयोग तब किया जाता है जब आपको विशिष्ट मूल्यों पर शाब्दिक रूप से जांच करने की आवश्यकता होती है

उदाहरण के लिए, Literal[42] अर्थ है कि मूल्य के रूप में केवल 42 की उम्मीद है।
यह महत्वपूर्ण है कि न केवल मूल्य की समानता की जांच की जाती है, बल्कि इसके प्रकार (उदाहरण के लिए, यदि 0 की उम्मीद है तो गलत तरीके से उपयोग करना संभव नहीं होगा)।

 def give_me_five(x: Literal[5]) -> None: pass give_me_five(5) # ok give_me_five(5.0) # error: Argument 1 to "give_me_five" has incompatible type "float"; expected "Literal[5]" give_me_five(42) # error: Argument 1 to "give_me_five" has incompatible type "Literal[42]"; expected "Literal[5]"

इस मामले में, कई मूल्यों को कोष्ठक में प्रेषित किया जा सकता है, जो संघ के उपयोग के बराबर है (मूल्यों के प्रकार संयोग नहीं हो सकते हैं)।

भाव (उदाहरण के लिए, Literal[1+2] ) या उत्परिवर्तनीय प्रकारों के मानों का उपयोग मूल्यों के रूप में नहीं किया जा सकता है।

एक उपयोगी उदाहरण के रूप में, Literal का उपयोग open() फ़ंक्शन है, जो विशिष्ट mode मानों की अपेक्षा करता mode ।

रनटाइम में टाइपिंग हैंडल

यदि आप कार्यक्रम चल रहा है, तो विभिन्न प्रकार की जानकारी (जैसे मेरे ) संसाधित करना चाहते हैं,
get_origin और get_args फ़ंक्शन अब उपलब्ध हैं।

तो, X[Y, Z,...] के एक प्रकार के लिए X[Y, Z,...] टाइप X को मूल के रूप में लौटाया जाएगा, और तर्क के रूप में (Y, Z, ...)
यह ध्यान देने योग्य है कि यदि X collections मॉड्यूल से अंतर्निहित प्रकार या प्रकार के लिए एक उपनाम है, तो इसे मूल द्वारा प्रतिस्थापित किया जाएगा।

 assert get_origin(Dict[str, int]) is dict assert get_args(Dict[int, str]) == (int, str) assert get_origin(Union[int, str]) is Union assert get_args(Union[int, str]) == (int, str)

दुर्भाग्य से, __parameters__ लिए फ़ंक्शन नहीं था

पायथन 3.8 में नए प्रकार के एनोटेशन (प्रोटोकॉल, फाइनल, टाइप्डडिक्ट, लिटरल)