在这篇文章中，我们将带领您了解线程中的PythonSubprocess.Popen的全貌，包括线程中的while循环的相关情况。同时，我们还将为您介绍有关Python3.4.3subprocess.P

在这篇文章中，我们将带领您了解线程中的Python Subprocess.Popen的全貌，包括线程中的while循环的相关情况。同时，我们还将为您介绍有关Python 3.4.3 subprocess.Popen获取命令输出而不管道？、python subprocess Popen、python subprocess popen 静默模式（不弹出console控制台）、python subprocess.Popen 使用简介的知识，以帮助您更好地理解这个主题。

• 线程中的Python Subprocess.Popen（线程中的while循环）
• Python 3.4.3 subprocess.Popen获取命令输出而不管道？
• python subprocess Popen
• python subprocess popen 静默模式（不弹出console控制台）
• python subprocess.Popen 使用简介

线程中的Python Subprocess.Popen（线程中的while循环）

我正在尝试使用子进程模块和线程内部的Popen启动“
rsync”。调用rsync之后，我还需要读取输出。我正在使用communication方法读取输出。当我不使用线程时，代码运行良好。看来，当我使用线程时，它挂在通信调用上。我注意到的另一件事是，当我将shell设置为False时，在线程中运行时无法从通信中得到任何回报。

答案1

您没有提供任何代码供我们查看，但是以下示例与您描述的内容类似：

import threadingimport subprocessclass MyClass(threading.Thread):    def __init__(self):        self.stdout = None        self.stderr = None        threading.Thread.__init__(self)    def run(self):        p = subprocess.Popen(''rsync -av /etc/passwd /tmp''.split(),                             shell=False,                             stdout=subprocess.PIPE,                             stderr=subprocess.PIPE)        self.stdout, self.stderr = p.communicate()myclass = MyClass()myclass.start()myclass.join()print myclass.stdout

Python 3.4.3 subprocess.Popen获取命令输出而不管道？

output = subprocess.Popen(command,stdout=subprocess.PIPE)
output = output.communicate()[0]
output = output.decode()
print(output)

output = subprocess.check_output(command)
output = output.decode()
print(output)

import sys

if sys.stdout.isatty():
    print('hello')
else:
    print('goodbye')

import subprocess

p = subprocess.Popen(
    ['python3.4','2.py'],stdout=subprocess.PIPE
)

print(p.stdout.read())

--output:--
goodbye

import pexpect

child = pexpect.spawn('python3.4 2.py')

child.expect(pexpect.EOF)
print(child.before)  #Print all the output before the expectation.

--output:--
hello

import subprocess

p = subprocess.Popen(
    ['grep','--colour=auto','hello','data.txt'],stdout=subprocess.PIPE
)

print(p.stdout.read())

import pexpect

child = pexpect.spawn('grep --colour=auto hello data.txt')
child.expect(pexpect.EOF)
print(child.before)

--output:--
b'hello world\n'
b'\x1b[01;31mhello\x1b[00m world\r\n'

python subprocess Popen

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可以是字符串或者序列类型(如:list,元组),用于指定进程的可执行文件及其参数.如果是序列类型,第一个元素通常是可执行文件的路径.我们也可以显式的使用executeable参数来指定可执行文件的路径.在windows操作系统上,Popen通过调用 CreateProcess()来创建子进程,CreateProcess接收一个字符串参数,如果args是序列类型,系统将会通过list2cmdline()函数将序列类型转换为字符串。

• 参数bufsize:指定缓冲.我到现在还不清楚这个参数的具体含义,望各个大牛指点.

• 参数executable用于指定可执行程序.一般情况下我们通过args参数来设置所要运行的程序.如果将参数shell设为True,executable将指定程序使用的shell.在windows平台下,默认的shell由COMSPEC环境变量来指定.

• 参数stdin,stdout,stderr分别表示程序的标准输入、输出、错误句柄.他们可以是PIPE,文件描述符或文件对象,也可以设置为None,表示从父进程继承.

• 参数preexec_fn只在Unix平台下有效,用于指定一个可执行对象(callable object),它将在子进程运行之前被调用.

• 参数Close_sfs:在windows平台下,如果close_fds被设置为True,则新创建的子进程将不会继承父进程的输入、输出、错误管 道.我们不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr).

• 如果参数shell设为true,程序将通过shell来执行.

• 参数cwd用于设置子进程的当前目录.

• 参数env是字典类型,用于指定子进程的环境变量.如果env = None,子进程的环境变量将从父进程中继承.

• 参数Universal_newlines:不同操作系统下,文本的换行符是不一样的.如:windows下用''\r\n''表示换,而Linux下用''\n''.如果将此参数设置为True,Python统一把这些换行符当作''\n''来处理.

• 参数startupinfo与createionflags只在windows下用效,它们将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等.

用于检查子进程是否已经结束.设置并返回returncode属性.

python subprocess popen 静默模式（不弹出console控制台）

python subprocess popen 静默模式（不弹出console控制台）

import subprocess,sys
 
IS_WIN32 = ''win32'' in str(sys.platform).lower()
 
if IS_WIN32:
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags = subprocess.CREATE_NEW_CONSOLE | 
    subprocess.STARTF_USESHOWWINDOW
    startupinfo.wShowWindow = subprocess.SW_HIDE
    p = subprocess.popen([],startupinfo = startupinfo)

参考链接：https://blog.csdn.net/ztb3214/article/details/19256849?utm_source=blogxgwz9

python subprocess.Popen 使用简介

目录

一、subprocess.Popen

二、subprocess.PIPE

三、相关的函数

四、其他实例

从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参数

可以是一个字符串，可以是一个包含程序参数的列表。要执行的程序一般就是这个列表的第一项，或者是字符串本身。

subprocess.Popen(["cat","test.txt"])
subprocess.Popen("cat test.txt")

这两个之中，后者将不会工作。因为如果是一个字符串的话，必须是程序的路径才可以。(考虑unix的api函数exec，接受的是字符串列表)但是下面的可以工作

subprocess.Popen("cat test.txt",shell=True)

这是因为它相当于

subprocess.Popen(["/bin/sh","-c","cat test.txt"])

在*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 -input test.txt -output "diege.txt" -cmd "echo '$MONEY'"
>>>args = shlex.split(command_line)
>>> print args
['/bin/cat','-input','test.txt','-output','diege.txt','-cmd',"echo '$MONEY'"]
>>>p=subprocess.Popen(args)

可以看到，空格分隔的选项（如-input）和参数（如test.txt）会被分割为列表里独立的项，但引号里的或者转义过的空格不在此列。这也有点像大多数shell的行为。

在linux下，当shell=True时，如果arg是个字符串，就使用shell来解释执行这个字符串。如果args是个列表，则第一项被视为命令，其余的都视为是给shell本身的参数。也就是说，等效于：

subprocess.Popen(['/bin/sh','-c',args[0],args[1],...])

在Windows下，下面的却又是可以工作的

subprocess.Popen(["notepad.exe","test.txt"])
subprocess.Popen("notepad.exe test.txt")

这是由于windows下的api函数CreateProcess接受的是一个字符串。即使是列表形式的参数，也需要先合并成字符串再传递给api函数

subprocess.Popen("notepad.exe test.txt" shell=True)

等同于

subprocess.Popen("cmd.exe /C "+"notepad.exe test.txt" 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=p.stdout.readlines()
>>>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% /var\n'
>>> 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 = kwargs.get("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 = process.communicate()
 retcode = process.poll()
 if retcode:
  cmd = kwargs.get("args")
  raise CalledProcessError(retcode,cmd,output=output)
 return output
p=subprocess.check_output('ifconfig')

结果是所有行/n分割的一个字符串可以直接print出来 这里开始

4、Popen对象

产生对象

p=subprocess.Popen("df -h",stdout=subprocess.PIPE)

>>> dir(p)

Popen对象有以下方法：

Popen.poll()

检查子进程是否已结束，设置并返回returncode属性。

>>> p.poll()
0

Popen.wait()

等待子进程结束，设置并返回returncode属性。

>>> p.wait()
0

注意： 如果子进程输出了大量数据到stdout或者stderr的管道，并达到了系统pipe的缓存大小的话，子进程会等待父进程读取管道，而父进程此时正wait着的话，将会产生传说中的死锁，后果是非常严重滴。建议使用communicate() 来避免这种情况的发生。

Popen.communicate(input=None)

和子进程交互：发送数据到stdin，并从stdout和stderr读数据，直到收到EOF。等待子进程结束。可选的input如有有的话，要为字符串类型。

此函数返回一个元组： (stdoutdata,stderrdata ) 。

注意，要给子进程的stdin发送数据，则Popen的时候，stdin要为PIPE；同理，要可以接收数据的话，stdout或者stderr也要为PIPE。

p1=subprocess.Popen('cat /etc/passwd',stdin=subprocess.PIPE,stdout=subprocess.PIPE)   
>>> p2=subprocess.Popen('grep 0:0',stdin=p1.stdout,stdout=subprocess.PIPE)

注意：读到的数据会被缓存在内存里，所以数据量非常大的时候要小心了。

>>> p.communicate() 
(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() 。

Popen.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

Popen.returncode

子程序的返回值，由poll()或者wait()设置，间接地也由communicate()设置。

如果为None，表示子进程还没终止。

如果为负数-N的话，表示子进程被N号信号终止。（仅限*nux）

用subprocess来代替其他函数都可以用subprocess来完成，我们假定是用 “from subprocess import *” 来导入模块的：

代替shell命令：

p=`ls -l`

等效于

p=Popen(['ls','-l'],stdout=PIPE).communicate()[0]

代替shell管道：

p=`dmesg | grep cpu`

等效于

p1=Popen(['dmesg'],stdout=PIPE)
p2=Popen(['grep','cpu'],stdout=PIPE)
output = p2.communicate()[0]
output
cpu0: <ACPI cpu> on acpi0\nacpi_throttle0: <ACPI cpu Throttling> on cpu0\n

>>> p1=subprocess.Popen('cat /etc/passwd',stdout=subprocess.PIPE)
>>> p3=subprocess.Popen("cut -d ':' -f 7",stdin=p2.stdout,stdout=subprocess.PIPE)
>>> print p3.stdout.read()

代替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,“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',stdin=PIPE)
...
process.stdin.close()
if process.wait() != 0:
 print “There were some errors”

四、其他实例

今天遇到的一个问题。简单说就是，使用 subprocess 模块的 Popen 调用外部程序，如果 stdout或 stderr 参数是 pipe，并且程序输出超过操作系统的 pipe size时，如果使用 Popen.wait() 方式等待程序结束获取返回值，会导致死锁，程序卡在 wait() 调用上。

ulimit -a 看到的 pipe size 是 4KB，那只是每页的大小，查询得知 linux 默认的 pipe size 是 64KB。

看例子：

import subprocess

def test(size):
    print('start')
    cmd = 'dd if=/dev/urandom bs=1 count=%d 2>/dev/null' % size
    p = subprocess.Popen(args=cmd,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,close_fds=True)
    # p.communicate()
    p.wait()
    print('end')
    
 # 64KB
test(64 * 1024)

# 64KB + 1B
test(64 * 1024 + 1)

首先测试输出为 64KB 大小的情况。使用 dd 产生了正好 64KB 的标准输出，由 subprocess.Popen调用，然后使用 wait() 等待 dd 调用结束。可以看到正确的 start 和 end 输出；然后测试比 64KB 多的情况，这种情况下只输出了 start，也就是说程序执行卡在了 p.wait() 上，程序死锁。具体输出如下：

start
end
start

那死锁问题如何避免呢？官方文档里推荐使用 Popen.communicate()。这个方法会把输出放在内存，而不是管道里，所以这时候上限就和内存大小有关了，一般不会有问题。而且如果要获得程序返回值，可以在调用 Popen.communicate() 之后取 Popen.returncode 的值。

结论：如果使用 subprocess.Popen，就不使用 Popen.wait()，而使用 Popen.communicate() 来等待外部程序执行结束。

关于线程中的Python Subprocess.Popen和线程中的while循环的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于Python 3.4.3 subprocess.Popen获取命令输出而不管道？、python subprocess Popen、python subprocess popen 静默模式（不弹出console控制台）、python subprocess.Popen 使用简介的相关知识，请在本站寻找。