精华内容
下载资源
问答
  • stdout
    2022-06-29 14:05:35

    import是python中封装的一个类,便于函数调用

    import sys
    sys.stdout.write(str(123)+'\n')

    print 123

    等价

    更多相关内容
  • c3io利用stdin和stdout进行,以便与其他进程进行通信。 如果您只想在nodejs中与父子进行通信,则只需使用标准。 进展中-不稳定 用例 看看使用c3io与沟通的手段容器。 基本用法 var c3io = require('c3io')...
  • 主要介绍了详解使用python的logging模块在stdout输出的相关资料,需要的朋友可以参考下
  • GoLangLog 简约的Golang记录器,可记录到stdout和文件。安装go get github.com/munirehmad/golanglog用法package mainimport ( "github.com/munirehmad/golanglog")func main(){ log := golanglog.NewLogger("./logs...
  • python-tee Python库将stderr / stdout发送到文件安装pip install tee快速开始tee_test.py import sysfrom tee import StdoutTee , StderrTeewith StdoutTee ( "mystdout.txt" ), StderrTee ( "mystderr.txt" ): sys...
  • supervisor-stdout

    2021-05-24 08:39:28
    pip install supervisor-stdout 用法 一个示例supervisord.conf: [supervisord] nodaemon = true [program:web] command = ... stdout_events_enabled = true stderr_events_enabled = true [eventlistener:...
  • 你的程序中有个方法会输出到标准输出中(sys.stdout)。也就是说它会将文本打印到屏幕上面。 你想写个测试来证明它,给定一个输入,相应的输出能正常显示出来。 解决方案 使用 unittest.mock 模块中的 patch() 函数...
  • is-interactive检查stdout或stderr是否是交互式的它检查流是否为TTY,而不是哑终端,并且不在CI中运行。 这对于决定是否在交互式交互中呈现交互式UI或动画很有用。检查stdout或stderr是否是交互式的。它检查流是TTY...
  • /usr/bin/env pythonimport syssys.stdout.write(“stdout1 “)sys.stderr.write(“stderr1 “)sys.stdout.write(“stdout2 “)sys.stderr.write(“stderr2 “)其中的sys.stdout.write也可以换成print。运行这程序,...
  • ucrt_crash_on_printf:在_setmode(_fileno(stdout),_O_U8TEXT)之后,使用printf会使程序崩溃
  • def writeline(text, stream=sys.stdout): stream.write(text + ' ') with open('/path/to/file', 'w') as f: # writes to /path/to/file writeline('foo', f) # writes to standard output writeline('bar') ...
  • e Gee是每个文件和stdout的stdin工具。 它与tee命令类似,但为方便起见,还有更多功能。 此外,它还作为go标准输入写入了每个文件和stdout。 与tee相似,但是还有更多东西可以写Write简介Gee是每个文件和stdout的...
  • 允许您获取 Node 全局 process.stdout 和 process.stderr 管道并监听。 文档 API 很简单。 使用钩子库的 stderr 或 stdout 函数,只需传入一个处理函数。 可选的第二个参数是真/假,它控制数据是复制到原始目的地...
  • 今天小编就为大家分享一篇Python中的sys.stdout.write实现打印刷新功能,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 一、sys.stdout的形式就是print的一种默认输出格式,等于print “%VALUE%” print函数是对sys.stdout的高级封装,看下print函数的解释 Prints the values to a stream, or to sys.stdout by default. Optional ...
  • 带有 GPIO、MQTT 和标准输出的基本 ESP8266 代码。 在 ESP8266-01 上工作和测试 特征 读取 GPIO 开关状态 中断驱动的 GPIO0 上的密钥... Jeroen Domburg ( ) stdout 驱动程序的克隆。 它是一种仅使用 TX 引脚的替代
  • 《算法》中,使用StdOut.printf () 语句需要的algs4.jar文件 下载及配置。《算法》第四版的jar包08-02 《算法(第4版)》是Sedgewick之巨著,与高德纳TAOCP一脉相承,是算法领域经典的参考书,涵盖所有程序员必须掌握...
  • python 打印信息重定向 GUI界面 ,PyQt5实时显示调用外部程序的实时输出显示,subprocess.Popen stdout输出重定向,备注详细!
  • JAVA StdOut工具类下载

    2019-04-18 10:49:58
    分享一个JAVA StdOut的工具类,此工具类主要用于输出等一系列变换,推荐大家在我博客百度云盘下载。
  • Ansible Stdout紧凑型记录仪 安装 放在磁盘上的某个地方 在您的ansible配置的[defaults]设置中添加callback_plugins设置 将stdout_callback更改为anstomlog cf ansible.cfg 。 产品特点 单行显示 兼容pylint...
  • jsonexec 运行命令并将输出(stdout)JSON转换为提供的对象
  • 安装将此行添加到应用程序的Gemfile中: gem 'bundler-update_stdout'然后执行: $ bundle或将其自己安装为: $ gem install bundler-update_stdout用法$ bundle-update_stdout update_stdout备注:将来,我想以...
  • 它提供了一种使用 C# 函数重定向外部可执行文件的控制台输入和输出的方法。
  • How do I redirect stdout to an arbitrary file in Python? 如何在Python中将stdout重定向到任意文件? When a long-r

    本文翻译自:Redirect stdout to a file in Python?

    How do I redirect stdout to an arbitrary file in Python? 如何在Python中将stdout重定向到任意文件?

    When a long-running Python script (eg, web application) is started from within the ssh session and backgounded, and the ssh session is closed, the application will raise IOError and fail the moment it tries to write to stdout. 当从ssh会话中启动运行了长时间的Python脚本(例如,Web应用程序)并进行背景调整,并且ssh会话关闭时,该应用程序将在尝试写入stdout时引发IOError并失败。 I needed to find a way to make the application and modules output to a file rather than stdout to prevent failure due to IOError. 我需要找到一种方法来使应用程序和模块输出到文件而不是stdout,以防止由于IOError而导致失败。 Currently, I employ nohup to redirect output to a file, and that gets the job done, but I was wondering if there was a way to do it without using nohup, out of curiosity. 当前,我使用nohup将输出重定向到文件,并且可以完成工作,但是我想知道是否有一种出于好奇而无需使用nohup的方法。

    I have already tried sys.stdout = open('somefile', 'w') , but this does not seem to prevent some external modules from still outputting to terminal (or maybe the sys.stdout = ... line did not fire at all). 我已经尝试过sys.stdout = open('somefile', 'w') ,但这似乎并不能阻止某些外部模块仍然输出到终端(或者sys.stdout = ...行未在所有)。 I know it should work from simpler scripts I've tested on, but I also didn't have time yet to test on a web application yet. 我知道它应该可以通过我测试过的简单脚本工作,但是我还没有时间在Web应用程序上进行测试。


    #1楼

    参考:https://stackoom.com/question/jCmY/将stdout重定向到Python中的文件


    #2楼

    The other answers didn't cover the case where you want forked processes to share your new stdout. 其他答案没有涉及您希望分叉的进程共享新标准输出的情况。

    To do that: 要做到这一点:

    from os import open, close, dup, O_WRONLY
    
    old = dup(1)
    close(1)
    open("file", O_WRONLY) # should open on 1
    
    ..... do stuff and then restore
    
    close(1)
    dup(old) # should dup to 1
    close(old) # get rid of left overs
    

    #3楼

    Quoted from PEP 343 -- The "with" Statement (added import statement): 引用自PEP 343-“ with”语句 (添加的导入语句):

    Redirect stdout temporarily: 暂时重定向标准输出:

    import sys
    from contextlib import contextmanager
    @contextmanager
    def stdout_redirected(new_stdout):
        save_stdout = sys.stdout
        sys.stdout = new_stdout
        try:
            yield None
        finally:
            sys.stdout = save_stdout
    

    Used as follows: 用法如下:

    with open(filename, "w") as f:
        with stdout_redirected(f):
            print "Hello world"
    

    This isn't thread-safe, of course, but neither is doing this same dance manually. 当然,这不是线程安全的,但是也没有手动进行相同的舞蹈。 In single-threaded programs (for example in scripts) it is a popular way of doing things. 在单线程程序中(例如在脚本中),这是一种流行的处理方式。


    #4楼

    Programs written in other languages (eg C) have to do special magic (called double-forking) expressly to detach from the terminal (and to prevent zombie processes). 用其他语言(例如C)编写的程序必须做特别的魔术(称为双叉)才能与终端分离(并防止僵尸进程)。 So, I think the best solution is to emulate them. 因此,我认为最好的解决方案是模仿它们。

    A plus of re-executing your program is, you can choose redirections on the command-line, eg /usr/bin/python mycoolscript.py 2>&1 1>/dev/null 重新执行程序的一个/usr/bin/python mycoolscript.py 2>&1 1>/dev/null是,您可以在命令行上选择重定向,例如/usr/bin/python mycoolscript.py 2>&1 1>/dev/null

    See this post for more info: What is the reason for performing a double fork when creating a daemon? 有关更多信息,请参见此帖子: 创建守护程序时执行双叉的原因是什么?


    #5楼

    There is contextlib.redirect_stdout() function in Python 3.4: Python 3.4中有contextlib.redirect_stdout()函数

    from contextlib import redirect_stdout
    
    with open('help.txt', 'w') as f:
        with redirect_stdout(f):
            print('it now prints to `help.text`')
    

    It is similar to: 它类似于:

    import sys
    from contextlib import contextmanager
    
    @contextmanager
    def redirect_stdout(new_target):
        old_target, sys.stdout = sys.stdout, new_target # replace sys.stdout
        try:
            yield new_target # run some code with the replaced stdout
        finally:
            sys.stdout = old_target # restore to the previous value
    

    that can be used on earlier Python versions. 可以在早期的Python版本中使用。 The latter version is not reusable . 后一版本不可重用 It can be made one if desired. 如果需要,可以将其制成一个。

    It doesn't redirect the stdout at the file descriptors level eg: 它不会在文件描述符级别重定向标准输出,例如:

    import os
    from contextlib import redirect_stdout
    
    stdout_fd = sys.stdout.fileno()
    with open('output.txt', 'w') as f, redirect_stdout(f):
        print('redirected to a file')
        os.write(stdout_fd, b'not redirected')
        os.system('echo this also is not redirected')
    

    b'not redirected' and 'echo this also is not redirected' are not redirected to the output.txt file. b'not redirected''echo this also is not redirected'未重定向到output.txt文件。

    To redirect at the file descriptor level, os.dup2() could be used: 要在文件描述符级别重定向,可以使用os.dup2()

    import os
    import sys
    from contextlib import contextmanager
    
    def fileno(file_or_fd):
        fd = getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
        if not isinstance(fd, int):
            raise ValueError("Expected a file (`.fileno()`) or a file descriptor")
        return fd
    
    @contextmanager
    def stdout_redirected(to=os.devnull, stdout=None):
        if stdout is None:
           stdout = sys.stdout
    
        stdout_fd = fileno(stdout)
        # copy stdout_fd before it is overwritten
        #NOTE: `copied` is inheritable on Windows when duplicating a standard stream
        with os.fdopen(os.dup(stdout_fd), 'wb') as copied: 
            stdout.flush()  # flush library buffers that dup2 knows nothing about
            try:
                os.dup2(fileno(to), stdout_fd)  # $ exec >&to
            except ValueError:  # filename
                with open(to, 'wb') as to_file:
                    os.dup2(to_file.fileno(), stdout_fd)  # $ exec > to
            try:
                yield stdout # allow code to be run with the redirected stdout
            finally:
                # restore stdout to its previous value
                #NOTE: dup2 makes stdout_fd inheritable unconditionally
                stdout.flush()
                os.dup2(copied.fileno(), stdout_fd)  # $ exec >&copied
    

    The same example works now if stdout_redirected() is used instead of redirect_stdout() : 如果使用stdout_redirected()而不是redirect_stdout()则现在可以使用相同的示例:

    import os
    import sys
    
    stdout_fd = sys.stdout.fileno()
    with open('output.txt', 'w') as f, stdout_redirected(f):
        print('redirected to a file')
        os.write(stdout_fd, b'it is redirected now\n')
        os.system('echo this is also redirected')
    print('this is goes back to stdout')
    

    The output that previously was printed on stdout now goes to output.txt as long as stdout_redirected() context manager is active. 只要上下文管理器stdout_redirected()处于活动状态,以前打印在stdout上的输出现在将进入output.txt

    Note: stdout.flush() does not flush C stdio buffers on Python 3 where I/O is implemented directly on read() / write() system calls. 注意: stdout.flush()不会刷新Python 3上的C stdio缓冲区,在该Python 3上,I / O是直接在read() / write()系统调用上实现的。 To flush all open C stdio output streams, you could call libc.fflush(None) explicitly if some C extension uses stdio-based I/O: 要刷新所有打开的C stdio输出流,如果某些C扩展使用基于stdio的I / O,则可以显式调用libc.fflush(None)

    try:
        import ctypes
        from ctypes.util import find_library
    except ImportError:
        libc = None
    else:
        try:
            libc = ctypes.cdll.msvcrt # Windows
        except OSError:
            libc = ctypes.cdll.LoadLibrary(find_library('c'))
    
    def flush(stream):
        try:
            libc.fflush(None)
            stream.flush()
        except (AttributeError, ValueError, IOError):
            pass # unsupported
    

    You could use stdout parameter to redirect other streams, not only sys.stdout eg, to merge sys.stderr and sys.stdout : 您可以使用stdout参数重定向其他流,而不仅仅是sys.stdout例如,合并sys.stderrsys.stdout

    def merged_stderr_stdout():  # $ exec 2>&1
        return stdout_redirected(to=sys.stdout, stdout=sys.stderr)
    

    Example: 例:

    from __future__ import print_function
    import sys
    
    with merged_stderr_stdout():
         print('this is printed on stdout')
         print('this is also printed on stdout', file=sys.stderr)
    

    Note: stdout_redirected() mixes buffered I/O ( sys.stdout usually) and unbuffered I/O (operations on file descriptors directly). 注意: stdout_redirected()将缓冲的I / O(通常为sys.stdout )和无缓冲的I / O(直接对文件描述符的操作)混合使用。 Beware, there could be buffering issues . 当心,可能存在缓冲 问题

    To answer, your edit: you could use python-daemon to daemonize your script and use logging module (as @erikb85 suggested ) instead of print statements and merely redirecting stdout for your long-running Python script that you run using nohup now. 要回答,请进行编辑:您可以使用python-daemon并使用logging模块(如@ erikb85建议 )代替print语句,而仅将stdout重定向为您现在使用nohup运行的长期运行的Python脚本。


    #6楼

    Based on this answer: https://stackoverflow.com/a/5916874/1060344 , here is another way I figured out which I use in one of my projects. 基于以下答案: https : //stackoverflow.com/a/5916874/1060344 ,这是我想出在我的一个项目中使用的另一种方法。 For whatever you replace sys.stderr or sys.stdout with, you have to make sure that the replacement complies with file interface, especially if this is something you are doing because stderr/stdout are used in some other library that is not under your control. 对于用sys.stderrsys.stdout替换的任何内容,都必须确保替换符合file接口,尤其是在执行此操作时,因为stderr / stdout用于其他不受您控制的库中。 That library may be using other methods of file object. 该库可能正在使用文件对象的其他方法。

    Check out this way where I still let everything go do stderr/stdout (or any file for that matter) and also send the message to a log file using Python's logging facility (but you can really do anything with this): 看看这种方式,我仍然可以让所有事情继续进行stderr / stdout(或与此有关的任何文件),并使用Python的日志记录工具将消息发送到日志文件中(但您实际上可以执行任何操作):

    class FileToLogInterface(file):
        '''
        Interface to make sure that everytime anything is written to stderr, it is
        also forwarded to a file.
        '''
    
        def __init__(self, *args, **kwargs):
            if 'cfg' not in kwargs:
                raise TypeError('argument cfg is required.')
            else:
                if not isinstance(kwargs['cfg'], config.Config):
                    raise TypeError(
                        'argument cfg should be a valid '
                        'PostSegmentation configuration object i.e. '
                        'postsegmentation.config.Config')
            self._cfg = kwargs['cfg']
            kwargs.pop('cfg')
    
            self._logger = logging.getlogger('access_log')
    
            super(FileToLogInterface, self).__init__(*args, **kwargs)
    
        def write(self, msg):
            super(FileToLogInterface, self).write(msg)
            self._logger.info(msg)
    
    展开全文
  • stdout, stdin, stderr的区别

    stdin, stdout,stderr的中文名字分别是标准输入,标准输出和标准错误。

    当一个用户进程被创建的时候,系统会自动为该进程创建三个数据流, 一个程序要运行,需要有输入、输出,如果出错,还要能表现出自身的错误。这就是要从某个地方读入数据、将数据输出到某个地方,这就够成了数据流。

    因此,一个进程初期所拥有的这三个数据流即为标准输入、标准输出和标准错误,分别用stdin, stdout, stderr来表示。这3个文件分别为标准输入(stdin)、标准输出(stdout)、标准错误(stderr)。大多数环境中,stdin指向键盘,stdout、stderr指向显示器。之所以使用stderr,是因为一般来讲,若因某种原因造成其中一个文件无法访问,相应的诊断信息要在该程序运行输出信息的末尾才能打印出来。当输出到屏幕时,这种处理方法尚可接受,但如果诊断信息输出到一个文件或通过管道输出到另一个程序时,就无法接受了。若有stderr存在,即使对标准输出进行了重定向,也只有stdout的信息会写入重定向文件,而stderr中的输出还是显示在屏幕上。

    sys.stdin 介绍

    sys.stdin提供了read()和readline()函数,如果想按一行行来读取,可以考虑使用它:

    import sys
    line = sys.stdin.readline()
    while line:
        print line,
        line = sys.stdin.readline()
    

    注意:如果没有数据,io会被堵塞,所以可以对标准输入做数据检查(Linux):
    ···
    import sys
    import select

    if select.select([sys.stdin], [], [], 0.0)[0]:
    help_file_fragment = sys.stdin.read()
    else:
    print(“No data”, file=sys.stderr)
    sys.exit(2)
    ···
    此外,python还提供input()函数可以进行数据输入,但两者有区别,input()会把末尾的‘\n’忽略:

    >>> a = input("请输入一个数字:")
    请输入一个数字:20
    >>> a
    

    而stdin.readline()默认输入的格式是字符串,如果输入的是int,float类型则会强制转换成字符串类型,且会将标准输入全部获取,包括末尾的’\n’。

    sys.stdin 还可以与print合用产生input的效果:

    import sys
    print('Please input your name: ')
    name = sys.stdin.readline()
    print('Hello ', name)
    
    输出结果:
    Please input your name: 
    Hello 
    

    这里可以看到,尽管在print('Hello ', name)里,name在后面,但是在显示的时候会出现在前面。

    sys.stdout与sys.stderr 介绍

    在默认情况下,stdout是行缓冲的,他的输出会放在一个buffer里面,只有到换行的时候,才会输出到屏幕。stderr是不带缓冲的,这使得出错信息可以直接尽快地显示出来。

    sys.stdout 还可将标准输出重新定向到指定文件:

    import sys
    sys.stdout = open('log', 'a')
    b = print('haha', file=sys.stdout)
    

    运行代码后打印信息不会在屏幕上显示,而是会写到log文件中

    sys.stderr 则可将标准错误信息重定向输出到错误文件中:

    import sys
    sys.stdout = open('errlog', 'a')
    b = print('haha', file=sys.stdout)
    

    运行代码后错误信息不会在屏幕上显示,会写入到errlog文件中
    在linux中可以不用指定sys的stdout和stderr文件,若运行:

    python test.py >log 2>errlog
    

    这样打印信息会在log文件中,错误信息会展示到errlog文件中。这里的2表示标准错误信息流,>errlog表示将结果打印到errlog文件中。

    此外,我们还可以结合logging模块的操作通过指定handler来控制屏幕信息输出:

    #test.py
    import logging
    import sys
    logger1=logging.getLogger("logger1")
    handler1 = logging.StreamHandler(sys.stderr)
    formatter1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler1.setFormatter(formatter1)
    logger1.addHandler(handler1)
    
    logger2=logging.getLogger("logger2")
    formatter2 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler2 = logging.StreamHandler(sys.stdout)
    handler2.setFormatter(formatter2)
    logger2.addHandler(handler2)
    logger2.setLevel(level=logging.INFO)`
    
    logger1.info("not output because of level")
    logger1.warning("output in red")#标准错误输出在notebook中输出是红色的。
    logger2.info("output in white")
    logger2.warning("output in white")#标准正常输出是白色的。
    

    输出结果为:

    2022-07-28 15:25:56,570 - logger1 - WARNING - output in red
    2022-07-28 15:25:56,575 - logger2 - INFO - output in white
    2022-07-28 15:25:56,577 - logger2 - WARNING - output in white
    

    如果进行重定向,python test.py >log 2>errlog,则第一条logger1的输出结果存入errlog文件,其余logger2的输出结果存入log文件。

    sys.stdout.write方法

    sys.stdout还有一个write方法,调用的是 file 对象的 write 方法,区别是 file 对象的 write 方法把字符写入到文件中,sys.stdout.write 方法把字符写入到标准输出中,也就是控制台。这一点上与print()方法类似,但是stdout.write 默认不换行,print 默认换行

    import sys
    print('print 默认换行')
    sys.stdout.write('stdout.write 默认不换行')
    print('+++++++++')
    
    输出结果:
    print 默认换行
    stdout.write 默认不换行+++++++++
    

    因此stdout.write 需配合 \n 换行符实现换行功能:

    sys.stdout.write('str \n')
    

    print也可以实现不换行:

    print('str', end='')
    

    此外,print 几乎可以打印所有的对象,而 stdout.write 只能接受 str 类型。

    import sys
    class name():
        def __str__(self):
            return 'Citizen_Wang'
    a = name()
    
    print(a)
    print(type(a))
    sys.stdout.write(a)
    
    此脚本会报错:
    TypeError: write() argument must be str, not name
    
    解决方法:
    sys.stdout.wirte(str(a))
    

    sys.stdout还可以与print结合使用:

    import sys
    file = sys.stdout    # 存储原始的输出对象
    sys.stdout = open('1.txt', 'w')  # 重定向所有的写入内容到 1.txt 文件
    print('Citizen_Wang')   # 写入到 1.txt 文件中
    print('Always fall in love with neighbours')  # 继续写入到文件中
    sys.stdout.close()    # 其实就是 open 文件之后的关闭
    sys.stdout = file  # 将 print 命令的结果返回给控制台
    print('输出信息返回在控制台')  # 该信息会在控制台也显示
    

    以上代码会在当前目录下创建了一个 1.txt 文件,内容如下:

    Citizen_Wang
    Always fall in love with neighbours
    
    展开全文
  • 检查stdout或stderr是否是交互式的
  • piper - 一个小devtool,旨在通过安全连接(TLS)从进程立即共享stdout

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 497,976
精华内容 199,190
关键字:

stdout