Python exit commands: quit(), exit(), sys.exit() and os._exit()

The functions quit(), exit(), sys.exit(), and os._exit() have almost the same functionality as they raise the SystemExit exception by which the Python interpreter exits and no stack traceback is printed. We can catch the exception to intercept early exits and perform cleanup activities; if uncaught, the interpreter exits as usual. In this article, we will see how to exit from the Python program.

What are Python Exit Commands?

Exit commands in Python refer to methods or statements used to terminate the execution of a Python program or exit the Python interpreter. The commonly used exit commands include `sys.exit()`, `exit()`, and `quit()`. These commands halt the program or interpreter, allowing the user to gracefully terminate the execution. there are some commands in Python for exit here we are discussing these commands in brief the commands are the following

• quit() in Python
• exit() in Python
• sys.exit() using Python
• os._exit() in Python

Note: In interactive mode (running Python in the terminal), you can typically exit by typing exit() or quit() without parentheses.

Python Exit Command using quit() Function

The quit() function works as an exit command in Python if only if the site module is imported so it should not be used in production code. Production code means the code is being used by the intended audience in a real-world situation. This function should only be used in the interpreter. It raises the SystemExit exception behind the scenes. If you print it, it will give a message and end a program in Python.

Example: In the provided code, when i is equal to 5, it prints “quit” and attempts to exit the Python interpreter using the quit() function. If i is not equal to 5, it prints the value of i.

for i in range(10):
    if i == 5:
        print(quit)
        quit()
    print(i)

Output:

0
1
2
3
4
Use quit() or Ctrl-D (i.e. EOF) to exit

Python Exit Command using exit() Function

The exit() in Python is defined as exit commands in python if in site.py and it works only if the site module is imported so it should be used in the interpreter only. It is like a synonym for quit() to make Python more user-friendly. It too gives a message when printed and terminate a program in Python.

Example: In the provided code, when i is equal to 5, it prints “exit” and attempts to exit the Python interpreter using the exit() function. If i is not equal to 5, it prints the value of i.

for i in range(10):
    if i == 5:
        print(exit)
        exit()
    print(i)

Output:

0
1
2
3
4
Use exit() or Ctrl-D (i.e. EOF) to exit

sys.exit([arg]) using Python

Unlike quit() and exit(), sys.exit() is considered as exit commands in python if good to be used in production code for the sys module is always available. The optional argument arg can be an integer giving the exit or another type of object. If it is an integer, zero is considered “successful termination”.
Note: A string can also be passed to the sys.exit() method. 

Example: In the given code, the sys.exit("Age less than 18") line will terminate the Python script with a message “Age less than 18” if the variable age is less than 18. If age is 18 or greater, it will print “Age is not less than 18”. This code is used to exit the script with a specific message when a certain condition is met. And it stop a program in Python.

import sys
age = 17
if age < 18:    
    sys.exit("Age less than 18")    
else:
    print("Age is not less than 18")

Output:

An exception has occurred, use %tb to see the full traceback.
SystemExit: Age less than 18

os._exit(n) in Python

The os._exit() method in Python is used to exit the process with specified status without calling cleanup handlers, flushing stdio buffers, etc. 

Note: This method is normally used in the child process after os.fork() system call. The standard way to exit the process is sys.exit(n) method.

Example : In this example the below Python code creates a parent-child process relationship using os.fork(). The parent process waits for the child process to finish and retrieves its exit code, while the child process prints a message and exits with a status code of success.

import os
pid = os.fork()
if pid > 0:
    
    print("\nIn parent process")
    info = os.waitpid(pid, 0)
    if os.WIFEXITED(info[1]) :
        code = os.WEXITSTATUS(info[1])
        print("Child's exit code:", code)
    
else :
    print("In child process")
    print("Process ID:", os.getpid())
    print("Hello ! Geeks")
    print("Child exiting..")
       
    os._exit(os.EX_OK)

Output:

In child process
Process ID: 25491
Hello ! Geeks
Child exiting..
In parent process
Child's exit code: 0

Conclusion

Among the above four exit functions, sys.exit() is preferred mostly because the exit() and quit() functions cannot be used in production code while os._exit() is for special cases only when the immediate exit is required.

Python exit commands: quit(), exit(), sys.exit() and os._exit() – FAQs

Is it exit() or quit() in Python?

Both exit() and quit() are built-in Python functions that are available in the interpreter to stop the execution of a Python script. They are intended for use in the interactive interpreter shell and not for use in production code. The functionality of both is essentially the same — they raise the SystemExit exception.

What is the difference between OS _exit and SYS exit?

• sys.exit(): This function is provided by the sys module in Python. It exits from Python by raising a SystemExit exception. Any cleanup actions specified in finally clauses of try statements are honored, and it allows an optional integer exit status or another type of object to be passed, which will be printed to stderr and is retrievable by some operating systems.
• os._exit(): Provided by the os module, this function exits the program without calling cleanup handlers, flushing stdio buffers, etc. Hence, it is typically used in child processes after a fork() call. The _exit() function requires a status code to be passed, which is typically an integer.

What is the SystemExit in Python?

SystemExit is an exception in Python that is raised by the sys.exit() function. When not caught, this exception will cause the Python interpreter to exit. Handling this exception can be particularly useful in larger applications where a graceful shutdown procedure might be needed (e.g., saving data, closing connections).

What is sys in Python?

The sys module in Python provides access to some variables used or maintained by the interpreter and functions that interact strongly with the interpreter. It is used to manipulate the Python runtime environment. sys provides functions and variables to manipulate different parts of the Python runtime environment such as:

• sys.argv: The list of command line arguments passed to a Python script.
• sys.exit(): Exits from Python.
• sys.path: A list of strings that specifies the search path for modules.
• sys.version: A string containing the Python version number.

What is the difference between exit() and _exit() functions?

• exit() (or sys.exit()): Exits Python by raising a SystemExit exception, allowing Python to perform all its cleanup actions, such as executing finally clauses and calling atexit-registered functions.
• _exit() (or os._exit()): Exits the program without any cleanup. This is a low-level call that is typically used in forked child processes where you want to ensure that the process exits immediately without causing any side effects with the parent process.

N

naina024

Follow

Improve

Article Tags :

• Python
• python-utility

Practice Tags :

• python