पायथन में प्रकार एनोटेशन की गहराई की खोज। भाग २

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



→ पहला भाग

पायथन डेटा प्रकारों का समर्थन कैसे करता है?

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

यहां तब होता है जब आप अपने पायथन कोड को निष्पादन के लिए तैयार करते हैं: “पायथन में, स्रोत कोड CPython का उपयोग करके एक बहुत ही सरल रूप में परिवर्तित किया जाता है जिसे बायटेकोड कहा जाता है। बाइटकोड में ऐसे निर्देश होते हैं, जो संक्षेप में, प्रोसेसर के निर्देशों के समान होते हैं। लेकिन उन्हें प्रोसेसर द्वारा निष्पादित नहीं किया जाता है, बल्कि एक वर्चुअल मशीन नामक एक सॉफ्टवेयर सिस्टम द्वारा किया जाता है। (यह वर्चुअल मशीनों के बारे में नहीं है जिनकी क्षमताएं आपको उन पर पूरे ऑपरेटिंग सिस्टम को चलाने की अनुमति देती हैं। हमारे मामले में, यह एक ऐसा वातावरण है जो प्रोसेसर पर चलने वाले कार्यक्रमों के लिए उपलब्ध पर्यावरण का एक सरलीकृत संस्करण है)। "

CPython को कैसे पता चलता है कि निष्पादन के लिए एक कार्यक्रम तैयार करते समय चर प्रकार क्या होना चाहिए? आखिरकार, हमने इन प्रकारों का संकेत नहीं दिया। सीपीथॉन को इस बारे में पता नहीं है। वह केवल इतना जानता है कि चर वस्तुएं हैं। पायथन में सब कुछ एक वस्तु है , कम से कम जब तक यह पता नहीं चलता है कि किसी चीज में अधिक विशिष्ट प्रकार है।

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

स्ट्रिंग और संख्या को जोड़ने का प्रयास करते समय दिखाई देने वाले निम्न त्रुटि संदेश पर विचार करें:

name = 'Vicki' seconds = 4.71; --------------------------------------------------------------------------- TypeError                 Traceback (most recent call last) <ipython-input-9-71805d305c0b> in <module>       3       4 ----> 5 name + seconds TypeError: must be str, not float 

सिस्टम हमें बताता है कि यह तार और फ्लोटिंग-पॉइंट नंबर नहीं जोड़ सकता है। इसके अलावा, तथ्य यह है कि name एक स्ट्रिंग है, और seconds एक संख्या है, जब तक name और seconds को जोड़ने का प्रयास नहीं किया गया था, तब तक ब्याज नहीं दिया।

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

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

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

कड़ाई से बोलते हुए, यहाँ हम पायथन में टाइप एनोटेशन के बारे में बातचीत करते हैं।

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

क्या होगा अगर हमें जटिल कार्यों के साथ काम करने की ज़रूरत है जो कई इनपुट मान लेते हैं जो पाइरॉच प्रलेखन से इसके समान हैं:

 def train(args, model, device, train_loader, optimizer, epoch):    model.train()    for batch_idx, (data, target) in enumerate(train_loader):        data, target = data.to(device), target.to(device)        optimizer.zero_grad()        output = model(data)        loss = F.nll_loss(output, target)        loss.backward()        optimizer.step()        if batch_idx % args.log_interval == 0:            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(                epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) 

model क्या है? बेशक, हम कोड बेस में खुदाई कर सकते हैं और पता लगा सकते हैं:

 model = Net().to(device) 

लेकिन यह अच्छा होगा यदि आप फ़ंक्शन हस्ताक्षर में model प्रकार को निर्दिष्ट कर सकते हैं और अपने आप को अनावश्यक कोड विश्लेषण से बचा सकते हैं। शायद यह इस तरह दिखेगा:

 def train(args, model (type Net), device, train_loader, optimizer, epoch): 

device बारे में क्या? यदि आप कोड के माध्यम से अफवाह करते हैं, तो आप निम्नलिखित का पता लगा सकते हैं:

 device = torch.device("cuda" if use_cuda else "cpu") 

अब हम इस सवाल का सामना कर रहे हैं कि torch.device क्या torch.device । यह एक विशेष प्रकार का PyTorch है। इसका विवरण PyTorch प्रलेखन के संबंधित अनुभाग में पाया जा सकता है।

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

 def train(args, model (type Net), device (type torch.Device), train_loader, optimizer, epoch): 

ये विचार बहुत लंबे समय तक जारी रह सकते हैं।

नतीजतन, यह पता चला है कि किसी भी कोड को लिखने के लिए एनोटेशन बहुत उपयोगी हैं। लेकिन वे उन लोगों को भी लाभान्वित करते हैं जो अन्य लोगों के कोड को पढ़ते हैं। कोड की तुलना में टाइप किए गए कोड को पढ़ना बहुत आसान है, यह समझने के लिए कि आपको एक इकाई क्या है से निपटना है। प्रकार एनोटेशन कोड पठनीयता में सुधार करते हैं।

तो, कोड को पठनीयता के समान स्तर पर लाने के लिए पायथन में क्या किया गया है जो सांख्यिकीय रूप से टाइप की गई भाषाओं में लिखे गए कोड को अलग करता है?

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

अब हम पायथन में टाइप एनोटेशन के बारे में गंभीरता से बात करने के लिए तैयार हैं। पायथन 2 में लिखे गए कार्यक्रमों को पढ़ते समय, कोई यह देख सकता है कि प्रोग्रामर ने कोड के पाठकों को यह बताकर अपने कोड की आपूर्ति की कि फंक्शंस द्वारा दिए गए चर या मान किस प्रकार के हैं।

समान कोड मूल रूप से इस तरह दिखता था :

 users = [] # type: List[UserID] examples = {} # type: Dict[str, Any] 

टाइप एनोटेशन सरल टिप्पणियाँ हुआ करती थीं। लेकिन ऐसा हुआ कि पायथन ने एनोटेशन को संभालने के एक समान तरीके से धीरे-धीरे बदलाव करना शुरू कर दिया। विशेष रूप से, हम दस्तावेज़ PEP 3107 के उद्भव के बारे में बात कर रहे हैं, जो फ़ंक्शन के एनोटेशन को समर्पित है।

इसके बाद, पीईपी 484 पर काम शुरू हुआ। यह दस्तावेज़, टाइप एनोटेशन के लिए समर्पित, मैपी, ड्रॉपबॉक्स प्रोजेक्ट के साथ निकट संबंध में विकसित किया गया था, जिसका उद्देश्य स्क्रिप्ट चलाने से पहले प्रकारों को सत्यापित करना है। मैपी का उपयोग करना, यह याद रखने योग्य है कि स्क्रिप्ट निष्पादन के दौरान प्रकार की जाँच नहीं की जाती है। एक त्रुटि संदेश रनटाइम पर प्राप्त किया जा सकता है यदि, उदाहरण के लिए, आप कुछ ऐसा प्रकार बनाने की कोशिश करते हैं जो इस प्रकार का समर्थन नहीं करता है। कहते हैं - यदि आप एक शब्दकोश को स्लाइस करने की कोशिश करते हैं या एक स्ट्रिंग के लिए .pop() विधि कहते हैं।

एनोटेशन कार्यान्वयन के विवरण के बारे में पीईपी 484 से आप यहां जान सकते हैं: “हालांकि ये एनोटेशन नियमित annotations विशेषताओं के माध्यम से रन टाइम पर उपलब्ध हैं, टाइप रन चेक रन टाइम पर नहीं किए जाते हैं। इसके बजाय, यह प्रस्ताव एक अलग स्टैंड-अलोन प्रकार के चेकिंग टूल के अस्तित्व के लिए प्रदान करता है, जिसके साथ उपयोगकर्ता, यदि वह चाहे, तो अपने कार्यक्रमों के स्रोत कोड की जांच कर सकता है। सामान्य तौर पर, एक समान प्रकार का चेकिंग टूल बहुत शक्तिशाली लिंटर की तरह काम करता है। "हालांकि, निश्चित रूप से, व्यक्तिगत उपयोगकर्ता रनटाइम पर प्रकारों की जांच के लिए एक समान उपकरण का उपयोग कर सकते हैं, या तो डिज़ाइन बाय कॉन्ट्रैक्टोलॉजी के कार्यान्वयन के लिए या जेआईटी अनुकूलन के कार्यान्वयन के लिए। लेकिन यह ध्यान दिया जाना चाहिए कि ऐसे उपकरण अभी तक पर्याप्त परिपक्वता तक नहीं पहुंचे हैं।"

टाइप एनोटेशन के साथ काम करना अभ्यास में कैसा लगता है?

उदाहरण के लिए, उनके उपयोग का मतलब विभिन्न आईडीई में काम की सुविधा की संभावना है। तो, PyCharm , ऑफ़र, प्रकार की जानकारी, कोड पूरा होने और सत्यापन के आधार पर प्रदान करता है। इसी तरह की सुविधाएँ वीएस कोड में उपलब्ध हैं।

टाइप एनोटेशन एक और कारण से उपयोगी होते हैं: वे डेवलपर को बेवकूफ त्रुटियों से बचाते हैं। यहाँ इस तरह के संरक्षण का एक बड़ा उदाहरण है।

मान लीजिए कि हम लोगों के नाम शब्दकोश में जोड़ते हैं:

 names = {'Vicki': 'Boykis',         'Kim': 'Kardashian'} def append_name(dict, first_name, last_name):    dict[first_name] = last_name   append_name(names,'Kanye',9) 

यदि हम इसकी अनुमति देते हैं, तो शब्दकोश में कई गलत तरीके से बनाई गई प्रविष्टियाँ होंगी।
चलो इसे ठीक करें:

 from typing import Dict names_new: Dict[str, str] = {'Vicki': 'Boykis',                             'Kim': 'Kardashian'} def append_name(dic: Dict[str, str] , first_name: str, last_name: str):    dic[first_name] = last_name append_name(names_new,'Kanye',9.7) names_new 

अब इस कोड को mypy से जांचें और निम्नलिखित प्राप्त करें:

 (kanye) mbp-vboykis:types vboykis$ mypy kanye.py kanye.py:9: error: Argument 3 to "append_name" has incompatible type "float"; expected "str" 

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

विभिन्न आईडीई में संकेत टाइप करें

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

उदाहरण के लिए, मान लें कि आपके पास कोड का एक टुकड़ा है जो निम्नलिखित जैसा दिखता है। यह वर्गों में लिपटे पिछले उदाहरणों से कुछ कार्य है।

 from typing import Dict class rainfallRate:    def __init__(self, hours, inches):        self.hours= hours        self.inches = inches    def calculateRate(self, inches:int, hours:int) -> float:        return inches/hours rainfallRate.calculateRate() class addNametoDict:    def __init__(self, first_name, last_name):        self.first_name = first_name        self.last_name = last_name        self.dict = dict    def append_name(dict:Dict[str, str], first_name:str, last_name:str):        dict[first_name] = last_name addNametoDict.append_name() 

अच्छी बात यह है कि हम अपनी पहल पर, कोड में प्रकार विवरण जोड़ते हैं, हम यह देख सकते हैं कि कार्यक्रम में तब क्या होता है जब कक्षा के तरीकों को कहा जाता है:



आईडीई टाइप टिप्स

टाइप एनोटेशन के साथ शुरुआत करना

कोडपी टाइप करने के साथ शुरू करने के लिए क्या शुरू करना है, इसके बारे में आपको दस्तावेज़ों में अच्छी सिफारिशें मिल सकती हैं:

1. छोटे से शुरू करें - सुनिश्चित करें कि कई एनोटेशन वाली कुछ फाइलें mypy के साथ मान्य हैं।
2. मैपी को चलाने के लिए एक स्क्रिप्ट लिखें। यह लगातार परीक्षण के परिणाम प्राप्त करने में मदद करेगा।
3. प्रकार की त्रुटियों को रोकने के लिए CI पाइपलाइनों में mypy चलाएं।
4. धीरे-धीरे मॉड्यूल का एनोटेट करें जो परियोजना में सबसे अधिक बार उपयोग किया जाता है।
5. मौजूदा कोड में टाइप एनोटेशन जोड़ें जिसे आप संशोधित कर रहे हैं; उन्हें आपके द्वारा लिखे गए नए कोड से लैस करें।
6. पुराने कोड को स्वचालित रूप से एनोटेट करने के लिए MonkeyType या PyAnnotate का उपयोग करें।

अपने स्वयं के कोड की व्याख्या करने से पहले, यह आपके लिए उपयोगी होगा कि आप किसी चीज़ से निपटें।

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

दूसरे, यह मॉड्यूल कई जटिल प्रकारों के साथ काम करना संभव बनाता है। इनमें Tuple , Tuple , List और Set । Dict[str, float] फॉर्म के निर्माण का मतलब है कि आप एक ऐसे शब्दकोश के साथ काम करना चाहते हैं, जिसके तत्व मान के रूप में एक कुंजी और एक फ्लोटिंग-पॉइंट नंबर के रूप में उपयोग करते हैं। Optional और Union नामक प्रकार भी हैं।

तीसरा, आपको अपने आप को प्रकार एनोटेशन के प्रारूप से परिचित करना होगा:

 import typing def some_function(variable: type) -> return_type:  do_something 

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

परिणाम। क्या पायथन में प्रकार एनोटेशन का उपयोग करना लायक है?

अब चलो अपने आप से पूछें कि क्या आपको पायथन में टाइप एनोटेशन का उपयोग करना चाहिए। दरअसल, यह आपके प्रोजेक्ट की सुविधाओं पर निर्भर करता है। इस बारे में गुइडो वैन रोसुम ने इस बारे में माईपी के लिए दस्तावेज में कहा है: “मैपी का उद्देश्य हर किसी को सांख्यिकीय रूप से टाइप किए गए पायथन कोड को लिखना नहीं है। अभी और भविष्य में स्टेटिक टाइपिंग पूरी तरह से वैकल्पिक है। Mypy का लक्ष्य पायथन प्रोग्रामर्स को अधिक विकल्प देना है। यह पायथन को बड़ी परियोजनाओं में प्रयुक्त अन्य सांख्यिकीय रूप से टाइप की जाने वाली भाषाओं के लिए अधिक प्रतिस्पर्धी विकल्प बनाना है। यह प्रोग्रामर्स की उत्पादकता बढ़ाने और सॉफ्टवेयर की गुणवत्ता में सुधार करना है। ”

मायपी को कॉन्फ़िगर करने और एक निश्चित कार्यक्रम के लिए आवश्यक प्रकारों की योजना बनाने के लिए आवश्यक समय छोटी परियोजनाओं में और प्रयोगों के दौरान (उदाहरण के लिए, ज्यूपिटर में प्रदर्शन किए गए) खुद को उचित नहीं ठहराता है। किस परियोजना को छोटा माना जाना चाहिए? संभवतः वह, जिसकी मात्रा, सावधानीपूर्वक अनुमान के अनुसार, 1000 रेखाओं से अधिक नहीं है।

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

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

प्रिय पाठकों! क्या आप अपने पायथन प्रोजेक्ट्स में टाइप एनोटेशन का उपयोग करते हैं?