Stille den stdout einer Funktion in Python ohne Dresch-sys.stdout und wiederherstellen von jedem Funktionsaufruf

Gibt es eine Möglichkeit in Python zu schweigen stdout ohne Umhüllung eine Funktion aufrufen, wie folgende?

Original Gebrochen-Code:

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

Edit: Korrigierte code von Alex Martelli

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

So funktioniert, scheint aber furchtbar ineffizient. Es hat der bessere Weg zu sein. Irgendwelche Ideen?

Ich würde sagen, Sie sollte es lassen, unkorrigiert, da Alex schon Tat es für Sie. Es würde mehr Sinn machen, ist das Lesen.
Cawas: ich werde meine erste unkorrigierte man wieder oben. Oder etwas ähnliches mit dem gleichen Fehler. Gute Entscheidung,
Verwandte: Vorübergehend Umleiten von stdout/stderr

InformationsquelleAutor Tim McJilton | 2010-05-13

python stdout

77

Zuweisung der stdout variable, wie Sie tun, hat keinerlei Auswirkungen, vorausgesetzt foo enthält print Aussagen-noch ein weiteres Beispiel, warum Sie sollten nie-import-Sachen aus innen ein Modul (wie du hier tust), aber immer auf ein Modul als ganzes (dann verwenden Sie qualifizierten Namen). Die copy ist irrelevant, die durch die Art und Weise. Das korrekte äquivalent zu Ihrem snippet:
```
import sys
save_stdout = sys.stdout
sys.stdout = open('trash', 'w')
foo()
sys.stdout = save_stdout
```
Jetzt, wenn der code korrekt ist, ist die Zeit, um zu machen es mehr elegant oder schnell. Zum Beispiel könnten Sie verwenden eine in-memory file-like-Objekt anstelle der Datei 'trash':
```
import sys
import io
save_stdout = sys.stdout
sys.stdout = io.BytesIO()
foo()
sys.stdout = save_stdout
```
für Eleganz, ein Kontext am besten ist, e.g:
```
import contextlib
import io
import sys

@contextlib.contextmanager
def nostdout():
    save_stdout = sys.stdout
    sys.stdout = io.BytesIO()
    yield
    sys.stdout = save_stdout
```
sobald Sie definiert haben, in diesem Zusammenhang, für jeden block, in dem Sie nicht wollen, eine stdout,
```
with nostdout():
    foo()
```
Mehr Optimierung: Sie brauchen nur zu ersetzen, sys.stdout mit einem Objekt, einem no-op write Methode. Zum Beispiel:
```
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
```
verwendet werden, die gleiche Weise wie die Vorherige Umsetzung von nostdout. Ich glaube nicht, dass es etwas sauberer oder schneller als diese;-).

Alex Martelli: das letztere scheint auch ziemlich. Ich habe nie verwendet die "mit" - Schlüsselwort vor. Ich werde das prüfen.
Es sollte angemerkt werden, dass, wenn Sie diese in einer Multithread-Umgebung, die Ihre substitution gelten für alle threads. Also, wenn Sie es verwenden in einer Multithread-webserver zum Beispiel, stdout erhalten trashed für alle threads (für die Dauer dieser Funktion rufen, die einige zufällige Teil der Zeit in anderen threads). Die Handhabung dieser Falle ist schwer, und würde threading.local (vor allem ich würde empfehlen, versuchen Sie zu vermeiden threads und stdout-Umleitung).
Ich habe downvoted weil dies macht code hängen — in einer Weise, dass es nicht unterbrochen werden kann, soweit ich das beurteilen kann—, wenn eine Ausnahme ausgelöst wird, im Kontext. Ich denke, @bitmous Antwort robuster und mehr elegant in sehr geschickter Weise (ohne die Notwendigkeit für die DummyFile Klasse).
Nachdem keine Antworten in diesem thread für mich gearbeitet, ich fand heraus, nach Art zu lang, dass eine C-level-Funktion zum generieren der Ausgabe, die der python-stdout nicht fangen direkt an. Die folgende Antwort hat geholfen: stackoverflow.com/a/17954769/2965879 insbesondere sys.stdout.close() im try-block sollte helfen.

InformationsquelleAutor Alex Martelli

Nur hinzufügen, was andere schon gesagt, Python 3.4 eingeführt, die contextlib.redirect_stdout Kontext-manager. Es akzeptiert eine Datei(-like) Objekt, auf das die Ausgabe umgelenkt.

Umleiten zu /dev/null unterdrückt die Ausgabe:

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

Diese Lösung angepasst werden kann verwendet werden als Dekorateur:

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

Andere mögliche und gelegentlich nützliche Lösung, die die Arbeit in beiden Python 2 und 3 ist das bestehen /dev/null als argument zu f und leiten Sie die Ausgabe über die file argument der print Funktion:

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

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

In [16]:

Können Sie auch target komplett optional:

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

Beachten Sie, müssen Sie

from __future__ import print_function

in Python 2.

Eleganteste Lösung für Python 3.4 und höher.

InformationsquelleAutor vaultah

15

Warum glaubst du, ist das ineffizient? Hast du test? Übrigens, es funktioniert nicht bei allen, weil Sie die from ... import - Anweisung.
Ersetzen sys.stdout ist gut, aber nicht machen Sie eine Kopie und verwenden Sie nicht eine temporäre Datei. Öffnen Sie das null-Gerät statt:
```
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
```
Der einzige Grund, warum ich denke, es ist ineffizient, weil es ist eine Datei schreiben. Datei schreibt, sind definitiv langsamer als nötig, wenn Sie tun es oft genug. Aber ja, ich Durcheinander mein ersten code, habe ich es behoben wird, basierend auf Alex ' ersten Kommentar
Es sollte open(os.devnull, 'w'). Im Allgemeinen os.devnull ist nützlich, wenn Sie echte Datei-Objekt. Aber print akzeptiert alles, was mit einem write() Methode.
+1 für das os.devnull.. überrascht die Gewinner Antwort propagierte die Verwendung von Dateien für die Ausgabe.
In der Tat sollte es open(os.devnull, 'w'). Ansonsten bekommen Sie:[Errno 9] Bad file descriptor

InformationsquelleAutor Philipp
12

Geläute in sehr spät, um dies mit dem, was ich dachte, war eine saubere Lösung für dieses problem.
```
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
```
Verwendung:
```
with Suppressor():
    DoMyFunction(*args,**kwargs)
```
Das ist nett, weil es behandelt Ausnahmen im Rahmen. Und die Verwendung von self als trivial writer ist sehr clever.
Dies ist sicherlich die beste Antwort. Tipp für alle die unsicher sind: wenn Sie wollen, dass Fehler geworfen werden, als normal, ersetzen Sie einfach # Do normal exception handling mit raise. Ich habe ein edit
Es sollte auch erwähnt werden, hier, dass, wenn Sie irgendwelche debugger Spuren legen in DoMyFunction() werden, werden Sie unsichtbar, das Programm einfach warten, auf die Spur, mit keine Aufforderung.
Was meinst du normale exception handling hier? Was genau wird diese zu fangen? Wenn ich dies nutzen wollen, für eine beliebige Anzahl von abstrakten Fällen, was sollte ich erwarten, zu schlagen if type is not None und was passiert, wenn ich das weglasse?

InformationsquelleAutor bitmous
5

Leicht ändern Alex Martelli Antwort...

Diese Adressen dem Fall, wo Sie immer wollen zu unterdrücken stdout für eine Funktion anstelle von einzelnen Aufrufe der Funktion.

Wenn foo() wurde viele Male aufgerufen würde es möglicherweise besser/einfacher zu wickeln, die Funktion (dekorieren). Auf diese Weise ändern Sie die definition von foo einmal statt encasing jeder Verwendung der Funktion in einer with-Anweisung.
```
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)
```
tgray: ich mag diesen Ansatz. Ist es wirklich schneller? Es kann sparen Sie ein bisschen Zeit über nicht tun, ich denke, zwei jmps und weniger zerren und ziehen aus dem Stapel. Und ich kann über-rufen Sie alle Funktionen, die ich nennen werde. Ihre anderen, verborgenen Vorteil, dass ich nicht sehen?
Tim: Es ist größte Vorteil ist, speichern Programmierer Zeit durch die Verringerung der Anzahl von änderungen, die Sie vornehmen müssen, um Ihren code zu deaktivieren stdout für eine Funktion. Ich habe keine performance-test gegen den contextmanager noch.
tgray: Das ist, was ich dachte. Es ist eine gute Idee, obwohl. Ich mag es. Ich denke, beide Ansätze sind gut, je nachdem, was Sie versuchen zu tun. DH, wenn Sie versuchen, zu ersetzen, eine call-in 100s der Ort, die Art und Weise ist besser, aber wenn Sie wollen, um es für eine Funktion übergeben in eine andere Funktion, ich denke, den anderen hat seine Vorteile. Ich mag es wenn
tgray: Random Hinweis. Nach timing der zwei Wege Verpackung eine Funktion, die nicht einfach 1+1, weil ich nur ein Auge an den Gemeinkosten. That being said, es war ziemlich viel waschen. Also, was jemals zwischen den beiden Stilen ist am einfachsten zu implementieren, ist das one to go für.

InformationsquelleAutor tgray

Durch Generalisierung noch mehr, können Sie eine schöne Dekorateur, die Erfassung der Ausgabe und auch die Rücksendung:

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

InformationsquelleAutor e-satis

Ich glaube nicht, dass es etwas sauberer oder schneller als diese;-)

Bah! Ich glaube, ich kann ein wenig besser 😀

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

Dem bekommt, was wollte ich ursprünglich, um die Ausgabe unterdrücken aber normalerweise zeigen die Unterdrückten ausgegeben, wenn ein Fehler ausgegeben wurde.

InformationsquelleAutor PatB

1

redirect_stdout() Hinzugefügt wurde contextlib da python 3.4

Python >= 3.4, dies sollte es tun:
```
import contextlib
import io

with contextlib.redirect_stdout(io.StringIO()):
    foo()
```
Ist dies ein Duplikat von @vaultah die Antwort oben?

InformationsquelleAutor Pin-Yen

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.