[轉載]Python 中的 Subprocess

原文地址：Python 中的 Subprocess 作者：正在拉磨摘自：http://li2z.cn/2010/04/14/python_subprocess/

此文和python 內建函數一樣，內容全部出自python官方文檔，但是會 有自己的理解，並非單純的翻譯。所以，如果我理解有誤，歡迎指正，謝謝。

從python2.4版本開始，你就可以用可以用subprocess這個模組來產生子進程，並串連到子進程的標準輸入 /輸出/錯誤中去，還可以得到子進程的傳回值。subprocess意在替代其他幾個老的模組或者函數，比如：

os.system
os.spawn*
os.popen*
popen2.*
commands.*

下面將一一介紹如何用subprocess來替代這些函數或者模組。

使用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需要是一個字串，或者包含程式參數的列表。要執行的程式一般就是這個列表的第一項，或者是字串本身。但是也可以用executable參 數來明確指出。當executable參數不為空白時，args裡的第一項仍被認為是程式的“命令名”，不同於真正的 可執行檔的檔案名稱，這個“命令名”是一個用來顯示的名稱，例如執行*nix下的 ps 命令，顯示出來的就是這個“命令名”。

在*nix下，當shell=False（預設）時，Popen使用os.execvp()來 執行子程式。args一般要是一個列表。如果args是個字串的話，會被當做是可執行檔的路徑，這樣就不能傳入 任何參數了。

注意：
shlex.split()可 以被用於序列化複雜的命令參數，比如：

>>> import shlex, subprocess 
>>> command_line = raw_input() /bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'" 
>>> args =shlex.split(command_line) 
>>> print args ['/bin/vikings', '-input','eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"] 
>>> p =subprocess.Popen(args) # 成功執行!

可以看到，空格分隔的選項（如-input）和參數（如eggs.txt）會被分割為列表裡獨立的項，但引號裡的或者轉義過的空格不在此列。這也有 點像大多數shell的行為。

在*nix下，當shell=True時，如果args是個字串，就使用shell來解釋執行這個字串。 如果args是個列表，則第一項被視為命令，其餘的都視為是給shell本身的參數。也就是說，等效於：

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

在windows下，Popen使用接受字串參數的CreateProcess()來執行子程式。如果args是個列表，它會 被先用list2cmdline()轉換成字串。

如果指定了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分別表示子程式的標準輸入、標準輸出和標準錯誤。 可選的值有PIPE（見 下面的描述）或者一個有效檔案描述符（其實是個正整數）或者一個檔案對象，還有None。如果是PIPE，則表示需要建立一個新的管道，如果是 None，不會做任何重新導向工作，子進程的檔案描述符會繼承父進程的。另外，stderr的值還可以是STDOUT（見 下），表示子進程的標準錯誤也輸出到標準輸出。

如果把preexec_fn設定為一個可調用的對象（比如函數），就會在子進程被執行前被調用。（僅限*nix）

如果把close_fds設定成True，*nix下會在開子進程前把除了0、1、2以外的檔案描述符都先關閉。在 Windows下也不會繼承其他檔案描述符。

如果把shell設定成True，指定的命令會在shell裡解釋執行，這個前面已經說得比較詳細了。

如果cwd不是None，則會把cwd做為子程式的目前的目錄。注意，並不會把該目錄做為可執行檔的搜尋目 錄，所以不要把程式檔案所在目錄設定為cwd。

如果env不是None，則子程式的環境變數由env的值來設定，而不是預設那樣繼承父進程的環境變數。注 意，即使你只在env裡定義了某一個環境變數的值，也會阻止子程式得到其他的父進程的環境變數（也就是說，如果env裡只有1項，那麼子進程的環境變數就 只有1個了）。例如：

>>> subprocess.Popen('env', env={'xxx':'123', 'yyy':'zzz'}) 
<subprocess.Popen objectat 0xb694112c> 
>>> xxx=123 yyy=zzz

如果把universal_newlines設定成True，則子進程的stdout和stderr被視為文字物件，並且不管 是*nix的行結束符（'n'），還是老mac格式的行結束符（'r'），還是windows 格式的行結束符（'rn'）都將被視為 'n' 。

如果指定了startupinfo和creationflags，將會被傳遞給後面的CreateProcess()函 數，用於指定子程式的各種其他屬性，比如主視窗樣式或者是子進程的優先順序等。（僅限Windows）

介紹完Popen的各參數，再來看下兩個小東西：

subprocess.PIPE
一個可以被用於Popen的stdin、stdout和stderr3個參數的特輸值，表示需要 建立一個新的管道。

subprocess.STDOUT
一個可以被用於Popen的stderr參數的特輸值，表示子程式的標準錯誤匯合到標準輸出。

方便的函數

subprocess.call(*popenargs, **kwargs)
執行命令，並等待命令結束，再返回子進程的傳回值。參數同Popen，因為開啟 /usr/lib/python2.6/subprocess.py 你就知道，去掉文檔，其實是這樣的：

def call(*popenargs, **kwargs): return Popen(*popenargs, **kwargs).wait()

subprocess.check_call(*popenargs, **kwargs)
執行上面的call命令，並檢查傳回值，如果子進程返回非0，則會拋出CalledProcessError異常，這 個異常會有個returncode屬性，記錄子進程的傳回值。

>>> subprocess.check_call('false') 
Traceback (most recent call last): 
File "<stdin>", line 1, in <module> 
File "/usr/lib/python2.6/subprocess.py", line 498, in check_callraise CalledProcessError(retcode, cmd) 
subprocess.CalledProcessError: Command 'false'returned non-zero exit status 1

異常

子進程裡拋出的異常，會在父進程中再次拋出。並且，異常會有個叫child_traceback的額外屬性，這 是個包含子進程錯誤traceback資訊的字串。

遇到最多的錯誤回是 OSError，比如執行了一個並不存在的子程式就會產生OSError。

另外，如果使用錯誤的參數調用Popen，會拋出ValueError。

當子程式返回非0時，check_call()還會產生CalledProcessError異常。

安全性

不像其他的popen函數，本模組不會偷偷地調用/bin/sh來解釋命令，也就是說，命令中的每一個字元都會被安全地傳遞到子進程裡。

Popen對象

Popen對象有以下方法：

Popen.poll()
檢查子進程是否已結束，設定並返回 returncode 屬性。

Popen.wait()
等待子進程結束，設定並返回 returncode 屬性。

注意：如果子進程輸出了大量資料到stdout或者stderr的管道，並達到了系統 pipe的緩衝大小的話，子進程會等待父進程讀取管道，而父進程此時正wait著的話，將會產生傳說中的死結，後果是非常嚴重滴。建議使用communicate()來 避免這種情況的發生。

Popen.communicate(input=None)
和子進程互動：發送資料到stdin，並從stdout和stderr讀資料，直到收到EOF。等待子進程結束。可選的input如有 有的話，要為字串類型。
此函數返回一個元組： (stdoutdata, stderrdata) 。
注意，要給子進程的stdin發送資料，則Popen的時候，stdin要為PIPE；同理，要可以收資料的話，stdout或者stderr也要為 PIPE。

注意：讀到的資料會被緩衝在記憶體裡，所以資料量非常大的時候要小心了。

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的進程號。

Popen.returncode
子程式的傳回值，由poll()或者wait()設定，間接地也由communicate()設定。
如果為None，表示子進程還沒終止。
如果為負數-N的話，表示子進程被N號訊號終止。（僅限*nux）

用subprocess來代替其他函數

在這節裡，舉一些常用的例子，都可以用subprocess來完成，我們假定是用 “from subprocess import *” 來匯入模組的：

代替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)
sts = 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"])

Vector的例子

os.spawnvp(os.P_NOWAIT, path, args)
等效於
Popen([path] + args[1:])

關於環境變數的例子

os.spawnlpe(os.P_NOWAIT, “/bin/mycmd”, “mycmd”, “myarg”, env)
等效於
Popen(["/bin/mycmd", "myarg"], env={“PATH”: “/usr/bin”})

代替os.popen(), os.popen2(), os.popen3()：

pipe = os.popen(“cmd”, ‘r’, bufsize)
等效於
pipe = Popen(“cmd”, shell=True, bufsize=bufsize, stdout=PIPE).stdout

pipe = os.popen(“cmd”, ‘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)

*nix下，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)

傳回值處理：

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”

代替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)

*nix下，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)

popen2.Popen3 and popen2.Popen4 基本上也能用 subprocess.Popen 代替，除了以下幾點要注意：

• 執行失敗的時候Popen會拋出異常
• capturestderr參數用stderr代替
• stdin=PIPE 和 stdout=PIPE 必須要指定
• popen2預設會關掉所有檔案描述符，而Popen要指定close_fds=True