Korrekter Weg, Ausnahmen in Python zu behandeln?

Question

Ich habe nach anderen Posts gesucht, da ich dachte, dass dies ein ziemlich häufiges Problem ist, aber alle anderen Python-Ausnahmefragen, die ich gefunden habe, spiegelten mein Problem nicht wider.

Ich werde versuchen, so spezifisch wie möglich zu sein, also werde ich ein direktes Beispiel geben. Und peeeeease postet keine Problemumgehungen für dieses spezielle Problem. Ich bin nicht speziell daran interessiert, wie man mit xyz eine Email viel schöner versenden kann. Ich möchte wissen, wie Sie im Allgemeinen mit abhängigen, fehleranfälligen Aussagen umgehen.

Meine Frage ist, wie man Ausnahmen gut behandelt, die voneinander abhängen, was bedeutet: Nur wenn der erste Schritt erfolgreich war, versuchen Sie die nächste, und so weiter. Ein weiteres Kriterium ist: Alle Ausnahmen müssen abgefangen werden, dieser Code muss robust sein.

Für Ihre Überlegung, ein Beispiel:

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 

Das sieht extrem unpythonic mir, und der Fehlercode Handhabung ist das Dreifache der realen Business-Code, aber auf der anderen Seite, wie kann ich einige Aussagen behandeln, sind voneinander abhängig, dh Aussage1 ist Voraussetzung für Aussage2 und so weiter?

Ich interessiere mich auch für die ordnungsgemäße Ressourcenbereinigung, sogar Python kann das für sich selbst verwalten.

Danke, Tom

Answer 1

Anstatt den Versuch zu verwenden/außer else-Block ist, können Sie einfach zurück, wenn es Fehler:

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() 

, die perfekt lesbar und Pythonic ist ..

Ein anderer Weg, dies zu tun ist, anstatt Sorge über die konkrete Umsetzung entscheiden, wie Sie Ihren Code zum Beispiel zu sehen, wollen ..

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!" 

Dann den Code für die message() Methode, ca schreiben tching alle Fehler, die Sie erwarten, und erhöhen Sie Ihre eigenen benutzerdefinierten, und behandeln Sie, wo es relevant ist. Ihre Klasse kann so etwas wie aussehen ..

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

Warum nicht einen großen Versuch: Block? Auf diese Weise werden Sie, wenn eine Ausnahme abgefangen wird, den ganzen Weg zur Ausnahme gehen. Und solange alle Ausnahmen für die verschiedenen Schritte unterschiedlich sind, können Sie immer feststellen, welcher Teil die Ausnahme ausgelöst hat.

Answer 3

Im Allgemeinen möchten Sie so wenig Testblöcke wie möglich verwenden, um Fehlerbedingungen durch die Art der Ausnahmen zu unterscheiden, die sie auslösen. Zum Beispiel, hier ist meine Refactoring des Codes Sie auf dem Laufenden:

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 

Hier nutzen wir die Tatsache, dass smtplib.SMTP(), server.login() und server.sendmail() alle verschiedenen Ausnahmen werfen abzuflachen der Baum der Try-Catch-Blöcke. Im finally-Block testen wir Server explizit, um den Aufruf von quit() für das nil-Objekt zu vermeiden.

Wir haben auch drei sequentielle Try-Catch-Blöcke verwenden könnte, falsch in den Ausnahmebedingungen zurückkehrt, wenn es überlappende Ausnahmefälle sind, die separat behandelt werden müssen:

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 

Dies ist nicht ganz so schön, da Sie den Server an mehr als einem Ort töten müssen, aber jetzt können wir bestimmte Ausnahmetypen auf unterschiedliche Weise an verschiedenen Orten behandeln, ohne einen zusätzlichen Status zu erhalten.

Answer 4

Ich mag Davids Antwort, aber wenn Sie auf den Server-Ausnahmen stecken, können Sie auch nach Server suchen, wenn keine oder Staaten. Ich habe die Methode ein wenig abgeflacht, sie ist immer noch ein unpythonisches, aber in der unteren Logik besser lesbar.

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

Mit nur einem Try-Block ist der Weg zu gehen. Dies ist genau das, was sie sind entworfen für: nur die nächste Anweisung ausführen, wenn die vorherige Anweisung keine Ausnahme ausgelöst. Wie für die Ressourcenbereinigungen, vielleicht können Sie die Ressource überprüfen, wenn es gereinigt werden muss (z. B. myfile.is_open(), ...) Dies fügt einige zusätzliche Bedingungen hinzu, aber sie werden nur im Ausnahmefall ausgeführt. Zur Behandlung des Falls , dass die gleiche Ausnahme aus verschiedenen Gründen ausgelöst werden kann, sollten Sie den Grund von der Ausnahme abrufen können.

Ich schlage vor, Code wie folgt:

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 

Es ist nicht ungewöhnlich, dass Fehlercode überschreitet Code Geschäfts Handhabung. Die korrekte Fehlerbehandlung kann komplex sein. Um die Wartbarkeit zu erhöhen, hilft es jedoch, den Geschäftscode vom Fehlerbehandlungscode zu trennen.

Answer 6

Wenn es mir war ich wohl so etwas wie das folgende tun würde:

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 

Alle Fehler werden gefangen und auf Fehler, den Rückgabewert == true bei Erfolg und die Serververbindung wird ordnungsgemäß bereinigt, wenn die anfängliche Verbindung hergestellt wird.

Answer 7

würde ich so etwas wie dies versuchen:

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__) 

Alle Methoden (einschließlich send_message, wirklich) das gleiche Protokoll wie folgt vor: sie zurückkehren wahr, wenn sie erfolgreich war, und wenn sie nicht tatsächlich Griff eine Ausnahme, Sie fangen es nicht ein. Dieses Protokoll ermöglicht es auch, den Fall zu behandeln, in dem eine Methode angeben muss, dass ein Fehler aufgetreten ist, ohne eine Ausnahme auszulösen. (Wenn Ihre Methoden nur dadurch fehlschlagen, dass eine Ausnahme ausgelöst wird, vereinfacht das das Protokoll. Wenn Sie mit vielen fehlerfreien Ausnahmezuständen außerhalb der fehlgeschlagenen Methode arbeiten müssen, haben Sie wahrscheinlich ein Designproblem habe noch nicht ausgearbeitet.)

Der Nachteil dieses Ansatzes ist, dass alle Methoden dieselben Argumente verwenden müssen. Ich habe mich für keines entschieden, mit der Erwartung, dass die Methoden, die ich ausgedruckt habe, am Ende die Klassenmitglieder manipulieren werden.

Die Oberseite dieses Ansatzes ist jedoch beträchtlich. Erstens können Sie dem Prozess Dutzende von Methoden hinzufügen, ohne dass es komplexer wird.

Sie können auch verrückt gehen und etwas tun:

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." 

... obwohl an diesem Punkt, sage ich mir, vielleicht, „Selbst, bist du ziemlich hart auf den Befehl Muster arbeiten, ohne die Schaffung eine Kommandoklasse, vielleicht ist jetzt die Zeit."