精华内容
下载资源
问答
  • python子进程异常结束Python subprocess module provides easy functions that allow us to spawn a new process and get their return codes. This module was introduced in Python v2.4. Python子流程模块提供了...

    python子进程异常结束

    Python subprocess module provides easy functions that allow us to spawn a new process and get their return codes. This module was introduced in Python v2.4.

    Python子流程模块提供了简单的功能,这些功能使我们可以生成新流程并获取其返回代码。 该模块是Python v2.4中引入的。

    In this lesson, we will study various functions available with the subprocess module and how we can put them to use.

    在本课程中,我们将研究subprocess模块可用的各种功能以及如何使用它们。

    Python子进程 (Python subprocess)

    Python subprocess module is a powerful tool and was introduced to replace various old modules/functions present in Python, like:

    Python子进程模块是一个功能强大的工具,被引入以替换Python中存在的各种旧模块/函数,例如:

    • os.system

      操作系统
    • os.spawn and related functions

      os.spawn和相关功能
    • os.popen and related functions

      os.popen和相关功能
    • popen2.*

      popen2。*
    • commands.*

      命令。*

    Please note that replacements were not as is and some modifications in the program were needed to move to the subprocess module usage. Let’s start our journey with the functions of this module.

    请注意,替换不是一样,并且需要对程序进行一些修改才能移至subprocess模块的用法。 让我们从该模块的功能开始我们的旅程。

    Python子进程call() (Python subprocess call())

    This function is used to run a command and get the return code of the command. Let’s quickly look at an example code snippet:

    此函数用于运行命令并获取命令的返回码。 让我们快速看一下示例代码片段:

    import subprocess
    print(subprocess.call(["pwd", "-P"]))

    The output will be:

    python subprocess call

    输出将是:

    Let’s understand what happened in above program:

    让我们了解以上程序发生了什么:

    • When an argument list is passed, the first argument is interpreted as the executable.

      传递参数列表时,第一个参数将解释为可执行文件。
    • The parameters from second param onwards are treated as the command line arguments to the program.

      从第二个参数开始的参数被视为程序的命令行参数。
    • We could also have done:

      我们也可以这样做:
    import subprocess
    print(subprocess.call('ls -l', shell=True))

    With shell being True, call() function treats this as command completely and run it as is. The output would have shown all files and directories in current folder.

    在shell为True的情况下, call()函数将其完全视为命令并按原样运行。 输出将显示当前文件夹中的所有文件和目录。

    Note that in POSIX based systems, a 0 return code is for success and 1 to 255 are for anything else. These exit codes are interpreted by machine scripts to evaluate the events of success and failures.

    请注意,在基于POSIX的系统中,返回码0表示成功,而1到255表示其他任何东西。 这些退出代码由机器脚本解释,以评估成功和失败的事件。

    Python子流程run() (Python subprocess run())

    This function works just like the call method and is used to run a command and get the return code of the command. Let’s quickly look at an example code snippet:

    该函数的工作方式与call方法类似,用于运行命令并获取命令的返回码。 让我们快速看一下示例代码片段:

    import subprocess
    print(subprocess.run(["pwd", "-P"]))

    The output will be:

    python subprocess run

    输出将是:

    Note that the run() function was added in Python 3.5. A clear difference between the run() and the call() function is that the call() function doesn’t supports the input and check parameters.

    请注意, run()函数是在Python 3.5中添加的。 run()call()函数之间的明显区别是call()函数不支持输入和检查参数。

    Python子流程check_call() (Python subprocess check_call())

    This function works like call() function but if there was an error in running the specified command, it raises a CalledProcessError exception. Let’s quickly look at an example code snippet:

    该函数的功能类似于call()函数,但是如果在运行指定命令时出错,则会引发CalledProcessError异常。 让我们快速看一下示例代码片段:

    import subprocess
    print(subprocess.check_call("false"))

    The output will be:

    Python subprocess example check call

    输出将是:

    We used the false command as it always return with an error return code.

    我们使用false命令,因为它总是返回错误返回码。

    Python子流程check_output() (Python subprocess check_output())

    When we use the call() function to run a command, the output is bound to the parent process and is unretrievable for the calling program. We can use the check_output() function to capture the output for later usage. Let’s quickly look at an example code snippet:

    当我们使用call()函数运行命令时,输出将绑定到父进程,并且对于调用程序是不可检索的。 我们可以使用check_output()函数捕获输出以供以后使用。 让我们快速看一下示例代码片段:

    import subprocess
    output = subprocess.check_output(['ls', '-1'])
    print("Output is {} bytes long.".format(len(output)))

    The output will be:

    Python subprocess check output

    输出将是:

    Python子进程communication() (Python subprocess communicate())

    We can use the communicate() function in this Python module to read input and the output forom the process itself. stdout is the process output and stderr is populated in case of an error. Let’s quickly look at an example code snippet:

    我们可以在此Python模块中使用communicate()函数来读取输入和输出,以形成流程本身。 stdout是进程输出,如果发生stderr则填充stderr 。 让我们快速看一下示例代码片段:

    import subprocess
    process = subprocess.Popen(
        ['cat', 'hello.py'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = process.communicate()
    print(stdout)

    The output will be:

    Python subprocess communicate

    输出将是:

    Note that we have a hello.py script which just says print("Hello").

    请注意,我们有一个hello.py脚本, hello.py print("Hello")

    Python子进程Popen (Python subprocess Popen)

    Python subprocess Popen is used to execute a child program in a new process. We can use it to run some shell commands. Let’s look at Popen usage through simple example program.

    Python子进程Popen用于在新进程中执行子程序。 我们可以使用它来运行一些shell命令。 让我们通过简单的示例程序来了解Popen的用法。

    import subprocess
    
    process = subprocess.Popen(['ls', '-ltr'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    
    print(process.communicate())
    
    process = subprocess.Popen(['echo', 'Pankaj'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None)
    
    print(process.communicate())
    
    process = subprocess.Popen(['ping', '-c 1', 'journaldev.com'], stdout=subprocess.PIPE)
    
    print(process.communicate())

    When executed, it produces following output.

    执行后,将产生以下输出。

    (b'total 8\n-rw-r--r--  1 pankaj  staff  396 Dec  9 22:00 subprocess_popen.py\n', b'')
    (b'Pankaj\n', b'')
    (b'PING journaldev.com (209.124.77.163): 56 data bytes\n64 bytes from 209.124.77.163: icmp_seq=0 ttl=53 time=474.153 ms\n\n--- journaldev.com ping statistics ---\n1 packets transmitted, 1 packets received, 0.0% packet loss\nround-trip min/avg/max/stddev = 474.153/474.153/474.153/0.000 ms\n', None)

    In this lesson, we learned about various functions provided by subprocess module in Python and saw how they work.

    在本课程中,我们学习了Python子进程模块提供的各种功能,并了解了它们如何工作。

    Reference: API Doc

    参考: API文档

    翻译自: https://www.journaldev.com/17416/python-subprocess

    python子进程异常结束

    展开全文
  • 主要介绍了Python子进程subpocess原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 此示例启动一个 python 子进程,读取 python 命令的标准输入,将它们通过管道传输到 python shell 并运行带有结果输出的回调方法。 状态在调用之间保留在外壳中。 // ------ // app.js // ------ var python = ...
  • Python子进程 (subprocess包) subprocess以及常用的封装函数 当我们运行python的时候,我们都是在创建并运行一个进程。正如我们在Linux进程基础中介绍的那样,一个进程可以fork一个子进程,并让这个子进程exec另外一...

    Python子进程 (subprocess包)

    subprocess以及常用的封装函数

    当我们运行python的时候,我们都是在创建并运行一个进程。正如我们在Linux进程基础中介绍的那样,一个进程可以fork一个子进程,并让这个子进程exec另外一个程序。在Python中,我们通过标准库中的subprocess包来fork一个子进程,并运行一个外部的程序(fork,exec见Linux进程基础)。

    subprocess包中定义有数个创建子进程的函数,这些函数分别以不同的方式创建子进程,所以我们可以根据需要来从中选取一个使用。另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具,从而在进程间使用文本通信。
    使用subprocess包中的函数创建子进程的时候,要注意:
    1) 在创建子进程之后,父进程是否暂停,并等待子进程运行。
    2) 函数返回什么
    3) 当returncode不为0时,父进程如何处理。
    subprocess.call()
    父进程等待子进程完成
    返回退出信息(returncode,相当于exit code,见Linux进程基础)
    subprocess.check_call()
    父进程等待子进程完成
    返回0
    检查退出信息,如果returncode不为0,则举出错误subprocess.CalledProcessError,该对象包含有returncode属性,可用try...except...来检查(见Python错误处理)。
    subprocess.check_output()
    父进程等待子进程完成
    返回子进程向标准输出的输出结果
    检查退出信息,如果returncode不为0,则举出错误subprocess.CalledProcessError,该对象包含有returncode属性和output属性,output属性为标准输出的输出结果,可用try...except...来检查。
    这三个函数的使用方法相类似,我们以subprocess.call()来说明:
    import subprocess
    rc = subprocess.call(["ls","-l"])
    我们将程序名(ls)和所带的参数(-l)一起放在一个表中传递给subprocess.call()
    可以通过一个shell来解释一整个字符串:
    import subprocess
    out = subprocess.call("ls -l", shell=True)
    out = subprocess.call("cd ..", shell=True)
    我们使用了shell=True这个参数。这个时候,我们使用一整个字符串,而不是一个表来运行子进程。Python将先运行一个shell,再用这个shell来解释这整个字符串。
    shell命令中有一些是shell的内建命令,这些命令必须通过shell运行,$cd。shell=True允许我们运行这样一些命令。
    Popen()
    实际上,我们上面的三个函数都是基于Popen()的封装(wrapper)。这些封装的目的在于让我们容易使用子进程。当我们想要更个性化我们的需求的时候,就要转向Popen类,该类生成的对象用来代表子进程。
    与上面的封装不同,Popen对象创建后,主程序不会自动等待子进程完成。我们必须调用对象的wait()方法,父进程才会等待 (也就是阻塞block):
    import subprocess
    child = subprocess.Popen(["ping","-c","5","www.google.com"])
    print("parent process")
    从运行结果中看到,父进程在开启子进程之后并没有等待child的完成,而是直接运行print。
    对比等待的情况:
    import subprocess
    child = subprocess.Popen(["ping","-c","5","www.google.com"])
    child.wait()
    print("parent process")
    此外,你还可以在父进程中对子进程进行其它操作,比如我们上面例子中的child对象:
    child.poll()           # 检查子进程状态
    child.kill()           # 终止子进程
    child.send_signal()    # 向子进程发送信号
    child.terminate()      # 终止子进程
    子进程的PID存储在child.pid
    子进程的文本流控制
    (沿用child子进程) 子进程的标准输入,标准输出和标准错误也可以通过如下属性表示:
    child.stdin
    child.stdout
    child.stderr
    我们可以在Popen()建立子进程的时候改变标准输入、标准输出和标准错误,并可以利用subprocess.PIPE将多个子进程的输入和输出连接在一起,构成管道(pipe):
    import subprocess
    child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
    child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)
    out = child2.communicate()
    print(out)
    subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区,随后child2的stdin从该PIPE中将文本读取走。child2的输出文本也被存放在PIPE中,直到communicate()方法从PIPE中读取出PIPE中的文本。
    要注意的是,communicate()是Popen对象的一个方法,该方法会阻塞父进程,直到子进程完成。
    我们还可以利用communicate()方法来使用PIPE给子进程输入:
    import subprocess
    child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
    child.communicate("vamei")
    我们启动子进程之后,cat会等待输入,直到我们用communicate()输入"vamei"。
    通过使用subprocess包,我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用,你可以从Python中直接调用该应用(而不是完全依赖Python),并将应用的结果输出给Python,并让Python继续处理。shell的功能(比如利用文本流连接各个应用),就可以在Python中实现。数据分析师培训
    总结
    subprocess.call, subprocess.check_call(), subprocess.check_output()
    subprocess.Popen(), subprocess.PIPE
    Popen.wait(), Popen.communicate()

    转载于:https://www.cnblogs.com/amengduo/p/9587112.html

    展开全文
  • python 子进程subprocess

    2018-09-18 08:02:00
    文章目录1.subprocess模块常用函数2.字节流与字符串之间的...此外也有其它运行子进程的方式,如popen、popen2、os.exex*等,在此只说subprocess。 1.subprocess模块常用函数 subprocess可以生成子进程,可以连接管...


    python与系统交互,可以用命令行工具,但是命令行中的越写会越复杂,且多子进程的管理太麻烦,可以用subprocess模块来处理。此外也有其它运行子进程的方式,如popen、popen2、os.exex*等,在此只说subprocess。

    1.subprocess模块常用函数

    subprocess可以生成子进程,可以连接管道,将标准输入输出串在一起,方便使用。

    • run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None, env=None)

    可以用来运行命令行,返回子进程实例。3.5版本开始加入,旧版本用call().
    返回值是一个subprocess.CompletedProcess。

    args,用一个列表,输入参数

    window系统,要加shell参数,才能运行命令行。输出时编码格式要正确。

    c = subprocess.run(['dir'], shell = True, stdout=subprocess.PIPE)
    out = str(c.stdout, encoding='gb2312' )
    print(out)
    
     驱动器 D 中的卷没有标签。
     卷的序列号是 A66A-075E
    
     D:\MyDocuments\python_works\untitled 的目录
    
    2018/09/14  22:05    <DIR>          .
    2018/09/14  22:05    <DIR>          ..
    2018/09/14  22:03    <DIR>          .idea
    2018/09/01  21:54             1,143 propertyBindTest.py
    2018/08/31  22:24             1,200 serialize.py
    2018/09/14  22:05               197 subprocessTest.py
               3 个文件          2,540 字节
               3 个目录 37,198,790,656 可用字节
    
    • Popen 构造器

    Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, 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)

    为了方便使用,可以用Popen 构造器来启动进程。

    with subprocess.Popen(["dir"], shell = True, stdout=subprocess.PIPE) as proc:
            print(proc.stdout.read().decode('gb2312' ))
    
    • Popen实例函数

    1.Popen.poll(),检查子进程是否终止。返回None,表示进程未终止。

    2.Popen.wait(timeout=None)

    3.Popen.communicate(input=None, timeout=None),返回元组
    (stdout_data, stderr_data).

    用于与子进程交互,input用来输入数据,如果流用文本模式打开,则输入字符串,否则输入数据为字节流。
    

    4.Popen.send_signal(signal),发送信号给子进程

    5.Popen.terminate()、Popen.kill(),终止进程

    proc = subprocess.Popen(...)
    try:
        outs, errs = proc.communicate(timeout=15)
    except TimeoutExpired:
        proc.kill()
        outs, errs = proc.communicate()
    
    • 经典命令行调用方式

    不考虑安全与异常

    1.subprocess.getstatusoutput(cmd),返回 (exitcode, output).

    >>> subprocess.getstatusoutput('ls /bin/ls')
    (0, '/bin/ls')
    >>> subprocess.getstatusoutput('cat /bin/junk')
    (1, 'cat: /bin/junk: No such file or directory')
    

    2.subprocess.getoutput(cmd),返回(stdout and stderr)

    >>> subprocess.getoutput('ls /bin/ls')
    '/bin/ls'
    

    2.字节流与字符串之间的转换

     # bytes object
      b = b"example"
    
      # str object
      s = "example"
    	
      # str to bytes
      byte_code = s.encode("utf-8")
    
      # bytes to str
      str_code = b.decode('gb2312')
    

    参考:

    1. my coding.net
    2. Python之系统交互(subprocess)
    展开全文
  • Python 提供了multiprocessing模块来开启子进程,并在子进程中执行我们定制的任务。 multiprocessing模块的功能众多,支持子进程,通信,共享数据,执行不同形式的同步,有Process、Queue、Pipe、Lock等组件。 ...

    感谢作者的总结:https://blog.csdn.net/miaoqinian/article/details/80062740

    Python 提供了multiprocessing模块来开启子进程,并在子进程中执行我们定制的任务。

    multiprocessing模块的功能众多,支持子进程,通信,共享数据,执行不同形式的同步,有Process、Queue、Pipe、Lock等组件。

    创建进程的类Process:

    实例化Process类可得到一个对象,来启一个进程。

    我们来看一下它的参数:

    group参数未使用,值始终为None。

    target表示调用的对象,就是子进程要执行的任务

    name可以为子进程命名

    args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号,如:args=(‘monicx’)

    kwargs指定的为传给target函数的关键字参数,是一个字典,如kwargs={'name':'monicx', 'age':18}

    Process类的方法有:

    start():启动进程,并调用该子进程中的p.run()

    run():进程启动进运行的方法,就是它去调用target指定的函数,我们自定义类的类中一定要实现该方法。

    terminate():强制终止进程。不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用此方法需要小心:如果此进程还保存了一个锁那么也将不会释放这个锁,进而导致死锁。

    is_alive():判断进程是否是“活着”的状态。

    join(timeout):让主线程等待某一子进程结束,才继续执行主进程。timeout是可选的超时时间。超过一个时间主进程就不等待了。

    创建子进程的两种方式:

    方式一:
     

    from multiprocessing import Process
    import time
     
    def test(name):
        print("%s is running "% name)
        time.sleep(2)
        print('%s is done'%name)
     
    if __name__ == '__main__':
        #在windows系统之上,开启子进程的操作一定要放在这下面
        # Process(target=test,kwargs={'name':'monicx'})
        p=Process(target=test,args=('monicx',))
        p.start()#向操作系统发送一个请求,操作系统会申请内存空间给,然后把父进程的数据拷贝给子进程,作为子进程的初始数据。
        print('=======主')

    运行效果为:

    方式二:

    from multiprocessing import Process
    import time
     
    class MyProcess(Process):
        def __init__(self,name):
            super(MyProcess,self).__init__()
            self.name=name
     
        def run(self):
            print("%s is running " %self.name)
            time.sleep(2)
            print('%s is done'%self.name)
     
    if __name__ == '__main__':
        p=MyProcess('monicx')
        p.start()#就是调用run()方法。
        print('====主')

    运行结果:

    验证,进程之间的内存空间是相互隔离的。

    from multiprocessing import Process
    import time
     
    x=1000
     
    def test():
        global x
        x=0
        print('子进程结束',x)
     
    if __name__ == '__main__':
        p=Process(target=test)
        p.start()
        print('=======主')
        time.sleep(3)
        print(x)

     

    运行结果:

    父进程如何等待子进程结束——join()

    from multiprocessing import Process
    import time,random
     
    def test(n):
        print('%s is running'%n)
        time.sleep(random.randint(1,4))
        print('%s子进程结束了'%n)
     
    if __name__ == '__main__':
        start_time=time.time()
        p_l=[]
        for i in range(5):
            p=Process(target=test,args=(i,))
            p_l.append(p)
            p.start()
        for p in p_l:
            p.join()
        # p.join()#让父进程在原地等
        print('主====运行时间:%s'%(time.time()-start_time))

    运行结果:

     

     

     

    展开全文
  • python 子进程无法调用

    2019-07-23 09:57:08
    import os from multiprocessing import Pool """ 我的出的结论是不能在init中初始化 self.p_pool = Pool(3) """ class SomeClass(object): def some_method(self): ... p_pool.apply_async...python3 亲测有效!
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • python 子进程超时退出

    2014-09-05 09:18:00
    一:循环 忙等 子进程结束 import subprocess import os import time tt = '555' cmd = "python /home/100003/python/mypython/sub2.py "+" 333"+" 444 "+tt print time.time() sub2 = subprocess....
  • popen pythonPython provides a lot of functionalities with different modules and libraries. When we need to open a new process inside a Python application we can use subprocesslibrary and related func....
  • python子进程嘛,就是利用python打开一个子进程(当然像是一句废话),但是可能和我们理解的不太一样。 一:如何理解? 我们可能的理解:多开一个进程运行某个python函数(如果只想实现这个功能,请使用...
  • @数据挖掘 在一段python代码片段里调用另一python程序(或者代码片段) 概念说明
  • 转载原文出处:http://mushanblog.com/blog/python-subprocess-module-primer 自己又结合源码和说明文档 有时候我们想做python脚本里...subprocess模块用来建立子进程,并且可以控制子进程的stdout,stdout,stde
  • 属性1.Popen.poll():用于检查子进程是否已经结束。设置并返回returncode属性。2.Popen.wait():等待子进程结束。设置并返回returncode属性。3.Popen.communicate(input=None):与子进程进行交互。向stdin发送数据,...
  • python子进程不支持input函数

    千次阅读 2018-12-19 10:04:40
    写多进程程序的时候,在子进程调用的函数内部调用了input函数,提示EOFError: EOF when reading a line,具体如下错误: 抽象出来的代码如下: #encoding=utf-8 from multiprocessing import Pool,Process def ...
  • python 子进程名定义

    2015-09-17 12:59:00
    使用模块: 安装:setproctitle #!/bin/envpython2.7 #coding:utf-8 fromsetproctitleimportsetproctitle frommultiprocessingimportPoo...
  • 在Windows下使用python的subprocess.Popen创建子进程时,子进程如果是控制台程序(子系统为console的程序),便会继承父进程的控制台窗口 当子进程在运行时,如果在控制台使用Ctrl+C向父进程发送信号,这时会让子进程...
  • Python子进程 subprocess模块

    千次阅读 2013-08-19 17:59:15
    这里的内容以Linux进程基础和Linux文本流为基础。subprocess包主要功能是执行外部的命令和程序。比如说,我需要使用wget下载文件。...当我们运行python的时候,我们都是在创建并运行一个进程。正如我们在Linux进程
  • subprocess.run(cmd, capture_output=True, text=True) print('subprocess.run\t',res.stdout) 总结 我们这里推荐大家使用 subprocess.run() 模块,这个可以检测 子进程 的执行状态,且可以获得返回值,及错误信息。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,139
精华内容 1,655
关键字:

python子进程

python 订阅