Histoire de Python

Le langage de programmation Python a été conçu à la fin des années 1980 et son implémentation a été lancée en décembre 1989 par Guido van Rossum au CWI aux Pays-Bas en tant que successeur d' ABC capable de gérer les exceptions et de s'interfacer avec le système d'exploitation Amoeba . Van Rossum est l'auteur principal de Python, et son rôle central continu dans la décision de la direction de Python se reflète dans le titre qui lui a été donné par la communauté Python, Benevolent Dictator for Life (BDFL) [ (Cependant, Van Rossum a démissionné de son poste de leader le 12 juillet 2018 ). Python doit son nom à l' émission télévisée de la BBC Monty Python's Flying Circus .

Python 2.0 est sorti le 16 octobre 2000, avec de nombreuses nouvelles fonctionnalités majeures, notamment un récupérateur de mémoire à détection de cycle (en plus du comptage de références ) pour la gestion de la mémoire et la prise en charge d' Unicode , ainsi qu'un changement dans le processus de développement lui-même, avec un passage à un processus plus transparent et soutenu par la communauté.

Python 3.0, une version majeure et non rétrocompatible, a été publiée le 3 décembre 2008 après une longue période de tests. Bon nombre de ses principales fonctionnalités ont également été rétroportées vers les versions rétrocompatibles, bien que non prises en charge, de Python 2.6 et 2.7.

En février 1991, Van Rossum a publié le code (étiqueté version 0.9.0) sur alt.sources. Déjà présents à ce stade du développement étaient les classes avec héritage , gestion des exceptions, fonctions et les types de données de base , , etc. listÉgalement dans cette version initiale figurait un système de modules emprunté à Modula-3 ; Van Rossum décrit le module comme « l'une des principales unités de programmation de Python ». Le modèle d'exception de Python ressemble également à celui de Modula-3, avec l'ajout d'une clause. En 1994, comp.lang.python, le principal forum de discussion pour Python, a été formé, marquant une étape importante dans la croissance de la base d'utilisateurs et de la popularité de Python. dictstrelse

Python a atteint la version 1.0 en janvier 1994. Les principales nouvelles fonctionnalités incluses dans cette version étaient les outils de programmation fonctionnelle lambda, map, filteret reduce. Van Rossum a déclaré que « Python a acquis lambda, reduce(), filter() et map(), grâce à un hacker Lisp qui les a manqués et a soumis des correctifs fonctionnels ».

La dernière version publiée alors que Van Rossum était au CWI était Python 1.2. En 1995, Van Rossum a continué ses travaux sur Python à la Corporation for National Research Initiatives (CNRI) à Reston , en Virginie, d'où il a publié plusieurs versions.

Dans la version 1.4, Python a acquis plusieurs nouvelles fonctionnalités. Parmi celles-ci, on peut citer les arguments de mots-clés inspirés de Modula-3 (qui sont également similaires aux arguments de mots-clés de Common Lisp ) et la prise en charge intégrée des nombres complexes . Une forme basique de masquage des données par modification des noms est également incluse , bien que cela soit facilement contourné.

Pendant son séjour au CNRI, Van Rossum a lancé l'initiative Computer Programming for Everybody (CP4E), dans le but de rendre la programmation plus accessible à un plus grand nombre de personnes, avec une « alphabétisation » de base dans les langages de programmation, similaire aux compétences de base en anglais et en mathématiques requises par la plupart des employeurs. Python a joué un rôle central dans ce domaine : en raison de son accent sur une syntaxe propre, il était déjà adapté, et les objectifs de CP4E présentaient des similitudes avec son prédécesseur, ABC. Le projet a été financé par la DARPA . En 2007 , le projet CP4E est inactif, et bien que Python tente d'être facilement apprenable et pas trop obscur dans sa syntaxe et sa sémantique, la sensibilisation des non-programmeurs n'est pas une préoccupation active.

En 2000, l'équipe de développement de base de Python a rejoint BeOpen.com pour former l'équipe BeOpen PythonLabs. Le CNRI a demandé qu'une version 1.6 soit publiée, résumant le développement de Python jusqu'au moment où l'équipe de développement a quitté le CNRI. Par conséquent, les calendriers de publication des versions 1.6 et 2.0 se chevauchaient considérablement. Python 2.0 était la seule version de BeOpen.com. Après la publication de Python 2.0 par BeOpen.com, Guido van Rossum et les autres développeurs de PythonLabs ont rejoint Digital Creations .

La version 1.6 de Python comprenait une nouvelle licence CNRI, sensiblement plus longue que la licence CWI utilisée pour les versions précédentes. La nouvelle licence comprenait une clause stipulant que la licence était régie par les lois de l' État de Virginie . La Free Software Foundation a fait valoir que la clause de choix de la loi était incompatible avec la GNU General Public License . BeOpen, CNRI et la FSF ont négocié une modification de la licence de logiciel libre de Python qui la rendrait compatible avec la GPL. Python 1.6.1 est essentiellement identique à Python 1.6, avec quelques corrections de bogues mineures et avec la nouvelle licence compatible avec la GPL.

Python 2.0, sorti en octobre 2000, a introduit les compréhensions de listes , une fonctionnalité empruntée aux langages de programmation fonctionnelle SETL et Haskell . La syntaxe de Python pour cette construction est très similaire à celle de Haskell, à l'exception de la préférence de Haskell pour les caractères de ponctuation et de la préférence de Python pour les mots-clés alphabétiques. Python 2.0 a également introduit un récupérateur de mémoire capable de collecter les cycles de référence.

Python 2.1 était proche de Python 1.6.1, ainsi que de Python 2.0. Sa licence a été renommée Python Software Foundation License . Tout le code, la documentation et les spécifications ajoutés, à partir de la sortie alpha de Python 2.1, appartiennent à la Python Software Foundation (PSF), une organisation à but non lucratif créée en 2001, sur le modèle de l' Apache Software Foundation . La version comprenait une modification de la spécification du langage pour prendre en charge les portées imbriquées, comme d'autres langages à portée statique . (La fonctionnalité était désactivée par défaut et non requise jusqu'à Python 2.2.)

Python 2.2 a été publié en décembre 2001 ; une innovation majeure a été l'unification des types de Python (types écrits en C ) et des classes (types écrits en Python) en une seule hiérarchie. Cette unification unique a rendu le modèle objet de Python purement et systématiquement orienté objet. Des générateurs inspirés d' Icon ont également été ajoutés .

Python 2.5 a été publié en septembre 2006 et a introduit l' withinstruction, qui enferme un bloc de code dans un gestionnaire de contexte (par exemple, l'acquisition d'un verrou avant l'exécution du bloc de code et la libération du verrou par la suite, ou l'ouverture d'un fichier puis sa fermeture), permettant l'acquisition de ressources dans un comportement de type initialisation (RAII) et remplaçant un idiome try/finally courant.

Python 2.6 a été publié pour coïncider avec Python 3.0, et comprenait certaines fonctionnalités de cette version, ainsi qu'un mode « avertissements » qui mettait en évidence l'utilisation de fonctionnalités qui ont été supprimées dans Python 3.0. De même, Python 2.7 a coïncidé avec et incluait des fonctionnalités de Python 3.1, qui a été publié le 26 juin 2009. Les versions parallèles 2.x et 3.x ont ensuite cessé, et Python 2.7 était la dernière version de la série 2.x. En novembre 2014, il a été annoncé que Python 2.7 serait pris en charge jusqu'en 2020, mais les utilisateurs ont été encouragés à passer à Python 3 dès que possible. Le support de Python 2.7 a pris fin le 1er janvier 2020, avec le gel du code de la branche de développement 2.7. Une version finale, la 2.7.18, est sortie le 20 avril 2020 et comprenait des correctifs pour les bogues critiques et les bloqueurs de version. Cela a marqué la fin de vie de Python 2.

Python 3.0 (également appelé « Python 3000 » ou « Py3K ») a été publié le 3 décembre 2008. Il a été conçu pour corriger des défauts de conception fondamentaux du langage : les changements requis ne pouvaient pas être implémentés tout en conservant une compatibilité complète avec la série 2.x, ce qui nécessitait un nouveau numéro de version majeur. Le principe directeur de Python 3 était : « réduire la duplication des fonctionnalités en supprimant les anciennes façons de faire les choses ».

Python 3.0 a été développé avec la même philosophie que les versions précédentes. Cependant, comme Python avait accumulé de nouvelles façons redondantes de programmer la même tâche, Python 3.0 a mis l'accent sur la suppression des constructions et modules en double, conformément au Zen de Python : « Il devrait y avoir une seule façon évidente de le faire, et de préférence une seule. »

Néanmoins, Python 3.0 est resté un langage multi-paradigme . Les codeurs pouvaient toujours suivre les paradigmes de programmation orientée objet , structurée et fonctionnelle , entre autres, mais dans le cadre de choix aussi vastes, les détails étaient censés être plus évidents dans Python 3.0 que dans Python 2.x.

Python 3.0 a rompu la compatibilité ascendante, et une grande partie du code Python 2 ne fonctionne pas sans modification sur Python 3. Le typage dynamique de Python combiné aux projets de modification de la sémantique de certaines méthodes de dictionnaires, par exemple, a rendu très difficile la traduction mécanique parfaite de Python 2.x vers Python 3.0. Un outil appelé « 2to3 » effectue les parties de la traduction qui peuvent être effectuées automatiquement. À ce stade, 2to3 semble avoir eu un certain succès, bien qu'une première évaluation ait noté qu'il y avait des aspects de la traduction qu'un tel outil ne serait jamais en mesure de gérer. Avant le déploiement de Python 3, il était recommandé aux projets nécessitant une compatibilité avec les séries 2.x et 3.x d'avoir une source unique (pour la série 2.x) et de produire des versions pour la plate-forme Python 3.x en utilisant 2to3. Les modifications du code Python 3.x ont été déconseillées tant que le code devait s'exécuter sur Python 2.x. Cela n'est plus recommandé ; en 2012, l'approche privilégiée consistait à créer une base de code unique pouvant s'exécuter sous Python 2 et 3 à l'aide de modules de compatibilité.

Certains des changements majeurs inclus dans Python 3.0 étaient :

• Modification printpour qu'il s'agisse d'une fonction intégrée et non d'une instruction. Cela a facilité la modification d'un module pour utiliser une fonction d'impression différente, ainsi que la syntaxe plus régulière. Dans Python 2.6 et 2.7, print()il est disponible en tant que fonction intégrée, mais est masqué par la syntaxe de l'instruction d'impression, qui peut être désactivée en entrant from __future__ import print_functionen haut du fichier
• Suppression de la inputfonction Python 2 et changement de nom de la raw_inputfonction en input. inputLa fonction de Python 3 se comporte comme raw_inputla fonction de Python 2, dans la mesure où l'entrée est toujours renvoyée sous forme de chaîne plutôt que d'être évaluée sous forme d'expression
• Déplacement reduce(mais pas mapou filter) hors de l'espace de noms intégré et dans functools(la raison étant que le code qui utilise reduceest moins lisible que le code qui utilise une boucle for et une variable d'accumulateur)
• Ajout de la prise en charge des annotations de fonctions facultatives qui peuvent être utilisées pour des déclarations de type informelles ou à d'autres fins
• Unification des types str/ unicode, représentation du texte et introduction d'un bytestype immuable distinct ; et d'un type mutable principalement correspondant bytearray, qui représentent tous deux des tableaux d' octets
• Suppression des fonctionnalités de compatibilité descendante, notamment les classes à l'ancienne, les exceptions de chaîne et les importations relatives implicites
• Un changement dans la fonctionnalité de division d'entiers : dans Python 2, la division d'entiers renvoie toujours un entier. Par exemple , 5 / 2is 2; alors que dans Python 3, 5 / 2is 2.5. (Dans Python 2 – 2.2 et suivants – et Python 3, un opérateur distinct existe pour fournir l'ancien comportement : 5 // 2is 2)
• Autoriser l'utilisation de lettres non-ASCII dans les identifiants, comme dans smörgåsbord, prenant entièrement en charge les caractères Unicode dans le code source ( UTF-8 est utilisé par défaut)

Les versions ultérieures de la série Python 3.x ont inclus de nouvelles fonctionnalités supplémentaires et substantielles ; tout le développement continu du langage est effectué dans la série 3.x.

Versions antérieures aux versions numérotées :

• Début de la mise en œuvre – décembre 1989
• Versions internes du Centrum Wiskunde & Informatica – 1990

Notes de tableau :