मेरे पास एक ही वस्तु के उदाहरणों का संग्रह है, जैसे (पायथन में - मेरा प्रश्न वास्तव में भाषा स्वतंत्र है)

class shopping_cart:
    def __init__(self, newID, newproduct, currentdate, dollars ):
        shopping_cart.customerID = newID
        shopping_cart.product = newproduct
        shopping_cart.date = currentdate
        shopping_cart.value = dollars

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

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

क्या ओओपी डिज़ाइन का उपयोग करने का कोई तरीका है जो मुझे उस संरचना से डेटा पर प्रदर्शन करने के लिए आवश्यक संचालन को अलग करके अंतर्निहित डेटा संरचनाओं को दोबारा करने की अनुमति देता है जिसमें डेटा सहेजा जाता है? (मुझे अपने कोड को फिर से लिखना पड़ सकता है और अपनी कक्षा को फिर से डिज़ाइन करना पड़ सकता है, लेकिन मैं इसे अभी करना चाहता हूं, इस तरह के एनकैप्सुलेशन का समर्थन करने के लिए, बाद में ऐसा करने के लिए, जहां मुझे ऑपरेशन को फिर से लिखने के लिए बहुत बड़ी रिफैक्टरिंग से गुजरना पड़ सकता है < em>और डेटा संरचनाएं एक साथ।)

0
l7ll7 26 अक्टूबर 2018, 19:49

1 उत्तर

सबसे बढ़िया उत्तर

मुझे लगता है कि आपका प्रश्न दो अलग-अलग चीजों को मिलाता है।

एक आपकी वस्तुओं को उन तरीकों से अलग कर रहा है जिन्हें आप उन पर लागू करना चाहते हैं। इसके लिए आगंतुक पैटर्न में आपकी रुचि होगी।

दूसरा बहुत सारी वस्तुओं को संसाधित करते समय प्रदर्शन बढ़ाने के बारे में है। इसके लिए आप पाइप और फ़िल्टर (या पाइपलाइन) पैटर्न पर विचार कर सकते हैं जहां आप वस्तुओं को विभाजित करते हैं अंत में समानांतर निष्पादन पाइपलाइनों और समूह परिणामों में उन्हें संसाधित करें।

एक फुटनोट के रूप में मुझे लगता है कि आपका मतलब था

class shopping_cart:
    def __init__(self, newID, newproduct, currentdate, dollars ):
        self.customerID = newID
        self.product = newproduct
        self.date = currentdate
        self.value = dollars

अन्यथा आप कक्षा के सदस्यों को सेट कर रहे हैं, उदाहरण के सदस्य नहीं।

1
progmatico 27 अक्टूबर 2018, 21:04