TRY E EXCEPT PYTHON

Introdução ao bloco “try-except” em Python

O bloco “try-except” é uma construção fundamental em Python que permite lidar com exceções e erros durante a execução de um programa. Com ele, você pode escrever um código que possa falhar sem interromper abruptamente a execução do programa. Ao usar o bloco “try-except”, você pode identificar e tratar exceções, fornecendo uma lógica alternativa para lidar com erros de forma controlada.

O bloco “try-except” é amplamente utilizado para prevenir falhas inesperadas e melhorar a robustez do código. Seu propósito é permitir que o programa continue a ser executado mesmo quando ocorre uma exceção, fornecendo um mecanismo para capturar, tratar e manipular erros de maneira adequada.

A estrutura básica do bloco “try-except” é a seguinte:

try:
    # Código que pode gerar uma exceção
except ExcecaoTipo:
    # Tratamento específico para a exceção ExcecaoTipo
except OutraExcecaoTipo:
    # Tratamento específico para a exceção OutraExcecaoTipo
else:
    # Código a ser executado se nenhum erro ocorrer
finally:
    # Código a ser executado sempre, independentemente de ocorrer uma exceção ou não

Aqui está como o bloco “try-except” funciona:

1. O código dentro do bloco “try” é executado.
2. Se nenhuma exceção ocorrer, o bloco “except” correspondente é ignorado e o fluxo de execução continua após o bloco “try-except”.
3. Se uma exceção ocorrer dentro do bloco “try”, o código restante dentro do bloco “try” é interrompido e a execução passa para o bloco “except” correspondente.
4. O primeiro bloco “except” cujo tipo de exceção corresponda à exceção gerada é executado. Se não houver um bloco “except” adequado, a exceção será propagada para blocos “try-except” superiores ou, se não houver nenhum tratamento, o programa será encerrado e uma mensagem de erro será exibida.
5. O bloco “else” é opcional e é executado se nenhum erro ocorrer no bloco “try”.
6. O bloco “finally” também é opcional e é sempre executado, independentemente de ocorrer uma exceção ou não. É usado para executar código de limpeza, como fechar arquivos ou liberar recursos.

Aqui está um exemplo que ilustra o uso do bloco “try-except” em Python:

try:
    valor = int(input("Digite um número inteiro: "))
    resultado = 10 / valor
    print("O resultado é:", resultado)
except ValueError:
    print("Você digitou um valor inválido. Digite um número inteiro.")
except ZeroDivisionError:
    print("Não é possível dividir por zero.")
else:
    print("Nenhum erro ocorreu.")
finally:
    print("Fim do programa.")

Neste exemplo, o programa solicita ao usuário um número inteiro. Se o usuário digitar um valor inválido, como uma string em vez de um número, uma exceção do tipo ValueError será gerada e o programa exibirá uma mensagem apropriada. Se o usuário digitar zero, ocorrerá uma exceção do tipo ZeroDivisionError ao tentar dividir por zero. Caso contrário, o resultado da divisão será exibido. O bloco “else” é executado se nenhum erro ocorrer, e o bloco “finally” é executado independentemente do resultado.

O uso adequado do bloco “try-except” pode ajudar a tornar o código mais robusto e evitar falhas inesperadas. É importante identificar as exceções relevantes para o seu programa e fornecer tratamentos adequados para cada uma delas.

Sintaxe do bloco “try-except” em Python

A estrutura básica do bloco “try-except” em Python segue a seguinte sintaxe:

try:
    # Código que pode gerar uma exceção
except ExcecaoTipo1:
    # Tratamento para a exceção ExcecaoTipo1
except ExcecaoTipo2:
    # Tratamento para a exceção ExcecaoTipo2
...
else:
    # Código a ser executado se nenhum erro ocorrer
finally:
    # Código a ser executado sempre, independentemente de ocorrer uma exceção ou não

• O bloco try é onde o código que pode gerar uma exceção é colocado.
• O bloco except é onde você captura e trata exceções específicas.
• O bloco else é opcional e contém o código a ser executado se nenhum erro ocorrer no bloco try.
• O bloco finally também é opcional e contém o código que será executado sempre, independentemente de ocorrer uma exceção ou não.

Você pode usar uma ou mais cláusulas except para capturar exceções específicas. Cada cláusula except especifica o tipo de exceção que será capturada e o bloco de código a ser executado para tratá-la. Aqui está um exemplo:

try:
    # Código que pode gerar uma exceção
except ExcecaoTipo1:
    # Tratamento para a exceção ExcecaoTipo1
except ExcecaoTipo2:
    # Tratamento para a exceção ExcecaoTipo2

No exemplo acima, se uma exceção do tipo ExcecaoTipo1 for gerada dentro do bloco try, o código dentro do bloco except ExcecaoTipo1 será executado. Se uma exceção do tipo ExcecaoTipo2 for gerada, o código dentro do bloco except ExcecaoTipo2 será executado. Você pode adicionar quantas cláusulas except forem necessárias para capturar diferentes tipos de exceções.

A cláusula else é usada para especificar um bloco de código que será executado se nenhum erro ocorrer dentro do bloco try. Isso é útil para executar ações específicas quando o código dentro do bloco try é bem-sucedido. Veja o exemplo abaixo:

try:
    # Código que pode gerar uma exceção
except ExcecaoTipo:
    # Tratamento para a exceção ExcecaoTipo
else:
    # Código a ser executado se nenhum erro ocorrer

No exemplo acima, se nenhuma exceção do tipo ExcecaoTipo ocorrer dentro do bloco try, o código dentro do bloco else será executado.

A cláusula finally é usada para especificar um bloco de código que será executado sempre, independentemente de ocorrer uma exceção ou não. É útil para realizar ações de limpeza ou liberação de recursos, garantindo que o código seja executado, mesmo em caso de exceção. Aqui está um exemplo:

try:
    # Código que pode gerar uma exceção
except ExcecaoTipo:
    # Tratamento para a exceção ExcecaoTipo
finally:
    # Código a ser executado sempre

No exemplo acima, o código dentro do bloco finally será executado independentemente de ocorrer uma exceção ou não.

Agora que você entende a sintaxe básica do bloco try-except, as cláusulas except, else e finally, você pode utilizá-las para capturar exceções específicas, executar código quando nenhum erro ocorrer ou realizar ações de limpeza e garantir que seu código seja mais robusto.

Lidando com exceções em Python

Ao utilizar o bloco try-except, é possível identificar e tratar exceções para lidar com erros de forma controlada em seu código Python. Aqui estão os principais pontos a serem considerados ao lidar com exceções:

Identificar e tratar exceções:

Ao utilizar o bloco try-except, você pode identificar as partes do código que podem gerar exceções e envolvê-las com um bloco try. Isso permite que você capture as exceções específicas que podem ocorrer e trate-as adequadamente no bloco except. Dessa forma, você evita que o programa seja interrompido abruptamente em caso de erro.

Tipos de exceções comuns em Python:

Python possui uma ampla variedade de tipos de exceções embutidos que podem ser capturados e tratados. Alguns dos tipos de exceções comuns incluem:

Evitando a interrupção do programa:

O tratamento de exceções com o bloco try-except permite evitar a interrupção do programa, mesmo quando ocorre uma exceção. Ao capturar e tratar as exceções relevantes, você pode fornecer uma lógica alternativa para lidar com erros, exibir mensagens de erro adequadas ou até mesmo ignorar o erro e continuar a execução do programa.

Aqui está um exemplo que demonstra como identificar e tratar exceções com o bloco try-except:

try:
    divisor = int(input("Digite um divisor: "))
    resultado = 10 / divisor
    print("O resultado é:", resultado)
except ZeroDivisionError:
    print("Erro: Divisão por zero não é permitida.")
except ValueError:
    print("Erro: Digite um número válido.")
except Exception as e:
    print("Erro desconhecido:", str(e))

Nesse exemplo, o programa solicita ao usuário um divisor. Se o usuário digitar zero, ocorrerá uma exceção ZeroDivisionError e a mensagem “Erro: Divisão por zero não é permitida.” será exibida. Se o usuário digitar um valor inválido, como uma string, ocorrerá uma exceção ValueError e a mensagem “Erro: Digite um número válido.” será exibida. Caso ocorra qualquer outra exceção não prevista, o bloco except Exception as e será executado e exibirá uma mensagem de erro genérica.

Ao lidar com exceções, é importante capturar exceções específicas que você espera encontrar e fornecer tratamentos adequados para cada uma delas. Isso ajudará a tornar seu código mais robusto e evitará a interrupção inesperada do programa em caso de erros.

Exceções personalizadas em Python

Em Python, é possível criar suas próprias exceções personalizadas para lidar com situações específicas em seu código. Criar exceções personalizadas permite que você tenha um controle mais granular sobre os erros e forneça informações mais claras sobre o que deu errado. Aqui estão os principais pontos a serem considerados ao trabalhar com exceções personalizadas:

Criar exceções personalizadas

Para criar uma exceção personalizada, você precisa definir uma classe que herde da classe Exception ou de uma de suas subclasses. A classe personalizada pode conter atributos e métodos adicionais para fornecer informações específicas sobre o erro. Aqui está um exemplo de como criar uma exceção personalizada:

class MinhaExcecao(Exception):
    def __init__(self, mensagem):
        self.mensagem = mensagem

    def __str__(self):
        return f"Erro personalizado: {self.mensagem}"

Neste exemplo, a classe MinhaExcecao herda da classe Exception e possui um construtor __init__ que recebe uma mensagem de erro como parâmetro. O método __str__ é sobrescrito para retornar uma representação em string da exceção personalizada.

Herança de exceções

É possível criar uma hierarquia de exceções personalizadas usando herança. Isso permite organizar as exceções em categorias e fornecer tratamentos específicos para cada uma delas. Por exemplo:

class ExcecaoBase(Exception):
    pass

class ExcecaoFilha(ExcecaoBase):
    pass

Neste exemplo, a classe ExcecaoFilha herda da classe ExcecaoBase. Isso significa que ExcecaoFilha é uma subclasse de ExcecaoBase. Ao capturar exceções, você pode tratar ExcecaoFilha separadamente de ExcecaoBase, se necessário.

Lançar exceções personalizadas

Para lançar uma exceção personalizada, você pode criar uma instância da classe de exceção e levantá-la usando a palavra-chave raise. Isso permite que você sinalize explicitamente um erro em seu código. Aqui está um exemplo:

def dividir(a, b):
    if b == 0:
        raise MinhaExcecao("Divisão por zero não é permitida.")
    return a / b

Neste exemplo, a função dividir verifica se o divisor é igual a zero. Se for o caso, uma exceção MinhaExcecao é lançada com uma mensagem de erro personalizada.

Ao lançar exceções personalizadas, é possível adicionar tratamentos específicos para capturar essas exceções em blocos try-except. Isso permite que você manipule erros personalizados de acordo com a lógica desejada.

As exceções personalizadas são úteis para fornecer informações detalhadas sobre erros específicos e criar uma estrutura de tratamento de erros mais organizada em seu código Python. Ao criar exceções personalizadas, você pode adicionar comportamentos específicos e melhorar a clareza e a manutenibilidade do seu código.

Manipulação de múltiplas exceções em Python

Em Python, é possível lidar com várias exceções em um único bloco try-except, permitindo que você capture e trate diferentes tipos de exceções de maneira conveniente. Aqui estão os principais pontos a serem considerados ao lidar com múltiplas exceções:

Lidando com várias exceções

Para lidar com várias exceções, você pode ter várias cláusulas except em um bloco try-except, cada uma capturando um tipo específico de exceção. A ordem das cláusulas except é importante, pois as exceções são tratadas na primeira cláusula que corresponder ao tipo da exceção gerada. Aqui está um exemplo:

try:
    # Código que pode gerar exceções
except ExcecaoTipo1:
    # Tratamento para a exceção ExcecaoTipo1
except ExcecaoTipo2:
    # Tratamento para a exceção ExcecaoTipo2

Nesse exemplo, se uma exceção do tipo ExcecaoTipo1 ocorrer dentro do bloco try, o código dentro da primeira cláusula except ExcecaoTipo1 será executado. Se uma exceção do tipo ExcecaoTipo2 ocorrer, o código dentro da cláusula except ExcecaoTipo2 será executado. É importante observar que, se uma exceção ocorrer, apenas a primeira cláusula except correspondente será executada, e as cláusulas seguintes serão ignoradas.

Ordem das cláusulas except

A ordem das cláusulas except é importante porque as exceções são tratadas de cima para baixo. Portanto, ao lidar com múltiplas exceções, é recomendável começar com as exceções mais específicas e, em seguida, tratar as exceções mais genéricas. Isso ocorre porque as exceções mais específicas devem ser capturadas antes das exceções mais genéricas, caso contrário, as exceções genéricas capturariam as exceções específicas e o tratamento adequado não seria realizado. Veja o exemplo a seguir:

try:
    # Código que pode gerar exceções
except ExcecaoEspecifica:
    # Tratamento para a exceção ExcecaoEspecifica
except ExcecaoGenerica:
    # Tratamento para a exceção ExcecaoGenerica

Nesse exemplo, se uma exceção do tipo ExcecaoEspecifica ocorrer, ela será capturada e tratada pela primeira cláusula except ExcecaoEspecifica. Se uma exceção do tipo ExcecaoGenerica ocorrer, ela será capturada pela cláusula except ExcecaoGenerica, pois não corresponde à cláusula except ExcecaoEspecifica anteriormente.

Ao lidar com múltiplas exceções, é importante planejar cuidadosamente a ordem das cláusulas except com base na hierarquia das exceções e nos tratamentos necessários.

Lidar com múltiplas exceções em um único bloco try-except permite que você trate diferentes tipos de erros de maneira mais concisa e organizada. Ao organizar as cláusulas except na ordem correta, você garante que cada exceção seja tratada adequadamente e que o código continue a ser executado mesmo em caso de erros.

Aninhamento de blocos try-except em Python

Em Python, é possível aninhar blocos try-except, o que significa que você pode ter um bloco try-except dentro de outro bloco try-except. Isso permite lidar com diferentes níveis de exceções de forma mais granular e fornecer tratamentos específicos para cada caso. No entanto, o aninhamento excessivo de blocos try-except pode tornar o código mais complexo e difícil de manter. Aqui estão os principais pontos a serem considerados ao usar o aninhamento de blocos try-except:

Aninhamento de blocos try-except

Você pode aninhar um bloco try-except dentro de outro bloco try-except, permitindo que você trate exceções em diferentes níveis de granularidade. Isso é útil quando você precisa capturar exceções específicas em um nível mais interno e exceções mais genéricas em um nível mais externo. Aqui está um exemplo:

try:
    # Código externo
    try:
        # Código interno
    except ExcecaoInterna:
        # Tratamento para a exceção ExcecaoInterna
except ExcecaoExterna:
    # Tratamento para a exceção ExcecaoExterna

Nesse exemplo, temos um bloco try externo que envolve um bloco try interno. Se uma exceção do tipo ExcecaoInterna ocorrer no bloco interno, ela será capturada pela cláusula except ExcecaoInterna dentro desse bloco. Caso contrário, se uma exceção do tipo ExcecaoExterna ocorrer no bloco externo, ela será capturada pela cláusula except ExcecaoExterna.

Implicações do aninhamento excessivo

Embora o aninhamento de blocos try-except seja útil em certas situações, é importante evitar o aninhamento excessivo, pois isso pode tornar o código mais complexo e difícil de entender. O aninhamento excessivo pode levar a uma estrutura de código confusa, dificultando a identificação e o tratamento adequado das exceções. Portanto, é recomendável manter o aninhamento de blocos try-except no mínimo necessário para lidar com as exceções de forma eficiente.

Aqui está um exemplo que demonstra o aninhamento de blocos try-except:

try:
    # Código externo
    try:
        # Código interno
    except ExcecaoInterna:
        # Tratamento para a exceção ExcecaoInterna
    except OutraExcecaoInterna:
        # Tratamento para outra exceção interna
except ExcecaoExterna:
    # Tratamento para a exceção ExcecaoExterna

Nesse exemplo, temos um bloco try externo que envolve um bloco try interno. Se ocorrer uma exceção do tipo ExcecaoInterna, ela será capturada pela cláusula except ExcecaoInterna dentro do bloco interno. Se ocorrer uma exceção do tipo OutraExcecaoInterna, ela será capturada pela cláusula except OutraExcecaoInterna. Por fim, se ocorrer uma exceção do tipo ExcecaoExterna, ela será capturada pela cláusula except ExcecaoExterna.

Ao utilizar o aninhamento de blocos try-except, é importante encontrar um equilíbrio entre a granularidade do tratamento de exceções e a complexidade do código. Mantenha o aninhamento no nível necessário para lidar com as exceções de forma clara e eficiente, evitando o aninhamento excessivo sempre que possível.

Boas práticas usando try-except

Ao lidar com exceções usando try-except em Python, existem algumas melhores práticas e considerações importantes a serem seguidas para garantir um código robusto e legível. Aqui estão algumas delas:

Seja específico nas exceções capturadas

É recomendável ser o mais específico possível ao capturar exceções. Em vez de capturar exceções genéricas, como Exception, é preferível capturar exceções mais específicas, como ValueError ou FileNotFoundError. Isso permite um tratamento mais adequado e evita que erros inesperados sejam ignorados.

try:
    # Código que pode gerar exceções
except ValueError:
    # Tratamento para exceções de ValueError
except FileNotFoundError:
    # Tratamento para exceções de FileNotFoundError

Trate exceções de forma apropriada

Ao capturar exceções, é importante fornecer um tratamento adequado para cada tipo de exceção. Isso pode incluir exibir mensagens de erro, registrar informações relevantes, executar ações alternativas ou lançar exceções personalizadas. O tratamento apropriado depende do contexto e da lógica específica do seu código.

try:
    # Código que pode gerar exceções
except ValueError as e:
    print(f"Erro de valor: {str(e)}")
except FileNotFoundError:
    # Lidar com o arquivo ausente de acordo com a lógica do programa

Use blocos try-except somente quando necessário

Nem todos os trechos de código requerem um bloco try-except. Use-o somente em torno do código que pode gerar exceções. Isso ajuda a manter a clareza do código e evita capturar exceções desnecessárias.

# Exemplo incorreto - try-except desnecessário
try:
    resultado = a / b
except:
    resultado = 0

# Exemplo correto - try-except aplicado apenas ao código suscetível a exceções
resultado = 0
if b != 0:
    resultado = a / b

Utilize blocos else e finally, quando necessário

O bloco else pode ser usado para especificar um código a ser executado somente se nenhuma exceção for lançada. Isso pode ser útil para separar o código de tratamento de exceções do código que deve ser executado apenas se tudo ocorrer bem. O bloco finally é usado para especificar um código que sempre será executado, independentemente de ter ocorrido uma exceção ou não.

try:
    # Código que pode gerar exceções
except ValueError:
    # Tratamento para exceções de ValueError
else:
    # Código a ser executado se nenhuma exceção ocorrer
finally:
    # Código a ser executado sempre, independentemente de exceções

Registre exceções, se necessário

Em muitos casos, é útil registrar informações sobre exceções para fins de depuração ou monitoramento. Você pode registrar exceções em um arquivo de log ou enviá-las para um serviço de registro de erros.

import logging

try:
    # Código que pode gerar exceções
except Exception as e:
    logging.exception("Ocorreu uma exceção")

Lidar com exceções de maneira adequada é essencial para garantir a robustez do código. Ao seguir as melhores práticas acima, você pode garantir um tratamento de exceção adequado, facilitar a depuração e melhorar a manutenibilidade do código.

Referências:

1. “Errors and Exceptions” (Erros e Exceções) https://docs.python.org/3/tutorial/
2. Python Crash Course, 2nd Edition, de Eric Matthes: https://ehmatthes.github.io/pcc_2e/
3. Python Tricks: A Buffet of Awesome Python Features, de Dan Bader: https://dbader.org/blog/python-exceptions-explained