Redirigiendo stdout a "nada" en python

Tengo un gran proyecto que consta de un número suficientemente grande de módulos, cada uno imprimiendo algo en la salida estándar. Ahora que el proyecto ha crecido en tamaño, hay grandes no. de printdeclaraciones que imprimen mucho en la salida estándar lo que ha hecho que el programa sea considerablemente más lento.

Entonces, ahora quiero decidir en tiempo de ejecución si imprimir o no algo en el stdout. No puedo hacer cambios en los módulos, ya que hay muchos. (Sé que puedo redirigir el stdout a un archivo, pero incluso esto es considerablemente lento).

Entonces, mi pregunta es ¿cómo redirijo el stdout a nada, es decir, cómo hago que la printdeclaración no haga nada?

# I want to do something like this.
sys.stdout = None         # this obviously will give an error as Nonetype object does not have any write method.

Actualmente, la única idea que tengo es crear una clase que tenga un método de escritura (que no hace nada) y redirigir el stdout a una instancia de esta clase.

class DontPrint(object):
    def write(*args): pass

dp = DontPrint()
sys.stdout = dp

¿Hay un mecanismo incorporado en Python para esto? ¿O hay algo mejor que esto?

Multiplataforma:

import os
import sys
f = open(os.devnull, 'w')
sys.stdout = f

En Windows:

f = open('nul', 'w')
sys.stdout = f

En Linux:

f = open('/dev/null', 'w')
sys.stdout = f

Una buena manera de hacer esto es crear un pequeño procesador de contexto en el que se envuelvan sus impresiones. Luego, simplemente use una withdeclaración para silenciar todos los resultados.

Python 2:

import os
import sys
from contextlib import contextmanager

@contextmanager
def silence_stdout():
    old_target = sys.stdout
    try:
        with open(os.devnull, "w") as new_target:
            sys.stdout = new_target
            yield new_target
    finally:
        sys.stdout = old_target

with silence_stdout():
    print("will not print")

print("this will print")

Python 3.4+:

Python 3.4 tiene un procesador de contexto como este incorporado, por lo que simplemente puede usar contextlib de esta manera:

import contextlib

with contextlib.redirect_stdout(None):
    print("will not print")

print("this will print")

La ejecución de este código solo imprime la segunda línea de salida, no la primera:

$ python test.py
this will print

Esto funciona multiplataforma (Windows + Linux + Mac OSX), y es más limpio que las otras respuestas en mi humilde opinión.

Si está en Python 3.4 o superior, hay una solución simple y segura que utiliza la biblioteca estándar:

import contextlib

with contextlib.redirect_stdout(None):
  print("This won't print!")

(al menos en mi sistema) parece que escribir en os.devnull es aproximadamente 5 veces más rápido que escribir en una clase DontPrint, es decir

#!/usr/bin/python
import os
import sys
import datetime

ITER = 10000000
def printlots(out, it, st="abcdefghijklmnopqrstuvwxyz1234567890"):
   temp = sys.stdout
   sys.stdout = out
   i = 0
   start_t = datetime.datetime.now()
   while i < it:
      print st
      i = i+1
   end_t = datetime.datetime.now()
   sys.stdout = temp
   print out, "\n   took", end_t - start_t, "for", it, "iterations"

class devnull():
   def write(*args):
      pass


printlots(open(os.devnull, 'wb'), ITER)
printlots(devnull(), ITER)

dio el siguiente resultado:

<open file '/dev/null', mode 'wb' at 0x7f2b747044b0> 
   took 0:00:02.074853 for 10000000 iterations
<__main__.devnull instance at 0x7f2b746bae18> 
   took 0:00:09.933056 for 10000000 iterations

Si está en un entorno Unix (Linux incluido), puede redirigir la salida a /dev/null:

python myprogram.py > /dev/null

Y para Windows:

python myprogram.py > nul

Qué tal esto:

from contextlib import ExitStack, redirect_stdout
import os

with ExitStack() as stack:
    if should_hide_output():
        null_stream = open(os.devnull, "w")
        stack.enter_context(null_stream)
        stack.enter_context(redirect_stdout(null_stream))
    noisy_function()

Esto usa las características en el módulo contextlib para ocultar la salida de cualquier comando que esté intentando ejecutar, dependiendo del resultado deshould_hide_output() , y luego restaura el comportamiento de salida después de que esa función se haya ejecutado.

Si desea ocultar la salida de error estándar, a continuación, importar redirect_stderrdesde contextliby añadir una línea que digastack.enter_context(redirect_stderr(null_stream)) .

El principal inconveniente es que esto solo funciona en Python 3.4 y versiones posteriores.

Su clase funcionará bien (con la excepción del write()nombre del método; debe llamarse en write()minúsculas). Solo asegúrese de guardar una copia de sys.stdouten otra variable.

Si está en un * NIX, puede hacerlo sys.stdout = open('/dev/null'), pero esto es menos portátil que rodar su propia clase.

Puedes burlarte de eso.

import mock

sys.stdout = mock.MagicMock()

¿Por qué no intentas esto?

sys.stdout.close()
sys.stderr.close()

sys.stdout = None

Está bien para el print()caso. Pero puede causar un error si llama a cualquier método de sys.stdout, por ejemplo sys.stdout.write().

Hay una nota en los documentos :

En algunas condiciones, stdin, stdout y stderr, así como los valores originales, stdin , stdout y stderr pueden ser Ninguno. Por lo general, es el caso de las aplicaciones GUI de Windows que no están conectadas a una consola y las aplicaciones Python comenzaron con pythonw.

Complemento a la respuesta de iFreilicht : funciona tanto para python 2 como para 3.

import sys

class NonWritable:
    def write(self, *args, **kwargs):
        pass

class StdoutIgnore:
    def __enter__(self):
        self.stdout_saved = sys.stdout
        sys.stdout = NonWritable()
        return self

    def __exit__(self, *args):
        sys.stdout = self.stdout_saved

with StdoutIgnore():
    print("This won't print!")