Manière correcte de la gestion des exceptions en Python?

Au lieu d'utiliser le try/except de l'autre bloc, vous pouvez simplement retourner quand il erreurs:

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

C'est parfaitement lisible et Pythonic..

Une autre manière de faire, plutôt que de vous soucier de la mise en œuvre spécifique, décidez comment vous voulez que votre code, par exemple..

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

Puis écrire le code pour le message() méthode, la capture des erreurs que vous attendez, et d'élever votre propre personnalisé, et la poignée que lorsque c'est pertinent. Votre classe peut ressembler à quelque chose comme..

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

Si c'était moi, je serais probablement faire quelque chose comme ce qui suit:

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

Toutes les erreurs sont capturés et de débogage, la valeur de retour == True en cas de succès, et la connexion au serveur est correctement nettoyé si la connexion initiale est faite.

Je voudrais essayer quelque chose comme ceci:

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

Toutes les méthodes (y compris send_message, vraiment) suivre le même protocole: ils retournent True si ils ont réussi, à moins qu'il n'en fait poignée une exception, ils n'ont pas l'emprisonner. Ce protocole permet également de gérer le cas où une méthode doit indiquer qu'il n'a pas sans soulever une exception. (Si la seule façon de vos méthodes échouent est de lever une exception, qui simplifie le protocole. Si vous êtes d'avoir à traiter avec beaucoup de non-exception de l'échec des états à l'extérieur de la méthode qui a échoué, vous avez probablement un problème de conception que vous n'avez pas travaillé encore.)

L'inconvénient de cette approche est que toutes les méthodes doivent utiliser les mêmes arguments. J'ai opté pour aucun, avec l'espoir que les méthodes que j'ai écrasé sera à la fin de manipuler les membres de la classe.

L'avantage de cette approche est considérable, bien. Tout d'abord, vous pouvez ajouter des dizaines de méthodes pour le processus sans send_message obtenir plus complexe.

Vous pouvez également devenir fou et de faire quelque chose comme ceci:

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

...mais à ce point, je pourrais me dire, "auto, vous travaillez le modèle de Commande assez difficile sans la création d'une classe de Commande. Peut-être que maintenant est le temps."

J'aime bien David de répondre, mais si vous êtes coincé sur le serveur exceptions vous pouvez également vérifier pour le serveur si ce n'est ou des etats. J'ai aplati la méthode un peu peu qu'il est toujours un mais unpythonic à la recherche, mais plus lisible dans la logique au fond.

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