python中的subprocess.Popen（）使⽤详解
从python2.4版本开始，可以⽤subprocess这个模块来产⽣⼦进程，并连接到⼦进程的标准输⼊/输出/错误中去，还可以得到⼦进程的返回值。
subprocess意在替代其他⼏个⽼的模块或者函数，⽐如：os.system os.spawn* os.popen* popen2.* commands.*
⼀、subprocess.Popen
subprocess模块定义了⼀个类： Popen
class 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)
各参数含义如下：
args:
args参数。可以是⼀个字符串，可以是⼀个包含程序参数的列表。要执⾏的程序⼀般就是这个列表的第⼀项，或者是字符串本⾝。
subprocess.Popen(["cat",""])
subprocess.Popen("")
这两个之中，后者将不会⼯作。因为如果是⼀个字符串的话，必须是程序的路径才可以。(考虑unix的api函数exec，接受的是字符串列表)但是下⾯的可以⼯作
subprocess.Popen("", shell=True)
这是因为它相当于
subprocess.Popen(["/bin/sh", "-c", ""])
在*nix下，当shell=False（默认）时，Popen使⽤os.execvp()来执⾏⼦程序。args⼀般要是⼀个【列表】。如果args是个字符串的话，会被当做是可执⾏⽂件的路径，这样就不能传⼊任何参数了。
注意：
shlex.split()可以被⽤于序列化复杂的命令参数，⽐如：
>>> shlex.split('ls ps top grep pkill')
['ls', 'ps', 'top', 'grep', 'pkill']
>>>import shlex, subprocess
>>>command_line = raw_input()
/bin/cat - -output "" -cmd "echo '$MONEY'"
>>>args = shlex.split(command_line)
>>> print args
['/bin/cat', '-input', '', '-output', '', '-cmd', "echo '$MONEY'"]
>>>p=subprocess.Popen(args)
可以看到，空格分隔的选项（如-input）和参数（如）会被分割为列表⾥独⽴的项，但引号⾥的或者转义过的空格不在此列。这也有点像⼤多数shell的⾏为。
在linux下，当shell=True时，如果arg是个字符串，就使⽤shell来解释执⾏这个字符串。如果args是个列表，则第⼀项被视为命令，其余的都视为是给shell本⾝的参数。也就是说，等效于：
subprocess.Popen(['/bin/sh', '-c', args[0], args[1], ...])
在Windows下，下⾯的却⼜是可以⼯作的
subprocess.Popen(["", ""])
subprocess.Popen(" ")
这是由于windows下的api函数CreateProcess接受的是⼀个字符串。即使是列表形式的参数，也需要先合并成字符串再传递给api函数
subprocess.Popen(" " shell=True)
等同于
subprocess.Popen(" /C "+" " shell=True）
bufsize参数:
如果指定了bufsize参数作⽤就和内建函数open()⼀样：0表⽰不缓冲，1表⽰⾏缓冲，其他正数表⽰近似的缓冲区字节数，负数表⽰使⽤系统默认值。默认是0。
executable参数:
指定要执⾏的程序。它很少会被⽤到：⼀般程序可以由args 参数指定。如果shell=True ，executable 可以⽤于指定⽤哪个shell来执⾏（⽐如bash、csh、zsh等）。*nix下，默认是 /bin/sh ，windows 下，就是环境变量 COMSPEC 的值。windows下，只有当你要执⾏的命令确实是shell内建命令（⽐如dir ，copy 等）时，你才需要指定shell=True ，⽽当你要执⾏⼀个基于命令⾏的批处理脚本的时候，不需要指定此项。
stdin stdout和stderr：
stdin stdout和stderr，分别表⽰⼦程序的标准输⼊、标准输出和标准错误。可选的值有PIPE或者⼀个有效的⽂件描述符（其实是个正整数）或者⼀个⽂件对象，还有None。如果是PIPE，则表⽰需要创建⼀个新的管道，如果是None，不会做任何重定向⼯作，⼦进程的⽂件描述符会继承⽗进程的。另外，stderr的值还可以是STDOUT，表⽰⼦进程的标准错误也输出到标准输出。
preexec_fn参数：
如果把preexec_fn设置为⼀个可调⽤的对象（⽐如函数），就会在⼦进程被执⾏前被调⽤。（仅限*nix）
close_fds参数：
如果把close_fds设置成True，*nix下会在开⼦进程前把除了0、1、2以外的⽂件描述符都先关闭。在 Windows下也不会继承其他⽂件描述符。
shell参数：
如果把shell设置成True，指定的命令会在shell⾥解释执⾏。
cwd参数：
如果cwd不是None，则会把cwd做为⼦程序的当前⽬录。注意，并不会把该⽬录做为可执⾏⽂件的搜索⽬录，所以不要把程序⽂件所在⽬录设置为cwd 。
env参数：
如果env不是None，则⼦程序的环境变量由env的值来设置，⽽不是默认那样继承⽗进程的环境变量。
注意，即使你只在env⾥定义了某⼀个环境变量的值，也会阻⽌⼦程序得到其他的⽗进程的环境变量（也就是说，如果env⾥只有1项，那么⼦进程的环境变量就只有1个了）。例如：
>>> subprocess.Popen('env', env={'test':'123', 'testtext':'zzz'})
test=123
<subprocess.Popen object at 0x2870ad2c>
testtext=zzz
universal_newlines参数:
如果把universal_newlines 设置成True，则⼦进程的stdout和stderr被视为⽂本对象，并且不管是*nix的⾏结束符（'/n'），还是⽼mac格式的⾏结束符（'/r' ），还是windows 格式的⾏结束符（'/r/n' ）都将
被视为 '/n' 。
startupinfo和creationflags参数：
如果指定了startupinfo和creationflags，将会被传递给后⾯的CreateProcess()函数，⽤于指定⼦程序的
各种其他属性，⽐如主窗⼝样式或者是⼦进程的优先级等。（仅限Windows）
⼆、subprocess.PIPE
subprocess.PIPE
⼀个可以被⽤于Popen的stdin 、stdout 和stderr 3个参数的特输值，表⽰需要创建⼀个新的管道。
subprocess.STDOUT
⼀个可以被⽤于Popen的stderr参数的输出值，表⽰⼦程序的标准错误汇合到标准输出。
实例：
>>>p=subprocess.Popen("df -h",shell=True,stdout=subprocess.PIPE)
>>>out=adlines()
>>>out
[b'Filesystem  Size Used Avail Capacity Mounted on\n', b'/dev/ad0s1a 713M 313M 343M 48% /\n', b'
devfs  1.0K 1.0K  0B 100% /dev\n', b'/dev/ad0s1e 514M 2.1M 471M  0% /tmp\n', b'/dev/ad0s1f 4.3G 2.5G 1.4G 64% /usr\n', b'/dev/ad0s1d 2.0G 121M 1.7G  6 >>> for line in out:
...  print line.strip()
...
Filesystem  Size Used Avail Capacity Mounted on
/dev/ad0s1a 713M 313M 343M 48% /
devfs  1.0K 1.0K  0B 100% /dev
/dev/ad0s1e 514M 2.1M 471M  0% /tmp
/dev/ad0s1f 4.3G 2.5G 1.4G 64% /usr
/dev/ad0s1d 2.0G 121M 1.7G  6% /var
stdout可以使⽤read(),readline(),readlines()等⽅法
三、⽅便的函数
1、subprocess.call
subprocess.call (*popenargs , **kwargs )
执⾏命令，并等待命令结束，再返回⼦进程的返回值。参数同Popen，查看/usr/lib/python2.7/subprocess.py
去掉⽂档，其实是这样的：
def call(*popenargs, **kwargs):
return Popen(*popenargs, **kwargs).wait()
>>> subprocess.call('ifconfig',shell=True)
2、subprocess.check_call
subprocess.check_call (*popenargs , **kwargs )
执⾏上⾯的call命令，并检查返回值，如果⼦进程返回⾮0，则会抛出CalledProcessError异常，这个异常会有个returncode
属性，记录⼦进程的返回值。
def check_call(*popenargs, **kwargs):
retcode = call(*popenargs, **kwargs)
if retcode:
cmd = ("args")
raise CalledProcessError(retcode, cmd)
return 0
>>> subprocess.check_call('ifconfig')
>>> subprocess.call('noifconfig')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/local/lib/python2.7/subprocess.py", line 493, in call
return Popen(*popenargs, **kwargs).wait()
File "/usr/local/lib/python2.7/subprocess.py", line 679, in __init__
errread, errwrite)
File "/usr/local/lib/python2.7/subprocess.py", line 1228, in _execute_child
raise child_exception
OSError: [Errno 2] No such file or directory
异常⼦进程⾥抛出的异常，会在⽗进程中再次抛出。并且，异常会有个叫child_traceback的额外属性，这是个包含⼦进程错误traceback信息的字符串。遇到最多的错误回是 OSError，⽐如执⾏了⼀个并
不存在的⼦程序就会产⽣OSError。另外，如果使⽤错误的参数调⽤Popen，会抛出ValueError。当⼦程序返回⾮0时，check_call()还会产⽣CalledProcessError 异常。
安全性不像其他的popen函数，本函数不会调⽤/bin/sh来解释命令，也就是说，命令中的每⼀个字符都会被安全地传递到⼦进程⾥。
3、check_output
check_output()执⾏程序，并返回其标准输出.
def check_output(*popenargs, **kwargs):
process = Popen(*popenargs, stdout=PIPE, **kwargs)
output, unused_err = processmunicate()
retcode = process.poll()
if retcode:
cmd = ("args")
raise CalledProcessError(retcode, cmd, output=output)
return output
p=subprocess.check_output('ifconfig')
结果是所有⾏/n分割的⼀个字符串可以直接print出来这⾥开始
4、Popen对象
产⽣对象
write的返回值
p=subprocess.Popen("df -h",shell=True,stdout=subprocess.PIPE)
>>> dir(p)
Popen对象有以下⽅法：
Popen.poll()
检查⼦进程是否已结束，设置并返回returncode属性。
>>> p.poll()
Popen.wait()
等待⼦进程结束，设置并返回returncode属性。
>>> p.wait()
注意：如果⼦进程输出了⼤量数据到stdout或者stderr的管道，并达到了系统pipe的缓存⼤⼩的话，⼦进程会等待⽗进程读取管道，⽽⽗进程此时正wait着的话，将会产⽣传说中的死锁，后果是⾮常严重
滴。建议使⽤communicate() 来避免这种情况的发⽣。
Popenmunicate(input=None)
和⼦进程交互：发送数据到stdin，并从stdout和stderr读数据，直到收到EOF。等待⼦进程结束。可选的input如有有的话，要为字符串类型。
此函数返回⼀个元组： (stdoutdata , stderrdata ) 。
注意，要给⼦进程的stdin发送数据，则Popen的时候，stdin要为PIPE；同理，要可以接收数据的话，stdout或者stderr也要为PIPE。
p1=subprocess.Popen('cat /etc/passwd',shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE)
>>> p2=subprocess.Popen('grep 0:0',shell=True,stdin=p1.stdout,stdout=subprocess.PIPE)
注意：读到的数据会被缓存在内存⾥，所以数据量⾮常⼤的时候要⼩⼼了。
>>> pmunicate()
(b'Filesystem  Size Used Avail Capacity Mounted on\n/dev/ad0s1a 713M 313M 343M 48% /\ndevfs  1.0K 1.0K  0B 100% /dev\n/dev/ad0s1e 514M 2.1M 471M  0% /tmp\n/dev/ad0s1f 4.3G 2.5G 1.4G 64% /usr\n/dev/ad0s1d 2.0G 121M 1.7G  6% /var\n', None) Popen.send_signal(signal)
给⼦进程发送signal信号。
注意：windows下⽬前只⽀持发送SIGTERM，等效于下⾯的terminate() 。
停⽌⼦进程。Posix下是发送SIGTERM信号。windows下是调⽤TerminateProcess()这个API。
Popen.kill()
杀死⼦进程。Posix下是发送SIGKILL信号。windows下和terminate() ⽆异。
Popen.stdin
如果stdin 参数是PIPE，此属性就是⼀个⽂件对象，否则为None 。
Popen.stdout
如果stdout参数是PIPE，此属性就是⼀个⽂件对象，否则为None 。
Popen.stderr
如果stderr 参数是PIPE，此属性就是⼀个⽂件对象，否则为None 。
Popen.pid
⼦进程的进程号。注意，如果shell 参数为True，这属性指的是⼦shell的进程号。
>>> p.pid
22303
⼦程序的返回值，由poll()或者wait()设置，间接地也由communicate()设置。
如果为None，表⽰⼦进程还没终⽌。
如果为负数-N的话，表⽰⼦进程被N号信号终⽌。（仅限*nux）
⽤subprocess来代替其他函数都可以⽤subprocess来完成，我们假定是⽤ “from subprocess import *” 来导⼊模块的：
代替shell命令：
p=`ls -l`
等效于
p=Popen(['ls','-l'],stdout=PIPE)municate()[0]
代替shell管道：
p=`dmesg | grep cpu`
等效于
p1=Popen(['dmesg'],stdout=PIPE)
p2=Popen(['grep','cpu'],stdin=p1.stdout,stdout=PIPE)
output = p2municate()[0]
output
cpu0: <ACPI CPU> on acpi0\nacpi_throttle0: <ACPI CPU Throttling> on cpu0\n
>>> p1=subprocess.Popen('cat /etc/passwd',shell=True,stdout=subprocess.PIPE)
>>> p2=subprocess.Popen('grep 0:0',shell=True,stdin=p1.stdout,stdout=subprocess.PIPE)
>>> p3=subprocess.Popen("cut -d ':' -f 7",shell=True,stdin=p2.stdout,stdout=subprocess.PIPE)
>>> print ad()
代替os.system()
lsl = os.system('ls '+'-l')
这个是⼀个返回状态
等效于
p=Popen('ls -l', shell=True)
lsl=os.waitpid(p.pid,0)[1]
注意：
通常并不需要⽤shell来调⽤程序。⽤subprocess可以更⽅便地得到⼦程序的返回值。
其实，更真实的替换是：
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的例⼦
pid = os.spawnlp(os.P_NOWAIT, “/bin/mycmd”, “mycmd”, “myarg”)
等效于
pid = Popen(["/bin/mycmd", "myarg"]).pid
P_WAIT的例⼦
retcode = os.spawnlp(os.P_WAIT, “/bin/mycmd”, “mycmd”, “myarg”)
等效于
retcode = call(["/bin/mycmd", "myarg"])
返回值处理：
pipe = os.popen(“cmd”, ‘w')
...
rc = pipe.close()
if rc != 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”
以上这篇python中的subprocess.Popen()使⽤详解就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。