将stdout重定向到Python中的文件？

痛定思痛。 2022-11-27 07:03 152阅读 0赞

本文翻译自：[Redirect stdout to a file in Python?][Redirect stdout to a file in Python]

*How do I redirect stdout to an arbitrary file in Python?* **如何在Python中将stdout重定向到任意文件？**

*When a long-running Python script (eg, web application) is started from within the ssh session and backgounded, and the ssh session is closed, the application will raise IOError and fail the moment it tries to write to stdout.* **当从ssh会话中启动运行了长时间的Python脚本（例如，Web应用程序）并进行背景调整，并且ssh会话关闭时，该应用程序将在尝试写入stdout时引发IOError并失败。** *I needed to find a way to make the application and modules output to a file rather than stdout to prevent failure due to IOError.* **我需要找到一种方法来使应用程序和模块输出到文件而不是stdout，以防止由于IOError而导致失败。** *Currently, I employ nohup to redirect output to a file, and that gets the job done, but I was wondering if there was a way to do it without using nohup, out of curiosity.* **当前，我使用nohup将输出重定向到文件，并且可以完成工作，但是我想知道是否有一种出于好奇而无需使用nohup的方法。**

*I have already tried `sys.stdout = open('somefile', 'w')` , but this does not seem to prevent some external modules from still outputting to terminal (or maybe the `sys.stdout = ...` line did not fire at all).* **我已经尝试过`sys.stdout = open('somefile', 'w')` ，但这似乎并不能阻止某些外部模块仍然输出到终端（或者`sys.stdout = ...`行未在所有）。** *I know it should work from simpler scripts I've tested on, but I also didn't have time yet to test on a web application yet.* **我知道它应该可以通过我测试过的简单脚本工作，但是我还没有时间在Web应用程序上进行测试。**

--------------------

### \#1楼 ###

参考：[https://stackoom.com/question/jCmY/将stdout重定向到Python中的文件][https_stackoom.com_question_jCmY_stdout_Python]

--------------------

### \#2楼 ###

*The other answers didn't cover the case where you want forked processes to share your new stdout.* **其他答案没有涉及您希望分叉的进程共享新标准输出的情况。**

*To do that:* **要做到这一点：**

from os import open, close, dup, O_WRONLY
    
    old = dup(1)
    close(1)
    open("file", O_WRONLY) # should open on 1
    
    ..... do stuff and then restore
    
    close(1)
    dup(old) # should dup to 1
    close(old) # get rid of left overs

--------------------

### \#3楼 ###

*Quoted from [PEP 343 -- The "with" Statement][PEP 343 -- The _with_ Statement] (added import statement):* **引用自[PEP 343-“ with”语句][PEP 343 -- The _with_ Statement] （添加的导入语句）：**

*Redirect stdout temporarily:* **暂时重定向标准输出：**

import sys
    from contextlib import contextmanager
    @contextmanager
    def stdout_redirected(new_stdout):
        save_stdout = sys.stdout
        sys.stdout = new_stdout
        try:
            yield None
        finally:
            sys.stdout = save_stdout

*Used as follows:* **用法如下：**

with open(filename, "w") as f:
        with stdout_redirected(f):
            print "Hello world"

*This isn't thread-safe, of course, but neither is doing this same dance manually.* **当然，这不是线程安全的，但是也没有手动进行相同的舞蹈。** *In single-threaded programs (for example in scripts) it is a popular way of doing things.* **在单线程程序中（例如在脚本中），这是一种流行的处理方式。**

--------------------

### \#4楼 ###

*Programs written in other languages (eg C) have to do special magic (called double-forking) expressly to detach from the terminal (and to prevent zombie processes).* **用其他语言（例如C）编写的程序必须做特别的魔术（称为双叉）才能与终端分离（并防止僵尸进程）。** *So, I think the best solution is to emulate them.* **因此，我认为最好的解决方案是模仿它们。**

*A plus of re-executing your program is, you can choose redirections on the command-line, eg `/usr/bin/python mycoolscript.py 2>&1 1>/dev/null`* **重新执行程序的一个`/usr/bin/python mycoolscript.py 2>&1 1>/dev/null`是，您可以在命令行上选择重定向，例如`/usr/bin/python mycoolscript.py 2>&1 1>/dev/null`**

*See this post for more info: [What is the reason for performing a double fork when creating a daemon?][What is the reason for performing a double fork when creating a daemon]* **有关更多信息，请参见此帖子： [创建守护程序时执行双叉的原因是什么？][What is the reason for performing a double fork when creating a daemon]**

--------------------

### \#5楼 ###

*There is [`contextlib.redirect_stdout()` function][contextlib.redirect_stdout_ function] in Python 3.4:* **Python 3.4中有[`contextlib.redirect_stdout()`函数][contextlib.redirect_stdout_ function] ：**

from contextlib import redirect_stdout
    
    with open('help.txt', 'w') as f:
        with redirect_stdout(f):
            print('it now prints to `help.text`')

*It is similar to:* **它类似于：**

import sys
    from contextlib import contextmanager
    
    @contextmanager
    def redirect_stdout(new_target):
        old_target, sys.stdout = sys.stdout, new_target # replace sys.stdout
        try:
            yield new_target # run some code with the replaced stdout
        finally:
            sys.stdout = old_target # restore to the previous value

*that can be used on earlier Python versions.* **可以在早期的Python版本中使用。** *The latter version is not [reusable][] .* **后一版本不可[重用][reusable] 。** *It can be made one if desired.* **如果需要，可以将其制成一个。**

*It doesn't redirect the stdout at the file descriptors level eg:* **它不会在文件描述符级别重定向标准输出，例如：**

import os
    from contextlib import redirect_stdout
    
    stdout_fd = sys.stdout.fileno()
    with open('output.txt', 'w') as f, redirect_stdout(f):
        print('redirected to a file')
        os.write(stdout_fd, b'not redirected')
        os.system('echo this also is not redirected')

*`b'not redirected'` and `'echo this also is not redirected'` are not redirected to the `output.txt` file.* **`b'not redirected'`和`'echo this also is not redirected'`未重定向到`output.txt`文件。**

*To redirect at the file descriptor level, `os.dup2()` could be used:* **要在文件描述符级别重定向，可以使用`os.dup2()` ：**

import os
    import sys
    from contextlib import contextmanager
    
    def fileno(file_or_fd):
        fd = getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
        if not isinstance(fd, int):
            raise ValueError("Expected a file (`.fileno()`) or a file descriptor")
        return fd
    
    @contextmanager
    def stdout_redirected(to=os.devnull, stdout=None):
        if stdout is None:
           stdout = sys.stdout
    
        stdout_fd = fileno(stdout)
        # copy stdout_fd before it is overwritten
        #NOTE: `copied` is inheritable on Windows when duplicating a standard stream
        with os.fdopen(os.dup(stdout_fd), 'wb') as copied: 
            stdout.flush()  # flush library buffers that dup2 knows nothing about
            try:
                os.dup2(fileno(to), stdout_fd)  # $ exec >&to
            except ValueError:  # filename
                with open(to, 'wb') as to_file:
                    os.dup2(to_file.fileno(), stdout_fd)  # $ exec > to
            try:
                yield stdout # allow code to be run with the redirected stdout
            finally:
                # restore stdout to its previous value
                #NOTE: dup2 makes stdout_fd inheritable unconditionally
                stdout.flush()
                os.dup2(copied.fileno(), stdout_fd)  # $ exec >&copied

*The same example works now if `stdout_redirected()` is used instead of `redirect_stdout()` :* **如果使用`stdout_redirected()`而不是`redirect_stdout()`则现在可以使用相同的示例：**

import os
    import sys
    
    stdout_fd = sys.stdout.fileno()
    with open('output.txt', 'w') as f, stdout_redirected(f):
        print('redirected to a file')
        os.write(stdout_fd, b'it is redirected now\n')
        os.system('echo this is also redirected')
    print('this is goes back to stdout')

*The output that previously was printed on stdout now goes to `output.txt` as long as `stdout_redirected()` context manager is active.* **只要上下文管理器`stdout_redirected()`处于活动状态，以前打印在stdout上的输出现在将进入`output.txt` 。**

*Note: `stdout.flush()` does not flush C stdio buffers on Python 3 where I/O is implemented directly on `read()` / `write()` system calls.* **注意： `stdout.flush()`不会刷新Python 3上的C stdio缓冲区，在该Python 3上，I / O是直接在`read()` / `write()`系统调用上实现的。** *To flush all open C stdio output streams, you could call `libc.fflush(None)` explicitly if some C extension uses stdio-based I/O:* **要刷新所有打开的C stdio输出流，如果某些C扩展使用基于stdio的I / O，则可以显式调用`libc.fflush(None)` ：**

try:
        import ctypes
        from ctypes.util import find_library
    except ImportError:
        libc = None
    else:
        try:
            libc = ctypes.cdll.msvcrt # Windows
        except OSError:
            libc = ctypes.cdll.LoadLibrary(find_library('c'))
    
    def flush(stream):
        try:
            libc.fflush(None)
            stream.flush()
        except (AttributeError, ValueError, IOError):
            pass # unsupported

*You could use `stdout` parameter to redirect other streams, not only `sys.stdout` eg, to merge `sys.stderr` and `sys.stdout` :* **您可以使用`stdout`参数重定向其他流，而不仅仅是`sys.stdout`例如，合并`sys.stderr`和`sys.stdout` ：**

def merged_stderr_stdout():  # $ exec 2>&1
        return stdout_redirected(to=sys.stdout, stdout=sys.stderr)

*Example:* **例：**

from __future__ import print_function
    import sys
    
    with merged_stderr_stdout():
         print('this is printed on stdout')
         print('this is also printed on stdout', file=sys.stderr)

*Note: `stdout_redirected()` mixes buffered I/O ( `sys.stdout` usually) and unbuffered I/O (operations on file descriptors directly).* **注意： `stdout_redirected()`将缓冲的I / O（通常为`sys.stdout` ）和无缓冲的I / O（直接对文件描述符的操作）混合使用。** *Beware, there could be [buffering][] [issues][] .* **当心，可能存在[缓冲][buffering] [问题][issues] 。**

*To answer, your edit: you could use [`python-daemon`][python-daemon] to daemonize your script and use `logging` module (as [@erikb85 suggested][erikb85 suggested] ) instead of `print` statements and merely redirecting stdout for your long-running Python script that you run using `nohup` now.* **要回答，请进行编辑：您可以使用[`python-daemon`][python-daemon]并使用`logging`模块（如[@ erikb85建议][erikb85 suggested] ）代替`print`语句，而仅将stdout重定向为您现在使用`nohup`运行的长期运行的Python脚本。**

--------------------

### \#6楼 ###

*Based on this answer: [https://stackoverflow.com/a/5916874/1060344][https_stackoverflow.com_a_5916874_1060344] , here is another way I figured out which I use in one of my projects.* **基于以下答案： [https][https_stackoverflow.com_a_5916874_1060344] : [//stackoverflow.com/a/5916874/1060344][https_stackoverflow.com_a_5916874_1060344] ，这是我想出在我的一个项目中使用的另一种方法。** *For whatever you replace `sys.stderr` or `sys.stdout` with, you have to make sure that the replacement complies with `file` interface, especially if this is something you are doing because stderr/stdout are used in some other library that is not under your control.* **对于用`sys.stderr`或`sys.stdout`替换的任何内容，都必须确保替换符合`file`接口，尤其是在执行此操作时，因为stderr / stdout用于其他不受您控制的库中。** *That library may be using other methods of file object.* **该库可能正在使用文件对象的其他方法。**

*Check out this way where I still let everything go do stderr/stdout (or any file for that matter) and also send the message to a log file using Python's logging facility (but you can really do anything with this):* **看看这种方式，我仍然可以让所有事情继续进行stderr / stdout（或与此有关的任何文件），并使用Python的日志记录工具将消息发送到日志文件中（但您实际上可以执行任何操作）：**

class FileToLogInterface(file):
        '''
        Interface to make sure that everytime anything is written to stderr, it is
        also forwarded to a file.
        '''
    
        def __init__(self, *args, **kwargs):
            if 'cfg' not in kwargs:
                raise TypeError('argument cfg is required.')
            else:
                if not isinstance(kwargs['cfg'], config.Config):
                    raise TypeError(
                        'argument cfg should be a valid '
                        'PostSegmentation configuration object i.e. '
                        'postsegmentation.config.Config')
            self._cfg = kwargs['cfg']
            kwargs.pop('cfg')
    
            self._logger = logging.getlogger('access_log')
    
            super(FileToLogInterface, self).__init__(*args, **kwargs)
    
        def write(self, msg):
            super(FileToLogInterface, self).write(msg)
            self._logger.info(msg)

[Redirect stdout to a file in Python]: https://oldbug.net/q/jCmY/Redirect-stdout-to-a-file-in-Python
[https_stackoom.com_question_jCmY_stdout_Python]: https://stackoom.com/question/jCmY/%E5%B0%86stdout%E9%87%8D%E5%AE%9A%E5%90%91%E5%88%B0Python%E4%B8%AD%E7%9A%84%E6%96%87%E4%BB%B6
[PEP 343 -- The _with_ Statement]: http://www.python.org/dev/peps/pep-0343/
[What is the reason for performing a double fork when creating a daemon]: https://stackoverflow.com/questions/881388/what-is-the-reason-for-performing-a-double-fork-when-creating-a-daemon
[contextlib.redirect_stdout_ function]: http://docs.python.org/3.4/library/contextlib.html#contextlib.redirect_stdout
[reusable]: http://docs.python.org/3.4/library/contextlib.html#reusable-cms
[buffering]: https://stackoverflow.com/q/13932932/4279
[issues]: https://stackoverflow.com/q/22417010/4279
[python-daemon]: https://pypi.python.org/pypi/python-daemon/
[erikb85 suggested]: https://stackoverflow.com/questions/4675728/redirect-stdout-to-a-file-in-python/22434262#comment31368129_4675728
[https_stackoverflow.com_a_5916874_1060344]: https://stackoverflow.com/a/5916874/1060344