目录
2.5：subprocess.getstatusoutput
subprocess 模块允许你生成新的进程，连接它们的输入、输出、错误管道，并且获取它们的返回码。此模块打算代替一些老旧的模块与功能：
os.system
os.spawn*
1：获取模块帮助文档
# encoding=gbk
import subprocess
print(subprocess.__doc__)
print(dir(subprocess))
for item in dir(subprocess):
print(item)
print(help(subprocess.run))
print(help(subprocess.Popen))
print(subprocess.__doc__) 返回值如下：
This module allows you to spawn processes, connect to their
input/output/error pipes, and obtain their return codes.
For a complete description of this module see the Python documentation.
Main API
========
run(...): Runs a command, waits for it to complete, then returns a
CompletedProcess instance.
Popen(...): A class for flexibly executing a command in a new process
Constants
---------
DEVNULL: Special value that indicates that os.devnull should be used
PIPE: Special value that indicates a pipe should be created
STDOUT: Special value that indicates that stderr should go to stdout
Older API
=========
call(...): Runs a command, waits for it to complete, then returns
the return code.
check_call(...): Same as call() but raises CalledProcessError()
if return code is not 0
check_output(...): Same as check_call() but returns the contents of
stdout instead of a return code
getoutput(...): Runs a command in the shell, waits for it to complete,
then returns the output
getstatusoutput(...): Runs a command in the shell, waits for it to complete,
then returns a (exitcode, output) tuple
2：基本操作方法
2.1：subprocess.call
看下面的解释：与os.system()功能是一样；
print(help(subprocess.call))
"""
Help on function call in module subprocess:
call(*popenargs, timeout=None, **kwargs)
Run command with arguments. Wait for command to complete or
timeout, then return the returncode attribute.
The arguments are the same as for the Popen constructor. Example:
retcode = call(["ls", "-l"])
"""
# encoding=gbk
import subprocess
ret = subprocess.call(['ipconfig ','-a'])
print(ret)
ret = subprocess.call('ipconfig -a')
print(ret)
#
# print('*'*20)
# import os
# ret = os.system('ipconfig')
2.2：subprocess.check_call
与subprocess.call功能一样，不过在命令退出状态不为0时，raise CalledProcessError(retcode, cmd)
print(help(subprocess.check_call))
"""
check_call(*popenargs, **kwargs)
Run command with arguments. Wait for command to complete. If
the exit code was zero then return, otherwise raise
CalledProcessError. The CalledProcessError object will have the
return code in the returncode attribute.
The arguments are the same as for the call function. Example:
check_call(["ls", "-l"])
"""
测试：在同级目录下新建文件 test.py,内容如下：
import sys
print('in test')
sys.exit(1)
# encoding=gbk
import subprocess
# print(help(subprocess.check_call))
try:
# ret = subprocess.check_call('python test.py')
ret = subprocess.check_call('python test.py')
print(ret)
except subprocess.CalledProcessError as e:
print('脚本异常退出',e.returncode,e.cmd)
"""
结果：
in test
脚本异常退出 1 python test.py
"""
2.3：subprocess.check_output
与subprocess.check_call一样，在命令退出状态不为0时，raise CalledProcessError(retcode, cmd)；不过其返回值是命令的输出。
# encoding=gbk
import subprocess
# print(help(subprocess.check_output))
try:
# ret = subprocess.check_output('python test.py')
ret = subprocess.check_output(['python','test.py'])
print('ret=',ret)
except subprocess.CalledProcessError as e:
print('脚本异常退出',e.returncode,e.cmd)
2.4：subprocess.getoutput
getoutput(cmd) 返回命令执行中的输出结果，同os.popen返回的结果
Return output (stdout or stderr) of executing cmd in a shell.
# encoding=gbk
import subprocess
# print(help(subprocess.getoutput))
# ret = subprocess.getoutput('python test.py')
ret = subprocess.getoutput(['python','test.py'])
print('ret=',ret)
2.5：subprocess.getstatusoutput
getstatusoutput(cmd) 返回命令退出状态，及命令执行中的输出。
Return (exitcode, output) of executing cmd in a shell.
# encoding=gbk
import subprocess
print(help(subprocess.getstatusoutput))
# ret = subprocess.getstatusoutput('python test.py')
ret = subprocess.getstatusoutput(['python','test.py'])
print('ret=',ret) # 输出 ret= (2, 'in test')
2.6：subprocess.run
run(*popenargs, input=None, timeout=None, check=False, **kwargs)，返回CompletedProcess
使用 print(help(subprocess.run)) 查看详情说明。
| 参数 | 说明 | 描述 |
| popenargs | 可以是一个字符串，可以是一个包含程序参数的列表。 | 当为字符串时，需要是程序的路径才可以，或者shell为True |
| stdin、stdout 和 stderr： | stdout为None时不捕获，命令的输出 | 子进程的标准输入、输出和错误。其值可以是 subprocess.PIPE、 subprocess.DEVNULL、一个已经存在的文件描述符、已经打开的文件对象或者 None |
| check | check=True时，状态为非0时抛出CalledProcessError | 是否检测命令的退出状态 |
| universal_newlines |
universal_newlines=True时stdout 的输出结果为字符串，同时input也需要是字符串 universal_newlines=False时stdout 的输出结果为Bytes，同时input也需要是Bytes |
|
| encoding | encoding='gbk' encoding='utf-8' |
encoding是告诉python，命令的输出结果是什么编码格式。stdin、stdout 和 stderr 可以接收字符串数据，并以该编码方式解码命令中输出的结果（命令中的输出结果是gbk，就使用gbk）。否则只接收 bytes 类型的数据 |
| timeout | 如果发生超时，子进程将被杀死并等待。 TimeoutExpired 异常将在子进程中断后被抛出。 |
测试：
在同目录下新建文件test.py
其内容如下：
# encoding=gbk
import sys
print('in test 中国 1234')
print('int test,sys.argv=[',sys.argv,']')
sys.exit(2)
# encoding=gbk
import subprocess
# print(help(subprocess.run))
# ret = subprocess.run('python test.py')
# 1:只有命令参数，只执行命令，返回值中 有已执行的命令，returncode
ret = subprocess.run(['python','test.py'])
print('ret_001=',ret) # ret_001= CompletedProcess(args=['python', 'test.py'], returncode=2)
# 2：增加stdout参数，返回值中能捕获命令的输出结果，结果是bytes
ret = subprocess.run(['python','test.py'],stdout=subprocess.PIPE)
print('ret_002=',ret) # ret_002= CompletedProcess(args=['python', 'test.py'], returncode=2, stdout=b"in test \xd6\xd0\xb9\xfa 1234\r\nint test,sys.argv=[ ['test.py'] ]\r\n")
# 3：在上面2基础上增加universal_newlines=True，输出结果是字符串
ret = subprocess.run(['python','test.py'],stdout=subprocess.PIPE,universal_newlines=True)
print('ret_003=',ret) # ret_003= CompletedProcess(args=['python', 'test.py'], returncode=2, stdout="in test 中国 1234\nint test,sys.argv=[ ['test.py'] ]\n")
# 4: 添加 shell
# ret = subprocess.run(['dir']) # FileNotFoundError
# print('ret_004-1=',ret) #
ret = subprocess.run(['dir'],shell=True)
print('ret_004-2=',ret) #
# 5：在上面3基础上增加check=True，抛出 CalledProcessError异常，因为在test.py中退出状态码为2
ret = subprocess.run(['python','test.py'],stdout=subprocess.PIPE,universal_newlines=True,check=True)
print('ret_005=',ret) #
2.7：subprocess.Popen
在一个新的进程中执行子程序。在 POSIX，此类使用类似于 os.execvp() 的行为来执行子程序。在 Windows，此类使用了 Windows CreateProcess() 函数。subprocess模块的底层的进程创建与管理由 Popen 类处理。它提供了很大的灵活性，因此开发者能够处理未被上面函数覆盖的不常见用例。上面那些函数都是调用subprocess.Popen来实现的。
其参数如下：
args, bufsize=-1, executable=None,
stdin=None, stdout=None, stderr=None,
preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
shell=False, cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0,
restore_signals=True, start_new_session=False,
pass_fds=(), *, encoding=None, errors=None
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个了）。
universal_newlines参数:
如果把universal_newlines 设置成True，则子进程的stdout和stderr被视为文本对象，并且不管是*nix的行结束符（’/n’），还是老mac格式的行结束符（’/r’ ），还是windows 格式的行结束符（’/r/n’ ）都将被视为 ‘/n’ 。
startupinfo和creationflags参数：
如果指定了startupinfo和creationflags，将会被传递给后面的CreateProcess()函数，用于指定子程序的各种其他属性，比如主窗口样式或者是子进程的优先级等。（仅限Windows）