Tratamento de exceções e erros em Python

Erros e exceções podem levar a um comportamento inesperado ou até mesmo interromper a execução de um programa. O Python fornece várias funções e mecanismos para lidar com esses problemas e melhorar a robustez do código. Neste tutorial, você aprenderá sobre vários tipos de erro e funções internas com exemplos. 

Um erro é um problema em um programa que o impede de concluir sua tarefa. Em comparação, uma exceção é uma condição que interrompe o fluxo normal do programa. Tanto os erros quanto as exceções são um tipo de erro de tempo de execução, o que significa que ocorrem durante a execução de um programa. 

Em palavras simples, o erro é um problema crítico que um aplicativo normal não deve detectar, enquanto uma exceção é uma condição que um programa deve detectar. 

Vamos aprender mais sobre erros e exceções observando vários exemplos. Para executá-los com facilidade, você pode criar gratuitamente uma pasta de trabalho do DataLab que tenha o Python pré-instalado e contenha todos os exemplos de código.

Erros em Python

Aqui está um exemplo de um erro de sintaxe em que um retorno fora da função não significa nada. Não devemos lidar com erros em um programa. Em vez disso, devemos criar uma função que retorne a string. 

return "DataCamp"

Input In [1]
    return "DataCamp"
    ^
SyntaxError: 'return' outside function

Criamos a função, mas com o recuo errado. Não devemos tratar erros de indentação em tempo de execução. Você pode fazer isso manualmente ou usar ferramentas de formatação de código.

def fun():
return "DataCamp"    

Input In [2]
    return "DataCamp"
    ^
IndentationError: expected an indented block

Exceções em Python

Encontramos um ZeroDivisionError (Exceção). Você pode lidar com isso em tempo de execução usando os blocos try e except.

test = 1/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Input In [4], in <cell line: 1>()
----> 1 test = 1/0

ZeroDivisionError: division by zero

NameError As exceções são bastante comuns quando uma variável não é encontrada. Também podemos tratar a exceção substituindo a variável ou imprimindo o aviso. 

y = test

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [5], in <cell line: 1>()
----> 1 y = test

NameError

Exceções integradas do Python

Aqui está a lista de exceções padrão do Python com descrições:

1. AssertionError: gerado quando a instrução assert falha.
2. EOFError: gerado quando a função input() atende à condição de fim de arquivo.
3. AttributeErrorQuando a atribuição de atributo ou a referência falhar.
4. TabErrorQuando você não tem acesso a um recuo, o que acontece é que o recuo consiste em tabulações ou espaços inconsistentes. 
5. ImportError: gerado quando a importação do módulo falha. 
6. IndexErrorOcorre quando o índice de uma sequência está fora do intervalo
7. KeyboardInterruptQuando o usuário digita teclas de interrupção (Ctrl + C ou Delete).
8. RuntimeErrorOcorre quando um erro não se enquadra em nenhuma categoria. 
9. NameErrorQuando uma variável não é encontrada no escopo local ou global. 
10. MemoryErrorQuando você está em um programa, o que você está fazendo? 
11. ValueErrorOcorre quando a operação ou função recebe um argumento com o tipo correto, mas com o valor incorreto. 
12. ZeroDivisionError: gerado quando você divide um valor ou uma variável por zero. 
13. SyntaxError: levantado pelo analisador quando a sintaxe do Python está errada. 
14. IndentationErrorOcorre quando há um recuo errado.
15. SystemErrorErro interno: gerado quando o interpretador detecta um erro interno.

Você pode encontrar uma lista completa de erros e exceções no Python lendo a documentação. 

Aprenda sobre exceções em Python fazendo nosso curso Programação orientada a objetos em Python. Ele ensinará a você como criar classes e aproveitar a herança e o polimorfismo para reutilizar e otimizar o código.

Tratamento de exceções com try, except, else e finally

Depois de aprender sobre erros e exceções, aprenderemos a lidar com eles usando os blocos try, except, else e finally. 

Então, o que queremos dizer com lidar com eles? Em circunstâncias normais, esses erros interromperão a execução do código e exibirão a mensagem de erro. Para criar sistemas estáveis, precisamos prever esses erros e apresentar soluções alternativas ou mensagens de aviso. 

Nesta seção, aprenderemos o que cada bloco faz e como podemos usá-los para escrever um código robusto. 

A instrução try e except 

A maneira mais simples de lidar com exceções em Python é usar o bloco try e except.  

1. Execute o código na instrução try.
2. Quando uma exceção for levantada, execute o código na instrução except. 

Em vez de parar em um erro ou exceção, nosso código seguirá para soluções alternativas. 

Exemplo simples

No primeiro exemplo, tentaremos imprimir a variável indefinida x. Em circunstâncias normais, ele deve lançar o erro e interromper a execução, mas com o bloco try e except, podemos alterar o comportamento do fluxo. 

• O programa executará o código na instrução try. 
• Como sabemos, o x não está definido, portanto, você executará a instrução except e imprimirá o aviso.

try:
   print(x)
except:
   print("An exception has occurred!")

An exception has occurred!

Exemplo de instrução Multiple except

No segundo exemplo, usaremos vários comandos except para tratar vários tipos de exceções.

•  Se uma exceção ZeroDivisionError for levantada, o programa imprimirá "Você não pode dividir um valor com zero".
• O restante das exceções imprimirá "Algo mais deu errado".

Isso nos permite escrever um código flexível que pode lidar com várias exceções ao mesmo tempo sem quebras. 

try:
   print(1/0)
except ZeroDivisionError:
   print("You cannot divide a value with zero")
except:
   print("Something else went wrong")

You cannot divide a value with zero

Carregando o arquivo de exemplo

Agora, vamos dar uma olhada em um exemplo mais prático. 

No código abaixo, estamos lendo o arquivo CSV e, quando ele gerar a exceção FileNotFoundError, o código imprimirá o erro e uma mensagem adicional sobre o arquivo data.csv. 

Sim, podemos imprimir mensagens de erro padrão sem interromper a execução. 

try:
   with open('data.csv') as file:
       read_data = file.read()
except FileNotFoundError as fnf_error:
   print(fnf_error)
   print("Explanation: We cannot load the 'data.csv' file")

[Errno 2] No such file or directory: 'data.csv'
Explanation: We cannot load the 'data.csv' file

O try com a cláusula else

Você já aprendeu sobre try e except e agora aprenderá sobre a declaração else.

Quando a instrução try não gera uma exceção, o código entra no bloco else. É a solução ou uma opção alternativa quando você espera que uma parte do seu script produza uma exceção. Geralmente é usado em uma breve configuração ou seção de verificação em que você não quer que determinados erros fiquem ocultos. 

Observação: No bloco try-except, você pode usar o else depois de todas as declarações except. 

Exemplo simples

Estamos adicionando a instrução else ao exemplo ZeroDivisionError. Como podemos ver, quando não há exceções, a função de impressão na instrução else é executada, exibindo o resultado. 

try:
   result = 1/3
except ZeroDivisionError as err:
   print(err)
else:
   print(f"Your answer is {result}")

Your answer is 0.3333333333333333

Exemplo de IndexError com else

Vamos aprender mais criando uma função simples e testando-a em vários cenários. 

A função find_nth_value() tem como argumentos x (lista) e n (número de índice). Criamos um bloco try, except e else para tratar a exceção IndexError. 

x = [5,8,9,13]

def find_nth_value(x,n):
    try:
        result = x[n]
    except IndexError as err:
        print(err)
    else:
        print("Your answer is ", result)

A lista x tem quatro valores, e nós os testaremos para o sexto e segundo índices. 

# Testing
find_nth_value(x,6)
find_nth_value(x,2)

• Em n=6, a exceção IndexError foi levantada e você pode ver a mensagem de erro padrão "list index out of range". 
• Em n=2, nenhuma exceção foi levantada e a função imprimiu o resultado que está sob a instrução else. 

list index out of range
Your answer is  9

A palavra-chave finally em Python

A palavra-chave finally no bloco try-except é sempre executada, independentemente de haver ou não uma exceção. Em palavras simples, o bloco de código finally é executado depois que o bloco try, except e else é finalizado. É bastante útil para limpar recursos e fechar o objeto, especialmente para fechar os arquivos.

A função divide foi criada para tratar as exceções do ZeroDivisionError e exibir o resultado quando não houver exceções. Não importa qual seja o resultado, ele sempre será executado em finally para imprimir "Code by DataCamp" na cor verde.

def divide(x,y):
    try:
        result = x/y
    except ZeroDivisionError:
        print("Please change 'y' argument to non-zero value")
    except:
        print("Something went wrong")
    else:
        print(f"Your answer is {result}")
    finally:
        print("\033[92m Code by DataCamp\033[00m")

No primeiro teste, estamos dividindo 1 por 0, o que deve gerar a exceção ZeroDivisionError e imprimir a mensagem. Como você pode ver, temos uma linha adicional após a mensagem de erro. 

divide(1,0)

Please change 'y' argument to non-zero value
 Code by DataCamp

Quando adicionamos uma entrada válida, ele exibe o resultado executando o bloqueio else e finally.

divide(3,4)

Your answer is 0.75
 Code by DataCamp

Em vez de um número inteiro, adicionamos uma cadeia de caracteres como segundo argumento, o que gerou uma exceção, que é diferente de ZeroDivisionError, com uma mensagem diferente. 

divide(1,'g')

Something went wrong
 Code by DataCamp

Em todos os três cenários, há uma coisa em comum. O código está sempre executando a função de impressão na instrução finally.

Se você é novo no Python e deseja codificar como um programador de verdade, experimente nosso curso de habilidades em programação Python. Você aprenderá a escrever códigos eficientes, funções Python, engenharia de software, testes unitários e programação orientada a objetos. 

Tratamento de exceções aninhadas em Python

Precisamos do tratamento de exceções aninhadas quando estamos preparando o programa para tratar várias exceções em uma sequência. Por exemplo, podemos adicionar outro bloco try-except sob a instrução else. Portanto, se a primeira instrução não gerar uma exceção, verifique a segunda instrução com a outra metade do código. 

Modificação da função de divisão

Modificamos a função divide do exemplo anterior e adicionamos um bloco try-except aninhado sob a instrução else. Portanto, se não houver AttributeError, você executará o else e verificará o novo código para a exceção ZeroDivisionError.

def divide(x,y):
    
    try:
        value = 50
        x.append(value)
    
    except AttributeError as atr_err:
        print(atr_err)
        
    else:
        try:
            result = [i / y for i in x]
            print( result )
 except ZeroDivisionError:
            print("Please change 'y' argument to non-zero value")

    finally:
        print("\033[92m Code by DataCamp\033[00m")

No primeiro cenário, fornecemos a lista de quatro valores x e o denominador 3. O script adicionará 50 à lista, dividirá o valor individual na lista por 3 e exibirá o resultado. 

x = [40,65,70,87]
divide(x,3)

A função foi executada com êxito sem gerar nenhuma exceção.

[13.333333333333334, 21.666666666666668, 23.333333333333332, 29.0, 16.666666666666668]
 Code by DataCamp

Em vez de uma lista, fornecemos um número inteiro para o primeiro argumento, o que gerou AttributeError.

divide(4,3)

'int' object has no attribute 'append'
 Code by DataCamp

No último cenário, fornecemos a lista, mas 0 é o segundo argumento que gerou a exceção ZeroDivisionError no comando else. 

divide(x,0)

Please change 'y' argument to non-zero value
 Code by DataCamp

Exemplo de edição de arquivo

Vamos ver exemplos mais práticos de como carregar o arquivo, escrever um texto e fechar o arquivo. 

A função file_editor() permitirá que você acesse o site:

• Verifique a exceção FileNotFoundError para a função open().
• Se a exceção externa não for levantada, ele verificará a exceção da função write().
• Independentemente disso, depois de abrir o arquivo, ele o fechará executando a instrução finally. 
• Se a instrução try externa gerar a exceção, ela retornará a mensagem de erro com um caminho de arquivo inválido. 

def file_editor(path,text):
    try:
      data = open(path)

      try:
        data.write(text)

      except:
        print("Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.")

      finally:
        data.close()

    except:
      print(f"{path} file is not found!!")

No primeiro cenário, fornecemos o caminho do arquivo e o texto.

path = "data.txt"
text = "DataLab: Share your data analysis in a cloud-based environment--no installation required."

file_editor(path,text)

A exceção externa é levantada. 

data.txt file is not found!!

Para resolver a exceção de arquivo não encontrado, precisamos criar um arquivo data.txt usando o comando echo do Linux. 

!echo "File by DataCamp" > "data.txt"

Depois disso, execute novamente a função file_editor().

file_editor(path,text)

A exceção interna é levantada, pois a função write() não é capaz de adicionar o texto.

Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.

Para resolver esse problema, precisamos alterar a terceira linha de data = open(path) para data = open(path, 'a'). Isso nos permitirá anexar o novo texto ao arquivo. 

Depois de executar novamente a função, adicionamos com êxito o texto ao arquivo. 

file_editor(path,text)

O tratamento de exceções aninhadas não é recomendado, pois torna o tratamento de exceções mais complexo; os desenvolvedores usam vários blocos try-except para criar um tratamento de exceções sequencial simples. 

Observação: você também pode adicionar um bloco try-except aninhado sob a declaração try ou except. Depende apenas de suas necessidades. 

Levantamento de exceções em Python

Como desenvolvedor Python, você pode lançar uma exceção se determinadas condições forem atendidas. Ele permite que você interrompa o programa com base em suas necessidades. 

Para lançar uma exceção, precisamos usar a palavra-chave raise seguida de um nome de exceção. 

Exemplo de erro de aumento de valor

Você pode simplesmente levantar exceções adicionando uma palavra-chave raise na instrução if/else. 

No exemplo, aumentamos o endereço ValueError se o valor for superior a 1.000. Alteramos o valor para 2.000, o que fez com que a declaração if fosse TRUE e levantasse ValueError com a mensagem personalizada. A mensagem de erro personalizada ajuda você a descobrir o problema rapidamente. 

value = 2_000
if value > 1_000:   
    # raise the ValueError
    raise ValueError("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

----> 4     raise ValueError("Please add a value lower than 1,000")
      5 else:
      6     print("Congratulations! You are the winner!!")

ValueError: Please add a value lower than 1,000

Exemplo de exceção de aumento

Também podemos gerar qualquer exceção aleatória incorporada ao Python se a condição for atendida. No nosso caso, criamos uma exceção genérica com a mensagem de erro.

if value > 1_000:   
    # raise the Exception
    raise Exception("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")

---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
----> 3     raise Exception("Please add a value lower than 1,000")
      4 else:
      5     print("Congratulations! You are the winner!!")

Exception: Please add a value lower than 1,000

Exemplo de tratamento de exceção levantada

Também podemos criar nossa exceção personalizada e tratar a exceção usando o bloco try-except. 

No exemplo, adicionamos um exemplo de erro de valor na declaração try.  

Então, como isso funcionará? Em vez de lançar a exceção e encerrar o programa, ele exibirá a mensagem de erro que fornecemos.

value = 2_000
try:
    if value > 1_000:
          
        # raise the ValueError
        raise ValueError("Please add a value lower than 1,000")
    else:
        print("Congratulations! You are the winner!!")
              
# if false then raise the value error
except ValueError as e:
        print(e)

Esse tipo de tratamento de exceções nos ajuda a nos prepararmos para erros não cobertos pelo Python e que são específicos aos requisitos do seu aplicativo. 

Please add a value lower than 1,000

O que há de novo no Python 3.10 e 3.11 para o tratamento de exceções?

Alguns novos desenvolvimentos importantes foram adicionados às versões mais recentes do Python, como a 3.10 e a 3.11, desde que a postagem do blog foi originalmente escrita:

1. Correspondência de padrões estruturais no Python 3.10: O Python 3.10 introduziu a correspondência de padrão estrutural, que pode ser usada para tratar exceções de forma mais elegante, fazendo a correspondência de tipos de erro em uma instrução match. Isso é particularmente útil quando você lida com vários tipos de exceção de uma forma mais legível. Exemplo:

try:
    result = 1 / 0
except Exception as e:
    match e:
        case ZeroDivisionError():
            print("You cannot divide by zero.")
        case NameError():
            print("Variable not defined.")
        case _:
            print("An unexpected error occurred.")

2. Localizações de erro refinadas em tracebacks (Python 3.11): Os rastreamentos no Python 3.11 agora mostram os locais exatos dos erros, facilitando a depuração de exceções.

• Antes do Python 3.11:

value = (1 + 2) * (3 / 0)

• Retorno:

ZeroDivisionError: division by zero

• Python 3.11: Os rastreamentos identificam a subexpressão exata que está causando a exceção:

ZeroDivisionError: division by zero
       (1 + 2) * (3 / 0)
                      ^

3. Grupos de exceções e except* (Python 3.11): O Python 3.11 introduziu grupos de exceções para tratar várias exceções em um único bloco usando except*. Isso é útil para gerenciar código assíncrono ou cenários em que várias exceções podem ser levantadas. Exemplo:

try:
    raise ExceptionGroup("Multiple errors", [ValueError("Bad value"), TypeError("Bad type")])
except* ValueError as ve:
    print(f"Handling ValueError: {ve}")
except* TypeError as te:
    print(f"Handling TypeError: {te}")

4. add_note método para exceções (Python 3.11): As exceções agora têm um método add_note(), que permite que os desenvolvedores adicionem notas personalizadas às exceções para melhorar a depuração. Exemplo:

try:
    raise ValueError("Invalid input")
except ValueError as e:
    e.add_note("This happened while processing user input.")
    e.add_note("Consider validating input before processing.")
    raise

• Retorno:

ValueError: Invalid input
Notes:
- This happened while processing user input.
- Consider validating input before processing.

5. PEP 654: Melhor tratamento de exceções aninhadas: Com os grupos de exceções, as exceções aninhadas agora são mais fáceis de depurar e manipular, especialmente em fluxos de trabalho complexos, como multiprocessamento ou tarefas assíncronas.

Conclusão

Ambos teste unitário e o tratamento de exceções são as partes principais da programação Python que tornam seu código pronto para produção e à prova de erros. Neste tutorial, aprendemos sobre exceções e erros em Python e como lidar com eles. Além disso, aprendemos sobre blocos try-except aninhados complexos e criamos blocos de exceção personalizados com base nos requisitos.  

Essas ferramentas e mecanismos são essenciais, mas a maior parte do trabalho é feita por meio de blocos simples try e except. Onde try procura exceções levantadas pelo código e except trata essas exceções. 

Se isso for confuso e você não souber por onde começar, conclua nosso curso Introdução às funções em Python para entender o escopo, as funções lambda e o tratamento de erros. Você também pode se inscrever no curso de carreira de programador Python para adquirir habilidades de desenvolvimento de carreira e se tornar um desenvolvedor Python profissional.