ปิดใช้งานการบัฟเฟอร์เอาต์พุต

การส่งออกบัฟเฟอร์เปิดใช้งานโดยค่าเริ่มต้นในตัวแปลของ Python ไว้sys.stdoutหรือไม่

หากคำตอบเป็นบวกทุกวิธีที่จะปิดการใช้งานคืออะไร?

คำแนะนำจนถึง:

1. ใช้-uสวิตช์บรรทัดคำสั่ง
2. ห่อsys.stdoutในวัตถุที่วูบวาบหลังจากการเขียนทุกครั้ง
3. ตั้งค่าPYTHONUNBUFFEREDenv
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

มีวิธีอื่นในการตั้งค่าสถานะโกลบอลบางรายการในsys/ โดยทางsys.stdoutโปรแกรมในระหว่างการดำเนินการหรือไม่?

จากคำตอบของ Magnus Lycka ในรายชื่อผู้รับจดหมาย :

คุณสามารถข้ามการบัฟเฟอร์สำหรับกระบวนการ python ทั้งหมดโดยใช้ "python -u" (หรือ #! / usr / bin / env python -u ฯลฯ ) หรือโดยการตั้งค่าตัวแปรสภาพแวดล้อม PYTHONUNBUFFERED

คุณยังสามารถแทนที่ sys.stdout ด้วยสตรีมอื่น ๆ เช่น wrapper ซึ่งจะล้างข้อมูลหลังจากการโทรทุกครั้ง

class Unbuffered(object):
   def __init__(self, stream):
       self.stream = stream
   def write(self, data):
       self.stream.write(data)
       self.stream.flush()
   def writelines(self, datas):
       self.stream.writelines(datas)
       self.stream.flush()
   def __getattr__(self, attr):
       return getattr(self.stream, attr)

import sys
sys.stdout = Unbuffered(sys.stdout)
print 'Hello'

ฉันอยากจะใส่คำตอบของฉันในวิธีการล้างผลลัพธ์ของฟังก์ชั่นการพิมพ์? หรือในฟังก์ชั่นการพิมพ์ Python ที่ล้างบัฟเฟอร์เมื่อมันถูกเรียก? แต่เนื่องจากพวกเขาถูกทำเครื่องหมายว่าซ้ำซ้อนของอันนี้ (สิ่งที่ฉันไม่เห็นด้วย) ฉันจะตอบมันที่นี่

เนื่องจาก Python 3.3 พิมพ์ () สนับสนุนอาร์กิวเมนต์คำหลัก "flush" ( ดูเอกสารประกอบ ):

print('Hello World!', flush=True)

# reopen stdout file descriptor with write mode
# and 0 as the buffer size (unbuffered)
import io, os, sys
try:
    # Python 3, open as binary, then wrap in a TextIOWrapper with write-through.
    sys.stdout = io.TextIOWrapper(open(sys.stdout.fileno(), 'wb', 0), write_through=True)
    # If flushing on newlines is sufficient, as of 3.7 you can instead just call:
    # sys.stdout.reconfigure(line_buffering=True)
except TypeError:
    # Python 2
    sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

เครดิต: "เซบาสเตียน" บางแห่งในรายชื่อผู้รับจดหมายของ Python

ใช่แล้ว.

คุณสามารถปิดการใช้งานมันบน commandline ด้วยสวิตช์ "-u"

อีกวิธีหนึ่งคือคุณสามารถเรียก. flush () บน sys.stdout ในทุก ๆ การเขียน (หรือล้อมด้วยวัตถุที่ทำสิ่งนี้โดยอัตโนมัติ)

สิ่งนี้เกี่ยวข้องกับคำตอบของCristóvão D. Sousa แต่ฉันยังไม่สามารถแสดงความคิดเห็นได้

วิธีที่ตรงไปข้างหน้าของการใช้flushอาร์กิวเมนต์คำหลักของงูหลาม 3เพื่อที่จะมักจะมีการส่งออก unbuffered คือ:

import functools
print = functools.partial(print, flush=True)

หลังจากนั้นการพิมพ์จะล้างข้อมูลโดยตรงเสมอ (ยกเว้นflush=Falseจะได้รับ)

โปรดทราบว่า (a) คำถามนี้ตอบคำถามเพียงบางส่วนเท่านั้นเนื่องจากไม่ได้เปลี่ยนทิศทางเอาต์พุตทั้งหมด แต่ฉันเดาว่าprintเป็นวิธีที่ใช้กันมากที่สุดในการสร้างเอาต์พุตไปยังstdout/ stderrในไพ ธ อนดังนั้น 2 บรรทัดนี้จึงครอบคลุมกรณีการใช้งานส่วนใหญ่

หมายเหตุ (b) ใช้งานได้เฉพาะในโมดูล / สคริปต์ที่คุณกำหนดไว้เท่านั้น sys.stdoutนี้สามารถที่ดีเมื่อเขียนโมดูลเป็นก็ไม่ได้ยุ่งกับ

งูหลาม 2ไม่ได้ให้flushการโต้แย้ง แต่คุณสามารถเลียนแบบงูหลาม 3 ประเภทprintฟังก์ชั่นตามที่อธิบายไว้ที่นี่https://stackoverflow.com/a/27991478/3734258

def disable_stdout_buffering():
    # Appending to gc.garbage is a way to stop an object from being
    # destroyed.  If the old sys.stdout is ever collected, it will
    # close() stdout, which is not good.
    gc.garbage.append(sys.stdout)
    sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

# Then this will give output in the correct order:
disable_stdout_buffering()
print "hello"
subprocess.call(["echo", "bye"])

หากไม่บันทึก sys.stdout เก่า ๆ disable_stdout_buffering () ไม่ใช่ idempotent และการโทรหลายครั้งจะทำให้เกิดข้อผิดพลาดดังนี้:

Traceback (most recent call last):
  File "test/buffering.py", line 17, in <module>
    print "hello"
IOError: [Errno 9] Bad file descriptor
close failed: [Errno 9] Bad file descriptor

ความเป็นไปได้อีกอย่างคือ:

def disable_stdout_buffering():
    fileno = sys.stdout.fileno()
    temp_fd = os.dup(fileno)
    sys.stdout.close()
    os.dup2(temp_fd, fileno)
    os.close(temp_fd)
    sys.stdout = os.fdopen(fileno, "w", 0)

(การผนวกกับ gc.garbage นั้นไม่ใช่ความคิดที่ดีเพราะเป็นที่ที่วงจรไม่เป็นระเบียบและคุณอาจต้องการตรวจสอบสิ่งเหล่านั้น)

การทำงานต่อไปนี้ใน Python 2.6, 2.7 และ 3.2:

import os
import sys
buf_arg = 0
if sys.version_info[0] == 3:
    os.environ['PYTHONUNBUFFERED'] = '1'
    buf_arg = 1
sys.stdout = os.fdopen(sys.stdout.fileno(), 'a+', buf_arg)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'a+', buf_arg)

ใช่มันถูกเปิดใช้งานโดยค่าเริ่มต้น คุณสามารถปิดการใช้งานได้โดยใช้ตัวเลือก -u บนบรรทัดคำสั่งเมื่อเรียก python

คุณสามารถรัน Python ด้วยยูทิลิตี้stdbuf :

stdbuf -oL python <script>

ใน Python 3 คุณสามารถ monkey-patch ฟังก์ชั่นการพิมพ์เพื่อส่ง flush = True:

_orig_print = print

def print(*args, **kwargs):
    _orig_print(*args, flush=True, **kwargs)

ตามที่ระบุไว้ในความคิดเห็นคุณสามารถทำให้สิ่งนี้ง่ายขึ้นโดยการผูกพารามิเตอร์ flush กับค่าผ่านfunctools.partial:

print = functools.partial(print, flush=True)

คุณยังสามารถใช้ fcntl เพื่อเปลี่ยนแฟล็กไฟล์ในทันที

fl = fcntl.fcntl(fd.fileno(), fcntl.F_GETFL)
fl |= os.O_SYNC # or os.O_DSYNC (if you don't care the file timestamp updates)
fcntl.fcntl(fd.fileno(), fcntl.F_SETFL, fl)

มันเป็นไปได้ที่จะแทนที่เพียง writeวิธีการกับคนที่โทรsys.stdout flushวิธีการใช้งานที่แนะนำอยู่ด้านล่าง

def write_flush(args, w=stdout.write):
    w(args)
    stdout.flush()

ค่าเริ่มต้นของการwโต้แย้งจะเก็บwriteวิธีการอ้างอิงเดิม หลังจาก write_flushมีการกำหนดต้นฉบับwriteอาจถูกเขียนทับ

stdout.write = write_flush

รหัสจะถือว่าstdoutมีการนำเข้าด้วยวิธีfrom sys import stdoutนี้

คุณสามารถสร้างไฟล์ที่ไม่มีบัฟเฟอร์และกำหนดไฟล์นี้ให้กับ sys.stdout

import sys 
myFile= open( "a.log", "w", 0 ) 
sys.stdout= myFile

คุณไม่สามารถเปลี่ยน stdout ที่ระบบจัดหาได้อย่างน่าอัศจรรย์ เนื่องจากมันถูกส่งไปยังโปรแกรม python ของคุณโดยระบบปฏิบัติการ

ตัวแปรที่ทำงานโดยไม่หยุดทำงาน (อย่างน้อยใน win32; python 2.7, ipython 0.12) จากนั้นเรียกใช้ในภายหลัง (หลายครั้ง):

def DisOutBuffering():
    if sys.stdout.name == '<stdout>':
        sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

    if sys.stderr.name == '<stderr>':
        sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 0)

(ฉันได้โพสต์ความคิดเห็น แต่มันก็หายไปอย่างนั้นอีกครั้ง :)

1. ตามที่ฉันสังเกตเห็น CPython (อย่างน้อยบน Linux) จะทำงานแตกต่างกันไปขึ้นอยู่กับตำแหน่งที่ส่งออก หากไปที่ tty เอาต์พุตจะถูกล้างออกหลังจากแต่ละ ' \n'
   หากไปยังไพพ์ / กระบวนการก็จะถูกบัฟเฟอร์และคุณสามารถใช้flush()โซลูชันพื้นฐานหรือตัวเลือก-u ที่แนะนำข้างต้น

2. เกี่ยวข้องเล็กน้อยกับการบัฟเฟอร์เอาต์พุต:
   หากคุณวนซ้ำบรรทัดในอินพุตด้วย

   for line in sys.stdin:
   ...

ดังนั้นสำหรับการนำไปใช้ในCPythonจะรวบรวมอินพุตชั่วขณะหนึ่งจากนั้นเรียกใช้เนื้อความลูปสำหรับกลุ่มของอินพุตบรรทัด หากสคริปต์ของคุณกำลังจะเขียนเอาต์พุตสำหรับแต่ละบรรทัดอินพุตสิ่งนี้อาจดูเหมือนบัฟเฟอร์เอาต์พุต แต่จริงๆแล้วเป็นการแบ็ตช์และดังนั้นจึงไม่มีflush()เทคนิคและอื่น ๆ ที่จะช่วยได้ ที่น่าสนใจที่คุณไม่ได้มีพฤติกรรมในpypy เพื่อหลีกเลี่ยงปัญหานี้คุณสามารถใช้

while True: line=sys.stdin.readline()
...

วิธีหนึ่งในการรับเอาต์พุตที่ไม่มีบัฟเฟอร์จะใช้sys.stderrแทนsys.stdoutหรือเพียงแค่เรียกsys.stdout.flush()เพื่อบังคับให้เขียนอย่างชัดเจน

คุณสามารถเปลี่ยนเส้นทางทุกอย่างที่พิมพ์โดยทำอย่างง่ายดาย:

import sys; sys.stdout = sys.stderr
print "Hello World!"

หรือเปลี่ยนเส้นทางสำหรับข้อความเฉพาะprint:

print >>sys.stderr, "Hello World!"

หากต้องการรีเซ็ต stdout คุณสามารถทำได้:

sys.stdout = sys.__stdout__