Course
Execute e edite o código deste tutorial online
Executar códigoErros 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, conheceremos vários tipos de erro e aprenderemos sobre 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 examinando vários exemplos.
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. Ou fazemos isso manualmente ou usamos 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). Podemos 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
As exceções NameError 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:
- AssertionError: gerado quando a instrução assert falha.
- EOFError: gerado quando a função input() atende à condição de fim de arquivo.
- AttributeError: gerado quando a atribuição ou referência de atributo falha.
- TabError: gerado quando os recuos consistem em tabulações ou espaços inconsistentes.
- ImportError: gerado quando a importação do módulo falha.
- IndexError: ocorre quando o índice de uma sequência está fora do intervalo
- KeyboardInterrupt: acionado quando o usuário insere teclas de interrupção (Ctrl + C ou Delete).
- RuntimeError: ocorre quando um erro não se enquadra em nenhuma categoria.
- NameError: gerado quando uma variável não é encontrada no escopo local ou global.
- MemoryError: acionado quando os programas ficam sem memória.
- ValueError: ocorre quando a operação ou função recebe um argumento com o tipo correto, mas com o valor incorreto.
- ZeroDivisionError: gerado quando você divide um valor ou uma variável com zero.
- SyntaxError: levantado pelo analisador quando a sintaxe do Python está incorreta.
- IndentationError: ocorre quando há um recuo incorreto.
- SystemError: acionado 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 o ensinará a criar classes e a 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.
Declaração try e except
A maneira mais simples de lidar com exceções em Python é usar o bloco `try` e `except`.
- Execute o código sob a instrução `try`.
- Quando uma exceção for levantada, execute o código sob a 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 sob a instrução `try`.
- Como sabemos que `x` não está definido, ele 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árias instruções `except` para lidar com 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".
- Para o restante das exceções, ele 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 gera a exceção FileNotFoundError, o código imprime 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
tentar com a cláusula else
Aprendemos sobre `try` e `except`, e agora aprenderemos sobre a instruçã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 não se deseja ocultar determinados erros.
Observação: No bloco try-except, você pode usar o `else` após todas as instruçõ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 sob a 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 `x` (lista) e `n` (número de índice) como argumentos. 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 vamos testá-la para o 6º índice e o 2º índice.
# Testing
find_nth_value(x,6)
find_nth_value(x,2)
- Em n=6, a exceção IndexError foi levantada, e vimos 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
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 após o try, exceto que o bloco else é final. É bastante útil na limpeza de recursos e no fechamento do objeto, especialmente no fechamento dos arquivos.
A função `divide` foi criada para tratar as exceções ZeroDivisionError e exibir o resultado quando não houver exceções. Não importa qual seja o resultado, ele sempre será executado `finalmente` 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 podemos 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 sob a instrução `finally`.
Se você é iniciante em Python e deseja codificar como um programador de verdade, experimente nosso curso de habilidades em programação em 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 Divide
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, ele executará o `else` e verificará o novo código quanto à 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, estamos fornecendo a lista de 3 valores `x` e o denominador 3. O script adicionará 50 à lista, dividirá o valor individual da lista por 3 e exibirá o resultado.
x = [40,65,70,87]
divide(x,3)
A função foi executada com sucesso 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 com 0 como segundo argumento, o que gerou a exceção ZeroDivisionError na instrução `else`.
divide(x,0)
Please change 'y' argument to non-zero value
Code by DataCamp
Exemplo de edição de arquivos
Vejamos exemplos mais práticos de como carregar o arquivo, escrever um texto e fechar o arquivo.
A função file_editor será:
- 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, estamos fornecendo o caminho do arquivo e o texto.
path = "data.txt"
text = "DataCamp Workspace: 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, devemos 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; em vez disso, 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 instrução `try` ou `except`. Depende apenas de suas necessidades.
Levantamento de exceções em Python
Como desenvolvedor de Python, você tem a opção de 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, temos que usar a palavra-chave `raise` seguida de um nome de exceção.
Exemplo de erro de aumento de valor
Podemos simplesmente gerar exceções adicionando a palavra-chave raise na instrução if/else.
No exemplo, estamos gerando o erro ValueError se o valor for maior que 1.000. Alteramos o valor para 2.000, o que tornou a instrução `if` TRUE e gerou 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. Em 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 sob a instruçã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 os erros que não são cobertos pelo Python e que são específicos aos requisitos do seu aplicativo.
Please add a value lower than 1,000
Conclusão
Tanto o teste de unidade quanto o tratamento de exceções são a parte principal da programação Python que torna 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 Python Data Science Toolbox (Parte 1) 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.
Cursos de Python
Course
Intermediate Python
Course
Introduction to Importing Data in Python
blog
6 práticas recomendadas de Python para um código melhor
blog
5 desafios Python para desenvolver suas habilidades
DataCamp Team
5 min
blog
O que é Python? - A linguagem de programação mais versátil
Summer Worsley
20 min
tutorial
21 ferramentas essenciais do Python
tutorial
Tutorial e exemplos de funções e métodos de lista do Python
tutorial