Stdout'u Python'daki bir dosyaya yönlendirilsin mi?

Stdout'u Python'daki rastgele bir dosyaya nasıl yeniden yönlendirebilirim?

Ssh oturumundan uzun süredir çalışan bir Python betiği (örn. Web uygulaması) başlatıldığında ve yedeklendiğinde ve ssh oturumu kapatıldığında, uygulama IOError değerini yükseltir ve stdout'a yazmaya çalıştığı anda başarısız olur. Uygulama ve modüller IOError nedeniyle başarısızlığı önlemek için stdout yerine bir dosyaya çıktı yapmak için bir yol bulmak gerekiyordu. Şu anda çıktıyı bir dosyaya yönlendirmek için nohup kullanıyorum ve bu işi hallediyor, ancak meraktan çıkmadan nohup kullanmadan yapmanın bir yolu olup olmadığını merak ediyordum.

Zaten denedim sys.stdout = open('somefile', 'w'), ama bu hala bazı harici modüller hala çıkış terminali (ya da belki de sys.stdout = ...hattı hiç ateş vermedi) önlemek gibi görünmüyor . Test ettiğim daha basit komut dosyalarından çalışması gerektiğini biliyorum, ancak henüz bir web uygulamasında test etmek için henüz zamanım olmadı.

Python betiği içindeki yeniden yönlendirmeyi yapmak istiyorsanız, sys.stdoutbir dosya nesnesine ayarlamak hile yapar:

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

Çok daha yaygın bir yöntem, yürütme sırasında kabuk yeniden yönlendirmesini kullanmaktır (Windows ve Linux'ta aynıdır):

$ python foo.py > file

Python 3.4'te contextlib.redirect_stdout()fonksiyon var :

from contextlib import redirect_stdout

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

Benzer:

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

önceki Python sürümlerinde kullanılabilir. İkinci sürüm yeniden kullanılamaz . İstenirse yapılabilir.

Stdout'u dosya tanıtıcıları düzeyinde yeniden yönlendirmez, örn:

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've dosyaya 'echo this also is not redirected'yönlendirilmez output.txt.

Dosya tanımlayıcı düzeyinde yeniden yönlendirmek os.dup2()için kullanılabilir:

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

Aynı örnek şunun stdout_redirected()yerine kullanılırsa şimdi çalışır 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')

Daha önce stdout'a yazdırılan çıktı artık bağlam yöneticisi aktif output.txtolduğu sürece devam ediyor stdout_redirected().

Not: stdout.flush()G / Ç'nin doğrudan read()/ write()sistem çağrılarına uygulandığı Python 3'teki C stdio tamponlarını temizlemez . Tüm açık C stdio çıkış akışlarını temizlemek için, libc.fflush(None)bazı C uzantılarında stdio tabanlı G / Ç kullanılıyorsa açıkça çağrı yapabilirsiniz :

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

Sen kullanabilirsiniz stdoutdiğer akışları, sadece yönlendirmek için parametre sys.stdoutbirleştirme örneğin, sys.stderrve sys.stdout:

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

Misal:

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)

Not: stdout_redirected()arabelleğe alınmış G / Ç ( sys.stdoutgenellikle) ve arabelleğe alınmamış G / Ç'yi (doğrudan dosya tanımlayıcılarındaki işlemler) karıştırır. Dikkat edin, arabelleğe alma sorunları olabilir .

Yanıtlamak için, düzenlemenizi kullanın: python-daemonkomut dosyanızı arka plana aktarmak ve ifadeler yerine loggingmodülü ( @ erikb85 önerdiği gibi ) kullanmak printve yalnızca nohupşimdi kullandığınız uzun süredir çalışan Python komut dosyanız için stdout'u yeniden yönlendirmek için kullanabilirsiniz .

bunu çok daha iyi deneyebilirsin

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

Diğer cevaplar, çatallı süreçlerin yeni stdout'unuzu paylaşmasını istediğiniz durumu kapsamıyordu.

Bunu yapmak için:

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

Alıntı sahibi PEP 343 - "with" Deyimi (eklenen ithalat bildirimi):

Stdout'u geçici olarak yeniden yönlendir:

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

Aşağıdaki gibi kullanılır:

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

Bu elbette iş parçacığı için güvenli değildir, ancak ikisi de aynı dansı elle yapmaz. Tek iş parçacıklı programlarda (örneğin komut dosyalarında), bir şeyler yapmanın popüler bir yoludur.

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

İşte Yuda Prawira cevabının bir çeşidi :

• uygulamak flush()ve tüm dosya öznitelikleri
• onu bağlam yöneticisi olarak yaz
• stderrayrıca yakala

.

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

Bu cevaba dayanarak: https://stackoverflow.com/a/5916874/1060344 , projelerimden birinde kullandığım başka bir yol var. Ne değiştirirseniz sys.stderrveya neyle değiştirirseniz değiştirin , özellikle bu yaptığınız bir şeyse sys.stdoutdeğiştirmenin filearayüzle uyumlu olduğundan emin olmalısınız çünkü stderr / stdout kontrolünüz altında olmayan başka bir kütüphanede kullanılır. Bu kütüphane başka dosya nesnesi yöntemleri kullanıyor olabilir.

Ben hala her şeyin stderr / stdout (ya da bu konuda herhangi bir dosya) yapmasına izin vermek ve ayrıca Python günlüğü tesisini kullanarak bir günlük dosyasına mesaj göndermek (ama gerçekten bununla her şeyi yapabilirsiniz) bu şekilde göz atın:

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)

Tmux veya GNU ekran gibi bir terminal çoklayıcısına ihtiyacınız var

Ryan Amos'un orijinal soruya yaptığı küçük bir yorumun, python hilesinin ne kadar akıllı olabileceği ve kaç tane upvotes aldıkları fark etmeksizin, sunulan diğerlerine göre çok tercih edilen bir çözümün tek sözü olması beni şaşırttı. Ryan'ın yorumuna ek olarak, tmux GNU ekranına güzel bir alternatif.

Ancak ilke aynıdır: Oturumu kapatırken bir terminal işini terk etmek istediğinizi düşünüyorsanız, bir sandviç için kafeye gidin, banyoya gidin, eve gidin (vb.) Ve daha sonra tekrar herhangi bir yerden veya herhangi bir bilgisayardan terminal oturumu hiç uzakta olmamış gibi , cevap çoklayıcı terminaller . Bunları terminal oturumları için VNC veya uzak masaüstü olarak düşünün. Başka bir şey geçici bir çözümdür. Bonus olarak, patron ve / veya ortak içeri girdiğinde ve tehlikeli içeriğiyle tarayıcı pencereniz yerine terminal pencerenizi yanlışlıkla ctrl-w / cmd-w yaptığınızda, son 18 saatlik işlem kaybını kaybetmezsiniz !

Diğer dillerde yazılmış programlar (örneğin C) terminalden ayrılmak (ve zombi işlemlerini önlemek için) özel büyü (çift çatal adı verilir) yapmak zorundadır. Bence en iyi çözüm onları taklit etmektir.

Programınızı yeniden çalıştırmanın bir artısı, komut satırında yeniden yönlendirmeler seçebilirsiniz, örn. /usr/bin/python mycoolscript.py 2>&1 1>/dev/null

Daha fazla bilgi için bu gönderiye bakın: Bir daemon oluştururken çift çatal yapmanın nedeni nedir?