Temporarily Redirect stdout/stderr


Is it possible to temporarily redirect stdout/stderr in Python (i.e. for the duration of a method)?


The problem with the current solutions (which I at first remembered but then forgot) is that they don’t redirect; rather, they just replace the streams in their entirety. Hence, if a method has a local copy of one the variable for any reason (e.g. because the stream was passed as a parameter to something), it won’t work.

Any solutions?

Asked By: user541686



I am not sure what temporary redirection means. But, you can reassign streams like this and reset it back.

temp = sys.stdout
sys.stdout = sys.stderr
sys.stderr = temp

Also to write to sys.stderr within print stmts like this.

 print >> sys.stderr, "Error in atexit._run_exitfuncs:"

Regular print will to stdout.

Answered By: Senthil Kumaran

It’s possible with a decorator such as the following:

import sys

def redirect_stderr_stdout(stderr=sys.stderr, stdout=sys.stdout):
    def wrap(f):
        def newf(*args, **kwargs):
            old_stderr, old_stdout = sys.stderr, sys.stdout
            sys.stderr = stderr
            sys.stdout = stdout
                return f(*args, **kwargs)
                sys.stderr, sys.stdout = old_stderr, old_stdout

        return newf
    return wrap

Use as:

@redirect_stderr_stdout(some_logging_stream, the_console):
def fun(...):
    # whatever

or, if you don’t want to modify the source for fun, call it directly as

redirect_stderr_stdout(some_logging_stream, the_console)(fun)

But note that this is not thread-safe.

Answered By: Fred Foo

You can also put the redirection logic in a contextmanager.

import os
import sys

class RedirectStdStreams(object):
    def __init__(self, stdout=None, stderr=None):
        self._stdout = stdout or sys.stdout
        self._stderr = stderr or sys.stderr

    def __enter__(self):
        self.old_stdout, self.old_stderr = sys.stdout, sys.stderr
        self.old_stdout.flush(); self.old_stderr.flush()
        sys.stdout, sys.stderr = self._stdout, self._stderr

    def __exit__(self, exc_type, exc_value, traceback):
        self._stdout.flush(); self._stderr.flush()
        sys.stdout = self.old_stdout
        sys.stderr = self.old_stderr

if __name__ == '__main__':

    devnull = open(os.devnull, 'w')

    with RedirectStdStreams(stdout=devnull, stderr=devnull):
        print("You'll never see me")

    print("I'm back!")
Answered By: Rob Cowie

Here’s a context manager that I found useful. The nice things about this are that you can use it with the with statement and it also handles redirecting for child processes.

import contextlib

def stdchannel_redirected(stdchannel, dest_filename):
    A context manager to temporarily redirect stdout or stderr


    with stdchannel_redirected(sys.stderr, os.devnull):

        oldstdchannel = os.dup(stdchannel.fileno())
        dest_file = open(dest_filename, 'w')
        os.dup2(dest_file.fileno(), stdchannel.fileno())

        if oldstdchannel is not None:
            os.dup2(oldstdchannel, stdchannel.fileno())
        if dest_file is not None:

The context for why I created this is at this blog post.

Answered By: Marc Abramowitz

Raymond Hettinger shows us a better way[1]:

import sys
with open(filepath + filename, "w") as f: #replace filepath & filename
    with f as sys.stdout:
        print("print this to file")   #will be written to filename & -path

After the with block the sys.stdout will be reset

[1]: http://www.youtube.com/watch?v=OSGv2VnC0go&list=PLQZM27HgcgT-6D0w6arhnGdSHDcSmQ8r3

Answered By: Daniel

To solve the issue that some function might have cached sys.stdout stream as a local variable and therefore replacing the global sys.stdout won’t work inside that function, you could redirect at a file descriptor level (sys.stdout.fileno()) e.g.:

from __future__ import print_function
import os
import sys

def some_function_with_cached_sys_stdout(stdout=sys.stdout):
    print('cached stdout', file=stdout)

with stdout_redirected(to=os.devnull), merged_stderr_stdout():
    print('stdout goes to devnull')
    print('stderr also goes to stdout that goes to devnull', file=sys.stderr)
print('stdout is back')
print('stderr is back', file=sys.stderr)

stdout_redirected() redirects all output for sys.stdout.fileno() to a given filename, file object, or file descriptor (os.devnull in the example).

stdout_redirected() and merged_stderr_stdout() are defined here.

Answered By: jfs

We’ll use the PHP syntax of ob_start and ob_get_contents functions in python3, and redirect the input into a file.

The outputs are being stored in a file, any type of stream could be used as well.

from functools import partial
output_buffer = None
print_orig = print
def ob_start(fname="print.txt"):
    global print
    global output_buffer
    print = partial(print_orig, file=output_buffer)
    output_buffer = open(fname, 'w')
def ob_end():
    global output_buffer
    print = print_orig
def ob_get_contents(fname="print.txt"):
    return open(fname, 'r').read()


print ("Hi John")
print ("Hi John")
print (ob_get_contents().replace("Hi", "Bye"))

Would print

Hi John
Bye John

Answered By: Uri Goren

starting from python 3.4 there is the context manager contextlib.redirect_stdout:

from contextlib import redirect_stdout

with open('yourfile.txt', 'w') as f:
    with redirect_stdout(f):
        # do stuff...

to completely silence stdout this works:

from contextlib import redirect_stdout

with redirect_stdout(None):
    # do stuff...
Answered By: hiro protagonist

Look at contextlib.redirect_stdout(new_target) and contextlib.redirect_stderr(new_target). redirect_stderr is new in Python 3.5.

Answered By: Cristóbal Ganter
Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.