Table des matières
partie I Le langage Python 9
1.1 Ordinateur et langages . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Présentation du langage Python . . . . . . . . . . . . . . . . . . . . . 12
1.3 Installation du langage Python . . . . . . . . . . . . . . . . . . . . . 14
1.4 Installation d’un éditeur de texte . . . . . . . . . . . . . . . . . . . . 18
1.5 Premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.6 Installation d’extensions (ou modules externes) . . . . . . . . . . . . 23
1.7 Outils connexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2 Types immuables (ou immutable) . . . . . . . . . . . . . . . . . . . . 32
2.3 Types modifiables (ou mutable) . . . . . . . . . . . . . . . . . . . . . 42
2.4 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.1 Les trois concepts des algorithmes . . . . . . . . . . . . . . . . . . . . 57
3.2 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.5 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.6 Fonctions usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.7 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.1 Présentation des classes : méthodes et attributs . . . . . . . . . . . . 93
4.2 Constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.3 Apport du langage Python . . . . . . . . . . . . . . . . . . . . . . . . 99
4.4 Opérateurs, itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 103
4.5 Méthodes, attributs statiques et ajout de méthodes . . . . . . . . . . 108
4.6 Copie d’instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.7 Attributs figés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.8 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.9 Compilation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . 133
4.10 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . 134
5.1 Principe des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.2 Définir ses propres exceptions . . . . . . . . . . . . . . . . . . . . . . 145
5.3 Exemples d’utilisation des exceptions . . . . . . . . . . . . . . . . . . 146
6.1 Modules et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
6.2 Modules internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.3 Modules externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.4 Python et les autres langages . . . . . . . . . . . . . . . . . . . . . . 157
6.5 Boost Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
7.1 Format texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
7.2 Fichiers zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
7.3 Manipulation de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 175
7.4 Format binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
7.5 Paramètres en ligne de commande . . . . . . . . . . . . . . . . . . . 182
7.6 Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . 184
7.7 Dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
7.8 Problème de jeux de caractères . . . . . . . . . . . . . . . . . . . . . 191
8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
8.2 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
8.3 Disposition des objets dans une fenêtre . . . . . . . . . . . . . . . . . 206
8.4 Evénements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
8.5 D’autres fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
8.6 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . 219
9.1 Premier thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
9.2 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
9.3 Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
9.4 Files de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
partie II Enoncés pratiques, exercices 237
10.1 Montant numérique, montant littéral . . . . . . . . . . . . . . . . . . 238
10.2 Représentation des données, partie de dames . . . . . . . . . . . . . . 242
10.3 Reconnaître la langue d’un texte . . . . . . . . . . . . . . . . . . . . 245
10.4 Carrés magiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
10.5 Tri rapide ou quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . 261
11.1 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . . . 270
11.2 Ajouter un jour férié . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
11.3 Fréquentation d’un site Internet . . . . . . . . . . . . . . . . . . . . 276
12.1 Premier énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
12.2 Second énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
12.3 Troisème énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
12.4 Quatrième énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
12.5 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . 319
Index 323
Première partie
LE LANGAGE PYTHON
Les programmes informatiques sont souvent l’aboutissement d’un raisonnement, d’une construction, d’une idée, parfois imprécise mais dont le principe général est compris. Et pour valider cette idée, on utilise un langage de programmation qui ne tolère jamais l’imprécision, qui refuse de comprendre au moindre signe de ponctuation oublié, qui est d’une syntaxe si rigide.
On reste parfois indécis devant une erreur qui se produit avec un exemple qu’on a pourtant recopié sans ajout. On compare les deux versions sans faire attention aux petits détails qui ne changent rien pour le concepteur et beaucoup pour le langage. C’est un espace en plus ou en moins, un symbole : oublié Il est fréquent de ne pas vérifier ces petits détails lorsqu’on commence à programmer. Et ils découragent souvent. On s’habitue peu à peu au fait qu’il ne faut pas confondre parenthèses et crochets, qu’il manque des guillemets, qu’il y a une lettre en plus, ou en moins.
Lorsque sa syntaxe n’est pas respectée, le langage de programmation ne cherche jamais à comprendre l’intention du programmeur. Il faut penser à la vérifier en premier lorsqu’une erreur se produit. Les messages d’erreur, obscurs au premier abord, donnent néanmoins un bon indice pour corriger un programme. Et si cela ne suffisait pas, il ne faut pas hésiter à recopier ce message dans un moteur de recherche sur Internet pour y trouver une indication dès les premiers résultats, et le plus souvent en français.
Cette première partie est consacrée à la description du langage Python. Il est parfois utile de reproduire un des exemples, de le faire fonctionner, de le modifier, d’y introduire des erreurs puis de les corriger. Plus tard, dans de plus longs programmes, les mêmes erreurs seront plus difficiles à déceler et l’expérience montre qu’on fait presque toujours les mêmes erreurs.
Chapitre 1 Introduction
Ce chapitre s’intéresse tout d’abord à l’installation du langage Python et à la réalisation d’un premier programme avec des instructions dont le sens est intuitif. Les derniers paragraphes présentent de nombreuses extensions disponibles sur Internet. Elles rendent le langage Python très attractif dans des domaines variés. Ces extensions témoignent que ce langage emporte l’adhésion de nombreux informaticiens qui en retour assurent sa pérennité. Il permet de relier facilement différents éléments, différentes applications. C’est une des raisons de son succès.
1.1 Ordinateur et langages
Il est rare aujourd’hui de ne pas avoir déjà entendu ou lu les termes informatiques définis ci-dessous. C’est un rapide rappel.
1.1.1 L’ordinateur
On peut considérer simplement qu’un ordinateur est composé de trois ensembles : le microprocesseur, la mémoire, les périphériques. Cette description n’a pas varié en cinquante ans depuis qu’un scientifique du nom de von Neumann l’a imaginée.
Le microprocesseur est le cœur de l’ordinateur, il suit les instructions qu’on lui donne et ne peut travailler qu’avec un très petit nombre d’informations. Sa vitesse se mesure en GigaHertz (GHz) qui correspondent au nombre d’opérations qu’il est capable d’effectuer en une seconde et en nombre de cœurs qui détermine le nombre d’opérations en parallèle qu’il est capable d’exécuter. On lui adjoint une mémoire avec laquelle il échange sans arrêt des données. Sa capacité se mesure en octets (kilooctets, mégaoctets, gigaoctets ou leurs abréviations Ko, Mo, Go ). Ces échanges entre processeur et mémoire sont rapides.
Les périphériques regroupent tout le reste (écran, clavier, souris, disque dur, imprimante ). Ils sont principalement de deux types : les périphériques de stockages (disque dur, DVD) et ceux qui nous permettent de dialoguer avec l’ordinateur, que ce soit pour afficher, sonoriser (écran, enceintes) ou pour recevoir (souris, clavier, webcam, micro ).
1.1.2 Termes informatiques
Certains termes reviendront fréquemment dans le livre. Ils sont souvent utilisés comme si tout le monde les connaissait comme la notion d’algorithme qui paraît plutôt abstraite si on se réfère à sa définition dans le dictionnaire. Dans la pratique, on confond souvent algorithme avec programme informatique.
Définition 1.1 : algorithme
Un algorithme est une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini de données pour arriver avec certitude, en un nombre fini d’étapes, à un certain résultat et cela, indépendamment des données.
Leur écriture est indépendante du langage choisi, qu’il soit écrit en Basic, en Pascal, en C, en Perl, en PHP, en Python, en français, un algorithme reste le même. Pour les algorithmes simples (un tri par exemple), le passage d’un langage à l’autre consiste souvent à traduire mot-à-mot, ce qui favorise l’apprentissage d’un nouveau langage informatique lorsqu’on en connaît déjà un. Les différences entre ces langages résident dans leur spécialisation, le Visual Basic permet de piloter les applications Microsoft Office, le PHP, le JavaScript sont dédiés à la programmation Internet. Le langage Python n’est pas spécialisé. Il est souvent moins efficace que chaque langage appliqué à son domaine de prédilection mais il peut éviter l’apprentissage d’une syntaxe différente.
Définition 1.2 : programme
Un programme informatique est une suite d’instructions ou séquence d’instructions. C’est la réalisation informatique d’un ou plusieurs algorithmes. Il dépend du langage.
Définition 1.3 : compilateur et compilation
Le compilateur est un programme qui traduit un code écrit dans un langage de programmation en langage dit "machine", compréhensible par l’ordinateur. La compilation est le fait de traduire un programme afin que l’ordinateur le comprenne.
Définition 1.4 : langage interprété
Un langage interprété est converti en instructions propres à la machine au fur et à mesure de son exécution.
Le langage Python n’est pas un langage compilé car un programme Python n’est pas traduit en langage machine, il est un langage interprété. Entre son écriture et son exécution, il n’y a pas d’étape intermédiaire telle que la compilation et on peut ainsi tester un programme plus rapidement même si son exécution est alors plus lente.
Définition 1.5 : mot-clé
Un mot-clé est une composante du langage et fait partie de sa grammaire qui comprend également les opérateurs numériques.
La table 3.1 (page 58) regroupe les mots-clés du langage Python. Elle contient peu de mots-clés : son concepteur s’est attaché à créer un langage objet avec la grammaire la plus simple possible.
Définition 1.6 : instruction
Ce terme est assez vague et dépend en général du langage. On peut considérer qu’une instruction est une expression syntaxiquement correcte pour un langage donné.
Les instructions sont très courtes et tiennent sur une ligne mais si on n’en prend qu’une partie, elle perd son sens. Ce serait comme considérer une phrase avec un verbe transitif mais sans son complément d’objet direct.
1.2 Présentation du langage Python
1.2.1 Histoire résumée
Python est un langage objet interprété de haut niveau, il a été créé au début des années quatre-vingt-dix par Guido van Rossum. Entre 1995 et 2001, Rossum a changé plusieurs fois de travail tout en continuant l’élaboration du langage Python. En 2001, la PSF (Python Software Foundation) est créée. Il s’agit d’une organisation à but non lucratif détenant les droits de propriété intellectuelle de Python. Il est depuis distribué sous forme de logiciel libre. Python est couvert par sa propre licence . Toutes les versions depuis la 2.0.1 sont compatibles avec la licence GPL . Selon Wikipedia , Rossum travaillerait maintenant pour l’entreprise Google qui propose une plate-forme de développement de sites web en Python et qui héberge de nombreux projets en langage Python via son projet Google Code .
1.2.2 Le langage en quelques points
On distingue plusieurs classes parmi les langages informatiques selon la syntaxe qu’ils proposent ou les possibilités qu’ils offrent. Python est un langage : interprété, orienté objet, de haut niveau, modulaire, à syntaxe positionnelle, au typage dynamique.
Le langage Python est dit interprété car il est directement exécuté sans passer par une phase de compilation qui traduit le programme en langage machine, comme c’est le cas pour le langage C. En quelque sorte, il fonctionne autant comme une calculatrice que comme un langage de programmation. Afin d’accélérer l’exécution d’un programme Python, il est traduit dans un langage intermédiaire qui est ensuite interprété par une machine virtuelle Python. Ce mécanisme est semblable à celui propre au langage Java.
Le langage est orienté objet car il intègre le concept de classe ou d’objet. Un objet regroupe un ensemble de données et un ensemble de fonctionnalités attachées à ces données. Ce concept relie la description des données et les algorithmes qui leur sont appliqués comme un tout indissociable. Un objet est en quelque sorte une entité autonome avec laquelle on peut communiquer via une interface.
On considère que le langage Python est de haut niveau car il propose des fonctionnalités avancées et automatiques comme le garbage collecting. Cette tâche correspond à la destruction automatique des objets lorsqu’ils ne sont plus utilisés. Cette fonctionnalité est proposée par la plupart des langages interprétés ou encore Java mais pas C++. Il propose également des structures de données complexes éloignées des types numériques standards telles que des dictionnaires.
Le langage Python est modulaire. La définition du langage est très succincte et autour de ce noyau concis, de nombreuses librairies ou modules ont été développées. Python est assez intuitif. Etre à l’aise avec ce langage revient à connaître tout autant sa syntaxe que les nombreux modules disponibles. Comme il est assez simple de construire un pont entre Python et C++, de nombreux projets open source antérieurs à Python sont maintenant accessibles dans ce langage et sous toutes les plateformes.
Le langage Python est à syntaxe positionnelle en ce sens que l’indentation fait partie du langage. Le point virgule permet de séparer les instructions en langage C, l’accolade permet de commencer un bloc d’instructions. En Python, seule l’indentation permet de marquer le début et la fin d’un tel bloc, ce procédé consiste à décaler les lignes vers la droite pour signifier qu’elles appartiennent au même bloc d’instructions et qu’elles doivent être exécutées ensemble. Cette contrainte rend les programmes Python souvent plus faciles à lire.
Le langage Python est à typage dynamique. Le type d’une variable, d’une donnée est définie lors de l’exécution du programme. Chaque information est désignée par un identificateur qui est manipulé tout au long du programme. Le fait que telle ou telle opération soit valide est vérifiée au moment où elle doit être réalisée et non au moment où le programme est traduit en langage machine, c’est-à-dire compilé.
1.2.3 Avantages et inconvénients du langage Python
Alors qu’il y a quelques années, le langage C puis C++ s’imposaient souvent comme langage de programmation, il existe dorénavant une profusion de langages (Java, JavaScript, PHP, Visual Basic, C#, Perl, PHP, ). Il est souvent possible de transposer les mêmes algorithmes d’un langage à un autre. Le choix approprié est bien souvent celui qui offre la plus grande simplicité lors de la mise en œuvre d’un programme même si cette simplicité s’acquiert au détriment de la vitesse d’exécution. Le langage PHP est par exemple très utilisé pour la conception de sites Internet car il propose beaucoup de fonctions très utiles dans ce contexte. Dans ce domaine, le langage Python est une solution alternative intéressante.
Comme la plupart des langages, le langage Python est tout d’abord portable puisqu’un même programme peut être exécuté sur un grand nombre de systèmes d’exploitation comme Linux, Microsoft Windows, Mac OS XPython possède également l’avantage d’être entièrement gratuit tout en proposant la possibilité de pouvoir réaliser des applications commerciales à l’aide de ce langage.
Si le langage C reste le langage de prédilection pour l’implémentation d’algorithmes complexes et gourmands en temps de calcul ou en capacités de stockage, un langage tel que Python suffit dans la plupart des cas. De plus, lorsque ce dernier ne convient pas, il offre toujours la possibilité, pour une grande exigence de rapidité, d’intégrer un code écrit dans un autre langage tel que le C/C++ ou Java, et ce, d’une manière assez simple. La question du choix du langage pour l’ensemble d’un projet est souvent superflue, il est courant aujourd’hui d’utiliser plusieurs langages et de les assembler. Le langage C reste incontournable pour concevoir des applications rapides, en revanche, il est de plus en plus fréquent d’"habiller" un programme avec une interface graphique programmée dans un langage tel que Python.
En résumé, l’utilisation du langage Python n’est pas restreinte à un domaine : elle comprend le calcul scientifique, les interfaces graphiques, la programmation Internet. Sa gratuité, la richesse des extensions disponibles sur Internet le rendent séduisant dans des environnements universitaire et professionnel. Le langage est vivant et l’intérêt qu’on lui porte ne décroît pas. C’est un critère important lorsqu’on choisit un outil parmi la myriade de projets open source. De plus, il existe différentes solutions pour améliorer son principal point faible qui est la vitesse d’exécution.
1.3 Installation du langage Python
1.3.1 Installation du langage Python
Python a l’avantage d’être disponible sur de nombreuses plates-formes comme Microsoft Windows, Linux ou Mac OS X. L’installation sous Windows est simple. Le langage Python est déjà intégré aux systèmes d’exploitation Linux et Mac OS X.
Sous Microsoft Windows, il suffit d’exécuter le fichier ou tout autre version plus récente. En règle générale, il est conseillé de télécharger la dernière version stable du langage, celle avec laquelle le plus grande nombre d’extensions seront compatibles, en particulier toutes celles dont vous avez besoin. Les options d’installation choisies sont celles par défaut, le répertoire d’installation est par défaut C:/Python26. A la fin de cette installation apparaît un menu supplémentaire dans le menu Démarrer (ou Start) de Microsoft Windows comme le montre la figure 1.1. Ce menu contient les intitulés suivant :
IDLE (Python GUI) éditeur de texte, pour programmer
Module Docs pour rechercher des informations dans la docu-
mentation
Python (command line) ligne de commande Python
Python Manuals documentation à propos du langage Python Uninstall Python pour désinstaller Python
La documentation (de langue anglaise ) décrit en détail le langage Python, elle inclut également un tutoriel qui permet de le découvrir. La ligne de commande (voir figure 1.2) permet d’exécuter des instructions en langage Python. Elle est pratique pour effectuer des calculs mais il est nécessaire d’utiliser un éditeur de texte pour écrire un programme, de le sauvegarder, et de ne l’exécuter qu’une fois terminé au lieu que chaque ligne de celui-ci ne soit interprétée immédiatement après qu’elle a été écrite comme c’est le cas pour une ligne de commande.
Figure 1.2 : Ligne de commande, la première ligne affecte la valeur 3 à la variable x, la seconde ligne l’affiche.
1.3.2 Particularité de Mac OS X et Linux
Le langage Python est déjà présent sur les ordinateurs d’Apple si ceux-ci sont équipés du système d’exploitation Mac OS X. Il est également présent dans les distributions Linux. L’installation de Python est parfois rendue nécessaire si on désire utiliser la dernière version du langage. L’installation des extensions du langage est similaire à celle d’autres extensions Linux.
Il ne faut pas oublier de vérifier la version du langage Python installée sur l’ordinateur Linux et Mac OS X. Il suffit pour cela de taper la ligne help() pour en prendre connaissance. Cela signifie que toutes les extensions qui doivent être installées doivent l’être pour cette version qu’il est néanmoins possible de mettre à jour .
1.3.3 Utilisation de l’éditeur de texte
La figure 1.1 montre le menu installé par Python dans le menu "Démarrer" de Microsoft Windows. En choisissant l’intitulé "IDLE (Python GUI)", on active la fenêtre de commande de Python(voir figure 1.3). Les instructions sont interprétées au fur et à mesure qu’elles sont tapées au clavier. Après chaque ligne, cette fenêtre de commande conserve la mémoire de tout ce qui a été exécuté. Par exemple :
>>> x = 3
>>> y = 6
>>> z = x * y
>>> print z
18
>>>
Après l’exécution de ces quelques lignes, les variables x, y, z existent toujours. La ligne de commande ressemble à une calculatrice améliorée. Pour effacer toutes les variables créées, il suffit de redémarrer l’interpréteur par l’intermédiaire du menu Shell–>RestartShell. Les trois variables précédentes auront disparu.
Il n’est pas possible de conserver le texte qui a été saisi au clavier, il est seulement possible de rappeler une instruction déjà exécutée par l’intermédiaire de la combinaison de touches ALT + p, pressée une ou plusieurs fois. La combinaison ALT + n permet de revenir à l’instruction suivante. Pour écrire un programme et ainsi conserver toutes les instructions, il faut d’actionner le menu File–>NewWindow qui ouvre une seconde fenêtre qui fonctionne comme un éditeur de texte (voir figure 1.4).
Après que le programme a été saisi, le menu Run?RunModule exécute le programme. Il demande au préalable s’il faut enregistrer le programme et réinitialise l’interpréteur Python pour effacer les traces des exécutions précédentes. Le résultat apparaît dans la première fenêtre (celle de la figure 1.3). La pression des touches "Ctrl + C" permet d’arrêter le programme avant qu’il n’arrive à sa fin.
Remarque 1.7 : fenêtre intempestive
Si on veut se débarrasser de cette fenêtre intempestive qui demande confirma-
tion pour enregistrer les dernières modifications, il suffit d’aller dans le menu
Options–>ConfigureIDLE et de choisir Noprompt sur la quatrième ligne dans la rubrique General (voir figure 1.5). Ce désagrément apparaît sur la plupart des éditeurs de texte et se résout de la même manière.
Cette description succincte permet néanmoins de réaliser puis d’exécuter des programmes. Les autres fonctionnalités sont celles d’un éditeur de texte classique, notamment la touche F1 qui débouche sur l’aide associée au langage Python. Il est possible d’ouvrir autant de fenêtres qu’il y a de fichiers à modifier simultanément.
Néanmoins, il est préférable d’utiliser d’autres éditeurs plus riches comme celui proposé au paragraphe 1.4.1. Ils proposent des fonctions d’édition plus évoluées que l’éditeur installé avec Python.
Figure 1.5 : Cliquer sur
General puis sur Noprompt pour se débarrasser de la fenêtre intempestive qui demande à l’utilisateur de confirmer la sauvegarde des dernières modifications. D’autres éditeurs de texte se comportent de la même manière et disposent d’une option similaire.
1.4 Installation d’un éditeur de texte
1.4.1 Editeur SciTe
Il existe de nombreux éditeurs de texte, payants ou gratuits. Le premier proposé dans ce livre est SciTe, il est gratuit et fonctionne avec de nombreux compilateurs de langages différents (voir figure 1.6). L’éditeur SciTe est léger et son utilisation ne nécessite pas de droits spécifiques . La gestion des erreurs est également plus pratique puisqu’il suffit de cliquer sur une erreur pour que l’éditeur positionne automatiquement le curseur sur la ligne ayant généré cette erreur.
Une fois installé, il faut configurer l’éditeur de manière à ce qu’il puisse utiliser le compilateur Python. Il faut cliquer sur le menu Option et choisir la rubrique Openpython.properties (voir figure 1.6).
Figure 1.6 : Configuration de l’éditeur de texte SciTe. Il faut cliquer sur le menu Option, puis sur Openpython.properties pour ouvrir les paramètres de configuration associées au langage Python.
Après avoir sélectionné ce menu, un fichier texte s’ouvre. Vers la fin, on trouve les lignes suivantes qui contiennent la ligne de commande qui permet d’exécuter un programme Python :
|
if PLAT_WIN .*.py=python -u "$(FileNameExt)" .subsystem.*.py=0 .*.pyw=pythonw -u "$(FileNameExt)" .subsystem.*.pyw=1 |
Il suffit de préciser le répertoire où se trouve l’interpréteur qui devrait être c : /python26 sur Microsoft Windows si le répertoire d’installation par défaut du langage Python n’a pas été modifié.
if PLAT_WIN .*.py=c:\Python26\python -u "$(FileNameExt)" .subsystem.*.py=0 .*.pyw=c:\Python26\pythonw -u "$(FileNameExt)" .subsystem.*.pyw=1
Une fois ce fichier enregistré, il ne reste plus qu’à écrire un programme Python. Une fois terminé, la touche F5 lance son exécution. L’exemple de la figure 1.7 montre un cas où l’exécution a été interrompue par une erreur.
Figure 1.7 : Exécution d’un programme interrompue par une erreur. Pour cet éditeur, il suffit de cliquer sur le message d’erreur pour placer le curseur sur la ligne erronée.
Le site Internet de SciTe propose quelques trucs et astuces pour configurer l’éditeur à votre convenance. Comme à peu près tous les logiciels, il dispose d’une rubrique FAQ (Frequently Asked Questions) qui recense les questions et les réponses les plus couramment posées. Cette rubrique existe pour la plupart des éditeurs et plus généralement pour la plupart des applications disponibles sur Internet.
1.4.2 Python Scripter
Le second éditeur proposé dans ce livre est Python Scripter (voir figure 1.8). Il est plus lourd mais offre plus de fonctionnalités notamment un débugger qui permet d’exécuter pas à pas un programme afin de vérifier chaque ligne de son exécution. Lorsqu’un programme produit de mauvais résultats, la première solution consiste à afficher de nombreux résultats intermédiaires mais cela nécessite d’ajouter des instructions un peu partout dans le programme. La seconde méthode est l’utilisation du débugger. Sans modifier le code informatique, il est possible d’arrêter temporairement l’exécution à une ligne donnée pour inspecter le contenu des variables à cet instant de l’exécution. Ce logiciel fonctionne sans autre manipulation supplémentaire autre que son installation.
Cet éditeur, contrairement à SciTe, ne fonctionne qu’avec Python et ne peut être utilisé avec d’autres langages. Son apparence est adaptée au développement. Il permet également de voir la liste des variables, fonctions, classes, présentes dans un programme.
1.4.3 Eclipse et PyDev
Eclipse est un environnement complet de développement adapté à une multitude de langages dont Python via une extension appelé PyDev . Cette solution s’adresse plus à des gens ayant déjà une expérience en informatique ou souhaitant construire un projet conséquent. En constante évolution, Eclipse est un éditeur très complet mais son utilisation nécessite un apprentissage non négligeable qui n’est pas indispensable pour des projets de petite taille.
1.4.4 Côté Mac OS X : TextWrangler
Un éditeur possible est TextWrangler qui est gratuit. Lorsqu’on programme à la fois sous Microsoft Windows et Linux ou Mac OS X, les fichiers contiennent des codes de fins de lignes différents et l’éditeur vous le fait remarquer à chaque exécution. Pour éviter ce désagrément, il convient d’écraser le fichier contenant le programme en le sauvegardant à nouveau en prenant soin de choisir des fins de lignes identiques à celles du monde Linux. Linux fait également la différence entre les minuscules et les majuscules en ce qui concerne les noms de fichiers contrairement à Microsoft Windows . L’environnement de développement XCode est aussi une solution.
1.4.5 Autres éditeurs
Certains éditeurs de texte sont eux-mêmes écrits en Python, ce qui leur permet de fonctionner sur toutes les plates-formes. Trois sont assez connues, DrPython , Boa Constructor , The Eric Python IDE . Ce dernier s’appuie sur une interface graphique de type pyQt , son interface est riche, presque trop lorsqu’on commence à programmer. Boa Constructor s’appuie sur wxPython et offre des outils permettant de dessiner des interfaces graphiques. DrPython est le plus simple des trois.
Certains éditeurs connus du monde Linux ont été déclinés pour le monde Windows, c’est le cas de Emacs . SciTe est souvent utilisé car c’est le plus simple. Les autres offrent des fonctionnalités variées dont l’utilité n’apparaît que pour des programmes conséquents. Le site officiel répertorie d’autres éditeurs de texte dont certains sont de véritables environnements de développements. Il n’est pas aberrant d’en utiliser plus d’un car chacun d’eux est plus approprié dans telle situation ou pour tel type de programme.
1.4.6 Tabulations
De nombreux éditeurs utilisent les tabulations pour mettre en forme un programme et tenir compte des décalages (indentation) d’un bloc par rapport à un autre. Il est conseillé de remplacer ces tabulations par des espaces, cela évite les confusions et les mauvaises interprétations lorsque tabulations et espaces sont mélangés. La taille d’une tabulation peut varier d’un éditeur à l’autre contrairement aux espaces.
1.5 Premier programme
Après avoir installé le langage Python ainsi qu’un éditeur, il suffit d’écrire quelques lignes pour vérifier que cette première étape s’est achevée correctement. Tous les programmes Python porte l’extension .py.
1.5.1 Afficher le résultat d’un calcul
Le programme suivant, qu’on peut appeler premier.py, affiche le message premiermessage une fois qu’il est exécuté. Le mot-clé print précédant le message - toujours entre guillemets ou entre apostrophes sauf si ce sont des nombres - stipule qu’il faut afficher quelque chose.
