子进程 Popen 和 call 有什么区别(我该如何使用它们)?

What#39;s the difference between subprocess Popen and call (how can I use them)?(子进程 Popen 和 call 有什么区别(我该如何使用它们)?)

问题描述

我想从 Python 调用一个外部程序.我已经使用了 Popen() 和 call() 来做到这一点.

两者有什么区别?

我的具体目标是从 Python 运行以下命令.我不确定重定向是如何工作的.

./my_script.sh >输出

我阅读了 文档，上面写着 call() 是一个便利功能或快捷功能.我们是否会因为使用 call() 而不是 Popen() 而失去任何权力?

重定向有两种方式.两者都适用于 subprocess.Popen 或 subprocess.call.

1. 设置关键字参数 shell = True 或 executable =/path/to/the/shell 并指定命令，就像你在那里一样.

2. 由于您只是将输出重定向到文件，请设置关键字参数

   stdout = an_open_writeable_file_object

   对象指向输出文件的位置.

subprocess.Popen 更多一般比 subprocess.call.p>

Popen 不会阻塞，允许您在进程运行时与其进行交互，或继续在 Python 程序中进行其他操作.对 Popen 的调用返回一个 Popen 对象.

call 确实 阻塞.虽然它支持与 Popen 构造函数相同的所有参数，因此您仍然可以设置进程的输出、环境变量等，但您的脚本会等待程序完成，然后 call 返回一个代表进程退出状态的代码.

returncode = call(*args, **kwargs)

和调用基本一样

returncode = Popen(*args, **kwargs).wait()

call 只是一个便利功能.它在 CPython 中的实现位于 subprocess.py:

def call(*popenargs, timeout=None, **kwargs):"""带参数运行命令.等待命令完成或超时，然后返回 returncode 属性.参数与 Popen 构造函数的参数相同.例子:retcode = call(["ls", "-l"])"""使用 Popen(*popenargs, **kwargs) 作为 p:尝试:返回 p.wait(超时=超时)除了:p.kill()p.wait()增加

如您所见，它是对 Popen 的薄包装.

I want to call an external program from Python. I have used both Popen() and call() to do that.

What's the difference between the two?

My specific goal is to run the following command from Python. I am not sure how redirects work.

./my_script.sh > output

I read the documentation and it says that call() is a convenience function or a shortcut function. Do we lose any power by using call() instead of Popen()?

There are two ways to do the redirect. Both apply to either subprocess.Popen or subprocess.call.

1. Set the keyword argument shell = True or executable = /path/to/the/shell and specify the command just as you have it there.

2. Since you're just redirecting the output to a file, set the keyword argument

   stdout = an_open_writeable_file_object
   

   where the object points to the output file.

subprocess.Popen is more general than subprocess.call.

Popen doesn't block, allowing you to interact with the process while it's running, or continue with other things in your Python program. The call to Popen returns a Popen object.

call does block. While it supports all the same arguments as the Popen constructor, so you can still set the process' output, environmental variables, etc., your script waits for the program to complete, and call returns a code representing the process' exit status.

returncode = call(*args, **kwargs) 

is basically the same as calling

returncode = Popen(*args, **kwargs).wait()

call is just a convenience function. It's implementation in CPython is in subprocess.py:

def 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"])
    """
    with Popen(*popenargs, **kwargs) as p:
        try:
            return p.wait(timeout=timeout)
        except:
            p.kill()
            p.wait()
            raise

As you can see, it's a thin wrapper around Popen.

这篇关于子进程 Popen 和 call 有什么区别(我该如何使用它们)?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！