Cours de programmation événementielle python
Programmation Python
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL :
Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la Licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans Texte de dernière page de couverture. Une copie de cette licence est incluse dans l'annexe nommée « Licence de documentation libre GNU ».
Sections
6.1 Écoute
6.2 Discussion
7 Programmer en deux minutes/l'interface de Wikipédia pour programmer
7.1 Structure de l'API Wikipédia
7.2 Dernier modifieur de la page
7.3 Boucle des modifieurs du bistro
7.4 Tous les modifieurs de la page
8 Programmer en deux minutes/un serveur Web
8.1 Serveur HTTP
8.2 9 Afficher un texte
9.1 print()
9.1.1 print formaté
9.2 input()
9.3 raw_input()
9.4 Afficher des caractères spéciaux
9.5 Antislash
9.6 Triple quotes
9.7 Commentaires
9.7.1 Commentaires de bloc
9.8 Couleurs
9.9 Références
10 Structure d'un programme
10.1 Les instructions
10.1.1 Les espaces sont ignorés
10.2 Notion de bloc d'instructions
11.1 Affectations
11.1.1 Réaffectation
11.1.2 Affectations multiples
11.1.3 Affectations parallèles
11.2 Principe de fonctionnement
11.2.1 Exemple
11.2.2 Les références
11.3 Noms des variables
11.4 Références
12 Opérateurs
12.1 Définition
12.2 Présentation des différents opérateurs
12.2.1 les opérateurs d'affectation
12.2.2 les opérateurs logiques
12.2.3 les opérateurs de comparaisons
12.2.4 les opérateurs mathématiques
12.3 Priorité des opérations
12.4 Références
12.5 Opérateurs et expressions
12.6 Composition
13 Structures de contrôle
13.1 Définition
13.2 Séquence d'instructions
13.3 Sélection ou exécution conditionnelle
13.4 Instructions imbriquées
13.5 pass
14 Instructions répétitives
14.1 L'instruction "while"
14.1.1 Remarques
14.2 Construction d'une suite mathématique
14.3 L'instruction "for"
14.4 Les instructions "break", "continue"
15.1 Typage des variables
15.2 Types natifs
15.3 Détermination d'un type
15.4 Conversion des types 16 Numériques
16.1 Les nombres entiers de type int
16.2 Les nombres entiers de type long
16.2.1 Limite entre « integer » et « long »
16.3 Les nombres à virgule flottante (float)
16.4 Les nombres complexes
17.1 Définition
17.2 Exemple d'expressions booléennes
17.2.1 And
17.2.2 Not
17.2.3 Or
17.2.4 bool()
17.3 Note sur les opérateurs booléens
17.4 Véracité/fausseté d'une expression
17.5 Exemple
18 Chaines de caractères
18.1 Les données alphanumériques
18.1.1 Le type « string »
18.2 Accès aux caractères individuels d'une chaîne
18.3 Taille des chaines
18.4 Sous-chaines
18.5 Concaténation
18.6 Parcours d'une séquence : for in
18.7 Appartenance d'un élément à une séquence : if.. in
18.8 Les chaînes sont des séquences non modifiables
18.9 Les chaînes sont comparables
18.10 Encodage
18.11 Classement des caractères
18.12 Méthodes des objets string
18.13 Références
19.1 Déclaration
19.2 Lecture
19.2.1 Types
19.2.2 Recherche
19.3 Modification
19.3.1 Affectation
19.3.2 Opérations
19.3.3 Techniques de slicing avancées pour modifier une liste
19.3.3.1 Insertion
19.3.3.2 Suppression
19.3.3.3 Différence
19.3.3.4 Intersection
19.3.4 Copie
19.4 Méthodes
19.4.1 append
19.4.2 split
19.4.3 join
19.4.4 pop
19.5 Fonctions
19.5.1 len
19.5.2 del et max
19.5.4 range
19.5.5 Parcours d'une liste à l'aide de for, range() et len()
19.5.5.1 Une conséquence du typage dynamique
19.5.6 random
19.5.6.1 Exemple de résultats affichés par un programme de ce type
19.5.6.2 Tirage au hasard de nombres entiers
19.5.7 map
19.6 Exercices
20 Tuples
20.1 Description d'un tuple
21 Dictionnaires
21.1 Déclarations
21.2 Création d'un dictionnaire
21.3 Opérations sur les dictionnaires
21.4 Les dictionnaires sont des objets
21.4.1 keyset values
21.4.2 has_key
21.4.3 items
21.4.4 copy
21.4.5 update
21.5 Parcours d'un dictionnaire
21.6 Les clés ne sont pas nécessairement des chaînes de caractères
21.7 Les dictionnaires ne sont pas des séquences
21.8 Construction d'un histogramme à l'aide d'un dictionnaire
21.9 Contrôle du flux d'exécution à l'aide d'un dictionnaire
22 Dates
22.1 Module datetime
22.2 Syntaxe
22.3 Références 23 Ensembles
23.1 Définition
23.2 Construction d'ensembles
23.3 Recherche de membre
23.4 Retrait de membre
23.5 Itération des ensembles
23.6 Opérations sur les ensembles
23.6.1 Intersection
23.6.2 Union
23.6.3 Différence symétrique
23.6.4 Différence
23.7 Opérations non binaires
23.8 frozenset
23.9 Exercices
23.10 Références
24.1 Définir une fonction
24.2 Fonctionnement
24.2.1 Récursivité
24.2.2 Passage d'argument
24.2.3 Arguments facultatifs
24.2.4 Arguments nommés
24.3 Fonction lambda
24.4 Récupérer les arguments de la ligne de commande
24.5 Variables locales, variables globales
24.6 Utilisation des fonctions dans un script
24.7 Modules de fonctions
25.1 Définition
25.2 Importer un module
25.3 Modules personnalisés
25.4 Liste des modules standards
25.4.1 Exemple du module "math"
25.5 Références
26 Exercices sur les bases du langage
26.1 Révision
26.1.1 Contrôle du flux - Utilisation d'une liste simple
26.1.2 Boucle while - Instructions imbriquées
26.2 Exercices
26.2.1 Exercice 1 26.2.2 Exercice 2 26.2.3 Exercice 3 26.2.4 Exercice 4
26.2.5 Exercice 5
27.1 Syntaxe
27.2 Recherche
27.2.1 group()
27.2.2 Flags
27.2.2.1 re.IGNORECASE
27.2.2.2 re.MULTILINE
27.2.2.3 re.DOTALL
27.3 Remplacement
27.4 Exemples de formules
27.5 Références
28 Programmation orientée objet pour les non-programmeurs
28.1 Le concept objet
28.1.1 Le critère descriptif
28.1.2 Le critère d'interaction
28.1.3 l'héritage et l'implémentation
28.2 Utilité des classes 29 Classes
29.1 Définition d'une classe élémentaire
29.2 Attributs (ou variables) d'instance
29.3 Passage d'objets comme arguments lors de l'appel d'une fonction
29.4 Similitude et unicité
29.5 Objets composés d'objets
29.6 Objets comme valeurs de retour d'une fonction
29.7 Les objets sont modifiables
29.8 Définition d'une méthode
29.9 Méthodes prédéfinies
29.9.1 __doc__
29.9.2 __contains__
29.9.3 __del__
29.9.4 __enter__ et __exit__
29.9.5 __ init __
29.9.6 __main__
29.9.7 __new__
29.9.8 __repr__
29.9.9 __str__
29.9.10 __unicode__
29.9.11 Opérateurs binaires
29.9.12 Opérateurs unaires
29.9.13 Gestion des attributs
29.9.14 Gestion des indices
29.9.15 Divers
29.10 Espaces de noms des classes et instances
29.11 Héritage
29.12 Héritage et polymorphisme
29.13 Exercices
29.14 Références
30 Classes et Interfaces graphiques
30.1 « Code des couleurs » : un petit projet bien encapsulé
30.2 « Petit train » : héritage, échange d'informations entre classes
30.3 « OscilloGraphe » : un widget personnalisé
30.4 « Curseurs » : un widget composite
30.4.1 Présentation du widget « Scale »
30.4.2 Construction d'un panneau de contrôle à trois curseurs
30.4.2.1 Commentaires
30.4.2.2 Propagation des évènements
30.5 Intégration de widgets composites dans une application synthèse
30.5.1 Commentaires
30.6 Notes
31.1 Utilité des fichiers
31.2 Travailler avec des fichiers
31.3 Noms de fichiers - Répertoire courant
31.4 Les deux formes d'importation
31.5 Écriture séquentielle dans un fichier
31.6 Lecture séquentielle d'un fichier
31.7 Exemple avec une boucle
31.8 Fichiers texte
31.9 Enregistrement et restitution de variables diverses
31.10 Exercices
31.11 Notes
31.12 Sources
32 Exceptions
32.1 Principe
32.2 Syntaxe
32.3 Exemple
33 Bases de données
33.1 MySQL
33.2 Postgres
33.3 Installation de Gadfly
33.3.1 Sous Windows
33.3.2 Sous Linux
33.4 Références
33.5 Liens externes
34 Gestion d'une base de données
34.1 Les bases de données
34.1.1 SGBDR - Le modèle client/serveur
34.1.2 Le langage SQL - Gadfly
34.2 Mise en œuvre d'une base de données simple avec Gadfly
34.2.1 Création de la base de données
34.2.2 Connexion à une base de données existante
34.2.3 Recherches dans une base de données
34.2.4 La requête select
34.3 Ébauche d'un logiciel client pour MySQL
34.3.1 Décrire la base de données dans un dictionnaire d'application
34.3.2 Définir une classe d'objets-interfaces
34.3.3 Construire un générateur de formulaires
34.3.4 Le corps de l'application
34.4 Notes
35 L'interface CGI
35.1 Description
35.2 Installation
35.3 Exemples
35.3.1 Une interaction CGI rudimentaire
35.3.2 Un formulaire HTML pour l'acquisition des données
35.3.3 Un script CGI pour le traitement des données
35.4 Références
36 Applications web
36.1 Pages web interactives 36.2 Un serveur web en pur Python !
36.2.1 Installation de Karrigell 36.2.2 Démarrage du serveur :
36.2.3 Ébauche de site web
36.2.4 Prise en charge des sessions
36.2.5 Autres développements
36.3 Notes
37.1 Communication entre programmes
37.2 Les sockets
37.3 Construction d'un serveur élémentaire
37.4 Construction d'un client rudimentaire
37.5 Récupérer une page Web en python
37.5.1 Afficher une page Web
37.6 Références
38 Threads
38.1 Gestion de plusieurs tâches en parallèle à l'aide des threads
38.2 Client gérant l'émission et la réception simultanées
38.3 Serveur gérant les connexions de plusieurs clients en parallèle
38.4 Jeu des bombardes, version réseau
38.4.1 Programme serveur : vue d'ensemble
38.4.2 Protocole de communication
38.4.3 Programme serveur : première partie
38.4.4 Synchronisation de threads concurrents à l'aide de « verrous » (thread locks)
38.4.5 Programme serveur : suite et fin
38.4.6 Programme client
38.5 Utilisation de threads pour optimiser les animations.
38.5.1 Temporisation des animations à l'aide de after()
38.5.2 Temporisation des animations à l'aide de time.sleep()
38.5.3 Exemple concret
39 Bibliothèques pour Python
39.1 Bibliothèques standards
39.2 Bibliothèques alternatives
39.3 Références
40 L'interface graphique
40.1 L'interface graphique pour Python
41 Utilisation de fenêtres et de graphismes
41.1 Interfaces graphiques (GUI)
41.2 Premiers pas avec Tkinter
41.3 Programmes pilotés par des événements
41.3.1 Exemple graphique : détection et positionnement d'un clic de souris
41.4 Les classes de widgets Tkinter
41.5 Utilisation de la méthode grid() pour contrôler la disposition des widgets
41.5.1 Analysons à présent la fenêtre suivante :
41.5.2 Nous pouvons remarquer un certain nombre de choses dans ce script :
41.6 Composition d'instructions pour écrire un code plus compact
41.7 Modification des propriétés d'un objet - Animation
41.8 Animation automatique - Récursivité
42.1 Créer des interfaces python avec Tkinter
42.1.1 Que faut il posséder d'abord ?
42.1.2 Principes de base
42.1.3 Créer une fenêtre pour l'application
42.1.3.1 Propriétés et méthodes de l'objet fenêtre
42.1.4 Qu'est-ce qu'un widget ?
42.1.5 Le widget Button
42.1.5.1 propriétés et méthodes de l'objet "bouton"
42.1.6 Le widget Label
42.1.6.1 Propriétés et méthodes de l'objet label
42.1.7 Le widget Entry
42.1.7.1 Propriétés et méthodes de l'objet Entry
42.1.8 Le widget Canvas
42.1.8.1 Quelques propriétés de l'objet Canvas
42.1.8.2 Quelques méthodes du widget Canvas
42.1.8.3 Exemple supplémentaire
42.2 Images .gif
42.3 Installation des Python méga-widgets
42.4 Voir aussi
43 Et pour quelques widgets de plus
43.1 Les « boutons radio »
43.2 Utilisation des cadres (frames) pour la composition d'une fenêtre
43.3 Comment déplacer des dessins à l'aide de la souris
43.4 Python Mega Widgets
43.4.1 « Combo Box »
43.4.2 Remarque concernant l'entrée de caractères accentués
43.4.3 « Scrolled Text »
43.4.4 « Scrolled Canvas »
43.4.5 Barres d'outils avec bulles d'aide - expressions lambda
43.4.6 Métaprogrammation. Expressions lambda :
43.5 Fenêtres avec menus
43.5.1 Première ébauche du programme : 43.5.2 Ajout de la rubrique « Musiciens »
43.5.3 Ajout de la rubrique « Peintres » :
43.5.4 Ajout de la rubrique « Options » :
43.6 Notes
44.1 Fonctions disponibles
44.1.1 Fonctions principales
44.1.2 Autres fonctions
44.2 Détails des fonctions
44.2.1 color()
44.2.2 Fill
44.3 Exemples
44.4 Compléments
44.5 Exemples
44.5.1 Tracer une spirale quelconque
44.5.2 Tracer une lanterne
44.6 Un peu de détente avec le module turtle
45 Les threads
45.1 Exemples
45.1.1 Appel de fonction
45.1.2 Objet
45.2 Références
46.1 La méthode SAX
46.2 La méthode DOM
46.3 Références
47.1 Tests unitaires
47.1.1 Syntaxe
47.1.2 Exemples
47.2 Références
49 Exemples de scripts
49.1 Exemples de codes représentatifs
49.1.1 Une introduction
49.1.2 Les structures de données en natif
49.1.3 Accès a une base de données
49.1.4 Programmation réseau - Internet
49.1.5 Tracé de courbes avec matplotlib
49.1.6 Utilitaires de la bibliothèque standard
49.1.7 Jython : utilisation de Java en Python
49.1.8 Mail
49.1.9 Classe
49.1.10 WMI (sous Windows 2000/XP)
49.1.11 Automation Win32
49.1.12 ctypes
49.1.13 Data Mining - Réseaux bayésiens avec reverend
49.1.14 Implémentation du crible d'Ératosthène
49.1.15 Les fonctions, les types et les classes sont des objets
49.2 Graphique
49.2.1 Tkinter
56.3 Les modules
Avant-propos
Grace Hopper, inventeur du compilateur :
« Pour moi, la programmation est plus qu'un art appliqué important. C'est aussi une ambitieuse quête menée dans les tréfonds de la connaissance. »
Choix d'un premier langage de programmation
Ce livre est censé vous permettre d'apprendre à programmer à partir du langage Python. Pourquoi Python ? Il existe en effet plusieurs centaines de langages de programmation, chacun avec ses avantages et ses inconvénients. Parmi ces derniers, on compte :
Ils sont liés à des environnements de programmation (c'est-à-dire des logiciels) propriétaires.
Cela signifie donc, non seulement que l'institution scolaire désireuse de les utiliser devrait acheter une licence de ces logiciels pour chaque poste de travail (ce qui risque de se révéler assez coûteux), mais surtout que les utilisateurs souhaitant exercer leurs compétences de programmation ailleurs qu'à l'école seraient implicitement forcés d'en acquérir eux aussi des licences.
Ce sont des langages spécifiquement liés au seul système d'exploitation Windows. Ils ne sont pas « portables » sur d'autres systèmes (Unix, MacOS, etc.). Cela ne cadre pas avec un projet pédagogique qui ambitionne d'inculquer une formation générale (et donc diversifiée) dans laquelle les invariants de l'informatique seraient autant que possible mis en évidence.
Nous avons alors décidé d'examiner l'offre alternative, c'est-à-dire celle qui est proposée gratuitement dans la mouvance de l'informatique libre (open source). Copiable et modifiable librement au gré de son acquéreur, il est généralement le produit de la collaboration bénévole de centaines de développeurs enthousiastes dispersés dans le monde entier. Son code source étant "épluché" par de très nombreux spécialistes (étudiants et professeurs universitaires), un logiciel libre se caractérise la plupart du temps par un bon niveau de qualité technique. Le plus célèbre des logiciels libres est le système d'exploitation GNU/Linux, dont la popularité ne cesse de s'accroître de jour en jour.
Ce que nous avons trouvé nous a enthousiasmé : non seulement il existe dans le monde de l'open source des interpréteurs et des compilateurs gratuits pour toute une série de langages, mais le véritable cadeau réside dans le fait que ces langages sont modernes, performants, portables (c'est-à-dire utilisables sur différents systèmes d'exploitation tels que Windows, Linux, ou MacOS), et fort bien documentés.
Le langage dominant y est sans conteste C. Ce langage s'impose comme une référence absolue, et tout informaticien sérieux doit s'y frotter tôt ou tard. Il est malheureusement très rébarbatif et compliqué, trop proche de la machine. Sa syntaxe est peu lisible et fort contraignante. La mise au point d'un gros logiciel écrit en langage C est longue et pénible. (Les mêmes remarques valent aussi dans une large mesure pour le langage Java).
Pour nos débuts dans l'étude de la programmation, il nous semble préférable d'utiliser un langage de plus haut niveau, c'est-à-dire plus proche du langage humain que du langage machine, donc plus lisible et moins contraignant.
Après avoir successivement examiné et expérimenté quelque peu les langages Perl et Tcl/Tk , nous avons finalement décidé d'adopter Python, langage très moderne à la popularité grandissante.
La démarche du programmeur
Le but de ce cours est de vous apprendre à penser et à réfléchir comme un analyste-programmeur. Ce mode de pensée combine des démarches intellectuelles complexes, similaires à celles qu'accomplissent les mathématiciens, les ingénieurs et les scientifiques.
Comme le mathématicien, l'analyste-programmeur utilise des langages formels pour décrire des raisonnements (ou algorithmes). Comme l'ingénieur, il conçoit des dispositifs, il assemble des composants pour réaliser des mécanismes et il évalue leurs performances. Comme le scientifique, il observe le comportement de systèmes complexes, il ébauche des hypothèses explicatives, il teste des prédictions.
Remarque : l'activité essentielle d'un analyste-programmeur est la résolution de problèmes.
Il s'agit là d'une compétence de haut niveau, qui implique des capacités et des connaissances diverses : être capable de (re)formuler un problème de plusieurs manières différentes, être capable d'imaginer des solutions innovantes et efficaces, être capable d'exprimer ces solutions de manière claire et complète.
La programmation d'un ordinateur consiste en effet à « expliquer » en détail à une machine ce qu'elle doit faire, en sachant d'emblée qu'elle ne peut pas véritablement « comprendre » un langage humain, mais seulement effectuer un traitement automatique sur des séquences de caractères.
Un programme n'est rien d'autre qu'une suite d'instructions, encodées en respectant de manière très stricte un ensemble de conventions fixées à l'avance que l'on appelle un langage informatique. La machine est ainsi pourvue d'un mécanisme qui décode ces instructions en associant à chaque « mot » du langage une action précise.
Vous allez donc apprendre à programmer, activité déjà intéressante en elle-même parce qu'elle contribue à développer votre intelligence. Mais vous serez aussi amené à utiliser la programmation pour réaliser des projets concrets, ce qui vous procurera certainement de très grandes satisfactions.
Langage machine, langage de programmation
A strictement parler, un ordinateur n'est rien d'autre qu'une machine effectuant des opérations simples sur des séquences de signaux électriques, lesquels sont conditionnés de manière à ne pouvoir prendre que deux états seulement (par exemple un potentiel électrique maximum ou minimum). Ces séquences de signaux obéissent à une logique du type « tout ou rien » et peuvent donc être considérés conventionnellement comme des suites de nombres ne prenant jamais que les deux valeurs 0 et 1. Un système numérique ainsi limité à deux chiffres est appelé système binaire.
Sachez dès à présent que dans son fonctionnement interne, un ordinateur est totalement incapable de traiter autre chose que des nombres binaires. Toute information d'un autre type doit être convertie, ou codée, en format binaire. Cela est vrai non seulement pour les données que l'on souhaite traiter (les textes, les images, les sons, les nombres, etc.), mais aussi pour les programmes, c'est-à-dire les séquences d'instructions que l'on va fournir à la machine pour lui dire ce qu'elle doit faire avec ces données.
Le seul « langage » que l'ordinateur puisse véritablement « comprendre » est donc très éloigné de ce que nous utilisons nous-mêmes. C'est une longue suite de 1 et de 0 (les "bits") souvent traités par groupes de 8 (les « octets »), 16, 32, ou même 64. Ce « langage machine » est évidemment presqu'incompréhensible pour nous. Pour « parler » à un ordinateur, il nous faudra utiliser des systèmes de traduction automatiques, capables de convertir en nombres binaires des suites de caractères formant des mots-clés (anglais en général) qui seront plus significatifs pour nous.
Ces systèmes de traduction automatique seront établis sur la base de toute une série de conventions, dont il existera évidemment de nombreuses variantes.
Le système de traduction proprement dit s'appellera interpréteur ou bien compilateur, suivant la méthode utilisée pour effectuer la traduction (voir ci-après). On appellera langage de programmation un ensemble de mots-clés (choisis arbitrairement) associé à un ensemble de règles très précises indiquant comment on peut assembler ces mots pour former des « phrases » que l'interpréteur ou le compilateur puisse traduire en langage machine (binaire).
Suivant son niveau d'abstraction, on pourra dire d'un langage qu'il est « de bas niveau » (ex : Assembleur) ou « de haut niveau » (ex : Pascal, Perl,
Smalltalk, Clarion, Java…). Un langage de bas niveau est constitué d'instructions très élémentaires, très « proches de la machine ». Un langage de haut niveau comporte des instructions plus abstraites ou, plus « puissantes ». Cela signifie que chacune de ces instructions pourra être traduite par l'interpréteur ou le compilateur en un grand nombre d'instructions machine élémentaires.
Le langage que vous allez apprendre en premier est Python. Il s'agit d'un langage de haut niveau, dont la traduction en codes binaires est complexe et prend donc toujours un certain temps. Cela pourrait paraître un inconvénient. En fait, les avantages que présentent les langages de haut niveau sont énormes : il est beaucoup plus facile d'écrire un programme dans un langage de haut niveau ; l'écriture du programme prend donc beaucoup moins de temps ; la probabilité d'y faire des fautes est nettement plus faible ; la maintenance (c'est-à-dire l'apport de modifications ultérieures) et la recherche des erreurs (les « bugs ») sont grandement facilitées. De plus, un programme écrit dans un langage de haut niveau sera souvent portable, c'est-à-dire que l'on pourra le faire fonctionner sans grosses modifications sur des machines ou des systèmes d'exploitation différents. Un programme écrit dans un langage de bas niveau ne peut jamais fonctionner que sur un seul type de machine : pour qu'une autre l'accepte, il faut le réécrire entièrement.
Compilation et interprétation
Le programme tel que nous l'écrivons à l'aide d'un logiciel éditeur (une sorte de traitement de texte spécialisé) sera appelé désormais programme source (ou code source). Comme déjà signalé plus haut, il existe deux techniques principales pour effectuer la traduction d'un tel programme source en code binaire exécutable par la machine : l'interprétation et la compilation.
Dans la technique appelée interprétation, le logiciel interpréteur doit être utilisé chaque fois que l'on veut faire fonctionner le programme. Dans cette technique en effet, chaque ligne du programme source analysé est traduite au fur et à mesure en quelques instructions du langage machine, qui sont ensuite directement exécutées. Aucun programme objet n'est généré.
La compilation consiste à traduire la totalité du texte source en une fois. Le logiciel compilateur lit toutes les lignes du programme source et produit une nouvelle suite de codes que l'on appelle programme objet (ou code objet). Celui-ci peut désormais être exécuté indépendamment du compilateur et être conservé tel quel dans un fichier (« fichier exécutable »).
Chacune de ces deux techniques a ses avantages et ses inconvénients :
L'interprétation est idéale lorsque l'on est en phase d'apprentissage du langage, ou en cours d'expérimentation sur un projet. Avec cette technique, on peut en effet tester immédiatement toute modification apportée au programme source, sans passer par une phase de compilation qui demande toujours du temps.
Par contre, lorsqu'un projet comporte des fonctionnalités complexes qui doivent s'exécuter rapidement, la compilation est préférable : il est clair en effet qu'un programme compilé fonctionnera toujours nettement plus vite que son homologue interprété, puisque dans cette technique l'ordinateur n'a plus à (re)traduire chaque instruction en code binaire avant qu'elle puisse être exécutée.
Certains langages modernes tentent de combiner les deux techniques afin de retirer le meilleur de chacune. C'est le cas de Python et aussi de Java. Lorsque vous lui fournissez un programme source, Python commence par le compiler pour produire un code intermédiaire, similaire à un langage machine, que l'on appelle bytecode, lequel sera ensuite transmis à un interpréteur pour l'exécution finale. Du point de vue de l'ordinateur, le bytecode est très facile à interpréter en langage machine. Cette interprétation sera donc beaucoup plus rapide que celle d'un code source.
Les avantages de cette méthode sont appréciables :
Le fait de disposer en permanence d'un interpréteur permet de tester immédiatement n'importe quel petit morceau de programme. On pourra donc vérifier le bon fonctionnement de chaque composant d'une application au fur et à mesure de sa construction.
L'interprétation du bytecode compilé n'est pas aussi rapide que celle d'un véritable code binaire, mais elle est très satisfaisante pour de très nombreux programmes, y compris graphiques.
Le bytecode est portable. Pour qu'un programme Python ou Java puisse s'exécuter sur différentes machines, il suffit de disposer pour chacune d'elles d'un interpréteur adapté.
Tout ceci peut vous paraître un peu compliqué, mais la bonne nouvelle est que tout ceci est pris en charge automatiquement par l'environnement de développement de Python. Il vous suffira d'entrer vos commandes au clavier, de frapper , et Python se chargera de les compiler et de les interpréter pour vous.
Mise au point d'un programme - Recherche des erreurs (« debug »)
La programmation est une démarche très complexe, et comme c'est le cas dans toute activité humaine, on y commet de nombreuses erreurs. Pour des raisons anecdotiques, les erreurs de programmation s'appellent des « bugs » (ou « bogues », en France)[1], et l'ensemble des techniques que l'on met en œuvre pour les détecter et les corriger s'appelle debug (ou déboguage).
En fait, il peut exister dans un programme trois types d'erreurs assez différentes, et il convient que vous appreniez à bien les distinguer :
Erreurs de syntaxe
Python ne peut exécuter un programme que si sa syntaxe est parfaitement correcte. Dans le cas contraire, le processus s'arrête et vous obtenez un message d'erreur. Le terme syntaxe se réfère aux règles que les auteurs du langage ont établies pour la structure du programme.
Tout langage comporte sa syntaxe. Dans la langue française, par exemple, une phrase doit toujours commencer par une majuscule et se terminer par un point. ainsi cette phrase comporte deux erreurs de syntaxe
Dans les textes ordinaires, la présence de quelques petites fautes de syntaxe par-ci par-là n'a généralement pas d'importance. Il peut même arriver (en poésie, par exemple), que des fautes de syntaxe soient commises volontairement. Cela n'empêche pas que l'on puisse comprendre le texte.
Dans un programme d'ordinateur, par contre, la moindre erreur de syntaxe produit invariablement un arrêt de fonctionnement (un « plantage ») ainsi que l'affichage d'un message d'erreur. Au cours des premières semaines de votre carrière de programmeur, vous passerez certainement pas mal de temps à rechercher vos erreurs de syntaxe. Avec de l'expérience, vous en commettrez beaucoup moins.
Gardez à l'esprit que les mots et les symboles utilisés n'ont aucune signification en eux-mêmes : ce ne sont que des suites de codes destinés à être convertis automatiquement en nombres binaires. Par conséquent, il vous faudra être très attentifs à respecter scrupuleusement la syntaxe du langage.
Il est heureux que vous fassiez vos débuts en programmation avec un langage interprété tel que Python. La recherche des erreurs y est facile et rapide. Avec les langages compilés (tel C++), il vous faudrait recompiler l'intégralité du programme après chaque modification, aussi minime soit-elle.
Erreurs sémantiques
Le second type d'erreur est l'erreur sémantique ou erreur de logique. S'il existe une erreur de ce type dans un de vos programmes, celui-ci s'exécute parfaitement, en ce sens que vous n'obtenez aucun message d'erreur, mais le résultat n'est pas celui que vous attendiez : vous obtenez autre chose.
En réalité, le programme fait exactement ce que vous lui avez dit de faire. Le problème est que ce que vous lui avez dit de faire ne correspond pas à ce que vous vouliez qu'il fasse. La séquence d'instructions de votre programme ne correspond pas à l'objectif poursuivi. La sémantique (la logique) est incorrecte.
Rechercher des fautes de logique peut être une tâche ardue. Il faut analyser ce qui sort de la machine et tâcher de se représenter une par une les opérations qu'elle a effectuées, à la suite de chaque instruction.
Erreurs à l'exécution
Le troisième type d'erreur est l'erreur en cours d'exécution (Run-time error), qui apparaît seulement lorsque votre programme fonctionne déjà, mais que des circonstances particulières se présentent (par exemple, votre programme essaie de lire un fichier qui n'existe plus). Ces erreurs sont également appelées des exceptions, parce qu'elles indiquent généralement que quelque chose d'exceptionnel s'est produit (et qui n'avait pas été prévu). Vous rencontrerez davantage ce type d'erreur lorsque vous programmerez des projets de plus en plus volumineux.
Recherche des erreurs et expérimentation
L'une des compétences les plus importantes à acquérir au cours de votre apprentissage est celle qui consiste à déboguer efficacement un programme. Il s'agit d'une activité intellectuelle parfois énervante mais toujours très riche, dans laquelle il faut faire preuve de beaucoup de perspicacité, persévérance et de patience.
Ce travail ressemble par bien des aspects à une enquête policière. Vous examinez un ensemble de faits, et vous devez émettre des hypothèses explicatives pour reconstituer les processus et les événements qui ont logiquement entraîné les résultats que vous constatez.
Cette activité s'apparente aussi au travail expérimental en sciences. Vous vous faites une première idée de ce qui ne va pas, vous modifiez votre programme et vous essayez à nouveau. Vous avez émis une hypothèse, qui vous permet de prédire ce que devra donner la modification. Si la prédiction se vérifie, alors vous avez progressé d'un pas sur la voie d'un programme qui fonctionne. Si la prédiction se révèle fausse, alors il vous faut émettre une nouvelle hypothèse. Comme l'a bien dit Sherlock Holmes : « Lorsque vous avez éliminé l'impossible, ce qui reste, même si c'est improbable, doit être la vérité » (A. Conan Doyle, Le signe des quatre).