Maison > Article > développement back-end > Méthode de redirection de sortie standard Python
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 '<stdin>', mode 'r' at 0x00FED020> <open file '<stdout>', mode 'w' at 0x00FED078> <open file '<stderr>', mode 'w' 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 'Hello World' Hello World >>> sys.stdout.write('Hello World') Hello World
2. Méthodes de redirection
2.1 Redirection de la console
E:\>echo print 'hello' > 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 'hello'" hello [wangxiaoyuan_@localhost ~]$ python -c "print 'hello'" > out.txt [wangxiaoyuan_@localhost ~]$ cat out.txt hello [wangxiaoyuan_@localhost ~]$ python -c "print 'world'" >> out.txt [wangxiaoyuan_@localhost ~]$ cat out.txt hello world [wangxiaoyuan_@localhost ~]$ python -c "print 'I am'" | tee out.txt I am [wangxiaoyuan_@localhost ~]$ python -c "print 'xywang'" | tee -a out.txt xywang [wangxiaoyuan_@localhost ~]$ cat out.txt I am xywang [wangxiaoyuan_@localhost ~]$ python -c "print 'hello'" > /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('out.txt', 'w+') print >>memo, 'StringIO'; print >>serr, 'stderr'; print >>file, 'file' 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('out.txt', 'w+') as file: sys.stdout = file #标准输出重定向至文件 print 'This message is for file!' sys.stdout = savedStdout #恢复标准输出流 print 'This message is for screen!'
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 = '' 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='out.txt'): #标准输出重定向至文件 self.fileObj = open(file, 'a+', 1) #改为行缓冲 sys.stdout = self.fileObj def toMute(self): #抑制输出 self.nulObj = open(os.devnull, 'w') sys.stdout = self.nulObj def restore(self): self.content = '' 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's begin!"输出 print "Let's begin!" #屏显'Hello World!'和'I am xywang.'(两行) redirObj.toCons(); print 'Hello World!'; print 'I am xywang.' #写入'How are you?'和"Can't complain."(两行) redirObj.toFile(); print 'How are you?'; print "Can't complain." redirObj.toCons(); print "What'up?" #屏显 redirObj.toMute(); print '<Silence>' #无屏显或写入 os.system('echo Never redirect me!') #控制台屏显'Never redirect me!' redirObj.toMemo(); print 'What a pity!' #无屏显或写入 redirObj.toCons(); print 'Hello?' #屏显 redirObj.toFile(); print "Oh, xywang can't hear me" #该串写入文件 redirObj.restore() print 'Pop up' #屏显
可见,执行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'll show up when <raise> is executed!" #不屏显不写入 raise #屏显上句 print "I'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 'Hello, boss!' with open('out.txt', "w+") as file: print "I'm writing to you..." #屏显 with RedirectStdout(file): print 'I hope this letter finds you well!' #写入文件 print 'Check your mailbox.' #屏显 with open(os.devnull, "w+") as file, RedirectStdout(file): Greeting() #不屏显不写入 print 'I deserve a pay raise:)' #不屏显不写入 print 'Did you hear what I said?' #屏显
可见,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 'I am proud of myself!' @MuteStdout() def Mumble(): print 'I lack confidence...'; return 'sad' print Exclaim(), Exclaim.__name__ #屏显'I am proud of myself! Exclaim' print Mumble(), Mumble.__name__ #屏显'sad Mumble'
在所有线程中,被装饰函数执行期间,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('out.txt', "w+") @RedirectStdout(file) def FunNoArg(): print 'No argument.' @RedirectStdout(file) def FunOneArg(a): print 'One argument:', a def FunTwoArg(a, b): print 'Two arguments: %s, %s' %(a,b) FunNoArg() #写文件'No argument.' FunOneArg(1984) #写文件'One argument: 1984' RedirectStdout()(FunTwoArg)(10,29) #屏显'Two arguments: 10, 29' print FunNoArg.__name__ #屏显'wrapper'(应显示'FunNoArg') 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 = '%(asctime)s [%(levelname)s] at %(filename)s,%(lineno)d: %(message)s', datefmt = '%Y-%m-%d(%a)%H:%M:%S', filename = 'out.txt', filemode = 'w') #将大于或等于INFO级别的日志信息输出到StreamHandler(默认为标准错误) console = logging.StreamHandler() console.setLevel(logging.INFO) formatter = logging.Formatter('[%(levelname)-8s] %(message)s') #屏显实时查看,无需时间 console.setFormatter(formatter) logging.getLogger().addHandler(console) logging.debug('gubed'); logging.info('ofni'); logging.critical('lacitirc')
通过对多个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=('out.txt', 'a') [handler_hPartialFile] class=FileHandler level=WARNING formatter=timeFormatter args=('out.txt', 'w') ###############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('gubed'); logger.info('ofni'); logger.warn('nraw') logger.error('rorre'); logger.critical('lacitirc') logger1 = logging.getLogger("Logger2F") logger1.debug('GUBED'); logger1.critical('LACITIRC') logger2 = logging.getLogger() logger2.debug('gUbEd'); logger2.critical('lAcItIrC')
运行后屏幕上显示:
[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 !