Silenciar el stdout de una función en Python sin descartar sys.stdout y restaurar cada llamada de función

Question

¿Hay alguna manera en Python de silenciar stdout sin completar una llamada a función como la siguiente?

original Código roto:

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

Editar: Se ha corregido el código de Alex Martelli

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

De esa manera los trabajos, pero parece ser terriblemente ineficiente. Hay tiene para ser una mejor manera. ¿Algunas ideas?

Answer 1

Asignación de la variable stdout como que estás haciendo no tiene ningún efecto, suponiendo foo contiene declaraciones print - otro ejemplo de por qué nunca debe importar cosas de dentro un módulo (como se hace aquí), pero siempre un módulo como un todo (luego use nombres calificados). El copy es irrelevante, por cierto. La correcta equivalente de su fragmento es:

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

Ahora, cuando el código es correcto, es el momento para hacerlo más elegante o rápido. Por ejemplo, podría utilizar un objeto de tipo fichero en memoria en lugar del archivo 'basura':

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

para la elegancia, un contexto es mejor, por ejemplo:

import contextlib 
import io 
import sys 

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

una vez que haya definido este contexto, para cualquier bloque en el que no desea una salida estándar,

with nostdout(): 
    foo() 

Más optimización: sólo tiene que sustituir sys.stdout con un objeto que tiene un no-op write método. Por ejemplo:

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 

a usarse del mismo modo que la aplicación previa de nostdout. No creo que sea más limpio o más rápido que esto ;-).

Answer 2

¿Por qué crees que esto es ineficiente? ¿Hizo prueba? Por cierto, no funciona en absoluto porque está utilizando la declaración from ... import. Reemplazar sys.stdout está bien, pero no haga una copia y no use un archivo temporal. Abrir el dispositivo nulo en su lugar:

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

Una ligera modificación a Alex Martelli's answer ...

Esto está dedicado al caso en el que siempre desea suprimir stdout para una función en lugar de llamadas individuales a la función.

Si se llamó a foo() muchas veces, sería mejor/más fácil ajustar la función (decorarla). De esta forma puede cambiar la definición de foo una vez en lugar de incluir cada uso de la función en una declaración con.

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

Generalizando aún más, se puede obtener un buen decorador que puede capturar que la salida e incluso devolverlo:

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

no creo que llegue cualquier limpiador o más rápido que esto; -)

Bah! Creo que puedo hacer un poco mejor :-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 

que se hace a lo que quería en un principio, para suprimir la salida normalmente sino para mostrar la salida suprimida si se produce un error.

Answer 6

Para agregar a lo que otros ya han dicho, Python 3.4 introdujo el administrador de contexto contextlib.redirect_stdout. Acepta un objeto de archivo (-like) al que se debe redirigir la salida.

a redirigir a /dev/null se suprimir la salida:

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]: 

Esta solución se puede adaptar para ser utilizado como un decorador:

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 

Otra posible y ocasionalmente una solución útil que funcionará en Python 2 y 3 es pasar /dev/null como un argumento a f y redirigir la salida con el argumento de la función fileprint:

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

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

In [16]: 

Puede incluso hacer target completamente opcional:

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

Nota, que tendrá que

from __future__ import print_function 

en Python 2.

Answer 7

Acompañando muy tarde a esto con lo que pensé que era una solución más limpia a este problema.

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 

Uso:

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