पायथन में अपवादों को संभालने का सही तरीका?

Question

मैंने अन्य पोस्ट की खोज की है, क्योंकि मुझे लगा कि यह एक आम समस्या है, लेकिन मुझे मिले अन्य सभी पायथन अपवाद प्रश्नों ने मेरी समस्या को प्रतिबिंबित नहीं किया है।

मैं जितना संभव हो उतना विशिष्ट होने की कोशिश करूंगा, इसलिए मैं एक प्रत्यक्ष उदाहरण दूंगा। और pleeeeease इस विशिष्ट समस्या के लिए कोई कामकाज पोस्ट नहीं करते हैं। मुझे विशेष रूप से दिलचस्पी नहीं है कि आप xyz के साथ एक ईमेल कितना अच्छा भेज सकते हैं। मैं जानना चाहता हूं कि आप आम तौर पर निर्भर, त्रुटि प्रवण बयान से कैसे निपटते हैं।

मेरा सवाल यह है कि, एक दूसरे पर निर्भर होने वाले अपवादों को अच्छी तरह से कैसे संभालना है, जिसका अर्थ है: केवल पहला चरण सफल होने पर, अगला प्रयास करें, और इसी तरह। एक और मानदंड है: सभी अपवादों को पकड़ा जाना है, यह कोड मजबूत होना चाहिए।

आपके विचार के लिए, एक उदाहरण:

try: 
    server = smtplib.SMTP(host) #can throw an exception 
except smtplib.socket.gaierror: 
    #actually it can throw a lot more, this is just an example 
    pass 
else: #only if no exception was thrown we may continue 
    try: 
     server.login(username, password) 
    except SMTPAuthenticationError: 
     pass # do some stuff here 
    finally: 
     #we can only run this when the first try...except was successful 
     #else this throws an exception itself! 
     server.quit() 
    else: 
     try: 
      # this is already the 3rd nested try...except 
      # for such a simple procedure! horrible 
      server.sendmail(addr, [to], msg.as_string()) 
      return True 
     except Exception: 
      return False 
     finally: 
      server.quit() 

return False 

यह मेरे लिए अत्यंत unpythonic लग रहा है, और कोड से निपटने त्रुटि ट्रिपल वास्तविक व्यापार कोड है, लेकिन दूसरी ओर मैं कई बयान हैं कि कैसे संभाल कर सकते हैं एक दूसरे पर निर्भर, अर्थात् कथन 1 कथन 2 के लिए पूर्व शर्त है और इसी तरह?

मुझे उचित संसाधन सफाई में भी रूचि है, यहां तक ​​कि पायथन भी इसे अपने लिए प्रबंधित कर सकता है।

धन्यवाद, टॉम

Answer 1

इसके बजाय/छोड़कर बाकी ब्लॉक देता है तो आप वापस आ सकता है जब यह त्रुटियों:

def send_message(addr, to, msg): 
    ## Connect to host 
    try: 
     server = smtplib.SMTP(host) #can throw an exception 
    except smtplib.socket.gaierror: 
     return False 

    ## Login 
    try: 
     server.login(username, password) 
    except SMTPAuthenticationError: 
     server.quit() 
     return False 

    ## Send message 
    try: 
     server.sendmail(addr, [to], msg.as_string()) 
     return True 
    except Exception: # try to avoid catching Exception unless you have too 
     return False 
    finally: 
     server.quit() 

कि पूरी तरह से पठनीय और pythonic है ..

ऐसा करने का एक और तरीका है, बल्कि चिंता से विशिष्ट कार्यान्वयन के बारे में यह तय कर लें तो आप अपने कोड उदाहरण के लिए, देखने के लिए चाहते हैं ..

sender = MyMailer("username", "password") # the except SocketError/AuthError could go here 
try: 
    sender.message("addr..", ["to.."], "message...") 
except SocketError: 
    print "Couldn't connect to server" 
except AuthError: 
    print "Invalid username and/or password!" 
else: 
    print "Message sent!" 

फिर message() विधि, सीए के लिए कोड लिखने आप जिस भी त्रुटि की अपेक्षा करते हैं उसे खींचते हैं, और अपना खुद का कस्टम उठाते हैं, और इसे संभालते हैं जहां यह प्रासंगिक है। आपका वर्ग कुछ लग सकता है की तरह ..

class ConnectionError(Exception): pass 
class AuthError(Exception): pass 
class SendError(Exception): pass 

class MyMailer: 
    def __init__(self, host, username, password): 
     self.host = host 
     self.username = username 
     self.password = password 

    def connect(self): 
     try: 
      self.server = smtp.SMTP(self.host) 
     except smtplib.socket.gaierror: 
      raise ConnectionError("Error connecting to %s" % (self.host)) 

    def auth(self): 
     try: 
      self.server.login(self.username, self.password) 
     except SMTPAuthenticationError: 
      raise AuthError("Invalid username (%s) and/or password" % (self.username)) 

    def message(self, addr, to, msg): 
     try: 
      server.sendmail(addr, [to], msg.as_string()) 
     except smtplib.something.senderror, errormsg: 
      raise SendError("Couldn't send message: %s" % (errormsg)) 
     except smtp.socket.timeout: 
      raise ConnectionError("Socket error while sending message") 

Answer 2

क्यों एक बड़ी कोशिश नहीं: ब्लॉक? इस तरह, यदि कोई अपवाद पकड़ा जाता है, तो आप इसे छोड़कर सभी तरह से जाएंगे। और जब तक विभिन्न चरणों के लिए सभी अपवाद अलग-अलग होते हैं, तब तक आप हमेशा यह बता सकते हैं कि यह कौन सा हिस्सा अपवाद निकाल दिया गया था।

Answer 3

सामान्य रूप से, आप जितना संभव हो उतने प्रयास ब्लॉक का उपयोग करना चाहते हैं, जिससे वे अपवादों के प्रकारों को विफल कर सकते हैं। उदाहरण के लिए, यहाँ कोड आप पोस्ट की मेरी रिफैक्टरिंग है:

try: 
    server = smtplib.SMTP(host) 
    server.login(username, password) # Only runs if the previous line didn't throw 
    server.sendmail(addr, [to], msg.as_string()) 
    return True 
except smtplib.socket.gaierror: 
    pass # Couldn't contact the host 
except SMTPAuthenticationError: 
    pass # Login failed 
except SomeSendMailError: 
    pass # Couldn't send mail 
finally: 
    if server: 
     server.quit() 
return False 

यहाँ, हम इस तथ्य का उपयोग करें कि smtplib.SMTP(), server.login(), और server.sendmail() सभी समतल करने के लिए विभिन्न अपवाद फेंक कोशिश-पकड़ ब्लॉक का पेड़। अंत में ब्लॉक हम शून्य ऑब्जेक्ट पर छोड़ने() को आमंत्रित करने से बचने के लिए स्पष्ट रूप से सर्वर का परीक्षण करते हैं।

हम भी तीन अनुक्रमिक कोशिश पकड़ ब्लॉक इस्तेमाल कर सकते हैं, अपवाद की स्थिति में झूठी लौटने, अगर वहाँ ओवरलैपिंग अपवाद मामलों को अलग से नियंत्रित किया जा करने की आवश्यकता है:

try: 
    server = smtplib.SMTP(host) 
except smtplib.socket.gaierror: 
    return False # Couldn't contact the host 

try: 
    server.login(username, password) 
except SMTPAuthenticationError: 
    server.quit() 
    return False # Login failed 

try: 
    server.sendmail(addr, [to], msg.as_string()) 
except SomeSendMailError: 
    server.quit() 
    return False # Couldn't send mail 

return True 

यह काफी के रूप में नहीं है अच्छा, क्योंकि आपको सर्वर को एक से अधिक स्थानों पर मारना है, लेकिन अब हम विशिष्ट अपवाद प्रकारों को बिना किसी अतिरिक्त स्थिति को बनाए रखे विभिन्न स्थानों में विभिन्न तरीकों को संभाल सकते हैं।

Answer 4

मुझे डेविड का जवाब पसंद है, लेकिन यदि आप सर्वर अपवादों पर फंस गए हैं तो आप सर्वर या किसी भी राज्य के लिए भी जांच सकते हैं। मैंने थोड़ी सी विधि को फटकार दिया, यह अभी भी एक लेकिन अवांछित दिख रहा है लेकिन नीचे तर्क में अधिक पठनीय है।

server = None 

def server_obtained(host): 
    try: 
     server = smtplib.SMTP(host) #can throw an exception 
     return True 
    except smtplib.socket.gaierror: 
     #actually it can throw a lot more, this is just an example 
     return False 

def server_login(username, password): 
    loggedin = False 
    try: 
     server.login(username, password) 
     loggedin = True 
    except SMTPAuthenticationError: 
     pass # do some stuff here 
    finally: 
     #we can only run this when the first try...except was successful 
     #else this throws an exception itself! 
     if(server is not None): 
      server.quit() 
    return loggedin 

def send_mail(addr, to, msg): 
    sent = False 
    try: 
     server.sendmail(addr, to, msg) 
     sent = True 
    except Exception: 
     return False 
    finally: 
     server.quit() 
    return sent 

def do_msg_send(): 
    if(server_obtained(host)): 
     if(server_login(username, password)): 
      if(send_mail(addr, [to], msg.as_string())): 
       return True 
    return False 

Answer 5

बस एक कोशिश-ब्लॉक का उपयोग करने का तरीका है। यह वही है जो वे के लिए डिज़ाइन किए गए हैं: पिछले कथन ने अपवाद फेंकने पर केवल अगले कथन को निष्पादित किया है। संसाधन क्लीन-अप के लिए, शायद यदि आप (जैसे Myfile को साफ़ करने की आवश्यकता है तो आप संसाधन की जांच कर सकते हैं।is_open(), ...) यह कुछ अतिरिक्त शर्तों को जोड़ता है, लेकिन वे केवल असाधारण मामले में निष्पादित किए जाएंगे। केस को संभालने के लिए कि अलग-अलग कारणों से एक ही अपवाद उठाया जा सकता है, आप अपवाद से कारण पुनर्प्राप्त करने में सक्षम होना चाहिए।

मैं इस तरह कोड का सुझाव:

server = None 
try: 
    server = smtplib.SMTP(host) #can throw an exception 
    server.login(username, password) 
    server.sendmail(addr, [to], msg.as_string()) 
    server.quit() 
    return True 
except smtplib.socket.gaierror: 
    pass # do some stuff here 
except SMTPAuthenticationError: 
    pass # do some stuff here 
except Exception, msg: 
    # Exception can have several reasons 
    if msg=='xxx': 
     pass # do some stuff here 
    elif: 
     pass # do some other stuff here 

if server: 
    server.quit() 

return False 

यह है कोई असामान्य, कोड से निपटने कि त्रुटि व्यवसाय कोड से अधिक है। सही त्रुटि हैंडलिंग जटिल हो सकती है। लेकिन रखरखाव बढ़ाने के लिए यह त्रुटि कोडिंग कोड से व्यवसाय कोड को अलग करने में मदद करता है। कोशिश का उपयोग करने का

Answer 6

अगर यह मैं था मैं शायद निम्नलिखित की तरह कुछ करना होगा: सफलता पर

try: 
    server = smtplib.SMTP(host) 
    try: 
     server.login(username, password) 
     server.sendmail(addr, [to], str(msg)) 
    finally: 
     server.quit() 
except: 
    debug("sendmail", traceback.format_exc().splitlines()[-1]) 
    return True 

सभी त्रुटियों को पकड़ लिया और डिबग, वापसी मान रहे == सच , और प्रारंभिक कनेक्शन किए जाने पर सर्वर कनेक्शन ठीक से साफ़ किया जाता है। अगर वे सफल हो गए वे सच लौटने के लिए, और जब तक वे वास्तव में संभाल एक अपवाद:

class Mailer(): 

    def send_message(self): 
     exception = None 
     for method in [self.connect, 
         self.authenticate, 
         self.send, 
         self.quit]: 
      try: 
       if not method(): break 
      except Exception, ex: 
       exception = ex 
       break 

     if method == quit and exception == None: 
      return True 

     if exception: 
      self.handle_exception(method, exception) 
     else: 
      self.handle_failure(method) 

    def connect(self): 
     return True 

    def authenticate(self): 
     return True 

    def send(self): 
     return True 

    def quit(self): 
     return True 

    def handle_exception(self, method, exception): 
     print "{name} ({msg}) in {method}.".format(
      name=exception.__class__.__name__, 
      msg=exception, 
      method=method.__name__) 

    def handle_failure(self, method): 
     print "Failure in {0}.".format(method.__name__) 

सभी पद्धतियों का (send_message सहित, वास्तव में) का पालन ही प्रोटोकॉल:

Answer 7

मैं कुछ इस तरह की कोशिश करेगा वे इसे फंस नहीं करते हैं। यह प्रोटोकॉल उस मामले को संभालना भी संभव बनाता है जहां एक विधि को इंगित करने की आवश्यकता होती है कि यह अपवाद उठाए बिना विफल रहा। (यदि आपके तरीकों में असफल होने का एकमात्र तरीका अपवाद उठाकर है, तो प्रोटोकॉल को सरल बना दिया जाता है। यदि आपको विफल होने वाली विधि के बाहर कई गैर-अपवाद विफलता राज्यों से निपटना पड़ता है, तो संभवतः आपके पास एक डिज़ाइन समस्या है अभी तक काम नहीं किया है।)

इस दृष्टिकोण का नकारात्मक पक्ष यह है कि सभी विधियों को एक ही तर्क का उपयोग करना होगा। मैंने उम्मीद की है कि मैंने जिस तरीके से स्टब किया है, वह वर्ग के सदस्यों को जोड़ना समाप्त कर देगा।

हालांकि, इस दृष्टिकोण का उछाल काफी महत्वपूर्ण है। सबसे पहले, आप बिना किसी जटिल होने के send_message के बिना प्रक्रिया में दर्जनों तरीकों को जोड़ सकते हैं।

तुम भी पागल जाने के लिए और कुछ इस तरह कर सकते हैं:

def handle_exception(self, method, exception): 
    custom_handler_name = "handle_{0}_in_{1}".format(\ 
              exception.__class__.__name__, 
              method.__name__) 
    try: 
     custom_handler = self.__dict__[custom_handler_name] 
    except KeyError: 
     print "{name} ({msg}) in {method}.".format(
      name=exception.__class__.__name__, 
      msg=exception, 
      method=method.__name__) 
     return 
    custom_handler() 

def handle_AuthenticationError_in_authenticate(self): 
    print "Your login credentials are questionable." 

... हालांकि उस बिंदु पर, मैं अपने आप से कह सकते हैं, "आत्म, आप कमान पैटर्न काम कर रहे हैं बहुत मुश्किल बनाने के बिना एक कमांड क्लास। शायद अब समय है।"