To exit Python script execution, choose the least forceful option that matches the situation. Let the script reach the end for normal completion, use return or break for local control flow, and use sys.exit() when the whole process must report a deliberate status. Reserve subprocess termination for a separate process that cannot finish cooperatively.

These choices are not interchangeable: returning from a function does not stop the interpreter, while killing a process does not provide normal function cleanup.

How do you exit a Python script normally?

A Python script exits normally when its top-level code reaches the end. The interpreter then closes, and the operating system usually receives exit code 0. This is the cleanest way to close a Python program after all required work succeeds.

Put reusable work in a function and return from that function when its job is complete. A return value goes to the caller; it does not automatically exit the entire script. At the top level, reaching the end is equivalent to completing normally, but a top-level return is not valid Python syntax.

Use a context manager for resources that need predictable cleanup. For example, with open(“output.txt”, “w”) as file: closes the file when the block ends, including when an exception interrupts it. For custom cleanup, place it in a finally block:

try: perform_work()
finally: release_resource()

How do sys.exit() and SystemExit set exit codes while cleanup runs?

Call sys.exit() when a function needs to stop the whole interpreter intentionally. It raises the SystemExit exception, allowing Python to run active finally blocks and context-manager cleanup while unwinding the stack.

sys.exit(0) indicates success. A nonzero integer, such as sys.exit(2), signals an error or another meaningful failure state to the shell, scheduler, or calling process. Passing a string prints that message and normally produces a nonzero exit status.

SystemExit is an exception, but it inherits directly from BaseException rather than Exception. Code that catches SystemExit explicitly can prevent the process from ending, so only intercept it when an embedding application genuinely needs that behavior. Cleanup still belongs in finally or a context manager, not after a call that may exit.

How do return, break, Ctrl+C, and KeyboardInterrupt affect how you close a Python program?

• return leaves the current function and gives a value to its caller. It does not terminate the script unless the caller uses that result to end execution.
• break leaves the nearest loop only. Execution continues with the first statement after that loop.
• Ctrl+C sends an interrupt from the terminal. Python normally represents it as KeyboardInterrupt in the main thread.
• KeyboardInterrupt can be handled to log a message, save state, or perform an orderly shutdown. Without a handler, Python stops with an interrupt traceback and a nonzero status.

Handle interruption around the operation that needs protection: try the work, except KeyboardInterrupt to choose a response, and use finally for cleanup. Do not use break when an exception or process-wide exit is required.

How do you terminate or kill a subprocess, and when might you kill a Python program?

For a child process created with subprocess.Popen, call process.terminate() first. It requests termination and may allow the child to handle the signal and release resources. Then call process.wait() and inspect process.returncode to verify the final state.

If the child ignores termination or exceeds a shutdown timeout, call process.kill(), then call wait() again. On Unix-like systems, terminate commonly sends SIGTERM and kill sends SIGKILL; platform behavior differs, but kill is the forceful option. It can prevent application-level cleanup.

Use kill a Python program only when cooperative shutdown has failed or the process is unsafe or irreparably stuck. A parent process can check process.poll() before and after termination: None means the child is still running, while a numeric return code confirms that it has exited.