首先来看一段代码：

import subprocess as sp
p = sp.Popen(['echo','helloworl.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
print(p.poll())
print('Exit code:', p.returncode)
打印结果如下，在上述代码中我们仅仅创建了一个Popen对象，然后开启了子进程，随后通过poll()和returncode查看子进程的返回码，从结果来看，子进程没有结束主进程就退出了。
 
Exit code: None
下面我们通过读取stdout的内容来看看子进程会不会正常结束：
 
import subprocess as sp
p = sp.Popen(['echo','helloword.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
print((p.stdout.readlines())[0].decode(), end='')
print(p.poll())
print('Exit code:', p.returncode)
结果如下，可以看到，结果仍然是子进程没有结束。
 
helloword.py
Exit code: None
前面说到，wait会等待子进程结束，那么我们试试执行wait看看：
 
import subprocess as sp
p = sp.Popen(['echo','helloword.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
print(p.poll())
print(p.wait())
print('Exit code:', p.returncode)
结果可以看到，在wait之前子进程并没有结束，wait执行返回的值0，returncode也是0，表明子进程正常执行并结束了。
 
Exit code: 0
虽然wait可以让子进程正常结束，但是如果缓存中太多数据的话会导致死锁，因此我们采用communicate：
 
import subprocess as sp
p = sp.Popen(['echo','helloword.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
output, err = p.communicate()
print(output.decode('gbk'), end='')
print(err.decode('gbk'))
print(p.poll())
print('Exit code:', p.returncode)
结果如下，可见在communicate之后，子进程正常执行，缓存中的数据被读取出来，poll和returncode都返回0，表明子进程已正常结束。output是子进程执行输出的信息，err是执行异常时的报错信息，此处可以看到报错信息为空，说明子进程顺利执行，没有错误发生。
 
helloword.py
Exit code: 0
今天发现一个有意思的现象，当p.stdout.readlines()读取了内容之后，再使用p.communicate()读取子进程缓存中的内容，发现后者已经没有内容了，代码如下：
 
import subprocess as sp
p = sp.Popen(['echo','helloworl.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
print(p.poll())
print('Exit code:', p.returncode)
print((p.stdout.readlines())[0].decode(), end='')
output, err = p.communicate()
print(output.decode('gbk'), end='')
print(err.decode('gbk'))
# p.terminate()
print(p.poll())
print('Exit code:', p.returncode)
结果如下：
 
Exit code: None
helloworl.py
Exit code: 0
结果可以看出，p.communicate()没有读取到内容，猜测可能是p.stdout.readlines()已经将内容读取出来，因而管道中已经没有内容了，但是前面讲到p.stdout.readlines()读取了内容之后进程并不能正常结束，只有p.communicate()可以让进程正常结束。那么在碰到需要用p.stdout.readlines()的时候，我们可以采用terminate()让进程强制结束。
 
import subprocess as sp
p = sp.Popen(['echo','helloworl.py'], stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
print(p.poll())
print('Exit code:', p.returncode)
print((p.stdout.readlines())[0].decode(), end='')
p.terminate()
print(p.poll())
print('Exit code:', p.returncode)
结果如下：
 
Exit code: None
helloworl.py
Exit code: 0
                    subprocess.Popen()用法Popen的属性子进程的终止首先来看一段代码：p = subprocess.Popen(['echo','helloworl.py'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)print(p.poll())print('Exit code:', ...
				
python 中 subprocess.Popen 总结
subprocess的目的就是启动一个新的进程并且与之通信。
subprocess模块中只定义了一个类: Popen。可以使用Popen来创建进程，并与进程进行复杂的交互。它的构造函数如下：
subprocess.Popen(args, 
                bufsize=0, 
                executable=None, 
                stdin=None, 			              
				
本来收集整理网络上相关资料后整理：
从python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误中去，还可以得到子进程的返回值。
subprocess意在替代其他几个老的模块或者函数，比如：os.system os.spawn* os.popen* popen2.* commands.*
一、subprocess...
				
subprocess模块主要用于创建子进程，并连接它们的输入、输出和错误管道，获取它们的返回状态。通俗地说就是通过这个模块，你可以在Python的代码里执行操作系统级别的命令，比如“ipconfig”、“du -sh”等等。subprocess模块替代了一些老的模块和函数，比如：`os.system，os.spawn，os.popen*`
subprocess.Popen()的基本入参介绍
subprocess.Popen()(args, *, stdin=None, input=None, stdout
				
subprocess是Python 2.4中新增的一个模块，它允许你生成新的进程，连接到它们的 input/output/error 管道，并获取它们的返回（状态）码;
本文主要举例说明其中Popen的使用：
subprocess.Popen()：
在一些复杂场景中，我们需要将一个进程的执行输出作为另一个进程的输入。在另一些场景中，我们需要先进入到某个输入环境，然后再执行一系列的指令等。这个...
subprocess.Popen()
subprocess模块中基本的进程创建和管理由Popen类来处理.subprocess.popen是用来替代os.popen的.
from subprocess import Popen, PIPE
p = Pop...
				
subprocess.Popen()：
在一些复杂场景中，我们需要将一个进程的执行输出作为另一个进程的输入。在另一些场景中，我们需要先进入到某个输入环境，然后再执行一系列的指令等。这个时候我们就需要使用到suprocess的Popen()方法。该方法有以下参数：
args：shell命令，可以是字符串，或者序列类型，如list,tuple。
bufsize：缓冲区大小，可不用关心
stdi...
				
从的python2.4版本开始，可以用子这个模块来产生子进程，并连接到子进程的标准输入/输出/错误中去，还可以得到子进程的返回值。子意在替代其他几个老的模块或函数，例如：os.system，os.spawn *，os.popen *，popen2。，命令。subprocess模块可用于执行复杂的系统命令，包括os.popen()不适用的交互模式的场景，例如python
import subprocessobj = subprocess.Popen(['python'], stdin=sub..
				
subprocess.Popen()的简单用法
subprocess 模块允许你生成新的进程，连接它们的输入、输出、错误管道，并且获取它们的返回码。
subprocess.Popen(args, shell=True, stderr=subprocess.PIPE, stdin=subprocess.PIPE,stdout=subprocess.PIPE)
被用作启动进程的参数. 可能是...
1. 返回值类型：
   - `subprocess.Popen()`返回一个Popen对象，它代表了正在执行的子进程。
   - `subprocess.run()`返回一个CompletedProcess对象，它包含了已完成的子进程的执行结果。
2. 方便性：
   - `subprocess.Popen()`提供了更多底层的控制选项和灵活性。它可以用于更复杂的使用场景，如处理多个子进程、管道连接等。
   - `subprocess.run()`是Python 3.5及以上版本引入的更高级的接口，它封装了常见的命令行操作，提供了更简单易用的方式来执行外部命令。
3. 输出捕获：
   - 在Python 3.7及以下版本中，`subprocess.Popen()`需要手动处理标准输出和错误输出，通常需要使用`stdout=subprocess.PIPE`和`stderr=subprocess.PIPE`参数，并结合`communicate()`方法来获取输出结果。
   - 在Python 3.7及以上版本中，`subprocess.run()`提供了`capture_output=True`参数，可以直接捕获命令的标准输出和错误输出到`stdout`和`stderr`属性中。
4. 等待命令完成：
   - `subprocess.Popen()`需要显式地调用`wait()`或`communicate()`方法来等待子进程完成。
   - `subprocess.run()`会等待命令执行完毕，不需要显式调用其他方法。
总的来说，如果你需要更底层的控制或处理复杂的使用场景，可以使用`subprocess.Popen()`。而对于简单的命令行操作，`subprocess.run()`提供了更简洁易用的接口。如果你使用的是Python 3.7及以上版本，`subprocess.run()`可以方便地捕获输出结果。