एक यौगिक withबयान से उठाए गए अपवादों की संभावित उत्पत्ति के बीच अंतर करना
एक withबयान में होने वाले अपवादों के बीच अंतर करना मुश्किल है क्योंकि वे विभिन्न स्थानों में उत्पन्न हो सकते हैं। अपवादों को निम्नलिखित स्थानों में से किसी एक से उठाया जा सकता है (या उसमें किए गए कार्य):
ContextManager.__init__ContextManager.__enter__- का शरीर
with
ContextManager.__exit__
अधिक जानकारी के लिए संदर्भ प्रबंधक प्रकार के बारे में प्रलेखन देखें ।
अगर हम इन विभिन्न मामलों के बीच अंतर करना चाहते हैं, तो केवल withएक में लपेटना try .. exceptपर्याप्त नहीं है। निम्नलिखित उदाहरण पर विचार करें (उदाहरण के ValueErrorरूप में लेकिन निश्चित रूप से इसे किसी अन्य अपवाद प्रकार के साथ प्रतिस्थापित किया जा सकता है):
try:
with ContextManager():
BLOCK
except ValueError as err:
print(err)
यहां exceptचार अलग-अलग स्थानों में उत्पन्न होने वाले अपवादों को पकड़ा जाएगा और इस तरह उनके बीच अंतर करने की अनुमति नहीं है। हम बाहर संदर्भ प्रबंधक वस्तु की इन्स्टेन्शियशन ले जाते हैं with, हम बीच भेद कर सकते __init__और BLOCK / __enter__ / __exit__:
try:
mgr = ContextManager()
except ValueError as err:
print('__init__ raised:', err)
else:
try:
with mgr:
try:
BLOCK
except TypeError: # catching another type (which we want to handle here)
pass
except ValueError as err:
# At this point we still cannot distinguish between exceptions raised from
# __enter__, BLOCK, __exit__ (also BLOCK since we didn't catch ValueError in the body)
pass
प्रभावी रूप से यह सिर्फ __init__भाग के साथ मदद करता है, लेकिन हम यह जांचने के लिए एक अतिरिक्त संतरी चर जोड़ सकते हैं कि क्या withनिष्पादित करने के लिए शरीर (यानी __enter__और दूसरों के बीच अंतर करना ) है:
try:
mgr = ContextManager() # __init__ could raise
except ValueError as err:
print('__init__ raised:', err)
else:
try:
entered_body = False
with mgr:
entered_body = True # __enter__ did not raise at this point
try:
BLOCK
except TypeError: # catching another type (which we want to handle here)
pass
except ValueError as err:
if not entered_body:
print('__enter__ raised:', err)
else:
# At this point we know the exception came either from BLOCK or from __exit__
pass
मुश्किल भाग से उत्पन्न होने वाले अपवादों के बीच अंतर करना है BLOCKऔर __exit__क्योंकि एक अपवाद जो withइच्छाशक्ति के शरीर से बच जाता है, उसे पारित किया जाएगा __exit__जो यह तय कर सकता है कि इसे कैसे संभालना है ( डॉक्स देखें )। हालांकि अगर __exit__खुद को उठाता है, तो मूल अपवाद को नए द्वारा बदल दिया जाएगा। इन मामलों से निपटने के लिए हम किसी भी संभावित अपवाद को संग्रहीत करने exceptके withलिए शरीर में एक सामान्य खंड जोड़ सकते हैं जो अन्यथा किसी का ध्यान नहीं भगाएगा और इसकी तुलना सबसे बाहरी exceptबाद में पकड़े गए व्यक्ति से करेगा - यदि वे वही हैं तो इसका मतलब मूल था BLOCKया अन्यथा यह था __exit__(मामले __exit__में बाहरी मान को एक वास्तविक मूल्य लौटाकर अपवाद को दबा देता हैexcept बस निष्पादित नहीं किया जाएगा)।
try:
mgr = ContextManager() # __init__ could raise
except ValueError as err:
print('__init__ raised:', err)
else:
entered_body = exc_escaped_from_body = False
try:
with mgr:
entered_body = True # __enter__ did not raise at this point
try:
BLOCK
except TypeError: # catching another type (which we want to handle here)
pass
except Exception as err: # this exception would normally escape without notice
# we store this exception to check in the outer `except` clause
# whether it is the same (otherwise it comes from __exit__)
exc_escaped_from_body = err
raise # re-raise since we didn't intend to handle it, just needed to store it
except ValueError as err:
if not entered_body:
print('__enter__ raised:', err)
elif err is exc_escaped_from_body:
print('BLOCK raised:', err)
else:
print('__exit__ raised:', err)
पीईपी 343 में उल्लिखित समकक्ष फॉर्म का उपयोग करके वैकल्पिक दृष्टिकोण
पीईपी 343 - "स्टेटमेंट वाला " स्टेटमेंट के बराबर "नॉन-विथ" वर्जन को निर्दिष्ट करता है with। यहाँ हम आसानी से विभिन्न भागों को लपेट सकते हैं try ... exceptऔर इस प्रकार विभिन्न संभावित त्रुटि स्रोतों के बीच अंतर कर सकते हैं:
import sys
try:
mgr = ContextManager()
except ValueError as err:
print('__init__ raised:', err)
else:
try:
value = type(mgr).__enter__(mgr)
except ValueError as err:
print('__enter__ raised:', err)
else:
exit = type(mgr).__exit__
exc = True
try:
try:
BLOCK
except TypeError:
pass
except:
exc = False
try:
exit_val = exit(mgr, *sys.exc_info())
except ValueError as err:
print('__exit__ raised:', err)
else:
if not exit_val:
raise
except ValueError as err:
print('BLOCK raised:', err)
finally:
if exc:
try:
exit(mgr, None, None, None)
except ValueError as err:
print('__exit__ raised:', err)
आमतौर पर एक सरल तरीका ठीक काम करेगा
इस तरह के विशेष अपवाद संचालन के लिए की जरूरत काफी दुर्लभ और सामान्य रूप से पूरे लपेटकर होना चाहिए withएक में try ... exceptब्लॉक पर्याप्त होगा। विशेष रूप से यदि विभिन्न त्रुटि स्रोतों को अलग-अलग (कस्टम) अपवाद प्रकारों से दर्शाया जाता है (संदर्भ प्रबंधकों को तदनुसार डिजाइन करने की आवश्यकता है) तो हम आसानी से उनके बीच अंतर कर सकते हैं। उदाहरण के लिए:
try:
with ContextManager():
BLOCK
except InitError: # raised from __init__
...
except AcquireResourceError: # raised from __enter__
...
except ValueError: # raised from BLOCK
...
except ReleaseResourceError: # raised from __exit__
...
withबयान जादुई रूप से एक आसपास के बयान को नहीं तोड़ता हैtry...except।