Tauthon est un fork de Python 2.7 dont le développement a débuté avant que les premières annonces officielles de la fin du support de la version 2 du langage ne se mettent à tomber. En 2016, il n’y a que « très peu de fonctionnalités de Python 3.x dont Tauthon ne dispose pas », d’après son auteur. Ci-dessous, une liste non exhaustive de celles dont le portage est effectif : Annotation des fonctions
| Code Python : | Sélectionner tout |
1 2 3 4 5 | >>> def f(a:int, b:str) -> list: ... pass ... >>> f.__annotations__ {'a': <type 'int'>, 'b': <type 'str'>, 'return': <type 'list'>} |
Syntaxe "async" et "await"
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | >>> import types
>>> @types.coroutine
... def delayed_print():
... printme = yield
... print printme
...
>>> async def main():
... while True:
... await delayed_print()
...
>>> coro = main()
>>> coro.send(None)
>>> coro.send("hello")
hello
>>> coro.send("there")
there
>>> coro.send("friend")
friend |
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | >>> from collections import OrderedDict >>> class Meta(type): ... @staticmethod ... def __prepare__(name, bases, **kwds): ... return OrderedDict() ... def __new__(cls, name, bases, namespace, **kwds): ... namespace.update(kwds) ... res = type.__new__(cls, name, bases, dict(namespace)) ... res._namespace = namespace ... return res ... def __init__(*args, **kwds): ... pass ... >>> class MyClass(metaclass=Meta, foo="bar"): ... def first(self): pass ... def second(self): pass ... def third(self): pass ... >>> MyClass.foo 'bar' >>> MyClass._namespace OrderedDict([('__module__', '__main__'), ('first', <function first at 0x1007ef568>), ('second', <function second at 0x10131b060>), ('third', <function third at 0x10131b118>), ('foo', 'bar')]) |
Intégration de nonlocal, mais pas comme mot-clé
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | >>> x = 0 >>> def f(): ... x = 1 ... def g(): ... nonlocal x ... x = 2 ... print x ... g() ... print x ... >>> print x; f(); print x 0 1 2 0 >>> nonlocal = True; print nonlocal True |
Python 3.0 est paru en décembre 2008. Cela fait donc un peu plus de 10 ans que les développeurs habitués à Python 2 travaillent avec à l’esprit qu’il faut penser à la migration vers la version 3 du langage. Si la plupart des projets commerciaux qui étaient encore sous Python 2.7 en 2017 n’avaient pas jusqu’alors franchi le pas, c’était très probablement à cause de la prise en compte de l’une des incompatibilités les plus importantes entre les versions 2 et 3 du langage : la représentation des chaînes de caractères. De Python 2 à Python 3, on est passé d’une version du langage orientée octet à une autre axée caractères unicode. En raison de ce changement, le mappage d’un 'char*' C vers Python n’est plus possible ; du moins, de façon directe. En fait, le changement en matière de représentation des chaînes de caractère est si important qu’il est souvent plus simple de procéder à une réécriture totale du code. C’est pour éviter aux développeurs de devoir se retrouver autant à la peine que Tauthon est proposé. En effet, pour ceux du lot dont les bases de code ne sont pas compatibles avec les interpréteurs 3.x en raison des incompatibilités entre les versions 2 et 3 du langage, s’appuyer sur Tauthon apparaît comme une grosse option pour rester sur les rails de la productivité.
Mais, un récent état de l’écosystème des développeurs montre que Python 2 serait fortement sur le déclin au profit de Python 3. D’après une publication de Jetbrains parue à mi-parcours de l’année précédente, près de 9 développeurs sur 10 ayant participé à son enquête utilisent désormais Python 3. Une autre lecture des gains de productivité peut être à l’origine de tels positionnements. En effet, la perte de productivité nécessaire au portage de bases de code Python 2 vers la version 3 peut trouver compensation sur le long terme en raison des gains introduits par les fonctionnalités de la nouvelle version du langage ou le retrait des « impuretés » de son ancienne version. Passer à Python 3 est un choix qui s’appuie sur cette façon de voir les choses.
Python 2.7 est paru en juillet 2010. Un détail saillant à propos de cette version du langage est que, mis à part les incompatibilités, elle s’appuie pour beaucoup sur des portages des fonctionnalités de Python 3.x. C’est un effort auquel les développeurs du projet ont mis un terme en 2015, soit 5 ans après la sortie de la version 2.7 du langage. En d’autres termes, ils ont décidé de se passer de ce qu’on aurait pu considérer comme le fork que Tauthon se trouve être. C’est un argument valable pour remettre en question la pertinence du projet Tauthon qui, il faut le souligner, n’est plus maintenu par son auteur qui déclare : « Python 3 est un meilleur langage que Python 2, Tauthon inclus. Autrement dit, si Guido devait présenter Python aujourd'hui pour la première fois, et offrir à chacun le choix entre Python 2 et 3, je voterais pour Python 3. »
Source : Tauthon
Et vous ?
Êtes-vous en accord avec l’affirmation selon laquelle Python 3 est un meilleur langage que Python 2 ? Quelles sont les difficultés majeures auxquelles vous avez fait face lors de votre migration de Python 2 à Python 3 ? Quelle est la pertinence d’avoir un ou des forks de Python 2 comme Tauthon ? Voir aussi :
Meilleurs langages en 2019 selon l’IEEE : Python leader pour la troisième année consécutive, il s’impose dans tous les domaines dans lesquels il est utilisé, du développement web à l’embarqué Meilleurs langages en 2018 selon l’IEEE : Python conforte sa place de leader grâce à son ascension dans le machine learning et l’embarqué Netflix : Python est derrière chaque film que vous regardez, voici comment l’entreprise utilise le langage de programmation pour ses services Python 3.8.0 : la première version bêta est publiée avec une API C pour améliorer la configuration de l’initialisation Éducation : Python bientôt langage officiel de programmation en France*? Un projet dans le cadre de la réforme du Bac et du lycée 
Envoyé par Patrick Ruiz
