Python Program Termination: How to End or Terminate a Program


When writing Python programs, it is important to know how to properly end or terminate them. Whether you are running a simple script or a complex application, there may be times when you need to stop the program from running. In this section, we will discuss the different ways to end a Python program and when to use each method.

Using KeyboardInterrupt

Another way to terminate a Python program is by using KeyboardInterrupt. This method allows you to interrupt a running script with a keyboard signal (Ctrl+C). This can be useful if your program has entered an infinite loop or is taking too long to execute.

# Using KeyboardInterrupt
    while True:
        pass  # Your code here
except KeyboardInterrupt:
    print("Program interrupted by user")

In this example, we have an infinite loop that runs until it is interrupted by a keyboard signal. When a user presses Ctrl+C, a KeyboardInterrupt exception is raised which causes the loop to terminate and prints out a message indicating that the program was interrupted by user.

Using System Signals

Python also provides access to system signals which can be used to terminate a running program. These signals can be sent to a running program by the operating system or another process.

# Using System Signals
import signal

def signal_handler(signal, frame):
    print("Program terminated")

signal.signal(signal.SIGINT, signal_handler)

# Your code here

In this example, we define a function called signal_handler which is called when the program receives the SIGINT signal (Ctrl+C). When the signal is received, the function prints out a message and then calls the exit() function to terminate the program. We then use the signal.signal() method to assign the signal_handler function to handle the SIGINT signal.

Using the sys.exit() Function

One way to end a Python program is by using the sys.exit() function. This function is part of the built-in sys module in Python and allows you to exit a program with an optional status code.

Here’s an example of how to use the sys.exit() function:

import sys

# some code here...

# exit program with status code 0

In this example, we import the sys module and then call the exit() function with a status code of 0. The status code is optional, but it can be useful for indicating whether the program exited successfully or encountered an error.

If you don’t provide a status code, the default value is 0, which indicates successful termination. If you provide a non-zero status code, it typically indicates an error occurred during program execution.

Keep in mind that if you call sys.exit() within a try/except block, it will raise a SystemExit exception. This can be caught and handled like any other exception in Python.

Overall, the sys.exit() function is a simple and effective way to terminate a Python program. It’s especially useful when you need to exit a program from within a function or module.

Using the os._exit() Function

In Python, there are a few ways to terminate or end a program. One of the ways is by using the `os._exit()` function.

The `os._exit()` function is used to exit the current process with the specified status code. Unlike the `sys.exit()` function, which raises the `SystemExit` exception, the `os._exit()` function terminates the process without calling cleanup handlers or flushing unwritten data.

Here’s an example of how to use the `os._exit()` function:

import os

# Exit with status code 0

# Exit with status code 1

In this example, we import the `os` module and call the `_exit()` function with a status code of 0 and 1 respectively.

It’s important to note that when using the `os._exit()` function, any open files or sockets will not be closed properly, and any temporary files or directories will not be removed. Therefore, this function should only be used in situations where it is absolutely necessary to terminate the program immediately without performing any cleanup actions.

In summary, we can use the `os._exit()` function to terminate a Python program immediately without performing any cleanup actions. However, it should only be used in situations where it is absolutely necessary to do so.

Raising a SystemExit Exception

In Python, you can terminate a program by raising a SystemExit exception. This exception is raised when the sys.exit() function is called. The sys.exit() function takes an optional argument, which is usually an integer or a string.

The integer argument represents the exit status of the program, where 0 represents a successful exit and any other value represents an error. The string argument is used to display a message before terminating the program.

Here’s an example of using sys.exit() to terminate a program:

import sys

def main():
    # some code here
    if error_condition:
        print("Error: something went wrong")
    # more code here

if __name__ == '__main__':

In this example, if the `error_condition` is true, the program will print an error message and exit with status code 1. If `error_condition` is false, the program will continue running until it reaches the end of the script.

It’s important to note that raising SystemExit should be used sparingly and only when necessary. In most cases, it’s better to let the program terminate naturally at the end of its execution. However, there are cases where you might want to terminate a program early due to an error or other condition. In those cases, raising SystemExit can be useful.

Keyboard Interrupts

One way to terminate a Python program is by using keyboard interrupts. A keyboard interrupt happens when the user presses the Ctrl+C key combination on the command line interface while running the program. This sends a signal to the program to stop its execution.

To handle keyboard interrupts in Python, you can use a try-except block that catches the KeyboardInterrupt exception. Here’s an example:

    # Your code here
except KeyboardInterrupt:
    # Code to handle keyboard interrupt

In this example, if a keyboard interrupt occurs while executing the code inside the try block, the program will jump to the except block and execute the code there instead.

You can also customize the behavior of your program when a keyboard interrupt occurs. For example, you might want to display a message to the user before terminating the program. Here’s an updated example:

    # Your code here
except KeyboardInterrupt:
    print("Keyboard interrupt detected. Terminating program...")
    # Code to gracefully terminate the program

In this example, if a keyboard interrupt occurs, the program will display a message before terminating.

It’s important to note that not all programs can be terminated with a keyboard interrupt. For example, if your program is running an infinite loop or waiting for user input indefinitely, it may not respond to keyboard interrupts. In these cases, you may need to use other methods to terminate the program, such as ending it manually through your operating system’s task manager.


Python provides several ways to end or terminate a program, including the use of the `sys.exit()` function, raising a `SystemExit` exception, or simply letting the program reach its natural end.

It is important to note that terminating a program abruptly using methods such as `os._exit()` or `raise SystemExit` can have unintended consequences, such as leaving file descriptors open or not allowing cleanup code to run. Therefore, it is recommended to use `sys.exit()` as it allows for cleanup code execution and ensures proper termination of the program.

In conclusion, knowing how to properly terminate a Python program is an essential skill for any developer. By understanding the different methods available and their implications, you can ensure that your programs will end gracefully and without any issues.
Interested in learning more? Check out our Introduction to Python course!

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]