Mettre hors service la sortie standard d'une fonction en Python sans supprimer sys.stdout et restaurer chaque appel de fonction

Question

Est-il possible de désactiver la sortie stdout en Python sans encapsuler un appel de fonction comme suit?

Code original brisé:

from sys import stdout 
from copy import copy 
save_stdout = copy(stdout) 
stdout = open('trash','w') 
foo() 
stdout = save_stdout 

Edit: code corrigé de Alex Martelli

import sys 
save_stdout = sys.stdout 
sys.stdout = open('trash', 'w') 
foo() 
sys.stdout = save_stdout 

qui fonctionne de façon, mais semble être terriblement inefficace. Il a pour être un meilleur moyen. Des idées?

Answer 1

Attribution de la variable stdout que vous faites n'a aucun effet, dans l'hypothèse foo contient des déclarations print - encore un autre exemple des raisons pour lesquelles vous ne devriez jamais importer des choses de l'intérieur un module (comme vous faites ici), mais toujours un module dans son ensemble (utilisez alors des noms qualifiés). Le copy est hors de propos, d'ailleurs. L'équivalent correct de votre extrait est:

import sys 
save_stdout = sys.stdout 
sys.stdout = open('trash', 'w') 
foo() 
sys.stdout = save_stdout 

Maintenant, lorsque le code est correct, est le temps de le rendre plus élégant ou rapide. Par exemple, vous pouvez utiliser un lieu de fichier « » trash en mémoire objet de type fichier:

import sys 
import io 
save_stdout = sys.stdout 
sys.stdout = io.BytesIO() 
foo() 
sys.stdout = save_stdout 

pour l'élégance, un contexte est le meilleur, par exemple:

import contextlib 
import io 
import sys 

@contextlib.contextmanager 
def nostdout(): 
    save_stdout = sys.stdout 
    sys.stdout = io.BytesIO() 
    yield 
    sys.stdout = save_stdout 

une fois que vous avez défini ce contexte, pour un bloc dans lequel vous ne voulez pas stdout,

with nostdout(): 
    foo() 

optimisation plus: il vous suffit de remplacer sys.stdout avec un objet qui a une no-op write méthode. Par exemple:

import contextlib 
import sys 

class DummyFile(object): 
    def write(self, x): pass 

@contextlib.contextmanager 
def nostdout(): 
    save_stdout = sys.stdout 
    sys.stdout = DummyFile() 
    yield 
    sys.stdout = save_stdout 

à utiliser la même manière que la mise en œuvre précédente de nostdout. Je ne pense pas que ça devienne plus propre ou plus rapide que ça ;-).

Answer 2

Pourquoi pensez-vous que c'est inefficace? Avez-vous tester il? Soit dit en passant, cela ne fonctionne pas du tout parce que vous utilisez l'instruction from ... import. Remplacement sys.stdout est très bien, mais ne faites pas de copie et n'utilisez pas un fichier temporaire. Ouvrez le périphérique null à la place:

import sys 
import os 

def foo(): 
    print "abc" 

old_stdout = sys.stdout 
sys.stdout = open(os.devnull, "w") 
try: 
    foo() 
finally: 
    sys.stdout.close() 
    sys.stdout = old_stdout 

Answer 3

Une légère modification Alex Martelli's answer ...

Cela répond au cas où vous voulez toujours supprimer stdout pour une fonction au lieu des appels individuels à la fonction.

Si foo() a été appelée plusieurs fois, il pourrait être préférable/plus facile d'envelopper la fonction (la décorer). De cette façon, vous changez la définition de foo une fois au lieu d'encapsuler chaque utilisation de la fonction dans une instruction with.

import sys 
from somemodule import foo 

class DummyFile(object): 
    def write(self, x): pass 

def nostdout(func): 
    def wrapper(*args, **kwargs):   
     save_stdout = sys.stdout 
     sys.stdout = DummyFile() 
     func(*args, **kwargs) 
     sys.stdout = save_stdout 
    return wrapper 

foo = nostdout(foo) 

Answer 4

En généralisant encore plus, vous pouvez obtenir un beau décorateur qui peut capturer l'ouput et même retourner:

import sys 
import cStringIO 
from functools import wraps 

def mute(returns_output=False): 
    """ 
     Decorate a function that prints to stdout, intercepting the output. 
     If "returns_output" is True, the function will return a generator 
     yielding the printed lines instead of the return values. 

     The decorator litterally hijack sys.stdout during each function 
     execution for ALL THE THREADS, so be careful with what you apply it to 
     and in which context. 

     >>> def numbers(): 
      print "42" 
      print "1984" 
     ... 
     >>> numbers() 
     42 
     1984 
     >>> mute()(numbers)() 
     >>> list(mute(True)(numbers)()) 
     ['42', '1984'] 

    """ 

    def decorator(func): 

     @wraps(func) 
     def wrapper(*args, **kwargs): 

      saved_stdout = sys.stdout 
      sys.stdout = cStringIO.StringIO() 

      try: 
       out = func(*args, **kwargs) 
       if returns_output: 
        out = sys.stdout.getvalue().strip().split() 
      finally: 
       sys.stdout = saved_stdout 

      return out 

     return wrapper 

    return decorator 

Answer 5

Je ne pense pas qu'il ne fasse pas plus propre ou plus que cela; -)

Bah! Je pense que je peux faire un peu mieux :-D

import contextlib, cStringIO, sys 

@contextlib.contextmanager 
def nostdout(): 

    '''Prevent print to stdout, but if there was an error then catch it and 
    print the output before raising the error.''' 

    saved_stdout = sys.stdout 
    sys.stdout = cStringIO.StringIO() 
    try: 
     yield 
    except Exception: 
     saved_output = sys.stdout 
     sys.stdout = saved_stdout 
     print saved_output.getvalue() 
     raise 
    sys.stdout = saved_stdout 

Ce qui arrive à ce que je voulais à l'origine, pour supprimer la sortie normalement, mais pour montrer la sortie supprimée si une erreur a été levée.

Answer 6

Juste pour ajouter à ce que d'autres déjà dit, Python 3.4 a introduit le gestionnaire de contexte contextlib.redirect_stdout. Il accepte un objet de fichier (-comme) auquel la sortie doit être réorienté.

redirigeant vers /dev/null supprimera la sortie:

In [11]: def f(): print('noise') 

In [12]: import os, contextlib 

In [13]: with open(os.devnull, 'w') as devnull: 
    ....:  with contextlib.redirect_stdout(devnull): 
    ....:   f() 
    ....:   

In [14]: 

Cette solution peut être adapté pour être utilisé comme décorateur:

import os, contextlib 

def supress_stdout(func): 
    def wrapper(*a, **ka): 
     with open(os.devnull, 'w') as devnull: 
      with contextlib.redirect_stdout(devnull): 
       func(*a, **ka) 
    return wrapper 

@supress_stdout 
def f(): 
    print('noise') 

f() # nothing is printed 

Un autre possible et parfois utile solution qui fonctionne à la fois en Python 2 et 3 est de passer /dev/null comme argument pour f et rediriger la sortie en utilisant l'argument file de la fonction print:

In [14]: def f(target): print('noise', file=target) 

In [15]: with open(os.devnull, 'w') as devnull: 
    ....:  f(target=devnull) 
    ....:  

In [16]: 

Vous pouvez même faire target complètement en option:

def f(target=sys.stdout): 
    # Here goes the function definition 

Remarque, vous devrez

from __future__ import print_function 

en Python 2.

Answer 7

Chiming très tard à cela avec ce que je pensais était une solution plus propre à ce problème.

import sys, traceback 

class Suppressor(object): 

    def __enter__(self): 
     self.stdout = sys.stdout 
     sys.stdout = self 

    def __exit__(self, type, value, traceback): 
     sys.stdout = self.stdout 
     if type is not None: 
      # Do normal exception handling 

    def write(self, x): pass 

Utilisation:

with Suppressor(): 
    DoMyFunction(*args,**kwargs)