Maison  >  Article  >  développement back-end  >  Méthode de redirection de sortie standard Python

Méthode de redirection de sortie standard Python

高洛峰
高洛峰original
2017-02-25 13:11:213042parcourir

1. Contexte

En Python, les objets fichiers sys.stdin, sys.stdout et sys.stderr correspondent à l'entrée standard, à la sortie standard et au standard du interprète respectivement. Au démarrage du programme, les valeurs initiales de ces objets sont enregistrées par sys.__stdin__, sys.__stdout__ et sys.__stderr__ afin qu'elles puissent être utilisées pour restaurer les objets du flux standard lors de la finalisation.

IDLE (Python GUI) dans le système Windows est exécuté par pythonw.exe et l'interface graphique n'a pas de console. Par conséquent, IDLE remplace le handle de sortie standard par un objet PseudoOutputFile spécial afin que la sortie du script soit redirigée vers la fenêtre du terminal IDLE (Shell). Cela peut conduire à des problèmes étranges, tels que :

Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec 5 2015, 20:32:19) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> import sys
>>> for fd in (sys.stdin, sys.stdout, sys.stderr): print fd

<idlelib.PyShell.PseudoInputFile object at 0x0177C910>
<idlelib.PyShell.PseudoOutputFile object at 0x0177C970>
<idlelib.PyShell.PseudoOutputFile object at 0x017852B0>
>>> for fd in (sys.__stdin__, sys.__stdout__, sys.__stderr__): print fd

<open file &#39;<stdin>&#39;, mode &#39;r&#39; at 0x00FED020>
<open file &#39;<stdout>&#39;, mode &#39;w&#39; at 0x00FED078>
<open file &#39;<stderr>&#39;, mode &#39;w&#39; at 0x00FED0D0>
>>>

On peut constater que les valeurs de sys.__stdout__ et sys.stdout sont pas pareil. Lors de l'exécution du code ci-dessus sous un interpréteur Python normal (par exemple via une console Windows), les deux valeurs sont les mêmes.

Lorsque l'instruction print ne se termine pas par une virgule, un caractère de nouvelle ligne (saut de ligne) sera automatiquement ajouté à la fin de la chaîne de sortie ; sinon, un espace sera utilisé pour remplacer le caractère de nouvelle ligne supplémentaire. L'instruction print écrit par défaut dans le flux de sortie standard et peut également être redirigée vers un fichier ou un autre objet inscriptible (tous les objets qui fournissent une méthode d'écriture). De cette façon, vous pouvez utiliser des instructions d'impression concises au lieu d'une écriture object.write('hello' 'n') maladroite.

Comme le montre ce qui précède, lors de l'appel de print obj pour imprimer un objet en Python, cela équivaut par défaut à appeler sys.stdout.write(obj 'n')

L'exemple est le suivant :

>>> import sys
>>> print &#39;Hello World&#39;
Hello World
>>> sys.stdout.write(&#39;Hello World&#39;)
Hello World

2. Méthodes de redirection

Cette section présente les méthodes couramment utilisées. Méthodes de redirection de sortie standard Python. Chacune de ces méthodes présente ses propres avantages et inconvénients et convient à différents scénarios.

2.1 Redirection de la console

Le moyen le plus simple et le plus courant de rediriger la sortie consiste à utiliser les commandes de la console. Cette redirection est effectuée par la console et n'a rien à voir avec Python lui-même.

L'invite de commande Windows (cmd.exe) et Linux Shell (bash, etc.) redirigent la sortie via ">" ou ">>". Parmi eux, ">" signifie écraser du contenu et ">>" signifie ajouter du contenu. De même, "2>" redirige l'erreur standard. La redirection vers "nul" (Windows) ou "/dev/null" (Linux) supprime la sortie, sans l'afficher à l'écran ni l'enregistrer sur le disque.

En prenant l'invite de commande Windows comme exemple, redirigez la sortie du script Python vers un fichier (les lignes vides entre les commandes ont été supprimées pour raccourcir la longueur) :

E:\>echo print &#39;hello&#39; > test.py
E:\>test.py > out.txt
E:\>type out.txt
hello
E:\>test.py >> out.txt
E:\>type out.txt
hello
hello
E:\>test.py > nul

Notez que lors de l'exécution d'un script Python dans l'invite de commande Windows, la ligne de commande n'a pas besoin de commencer par "python", le système appellera automatiquement l'interpréteur Python basé sur le suffixe du script. De plus, la commande type peut afficher directement le contenu d'un fichier texte, similaire à la commande cat dans les systèmes Linux.

Lors de l'exécution d'un script Python dans Linux Shell, la ligne de commande doit commencer par "python". En plus de la redirection ">" ou ">>", la commande tee peut également être utilisée. Cette commande peut afficher le contenu sur l'écran du terminal et (plusieurs) fichiers en même temps. L'option "-a" signifie ajouter l'écriture, sinon elle écrasera l'écriture. Un exemple est le suivant (

ou echo $SHELL affiche le Shell actuellement utilisé) : echo

[wangxiaoyuan_@localhost ~]$ echo $SHELL
/bin/bash
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;hello&#39;"
hello
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;hello&#39;" > out.txt
[wangxiaoyuan_@localhost ~]$ cat out.txt
hello
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;world&#39;" >> out.txt
[wangxiaoyuan_@localhost ~]$ cat out.txt             
hello
world
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;I am&#39;" | tee out.txt
I am
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;xywang&#39;" | tee -a out.txt
xywang
[wangxiaoyuan_@localhost ~]$ cat out.txt
I am
xywang
[wangxiaoyuan_@localhost ~]$ python -c "print &#39;hello&#39;" > /dev/null
[wangxiaoyuan_@localhost ~]$

Si vous souhaitez simplement enregistrer la sortie du script dans un fichier, ou vous pouvez utiliser directement la fonction de capture de journal de la fenêtre de session.

Notez que l'impact de la redirection de console est global et ne s'applique qu'à des tâches de sortie relativement simples.

2.2 print >>Redirection

Cette méthode est basée sur la forme développée de l'instruction d'impression, c'est-à-dire "print obj >> expr". Parmi eux, obj est un objet de type fichier (en particulier celui qui fournit une méthode d'écriture), et lorsqu'il est None, il correspond à la sortie standard (sys.stdout). expr sera affiché dans cet objet fichier.

Les exemples sont les suivants :

memo = cStringIO.StringIO(); serr = sys.stderr; file = open(&#39;out.txt&#39;, &#39;w+&#39;)
print >>memo, &#39;StringIO&#39;; print >>serr, &#39;stderr&#39;; print >>file, &#39;file&#39;
print >>None, memo.getvalue()

Une fois le code ci-dessus exécuté, l'écran affiche "serr" et "StringIO" ( deux lignes, veuillez noter l'ordre), écrivez "file" dans le fichier out.txt.

On voit que cette méthode est très flexible et pratique. L’inconvénient est qu’il n’est pas adapté aux scénarios comportant de nombreuses instructions de sortie.

2.3 Redirection sys.stdout

L'attribution d'un objet inscriptible (tel qu'un objet de type fichier) à sys.stdout permet d'envoyer les instructions d'impression ultérieures vers cet objet. Une fois la redirection terminée, sys.stdout doit être restauré à sa valeur par défaut d'origine, qui est la sortie standard.

Un exemple simple est le suivant :

import sys
savedStdout = sys.stdout #保存标准输出流
with open(&#39;out.txt&#39;, &#39;w+&#39;) as file:
  sys.stdout = file #标准输出重定向至文件
  print &#39;This message is for file!&#39;

sys.stdout = savedStdout #恢复标准输出流
print &#39;This message is for screen!&#39;

Notez que la valeur initiale de sys.stdout dans IDLE est l'objet PseudoOutputFile, ce qui est différent de sys.__stdout__ pareil. Par souci de généralité, cet exemple définit une variable distincte (savedStdout) pour enregistrer sys.stdout, ce qui sera également fait ci-dessous. De plus, cet exemple ne fonctionne pas avec les objets stdout importés via from sys import stdout.

Ce qui suit permettra de personnaliser une variété d'objets de type fichier avec write() méthodes pour répondre à différents besoins :

class RedirectStdout: #import os, sys, cStringIO
  def __init__(self):
    self.content = &#39;&#39;
    self.savedStdout = sys.stdout
    self.memObj, self.fileObj, self.nulObj = None, None, None

  #外部的print语句将执行本write()方法,并由当前sys.stdout输出
  def write(self, outStr):
    #self.content.append(outStr)
    self.content += outStr

  def toCons(self): #标准输出重定向至控制台
    sys.stdout = self.savedStdout #sys.__stdout__

  def toMemo(self): #标准输出重定向至内存
    self.memObj = cStringIO.StringIO()
    sys.stdout = self.memObj

  def toFile(self, file=&#39;out.txt&#39;): #标准输出重定向至文件
    self.fileObj = open(file, &#39;a+&#39;, 1) #改为行缓冲
    sys.stdout = self.fileObj
  
  def toMute(self): #抑制输出
    self.nulObj = open(os.devnull, &#39;w&#39;)
    sys.stdout = self.nulObj
    
  def restore(self):
    self.content = &#39;&#39;
    if self.memObj.closed != True:
      self.memObj.close()
    if self.fileObj.closed != True:
      self.fileObj.close()
    if self.nulObj.closed != True:
      self.nulObj.close()
    sys.stdout = self.savedStdout #sys.__stdout__

注意,toFile()方法中,open(name[, mode[, buffering]])调用选择行缓冲(无缓冲会影响性能)。这是为了观察中间写入过程,否则只有调用close()flush()后输出才会写入文件。内部调用open()方法的缺点是不便于用户定制写文件规则,如模式(覆盖或追加)和缓冲(行或全缓冲)。

重定向效果如下:

redirObj = RedirectStdout()
sys.stdout = redirObj #本句会抑制"Let&#39;s begin!"输出
print "Let&#39;s begin!"

#屏显&#39;Hello World!&#39;和&#39;I am xywang.&#39;(两行)
redirObj.toCons(); print &#39;Hello World!&#39;; print &#39;I am xywang.&#39;
#写入&#39;How are you?&#39;和"Can&#39;t complain."(两行)
redirObj.toFile(); print &#39;How are you?&#39;; print "Can&#39;t complain."
redirObj.toCons(); print "What&#39;up?"   #屏显
redirObj.toMute(); print &#39;<Silence>&#39;  #无屏显或写入
os.system(&#39;echo Never redirect me!&#39;)  #控制台屏显&#39;Never redirect me!&#39;
redirObj.toMemo(); print &#39;What a pity!&#39; #无屏显或写入
redirObj.toCons(); print &#39;Hello?&#39;    #屏显
redirObj.toFile(); print "Oh, xywang can&#39;t hear me" #该串写入文件
redirObj.restore()

print &#39;Pop up&#39; #屏显

可见,执行toXXXX()语句后,标准输出流将被重定向到XXXX。此外,toMute()toMemo()的效果类似,均可抑制输出。

使用某对象替换sys.stdout时,尽量确保该对象接近文件对象,尤其是涉及第三方库时(该库可能使用sys.stdout的其他方法)。此外,本节替换sys.stdout的代码实现并不影响由os.popen()、os.system()os.exec*()系列方法所创建进程的标准I/O流。

2.4 上下文管理器(Context Manager)

本节严格意义上并非新的重定向方式,而是利用Pyhton上下文管理器优化上节的代码实现。借助于上下文管理器语法,可不必向重定向使用者暴露sys.stdout

首先考虑输出抑制,基于上下文管理器语法实现如下:

import sys, cStringIO, contextlib
class DummyFile:
  def write(self, outStr): pass

@contextlib.contextmanager
def MuteStdout():
  savedStdout = sys.stdout
  sys.stdout = cStringIO.StringIO() #DummyFile()
  try:
    yield
  except Exception: #捕获到错误时,屏显被抑制的输出(该处理并非必需)
    content, sys.stdout = sys.stdout, savedStdout
    print content.getvalue()#; raise
  #finally:
  sys.stdout = savedStdout

使用示例如下:

with MuteStdout():
  print "I&#39;ll show up when <raise> is executed!" #不屏显不写入
  raise #屏显上句
  print "I&#39;m hiding myself somewhere:)" #不屏显

再考虑更通用的输出重定向:

import os, sys
from contextlib import contextmanager
@contextmanager
def RedirectStdout(newStdout):
  savedStdout, sys.stdout = sys.stdout, newStdout
  try:
    yield
  finally:
    sys.stdout = savedStdout

使用示例如下:

def Greeting(): print &#39;Hello, boss!&#39;

with open(&#39;out.txt&#39;, "w+") as file:
  print "I&#39;m writing to you..."  #屏显
  with RedirectStdout(file):
    print &#39;I hope this letter finds you well!&#39; #写入文件
  print &#39;Check your mailbox.&#39;   #屏显

with open(os.devnull, "w+") as file, RedirectStdout(file):
  Greeting()           #不屏显不写入
  print &#39;I deserve a pay raise:)&#39; #不屏显不写入
print &#39;Did you hear what I said?&#39;  #屏显

可见,with内嵌块里的函数和print语句输出均被重定向。注意,上述示例不是线程安全的,主要适用于单线程。

当函数被频繁调用时,建议使用装饰器包装该函数。这样,仅需修改该函数定义,而无需在每次调用该函数时使用with语句包裹。示例如下:

import sys, cStringIO, functools
def MuteStdout(retCache=False):
  def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
      savedStdout = sys.stdout
      sys.stdout = cStringIO.StringIO()
      try:
        ret = func(*args, **kwargs)
        if retCache == True:
          ret = sys.stdout.getvalue().strip()
      finally:
        sys.stdout = savedStdout
      return ret
    return wrapper
  return decorator

若装饰器MuteStdout的参数retCache为真,外部调用func()函数时将返回该函数内部print输出的内容(可供屏显);若retCache为假,外部调用func()函数时将返回该函数的返回值(抑制输出)。

MuteStdout装饰器使用示例如下:

@MuteStdout(True)
def Exclaim(): print &#39;I am proud of myself!&#39;

@MuteStdout()
def Mumble(): print &#39;I lack confidence...&#39;; return &#39;sad&#39;

print Exclaim(), Exclaim.__name__ #屏显&#39;I am proud of myself! Exclaim&#39;
print Mumble(), Mumble.__name__  #屏显&#39;sad Mumble&#39;

在所有线程中,被装饰函数执行期间,sys.stdout都会被MuteStdout装饰器劫持。而且,函数一经装饰便无法移除装饰。因此,使用该装饰器时应慎重考虑场景。

接着,考虑创建RedirectStdout装饰器:

def RedirectStdout(newStdout=sys.stdout):
  def decorator(func):
    def wrapper(*args,**kwargs):
      savedStdout, sys.stdout = sys.stdout, newStdout
      try:
        return func(*args, **kwargs)
      finally:
        sys.stdout = savedStdout
    return wrapper
  return decorator

使用示例如下:

file = open(&#39;out.txt&#39;, "w+")
@RedirectStdout(file)
def FunNoArg(): print &#39;No argument.&#39;

@RedirectStdout(file)
def FunOneArg(a): print &#39;One argument:&#39;, a

def FunTwoArg(a, b): print &#39;Two arguments: %s, %s&#39; %(a,b)

FunNoArg()   #写文件&#39;No argument.&#39;
FunOneArg(1984) #写文件&#39;One argument: 1984&#39;
RedirectStdout()(FunTwoArg)(10,29) #屏显&#39;Two arguments: 10, 29&#39;
print FunNoArg.__name__      #屏显&#39;wrapper&#39;(应显示&#39;FunNoArg&#39;)

file.close()

注意FunTwoArg()函数的定义和调用与其他函数的不同,这是两种等效的语法。此外,RedirectStdout装饰器的最内层函数wrapper()未使用"functools.wraps(func)"修饰,会丢失被装饰函数原有的特殊属性(如函数名、文档字符串等)。

2.5 logging模块重定向

对于代码量较大的工程,建议使用logging模块进行输出。该模块是线程安全的,可将日志信息输出到控制台、写入文件、使用TCP/UDP协议发送到网络等等。

默认情况下logging模块将日志输出到控制台(标准出错),且只显示大于或等于设置的日志级别的日志。日志级别由高到低为CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET,默认级别为WARNING。

以下示例将日志信息分别输出到控制台和写入文件:

import logging
logging.basicConfig(level = logging.DEBUG,
  format = &#39;%(asctime)s [%(levelname)s] at %(filename)s,%(lineno)d: %(message)s&#39;,
  datefmt = &#39;%Y-%m-%d(%a)%H:%M:%S&#39;,
  filename = &#39;out.txt&#39;,
  filemode = &#39;w&#39;)

 
#将大于或等于INFO级别的日志信息输出到StreamHandler(默认为标准错误)
console = logging.StreamHandler()
console.setLevel(logging.INFO) 
formatter = logging.Formatter(&#39;[%(levelname)-8s] %(message)s&#39;) #屏显实时查看,无需时间
console.setFormatter(formatter)
logging.getLogger().addHandler(console)

logging.debug(&#39;gubed&#39;); logging.info(&#39;ofni&#39;); logging.critical(&#39;lacitirc&#39;)

通过对多个handler设置不同的level参数,可将不同的日志内容输入到不同的地方。本例使用在logging模块内置的StreamHandler(和FileHandler),运行后屏幕上显示:

[INFO  ] ofni
[CRITICAL] lacitirc

out.txt文件内容则为:

2016-05-13(Fri)17:10:53 [DEBUG] at test.py,25: gubed
2016-05-13(Fri)17:10:53 [INFO] at test.py,25: ofni
2016-05-13(Fri)17:10:53 [CRITICAL] at test.py,25: lacitirc

除直接在程序中设置Logger、Handler、Formatter等外,还可将这些信息写入配置文件。示例如下:

#logger.conf
###############Logger###############
[loggers]
keys=root,Logger2F,Logger2CF

[logger_root]
level=DEBUG
handlers=hWholeConsole

[logger_Logger2F]
handlers=hWholeFile
qualname=Logger2F
propagate=0

[logger_Logger2CF]
handlers=hPartialConsole,hPartialFile
qualname=Logger2CF
propagate=0

###############Handler###############
[handlers]
keys=hWholeConsole,hPartialConsole,hWholeFile,hPartialFile

[handler_hWholeConsole]
class=StreamHandler
level=DEBUG
formatter=simpFormatter
args=(sys.stdout,)

[handler_hPartialConsole]
class=StreamHandler
level=INFO
formatter=simpFormatter
args=(sys.stderr,)

[handler_hWholeFile]
class=FileHandler
level=DEBUG
formatter=timeFormatter
args=(&#39;out.txt&#39;, &#39;a&#39;)

[handler_hPartialFile]
class=FileHandler
level=WARNING
formatter=timeFormatter
args=(&#39;out.txt&#39;, &#39;w&#39;)

###############Formatter###############
[formatters]
keys=simpFormatter,timeFormatter

[formatter_simpFormatter]
format=[%(levelname)s] at %(filename)s,%(lineno)d: %(message)s

[formatter_timeFormatter]
format=%(asctime)s [%(levelname)s] at %(filename)s,%(lineno)d: %(message)s
datefmt=%Y-%m-%d(%a)%H:%M:%S

此处共创建三个Logger:root,将所有日志输出至控制台;Logger2F,将所有日志写入文件;Logger2CF,将级别大于或等于INFO的日志输出至控制台,将级别大于或等于WARNING的日志写入文件。

程序以如下方式解析配置文件和重定向输出:

import logging, logging.config

logging.config.fileConfig("logger.conf")

logger = logging.getLogger("Logger2CF")
logger.debug(&#39;gubed&#39;); logger.info(&#39;ofni&#39;); logger.warn(&#39;nraw&#39;)
logger.error(&#39;rorre&#39;); logger.critical(&#39;lacitirc&#39;)

logger1 = logging.getLogger("Logger2F")
logger1.debug(&#39;GUBED&#39;); logger1.critical(&#39;LACITIRC&#39;)

logger2 = logging.getLogger()
logger2.debug(&#39;gUbEd&#39;); logger2.critical(&#39;lAcItIrC&#39;)

运行后屏幕上显示:

[INFO] at test.py,7: ofni
[WARNING] at test.py,7: nraw
[ERROR] at test.py,8: rorre
[CRITICAL] at test.py,8: lacitirc
[DEBUG] at test.py,14: gUbEd
[CRITICAL] at test.py,14: lAcItIrC

out.txt文件内容则为:

2016-05-13(Fri)20:31:21 [WARNING] at test.py,7: nraw
2016-05-13(Fri)20:31:21 [ERROR] at test.py,8: rorre
2016-05-13(Fri)20:31:21 [CRITICAL] at test.py,8: lacitirc
2016-05-13(Fri)20:31:21 [DEBUG] at test.py,11: GUBED
2016-05-13(Fri)20:31:21 [CRITICAL] at test.py,11: LACITIRC

三. 总结

以上就是关于Python标准输出的重定向方式的全部内容,希望对学习python的朋友们能有所帮助,如果有疑问欢迎大家留言讨论。

Pour plus d'articles liés aux méthodes de redirection de sortie standard Python, veuillez faire attention au site Web PHP chinois !

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn