Pourquoi les parenthèses imprimées sont-elles volontaires dans Python 2.7?

Dans Python 2.7, les deux éléments suivants feront la même chose

print("Hello, World!") # Prints "Hello, World!"

print "Hello, World!" # Prints "Hello, World!"

Cependant, ce qui suit ne sera pas

print("Hello,", "World!") # Prints the tuple: ("Hello,", "World!")

print "Hello,", "World!" # Prints the words "Hello, World!"

En Python 3.x, les parenthèses printsont obligatoires, ce qui en fait essentiellement une fonction, mais dans 2.7 les deux fonctionneront avec des résultats différents. Que dois-je savoir d'autre sur printPython 2.7?

En Python 2.x printest en fait une instruction spéciale et non une fonction *.

C'est aussi pourquoi il ne peut pas être utilisé comme: lambda x: print x

Notez que (expr)cela ne crée pas de Tuple (il en résulte expr), mais le ,fait. Cela entraîne probablement la confusion entre print (x)et print (x, y)dans Python 2.7

(1)   # 1 -- no tuple Mister!
(1,)  # (1,)
(1,2) # (1, 2)
1,2   # 1 2 -- no tuple and no parenthesis :) [See below for print caveat.]

Cependant, comme il prints'agit d'une instruction de syntaxe / construction grammaticale spéciale en Python 2.x, sans les parenthèses, il traite les ,'s d'une manière spéciale - et ne crée pas de tuple. Ce traitement particulier de l' printinstruction lui permet d'agir différemment s'il y a un suivi ,ou non.

Bon codage.

* Ce printcomportement dans Python 2 peut être changé pour celui de Python 3:

from __future__ import print_function

Tout cela est très simple et n'a rien à voir avec la compatibilité ascendante ou descendante.

La forme générale de l' printinstruction dans toutes les versions de Python avant la version 3 est:

print expr1, expr2, ... exprn

(Chaque expression est à son tour évaluée, convertie en chaîne et affichée avec un espace entre elles.)

Mais rappelez-vous que placer des parenthèses autour d'une expression est toujours la même expression.

Vous pouvez donc également écrire ceci comme suit:

print (expr1), (expr2), ... (expr3)

Cela n'a rien à voir avec l'appel d'une fonction.

Ici, nous avons un effet secondaire intéressant en ce qui concerne UTF-8.

>> greek = dict( dog="σκύλος", cat="γάτα" )
>> print greek['dog'], greek['cat']
σκύλος γάτα
>> print (greek['dog'], greek['cat'])
('\xcf\x83\xce\xba\xcf\x8d\xce\xbb\xce\xbf\xcf\x82', '\xce\xb3\xce\xac\xcf\x84\xce\xb1')

La dernière impression est un tuple avec des valeurs d'octets hexadécimaux.

Fondamentalement, dans Python avant Python 3, print était une instruction spéciale qui imprimait toutes les chaînes si elles étaient obtenues en arguments. Donc print "foo","bar"simplement signifiait "imprimer 'foo' suivi de 'bar'". Le problème avec cela était qu'il était tentant d'agir comme si print était une fonction, et la grammaire Python est ambiguë à ce sujet, car (a,b)est un tuple contenant aet bmais foo(a,b)est un appel à une fonction de deux arguments.

Ils ont donc fait le changement incompatible pour 3 pour rendre les programmes moins ambigus et plus réguliers.

(En fait, je pense que 2.7 se comporte comme 2.6 à ce sujet, mais je ne suis pas certain.)