पायथन पैनिक / डिफर एरर हैंडलिंग

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


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

func CopyFile(dstName, srcName string) (written int64, err error) { src, err := os.Open(srcName) if err != nil { return } defer src.Close() dst, err := os.Create(dstName) if err != nil { return } defer dst.Close() return io.Copy(dst, src) } 

आप यहाँ और पढ़ सकते हैं। जब एक आस्थगित फ़ंक्शन को निर्दिष्ट किया जाता है, तो तर्क तय हो जाते हैं, और कॉल फ़ंक्शन वाले अंत में होता है। यदि आप किसी त्रुटि राज्य के साथ फ़ंक्शन के निष्पादन को बाधित करना चाहते हैं, तो आपको घबराहट () फ़ंक्शन को कॉल करना होगा। इस मामले में, रिवर्स ऑर्डर में, स्थगित कार्यों को कहा जाता है। यदि उनमें से किसी एक में रिकवरी () फ़ंक्शन को बुलाया जाता है, तो गलत स्थिति को हटा दिया जाता है, और विधि से लौटने के बाद, प्रोग्राम सामान्य क्रम में चलेगा।

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

 # Go-style error handling import inspect import sys def panic(x): raise Exception(x) def defer(x): for f in inspect.stack(): if '__defers__' in f[0].f_locals: f[0].f_locals['__defers__'].append(x) break def recover(): val = None for f in inspect.stack(): loc = f[0].f_locals if f[3] == '__exit__' and '__suppress__' in loc: val = loc['exc_value'] loc['__suppress__'].append(True) break return val class DefersContainer(object): def __init__(self): # List for sustain refer in shallow clone self.defers = [] def append(self, defer): self.defers.append(defer) def __enter__(self): pass def __exit__(self, exc_type, exc_value, traceback): __suppress__ = [] for d in reversed(self.defers): try: d() except: __suppress__ = [] exc_type, exc_value, traceback = sys.exc_info() return __suppress__ def defers_collector(func): def __wrap__(*args, **kwargs): __defers__ = DefersContainer() with __defers__: func(*args, **kwargs) return __wrap__ @defers_collector def func(): f = open('file.txt', 'w') defer(lambda: f.close()) defer(lambda : print("Defer called!")) def my_defer(): recover() defer(lambda: my_defer()) print("Ok )") panic("WTF?") print("Never printed (((") func() print("Recovered!") 

मैं लंबर स्टेटमेंट के व्यवहार को दोहराने के लिए एक आस्थगित कॉल पर तर्क रखने के लिए लैम्ब्डा का उपयोग करता हूं।

मैंने बारीकियों में कार्यात्मक पहचान का परीक्षण नहीं किया। लेकिन अगर आपको पता है कि आपको क्या परिष्कृत करना है, तो लिखें।