Redirect stdout ke file dengan Python?

Bagaimana cara mengarahkan stdout ke file sewenang-wenang dengan Python?

Ketika skrip Python yang berjalan lama (misalnya, aplikasi web) dimulai dari dalam sesi ssh dan backgounded, dan sesi ssh ditutup, aplikasi akan menaikkan IOError dan gagal saat mencoba menulis ke stdout. Saya perlu menemukan cara untuk membuat aplikasi dan modul keluaran ke file daripada stdout untuk mencegah kegagalan karena IOError. Saat ini, saya menggunakan nohup untuk mengarahkan output ke file, dan itu menyelesaikan pekerjaan, tetapi saya bertanya-tanya apakah ada cara untuk melakukannya tanpa menggunakan nohup, karena penasaran.

Saya sudah mencoba sys.stdout = open('somefile', 'w'), tetapi ini tampaknya tidak mencegah beberapa modul eksternal dari masih keluaran ke terminal (atau mungkin sys.stdout = ...garis tidak menyala sama sekali). Saya tahu itu harus bekerja dari skrip sederhana yang telah saya uji, tetapi saya juga belum punya waktu untuk menguji pada aplikasi web.

Jika Anda ingin melakukan pengalihan dalam skrip Python, pengaturan sys.stdoutke objek file melakukan trik:

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

Metode yang jauh lebih umum adalah dengan menggunakan pengalihan shell ketika menjalankan (sama pada Windows dan Linux):

$ python foo.py > file

Ada contextlib.redirect_stdout()fungsi dalam 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`')

Ini mirip dengan:

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

yang dapat digunakan pada versi Python sebelumnya. Versi terakhir tidak dapat digunakan kembali . Itu bisa dibuat satu jika diinginkan.

Itu tidak mengarahkan stdout di tingkat deskriptor file misalnya:

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'dan 'echo this also is not redirected'tidak diarahkan ke output.txtfile.

Untuk mengarahkan ulang di tingkat deskriptor file, os.dup2()dapat digunakan:

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

Contoh yang sama berfungsi sekarang jika stdout_redirected()digunakan alih-alih 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')

Output yang sebelumnya dicetak pada stdout sekarang pergi output.txtselama stdout_redirected()manajer konteks aktif.

Catatan: stdout.flush()tidak menyiram buffer C stdio di Python 3 di mana I / O diimplementasikan langsung pada read()/ write()system calls. Untuk menyiram semua aliran output C stdio yang terbuka, Anda dapat memanggil libc.fflush(None)secara eksplisit jika beberapa ekstensi C menggunakan I / O berbasis 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

Anda bisa menggunakan stdoutparameter untuk mengarahkan aliran lain, tidak hanya sys.stdoutmis., Untuk menggabungkan sys.stderrdan sys.stdout:

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

Contoh:

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)

Catatan: stdout_redirected()mencampur I / O buffer ( sys.stdoutbiasanya) dan I / O unbuffered (operasi pada deskriptor file secara langsung). Hati-hati, mungkin ada masalah buffering .

Untuk menjawab, hasil edit Anda: Anda dapat menggunakan python-daemonuntuk daemonisasi skrip Anda dan menggunakan loggingmodul (seperti yang disarankan @ erikb85 ) alih-alih printpernyataan dan hanya mengarahkan stdout untuk skrip Python Anda yang sudah berjalan lama yang Anda jalankan gunakan nohupsekarang.

Anda dapat mencoba ini jauh lebih baik

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

Jawaban lain tidak mencakup kasus di mana Anda ingin proses bercabang untuk berbagi stdout baru Anda.

Untuk melakukannya:

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

Dikutip dari PEP 343 - Pernyataan "with" (pernyataan impor ditambahkan):

Redirect stdout sementara:

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

Digunakan sebagai berikut:

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

Ini bukan thread-safe, tentu saja, tetapi tidak ada yang melakukan tarian yang sama ini secara manual. Dalam program single-threaded (misalnya dalam skrip) ini adalah cara populer untuk melakukan sesuatu.

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

Berikut adalah variasi jawaban Yuda Prawira :

• mengimplementasikan flush()dan semua atribut file
• tulis sebagai manajer konteks
• tangkap stderrjuga

.

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())

Berdasarkan jawaban ini: https://stackoverflow.com/a/5916874/1060344 , berikut adalah cara lain yang saya tahu yang saya gunakan di salah satu proyek saya. Untuk apa pun yang Anda ganti sys.stderratau sys.stdoutdengan, Anda harus memastikan bahwa penggantian sesuai dengan fileantarmuka, terutama jika ini adalah sesuatu yang Anda lakukan karena stderr / stdout digunakan di beberapa perpustakaan lain yang tidak di bawah kendali Anda. Perpustakaan itu mungkin menggunakan metode lain dari objek file.

Lihat cara ini di mana saya masih membiarkan semuanya berjalan stderr / stdout (atau file apa pun dalam hal ini) dan juga mengirim pesan ke file log menggunakan fasilitas logging Python (tetapi Anda benar-benar dapat melakukan apa pun dengan ini):

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)

Anda memerlukan terminal multiplexer seperti tmux atau layar GNU

Saya terkejut bahwa komentar kecil oleh Ryan Amos 'untuk pertanyaan asli adalah satu-satunya penyebutan solusi yang jauh lebih disukai daripada yang lain yang ditawarkan, tidak peduli seberapa pintar tipu muslihat python dan berapa banyak upvotes yang telah mereka terima. Lebih jauh dari komentar Ryan, tmux adalah alternatif yang bagus untuk layar GNU.

Tetapi prinsipnya sama: jika Anda mendapati diri Anda ingin meninggalkan pekerjaan terminal yang sedang berjalan saat Anda log-out, pergilah ke kafe untuk makan sandwich, mampir ke kamar mandi, pulang ke rumah (dll) dan kemudian, sambungkan kembali ke Anda sesi terminal dari mana saja atau komputer manapun seolah-olah Anda tidak pernah pergi, multiplexer terminal adalah yang jawabannya. Anggap mereka sebagai VNC atau desktop jarak jauh untuk sesi terminal. Yang lainnya adalah solusi. Sebagai bonus, ketika bos dan / atau mitra masuk dan Anda secara tidak sengaja ctrl-w / cmd-w jendela terminal Anda alih-alih jendela browser Anda dengan konten yang cerdik, Anda tidak akan kehilangan pemrosesan selama 18 jam terakhir yang bernilai !

Program yang ditulis dalam bahasa lain (misalnya C) harus melakukan sihir khusus (disebut forking ganda) secara tegas untuk melepaskan diri dari terminal (dan untuk mencegah proses zombie). Jadi, saya pikir solusi terbaik adalah meniru mereka.

Kelebihan dari menjalankan kembali program Anda adalah, Anda dapat memilih pengalihan pada baris perintah, misalnya /usr/bin/python mycoolscript.py 2>&1 1>/dev/null

Lihat posting ini untuk info lebih lanjut: Apa alasan melakukan garpu ganda saat membuat daemon?