Как предотвратить BrokenPipeError при сбросе в Python?

BrokenPipeError является нормальным, как упомянутый фантом, потому что процесс чтения (голова) завершается и закрывает свой конец канала, в то время как процесс записи (python) все еще пытается писать.

является ненормальным состоянием, и скрипты Python получают BrokenPipeError — точнее, интерпретатор Python получает системный сигнал SIGPIPE, который он перехватывает и поднимает BrokenPipeError, чтобы скрипт мог обработать ошибку.

И вы эффективно можете обработать ошибку, потому что в вашем последнем примере вы видите только сообщение о том, что исключение было проигнорировано — хорошо, это неправда, но похоже, что это связано с этим открытая проблема в Python: разработчики Python считают важным предупредить пользователя о ненормальном состоянии.

Что на самом деле происходит, так это то, что интерпретатор python всегда сигнализирует об этом на stderr, даже если вы поймаете исключение. Но вам просто нужно закрыть stderr перед выходом, чтобы избавиться от сообщения.

Я немного изменил ваш скрипт на:

• поймать ошибку, как в последнем примере
• поймать либо IOError (которую я получаю в Python34 на Windows64), либо BrokenPipeError (в Python 33 на FreeBSD 9.0) — и отобразить сообщение для этого
• отображать пользовательское сообщение Done на стандартном потоке (stdout закрыт из-за поломки конвейера)
• закройте stderr перед выходом, чтобы избавиться от сообщения

Вот скрипт, который я использовал:

import sys

try:
    for i in range(4000):
            print(i, flush=True)
except (BrokenPipeError, IOError):
    print ('BrokenPipeError caught', file = sys.stderr)

print ('Done', file=sys.stderr)
sys.stderr.close()

и вот результат python3.3 pipe.py | head -10 :

0
1
2
3
4
5
6
7
8
9
BrokenPipeError caught
Done

Если вы не хотите, чтобы посторонние сообщения просто использовали:

import sys

try:
    for i in range(4000):
            print(i, flush=True)
except (BrokenPipeError, IOError):
    pass

sys.stderr.close()

примечание к SIGPIPE было добавлен в документацию Python 3.7, и он рекомендует поймать BrokenPipeError следующим образом:

import os
import sys

def main():
    try:
        # simulate large output (your code replaces this loop)
        for x in range(10000):
            print("y")
        # flush output here to force SIGPIPE to be triggered
        # while inside this try block.
        sys.stdout.flush()
    except BrokenPipeError:
        # Python flushes standard streams on exit; redirect remaining output
        # to devnull to avoid another BrokenPipeError at shutdown
        devnull = os.open(os.devnull, os.O_WRONLY)
        os.dup2(devnull, sys.stdout.fileno())
        sys.exit(1)  # Python exits with error code 1 on EPIPE

if __name__ == '__main__':
    main()

Главное, там написано:

Не устанавливайте расположение SIGPIPE на SIG_DFL, чтобы избежать BrokenPipeError. Это приведет к неожиданному выходу вашей программы также всякий раз, когда любое соединение сокета прерывается, пока ваша программа все еще записывает в него.

Согласно документации Python, это вызывается, когда:

пытаюсь писать на трубе, пока другой конец закрыт

Это связано с тем, что утилита head читает из stdout, затем быстро закрывает его.

Как видите, это можно обойти, просто добавив sys.stdout.flush() после каждого print(). Обратите внимание, что иногда это не работает в Python 3.

В качестве альтернативы вы можете подключить его к awk, чтобы получить тот же результат, что и head -3:

python3 0to3.py | awk 'NR >= 4 {exit} 1'

Надеюсь, это помогло, удачи!

Временно игнорировать SIGPPIE

Я не уверен, насколько это плохая идея, но она работает:

#!/usr/bin/env python3

import signal
import sys

sigpipe_old = signal.getsignal(signal.SIGPIPE)
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
for i in range(4000):
    print(i, flush=True)
signal.signal(signal.SIGPIPE, sigpipe_old)

Мне часто хотелось, чтобы в командной строке не было опции для подавления этих обработчиков сигналов.

import signal

# Don't turn these signal into exceptions, just die.
signal.signal(signal.SIGINT, signal.SIG_DFL)
signal.signal(signal.SIGPIPE, signal.SIG_DFL)

Вместо этого лучшее, что мы можем сделать, это удалить обработчики как можно скорее, как только скрипт Python запустится.

Как вы можете видеть в опубликованном вами выводе, последнее исключение возникает на этапе деструктора: поэтому у вас есть ignored в конце

Exception BrokenPipeError: BrokenPipeError(32, 'Broken pipe') in <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'> ignored

Простой пример, чтобы понять, что происходит в этом контексте, следующий:

>> class A():
...     def __del__(self):
...         raise Exception("It will be ignored!!!")
... 
>>> a = A()
>>> del a
Exception Exception: Exception('It will be ignored!!!',) in <bound method A.__del__ of <__builtin__.A instance at 0x7ff1d5c06d88>> ignored
>>> a = A()
>>> import sys
>>> sys.stderr.close()
>>> del a

Каждое исключение, которое запускается во время уничтожения объекта, вызовет стандартный вывод ошибки, который объясняет, что исключение произошло и проигнорировано (это потому, что python сообщит вам, что что-то не может быть правильно обработано на этапе уничтожения). В любом случае, такого рода исключения не могут быть кэшированы, поэтому вы можете просто удалить вызовы, которые могут их генерировать, или закрыть stderr.

Вернитесь к вопросу. Это исключение не является реальной проблемой (как говорят, оно игнорируется), но если вы не хотите его печатать, вы должны переопределить функцию, которая может быть вызвана, когда объект будет уничтожен или закрыт stderr, как правильно предложил @SergeBallesta: в вас В этом случае вы можете отключить функции write и flush, и в контексте уничтожения не будет инициировано исключение.

Это пример того, как вы можете это сделать:

import sys
def _void_f(*args,**kwargs):
    pass

for i in range(4000):
    try:
        print(i,flush=True)
    except (BrokenPipeError, IOError):
        sys.stdout.write = _void_f
        sys.stdout.flush = _void_f
        sys.exit()

В то время как другие очень подробно рассмотрели основную проблему, существует простой обходной путь:

python whatever.py | tail -n +1 | head -n3000

Объяснение: tail буферизируется до тех пор, пока его STDIN не будет закрыт (python завершает работу и закрывает свой STDOUT). Таким образом, только хвост получает SIGPIPE, когда голова уходит. -n +1 фактически является неоперативным, заставляя tail выводить «хвост», начиная со строки 1, которая представляет собой весь буфер.