Use python to execute shell scripts and dynamically transfer parameters and basic use of subprocess

This article shares with you the use of python to execute shell scripts and dynamically transfer parameters and the basic use of subprocess. Interested friends can take a look.

I have encountered this situation in recent work requirements. The web side obtains the content of the configuration file and dynamically passes parameters into the shell script.

There are many ways to execute the shell script. In the end, I chose subprocess, the python standard library.

The subprocess module is very convenient. Start a child process and control its input and output

Class 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):
The parameters are:
args should be A string, or a sequence of program parameters. The program to execute is usually the first item in the args sequence or string, but can be set explicitly using executable arguments.
On UNIX, with shell=False (default): In this case, the POPEN class uses os.execvp() to execute the subroutine. args should usually be a sequence. A string will be treated as a sequence of strings as unique items (programs to be executed).

On UNIX, with shell=True: If args is a string, it specifies the command string to be executed via the shell. If args is a sequence, the first item specifies the command string and any other items are treated as additional shell arguments.

You can first create a simple shell script a.sh

$1 $2 respectively represent the first and second parameters passed into the script

If you do not write shell=True, the default is shell=False. You need to specify the executor path in the first parameter of args

bufsize If given, bufsize has the same meaning as the corresponding parameter of the built-in open() function: 0 means no buffering, 1 means line buffering, any other positive value means Use a buffer of (approximately) that size. Negative bufsize means using the system default, which usually means full buffering. The default value of bufsize is 0 (no buffering).


stdin, stdout and stderr respectively specify the standard input, standard output and standard error file handles of the executed program. Valid values are PIPE, existing file descriptor (positive integer), existing file object, and None. PIPE indicates that a new pipe should be created for the child. With None, no redirection will occur; the child's file handle will be inherited from the parent class. Alternatively, stderr can be STDOUT, which indicates that the application's stderr data should be captured into the same file handle as stdout.

In the Popen object, you can set the value subprocess.stdout=PIPE, that is, take out the standard output of the process through the pipe p.stdout.read()

preexec_fn If If preexec_fn is set to a callable object, the object will be called before the child process is executed.


If close_fds is true, all file descriptors except 0, 1 and 2 will be closed before executing the child process.


If shell is true, the specified command will be executed through the shell.


If cwd is not None, the current directory will be changed to cwd before executing the children.


If env is not None, it will define environment variables for the new process.


If universal_newlines is set to true, the file objects stdout and stderr will be opened as text files, but there may be \n, the Unix line ending convention \r, the Macintosh convention, or \r\n Any line termination, Windows convention. All these external representations are treated as \n by Python programs. Note: This feature is only available if Python was built with universal newline support (default). Additionally, the newlines properties of file objects stdout, stdin, and stderr are not updated by the communications() method.

If STARTUPINFO and creationflags are set, they will be passed to the underlying CreateProcess() function. They can specify things like the appearance of the main window and the priority of new processes. (Windows only)

Some methods of the Popen object

Popen.poll() Checks whether the child process terminates and returns the returncode of the object

Popen.wait() Waits for the child process to complete and blocks. Return returncode

Popen.communicate(input=None) Input information to the process, reading data from stdout and stderr until the end of the file is reached. Wait for the process to terminate. The optional stdin argument should be a string to be sent to the child process, or None if no data should be sent to the child process.

Returns a tuple (stdout, stderr) but the read data is cached in memory, so if the amount of data is large or infinite, do not use this method

Popen.pid Return to the Pid of the Sub -process PID

Popen.returnCode Reading the Status Code NONE -The Substitute has not ended; > 0——The child process exited abnormally, and the returncode corresponds to the error code;

Popen.kill() kills the process

Get hostname and fqdn based on Python Shell

bpython Powerful Python shell

The above is the detailed content of Use python to execute shell scripts and dynamically transfer parameters and basic use of subprocess. For more information, please follow other related articles on the PHP Chinese website!