subprocess模块最全笔记

最新推荐文章于 2024-05-07 17:06:37 发布
最新推荐文章于 2024-05-07 17:06:37 发布
阅读量2.6k 收藏 20
点赞数 3
分类专栏： python 文章标签： python subprocess os
本BLOG上原创文章未经本人许可，不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利。
本文链接：https://blog.csdn.net/kpc0564335/article/details/124047228
版权

文章目录

subprocess

使用 Popen 可以在Python进程中创建子进程，如果只对子进程的执行退出状态感兴趣，可以调用 subprocess.call() 函数，如果想通过异常处理机制解决子进程异常退出的情形，可以考虑使用 subprocess.check_call()和 subprocess.check_output。如果希望获得子进程的输出，可以调用
subprocess.check_output()，但 Popen() 无疑是功能最强大的。
subprocess模块的缺陷在于默认提供的父子进程间通信手段有限，只有管道；同时创建的子进程专门用来执行外部的程序或命令。
Linux下进程间通信的手段很多，子进程也完全可能从创建之后继续调用

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)1234

创建并返回一个子进程，并在这个进程中执行指定的程序。
实例化 Popen 可以通过许多参数详细定制子进程的环境，但是只有一个参数是必须的，即位置参数 args ，下面也会详细介绍剩余的具名参数。
参数介绍：

  • args：要执行的命令或可执行文件的路径。一个由字符串组成的序列（通常是列表），列表的第一个元素是可执行程序的路径，剩下的是传给这个程序的参数，如果没有要传给这个程序的参数，args 参数可以仅仅是一个字符串。
  • bufsize：控制 stdin, stdout, stderr 等参数指定的文件的缓冲，和打开文件的 open()函数中的参数bufsize 含义相同。
  • executable：如果这个参数不是 None，将替代参数 args 作为可执行程序；
  • stdin：指定子进程的标准输入；
  • stdout：指定子进程的标准输出；
  • stderr：指定子进程的标准错误输出；
    对于 stdin, stdout 和 stderr 而言，如果他们是 None（默认情况），那么子进程使用和父进程相同的标准流文件。
    父进程如果想要和子进程通过 communicate() 方法通信，对应的参数必须是subprocess.PIPE（见下文例4）；
    当然 stdin, stdout 和 stderr 也可以是已经打开的 file 对象，前提是以合理的方式打开，比如 stdin 对应的文件必须要可读等。
  • preexec_fn：默认是None，否则必须是一个函数或者可调用对象，在子进程中首先执行这个函数，然后再去执行为子进程指定的程序或Shell。
  • close_fds：布尔型变量，为 True 时，在子进程执行前强制关闭所有除 stdin，stdout和stderr外的文件；
  • shell：布尔型变量，明确要求使用shell运行程序，与参数 executable 一同指定子进程运行在什么 Shell中——如果executable=None 而 shell=True，则使用 /bin/sh 来执行 args
    指定的程序；也就是说，Python首先起一个shell，再用这个shell来解释指定运行的命令。
  • cwd：代表路径的字符串，指定子进程运行的工作目录，要求这个目录必须存在；
  • env：字典，键和值都是为子进程定义环境变量的字符串；
  • universal_newline：布尔型变量，为 True 时，stdout 和 stderr 以通用换行（universal
    newline）模式打开，
  • startupinfo：见下一个参数；
  • creationfalgs：最后这两个参数是Windows中才有的参数，传递给Win32的CreateProcess API调用。
    同 Linux 中创建子进程类似，父进程创建完子进程后，并不会自动等待子进程执行，父进程在子进程之前退出将导致子进程成为孤儿进程，孤儿进程统一由 init 进程接管，负责其终止后的回收工作。
    　　如果父进程在子进程之后终止，但子进程终止时父进程没有进行最后的回收工作，子进程残留的数据结构称为僵尸进程。大量僵尸进程将耗费系统资源，因此父进程及时等待和回收子进程是必要的，除非能够确认自己比子进程先终止，从而将回收工作过渡给 init 进程。
    这个等待和回收子进程的操作就是wait()函数，下文中将会介绍。
    例1：
# 创建一个子进程，然后执行一个简单的命令

>>> import subprocess
>>> p = subprocess.Popen('ls -l', shell=True)
>>> total 164
-rw-r--r--  1 root root   133 Jul  4 16:25 admin-openrc.sh
-rw-r--r--  1 root root   268 Jul 10 15:55 admin-openrc-v3.sh
...
>>> p.returncode
>>> p.wait()
0
>>> p.returncode
0
# 这里也可以使用 p = subprocess.Popen(['ls', '-cl']) 来创建子进程。1234567891011121314

Popen 对象的属性

Popen创建的子进程有一些有用的属性，假设 p 是 Popen 创建的子进程，p 的属性包括：

1.p.pid 子进程的PID
2.p.returncode 该属性表示子进程的返回状态，returncode可能有多重情况：
None —— 子进程尚未结束；
==0 —— 子进程正常退出；
< 0—— 子进程被信号杀掉了。
大于 0—— 子进程异常退出，returncode对应于出错码；
3.p.stdin, p.stdout, p.stderr子进程对应的一些初始文件，如果调用Popen()的时候对应的参数是subprocess.PIPE，则这里对应的属性是一个包裹了这个管道的 file 对象

，

Popen 对象的方法

1.p.poll() 检查子进程 p 是否已经终止，返回 p.returncode 属性 (参考下文 Popen 对象的属性)；
2.p.wait()等待子进程 p 终止，返回 p.returncode 属性；注意：wait() 立即阻塞父进程，直到子进程结束！
3.p.communicate(input=None) 和子进程 p 交流，将参数 input （字符串）中的数据发送到子进程的 stdin，同时从子进程的 stdout 和 stderr 读取数据，直到EOF。
返回值： 　
二元组 (stdoutdata, stderrdata) 分别表示从标准出和标准错误中读出的数据。 父进程调用 p.communicate() 和子进程通信有以下限制：
　　（1） 只能通过管道和子进程通信，也就是说，只有调用 Popen() 创建子进程的时候参数
stdin=subprocess.PIPE，才能通过 p.communicate(input) 向子进程的 stdin 发送数据；只有参数
stout 和 stderr 也都为 subprocess.PIPE ，才能通过p.communicate()
从子进程接收数据，否则接收到的二元组中，对应的位置是None。
　　（2）父进程从子进程读到的数据缓存在内存中，因此commucate()不适合与子进程交换过大的数据。 　
注意：
　 communicate() 立即阻塞父进程，直到子进程结束！

4.p.send_signal(signal) 向子进程发送信号 signal；

5.p.terminate()终止子进程 p ，等于向子进程发送 SIGTERM 信号；

6.p.kill() 杀死子进程 p ，等于向子进程发送 SIGKILL 信号；

subprocess模块的其他方法

  1. subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)
    父进程直接创建子进程执行程序，然后等待子进程完成
    　返回值：
    　　　call() 返回子进程的 退出状态 即 child.returncode 属性；
  2. subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False)
    父进程直接创建子进程执行程序，然后等待子进程完成，具体可以使用的参数，参考上文 Popen 类的介绍。
    返回值：
    　　无论子进程是否成功，该函数都返回 0；但是　
    　　如果子进程的退出状态不是0，check_call() 抛出异常 CalledProcessError，异常对象中包含了 child.returncode 对应的返回码。
    例2：
    　　check_call()正常与错误执行命令
>>> p = subprocess.check_call(['ping' ,'-c', '2', 'www.baidu.com'])
PING www.a.shifen.com (220.181.111.188) 56(84) bytes of data.
64 bytes from 220.181.111.188: icmp_seq=1 ttl=42 time=37.4 ms
64 bytes from 220.181.111.188: icmp_seq=2 ttl=42 time=37.3 ms

--- www.a.shifen.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 37.335/37.410/37.486/0.207 ms
>>> print p
<strong>0</strong>
>>> p = subprocess.check_call(['ping' ,'-c', '4', 'www.!@$#@!(*^.com'])
ping: unknown host www.!@$#@!(*^.com
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/subprocess.py", line 540, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.<strong>CalledProcessError</strong>: Command '['ping', '-c', '4', 'www.!@$#@!(*^.com']' returned non-zero exit status 2
>>> print p
<strong>0
</strong>1234567891011121314151617181920

3.subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)
父进程直接创建子进程执行程序，以字符串的形式返回子进程的输出。
返回值：
　　字符串形式的子进程的输出结果，但是，
　　如果子进程的 退出状态 不是0，那么抛出异常 CalledProcessError，异常对象中包含了 child.returncode 对应的返回码。
　　注意：
　　　　check_output() 的函数签名中没有参数 stdout，调用该方法时，子进程的输出默认就返回给父进程。
例3：
check_output() 调用的子进程正常与错误退出

subprocess.check_output(["echo", "Hello World!"])
'Hello World!\n'
subprocess.check_output("exit 1", shell=True)
Traceback (most recent call last):
   ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1123456

注意：
　　使用上面提到的三个方法：call()、check_call() 和 check_output() 时，尽量不要将参数 stderr 和 stdout 设置为 subprocess.PIPE，这几个函数默认都会等待子进程完成，子进程产生大量的输出数据如果造成管道堵塞，父进程再等待子进程完成可能造成死锁。

subprocess模块的其他属性

1.subprocess.PIPE 调用本模块提供的若干函数时，作为 std* 参数的值，为标准流文件打开一个管道。

例4：
　　使用管道连接标准流文件

import subprocess
child1 = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE)
child2 = subprocess.Popen(['wc', '-l'], stdin=child1.stdout, stdout=subprocess.PIPE)
out = child2.communicate()
child1.wait()
child2.wait()
print(out)
# 这里将子进程 child1 的标准输出作为子进程 child2 的标准输入，父进程通过 communicate() 读取 child2 的标准输出后打印。12345678

subprocess.STDOUT调用本模块提供的若干函数时，作为 stderr 参数的值，将子进程的标准错误输出打印到标准输出。

subprocess模块定义的异常

exception subprocess.CalledProcessError` 　 
（1）什么时候可能抛出该异常： 
`调用check_call() 或 check_output() ，子进程的退出状态不为 0 时。` 　 
（2）该异常包含以下信息： 
`returncode：子进程的退出状态； cmd：创建子进程时指定的命令； output：如果是调用 check_output()时抛出的该异常，这里包含子进程的输出，否则该属性为None。

os.system()

执行操作系统的命令，将结果输出到屏幕，只返回命令执行状态(0：成功，非 0 ：失败)

 >>> import os
 >>> a =os.system("df -Th")
 文件系统       类型     容量 已用 可用 已用% 挂载点
 devtmpfs       devtmpfs 126G     0126G    0% /dev
 tmpfs         tmpfs     126G 313M 126G    1% /dev/shm
 tmpfs         tmpfs     126G 107M 126G    1% /run
 tmpfs         tmpfs     126G     0126G    0% /sys/fs/cgroup
 /dev/sda3     xfs       1.1T   57G  1.1T    6% /
 /dev/sda1     xfs       397M 202M 195M   51% /boot
 tmpfs         tmpfs     26G     0  26G    0% /run/user/0
 tmpfs         tmpfs     26G     0  26G    0% /run/user/1003
 >>> a
 0 #0表示执行成功
 >>> res =os.system("list")
 sh: list: 未找到命令
 >>> res
 32512 #非0表示执行错误

os.popen()

执行操作系统的命令，会将结果保存在内存当中，可以用read()方法读取出来

>>> import os
 # 将结果保存到内存中
 >>> res =os.popen("ls -l")
 >>> print (res)
 <os._wrap_close object at 0x7f73a767f3c8>
 # 用read()读取内容
 >>> print (res.read())
 总用量 370984
 -rw-r--r--1root     root           46412月 2414:33 1.py
 -rw-r--r--1root     root           48012月 2414:44 2.py
 -rw-r--r--1root     root            8812月 2414:44 error.txt
 drwxr-xr-x 2smgadmin smgadmin      819212月 2415:26 hsperfdata_smgadmin
 -rw-r--r--1root     root     37985963012月 1617:01 新模型.zip

subprocess.run()

 >>> import subprocess
 # python解析则传入命令的每个参数的列表
 >>> subprocess.run(["df","-h"])
 文件系统       容量 已用 可用 已用% 挂载点
 devtmpfs       126G     0126G    0% /dev
 tmpfs           126G 151M 126G    1% /dev/shm
 tmpfs           126G 107M 126G    1% /run
 tmpfs           126G     0126G    0% /sys/fs/cgroup
 /dev/sda3       1.1T   57G  1.1T    6% /
 /dev/sda1       397M 202M 195M   51% /boot
 tmpfs           26G     0  26G    0% /run/user/0
 tmpfs           26G     0  26G    0% /run/user/1003
 CompletedProcess(args=['df', '-h'], returncode=0)
 # 需要交给Linux shell自己解析，则:传入命令字符串，shell=True
 >>> subprocess.run("df -h|grep /dev/sda1",shell=True)
 /dev/sda1       397M 202M 195M   51% /boot
 CompletedProcess(args='df -h|grep /dev/sda1', returncode=0)

subprocess.getstatusoutput()

接受字符串形式的命令，返回 一个元组形式的结果，第一个元素是命令执行状态，第二个为执行结果

#执行正确
 >>> subprocess.getstatusoutput('pwd')
 (0, '/tmp')
 #执行错误
 >>> subprocess.getstatusoutput('pd')
 (127, '/bin/sh: pd: 未找到命令')

subprocess.getoutput()

接受字符串形式的命令，查看执行结果

 >>> subprocess.getoutput('pwd')
 '/tmp'

terminate()

结束进程

import subprocess
res =subprocess.Popen("sleep 20;echo 'hello'",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
res.terminate()
res.stdout.read()

pid

获取当前执行子shell的程序的进程号

import subprocess
res =subprocess.Popen("sleep 5;echo 'hello'",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
res.pid  # 获取这个linux shell 的 进程号
 59858
我是一言
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python3之subprocess常见方法使用
adz41455的博客
07-12 854
python3之subprocess常见方法使用 一、常见subprocess方法 1、subprocess.getstatusoutput(cmd) 官方解释： Return (exitcode, output) of executing cmd in a shell.Execute the string 'cmd' in a shell with 'check_output' and...
Python模块整理(三)：子进程模块subprocess
weixin_34320159的博客
03-16 7758
本来收集整理网络上相关资料后整理： 从python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误中去，还可以得到子进程的返回值。 subprocess意在替代其他几个老的模块或者函数，比如：os.system os.spawn* os.popen* popen2.* commands.* 一、subprocess...
python os.popen基础/os.popen 安全注入（OS命令注入漏洞\subprocess.getstatusoutput OS命令注入漏洞）、python 过滤命令注入危险字符
西京刀客
04-29 7089
文章目录一、python OS命令注入漏洞1. 警惕subprocess.getstatusoutput OS命令注入漏洞2. os.popen OS命令注入漏洞os.popen基础python os.popen OS命令注入漏洞 一、python OS命令注入漏洞 1. 警惕subprocess.getstatusoutput OS命令注入漏洞 python直接执行代码漏洞_警惕OS命令注入漏洞 - python篇 参考URL: https://blog.csdn.net/weixin_3980585
python subprocess怎么获取进程pid
最新发布
活到老学到老
05-07 406
来启动一个新的进程，该进程会打印"Hello World"。在进程启动后，我们通过。模块来启动子进程，并获取子进程的进程ID（PID）。来获取该进程的PID，并将其打印出来。在Python中，可以使用。在这个例子中，我们使用。
subprocess模块和.communicate()（学习更新中）
热门推荐
cuiy24的博客
09-03 1万+
subprocess模块的作用 DESCRIPTION This module allows you to spawn processes, connect to their input/output/error pipes, and obtain their return codes. 允许创建一个新的进程让其执行另外的程序，并与它进行通信，获取标准的输入、标准输出、标准错误以及返回码等。 注意：使用这个模块之前要引入该模块。 Popen类 subprocess模块中定义了一个Popen类，通过它可以来
Python 中 subprocess模块的使用
刘石头的博客
05-11 6966
文章目录前言1、subprocess模块简介一、subprocess模块的遍历函数1、call函数（1）参数命令为数组时（2）参数命令为字符串时2、check_call函数3、check_output函数 前言 subprocess在jupyter notebook中被调用时与在python 中调用会有一些不一样的地方。 1、subprocess模块简介 subprocess 模块允许我们启动一个新进程，并连接到它们的输入/输出/错误管道，从而获取返回值。 这个模块用来创建和管理子进程。它提供了高层次.
python poll,Python：在后台进程上使用popen poll
weixin_29664819的博客
12-20 524
I am running a long process (actually another python script) in the background. I need to know when it has finished. I have found that Popen.poll() always returns 0 for a background process. Is there ...
Python Subprocess模块原理及实例
09-18
主要介绍了Python Subprocess模块原理及实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python subprocess模块常见用法分析
09-20
主要介绍了Python subprocess模块常见用法,结合实例形式分析了subprocess模块进程操作相关使用技巧与注意事项,需要的朋友可以参考下
Python中subprocess模块用法实例详解
09-22
主要介绍了Python中subprocess模块用法,实例分析了subprocess模块的相关使用技巧,需要的朋友可以参考下
Python subprocess模块详细解读
09-20
主要介绍了Python subprocess模块详细解读，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
Python的subprocess模块总结
12-23
subprocess意在替代其他几个老的模块或者函数，比如：os.system os.spawn* os.popen* popen2.* commands.* subprocess最简单的用法就是调用shell命令了,另外也可以调用程序,并且可以通过stdout,stdin和stderr进行...
subprocess使用方法
A Flying Bird
06-18 903
subprocess的使用方法
python之subprocess模块
zaygee的博客
04-06 293
1.subprocess用来生成子进程，并可通过管道连接输入、输出、错误，并获得其返回值，subprocess提供了一些管理标准流（standard stream）和管道（PIPE）的工具，供进程间使用文本通信 2.subprocess常用函数：run、call、check_call、check_putput、getoutput、getstatusoutput run： subp...
【Electron-vue】构建桌面应用（7）-nodejs执行exe程序并获取输出值
chenqk_123的专栏
09-25 4047
1.前言 在之前的文章中，实现了Electron-vue在不同系统打包成安装程序。但这只是前端build/package之后的文件打包，虽然服务端的编译之后的exe文件也可以放到一起打包，并且可以去启动服务端程序。然而不能与服务端通信的话，那么这个程序存在的意义就不大。所以在这片文章中会讲一下怎么在安装之后，启动应用程序调用服务端程序，同时获取服务端的输出值/返回值。 由于不是传统意义上的前后端通信(常见的前后端通信，只需要使用http/https进行通信即可，request发送请求，response返回请
（四）poll,epoll,本地套接字，多任务编程，父子进程
zh__quan的博客
07-17 271
poll from select import poll 1.创建poll对象 p = poll() 2.添加关注的IO poll IO事件分类 POLLIN  POLLOUT  POLLERR  POLLHUP  POLLPRI  POLLVAL  rlist    wlist   xlist   断开连接　　　紧急处理　　　无效 p.register(s,POLLIN　| POLLERR)...
python subprocess使用_Python 使用subprocess调用系统命令方法及示例代码
weixin_39637059的博客
12-21 483
1､subprocess对比os.system()的优势subprocess比os.system()更灵活，可以得到stdout，stderr，获到状态代码，更好的错误处理等，官方建议使用subprocess在替代模块os.system()，该subprocess模块提供了更强大的功能来生成新流程并检索其结果。使用该模块优于使用此功能[os.system()]。2､使用subproces调用命令...
【Python】subprocess子进程管理
littlemichelle
08-12 925
来源，之前在通过ffmpeg获取视频时长的时候遇到以下代码，对subprocess.Popen()的使用分析一下。 def getLenTime(filename): # 这个list其实等于"ffprobe.exe -loglevel quiet -print_format json -show_format -show_streams -i <input video>" command = ["ffprobe.exe","-loglevel","quiet","-pr..
subprocess模块
weixin_42176112的博客
10-06 693
概述 subprocess 模块可以启动一个新进程，并连接到它们的输入/输出/错误管道，获取进程执行的结果。Popen 是 subprocess的核心， 负责子进程的创建和管理。 subprocess.Popen() """ # 常用参数(入参） # args shell 命令：可以是字符串或者序列类型（list or tuple) # bufsize 缓冲区大小：创建标准流的管道对象时使用， 默认值：-1 0 ： 不使用缓冲区 1 ： 表示行缓冲，仅当 universal_newlines=T

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是一言

让我看看你的头像

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值