Pourquoi print statement n'est pas pythonique? [fermé]

https://stackoverflow.com/questions/1053849

20-08-2019
|

Question

Cette question me dérangeait depuis un bon moment (comme le prouve ma question précédente ): pourquoi exactement print(x) est-il meilleur (qui est défini comme étant plus pythonique) que print x?

Pour ceux qui ne le savent pas, l'instruction print a été transformée en fonction dans Python 3.0. La documentation officielle est PEP 3105 et la motivation est dans E-mail de Guido van Rossum .

Je souhaite faire un contrepoint à ces points:

Il existe d'autres opérateurs, tels que import que nous écrivons en tant qu'instruction, bien que leurs fonctionnalités soient dupliquées avec une fonction __import__
- Pour les débutants, l'opérateur __print__ n'appartient pas à la logique générale de l'application. Pour eux, c'est l'opérateur mystérieux qui constitue l'aboutissement de leur programme. Ils s'attendent à ce que cela ait l'air différent.
- Tous les livres pour débutants décrivant Python 2.x de base sont désormais garantis contre la rupture avec le premier exemple . Certes, les langues changent parfois, mais ces modifications sont généralement moins visibles pour les novices.
- Pour moi, il n'est pas immédiatement évident qu'une fonctionnalité de <=> puisse être dupliquée au niveau de l'application. Par exemple, je souhaite parfois rediriger l’impression depuis une console sous la forme d’une boîte de dialogue modale.
- Alors que les gens disent qu'il est difficile de réécrire toutes les <=> instructions dans une fonction, ils ont obligé tous les développeurs Python 2.x à faire exactement cela pour tous leurs projets. Bien, ce n’est pas difficile avec le convertisseur automatique.
- Tous ceux qui aiment avoir la possibilité de manipuler une fonction <=> seraient tout aussi bien servis si <=> était une fonction d'habillage d'instructions <=>.

Alors, pouvons-nous avoir une réponse canonique à cette question dans les pages de Stack Overflow?

La solution

Il me semble que le vôtre est un débat et non une question. Allez-vous vraiment accepter une réponse qui montre à quel point vous étiez dans vos affirmations?!

Passons à vos points de débat:

Il existe d'autres opérateurs, tels que importer ce que nous écrivons comme une déclaration, si leur fonctionnalité est en fait dupliqué avec une fonction __import__

Absolument faux: la fonction def (comme toutes les autres - et opérateurs, d'ailleurs) lie les non noms dans le cadre de " appelant " (code le contenant) - tout " thingie " qui lie les noms dans la " étendue de l'appelant " doit être une déclaration (tout comme les assignations, call et assert). Votre & Quot; point & Quot; semble manquer totalement la distinction extrêmement profonde et cruciale que Python établit entre les déclarations et les expressions - on peut raisonnablement ne pas aimer cette distinction, mais l'ignorer est, bien évidemment, tout simplement faux .

Les instructions Python sont des éléments dont le compilateur Python doit être particulièrement conscient - elles peuvent modifier la liaison des noms, modifier le flux de contrôle et / ou nécessiter une suppression totale du code by généré dans certaines conditions (ce dernier cas s'applique). à print). import this était l'exception seulement de cette assertion dans Python 2; en la supprimant de la liste des déclarations, Python 3 supprime une exception, fait l'affirmation générale & «tenir juste &»; et est donc un langage plus régulier. Les cas spéciaux ne sont pas assez spéciaux pour enfreindre les règles a longtemps été un principe Pythonic (faites-le >>> à l'invite sys.stdout d'un interprète interactif pour voir & "; le zen de Python & "affiché", et ce changement de langage supprime une violation de ce principe qui devait rester pendant de nombreuses années en raison d’une décision anticipée de conception erronée.

Pour les débutants, l’opérateur imprime n'appartient pas à l'application générale logique. Pour eux c'est le mystérieux opérateur qui est un aboutissement de leur programme. Ils s'attendent à ce qu'il regarde différemment.

Guérir les idées fausses des débutants le plus tôt possible est une très bonne chose.

Tous les livres pour débutants qui ont été décrivant la base Python 2.x sont maintenant garanti d'être cassé du poing Exemple. Certes, les langues change parfois, mais les changements sont généralement moins visible pour les novices.

Les langues changent rarement de manière profonde et incompatible (Python le fait environ une fois par décennie) et peu de fonctionnalités langagières sont & "très visibles pour les novices &"; le nombre total d'observations est donc faible. - Pourtant, même à l'intérieur de cette minuscule boussole, nous pouvons facilement trouver des contre-exemples, dans lesquels une fonctionnalité très visible pour les débutants était si mal conçue que sa suppression en valait la peine. Par exemple, les dialectes modernes de base, tels que Visual Basic de Microsoft, n'utilisent pas de numéros de ligne explicites saisis par l'utilisateur, une fonctionnalité & "; &"; C'était à la fois terrible et hautement visible pour tout le monde puisqu'il était obligatoire dans les premiers dialectes du Basic. Les variantes modernes de Lisp (à partir de Scheme) n'utilisent pas la portée dynamique, un défaut qui était malheureusement très visible (ce qui se traduisait habituellement par des bogues difficiles à comprendre dans leur code) pour les débutants, dès qu'ils ont commencé à écrire des fonctions dans Lisp. 1,5 (j'ai déjà été un débutant dans ce domaine et je peux témoigner de la gravité de ma morsure).

Ce n'est pas immédiatement évident pour moi qu'une fonctionnalité d'impression peut être dupliqué au niveau de l'application. Par exemple, parfois je voudrais rediriger l'impression à partir d'une console en tant que dialogue modal du système d'exploitation.

Je ne suis pas sûr de suivre ce & «point &»; Il suffit de changer 2to3 en votre pseudo objet favori et de le rediriger vers le contenu de votre coeur - vous avez le Option de monkey corrigeant la fonction intégrée __print__ (que vous n'avez jamais eue dans Python 2), mais que personne ne vous tord le bras et ne vous oblige à le faire.

Alors que les gens disent qu'il est difficile de réécrire toutes les instructions d'impression d'une fonction, ils ont forcé chaque Python 2.x développeur à faire exactement cela pour tous leurs projets. Bon, c'est pas difficile avec convertisseur automatique.

L’outil >> myfile s’occupe effectivement de toutes ces incompatibilités de surface faciles - pas de sueur (et il doit être exécuté de toute façon pour en prendre bien plus encore <=>, afin que les gens l'utilisent beaucoup) . Alors, quel est votre & Quot; point & Quot; ici?

Tous ceux qui aiment avoir une capacité pour manipuler la fonction d'impression serait tout aussi bien servi si l'impression était un instruction d'habillage des instructions imprimer .

Un tel arrangement ne supprime pas en soi un mot clé inutile (et plus particulièrement une irrégularité injustifiée , comme je l'ai expliqué ci-dessus: une déclaration qui n'a pas bonne raison pour être une déclaration, car il n’est absolument pas nécessaire que le compilateur en soit spécialement conscient, de quelque manière que ce soit, sous quelque forme que ce soit! Il est loin d'être clair pour moi qu'une telle fonction sous-jacente apporterait une réelle valeur ajoutée, mais si vous avez des cas d'utilisation réels, vous pouvez certainement le proposer dans la liste de diffusion Python Ideas - une telle fonction sous-jacente, si elle s'avère être précieuse , pourrait être installé ultérieurement pour être utilisé par l’instruction <=> dans Python 2.7 ainsi que par la <=> fonction dans Python 3.2.

Cependant, considérons un cas typique dans lequel on pourrait vouloir "patcher" le <=>: ajout des arguments de mot clé pour permettre des ajustements fantaisistes. Comment la fonction <=> que vous proposez apparemment aurait-elle jamais obtenue à l'aide de ces arguments KW à partir d'une instruction <=>? Une syntaxe plus amusante que les horreurs de <=> et la virgule finale ...?! Avec <=> en tant que fonction, les arguments de mot-clé suivent uniquement les règles parfaitement normales et ordinaires qui s'appliquent à toutes les fonctions et appels de fonctions - Bliss!

Donc, en résumé, c'est plus Pythonic pour <=> être une fonction car elle supprime les anomalies, les cas spéciaux et tout besoin de syntaxe étrange - la simplicité, la régularité et l'uniformité sont la marque de Python.

Autres conseils

Voici la raison pour laquelle je déteste l’impression print en 2.x.

>>> something()
<something instance at 0xdeadbeef>
>>> print something()
<something instance at 0xdeadbeef>

objet sans valeur n'a pas d'utilité __str__, très bien, je peux m'en occuper, regardez-le encore.

>>> dir(something())
['foo', 'bar', 'baz', 'wonderful']
>>> help(something().foo)
"foo(self, callable)"

hmm .. donc est-ce que l'appelable prend des arguments?

>>> something().foo(print)
    something().foo(print)
                        ^
SyntaxError: invalid syntax
>>> something().foo(lambda *args: print(*args))
    something().foo(lambda *args: print(*args))
                                      ^
SyntaxError: invalid syntax

Alors ... je dois soit définir une fonction à utiliser

>>> def myPrint(*args): print *args
    def myPrint(*args): print *args
                              ^
SyntaxError: invalid syntax
>>> def myPrint(*args): print args
...
>>> myPrint(1)
(1,)

Frémissez, ou utilisez sys.stdout.write, qui est presque aussi flou, car il a un comportement très différent de print. Il a également une apparence différente, ce qui signifie que je ne me souviendrai presque jamais de son existence.

Utiliser <=> des instructions dans une installation courte et ponctuelle, puis l’améliorer pour utiliser la journalisation ou quelque chose de mieux n’est tout simplement pas élégant. Si print fonctionnait comme ces choses-là, et surtout pouvait être utilisé avec des fonctions d'ordre élevé, alors ce serait mieux que ce que vous utilisez lorsque vous n'utilisez pas la journalisation réelle ou réelle débogueurs.

L'instruction print contient également la syntaxe >> inhabituelle pour l'impression dans un fichier spécifique. Il n’existe pas d’autre déclaration en Python qui présente cette syntaxe. C’est donc inhabituel de cette façon.

Je pense que vous avez raison, la plupart des problèmes liés à la déclaration __print__ auraient pu être résolus par l'introduction d'une fonction <=>.

J'ai trouvé que & "; print; de GvR est la seule fonctionnalité au niveau de l'application à laquelle une déclaration est dédiée &"; convaincant. Python est un langage généraliste et ne devrait pas avoir d'instruction pour la sortie d'un flux en tant qu'opérateur ou mot clé.

Ce n'est pas pythonique car la syntaxe doit être:

stdout.append("Hello World")

stdout += "hello world"

Avertissement: j'aime vraiment Python.

Sur une note sérieuse ...

Je pense que le modèle d'objet de Python et son approche "Implémentez-le vous-même" pour des éléments tels que la visibilité des attributs sont excellents. Je pense que cette approche "tout est objet" de la POO, et même les objets définis comme une collection d'objets sont très clairs d'esprit.

Ce que je crains que Python ne fasse, c'est de devenir un langage qui ne présente pas clairement ses intentions ... et je détesterais voir la beauté des principes s'enliser dans la sur-réflexion de la présentation de syntaxe déjà peu conventionnelle . Un peu comme Lisp , magnifique dans sa structure, sombre, à mon sens dans sa syntaxe.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow