In this article, we are going to see that how to exit a Python Script.
Exiting a Python script refers to the process of termination of an active python process. In this article, we will take a look at exiting a python program, performing a task before exiting the program, and exiting the program while displaying a custom (error) message.
Exiting a Python application
There exist several ways of exiting a python application. The following article has explained some of them in great detail.
Example: Exit Using Python exit() Method
Python3
print("this is the first statement")exit()print("this is the second statement") |
Output:
this is the first statement
Detecting Script exit
Sometimes it is required to perform certain tasks before the python script is terminated. For that, it is required to detect when the script is about to exit. atexit is a module that is used for performing this very task. The module is used for defining functions to register and unregister cleanup functions. Cleanup functions are called after the code has been executed. The default cleanup functions are used for cleaning residue created by the code execution, but we would be using it to execute our custom code.
In the following code, we would be defining (and registering) a function that would be called upon the termination of the program. First, the atexit module is imported. Then exit_handler() function is defined. This function contains a print statement. Later, this function is registered by passing the function object to the atexit.register() function. In the end, there is a call to print function for displaying GFG! in the output. In the output, the first line is the output of the last print statement in the code. The second line contains the output of exit_handler function that is called upon the code execution (as a cleanup function).
Not all kinds of exits are handled by the atexit module.
Example: Detecting code exit events using atexit module
Python3
import atexitdef exit_handler(): print('My application is ending!')atexit.register(exit_handler)print('GFG!') |
Output:
GFG My application is ending!
Exit without errors
Sometimes to terminate a code block, and it’s related process, we raise errors. These errors can be handled on the calling function side. Here, we have raised a SyntaxError with custom error message to terminal the code. The try…except block handles the error and terminates the code normally.
Example: Using explicitly raised errors to terminate a process
Python3
def main(): raise SyntaxError("Custom Syntax Error")if __name__ == "__main__": try: main() except SyntaxError: print("We caught the error!") |
Output:
We caught the error!
Exit with error messages
Generally, when a Python program encounters an error, it displays it on the console screen. But sometimes we are interested in exiting the application while displaying some text denoting a possible error which might have occurred. This process could also be used to exit the program and display some text at the end. In the following code, we will be exiting the python program after displaying some text.
Here, a string or an integer could be provided as an argument to the exit() function. If the argument is a string (denoting an error message etc.), then it will be outputted after program execution. If it is an integer, then it should be an POSIX exit code.
Example: Exiting Python code with custom error message
Python3
print("Hello world!")exit("__PUT_ERROR_MSG_HERE__") |
Output:
Hello world! __PUT_ERROR_MSG_HERE__
