Exceção personalizada do Python

Resumo : neste tutorial, você aprenderá como definir classes de exceção personalizadas em Python.

Introdução à exceção personalizada do Python

Para criar uma classe de exceção personalizada , você define uma classe que herda da classe interna Exceptionou de uma de suas subclasses, como ValueErrorclass:

O exemplo a seguir define uma CustomExceptionclasse que herda da Exceptionclasse:

class CustomException(Exception):
    """ my custom exception class """Linguagem de código:  Python  ( python )

Observe que a CustomExceptionclasse possui uma docstring que se comporta como uma instrução. Portanto, você não precisa adicionar a passinstrução para tornar a sintaxe válida.

Para gerar CustomException, você usa a raiseinstrução. Por exemplo, o seguinte usa a raiseinstrução para aumentar o CustomException:

class CustomException(Exception):
    """ my custom exception class """


try:
    raise CustomException('This is my custom exception')
except CustomException as ex:
    print(ex)Linguagem de código:  Python  ( python )

Saída:

This is my custom exceptionLinguagem de código:  Python  ( python )

Assim como as classes de exceção padrão, as exceções personalizadas também são classes. Portanto, você pode adicionar funcionalidades às classes de exceção personalizadas, como:

• Adicionando atributos e propriedades .
• Adicionar métodos , por exemplo, registrar a exceção, formatar a saída, etc.
• Substituindo os métodos __str__e__repr__
• E fazendo qualquer outra coisa que você possa fazer com aulas regulares.

Na prática, você desejará manter as exceções personalizadas organizadas criando uma hierarquia de exceções personalizadas. A hierarquia de exceções personalizada permite capturar exceções em vários níveis, como as classes de exceção padrão.

Exemplo de exceção personalizada Python

Suponha que você precise desenvolver um programa que converta uma temperatura de Fahrenheit para Celsius.

Os valores mínimo e máximo de uma temperatura em Fahrenheit são 32 e 212. Se os usuários inserirem um valor que não esteja nesta faixa, você desejará gerar uma exceção personalizada, por exemplo, FahrenheitError.

Defina a classe de exceção personalizada FahrenheitError

O seguinte define a FahrenheitErrorclasse de exceção:

class FahrenheitError(Exception):
    min_f = 32
    max_f = 212

    def __init__(self, f, *args):
        super().__init__(args)
        self.f = f

    def __str__(self):
        return f'The {self.f} is not in a valid range {self.min_f, self.max_f}'Linguagem de código:  Python  ( python )

Como funciona.

• Primeiro, defina a classe FahrenheitError que herda da Exceptionclasse.
• Em segundo lugar, adicione dois atributos de classe min_fque max_frepresentam os valores Fahrenheit mínimo e máximo.
• Terceiro, defina o __init__método que aceita um valor Fahrenheit ( f) e vários argumentos de posição ( *args). No __init__método, chame o __init__método da classe base. Além disso, atribua o fargumento ao fatributo de instância.
• Finalmente, substitua o __str__método para retornar uma representação de string personalizada da instância da classe.

Defina a função fahrenheit_to_celsius

O seguinte define a fahrenheit_to_celsiusfunção que aceita uma temperatura em Fahrenheit e retorna uma temperatura em Celsius:

def fahrenheit_to_celsius(f: float) -> float:
    if f < FahrenheitError.min_f or f > FahrenheitError.max_f:
        raise FahrenheitError(f)

    return (f - 32) * 5 / 9Linguagem de código:  Python  ( python )

A fahrenheit_to_celsiusfunção gera a FahrenheitErrorexceção se a temperatura de entrada não estiver na faixa válida. Caso contrário, ele converte a temperatura de Fahrenheit para Celsius.

Crie o programa principal

O programa principal a seguir usa a fahrenheit_to_celsiusfunção e a FahrenheitErrorclasse de exceção personalizada:

if __name__ == '__main__':
    f = input('Enter a temperature in Fahrenheit:')
    try:
        f = float(f)
    except ValueError as ex:
        print(ex)
    else:
        try:
            c = fahrenheit_to_celsius(float(f))
        except FahrenheitError as ex:
            print(ex)
        else:
            print(f'{f} Fahrenheit = {c:.4f} Celsius')Linguagem de código:  Python  ( python )

Como funciona.

Primeiro, solicite aos usuários a temperatura em Fahrenheit.

f = input('Enter a temperature in Fahrenheit:')Linguagem de código:  Python  ( python )

Segundo, converta o valor de entrada em float . Se float()não for possível converter o valor de entrada, o programa gerará uma ValueErrorexceção. Neste caso, exibe a mensagem de erro da ValueErrorexceção:

try:
    f = float(f)
    # ...
except ValueError as ex:
    print(ex)Linguagem de código:  Python  ( python )

Terceiro, converta a temperatura para Celsius chamando a fahrenheit_to_celsiusfunção e imprima a mensagem de erro se o valor de entrada não for válido Fahrenheit:

try:
    c = fahrenheit_to_celsius(float(f))
except FahrenheitError as ex:
    print(ex)
else:
    print(f'{f} Fahrenheit = {c:.4f} Celsius')Linguagem de código:  Python  ( python )

Junte tudo

class FahrenheitError(Exception):
    min_f = 32
    max_f = 212

    def __init__(self, f, *args):
        super().__init__(args)
        self.f = f

    def __str__(self):
        return f'The {self.f} is not in a valid range {self.min_f, self.max_f}'


def fahrenheit_to_celsius(f: float) -> float:
    if f < FahrenheitError.min_f or f > FahrenheitError.max_f:
        raise FahrenheitError(f)

    return (f - 32) * 5 / 9


if __name__ == '__main__':
    f = input('Enter a temperature in Fahrenheit:')
    try:
        f = float(f)
    except ValueError as ex:
        print(ex)
    else:
        try:
            c = fahrenheit_to_celsius(float(f))
        except FahrenheitError as ex:
            print(ex)
        else:
            print(f'{f} Fahrenheit = {c:.4f} Celsius')Linguagem de código:  Python  ( python )

Resumo

• Subclasse a Exceptionclasse ou uma de suas subclasses para definir uma classe de exceção personalizada.
• Crie uma hierarquia de classes de exceção para tornar as classes de exceção mais organizadas e capturar exceções em vários níveis.