raise an exception in python
Estimated reading time: 4 minutes
In a computer programme, there is a lot of different moving parts, that the programmer has created themselves.
And depending on the sophistication of the code written exceptions can occur, that no one has an understanding of what they mean!
As part of the process of building out the logic , knowledge will lie with the computer programmer,
but the errors that they know about and programme for, may not always be understood by everyone,
if the computer programme does not handle them correctly.
This is usually because the error message they code to explain the problem, are not always designed with ease of understandability.
Step into the frame, the ability to create your own error messages with understandable explanations.
Good programmers have a lot of traits that makes what they develop so powerful, but sometimes the simple things can really cause confusion.
Looking at the following code:
def checkvalue(): try: integervalues = input("Type something to test this out: ") if integervalue != "55" and integervalue.isdecimal(): raise ValueError elif integervalue.isalpha(): raise TypeError else: print("55 entered correctly") except ValueError: raise ValueError("Integervalue needs to be fifty five") except TypeError: raise TypeError("Number needs to be entered") finally: print("All checks completed") checkvalue() It returns: NameError: name 'integervalue' is not defined
The problem with the above code is that the variable used has a misspelling.
Luckily we can easily see that the variable “integervalue” is misspelt with an extra “s”, removing that will fix the issue
Say we took the above code, without the try and except:
from distlib.compat import raw_input def checkvalue(): integervalue =raw_input("Type something to test this out: ") if integervalue == int(55): print("success") else: print("integervalue needs to be a fifty five") checkvalue() It returns: Type something to test this out: aa integervalue needs to be a fifty five
In essence, both do the same thing, above all the first piece of code allows for better customization.
This allows us to test for specific types of errors, and allows for more specific error trapping like:
- Value Error
- Type Error
The above two are just examples you can use for built in exceptions coded to trap errors.
But what if we want to create our own exception list?
The simple way around this is to build your own class that has the errors you need to capture.
Then you reference that class in the try/except and bingo, there you have it.
The first step is to build classes with the errors you want to catch:
class ValueTooSmall(Exception): """Raised when the input value is too small""" pass class ValueLength(Exception): """Raised when the value entered is empty""" pass class ValueAlphabetic(Exception): """Raised when the value is alphabetic""" pass
Then create a function that will hold all the try except logic to check for the errors
try: integervalue = input("Type something to test this out: ") # Creates a string here if len(integervalue) == 0: raise ValueLength elif integervalue.isalpha(): raise ValueAlphabetic elif int(integervalue) != 55 and int(integervalue) < 10: # converting to integer to allow comparison raise ValueTooSmall elif int(integervalue) != 55 and int(integervalue) > 10: # converting to integer to allow comparison raise ValueError else: print("55 entered correctly") except ValueError: raise ValueError("Integervalue needs to be fifty five") except TypeError: raise TypeError("Number needs to be entered") except ValueTooSmall: raise ValueTooSmall("Number needs to be greater than 10") except ValueLength: raise ValueLength("Number needs to be entered, can't be empty") except ValueAlphabetic: raise ValueAlphabetic("You cannot enter an alphabetic value") finally:
Putting it all together
class ValueTooSmall(Exception): """Raised when the input value is too small""" pass class ValueLength(Exception): """Raised when the value entered is empty""" pass class ValueAlphabetic(Exception): """Raised when the value is alphabetic""" pass def checkvalue(): try: integervalue = input("Type something to test this out: ") # Creates a string here if len(integervalue) == 0: raise ValueLength elif integervalue.isalpha(): raise ValueAlphabetic elif int(integervalue) != 55 and int(integervalue) < 10: # converting to integer to allow comparison raise ValueTooSmall elif int(integervalue) != 55 and int(integervalue) > 10: # converting to integer to allow comparison raise ValueError else: print("55 entered correctly") except ValueError: raise ValueError("Integervalue needs to be fifty five") except TypeError: raise TypeError("Number needs to be entered") except ValueTooSmall: raise ValueTooSmall("Number needs to be greater than 10") except ValueLength: raise ValueLength("Number needs to be entered, can't be empty") except ValueAlphabetic: raise ValueAlphabetic("You cannot enter an alphabetic value") finally: print("All checks completed") checkvalue()
You will notice that the Classes we created are referenced within the code to call the exact exception we are looking to capture.
What are the benefits of approaching it this way:
- You can capture exceptions tailored to the code you are writing.
- Controls can easily be created and implemented so that specific errors with your data can be flagged straight away.
- If you are going to be looking to catch the same exceptions in numerous places, this methodology will help to implement a better structure to handle those.
- You can start to build a centralised repository of centralised exceptions and how to handle them.
- All contributors to your project know how to raise an exception in python , you do not get multiple different v