पायथन में सर्कुलर निर्भरता से कैसे बचें

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

कक्षा ए: def __init__(स्वयं, b_instance): self.b_instance = b_instance कक्षा बी: def __init__(स्वयं, a_instance): self.a_instance = a_instance

इस उदाहरण में, A को प्रारंभ करने के लिए B के एक उदाहरण की आवश्यकता होती है, और B को प्रारंभ करने के लिए A के एक उदाहरण की आवश्यकता होती है, जिससे एक परिपत्र निर्भरता बनती है।

class A:
    def __init__(self, b_instance):
        self.b_instance = b_instance

class B:
    def __init__(self, a_instance):
        self.a_instance = a_instance

पायथन में सर्कुलर निर्भरता से बचने के लिए, निम्नलिखित रणनीतियों पर विचार करें:

1. आयात को स्थगित करना

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

def get_a_instance(): b से आयात B # केवल तभी आयात करें जब a_instance की आवश्यकता हो वापसी ए(बी()) def get_b_instance(): आयात A से # आयात A केवल तभी करें जब b_instance की आवश्यकता हो वापसी बी(ए())

2. चक्र को तोड़ना

def get_a_instance():
    from b import B  # Import B only when a_instance is needed
    return A(B())

def get_b_instance():
    from a import A  # Import A only when b_instance is needed
    return B(A())

क्लास फ़ैक्टरी: def create_a(स्वयं): a_instance = ए() b_instance = self.create_b() # self पर कॉल करके सर्कुलर निर्भरता से बचें a_instance.b_instance = b_instance a_instance लौटाएँ def create_b(स्वयं): b_instance = B() a_instance = self.create_a() # self पर कॉल करके सर्कुलर निर्भरता से बचें b_instance.a_instance = a_instance वापसी b_instance

निष्कर्ष

class Factory:
    def create_a(self):
        a_instance = A()
        b_instance = self.create_b()  # Avoid circular dependency by calling to self
        a_instance.b_instance = b_instance
        return a_instance

    def create_b(self):
        b_instance = B()
        a_instance = self.create_a()  # Avoid circular dependency by calling to self
        b_instance.a_instance = a_instance
        return b_instance