परिचय

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

पायथन (गतिशील रूप से टाइप किया गया)

num = 4                # `num` is inferred as an integer
newString = "new string"  # `newString` is inferred as a string

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

सी (सांख्यिकीय रूप से टाइप किया गया)

int num = 4;            // `num` is declared as an integer
std::string newString = "new string";  // `newString` is declared as a string

MyPy का उपयोग क्यों करें?

पायथन जैसी गतिशील रूप से टाइप की गई भाषाओं में, रनटाइम पर टाइप त्रुटियां हो सकती हैं, जिससे बग पैदा हो सकते हैं जिनका पता लगाना कठिन होता है। MyPy आपको अपने पायथन कोड में टाइप संकेत जोड़ने की अनुमति देकर इसका समाधान करता है, जिसे निष्पादन से पहले स्थिर रूप से जांचा जा सकता है। यह कई लाभ प्रदान करता है:

• प्रारंभिक त्रुटि का पता लगाना: रनटाइम पर मिलने के बजाय विकास के दौरान प्रकार-संबंधित त्रुटियों की पहचान करें।
• बेहतर कोड पठनीयता: प्रकार संकेत अपेक्षित प्रकार के चर और फ़ंक्शन तर्कों को स्पष्ट करते हैं, कोड पठनीयता को बढ़ाते हैं।
• बेहतर आईडीई समर्थन: प्रकार के संकेतों का समर्थन करने वाले आईडीई में बेहतर कोड पूर्णता और इनलाइन दस्तावेज़ीकरण प्रदान करता है।

MyPy के साथ उदाहरण

यहां MyPy के साथ प्रकार संकेतों के उपयोग को प्रदर्शित करने वाला एक सरल उदाहरण दिया गया है:

प्रकार के संकेत के बिना

def add(a, b):
    return a   b

print(add(5, 3))      # Output: 8
print(add("hello", "world"))  # Output: helloworld

उपरोक्त कोड में, ऐड फ़ंक्शन पूर्णांक और स्ट्रिंग दोनों को स्वीकार कर सकता है, जो कि इच्छित व्यवहार नहीं हो सकता है।

टाइप संकेत के साथ

def add(a: int, b: int) -> int:
    return a   b

print(add(5, 3))      # Output: 8
# mypy will report an error for the following line:
# print(add("hello", "world"))  # TypeError: Expected int, got str

प्रकार संकेत (ए: इंट, बी: इंट) शामिल करके, आप निर्दिष्ट करते हैं कि ऐड केवल पूर्णांक के साथ काम करना चाहिए। MyPy इन प्रकार के संकेतों के विरुद्ध कोड की जांच करता है, संभावित प्रकार से संबंधित मुद्दों को पहले ही पकड़ लेता है।

MyPy को इंस्टाल करना और चलाना

MyPy के साथ आरंभ करने के लिए:

1. इंस्टॉलेशन: पाइप का उपयोग करके MyPy इंस्टॉल करें:

   python3 -m pip install mypy

1. MyPy चलाना: एक बार इंस्टॉल हो जाने पर, आप प्रकार की त्रुटियों के लिए अपने कोड की जांच करने के लिए MyPy चला सकते हैं। निम्न आदेश का प्रयोग करें:

   mypy program.py

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

MyPy का प्रभावी ढंग से उपयोग करने से आप इसकी गतिशील प्रकृति के लचीलेपन का आनंद लेते हुए, स्थिर टाइपिंग के लाभों को पायथन में एकीकृत कर सकते हैं।

आइए MyPy के साथ एक उदाहरण कोड करें

MyPy के बिना

def greeting(name):
    return 'Hello '   name

# These calls will fail when the program runs, but MyPy will not report an error
greeting(123)
greeting(b"Aniket")

मायपी के साथ

प्रकार एनोटेशन (जिसे प्रकार संकेत भी कहा जाता है) जोड़कर, MyPy संभावित समस्याओं का पता लगा सकता है:

def greeting(name: str) -> str:
    return 'Hello '   name

greeting(3)         # mypy will report: Argument 1 to "greeting" has incompatible type "int"; expected "str"
greeting(b'Alice')  # mypy will report: Argument 1 to "greeting" has incompatible type "bytes"; expected "str"
greeting("World!")  # No error

यहाँ:

• नाम: str एनोटेशन निर्दिष्ट करता है कि नाम तर्क एक स्ट्रिंग होना चाहिए।
• -> str एनोटेशन निर्दिष्ट करता है कि फ़ंक्शन ग्रीटिंग एक स्ट्रिंग लौटाएगा।

MyPy का उपयोग कब करें

MyPy कई स्थितियों में उपयोगी है:

• त्रुटियों को जल्दी पकड़ें: अपना कोड चलाने से पहले प्रकार-संबंधित त्रुटियों को ढूंढने के लिए MyPy का उपयोग करें। इससे गलतियों को जल्दी पकड़ने में मदद मिलती है और कोड विश्वसनीयता में सुधार होता है।

• कोड को स्पष्ट बनाएं: प्रकार संकेत जोड़ने से आपके कोड को समझना आसान हो जाता है। यह दर्शाता है कि किस प्रकार के मूल्यों की अपेक्षा की जाती है, जो दूसरों (और आपके भविष्य के स्वयं) को आपके कोड को बेहतर ढंग से समझने में मदद करता है।

• पुराने कोड को अपग्रेड करें: पुराने कोड को अपडेट करते समय, जब आप प्रकार के संकेत जोड़ते हैं, तो MyPy प्रकार की समस्याओं को ढूंढने में मदद करता है, जिससे संक्रमण आसान हो जाता है।

• प्रोटोटाइप में सुधार करें: नई सुविधाओं या प्रोटोटाइप का निर्माण करते समय, MyPy यह सुनिश्चित करने में मदद करता है कि नया कोड टाइप नियमों को लागू करके मौजूदा कोड के साथ सही ढंग से काम करता है।

• बड़ी परियोजनाओं को बनाए रखें: कई योगदानकर्ताओं वाली बड़ी परियोजनाओं में, MyPy कोड को सुसंगत रखने में मदद करता है और प्रकार से संबंधित बग को रोकता है।

• आईडीई सुविधाओं को बढ़ावा दें: यदि आप आईडीई का उपयोग करते हैं, तो MyPy कोड पूर्णता और नेविगेशन जैसी सुविधाओं में सुधार करता है, जिससे विकास आसान हो जाता है।

MyPy का उपयोग करने से आपको Python के लचीलेपन का आनंद लेते हुए बेहतर, अधिक विश्वसनीय Python कोड लिखने में मदद मिलती है।

mypy के लिए एक आधिकारिक त्वरित चीटशीट

1. आधिकारिक दस्तावेज़ीकरण ↩