पायथन की गतिशील प्रकृति और डक टाइपिंग के लिए समर्थन की उनके लचीलेपन के लिए लंबे समय से प्रशंसा की गई है। हालाँकि, जैसे-जैसे कोडबेस बड़े और अधिक जटिल होते जाते हैं, स्थैतिक प्रकार की जाँच के लाभ तेजी से स्पष्ट होते जाते हैं। लेकिन हम स्थैतिक प्रकार की जाँच की सुरक्षा के साथ डक टाइपिंग के लचीलेपन को कैसे समेट सकते हैं? पायथन की प्रोटोकॉल कक्षा दर्ज करें।

इस ट्यूटोरियल में, आप सीखेंगे:

1. डक टाइपिंग क्या है और यह पायथन में कैसे समर्थित है
2. बत्तख टाइपिंग के फायदे और नुकसान
3. एब्स्ट्रैक्ट बेस क्लासेस (एबीसी) टाइपिंग समस्याओं को कैसे हल करने का प्रयास करते हैं
4. दोनों दुनियाओं का सर्वश्रेष्ठ प्राप्त करने के लिए प्रोटोकॉल का उपयोग कैसे करें: स्थिर प्रकार की जांच के साथ डक टाइपिंग लचीलापन

डक टाइपिंग को समझना

डक टाइपिंग एक प्रोग्रामिंग अवधारणा है जहां किसी ऑब्जेक्ट का प्रकार या वर्ग उसके द्वारा परिभाषित तरीकों से कम महत्वपूर्ण है। यह इस विचार पर आधारित है कि "यदि यह बत्तख की तरह दिखता है, बत्तख की तरह तैरता है, और बत्तख की तरह टर्राता है, तो संभवतः यह बत्तख है।"

पायथन में, डक टाइपिंग पूरी तरह से समर्थित है। उदाहरण के लिए:

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing):  # Note: No type hint here
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)    # Output: Quack!
make_it_quack(person)  # Output: I'm imitating a duck!

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

डक टाइपिंग के फायदे और नुकसान

डक टाइपिंग कई फायदे प्रदान करती है:

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

हालांकि, इसमें कुछ कमियां भी हैं:

1. स्पष्टता का अभाव: यह अस्पष्ट हो सकता है कि किसी वस्तु को किन तरीकों को लागू करने की आवश्यकता है।
2. रनटाइम त्रुटियां: प्रकार-संबंधित त्रुटियां केवल रनटाइम पर पकड़ी जाती हैं।
3. कम आईडीई समर्थन: आईडीई सटीक स्वत: पूर्णता और त्रुटि जांच प्रदान करने के लिए संघर्ष करते हैं।

एबीसी समाधान

इन मुद्दों को संबोधित करने का एक तरीका एब्सट्रैक्ट बेस क्लासेस (एबीसी) का उपयोग करना है। यहाँ एक उदाहरण है:

from abc import ABC, abstractmethod

class Quacker(ABC):
    @abstractmethod
    def quack(self):
        pass

class Duck(Quacker):
    def quack(self):
        print("Quack!")

class Person(Quacker):
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing: Quacker):
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)
make_it_quack(person)

हालाँकि यह दृष्टिकोण बेहतर प्रकार की जाँच और स्पष्ट इंटरफ़ेस प्रदान करता है, इसके नुकसान भी हैं:

1. इसके लिए वंशानुक्रम की आवश्यकता होती है, जिससे अनम्य पदानुक्रम हो सकता है।
2. यह मौजूदा कक्षाओं के साथ काम नहीं करता है जिन्हें आप संशोधित नहीं कर सकते।
3. यह पायथन के "डक टाइपिंग" दर्शन के विरुद्ध है।

प्रोटोकॉल: दोनों दुनियाओं में सर्वश्रेष्ठ

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

from typing import Protocol

class Quacker(Protocol):
    def quack(self):...

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing: Quacker):
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)
make_it_quack(person)

आइए इसे तोड़ें:

1. हम एक क्वेकर प्रोटोकॉल को परिभाषित करते हैं जो हमारे अपेक्षित इंटरफ़ेस को निर्दिष्ट करता है।
2. हमारे डक और पर्सन वर्गों को किसी भी चीज़ से विरासत में मिलने की आवश्यकता नहीं है।
3. हम make_it_quack के साथ टाइप संकेतों का उपयोग यह निर्दिष्ट करने के लिए कर सकते हैं कि यह एक क्वेकर की अपेक्षा करता है।

यह दृष्टिकोण हमें कई लाभ देता है:

1. स्टेटिक टाइप चेकिंग: आईडीई और टाइप चेकर्स रनटाइम से पहले त्रुटियों को पकड़ सकते हैं।
2. किसी विरासत की आवश्यकता नहीं: मौजूदा कक्षाएं तब तक काम करती हैं जब तक उनके पास सही तरीके हैं।
3. इंटरफ़ेस साफ़ करें: प्रोटोकॉल स्पष्ट रूप से परिभाषित करता है कि कौन से तरीके अपेक्षित हैं।

यहां एक अधिक जटिल उदाहरण दिया गया है जो दिखाता है कि प्रोटोकॉल आपके डोमेन वर्गों (सर्कल, आयत) को सपाट रखते हुए आवश्यकतानुसार जटिल (आकार) कैसे हो सकते हैं:

from typing import Protocol, List

class Drawable(Protocol):
    def draw(self): ...

class Resizable(Protocol):
    def resize(self, factor: float): ...

class Shape(Drawable, Resizable, Protocol):
    pass

def process_shapes(shapes: List[Shape]):
    for shape in shapes:
        shape.draw()
        shape.resize(2.0)

# Example usage
class Circle:
    def draw(self):
        print("Drawing a circle")

    def resize(self, factor: float):
        print(f"Resizing circle by factor {factor}")

class Rectangle:
    def draw(self):
        print("Drawing a rectangle")

    def resize(self, factor: float):
        print(f"Resizing rectangle by factor {factor}")

# This works with any class that has draw and resize methods,
# regardless of its actual type or inheritance
shapes: List[Shape] = [Circle(), Rectangle()]
process_shapes(shapes)

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

सारांश

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

प्रोटोकॉल का उपयोग करके, आप यह कर सकते हैं:

1. अपने कोड के लिए स्पष्ट इंटरफ़ेस परिभाषित करें
2. बेहतर आईडीई प्राप्त करें, (स्थैतिक प्रकार की जांच), समर्थन करें और त्रुटियों को पहले पकड़ें
3. डक टाइपिंग का लचीलापन बनाए रखें
4. उन कक्षाओं के लिए प्रकार की जांच का लाभ उठाएं जिन्हें आप संशोधित करने में असमर्थ हैं।

यदि आप पायथन में प्रोटोकॉल और टाइप हिंटिंग के बारे में अधिक जानना चाहते हैं, तो टाइपिंग मॉड्यूल पर आधिकारिक पायथन दस्तावेज़ देखें, या mypy जैसे उन्नत स्थिर प्रकार जांच टूल का पता लगाएं।

हैप्पी कोडिंग, और आपकी बत्तखें हमेशा प्रकार की सुरक्षा के साथ चहकती रहें!

आप मेरे न्यूज़लेटर सहित मेरी अधिक सामग्री यहां पा सकते हैं