Stdout in Python auf "nichts" umleiten

Ich habe ein großes Projekt, das aus einer ausreichend großen Anzahl von Modulen besteht, von denen jedes etwas auf die Standardausgabe druckt. Jetzt, da das Projekt größer geworden ist, gibt es große Nr. von printAussagen, die viel auf den Standard drucken, was das Programm erheblich langsamer gemacht hat.

Daher möchte ich jetzt zur Laufzeit entscheiden, ob etwas auf dem Standard gedruckt werden soll oder nicht. Ich kann keine Änderungen an den Modulen vornehmen, da es viele davon gibt. (Ich weiß, dass ich den Standard in eine Datei umleiten kann, aber selbst das ist sehr langsam.)

Meine Frage ist also, wie ich den Standard zu nichts umleiten kann, dh wie kann ich die printAnweisung dazu bringen, nichts zu tun?

# 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.

Derzeit ist die einzige Idee, die ich habe, eine Klasse zu erstellen, die eine Schreibmethode hat (die nichts tut) und die Standardausgabe auf eine Instanz dieser Klasse umzuleiten.

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

dp = DontPrint()
sys.stdout = dp

Gibt es dafür einen eingebauten Mechanismus in Python? Oder gibt es etwas Besseres?

Plattformübergreifend:

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

Unter Windows:

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

Unter Linux:

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

Eine gute Möglichkeit, dies zu tun, besteht darin, einen kleinen Kontextprozessor zu erstellen, in den Sie Ihre Ausdrucke einwickeln. Sie verwenden dann nur is-in-a- withAnweisung, um alle Ausgaben stumm zu schalten.

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 verfügt über einen Kontextprozessor wie diesen, sodass Sie die Kontextlib einfach wie folgt verwenden können:

import contextlib

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

print("this will print")

Wenn Sie diesen Code ausführen, wird nur die zweite Ausgabezeile gedruckt, nicht die erste:

$ python test.py
this will print

Dies funktioniert plattformübergreifend (Windows + Linux + Mac OSX) und ist sauberer als die anderen Antworten imho.

Wenn Sie in Python 3.4 oder höher arbeiten, gibt es eine einfache und sichere Lösung mit der Standardbibliothek:

import contextlib

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

(zumindest auf meinem System) Es scheint, dass das Schreiben in os.devnull etwa fünfmal schneller ist als das Schreiben in eine DontPrint-Klasse, d. h

#!/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)

gab die folgende Ausgabe:

<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

Wenn Sie sich in einer Unix-Umgebung befinden (einschließlich Linux), können Sie die Ausgabe umleiten an /dev/null:

python myprogram.py > /dev/null

Und für Windows:

python myprogram.py > nul

Wie wäre es damit:

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()

Dadurch werden die Funktionen im contextlib- Modul verwendet, um die Ausgabe des Befehls, den Sie ausführen möchten, abhängig vom Ergebnis von auszublenden und das Ausgabeverhalten should_hide_output()wiederherzustellen, nachdem diese Funktion ausgeführt wurde.

Wenn Sie die Standardfehlerausgabe ausblenden möchten, importieren Sie redirect_stderraus contextlibund fügen Sie eine Zeile mit der Aufschrift hinzu stack.enter_context(redirect_stderr(null_stream)).

Der Hauptnachteil ist, dass dies nur in Python 3.4 und späteren Versionen funktioniert.

Ihre Klasse funktioniert einwandfrei (mit Ausnahme des write()Methodennamens - er muss in write()Kleinbuchstaben aufgerufen werden). Stellen Sie einfach sicher, dass Sie eine Kopie von sys.stdoutin einer anderen Variablen speichern .

Wenn Sie mit einem * NIX arbeiten, können Sie dies tun sys.stdout = open('/dev/null'), dies ist jedoch weniger portabel als das Rollen Ihrer eigenen Klasse.

Sie können es einfach verspotten.

import mock

sys.stdout = mock.MagicMock()

Warum versuchst du das nicht?

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

sys.stdout = None

Es ist OK für den print()Fall. Es kann jedoch einen Fehler verursachen, wenn Sie eine Methode von sys.stdout aufrufen, z sys.stdout.write().

In den Dokumenten ist ein Hinweis enthalten :

Unter bestimmten Bedingungen können stdin, stdout und stderr sowie die ursprünglichen Werte stdin , stdout und stderr None sein. Dies ist normalerweise bei Windows-GUI-Apps der Fall, die nicht mit einer Konsole verbunden sind, und bei Python-Apps, die mit Pythonw gestartet wurden.

Ergänzung zur Antwort von iFreilicht - es funktioniert sowohl für Python 2 als auch für Python 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!")