¿Redirigir stdout a un archivo en Python?

¿Cómo redirijo stdout a un archivo arbitrario en Python?

Cuando se inicia un script de Python de larga duración (por ejemplo, una aplicación web) desde la sesión ssh y retrocede, y la sesión ssh se cierra, la aplicación generará IOError y fallará en el momento en que intente escribir en stdout. Necesitaba encontrar una manera de hacer que la aplicación y los módulos salieran a un archivo en lugar de stdout para evitar fallas debido a IOError. Actualmente, uso nohup para redirigir la salida a un archivo, y eso hace el trabajo, pero me preguntaba si había una manera de hacerlo sin usar nohup, por curiosidad.

Ya lo he intentado sys.stdout = open('somefile', 'w'), pero esto no parece evitar que algunos módulos externos sigan saliendo al terminal (o tal vez la sys.stdout = ...línea no se disparó en absoluto). Sé que debería funcionar a partir de scripts más simples que he probado, pero todavía no tuve tiempo para probar en una aplicación web todavía.

Si desea hacer la redirección dentro de la secuencia de comandos de Python, la configuración sys.stdoutde un objeto de archivo hace el truco:

import sys
sys.stdout = open('file', 'w')
print('test')

Un método mucho más común es utilizar la redirección de shell al ejecutar (lo mismo en Windows y Linux):

$ python foo.py > file

Hay una contextlib.redirect_stdout()función en Python 3.4:

from contextlib import redirect_stdout

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

Esto es similar a:

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

que se puede usar en versiones anteriores de Python. La última versión no es reutilizable . Se puede hacer uno si se desea.

No redirige el stdout en el nivel de descriptores de archivo, por ejemplo:

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'y 'echo this also is not redirected'no se redirigen al output.txtarchivo.

Para redirigir en el nivel de descriptor de archivo, os.dup2()podría usarse:

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

El mismo ejemplo funciona ahora si stdout_redirected()se usa en lugar de 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')

El resultado que antes se imprimía en stdout ahora se mantiene output.txtmientras el stdout_redirected()administrador de contexto esté activo.

Nota: stdout.flush()no vacía las memorias intermedias de C stdio en Python 3 donde la E / S se implementa directamente en las llamadas read()/ write()system. Para vaciar todas las secuencias de salida de C stdio abiertas, puede llamar libc.fflush(None)explícitamente si alguna extensión de C usa E / S basadas en stdio:

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

Puede usar el stdoutparámetro para redirigir otras secuencias, no solo sys.stdout, por ejemplo, para fusionar sys.stderry sys.stdout:

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

Ejemplo:

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)

Nota: stdout_redirected()mezcla E / S con búfer ( sys.stdoutgeneralmente) y E / S sin búfer (operaciones en descriptores de archivo directamente). Cuidado, podría haber problemas de almacenamiento en búfer .

Para responder, su edición: puede usar python-daemonpara demonizar su script y usar el loggingmódulo (como sugirió @ erikb85 ) en lugar de printdeclaraciones y simplemente redireccionar stdout para su script Python de larga ejecución que ejecuta nohupahora.

puedes probar esto mucho mejor

import sys

class Logger(object):
    def __init__(self, filename="Default.log"):
        self.terminal = sys.stdout
        self.log = open(filename, "a")

    def write(self, message):
        self.terminal.write(message)
        self.log.write(message)

sys.stdout = Logger("yourlogfilename.txt")
print "Hello world !" # this is should be saved in yourlogfilename.txt

Las otras respuestas no cubrieron el caso en el que desea que los procesos bifurcados compartan su nuevo stdout.

Para hacer eso:

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

Citado de PEP 343 - La declaración "con" (declaración de importación agregada):

Redireccionar stdout temporalmente:

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

Usado de la siguiente manera:

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

Esto no es seguro para subprocesos, por supuesto, pero tampoco lo está haciendo este mismo baile manualmente. En los programas de subproceso único (por ejemplo, en los scripts) es una forma popular de hacer las cosas.

import sys
sys.stdout = open('stdout.txt', 'w')

Aquí hay una variación de la respuesta de Yuda Prawira :

• implementar flush()y todos los atributos del archivo
• escríbelo como gestor de contexto
• capturar stderrtambién

.

import contextlib, sys

@contextlib.contextmanager
def log_print(file):
    # capture all outputs to a log file while still printing it
    class Logger:
        def __init__(self, file):
            self.terminal = sys.stdout
            self.log = file

        def write(self, message):
            self.terminal.write(message)
            self.log.write(message)

        def __getattr__(self, attr):
            return getattr(self.terminal, attr)

    logger = Logger(file)

    _stdout = sys.stdout
    _stderr = sys.stderr
    sys.stdout = logger
    sys.stderr = logger
    try:
        yield logger.log
    finally:
        sys.stdout = _stdout
        sys.stderr = _stderr


with log_print(open('mylogfile.log', 'w')):
    print('hello world')
    print('hello world on stderr', file=sys.stderr)

# you can capture the output to a string with:
# with log_print(io.StringIO()) as log:
#   ....
#   print('[captured output]', log.getvalue())

En base a esta respuesta: https://stackoverflow.com/a/5916874/1060344 , aquí hay otra forma que descubrí que utilizo en uno de mis proyectos. Para lo que sea que reemplace sys.stderro sys.stdoutcon, debe asegurarse de que el reemplazo cumpla con la fileinterfaz, especialmente si esto es algo que está haciendo porque stderr / stdout se usan en alguna otra biblioteca que no está bajo su control. Esa biblioteca puede estar utilizando otros métodos de objeto de archivo.

Eche un vistazo de esta manera donde todavía dejo que todo vaya a hacer stderr / stdout (o cualquier archivo para el caso) y también envíe el mensaje a un archivo de registro utilizando la función de registro de Python (pero realmente puede hacer cualquier cosa con esto):

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)

Necesita un multiplexor de terminal como tmux o pantalla GNU

Me sorprende que un pequeño comentario de Ryan Amos a la pregunta original sea la única mención de una solución mucho más preferible a todas las demás que se ofrecen, sin importar cuán inteligente sea el truco de Python y cuántos votos positivos hayan recibido. Además del comentario de Ryan, tmux es una buena alternativa a la pantalla GNU.

Pero el principio es el mismo: si alguna vez te encuentras con ganas de dejar un trabajo en la terminal mientras cierras la sesión, ve al café a comer un sándwich, ve al baño, ve a casa (etc.) y luego, vuelve a conectarte con tu sesión terminal desde cualquier lugar o cualquier computadora como si nunca hubiera estado fuera, los multiplexores terminales son la respuesta. Piense en ellos como VNC o escritorio remoto para sesiones de terminal. Cualquier otra cosa es una solución alternativa. Como beneficio adicional, cuando entra el jefe y / o el socio y, sin darse cuenta, ctrl-w / cmd-w su ventana de terminal en lugar de la ventana de su navegador con su contenido dudoso, no habrá perdido las últimas 18 horas de procesamiento !

Los programas escritos en otros lenguajes (por ejemplo, C) tienen que hacer magia especial (llamada doble bifurcación) expresamente para desconectarse de la terminal (y para evitar procesos zombis). Entonces, creo que la mejor solución es emularlos.

Una ventaja adicional de volver a ejecutar su programa es que puede elegir redirecciones en la línea de comandos, p. Ej. /usr/bin/python mycoolscript.py 2>&1 1>/dev/null

Consulte esta publicación para obtener más información: ¿Cuál es la razón para realizar una doble bifurcación al crear un demonio?