python中的subprocess
python2.7 源码中的注释（由于能力有限，翻译的不太准确）：
这个模块允许您开启进程、连接输入、输出和错误的管道，并获取他们的返回代码。这个模块计划替代一些旧代码，如：
os.system、os.spawn*、os.Popen、popen2.* 、commands.*
关于subprocess模块可以用来取代这些模块和功能在下面可以找到
这个模块定义了一个Popen的类：
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): 参数为：
args应该是一个字符串或序列的程序命令及参数。程序通常执行序列或字符串的第一项，但可以通过使用明确的参数进行设置。
在UNIX上,shell = False(默认):在这种情况下,Popen类使用os.execvp()来执行程序的子进程。args应该通常是一个序列。字符串将被视为只有一个字符串的序列（程序执行)。
在UNIX上,shell= True:如果参数是一个字符串,它指定了通过shell执行命令字符串。如果参数是一个序列,第一项指定命令字符串,其他的将被视为附加的shell命令的参数。
在Windows:Popen类通过使用CreateProcess()执行这个子进程来对字符串操作。如果参数是一个序列,它将用list2cmdline方法将其转换成一个字符串。请注意,并不是所有的MS Windows应用程序解释命令行用相同的方法:list2cmdline是专为应用程序与MS C使用相同的规则。
bufsize，如果给定了,与内置行数open()的参数有相同意义:0意味着无缓冲的,1意味着线性缓冲,其他任何正值意味着使用的缓冲区(大约)大小。一个负bufsize意味着使用这个系统默认情况下,这通常意味着完全缓冲。默认值为bufsize是0(无缓冲的)。
stdin、stdout和stderr分别指定执行程序的标准输入,标准输出和标准错误。有效值是PIPE,现有的文件描述符(正整数),现有文件对象,None。PIPE创建一个新的子管道。None,没有重定向;子管道将会继承父管道的文件句柄。此外,标准错误可以用STDOUT来定义,表明应用程序应该从STDOUT捕获到相同的文件句柄的标准错误数据。
如果preexec_fn设置为一个可调用对象,该对象将在子进程执行之前调用。
如果close_fds 为True,所有的文件描述符除了0、1和2都会在子进程执行之前关闭。
如果shell是True,将通过shell执行指定的命令。
如果 cwd 不为None，子进程将在执行前切换到 cwd指定的目录
如果 env 不为空，为新进程定义环境变量
如果 universal_newlines 为 True, 则文件对象标准输出、标准错误输出以文本文件形式打开, 但是在unix系统中会以\n结束，windows中以\r\n结束。 在python程序中都是看作为\n 注意: 这种功能仅仅支持用通用换行符构建的python（默认）。同时文件对象标准输出、标准输入、标准错误的换行符属性，不会被communicate()模块所更新。
如果给定了startupinfo and creationflags参数, 将会转交给底层CreateProcess() 函数，他们可以指定诸如主窗体的外观、新进程的优先级之类的属性（仅支持windows）
这个模块也定义了一些简短的函数：
call(*popenargs, **kwargs):
运行带参数的命令. 等待命令完成后返回返回码属性。
这些参数相对于Popen构造函数是相同的。
Example:
retcode = call(["ls", "-l"])
check_call(*popenargs, **kwargs):
运行带参数的命令. 等待命令完成.如果退出码是0则返回，如果是其他则抛出
CalledProcessError错误，该CalledProcessError 对象就会有返回返回码属性
这些参数相对于Popen构造函数是相同的。
Example:
check_call(["ls", "-l"])
check_output(*popenargs, **kwargs):
运行带参数的命令并且以字节字符串来返回。
如果退出码是非0则会抛出CalledProcessError。
CalledProcessError的对象将有返回代码在returncode属性和输出在output属性
这些参数相对于Popen构造函数是相同的。
Example:
output = check_output(["ls", "-l", "/dev/null"])
异常处理：
==============
在新程序开始执行之前子进程抛出异常，之后父进程重新抛出异常。此外，异常对象会有一个额外称为'child_traceback'的属性，从子进程的角度上看，这是一个包含错误信息的字符串。
最常见的异常是OSError，比如：执行一个不存在的文件，应用程序会抛出OSError异常
如果Popen被无效的参数调用就会抛出‘ValueError’
如果check_call() and check_output()在被调用过程中返回一个非零的返回码则会抛出‘CalledProcessError’
安全
==============
和其他popen函数不同，它不会隐式的执行/bin/sh，这意味着所有的字符,包括shell元字符,可以安全地传递给子进程。
Popen 对象
=============
Popen类的实例有以下方法
poll()
检查子进程是否终止，返回returncode属性
wait()
等待子进程终止。返回returncode属性。
communicate(input=None)
与进程相互作用: 发送数据到标准输入。从标准输出、标准错误读取数据, 直到到达文件尾。等待进程终止。可选的input参数应该是发送给子进程的字符串，或者如果没有要发送给子进程的数据那就用None
communicate() 返回一个元组 (stdout, stderr).
注意:读取的数据是保存在缓冲区中,因此，如果数据太大或没有限制则不要使用这个方法
下面的属性也是有效的：
=====================
stdin
如果stdin参数是PIPE，这个属性是提供输入到子进程一个文件对象，否则为None
stdout
如果stdout参数是PIPE , 这个属性是提供输出到子进程一个文件对象，否则为None
stderr
如果stderr参数是PIPE , 这个属性是提供错误输出到子进程一个文件对象，否则为None
pid
子进程的PID
returncode
子进程的返回码。空值表示进程还没有结束，一个负值‘-N’表示子进程被信号N所结束（仅unix支持）
用subprocess模块取代旧函数：
====================================================
在本节中, "a ==> b" 意味着 b 可以替代 a.
注意: 如果没有找到执行程序，所有在本节中的函数都有可能以静默状态失败;这个模块会抛出OSError异常
在以下的例子中, 我们假设subprocess 模块是"from subprocess import *" 这样导入的：
替代 /bin/sh shell 的引号部分
---------------------------------
output=`mycmd myarg`
==>
output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
替代 shell 的管道
-------------------------
output=`dmesg | grep hda`
==>
p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]
替代 os.system()
---------------------
sts = os.system("mycmd" + " myarg")
==>
p = Popen("mycmd" + " myarg", shell=True)
pid, sts = os.waitpid(p.pid, 0)
注意:
* 通过shell调用程序通常不是必须的
* 查看returncode attribute要比exitstatus容易些.
一个更现实的例子:
try:
retcode = call("mycmd" + " myarg", shell=True)
if retcode < 0:
print >>sys.stderr, "Child was terminated by signal", -retcode
else:
print >>sys.stderr, "Child returned", retcode
except OSError, e:
print >>sys.stderr, "Execution failed:", e
替代 os.spawn*
-------------------
P_NOWAIT example:
pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
==>
pid = Popen(["/bin/mycmd", "myarg"]).pid
P_WAIT example:
retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
==>
retcode = call(["/bin/mycmd", "myarg"])
Vector example:
os.spawnvp(os.P_NOWAIT, path, args)
==>
Popen([path] + args[1:])
Environment example:
os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
==>
Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
替代 os.popen*
-------------------
pipe = os.popen("cmd", mode='r', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout
pipe = os.popen("cmd", mode='w', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin
(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdin, child_stdout) = (p.stdin, p.stdout)
(child_stdin,
child_stdout,
child_stderr) = os.popen3("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
(child_stdin,
child_stdout,
child_stderr) = (p.stdin, p.stdout, p.stderr)
(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
在 Unix系统中, os.popen2, os.popen3 与 os.popen4 同样可以在没有shell介入的情况下直接传递给程序
以序列形式执行命令行
这种方法可以用下面的方法替换:
(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
bufsize)
==>
p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
(child_stdin, child_stdout) = (p.stdin, p.stdout)
Return code handling translates as follows:
pipe = os.popen("cmd", 'w')
...
rc = pipe.close()
if rc is not None and rc % 256:
print "There were some errors"
==>
process = Popen("cmd", 'w', shell=True, stdin=PIPE)
...
process.stdin.close()
if process.wait() != 0:
print "There were some errors"
替代 popen2.*
------------------
(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
==>
p = Popen(["somestring"], shell=True, bufsize=bufsize
stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)
在 Unix系统中, popen2 也可以在没有shell介入的情况下直接传递给程序以序列形式执行命令行.
这种方法可以用下面的方法替换:
(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
mode)
==>
p = Popen(["mycmd", "myarg"], bufsize=bufsize,
stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)
The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
except that:
* subprocess.Popen raises an exception if the execution fails
* the capturestderr argument is replaced with the stderr argument.
* stdin=PIPE and stdout=PIPE must be specified.
* popen2 closes all filedescriptors by default, but you have to specify
close_fds=True with subprocess.Popen.
腾讯云开发者
