Como capturar múltiplas exceções em Python: um guia fácil

Capturar exceções em Python ajuda a garantir que seus programas travem com menos frequência. Isso torna seu código mais confiável e proporciona uma melhor experiência ao usuário. Neste artigo, discutirei como capturar várias exceções no mesmo bloco try/except em Python.

O que são exceções em Python?

Em Pitão, As exceções são um mecanismo de comunicação entre diferentes partes do programa. Este mecanismo de comunicação permite que uma parte do sistema comunique que encontrou um erro crítico que não sabe como tratar.

Então, isso levanta uma exceção. Outra parte do programa que sabe como tratar o erro capturará a exceção e tratará o erro adequadamente.

Quando não tratadas, as exceções travarão o programa. O tratamento de exceções, portanto, evita que seu programa trave e o torna mais confiável.

Para este artigo, presumirei que você já esteja familiarizado com os conceitos básicos de geração e tratamento de exceções, que são abordados neste artigo Introdução ao Python Try/Except.

Importância de lidar com múltiplas exceções em Python

• Reduz a duplicação de código, pois várias exceções são tratadas pelo mesmo bloco. Isso torna o código mais fácil de ler, editar e excluir.
• Também ajuda a escrever um código mais eficiente, pois o tipo de erro só precisa ser verificado uma vez, em vez de várias vezes.

Lidando com múltiplas exceções

A captura de múltiplas exceções refere-se à situação em que múltiplas exceções são capturadas usando o mesmo bloco except. Em Python, você pode capturar diferentes exceções em blocos except individuais.

Alternativamente, quando quiser tratar as exceções de maneira semelhante, você pode tratá-las usando um bloco. Para fazer isso, você precisará capturar várias exceções. Nesta seção, explicarei como fazer isso com um exemplo.

#1. Capturando diferentes exceções em blocos diferentes

Suponha que tivéssemos um programa projetado para receber dois valores diferentes e dividi-los. Neste programa, prevemos que diferentes tipos de exceções serão gerados quando o usuário inserir valores inválidos. Em particular, queremos lidar com ValueError e ZeroDivisionError.

O ValueError será gerado quando o usuário inserir um valor que não pode ser convertido em um número inteiro. O ZeroDivisionError será gerado quando o segundo número for zero. Em ambos os casos, queremos exibir uma mensagem de erro que diz: “Você inseriu um valor inválido”.

Para fazer o acima, podemos escrever o seguinte código:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except ValueError as e:
    print("You entered an invalid value")
except ZeroDivisionError as e:
    print("You entered an invalid value")
except Exception as e:
    print("Something went wrong")

Se executarmos o código acima e o texto que não pode ser convertido em um número inteiro, este será o resultado:

E se inserirmos o segundo número como 0, este seria o resultado:

O código funciona conforme o esperado, mas observe que estamos tratando ValueError e ZeroDivisionError de forma semelhante. Portanto, há muita duplicação de código entre os dois blocos Except. Isto não é o ideal, pois violamos o princípio DRY na programação. O Princípio DRY diz: Não se repita.

Portanto, em vez de escrever o código separadamente, podemos combinar os dois blocos em um bloco que captura múltiplas exceções. Se fizermos isso, evitaremos a repetição.

#2. Capturando múltiplas exceções em um bloco Except

Para capturar múltiplas exceções, fornecemos uma tupla que especifica todos os erros que queremos capturar. Aqui está um exemplo onde capturamos ValueError e ZeroDivisionError em um bloco except:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("You entered an invalid value")
except Exception as e:
    print("Something went wrong")

Esta é uma implementação muito melhor do que o código anterior. Essencialmente, é disso que se trata o tratamento de múltiplas exceções. O código acima funciona da mesma maneira que antes. Se você testar usando os exemplos anteriores, deverá funcionar como antes:

#3. Identificando qual exceção foi capturada

O código acima executa o primeiro bloco except quando um ValueError ou ZeroDivisionError foi capturado. Em alguns casos, você pode ter um código que deseja executar para ambos os erros e algum outro código que deseja executar para um, mas não para o outro erro.

Nesse caso, você deve primeiro identificar qual erro foi detectado e executar o código apropriado.

Para identificar qual exceção foi capturada, você pode usar um bloco if/else dentro do bloco except. Por exemplo:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("You entered an invalid value")

    if isinstance(e, ValueError):
        print('Value Error')
    else:
        print('Zero Division Error')
except Exception as e:
    print("Something went wrong")

Neste bloco, além de imprimir a mensagem de erro genérica para ValueError e ZeroDivisionError, também verificamos exatamente que tipo de erro detectamos e imprimimos uma mensagem adicional. Se testarmos o código novamente, veremos algumas mensagens adicionais específicas da exceção detectada.

Quando você desejaria lidar com múltiplas exceções?

No caso geral, lidar com múltiplas exceções é ideal quando você deseja executar o mesmo código para exceções semelhantes que possam ser geradas. Isso inclui o seguinte:

• Solicitações de rede que falharam por diferentes motivos. Independentemente disso, você pode notificar o usuário de que não foi possível acessar o servidor.
• Falha nas conexões de banco de dados, que produzem vários erros. Embora esses erros possam ser diferentes, seu tratamento pode ser o mesmo.
• A E/S de arquivo também produz erros que podem ser tratados de forma semelhante, como erros de permissão e de disco cheio.

Conclusão

Este artigo discutiu a combinação de vários blocos except em um, capturando várias exceções simultaneamente. Isso ajuda seu código a se tornar mais legível e fácil de manter. A seguir, você pode querer ler este artigo sobre projetos para iniciantes em Python que você deve tentar.