Правильный способ обработки исключений в Python?

Ответ 1

Вместо использования блока try/except else вы можете просто вернуть его при ошибках:

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

Ответ 2

В общем, вы хотите использовать как можно меньше блоков try, различая условия отказа по видам исключений, которые они бросают. Например, здесь мой рефакторинг кода, который вы опубликовали:

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-catch. В блоке finally мы проверяем сервер явно, чтобы избежать вызова quit() для объекта nil.

Мы могли бы также использовать три последовательных блока try-catch, возвращая False в условиях исключения, если есть перекрывающиеся исключения, которые нужно обрабатывать отдельно:

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

Это не так приятно, так как вам нужно убить сервер в нескольких местах, но теперь мы можем обрабатывать конкретные типы исключений по-разному в разных местах, не поддерживая какое-либо дополнительное состояние.

Ответ 3

Если бы это был я, я бы, вероятно, сделал бы что-то вроде следующего:

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

Все ошибки улавливаются и отлаживаются, возвращаемое value == True при успешном завершении, а соединение с сервером правильно очищается, если начальное соединение выполнено.

Ответ 4

Просто использование одного блока try - это путь. Это именно то, что они предназначены для: выполнения только следующего оператора, если предыдущий выражение не выдавало исключения. Что касается очистки ресурсов, возможно, вы можете проверить ресурс, если его нужно очистить (например, 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

Нет ничего необычного в том, что код обработки ошибок превышает бизнес-код. Правильная обработка ошибок может быть сложной. Но для повышения ремонтопригодности он помогает отделить бизнес-код от кода обработки ошибок.

Ответ 5

Я бы попробовал что-то вроде этого:

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, действительно) следуют одному и тому же протоколу: они возвращают True, если они преуспели, и если они фактически не обрабатывают исключение, они не ловушки. Этот протокол также позволяет обрабатывать случай, когда метод должен указывать на то, что он не прошел, не создавая исключения. (Если единственным способом, которым ваши методы не удается, является создание исключения, что упрощает протокол. Если вам приходится иметь дело с большим количеством состояний исключения, отличных от исключения, за пределами отказа метода, у вас, вероятно, есть проблема с дизайном, пока не разработаны).

Недостатком этого подхода является то, что все методы должны использовать одни и те же аргументы. Я не выбрал ни одного, ожидая, что методы, которые я пропустил, в конечном итоге будут манипулировать членами класса.

Потенциал этого подхода значителен. Во-первых, вы можете добавить десятки методов в процесс без 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."

... хотя в тот момент я мог бы сказать себе: "Я, вы очень хорошо работаете с шаблоном Command, не создавая класс Command. Возможно, сейчас самое время".

Ответ 6

Почему бы не одна большая попытка: заблокировать? Таким образом, если какое-либо исключение поймано, вы пройдете весь путь до исключения. И до тех пор, пока все исключения для разных этапов различны, вы всегда можете указать, в какой части было сделано это исключение.

Ответ 7

Мне нравится ответ Дэвида, но если вы застряли на серверных исключениях, вы также можете проверить сервер, если он есть или указывает. Я немного сгладил метод, но он по-прежнему остается неистовым, но более читаемым в логике внизу.

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