Aangepaste Python-uitzonderingen

In deze zelfstudie leert u met behulp van voorbeelden hoe u aangepaste uitzonderingen kunt definiëren, afhankelijk van uw vereisten.

Python heeft talloze ingebouwde uitzonderingen die je programma dwingen een fout uit te voeren wanneer er iets in het programma misgaat.

Soms moet u echter uw eigen aangepaste uitzonderingen maken die uw doel dienen.

Aangepaste uitzonderingen maken

In Python kunnen gebruikers aangepaste uitzonderingen definiëren door een nieuwe klasse te maken. Deze uitzonderingsklasse moet direct of indirect worden afgeleid van de ingebouwde Exception klas. De meeste ingebouwde uitzonderingen zijn ook afgeleid van deze klasse.

>>> class CustomError(Exception):
...     pass
...

>>> raise CustomError
Traceback (most recent call last):
...
__main__.CustomError

>>> raise CustomError("An error occurred")
Traceback (most recent call last):
...
__main__.CustomError: An error occurred

Hier hebben we een door de gebruiker gedefinieerde uitzondering gemaakt met de naam CustomError die erft van de Exception klas. Deze nieuwe uitzondering kan, net als andere uitzonderingen, worden gegenereerd met behulp van de raise statement met een optionele foutmelding.

Wanneer we een groot Python-programma ontwikkelen, is het een goede gewoonte om alle door de gebruiker gedefinieerde uitzonderingen die ons programma oproept in een apart bestand te plaatsen. Veel standaardmodules doen dit. Ze definiëren hun uitzonderingen afzonderlijk als exceptions.py of errors.py (in het algemeen, maar niet altijd).

Door de gebruiker gedefinieerde uitzonderingsklassen kunnen alles implementeren wat een normale klasse kan doen, maar we maken ze over het algemeen eenvoudig en beknopt. De meeste implementaties declareren een aangepaste basisklasse en leiden andere uitzonderingsklassen af ​​van deze basisklasse. Dit concept wordt verduidelijkt in het volgende voorbeeld.

Voorbeeld:door de gebruiker gedefinieerde uitzondering in Python

In dit voorbeeld laten we zien hoe door de gebruiker gedefinieerde uitzonderingen in een programma kunnen worden gebruikt om fouten op te heffen en op te vangen.

Dit programma zal de gebruiker vragen een nummer in te voeren totdat hij een opgeslagen nummer correct heeft geraden. Om ze te helpen erachter te komen, wordt een hint gegeven of hun gok groter of kleiner is dan het opgeslagen getal.

# define Python user-defined exceptions
class Error(Exception):
    """Base class for other exceptions"""
    pass


class ValueTooSmallError(Error):
    """Raised when the input value is too small"""
    pass


class ValueTooLargeError(Error):
    """Raised when the input value is too large"""
    pass


# you need to guess this number
number = 10

# user guesses a number until he/she gets it right
while True:
    try:
        i_num = int(input("Enter a number: "))
        if i_num < number:
            raise ValueTooSmallError
        elif i_num > number:
            raise ValueTooLargeError
        break
    except ValueTooSmallError:
        print("This value is too small, try again!")
        print()
    except ValueTooLargeError:
        print("This value is too large, try again!")
        print()

print("Congratulations! You guessed it correctly.")

Hier is een voorbeeld van dit programma.

Enter a number: 12
This value is too large, try again!

Enter a number: 0
This value is too small, try again!

Enter a number: 8
This value is too small, try again!

Enter a number: 10
Congratulations! You guessed it correctly.

We hebben een basisklasse gedefinieerd met de naam Error .

De andere twee uitzonderingen (ValueTooSmallError en ValueTooLargeError ) die daadwerkelijk door ons programma worden opgevoed, zijn afgeleid van deze klasse. Dit is de standaardmanier om door de gebruiker gedefinieerde uitzonderingen in Python-programmering te definiëren, maar u bent niet alleen op deze manier beperkt.

Uitzonderingsklassen aanpassen

We kunnen deze klasse verder aanpassen om andere argumenten te accepteren volgens onze behoeften.

Om meer te weten te komen over het aanpassen van de Exception-klassen, moet u de basiskennis van objectgeoriënteerd programmeren hebben.

Bezoek Objectgeoriënteerd programmeren in Python om te leren over objectgeoriënteerd programmeren in Python.

Laten we een voorbeeld bekijken:

class SalaryNotInRangeError(Exception):
    """Exception raised for errors in the input salary.

    Attributes:
        salary -- input salary which caused the error
        message -- explanation of the error
    """

    def __init__(self, salary, message="Salary is not in (5000, 15000) range"):
        self.salary = salary
        self.message = message
        super().__init__(self.message)


salary = int(input("Enter salary amount: "))
if not 5000 < salary < 15000:
    raise SalaryNotInRangeError(salary)

Uitvoer

Enter salary amount: 2000
Traceback (most recent call last):
  File "<string>", line 17, in <module>
    raise SalaryNotInRangeError(salary)
__main__.SalaryNotInRangeError: Salary is not in (5000, 15000) range

Hier hebben we de constructor van de Exception . overschreven class om onze eigen aangepaste argumenten te accepteren salary en message . Dan de constructor van de bovenliggende Exception klasse wordt handmatig aangeroepen met de self.message argument met behulp van super() .

De aangepaste self.salary attribuut is gedefinieerd om later te worden gebruikt.

De geërfde __str__ methode van de Exception class wordt vervolgens gebruikt om het bijbehorende bericht weer te geven wanneer SalaryNotInRangeError is verhoogd.

We kunnen ook de __str__ . aanpassen methode zelf door deze te overschrijven.

class SalaryNotInRangeError(Exception):
    """Exception raised for errors in the input salary.

    Attributes:
        salary -- input salary which caused the error
        message -- explanation of the error
    """

    def __init__(self, salary, message="Salary is not in (5000, 15000) range"):
        self.salary = salary
        self.message = message
        super().__init__(self.message)

    def __str__(self):
        return f'{self.salary} -> {self.message}'


salary = int(input("Enter salary amount: "))
if not 5000 < salary < 15000:
    raise SalaryNotInRangeError(salary)

Uitvoer

Enter salary amount: 2000
Traceback (most recent call last):
  File "/home/bsoyuj/Desktop/Untitled-1.py", line 20, in <module>
    raise SalaryNotInRangeError(salary)
__main__.SalaryNotInRangeError: 2000 -> Salary is not in (5000, 15000) range

Ga naar Python Exception Handling voor meer informatie over hoe u met uitzonderingen in Python om kunt gaan.