Comment gérer à la fois `with open (…)` et `sys.stdout` bien?

Souvent, j'ai besoin de sortir des données dans un fichier ou, si le fichier n'est pas spécifié, dans stdout. J'utilise l'extrait suivant:

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

Je voudrais le réécrire et gérer les deux cibles de manière uniforme.

Dans le cas idéal, ce serait:

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

mais cela ne fonctionnera pas bien car sys.stdout est fermé en quittant le withbloc et je ne le veux pas. Je ne veux pas non plus

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

parce que j'aurais besoin de me rappeler de restaurer la sortie standard d'origine.

En relation:

• Rediriger stdout vers un fichier en Python?
• Handling Exceptions - article intéressant sur la gestion des exceptions en Python, par rapport à C ++

Éditer

Je sais que je peux envelopper target, définir une fonction distincte ou utiliser le gestionnaire de contexte . Je recherche une solution de montage simple, élégante et idiomatique qui ne nécessiterait pas plus de 5 lignes

En sortant des sentiers battus ici, que diriez-vous d'une open()méthode personnalisée ?

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

Utilisez-le comme ceci:

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

Restez fidèle à votre code actuel. C'est simple et vous pouvez dire exactement ce qu'il fait simplement en le regardant.

Une autre façon serait avec un inline if:

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

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

Mais ce n'est pas beaucoup plus court que ce que vous avez et cela semble sans doute pire.

Vous pouvez également rendre sys.stdoutinaccessible, mais cela ne semble pas trop pythonique:

sys.stdout.close = lambda: None

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

Pourquoi LBYL quand vous pouvez EAFP?

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

Pourquoi le réécrire pour utiliser le bloc with/ asuniformément lorsque vous devez le faire fonctionner de manière alambiquée? Vous allez ajouter plus de lignes et réduire les performances.

Autre solution possible: n'essayez pas d'éviter la méthode de sortie du gestionnaire de contexte, dupliquez simplement stdout.

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

Une amélioration de la réponse 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

Cela permet les E / S binaires et de passer d'éventuels arguments superflus à openif filenameest en effet un nom de fichier.

J'opterais également pour une fonction wrapper simple, qui peut être assez simple si vous pouvez ignorer le mode (et par conséquent stdin vs stdout), par exemple:

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

D'accord, si nous nous engageons dans des guerres à une ligne, voici:

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

J'aime l'exemple original de Jacob tant que le contexte n'est écrit qu'à un seul endroit. Ce serait un problème si vous finissez par rouvrir le fichier pour de nombreuses écritures. Je pense que je prendrais simplement la décision une fois en haut du script et laisserais le système fermer le fichier à la sortie:

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

Vous pouvez inclure votre propre gestionnaire de sortie si vous pensez que c'est plus ordonné

import atexit

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

atexit(cleanup_output)

Si vous devez vraiment insister sur quelque chose de plus "élégant", c'est-à-dire un one-liner:

>>> 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.txtapparaît et contient le texte foo.

Que diriez-vous d'ouvrir un nouveau fd pour sys.stdout? De cette façon, vous n'aurez aucun problème à le fermer:

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)

Légère amélioration dans certains cas.

import contextlib
import sys

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

Juste deux lignes supplémentaires si vous utilisez Python 3.3 ou supérieur: une ligne pour le supplément importet une ligne pour le stack.enter_context.

Si c'est bien qui sys.stdoutest fermé après le withcorps, vous pouvez également utiliser des modèles comme celui-ci:

# 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")

ou encore plus généralement:

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