精华内容
下载资源
问答
  • 今天小编就为大家分享一篇python中的subprocess.Popen()使用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • python中popen使用

    2019-10-24 16:09:06
    os.popen() 功能强于os.system() , os.popen() 可以返回回显的内容,以文件描述符返回 实例 import os r = os.popen(“ipconfig”) # 执行操作系统命令dir print(r.read()) 输出 以太网适配器 以太网: 连接特定的 ...

    os.popen() 功能强于os.system() , os.popen() 可以返回回显的内容,以文件描述符返回

    实例
    import os
    r = os.popen(“ipconfig”) # 执行操作系统命令dir
    print(r.read())

    输出
    以太网适配器 以太网:

    连接特定的 DNS 后缀 . . . . . . . : xxxxxxx
    本地链接 IPv6 地址. . . . . . . . : xxxxxxx
    IPv4 地址 . . . . . . . . . . . . : xxxxxxxxx
    子网掩码 . . . . . . . . . . . . : 255.255.254.0
    默认网关. . . . . . . . . . . . . : 192.168.4.1

    展开全文
  • pythonpopen函数

    千次阅读 2019-04-18 11:49:02
    最近了解了一下pythonpopen函数的使用,主要是用来执行linux命令 函数使用 使用之前需要导入import os模块 使用方式: os.popen(cmd) 返回值: 返回一个文件句柄 import os cmd="/sbin/partx /dev/sdb" result_...

    最近了解了一下python的popen函数的使用,主要是用来执行linux命令

    函数使用

    使用之前需要导入import os模块

    • 使用方式: os.popen(cmd)
    • 返回值: 返回一个文件句柄
    import os
    cmd="/sbin/partx /dev/sdb"
    result_list=os.popen(cmd)
    print result_list
    
    执行结果如下,返回了一个文件地址:
    <open file '/sbin/partx /dev/sdb', mode 'r' at 0x7f4b0f0fe810>
    
    获取执行内容

    如果想要获取popen执行命令的文件内容,那么可以使用如下几个函数

    • read() 读取整个文件,并将整个文件放入一个字符串变量中
    • readline() 每次读取一行,返回一个字符串对象并保留当前行的内存
    • readlines() 读取整个文件,并将整个文件按行解析成列表
    #/bin/cat test.txt
    #a
    #bb
    #c
    import os 
    cmd="/bin/cat test.txt "
    
    #read()函数读取整个文件放入一个字符串,该返回值类型为str字符串
    os.popen(cmd).read()
    
    #执行结果如下:
    'a\nbb\nc\n\n'
    
    #readline()函数 读取一行,该返回值类型为str字符串
    os.popen(cmd).readline()
    
    #执行结果如下
    'a\n'
    
    #readlines()函数 读取整个文件并按行解析列表,该返回值类型为list
    os.popen(cmd).readlines()
    
    #执行结果如下
    ['a\n', 'bb\n', 'c\n', '\n']
    
    注意

    在想要使用popen搭配几个read函数获取命令执行结果时请务必注意换行符\n,进行字符串处理时需对该\n符进行处理

    展开全文
  • 那么我们在python3中使用os.popen()出错该怎么办?本篇文章小编同样以错误的操作方法为大家进行讲解,一起找寻不对的地方吧。 在当前 desktop 目录下,有如下内容: desktop $ls client.py server.py 中文测试 ...
  • python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误去,还可以得到子进程的返回值。 subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os....

    从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: 
    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",shell=True,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',shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE)              
    >>> p2=subprocess.Popen('grep 0:0',shell=True,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'],stdin=p1.stdout,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',shell=True,stdout=subprocess.PIPE)                
    >>> p2=subprocess.Popen('grep 0:0',shell=True,stdin=p1.stdout,stdout=subprocess.PIPE)
    >>> p3=subprocess.Popen("cut -d ':' -f 7",shell=True,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, “/bin/mycmd”, “mycmd”, “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’, shell=True, stdin=PIPE)
    ...
    process.stdin.close()
    if process.wait() != 0:
        print “There were some errors”

    展开全文
  • python中的subprocess.Popen()使用

    万次阅读 多人点赞 2019-02-19 14:50:38
    python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误去,还可以得到子进程的返回值。 subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os....

    转载自:https://www.cnblogs.com/zhoug2020/p/5079407.html

    从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:
    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的行为。

    在*nix下,当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”,shell=True,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’,shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE)

    >>> p2=subprocess.Popen('grep 0:0',shell=True,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’],stdin=p1.stdout,stdout=PIPE)
    output = p2.communicate()[0]
    output
    cpu0: on acpi0\nacpi_throttle0: on cpu0\n

    >>> p1=subprocess.Popen('cat /etc/passwd',shell=True,stdout=subprocess.PIPE)                
    >>> p2=subprocess.Popen('grep 0:0',shell=True,stdin=p1.stdout,stdout=subprocess.PIPE)
    >>> p3=subprocess.Popen("cut -d ':' -f 7",shell=True,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, “/bin/mycmd”, “mycmd”, “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’, shell=True, stdin=PIPE)
    ...
    process.stdin.close()
    if process.wait() != 0:
        print “There were some errors”
    
    展开全文
  • python的subprocess.Popen()的简单用法

    万次阅读 2017-04-15 20:43:41
    英语原文: https://www.python.org/dev/peps/pep-0324/ This module defines one class called Popen: class Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, ...
  • [638]python os.popen() 方法

    万次阅读 多人点赞 2019-07-18 19:08:11
    os.popen() 方法用于从一个命令打开一个管道。 在Unix,Windows有效 语法 popen()方法语法格式如下: os.popen(command[, mode[, bufsize]]) 参数 command – 使用的命令。 mode – 模式权限可以是 ‘r’(默认) ...
  • subprocess允许你去创建一个新的进程让其执行另外的程序,并与它...subprocess模块基本的进程创建和管理由Popen类来处理.subprocess.popen是用来替代os.popen的. from subprocess import Popen, PIPE p = Pop...
  • 说明: 1. 用communicate方法进行交互,直接读取p.stdout有可能数据还没刷新,会读取不到 ...2. windows shell参数表明是否使用windows bat作为执行的环境,因此只有在执行windows系统命令如dir,copy...
  • python中可以使用os模快来执行shell语句,在使用popen方式得到自己的输入的shell语句返回值的时候,对多出一个空行,下面示范去除空行的方法 可以看到,下面使用popen方法得到的输出值会多处一个空行 >>>...
  • python中的subprocess.Popen()使用

    万次阅读 2018-10-10 09:44:17
    python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误去,还可以得到子进程的返回值。 subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os....
  • Python os.popen() 方法

    2019-10-04 15:41:55
    方法是os.popen(命令,权限,缓冲大小) 比如 a = 'mkdir def' b = os.popen(a,'r',1) print b 就是等同于使用命令去创建了一个def的文件夹,r是其权限,1是缓冲大小。第二个第三个参数都是可选的。 详细...
  • 转自:https://www.chenyudong.com/archives/python-subprocess-popen-block.html 目录 [hide] 1 错误的使用例子 2 解决了我的问题 3 看看Python文档信息 4 Linux管道限制,为什么会阻塞呢...
  • 需要首先了解shell=...(3)subprocess.terminate()使用杀死子进程的方法处理 https://www.it610.com/article/5165972.htm (4) python subprocess模块开启的子进程不随父进程一同结束问题解决 wait() ...
  • python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误去,还可以得到子进程的返回值。 subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os....
  • 个人笔记,大佬勿喷 关于介绍,网上一堆,可自行百度 这里记录一下popen()接受命令返回值及处理,我想要的值是docker的ID ...但是使用python调用的时候没法直接得到这个结果,所以想要获取这个数据 #导入o...
  • subprocess的目的就是启动一个新...可以使用Popen来创建进程,并与进程进行复杂的交互。它的构造函数如下: subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_...
  • python subprocess.Popen()详解

    万次阅读 2019-08-19 09:40:16
    转自:... ################################################################################################## python中的subprocess.Popen()使用python2.4版本开始,可以用subproces...
  • 测试环境centos7 ...简单说communicate() 和wait()的区别,使用 subprocess 模块的 Popen 调用外部程序,如果 stdout 或 stderr 参数是 pipe,并且程序输出超过操作系统的 pipe size时,如果使用...
  • os.system方法是os模块最基础的方法,其它的方法一般在该方法基础上封装完成。 二、os.system原理 system函数可以将字符串转化成命令在服务器上运行; 其原理是每一条system函数执行时,都会创建一个子进程在系统上...
  • Python os.popen()方法用法

    千次阅读 2016-05-20 20:03:54
    os模块下的popen()可以调用shell命令或者shell脚本,但是默认无法获得调用的命令的标准输出值,可以使用以下方式获得:  A=os.popen('ls')  print A.read() 又如 在Python命令下输入如下的命令: import ...
  • python脚本调用其他程序,或执行命令行指令,可以用os.system,os.popen,subprocess.popen这三种方式。这三种方式所适用的情况各不相同。区别在于调用程序后执行的操作,函数返回的是调用程序的输出,还是程序...
  • os.popen() 方法用于从一个命令打开一个管道。 在Unix,Windows有效 os.popen(command[, mode[, bufsize]]) command -- 使用的命令。 mode -- 模式权限可以是 'r'(默认) 或 'w'。 bufsize -- 指明了文件需要的...
  • python--subprocess.Popen()多进程

    千次阅读 2019-09-17 21:00:49
    subprocess.Popen()用法 Popen的属性 子进程的终止 首先来看一段代码: p = subprocess.Popen(['echo','helloworl.py'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) print(p.poll()) ...
  • 避免python Popen阻塞

    万次阅读 2015-09-01 16:38:26
    很多开发和运维人员喜欢用python做一些开发或是运维的工作。不可避免要调用系统命令。 调用系统命令的方式有两种,一种是os.system(CMD),一种是subprocess.Popen(CMD,stdout=what,stderr=what)。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,411
精华内容 4,964
关键字:

python中popen的用法

python 订阅