Python Run Command: 5 Ways to Executing External Programs

Python has gone to excellent heights. That’s not surprising. But there are situations where we need to use the system commands instead of the pure Pythonic way.

Python is compatible with this, either. You can run almost any system command without opening a terminal. There are inbuilt options in Python to do this.

When you can programmatically do shell commands, you can do more with the flexibility of Python and the intricacy of your operating system.

Related: How To Execute Shell Commands Over SSH Using Python?

1. Using os.system

One of the simplest ways to run a command in Python is by using the os.system function. This method allows passing bash commands and arguments directly to the system’s shell. For instance:

import os

os.system("some_command < input_file | another_command > output_file")

While os.system is convenient for executing multiple commands, setting up pipes, and input/output redirection; it requires manual handling of shell characters like spaces. However, it also provides the flexibility to run shell commands directly.

Related: 4 Ways to Run Python Commands from Terminal

2. Embracing subprocess.run (Python 3.5+)

For the most flexibility and control over bash command execution, Python 3.5 introduced the subprocess.run function. It not only captures the return code but also provides access to the output, error, and other process-related information. Let’s see an example:

import subprocess

result = subprocess.run(
    ["echo", "Hello", "World"],
    capture_output=True,
    text=True
)
print(result.stdout)

In this example, we use subprocess.run to execute the command echo Hello World and capture the output using the capture_output=True argument. The text=True argument decodes the output as text, and we print the result.

The official documentation provides in-depth information on the subprocess module, its various functions, and usage examples.

This tutorial by Real Python provides a comprehensive overview of the subprocess module with practical examples and best practices.

3. Leveraging os.popen

An alternative to os.system is os.popen, which not only executes commands but also provides a file-like object for accessing standard input/output. By passing the command as a string or a list, you can avoid the hassle of escaping characters. Consider the following example:

import os

output = os.popen("ls -l").read()
print(output)

In this case, we use os.popen to run the ls -l command and store the output in the output variable.

Related: How to Execute Shell Commands With Python?

4. Harnessing the Power of subprocess.Popen

For more advanced command execution and greater flexibility, the subprocess.Popen class is a recommended choice. This comprehensive class replaces os.popen and provides various options for controlling input/output streams, handling errors, and more. Let’s see an example:

import subprocess

process = subprocess.Popen(
    "echo Hello World",
    shell=True,
    stdout=subprocess.PIPE
)
output = process.stdout.read()
print(output)

In this example, we create a subprocess.Popen instance to execute the command echo Hello World. The shell=True argument enables the use of shell syntax. We capture the output using process.stdout.read() and print it.

5. Simplifying with subprocess.call

If you only need the return code of a command and don’t require complex I/O handling, subprocess.call provides a simplified alternative. It waits for the command to complete and returns the return code. Consider this example:

import subprocess

return_code = subprocess.call("echo Hello World", shell=True)
print(return_code)

Here, we execute the command echo Hello World and store the return code in the return_code variable.

Less recommended methods.

While the methods described above, such as os.system, os.popen, and subprocess.Popen, cover most common use cases for executing commands in Python, there are alternatives available that closely resemble their counterparts in the C language. These alternatives include os.fork, os.exec, and os.spawn. However, it is generally not recommended to use these methods directly in Python due to their complexity and potential pitfalls.

Conclusion

In this guide, we explored various methods for running commands in Python, optimizing for the keyword “python run command”. From the straightforward os.system to the powerful subprocess.run, Python provides a range of options to execute external programs seamlessly. By understanding these techniques and following best practices, you can harness the full potential of Python for executing commands and automating system tasks with confidence and security.

When executing commands with user input or any untrusted parts, it is crucial to consider security implications. Ensure that all inputs are properly validated and sanitized to prevent any potential command injection vulnerabilities. It is recommended to use constant values or thoroughly validate user input before using it in command execution.

An informative tutorial by GeeksforGeeks that covers different methods to execute shell commands in Python, including os.system, os.popen, and subprocess.Popen, and subprocess.run.

Now, armed with this knowledge, you can confidently leverage Python’s command execution capabilities to streamline your development workflow and accomplish tasks that extend beyond the confines of your Python code. Happy coding!