La différence entre sys.stdout.write et print?

Y a-t-il des situations dans lesquelles sys.stdout.write()est préférable print?

( Exemples: meilleures performances; code plus logique)

printest juste un wrapper fin qui formate les entrées (modifiables, mais par défaut avec un espace entre args et newline à la fin) et appelle la fonction d'écriture d'un objet donné. Par défaut, cet objet est sys.stdout, mais vous pouvez passer un fichier en utilisant le formulaire "chevron". Par exemple:

print >> open('file.txt', 'w'), 'Hello', 'World', 2+3

Voir: https://docs.python.org/2/reference/simple_stmts.html?highlight=print#the-print-statement

En Python 3.x, printdevient une fonction, mais il est toujours possible de passer autre chose que sys.stdoutgrâce à l' fileargument.

print('Hello', 'World', 2+3, file=open('file.txt', 'w'))

Voir https://docs.python.org/3/library/functions.html#print

En Python 2.6+, printest toujours une instruction, mais elle peut être utilisée comme une fonction avec

from __future__ import print_function

Mise à jour: Bakuriu a commenté pour souligner qu'il existe une petite différence entre la fonction d'impression et l'instruction d'impression (et plus généralement entre une fonction et une instruction).

En cas d'erreur lors de l'évaluation des arguments:

print "something", 1/0, "other" #prints only something because 1/0 raise an Exception

print("something", 1/0, "other") #doesn't print anything. The function is not called

printconvertit d'abord l'objet en chaîne (s'il ne s'agit pas déjà d'une chaîne). Il mettra également un espace avant l'objet s'il n'est pas le début d'une ligne et un caractère de nouvelle ligne à la fin.

Lors de l'utilisation stdout, vous devez convertir l'objet en chaîne vous-même (en appelant "str", par exemple) et il n'y a pas de caractère de nouvelle ligne.

Donc

print 99

est équivalent à:

import sys
sys.stdout.write(str(99) + '\n')

Ma question est de savoir s'il existe ou non des situations dans lesquelles il sys.stdout.write()est préférable print

Après avoir fini de développer un script l'autre jour, je l'ai téléchargé sur un serveur Unix. Tous mes messages de débogage utilisaient des printinstructions, et celles - ci n'apparaissent pas dans un journal de serveur.

C'est un cas où vous pourriez avoir besoin à la sys.stdout.writeplace.

Voici un exemple de code basé sur le livre Learning Python de Mark Lutz qui répond à votre question:

import sys
temp = sys.stdout                 # store original stdout object for later
sys.stdout = open('log.txt', 'w') # redirect all prints to this log file
print("testing123")               # nothing appears at interactive prompt
print("another line")             # again nothing appears. it's written to log file instead
sys.stdout.close()                # ordinary file object
sys.stdout = temp                 # restore print commands to interactive prompt
print("back to normal")           # this shows up in the interactive prompt

L'ouverture de log.txt dans un éditeur de texte révélera ce qui suit:

testing123
another line

Il y a au moins une situation dans laquelle vous voulez sys.stdoutau lieu d'imprimer.

Lorsque vous souhaitez remplacer une ligne sans passer à la ligne suivante, par exemple lorsque vous dessinez une barre de progression ou un message d'état , vous devez parcourir en boucle quelque chose comme

Note carriage return-> "\rMy Status Message: %s" % progress

Et puisque l'impression ajoute une nouvelle ligne, il vaut mieux utiliser sys.stdout.

Ma question est de savoir s'il existe ou non des situations dans lesquelles il sys.stdout.write()est préférableprint

Si vous écrivez une application en ligne de commande qui peut écrire à la fois dans des fichiers et dans stdout, c'est pratique. Vous pouvez faire des choses comme:

def myfunc(outfile=None):
    if outfile is None:
        out = sys.stdout
    else:
        out = open(outfile, 'w')
    try:
        # do some stuff
        out.write(mytext + '\n')
        # ...
    finally:
        if outfile is not None:
            out.close()

Cela signifie que vous ne pouvez pas utiliser le with open(outfile, 'w') as out:modèle, mais cela en vaut parfois la peine.

Dans 2.x, l' printinstruction pré-traite ce que vous lui donnez, le transformant en chaînes en cours de route, gérant les séparateurs et les nouvelles lignes et permettant la redirection vers un fichier. 3.x le transforme en fonction, mais il a toujours les mêmes responsabilités.

sys.stdout est un fichier ou un fichier similaire qui a des méthodes d'écriture qui prennent des chaînes ou quelque chose le long de cette ligne.

il est préférable lorsque l'impression dynamique est utile, par exemple, pour donner des informations dans un long processus:

import time, sys
Iterations = 555
for k in range(Iterations+1):
    # some code to execute here ...
    percentage = k / Iterations
    time_msg = "\rRunning Progress at {0:.2%} ".format(percentage)
    sys.stdout.write(time_msg)
    sys.stdout.flush()
    time.sleep(0.01)

>>> sys.stdout.write(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: expected a string or other character buffer object
>>> sys.stdout.write("a")
a>>> sys.stdout.write("a") ; print(1)
a1

En observant l'exemple ci-dessus:

1. sys.stdout.writene pas écrire objet non-chaîne, mais printsera

2. sys.stdout.writene sera pas ajouter un nouveau symbole de ligne à la fin, mais printsera

Si nous plongeons profondément,

sys.stdout est un objet fichier qui peut être utilisé pour la sortie de print ()

si l'argument de fichier print()n'est pas spécifié, sys.stdoutsera utilisé

Existe-t-il des situations dans lesquelles sys.stdout.write () est préférable d'imprimer?

Par exemple, je travaille sur une petite fonction qui imprime des étoiles au format pyramide en passant le nombre comme argument, bien que vous puissiez accomplir cela en utilisant end = "" pour imprimer sur une ligne séparée, j'ai utilisé sys.stdout.write en coordination avec impression pour faire ce travail. Pour élaborer sur ce stdout.write imprime sur la même ligne où print imprime toujours son contenu sur une ligne distincte.

import sys

def printstars(count):

    if count >= 1:
        i = 1
        while (i <= count):
            x=0
            while(x<i):
                sys.stdout.write('*')
                x = x+1
            print('')
            i=i+1

printstars(5)

Existe-t-il des situations dans lesquelles sys.stdout.write () est préférable d'imprimer?

J'ai trouvé que stdout fonctionne mieux que l'impression dans une situation multithreading. J'utilise Queue (FIFO) pour stocker les lignes à imprimer et je tiens tous les threads avant la ligne d'impression jusqu'à ce que mon Q d'impression soit vide. Même ainsi, en utilisant l'impression, je perds parfois le \ n final sur les E / S de débogage (en utilisant l'IDE pro pro).

Lorsque j'utilise std.out avec \ n dans la chaîne, les formats d'E / S de débogage sont correctement affichés et les \ n s'affichent avec précision.

Dans Python 3, il existe une raison valable d'utiliser l'impression sys.stdout.write, mais cette raison peut également être transformée en une raison d'utiliser à la sys.stdout.writeplace.

Cette raison est que, maintenant, print est une fonction en Python 3, vous pouvez remplacer cela. Vous pouvez donc utiliser print partout dans un script simple et décider à la place de ces instructions print stderr. Vous pouvez maintenant simplement redéfinir la fonction d'impression, vous pouvez même changer la fonction d'impression globale en la modifiant à l'aide du module intégré. Bien sûr, file.writevous pouvez spécifier ce qu'est un fichier, mais avec l'écrasement de l'impression, vous pouvez également redéfinir le séparateur de lignes ou le séparateur d'arguments.

L'inverse est. Peut-être êtes-vous absolument certain d'écrire stdout, mais sachez également que vous allez changer l'impression en quelque chose d'autre, vous pouvez décider d'utilisersys.stdout.write et utiliser l'impression pour le journal des erreurs ou autre chose.

Donc, ce que vous utilisez dépend de la façon dont vous comptez l'utiliser. printest plus flexible, mais cela peut être une raison pour l'utiliser et pour ne pas l'utiliser. J'opterais toujours pour la flexibilité à la place et choisirais d'imprimer. Une autre raison d'utiliser à la printplace est la familiarité. Plus de gens comprendront maintenant ce que vous entendez par impression et moins savent sys.stdout.write.

L'une des différences est la suivante, lorsque vous essayez d'imprimer un octet dans son apparence hexadécimale. Par exemple, nous savons que la valeur décimale de 255est 0xFFen apparence hexadécimale:

val = '{:02x}'.format(255) 

sys.stdout.write(val) # prints ff2
print(val)            # prints ff

En python 2, si vous devez passer une fonction, vous pouvez affecter os.sys.stdout.write à une variable, vous ne pouvez pas le faire (dans la repl) avec print.

>import os
>>> cmd=os.sys.stdout.write
>>> cmd('hello')
hello>>> 

Cela fonctionne comme prévu.

>>> cmd=print
  File "<stdin>", line 1
    cmd=print
            ^
SyntaxError: invalid syntax

Cela ne fonctionne pas. l'impression est une fonction magique.

Une différence entre printet sys.stdout.writeà signaler en Python 3, est également la valeur qui est retournée lorsqu'elle est exécutée dans le terminal. En Python 3 sys.stdout.writeretourne la longueur de la chaîne alors que printretourne justeNone .

Ainsi, par exemple, exécuter le code suivant de manière interactive dans le terminal afficherait la chaîne suivie de sa longueur, car la longueur est renvoyée et sortie lorsqu'elle est exécutée de manière interactive:

>>> sys.stdout.write(" hi ")
 hi 4