Supprimer l'impression stdout / stderr des fonctions Python

Avez-vous essayé de rediriger stderr trop? par exemple,

sys.stdout = StringIO();
sys.stderr = StringIO();
foo(bar);
sys.stdout = sys.__stdout__; # These are provided by python
sys.stderr = sys.__stderr__;

utiliser aussi StringIO peut utiliser de la mémoire supplémentaire. Vous pouvez utiliser un dispositif factice à la place (par exemple http://coreygoldberg.blogspot.com/2009/05/python-redirect-or-turn-off-stdout-and.html).

ma solution est similaire à la vôtre mais utilise

import contextlib


@contextlib.contextmanager
def stdchannel_redirected(stdchannel, dest_filename):
    """
    A context manager to temporarily redirect stdout or stderr

    e.g.:


    with stdchannel_redirected(sys.stderr, os.devnull):
        if compiler.has_function('clock_gettime', libraries=['rt']):
            libraries.append('rt')
    """

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

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

le contexte de la raison pour laquelle j'ai créé ceci est à ce billet de blog. Semblable à la vôtre, je pense.

je l'utilise comme ceci:setup.py:

with stdchannel_redirected(sys.stderr, os.devnull):
    if compiler.has_function('clock_gettime', libraries=['rt']):
        libraries.append('rt')

Pas vraiment demandé par l'OP, mais j'avais besoin de cacher et magasin la sortie, et a fait comme suit:

from io import StringIO
import sys

class Hider:
    def __init__(self, channels=('stdout',)):
        self._stomach = StringIO()
        self._orig = {ch : None for ch in channels}

    def __enter__(self):
        for ch in self._orig:
            self._orig[ch] = getattr(sys, ch)
            setattr(sys, ch, self)
        return self

    def write(self, string):
        self._stomach.write(string)

    def flush(self):
        pass

    def autopsy(self):
        return self._stomach.getvalue()

    def __exit__(self, *args):
        for ch in self._orig:
            setattr(sys, ch, self._orig[ch])

Utilisation:

with Hider() as h:
    spammy_function()
    result = h.autopsy()

(testé seulement avec Python 3)

EDIT: permet de sélectionner stderr, stdout ou les deux, comme dans Hider([stdout, stderr])

Python 3.6 version de travail, Testé avec million suppressions sans aucune erreur

import os
import sys

class suppress_stdout_stderr(object):
    def __enter__(self):
        self.outnull_file = open(os.devnull, 'w')
        self.errnull_file = open(os.devnull, 'w')

        self.old_stdout_fileno_undup    = sys.stdout.fileno()
        self.old_stderr_fileno_undup    = sys.stderr.fileno()

        self.old_stdout_fileno = os.dup ( sys.stdout.fileno() )
        self.old_stderr_fileno = os.dup ( sys.stderr.fileno() )

        self.old_stdout = sys.stdout
        self.old_stderr = sys.stderr

        os.dup2 ( self.outnull_file.fileno(), self.old_stdout_fileno_undup )
        os.dup2 ( self.errnull_file.fileno(), self.old_stderr_fileno_undup )

        sys.stdout = self.outnull_file        
        sys.stderr = self.errnull_file
        return self

    def __exit__(self, *_):        
        sys.stdout = self.old_stdout
        sys.stderr = self.old_stderr

        os.dup2 ( self.old_stdout_fileno, self.old_stdout_fileno_undup )
        os.dup2 ( self.old_stderr_fileno, self.old_stderr_fileno_undup )

        os.close ( self.old_stdout_fileno )
        os.close ( self.old_stderr_fileno )

        self.outnull_file.close()
        self.errnull_file.close()

à partir de python 3.5, nous pouvons le faire avec un travail minimal en utilisant des "built-ins" dans contextlib,redirect_stdout et redirect_stderr. Nous avons seulement besoin de combiner ces deux gestionnaires de contexte intégrés dans un gestionnaire de contexte personnalisé de la nôtre, ce qui peut être facilement fait en utilisant le joli motif de Martijn de réponse ici. Rediriger les sorties os.devnull doit être Sécuritaire et portable assez.

from contextlib import contextmanager,redirect_stderr,redirect_stdout
from os import devnull

@contextmanager
def suppress_stdout_stderr():
    """A context manager that redirects stdout and stderr to devnull"""
    with open(devnull, 'w') as fnull:
        with redirect_stderr(fnull) as err, redirect_stdout(fnull) as out:
            yield (err, out)

notez que supprimer stderr va encore vous donner le plein retraçage quand quelque chose se brise, ce qui est une bonne chose:

import sys

def rogue_function():
    print('spam to stdout')
    print('important warning', file=sys.stderr)
    1 + 'a'
    return 42

with suppress_stdout_stderr():
    rogue_function()

Lorsque vous exécutez le ci-dessus ne s'imprime

Traceback (most recent call last):
  File "tmp.py", line 20, in <module>
    rogue_function()
  File "foo.py", line 16, in rogue_function
    1 + 'a'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

pour le terminal. Les exceptions ne devraient jamais passer inaperçues.

si vous exécutez ce script sur une machine linux, vous devriez pouvoir:

$> ./runscript.py > output.txt