Comment faire pour capturer la sortie standard sortie d'un Python appel de fonction?

Je suis en utilisant une bibliothèque Python qui fait quelque chose à un objet

do_something(my_object)

et la change. En faisant de la sorte, il affiche des statistiques sur la sortie standard, et j'aimerais avoir de l'emprise sur cette information. La bonne solution serait de changer do_something() pour retourner des informations pertinentes,

out = do_something(my_object)

mais il faudra un certain temps avant que les devs de do_something() à cette question. Comme solution, j'ai pensé à l'analyse ce que do_something() écrit sur la sortie standard stdout.

Comment capturer la sortie standard (stdout) de sortie entre deux points dans le code, par exemple,

start_capturing()
do_something(my_object)
out = end_capturing()

double possible de la capture d'dis.dis résultats
Ma réponse dans la question s'applique ici aussi.
J'ai essayé de le faire une fois et la meilleure réponse que j'ai trouvé: stackoverflow.com/a/3113913/1330293
lié réponse est une solution élégante
Voir ce répondre.

InformationsquelleAutor Nico Schlömer | 2013-05-15

144

Essayer ce gestionnaire de contexte:
```
# import StringIO for Python 2 or 3
try:
    from StringIO import StringIO
except ImportError:
    from io import StringIO

import sys

class Capturing(list):
    def __enter__(self):
        self._stdout = sys.stdout
        sys.stdout = self._stringio = StringIO()
        return self
    def __exit__(self, *args):
        self.extend(self._stringio.getvalue().splitlines())
        del self._stringio    # free up some memory
        sys.stdout = self._stdout
```
Utilisation:
```
with Capturing() as output:
    do_something(my_object)
```
output est maintenant une liste contenant les lignes imprimées par l'appel de la fonction.

Utilisation avancée:

Ce qui peut ne pas être évident, c'est que cela peut être fait plus d'une fois et les résultats concaténés:
```
with Capturing() as output:
    print 'hello world'

print 'displays on screen'

with Capturing(output) as output:  # note the constructor argument
    print 'hello world2'

print 'done'
print 'output:', output
```
De sortie:
```
displays on screen                     
done                                   
output: ['hello world', 'hello world2']
```
Mise à jour: Ils ont ajouté redirect_stdout() à contextlib en Python 3.4 (avec redirect_stderr()). Vous pouvez utiliser io.StringIO avec que, pour arriver à un résultat similaire (bien que Capturing être une liste ainsi qu'un gestionnaire de contexte est sans doute plus pratique).
- Merci! Et merci pour l'ajout de la section avancé... j'ai d'abord utilisé une tranche d'affectation pour coller le texte capturé dans la liste, puis j'ai bonked moi-même dans la tête et utilisé .extend() au lieu de sorte qu'il pourrait être utilisé concatenatively, tout comme vous l'avez remarqué. 🙂
- Vous êtes les bienvenus -- heureux que vous n'avez pas l'esprit de mon montage.
- P. S. Si elle va être utilisée à plusieurs reprises, je suggère l'ajout d'un self._stringio.truncate(0) après la self.extend() appel dans le __exit__() méthode pour libérer de la mémoire occupée par le _stringio membre.
- Une nouvelle StringIO instance sera créée à chaque fois que le gestionnaire de contexte est utilisé de toute façon, et le vieux va aller loin pour le moment, mais vous pouvez définir self._stringio à None (ou del) dans __exit__() si l'intérimaire de l'utilisation de la mémoire est un problème.
- Oh, oui, c'est vrai...mon erreur. Le contenu des interférences avec quelque chose d'expérimental je faisais pour la première instance avant la seconde a été créé, qui (mis)m'a conduit à penser que les résultats pourraient s'accumuler. Le fait que les deux ont le même nom composé de l'illusion. 😉
- C'est une très bonne solution! Fonctionne comme un charme, même si dans mon cas, j'ai dû rediriger stderr ainsi, comme je l'ai voulu capturer argsparse message d'erreur.
- Une grande réponse, merci. Pour Python 3, utilisation from io import StringIO au lieu de la première ligne dans le gestionnaire de contexte.
- Est-ce "thread-safe"? Qu'advient-il si un autre thread/appel utilise print (), tandis que faire_quelque_chose fonctionne?
- Répondre à moi-même.. Pas thread-safe. Si un autre thread appelle pour l'impression, il remonte en 'output'
- Yep, pas thread-safe, bien que l'impression sur stdout pouvez même obtenir un peu bancale avec des fils de toute façon.
- Malheureusement cela ne fonctionne pas avec des modules en C (comme fontforge)
- c'est une excellente idée. Merci pour ce!
- Est le del instruction nécessaire? J'aurais pensé qu'après __exit__ est fini, tout est hors de portée et sera rapidement nettoyée.
- Pourquoi serait-il hors de portée?
- Cette réponse ne fonctionnera pas pour la sortie de C bibliothèques partagées, voir cette réponse à la place.
- Pas thread-safe soit.
InformationsquelleAutor kindall
59

En python >= 3.4, contextlib contient un redirect_stdout décorateur. Il peut être utilisé pour répondre à votre question comme:
```
import io
from contextlib import redirect_stdout

f = io.StringIO()
with redirect_stdout(f):
    do_something(my_object)
out = f.getvalue()
```
De les docs:
Gestionnaire de contexte pour rediriger temporairement sys.stdout vers un autre fichier
ou fichier-comme objet.

Cet outil apporte de la flexibilité à des fonctions ou des classes dont les
de sortie est branché directement sur la sortie standard stdout.

Par exemple, la sortie de l'aide() est normalement envoyé à sys.la sortie standard stdout. Vous
peut capturer que la production dans une chaîne de caractères en redirigeant la sortie vers un
io.StringIO objet:
```
  f = io.StringIO() 
  with redirect_stdout(f):
      help(pow) 
  s = f.getvalue()
```
Pour envoyer la sortie de l'aide() dans un fichier sur disque, rediriger la sortie vers
un fichier régulier:
```
 with open('help.txt', 'w') as f:
     with redirect_stdout(f):
         help(pow)
```
Pour envoyer la sortie de l'aide() pour sys.stderr:
```
with redirect_stdout(sys.stderr):
    help(pow)
```
Remarque que le côté effet sur sys.stdout signifie que ce contexte
le gestionnaire n'est pas adapté pour une utilisation dans le code de la bibliothèque et de la plupart des filetés
des applications. Il n'a également aucun effet sur la sortie des sous-processus.
Cependant, il est encore utile pour de nombreux utilitaire de scripts.

Ce contexte, le gestionnaire est réentrant.
InformationsquelleAutor ForeverWintr

Vous devez vous connecter pour publier un commentaire.