我们如何编写一个装饰器来捕获由某些 function 打印的所有标准 output？

Question

假设 function 包含很多打印语句。

我想将所有这些打印语句捕获到一个字符串中，或者将它们保存到文本文件中。

什么样的 function 装饰器可以为我们做这件事？

log_file = open("log.txt", "w")  

@copy_print_statements(log_file)
def printy_the_printer():  
    print("I print a lot")
   
# should print to both `sys.stdout` and `log_file`
printy_the_printer() 
printy_the_printer()
printy_the_printer()

以下是一次失败的尝试。 请随意忽略或偏离下面的代码。 真正的目标是为装饰器编写代码。 装饰器将旧的 function 替换为新的 function。旧函数向控制台打印很多内容，新函数将打印语句发送到其他地方。

import io
import sys
import functools 

class MergedStream:
    """
    """
    def __init__(self, lefty, righty):
        """
        `lefty` and `righty` should be file-streams.  
  
        Examples of valid streams might be the values returned by
        the following function calls:

            getattr(sys, 'stdout') 
            io.StringIO()
            open("foo.txt", "w")
        """
        self._lefty  = lefty
        self._righty = righty

    def write(self, *args, **kwargs):
        """
        """
        self._lefty.write(*args, **kwargs)
        self._righty.write(*args, **kwargs)

class CopyPrintStatements:
    def __init__(_callable, file):
        self._callable = _callable 
        self._file = _file  

    def __call__(*args, **kwargs):
        old_stdout = sys.stdout  
        sys.stdout = MergedStream(sys.stdout, self._file)
        try:
            return self._callable(*args, **kwargs) 
        finally:
            sys.stdout = old_stdout

    @classmethod
    def copy_print_statements(cls, file_stream):
        """
             This class method is intended to decorate callables
 
             An example usage is shown below:  

             @copy_print_statements(sys.stderr)
             def foobar():
                  print("this message is printed to both `stdout` and `stderr`")
        """ 
        decorator = cls.make_decorator(file_stream)
        return decorator  

    @classmethod
    def make_decorator(cls, old_callable, file):
        new_callable = cls(old_callable, file)
        new_callable = functools.wraps(old_callable) 
        return new_callable  

Answer 1

我想我已经做了你想要的，我基本上做了一个上下文管理器，它 tempoaraly 将 sys.stdout 重定向到它自己，然后它将消息重定向到旧的 sys.stdout 和文件。 然后我制作了一个 function 装饰器，它在运行函数时使用上下文管理器：

import sys


class Logger:

    def __init__(self, file):
        self.file = file

    def __enter__(self):
        self.terminal = sys.stdout
        self.f = open(self.file, "a")
        sys.stdout = self

    def __exit__(self, *args):
        sys.stdout = self.terminal
        self.f.close()

    def write(self, message):
        self.terminal.write(message)
        self.f.write(message)

    def flush(self):
        self.terminal.flush()
        self.f.flush()


def copy_print_statements(file):
    def copy_print(fn):
        def wraps(*args, **kwargs):
            with Logger(file):
                fn(*args, **kwargs)
        return wraps
    return copy_print


@copy_print_statements("output.txt")
def printy_the_printer(x):
    print(f"I print a lot {x}")


# should print to both `sys.stdout` and `log_file`
printy_the_printer(1)
printy_the_printer(2)
printy_the_printer(3)

我将上下文管理器 append 添加到文件（“a”）而不是覆盖（“w”）

Answer 2

我在这个问题上的 2 美分。 尽可能简单。

import sys

def copy_print_statements(file):
    def decorator(func):
        def wrapper(*args, **kwargs):
            stdout_backup = sys.stdout
            stderr_backup = sys.stderr
            with open(file, "a") as f:
                sys.stdout = f
                sys.stderr = f
                func(*args, **kwargs)

            sys.stdout = stdout_backup
            sys.stderr = stderr_backup
        return wrapper
    return decorator

@copy_print_statements("log.txt")
def printy_the_printer():  
    print("I print a lot to stdout")
    print("I print a lot to stderr", file=sys.stderr)

printy_the_printer()
printy_the_printer()
printy_the_printer()

可悲的是，我不知道有什么办法可以在退出时关闭文件，所以在每次调用时重新打开它。