Vô hiệu hóa bộ đệm đầu ra

Bộ đệm đầu ra có được bật theo mặc định trong trình thông dịch của Python sys.stdoutkhông?

Nếu câu trả lời là tích cực, tất cả các cách để vô hiệu hóa nó là gì?

Gợi ý cho đến nay:

1. Sử dụng -uchuyển đổi dòng lệnh
2. Bọc sys.stdouttrong một đối tượng tuôn ra sau mỗi lần viết
3. Đặt PYTHONUNBUFFEREDenv var
4. sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)

Có cách nào khác để đặt một số cờ toàn cầu trong sys/ sys.stdoutlập trình trong khi thực hiện không?

Từ câu trả lời của Magnus Lycka trong danh sách gửi thư :

Bạn có thể bỏ qua việc đệm cho toàn bộ quá trình python bằng cách sử dụng "python -u" (hoặc #! / Usr / bin / env python -u, v.v.) hoặc bằng cách đặt biến môi trường PYTHONUNBUFFERED.

Bạn cũng có thể thay thế sys.stdout bằng một số luồng khác như trình bao bọc sẽ thực hiện sau mỗi cuộc gọi.

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'

Tôi muốn đặt câu trả lời của tôi trong Làm thế nào để tuôn ra đầu ra của chức năng in? hoặc trong chức năng in của Python để xóa bộ đệm khi nó được gọi? , nhưng vì chúng được đánh dấu là bản sao của cái này (những gì tôi không đồng ý), tôi sẽ trả lời nó ở đây.

Vì Python 3.3, print () hỗ trợ đối số từ khóa "flush" ( xem tài liệu ):

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)

Tín dụng: "Sebastian", ở đâu đó trong danh sách gửi thư của Python.

Vâng, đúng vậy.

Bạn có thể vô hiệu hóa nó trên dòng lệnh bằng công tắc "-u".

Ngoài ra, bạn có thể gọi .flush () trên sys.stdout trên mỗi lần ghi (hoặc bọc nó bằng một đối tượng thực hiện điều này tự động)

Điều này liên quan đến câu trả lời của Cristóvão D. Sousa, nhưng tôi chưa thể bình luận.

Một cách đơn giản để sử dụng flushđối số từ khóa của Python 3 để luôn có đầu ra không có bộ đệm là:

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

sau đó, in sẽ luôn xả trực tiếp đầu ra (ngoại trừ flush=Falseđược đưa ra).

Lưu ý, (a) rằng điều này chỉ trả lời một phần vì nó không chuyển hướng tất cả đầu ra. Nhưng tôi đoán printlà cách phổ biến nhất để tạo đầu ra stdout/ stderrtrong python, vì vậy 2 dòng này có thể bao gồm hầu hết các trường hợp sử dụng.

Lưu ý (b) rằng nó chỉ hoạt động trong mô-đun / tập lệnh mà bạn đã xác định nó. Điều này có thể tốt khi viết một mô-đun vì nó không gây rối với sys.stdout.

Python 2 không cung cấp flushđối số, nhưng bạn có thể mô phỏng hàm 3 loại Python printnhư được mô tả ở đây 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"])

Nếu không lưu sys.stdout cũ, vô hiệu hóa_stdout_buffering () không phải là idempotent và nhiều cuộc gọi sẽ dẫn đến một lỗi như thế này:

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

Một khả năng khác là:

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)

(Đăng ký vào gc.garbage không phải là một ý tưởng hay vì đó là nơi đặt các chu kỳ không thể thực hiện được và bạn có thể muốn kiểm tra chúng.)

Các công việc sau đây trong Python 2.6, 2.7 và 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)

Vâng, nó được kích hoạt theo mặc định. Bạn có thể vô hiệu hóa nó bằng cách sử dụng tùy chọn -u trên dòng lệnh khi gọi python.

Bạn cũng có thể chạy Python với tiện ích stdbuf :

stdbuf -oL python <script>

Trong Python 3, bạn có thể vá lỗi chức năng in, để luôn gửi flush = True:

_orig_print = print

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

Như đã chỉ ra trong một nhận xét, bạn có thể đơn giản hóa điều này bằng cách ràng buộc tham số tuôn ra với một giá trị, thông qua functools.partial:

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

Bạn cũng có thể sử dụng fcntl để thay đổi cờ tập tin đang bay.

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)

Có thể ghi đè chỉ write phương thức sys.stdoutvới một cuộc gọi flush. Đề xuất thực hiện phương pháp dưới đây.

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

Giá trị mặc định của wđối số sẽ giữ writetham chiếu phương thức ban đầu . Sau khi write_flush được xác định, bản gốc writecó thể bị ghi đè.

stdout.write = write_flush

Mã giả định stdoutđược nhập theo cách này from sys import stdout.

Bạn có thể tạo một tệp không có bộ đệm và gán tệp này cho sys.stdout.

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

Bạn không thể thay đổi một cách kỳ diệu các thiết bị xuất chuẩn do hệ thống cung cấp; do hệ điều hành cung cấp cho chương trình python của bạn.

Biến thể hoạt động mà không gặp sự cố (ít nhất là trên win32; python 2.7, ipython 0.12) sau đó được gọi sau đó (nhiều lần):

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)

(Tôi đã đăng một bình luận, nhưng nó đã bị mất bằng cách nào đó. Vì vậy, một lần nữa :)

1. Như tôi nhận thấy, CPython (ít nhất là trên Linux) hoạt động khác nhau tùy thuộc vào nơi đầu ra đi. Nếu nó đi đến một tty, thì đầu ra sẽ bị xóa sau mỗi ' \n'
   Nếu nó đi vào một đường ống / quy trình, thì nó được đệm và bạn có thể sử dụng các flush()giải pháp dựa trên hoặc tùy chọn -u được đề xuất ở trên.

2. Liên quan một chút đến bộ đệm đầu ra:
   Nếu bạn lặp qua các dòng trong đầu vào với

   for line in sys.stdin:
   ...

sau đó, việc thực hiện trong CPython sẽ thu thập đầu vào trong một thời gian và sau đó thực thi thân vòng lặp cho một loạt các dòng đầu vào. Nếu tập lệnh của bạn chuẩn bị ghi đầu ra cho mỗi dòng đầu vào, thì tập lệnh này có thể trông giống như bộ đệm đầu ra nhưng thực tế nó đang tạo khối, và do đó, không có flush()kỹ thuật nào, v.v. sẽ giúp điều đó. Thật thú vị, bạn không có hành vi này trong pypy . Để tránh điều này, bạn có thể sử dụng

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

Một cách để có được đầu ra không có bộ đệm sẽ là sử dụng sys.stderrthay vì sys.stdouthoặc chỉ đơn giản gọi sys.stdout.flush()để rõ ràng buộc phải ghi.

Bạn có thể dễ dàng chuyển hướng mọi thứ được in bằng cách thực hiện:

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

Hoặc để chuyển hướng chỉ cho một printtuyên bố cụ thể :

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

Để thiết lập lại thiết bị xuất chuẩn, bạn chỉ cần làm:

sys.stdout = sys.__stdout__