Illegal operations in Python can raise exceptions. There are plenty of built-in exceptions in Python that are raised when corresponding errors occur.
This post will demonstrate how to run another Python feature in Python4Delphi with RAD Studio: Exception Handling in Python GUI apps and gets the output.
Prerequisites: Before we begin to work, download and install the latest Python for your platform. Follow the Python4Delphi installation instructions mentioned here. Alternatively, you can check out the easy instructions found in this video Getting started with Python4Delphi.
First, open and run our Python GUI using project Demo1 from Python4Delphi with RAD Studio. Then insert the script into the lower Memo, click the Execute button, and get the result in the upper Memo. You can find the Demo1 source on GitHub.
Table of Contents
1. Python Built-in Exceptions
We can view all the Python built-in exceptions using the built-in local() function as follows:
|
1 |
print(dir(locals()['__builtins__'])) |
Output in our Python GUI by Python4Delphi:
The table below shows built-in exceptions that are usually raised in Python:
| Exception | Description |
|---|---|
| ArithmeticError | Raised when an error occurs in numeric calculations |
| AssertionError | Raised when an assert statement fails |
| AttributeError | Raised when attribute reference or assignment fails |
| Exception | Base class for all exceptions |
| EOFError | Raised when the input() method hits an “end of file” condition (EOF) |
| FloatingPointError | Raised when a floating point calculation fails |
| GeneratorExit | Raised when a generator is closed (with the close() method) |
| ImportError | Raised when an imported module does not exist |
| IndentationError | Raised when indendation is not correct |
| IndexError | Raised when an index of a sequence does not exist |
| KeyError | Raised when a key does not exist in a dictionary |
| KeyboardInterrupt | Raised when the user presses Ctrl+c, Ctrl+z or Delete |
| LookupError | Raised when errors raised cant be found |
| MemoryError | Raised when a program runs out of memory |
| NameError | Raised when a variable does not exist |
| NotImplementedError | Raised when an abstract method requires an inherited class to override the method |
| OSError | Raised when a system related operation causes an error |
| OverflowError | Raised when the result of a numeric calculation is too large |
| ReferenceError | Raised when a weak reference object does not exist |
| RuntimeError | Raised when an error occurs that do not belong to any specific expections |
| StopIteration | Raised when the next() method of an iterator has no further values |
| SyntaxError | Raised when a syntax error occurs |
| TabError | Raised when indentation consists of tabs or spaces |
| SystemError | Raised when a system error occurs |
| SystemExit | Raised when the sys.exit() function is called |
| TypeError | Raised when two different types are combined |
| UnboundLocalError | Raised when a local variable is referenced before assignment |
| UnicodeError | Raised when a unicode problem occurs |
| UnicodeEncodeError | Raised when a unicode encoding problem occurs |
| UnicodeDecodeError | Raised when a unicode decoding problem occurs |
| UnicodeTranslateError | Raised when a unicode translation problem occurs |
| ValueError | Raised when there is a wrong value in a specified data type |
| ZeroDivisionError | Raised when the second operator in a division is zero |
When these exceptions occur, the Python interpreter stops the current process and passes it to the calling process until it is handled. If not handled, the program will crash (an error message is displayed and our program comes to a sudden unexpected halt).
2. Catching Exceptions in Python
In Python, exceptions can be handled using a “try” statement. We placed the critical operation which can raise an exception is inside the “try” clause. The code that handles the exceptions is written in the “except” clause.
The simple example below shows that we can choose what operations to perform once we have caught the exception:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Import module sys to get the type of exception import sys randomList = ['a', 0, 2] for entry in randomList: try: print("The entry is", entry) r = 1/int(entry) break except: print("Oops!", sys.exc_info()[0], "occurred.") print("Next entry.") print() print("The reciprocal of", entry, "is", r) |
Output in Python GUI:
In this program, we loop through the values of the randomList list. As previously mentioned, the portion that can cause an exception is placed inside the try block.
If no exception occurs, the except block is skipped and normal flow continues(for last value). But if any exception occurs, it is caught by the except block (first and second values).
We use exc_info() function inside sys module to print the name of the exception. We can see that a causes ValueError and 0 causes ZeroDivisionError.
3. Catching Specific Exceptions in Python
In the example above, we did not mention any specific exception in the “except” clause.
This is not a good programming practice as it will catch all exceptions and handle every case in the same way. We can specify which exceptions an “except” clause should catch.
A “try” clause can have any number of “except” clauses to handle different exceptions, however, only one will be executed in case an exception occurs.
We can use a tuple of values to specify multiple exceptions in an except clause. Here is an pseudo code example to help you:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
try: # do something pass except ValueError: # handle ValueError exception pass except (TypeError, ZeroDivisionError): # handle multiple exceptions # TypeError and ZeroDivisionError pass except: # handle all other exceptions pass |
4. Raising Exceptions in Python
In Python programming, exceptions are raised when errors occur at runtime. We can also manually raise exceptions using the “raise” keyword.
We can optionally pass values to the exception to clarify why that exception was raised. Let’s try these examples to see how they are performing well in the Python4Delphi:
|
1 |
raise KeyboardInterrupt |
Output:
|
1 |
raise MemoryError("This is an argument") |
Output:
|
1 2 3 4 5 6 |
try: a = int(input("Enter a positive integer: ")) if a <= 0: raise ValueError("That is not a positive number!") except ValueError as vE: print(vE) |
Output:
Let’s try to enter -1 as our input, and see the exception arise:
5. Python try…else clause
In some situations, we might want to run a certain block of code if the code block inside “try” ran without any errors. For these cases, you can use the optional “else” keyword with the “try” statement.
Note: Exceptions in the else clause are not handled by the preceding except clauses.
Let’s look at an example:
|
1 2 3 4 5 6 7 8 9 |
# Program to print the reciprocal of even numbers try: num = int(input("Enter a number: ")) assert num % 2 == 0 except: print("Not an even number!") else: reciprocal = 1/num print(reciprocal) |
Let’s try to enter 3 (odd number) as our input, and see the exception arise:
If we pass an even number, the reciprocal is computed and displayed:
However, if we pass 0, we get ZeroDivisionError as the code block inside else is not handled by preceding except.
6. Python try…finally
The “try” statement in Python can have an optional “finally” clause. This clause is executed no matter what, and is generally used to release external resources.
For example, we may be connected to a remote data center through the network or working with a file or a Graphical User Interface (GUI).
In all these circumstances, we must clean up the resource before the program comes to a halt whether it successfully ran or not. These actions (closing a file, GUI or disconnecting from network) are performed in the finally clause to guarantee the execution.
Here is an example of file operations to illustrate this:
|
1 2 3 4 5 |
try: f = open("test.txt",encoding = 'utf-8') # perform file operations finally: f.close() |
This type of exception handling makes sure that the file is closed even if an exception occurs during the program execution.
Check out Python4Delphi which easily allows you to build Python GUIs for Windows using Delphi.
