"आउटसोर्सिंग" एक सजावटी को अपवाद-हैंडलिंग

Question

कई कोशिश/छोड़कर/आखिरकार खंड न केवल मेरे कोड को "उलझन" करते हैं, लेकिन मैं अक्सर इसी तरह के कार्यों के लिए समान अपवाद-हैंडलिंग का उपयोग करता हूं। तो मैं उन्हें "आउटसोर्सिंग" द्वारा सजावट को कम करने पर विचार कर रहा था ... सजावटी।

क्योंकि मुझे यकीन है कि इस निष्कर्ष पर आने वाला पहला व्यक्ति नहीं होना चाहिए, मैंने इसे गुमराह किया और पाया - imho - ingenious recipe जो एक से अधिक अपवाद को संभालने की संभावना को जोड़ता है।

लेकिन मुझे आश्चर्य हुआ कि यह एक व्यापक ज्ञात और प्रयुक्त अभ्यास क्यों नहीं प्रतीत होता है, इसलिए मैं सोच रहा था कि क्या कोई पहलू है जिस पर मैं विचार नहीं कर रहा था?

1. क्या यह अपवाद-हैंडलिंग के लिए सजावटी पैटर्न का उपयोग करने के लिए फर्जी है या क्या मैंने इसे पूरे समय याद किया है? कृपया मुझे ज्ञान दो! नुकसान क्या हैं?

2. क्या वहां कोई पैकेज/मॉड्यूल भी हो सकता है जो उचित तरीके से ऐसे अपवाद-संचालन के निर्माण का समर्थन करता है?

Answer 1

कोड में कोशिश/छोड़ने/आखिरकार ब्लॉक को रखने का सबसे बड़ा कारण यह है कि त्रुटि पुनर्प्राप्ति आमतौर पर फ़ंक्शन का एक अभिन्न हिस्सा होता है।

उदाहरण के लिए, यदि हम अपने ही int() समारोह था:

def MyInt(text): 
    return int(text) 

हम क्या करना चाहिए अगर text परिवर्तित नहीं किया जा सकता है? वापसी 0? वापसी None?

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

class ConvertExceptions(object): 

    func = None 

    def __init__(self, exceptions, replacement=None): 
     self.exceptions = exceptions 
     self.replacement = replacement 

    def __call__(self, *args, **kwargs): 
     if self.func is None: 
      self.func = args[0] 
      return self 
     try: 
      return self.func(*args, **kwargs) 
     except self.exceptions: 
      return self.replacement 

और नमूना उपयोग::

यहाँ एक सरल डेकोरेटर दृष्टिकोण पर मेरी ले है

@ConvertExceptions(ValueError, 0) 
def my_int(value): 
    return int(value) 

print my_int('34')  # prints 34 
print my_int('one')  # prints 0 

Answer 2

असल में, दोष यह है कि अब आप यह तय नहीं कर पाएंगे कि कॉलिंग संदर्भ में अपवाद को कैसे संभालना है (केवल अपवाद प्रचार को छोड़कर)। कुछ मामलों में इसका परिणाम जिम्मेदारी को अलग करने की कमी हो सकती है।

Answer 3

1. पायथन में सजावट सजावटी पैटर्न के समान नहीं है, सोचा कि कुछ समानता है। यह पूरी तरह से स्पष्ट नहीं है कि आपका मतलब है, लेकिन मुझे लगता है कि आपका मतलब पाइथन से है (इस प्रकार, शब्द पैटर्न का उपयोग न करना बेहतर है)

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

3. सजावटी के बजाय आप संदर्भ प्रबंधक का उपयोग कर सकते हैं। और मैं उस उद्देश्य के लिए उनका उपयोग करता हूं।