Erros e Exceções em Python

Introdução

Neste laboratório, você obterá uma compreensão prática de erros (errors) e exceções (exceptions) em Python. Exploraremos como identificar erros de sintaxe comuns que impedem a execução do código, reconhecer vários tipos de exceções que ocorrem durante a execução (runtime), e diferenciar claramente esses dois conceitos fundamentais na programação Python.

Através de exercícios práticos, você aprenderá a identificar e corrigir problemas como indentação incorreta, elementos de sintaxe ausentes e outras armadilhas comuns, construindo uma base sólida para escrever código Python robusto e livre de erros.

Identificar Erros de Sintaxe

Nesta etapa, exploraremos erros de sintaxe comuns em Python. Erros de sintaxe ocorrem quando o código viola as regras gramaticais da linguagem, impedindo que o interpretador compreenda e execute o código. Esses erros são detectados antes mesmo que o programa comece a rodar.

O arquivo necessário syntax_errors.py foi criado para você no diretório ~/project.

Primeiro, vamos introduzir um IndentationError. Abra syntax_errors.py no explorador de arquivos no lado esquerdo do WebIDE. Adicione o seguinte código, que contém indentação incorreta:

for i in range(5):
    print(i)
  print("This line has incorrect indentation")

Salve o arquivo. Agora, abra o terminal integrado e execute o script:

python syntax_errors.py

Você verá um IndentationError. O interpretador Python espera que blocos de código (como o de um loop for) tenham um nível de indentação consistente.

  File "/home/labex/project/syntax_errors.py", line 3
    print("This line has incorrect indentation")
                                                ^
IndentationError: unindent does not match any outer indentation level

Agora, vamos corrigir a indentação, mas introduzir um SyntaxError diferente. Modifique o código em syntax_errors.py para o seguinte. Note a ausência de dois pontos (:) no final da primeira linha.

for i in range(5)
    print(i)
    print("This line has correct indentation")

Salve o arquivo e execute-o novamente a partir do terminal:

python syntax_errors.py

Desta vez, você obterá um SyntaxError. A declaração de loop for em Python requer dois pontos no final para sinalizar o início de um bloco de código.

  File "/home/labex/project/syntax_errors.py", line 1
    for i in range(5)
                     ^
SyntaxError: expected ':'

Finalmente, vamos corrigir os dois pontos, mas introduzir outro SyntaxError comum: uma string não terminada. Modifique o arquivo syntax_errors.py da seguinte forma. A string "hello' começa com aspas duplas, mas termina com aspas simples.

for i in range(5):
    print("hello')

Salve o arquivo e execute-o:

python syntax_errors.py

Você encontrará um SyntaxError porque a string não foi devidamente fechada com as aspas correspondentes.

  File "/home/labex/project/syntax_errors.py", line 2
    print("hello')
          ^
SyntaxError: unterminated string literal (detected at line 2)

Estes exemplos ilustram que erros de sintaxe devem ser corrigidos antes que seu programa possa ser executado. Sempre preste muita atenção à indentação, a símbolos necessários como dois pontos e ao fechamento correto das aspas.

Reconhecer Exceções Comuns

Nesta etapa, exploraremos exceções comuns. Diferentemente dos erros de sintaxe, as exceções ocorrem durante a execução do programa. O código está sintaticamente correto, mas um erro acontece enquanto ele está rodando.

O arquivo common_exceptions.py está pronto para você no diretório ~/project.

Primeiro, vamos causar um ZeroDivisionError. Abra common_exceptions.py no editor e adicione o seguinte código:

numerator = 10
denominator = 0
result = numerator / denominator
print(result)

Salve o arquivo e execute-o a partir do terminal:

python common_exceptions.py

O programa começa a rodar, mas para e exibe um ZeroDivisionError. Matematicamente, a divisão por zero é indefinida, e Python levanta essa exceção para indicar o problema.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 3, in <module>
    result = numerator / denominator
ZeroDivisionError: division by zero

Em seguida, vamos acionar um NameError. Isso acontece quando você tenta usar uma variável que ainda não foi definida. Substitua o conteúdo de common_exceptions.py pelo seguinte:

print(undefined_variable)

Salve o arquivo e execute-o:

python common_exceptions.py

Você obterá um NameError porque o interpretador não sabe a que undefined_variable se refere.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 1, in <module>
    print(undefined_variable)
NameError: name 'undefined_variable' is not defined

Agora, vamos ver um TypeError. Isso ocorre quando você tenta realizar uma operação em um objeto de um tipo inadequado. Substitua o conteúdo de common_exceptions.py por este código:

print("Hello" + 5)

Salve e execute o script:

python common_exceptions.py

Você verá um TypeError. Python não permite que você some (+) uma string e um inteiro diretamente.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 1, in <module>
    print("Hello" + 5)
TypeError: can only concatenate str (not "int") to str

Finalmente, vamos demonstrar um IndexError. Isso acontece quando você tenta acessar um elemento de uma sequência (como uma lista) usando um índice que está fora do intervalo válido. Substitua o conteúdo de common_exceptions.py pelo seguinte:

my_list = [1, 2, 3]
print(my_list[5])

Salve e execute o script:

python common_exceptions.py

Você obterá um IndexError. A lista my_list tem três itens, então seus índices válidos são 0, 1 e 2. Acessar o índice 5 não é possível.

Traceback (most recent call last):
  File "/home/labex/project/common_exceptions.py", line 2, in <module>
    print(my_list[5])
IndexError: list index out of range

Compreender essas exceções comuns é uma parte fundamental do aprendizado de depuração (debugging) de código Python.

Diferenciar Entre Erros e Exceções

Nesta etapa final, distinguiremos claramente entre erros de sintaxe e exceções. Essa distinção é fundamental para a programação e depuração em Python.

Erros de Sintaxe (ou Erros de Análise - Parsing Errors):

• São erros na estrutura do seu código que violam as regras do Python.
• O interpretador Python encontra esses erros antes que seu programa comece a rodar.
• Um programa com erro de sintaxe não pode ser executado de forma alguma.
• Exemplos: IndentationError, dois pontos ausentes, parênteses ou aspas desalinhados.

Exceções (ou Erros de Tempo de Execução - Runtime Errors):

• Ocorrem durante a execução de um programa sintaticamente correto.
• Acontecem quando o programa encontra uma situação inesperada, como dividir por zero ou acessar um arquivo inexistente.
• Se não forem tratadas, uma exceção fará com que seu programa trave e exiba um traceback.
• Exemplos: ZeroDivisionError, NameError, TypeError, IndexError.

Vamos ver isso em ação. Abra o arquivo error_vs_exception.py no explorador de arquivos. Adicione o seguinte código, que contém um erro de sintaxe (dois pontos ausentes) e uma linha que causará uma exceção em tempo de execução.

## This line has a syntax error (missing colon)
for i in range(5)
    print(i)

## This line will cause an exception (division by zero)
result = 10 / 0
print(result)

Salve o arquivo e tente executá-lo:

python error_vs_exception.py

Note que você imediatamente obtém um SyntaxError. O interpretador verifica a sintaxe correta de todo o arquivo antes de executar qualquer parte dele. Ele encontra os dois pontos ausentes e para, sem sequer chegar à linha com 10 / 0.

  File "/home/labex/project/error_vs_exception.py", line 2
    for i in range(5)
                     ^
SyntaxError: expected ':'

Agora, vamos corrigir o erro de sintaxe. Adicione os dois pontos ausentes à linha do loop for em error_vs_exception.py:

## The syntax error is now fixed
for i in range(5):
    print(i)

## This line will cause an exception (division by zero)
result = 10 / 0
print(result)

Salve o arquivo e execute-o novamente:

python error_vs_exception.py

Desta vez, o programa está sintaticamente correto, então ele começa a rodar. O loop for executa e imprime os números de 0 a 4. Em seguida, quando o programa tenta executar result = 10 / 0, ele encontra um problema em tempo de execução e levanta um ZeroDivisionError, fazendo com que o programa trave.

0
1
2
3
4
Traceback (most recent call last):
  File "/home/labex/project/error_vs_exception.py", line 6, in <module>
    result = 10 / 0
ZeroDivisionError: division by zero

Isso demonstra claramente que erros de sintaxe impedem a execução, enquanto exceções ocorrem durante a execução. Nos próximos labs, você aprenderá como tratar exceções de forma elegante para que elas não travem seu programa.

Resumo

Neste lab, você aprendeu a diferença fundamental entre erros e exceções em Python. Você começou identificando e corrigindo erros de sintaxe comuns, como IndentationError e SyntaxError devido a dois pontos ausentes, entendendo que estes impedem que um programa seja executado.

Em seguida, você explorou várias exceções comuns de tempo de execução (runtime), incluindo ZeroDivisionError, NameError, TypeError e IndexError. Você viu como essas exceções ocorrem em código sintaticamente correto quando uma operação falha durante a execução. Finalmente, você solidificou seu entendimento observando como o interpretador Python lida com um arquivo contendo tanto um erro de sintaxe quanto uma exceção potencial, provando que a sintaxe é verificada antes que a execução comece. Esse conhecimento fornece uma base crucial para escrever e depurar aplicações Python.