Summarize several methods of executing commands in python

Currently, there are three ways to execute cmd in python that I use:

1. Use os.system("cmd")

The characteristic is that the program will type cmd during execution. Information executed on linux.

import os

os.system("ls")

2. Use the Popen module to generate a new process

Now most people like to use Popen. The Popen method does not print out information about cmd execution on Linux. Indeed, Popen is very powerful and supports a variety of parameters and modes. Before use, you need from subprocess import Popen, PIPE. But the Popen function has a flaw, that is, it is a blocking method. If a lot of content is generated when running cmd, the function can easily get blocked. The solution is not to use the wait() method, but the return value of the execution cannot be obtained.

Popen prototype is:

subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

Parameter bufsize: Specify buffer.

The parameter executable is used to specify the executable program. Generally, we use the args parameter to set the program to be run. If the shell parameter is set to True, executable specifies the shell used by the program. Under the Windows platform, the default shell is specified by the COMSPEC environment variable.

The parameters stdin, stdout, and stderr represent the standard input, output, and error handles of the program respectively. They can be PIPE, file descriptors or file objects, or can be set to None to inherit from the parent process.

The parameter preexec_fn is only valid on Unix platforms and is used to specify a callable object that will be called before the child process runs.

Parameter Close_sfs: Under the Windows platform, if close_fds is set to True, the newly created child process will not inherit the input, output, and error pipes of the parent process. We cannot set close_fds to True and redirect the standard input, output, and error (stdin, stdout, stderr) of the child process.

If the parameter shell is set to true, the program will be executed through the shell.

The parameter cwd is used to set the current directory of the child process.

The parameter env is a dictionary type, used to specify the environment variables of the child process. If env = None, the child process's environment variables will be inherited from the parent process.

Parameter Universal_newlines: Under different operating systems, the newlines of text are different. For example: '/r/n' is used to indicate replacement under Windows, while '/n' is used under Linux. If this parameter is set to True, Python will treat these newline characters as '/n'.

The parameters startupinfo and createionflags are only effective under windows. They will be passed to the underlying CreateProcess() function to set some attributes of the child process, such as: the appearance of the main window, the priority of the process, etc. wait.

subprocess.PIPE

When creating a Popen object, subprocess.PIPE can initialize the stdin, stdout or stderr parameters to represent the standard stream for communication with the subprocess.

subprocess.STDOUT

When creating a Popen object, it is used to initialize the stderr parameter, indicating that errors will be output through the standard output stream.

Popen method:

Popen.poll()

Used to check whether the child process has ended. Sets and returns the returncode attribute.

Popen.wait()

Wait for the child process to end. Sets and returns the returncode attribute.

Popen.communicate(input=None)

Interact with the child process. Send data to stdin, or read data from stdout and stderr. The optional parameter input specifies parameters to be sent to the child process. Communicate() returns a tuple: (stdoutdata, stderrdata). Note: If you want to send data to the process through its stdin, the stdin parameter must be set to PIPE when creating the Popen object. Likewise, if you want to get data from stdout and stderr, you must set stdout and stderr to PIPE.

Popen.send_signal(signal)

Send a signal to the child process.

Popen.terminate()

Stop (stop) the child process. Under the Windows platform, this method will call Windows API TerminateProcess() to end the child process.

Popen.kill()

Kill the child process.

Popen.stdin

If the parameter stdin is set to PIPE when creating the Popen object, Popen.stdin will return a file object for the child process to send instructions. Otherwise, None is returned.

Popen.stdout

If the parameter stdout is set to PIPE when creating the Popen object, Popen.stdout will return a file object for the child process to send instructions. Otherwise, None is returned.

Popen.stderr

If the stdout parameter is set to PIPE when the Popen object is created, Popen.stdout will return a file object for the child process to send instructions. Otherwise, None is returned.

Popen.pid

Get the process ID of the child process.

Popen.returncode

Get the return value of the process. If the process has not ended, return None.

For example:

p = Popen("cp -rf a/* b/", shell=True, stdout=PIPE, stderr=PIPE)

p.wait ()

if p.returncode != 0:

print "Error."

return -1

3. Use commands.getstatusoutput method

This method will not print out information about cmd execution on Linux. The only advantage of this method is that it is not a blocking method. That is, there is no problem of Popen function blocking. Import commands are required before use.

For example:

status, output = commands.getstatusoutput("ls")

There is also a method to get only output and status:

commands. getoutput("ls")

commands.getstatus("ls")

The above is the detailed content of Summarize several methods of executing commands in python. For more information, please follow other related articles on the PHP Chinese website!