Скачать или смотреть Keep Long-Running Processes Alive with Python: A Guide to Using Subprocess

Discover how to make a Python script call a shell script and keep its process alive even after the Python script ends. Learn the practical steps and code examples for effective process management.
---
This video is based on the question https://stackoverflow.com/q/68812695/ asked by the user 'takanoha' ( https://stackoverflow.com/u/11649397/ ) and on the answer https://stackoverflow.com/a/68812841/ provided by the user 'Marko Borković' ( https://stackoverflow.com/u/14015126/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: python script calling a shell script and i want to keep its process active even if the python script ends

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Keeping Long-Running Processes Alive with Python

In many scenarios, especially in development and scripting, you may find that you want a Python script to execute a long-running shell script or binary. The challenge arises when you want the shell process to continue running even after the Python script has completed. In this guide, we’ll explore how to achieve this with Python’s subprocess module, keeping your long-running processes active.

The Problem: Managing Process Lifespan

Let’s break down the requirement using a visual description of the expected behavior:

[[See Video to Reveal this Text or Code Snippet]]

p represents the Python script being executed.

b signifies the shell script or binary being called, which should continue to run even after the Python script finishes.

You tried using subprocess.Popen() but found that when the Python script ended, it also terminated the binary. Similarly, using os.popen() was synchronous and caused the script to wait until the binary returned, which is not what you desired.

So, how can we address this?

Solution: Using subprocess.Popen

The solution lies in using the subprocess.Popen method correctly to detach the child process from the parent. Here’s a step-by-step guide on how to achieve the desired outcome.

Step 1: Create Your Shell Script

Start by creating a simple shell script that runs indefinitely. For instance, create a file named child.sh with the following content:

[[See Video to Reveal this Text or Code Snippet]]

This script will execute an infinite loop, printing "Something" to the console every second.

Step 2: Write Your Python Script

Now, create a Python script, say main.py, which will call the shell script:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Make the Shell Script Executable

Before running your scripts, don’t forget to make child.sh executable. You can do this by running the following command in your terminal:

[[See Video to Reveal this Text or Code Snippet]]

Step 4: Run Your Python Script

Now, run your Python script:

[[See Video to Reveal this Text or Code Snippet]]

Expected Behavior

Once you run main.py, you should see the following:

The Python script prints “Starting” and “Ending” and finishes executing.

Meanwhile, the shell script keeps running in the background, continuously printing "Something" every second.

Conclusion

By following the steps outlined in this post, you can successfully launch a shell script or binary from a Python script while ensuring that the process continues to run independently. This is particularly useful for running monitoring scripts, long-running tasks, or services where you don’t want the parent process to control the lifespan of the child.

With subprocess.Popen, you have the power to manage process lifespans effectively without dependencies or waits. Feel free to adapt this solution to fit your specific use cases!

Happy scripting!