Перенаправление всех видов стандартного вывода в Python

from contextlib import redirect_stdout

f = io.StringIO()
with redirect_stdout(f):
    print('foobar')
    print(12)
print('Got stdout: "{0}"'.format(f.getvalue()))

from contextlib import contextmanager

@contextmanager
def stdout_redirector(stream):
    old_stdout = sys.stdout
    sys.stdout = stream
    try:
        yield
    finally:
        sys.stdout = old_stdout

f = io.StringIO()
with stdout_redirector(f):
    print('foobar')
    print(12)
print('Got stdout: "{0}"'.format(f.getvalue()))

import ctypes
libc = ctypes.CDLL(None)

f = io.StringIO()
with stdout_redirector(f):
    print('foobar')
    print(12)
    libc.puts(b'this comes from C')
    os.system('echo and this is from echo')
print('Got stdout: "{0}"'.format(f.getvalue()))

this comes from C
and this is from echo
Got stdout: "foobar
12
"

Python использует собственную абстракцию над базовым файловым дескриптором — файловым объектом . Более того, в Python 3 этот файловый объект является еще одной оберткой в ​​io.TextIOWrapper, потому что то, что мы передаем для печати, является строкой Unicode, но лежащие в основе системные вызовы write принимают двоичные данные, поэтому кодирование должно происходить в пути.

Важный вывод из этого: Python и расширение C, загруженное им (это также относится к коду C, вызываемому через ctypes), выполняются в одном и том же процессе и совместно используют базовый дескриптор файла для стандартного вывода. Однако, хотя Python имеет свою собственную высокоуровневую оболочку — sys.stdout, код C использует свой собственный объект FILE. Следовательно, простая замена sys.stdout не может, в принципе, повлиять на вывод кода C. Чтобы сделать замену глубже, мы должны коснуться чего-то общего для сред выполнения Python и C — дескриптора файла.

Перенаправление с дублированием файлового дескриптора

Без лишних слов, вот улучшенный stdout_redirector, который также перенаправляет вывод из кода C [4]:

from contextlib import contextmanager
import ctypes
import io
import os, sys
import tempfile

libc = ctypes.CDLL(None)
c_stdout = ctypes.c_void_p.in_dll(libc, 'stdout')

@contextmanager
def stdout_redirector(stream):
    # The original fd stdout points to. Usually 1 on POSIX systems.
    original_stdout_fd = sys.stdout.fileno()

    def _redirect_stdout(to_fd):
        """Redirect stdout to the given file descriptor."""
        # Flush the C-level buffer stdout
        libc.fflush(c_stdout)
        # Flush and close sys.stdout - also closes the file descriptor (fd)
        sys.stdout.close()
        # Make original_stdout_fd point to the same file as to_fd
        os.dup2(to_fd, original_stdout_fd)
        # Create a new sys.stdout that points to the redirected fd
        sys.stdout = io.TextIOWrapper(os.fdopen(original_stdout_fd, 'wb'))

    # Save a copy of the original stdout fd in saved_stdout_fd
    saved_stdout_fd = os.dup(original_stdout_fd)
    try:
        # Create a temporary file and redirect stdout to it
        tfile = tempfile.TemporaryFile(mode='w+b')
        _redirect_stdout(tfile.fileno())
        # Yield to caller, then redirect stdout back to the saved fd
        yield
        _redirect_stdout(saved_stdout_fd)
        # Copy contents of temporary file to the given stream
        tfile.flush()
        tfile.seek(0, io.SEEK_SET)
        stream.write(tfile.read())
    finally:
        tfile.close()
        os.close(saved_stdout_fd)

Здесь есть много деталей (например, управление временным файлом, в который перенаправляется вывод), которые могут скрыть ключевой подход: использование dup и dup2 для манипулирования дескрипторами файлов. Эти функции позволяют нам дублировать файловые дескрипторы и указывать любой дескриптор на любой файл. Я не буду тратить на них больше времени — читайте их документацию, если вам интересно. В объездном разделе должно быть достаточно информации, чтобы понять это.

Давайте попробуем это:

f = io.BytesIO()

with stdout_redirector(f):
    print('foobar')
    print(12)
    libc.puts(b'this comes from C')
    os.system('echo and this is from echo')
print('Got stdout: "{0}"'.format(f.getvalue().decode('utf-8')))

Дает нам:

Got stdout: "and this is from echo
this comes from C
foobar
12
"

Успех! Несколько вещей, на которые стоит обратить внимание:

1. Порядок вывода может не соответствовать ожидаемому. Это связано с буферизацией. Если важно сохранить порядок между различными видами вывода (например, между C и Python), требуется дальнейшая работа по отключению буферизации во всех соответствующих потоках.
2. Вы можете удивиться, почему вывод echo вообще был перенаправлен? Ответ заключается в том, что файловые дескрипторы наследуются подпроцессами. Так как мы настроили fd 1, чтобы он указывал на наш файл вместо стандартного вывода до разветвления echo, это то место, куда пошёл его вывод.
3. Мы используем BytesIO здесь. Это потому, что на самом низком уровне файловые дескрипторы являются двоичными. Может быть возможно выполнить декодирование при копировании из временного файла в данный поток, но это может скрыть проблемы. У Python есть понимание Unicode в памяти, но кто знает, какова правильная кодировка для данных, распечатанных из основного кода C? Вот почему этот конкретный подход перенаправления оставляет декодирование вызывающей стороне.
4. Вышеприведенное также делает этот код специфичным для Python 3. В этом нет никакой магии, и перенос на Python 2 тривиален, но некоторые сделанные здесь предположения не верны (например, sys.stdout является io.TextIOWrapper).

Перенаправление stdout дочернего процесса

Мы только что увидели, что подход дублирования файловых дескрипторов позволяет нам также получать выходные данные дочерних процессов. Но это не всегда самый удобный способ для достижения этой цели. В общем случае вы обычно используете модуль подпроцесса для запуска дочерних процессов и можете запускать несколько таких процессов либо в конвейере, либо по отдельности. Некоторые программы даже манипулируют несколькими подпроцессами, запущенными таким образом, в разных потоках. Более того, пока эти подпроцессы запущены, вы можете захотеть передать что-то на стандартный вывод, и вы не хотите, чтобы этот вывод был захвачен.

Таким образом, управление дескриптором файла stdout в общем случае может быть грязным; это также не нужно, потому что есть гораздо более простой способ.

Класс Popen швейцарского ножа модуля подпроцесса (который служит основой для большей части остальной части модуля) принимает параметр stdout, который мы можем использовать, чтобы попросить его получить доступ к stdout дочернего элемента:

import subprocess

echo_cmd = ['echo', 'this', 'comes', 'from', 'echo']
proc = subprocess.Popen(echo_cmd, stdout=subprocess.PIPE)
output = proc.communicate()[0]
print('Got stdout:', output)

Аргумент subprocess.PIPE может использоваться для установки фактических дочерних каналов процесса (а-ля оболочки), но в простейшем воплощении он захватывает выходные данные процесса.

Если вы одновременно запускаете только один дочерний процесс и заинтересованы в его выводе, есть еще более простой способ:

output = subprocess.check_output(echo_cmd)
print('Got stdout:', output)

check_output захватит и вернет вам стандартный вывод ребенка; это также вызовет исключение, если дочерний элемент существует с ненулевым кодом возврата.