¿Cómo manejar tanto `with open (...)` como `sys.stdout` correctamente?

A menudo necesito enviar datos a un archivo o, si el archivo no está especificado, a la salida estándar. Utilizo el siguiente fragmento:

if target:
    with open(target, 'w') as h:
        h.write(content)
else:
    sys.stdout.write(content)

Me gustaría reescribirlo y manejar ambos objetivos de manera uniforme.

En el caso ideal sería:

with open(target, 'w') as h:
    h.write(content)

pero esto no funcionará bien porque sys.stdout se cierra al salir del withbloque y no quiero eso. Yo tampoco quiero

stdout = open(target, 'w')
...

porque necesitaría recordar restaurar la salida estándar original.

Relacionado:

• ¿Redirigir stdout a un archivo en Python?
• Manejo de excepciones : artículo interesante sobre el manejo de excepciones en Python, en comparación con C ++

Editar

Sé que puedo ajustar target, definir una función separada o usar el administrador de contexto . Busco una solución sencilla, elegante e idiomática que no requiera más de 5 líneas.

Solo pensando fuera de la caja aquí, ¿qué tal un open()método personalizado ?

import sys
import contextlib

@contextlib.contextmanager
def smart_open(filename=None):
    if filename and filename != '-':
        fh = open(filename, 'w')
    else:
        fh = sys.stdout

    try:
        yield fh
    finally:
        if fh is not sys.stdout:
            fh.close()

Úselo así:

# For Python 2 you need this line
from __future__ import print_function

# writes to some_file
with smart_open('some_file') as fh:
    print('some output', file=fh)

# writes to stdout
with smart_open() as fh:
    print('some output', file=fh)

# writes to stdout
with smart_open('-') as fh:
    print('some output', file=fh)

Cíñete a tu código actual. Es simple y puedes saber exactamente lo que está haciendo con solo mirarlo.

Otra forma sería con una línea if:

handle = open(target, 'w') if target else sys.stdout
handle.write(content)

if handle is not sys.stdout:
    handle.close()

Pero eso no es mucho más corto de lo que tienes y posiblemente se ve peor.

También podría hacer sys.stdoutque no se pueda cerrar, pero eso no parece demasiado Pythonic:

sys.stdout.close = lambda: None

with (open(target, 'w') if target else sys.stdout) as handle:
    handle.write(content)

¿Por qué LBYL cuando puede EAFP?

try:
    with open(target, 'w') as h:
        h.write(content)
except TypeError:
    sys.stdout.write(content)

¿Por qué reescribirlo para usar el bloque with/ asuniformemente cuando tienes que hacerlo funcionar de una manera complicada? Agregará más líneas y reducirá el rendimiento.

Otra posible solución: no intente evitar el método de salida del administrador de contexto, simplemente duplique stdout.

with (os.fdopen(os.dup(sys.stdout.fileno()), 'w')
      if target == '-'
      else open(target, 'w')) as f:
      f.write("Foo")

Una mejora de la respuesta de Wolph.

import sys
import contextlib

@contextlib.contextmanager
def smart_open(filename: str, mode: str = 'r', *args, **kwargs):
    '''Open files and i/o streams transparently.'''
    if filename == '-':
        if 'r' in mode:
            stream = sys.stdin
        else:
            stream = sys.stdout
        if 'b' in mode:
            fh = stream.buffer  # type: IO
        else:
            fh = stream
        close = False
    else:
        fh = open(filename, mode, *args, **kwargs)
        close = True

    try:
        yield fh
    finally:
        if close:
            try:
                fh.close()
            except AttributeError:
                pass

Esto permite IO binario y pasar eventuales argumentos extraños a opensi de filenamehecho es un nombre de archivo.

También optaría por una función contenedora simple, que puede ser bastante simple si puede ignorar el modo (y, en consecuencia, stdin vs stdout), por ejemplo:

from contextlib import contextmanager
import sys

@contextmanager
def open_or_stdout(filename):
    if filename != '-':
        with open(filename, 'w') as f:
            yield f
    else:
        yield sys.stdout

De acuerdo, si nos estamos metiendo en guerras de una sola línea, aquí está:

(target and open(target, 'w') or sys.stdout).write(content)

Me gusta el ejemplo original de Jacob siempre y cuando el contexto esté escrito en un solo lugar. Sería un problema si vuelve a abrir el archivo para muchas escrituras. Creo que simplemente tomaría la decisión una vez en la parte superior del script y dejaría que el sistema cierre el archivo al salir:

output = target and open(target, 'w') or sys.stdout
...
output.write('thing one\n')
...
output.write('thing two\n')

Podría incluir su propio controlador de salida si cree que es más ordenado

import atexit

def cleanup_output():
    global output
    if output is not sys.stdout:
        output.close()

atexit(cleanup_output)

Si realmente debes insistir en algo más "elegante", es decir, una frase:

>>> import sys
>>> target = "foo.txt"
>>> content = "foo"
>>> (lambda target, content: (lambda target, content: filter(lambda h: not h.write(content), (target,))[0].close())(open(target, 'w'), content) if target else sys.stdout.write(content))(target, content)

foo.txtaparece y contiene el texto foo.

¿Qué tal abrir un nuevo fd para sys.stdout? De esta forma no tendrás problemas para cerrarlo:

if not target:
    target = "/dev/stdout"
with open(target, 'w') as f:
    f.write(content)

if (out != sys.stdout):
    with open(out, 'wb') as f:
        f.write(data)
else:
    out.write(data)

Ligera mejora en algunos casos.

import contextlib
import sys

with contextlib.ExitStack() as stack:
    h = stack.enter_context(open(target, 'w')) if target else sys.stdout
    h.write(content)

Solo dos líneas adicionales si usa Python 3.3 o superior: una línea para el extra importy una línea para el stack.enter_context.

Si está bien que sys.stdoutesté cerrado después del withcuerpo, también puede usar patrones como este:

# Use stdout when target is "-"
with open(target, "w") if target != "-" else sys.stdout as f:
    f.write("hello world")

# Use stdout when target is falsy (None, empty string, ...)
with open(target, "w") if target else sys.stdout as f:
    f.write("hello world")

o incluso más en general:

with target if isinstance(target, io.IOBase) else open(target, "w") as f:
    f.write("hello world")