Apprendre Python utilisation de fenêtres et de graphismes

Premiers pas

Apprendre à programmer avec Python, il est temps de se mettre au travail. Plus exactement, nous allons demander à l’ordinateur de travailler à notre place, en lui donnant, par exemple, l’ordre d’effectuer une addition et d’afficher le résultat.
Pour cela, nous allons devoir lui transmettre des « instructions », et également lui indiquer les « données » auxquelles nous voulons appliquer ces instructions.

Calculer avec Python

Python présente la particularité de pouvoir être utilisé de plusieurs manières différentes. Vous allez d’abord l’utiliser en mode interactif, c’est-à-dire d’une manière telle que vous pourrez dialoguer avec lui directement depuis le clavier. Cela vous permettra de découvrir très vite un grand nombre de fonctionnalités du langage. Dans un second temps, vous apprendrez comment créer vos premiers programmes (scripts) et les sauvegarder sur disque.
L’interpréteur peut être lancé directement depuis la ligne de commande (dans un « shell » Linux, ou bien dans une fenêtre DOS sous Windows) : il suffit d’y taper la commande python » » (en supposant que le logiciel lui-même ait été correctement installé).
Si vous utilisez une interface graphique telle que Windows, Gnome, WindowMaker ou KDE, vous préférerez vraisemblablement travailler dans une « fenêtre de terminal », ou encore dans un environnement de travail spécialisé tel que IDLE. Voici par exemple ce qui apparaît dans une fenêtre de terminal KDE (sous Linux)5 :
Sous Linux, nous préférons personnellement travailler dans l’environnement graphique WindowMaker (plutôt que KDE ou Gnome trop gourmands en ressources), en ouvrant une simple fenêtre de terminal pour lancer l’interpréteur Python ou l’exécution des scripts, et en faisant appel à l’excellent logiciel Nedit pour l’édition de ces derniers.
Avec IDLE sous Windows, votre environnement de travail ressemblera à celui-ci :
Les trois caractères « supérieur à » constituent le signal d’invite, ou prompt principal, lequel vous indique que Python est prêt à exécuter une commande.
Par exemple, vous pouvez tout de suite utiliser l’interpréteur comme une simple calculatrice de bureau. Veuillez donc vous-même tester les commandes ci-dessous (Prenez l’habitude d’utiliser votre cahier d’exercices pour noter les résultats qui apparaissent à l’écran) :
5+3
2 – 9# les espaces sont optionnels
7 + 3 * 4# la hiérarchie des opérations mathématiques
est-elle respectée ?
(7+3)*4
20 / 3# surprise !!!
Comme vous pouvez le constater, les opérateurs arithmétiques pour l’addition, la soustraction, la multiplication et la division sont respectivement +, -, * et /. Les parenthèses sont fonctionnelles.
Par défaut, la division est cependant une division entière , ce qui signifie que si on lui fournit des arguments qui sont des nombres entiers, le résultat de la division est lui-même un entier (tronqué), comme dans le dernier exemple ci-dessus. Si vous voulez qu’un argument soit compris par Python comme étant un nombre réel, il faut le lui faire savoir, en fournissant au moins un point décimal6.
Essayez par exemple :
20.0 / 3# (comparez le résultat avec celui obtenu à l’exercice précédent)
8./5
Si une opération est effectuée avec des arguments de types mélangés (entiers et réels), Python convertit automatiquement les opérandes en réels avant d’effectuer l’opération. Essayez :
4*2.5/3.3
6 Dans tous les langages de programmation, les conventions mathématiques de base sont celles en vigueur dans les pays anglophones : le séparateur décimal sera donc toujours un point, et non une virgule comme chez nous. Dans le monde de l’informatique, les nombres réels sont souvent désignés comme des nombres « à virgule flottante », ou encore des nombres « de type float ».

Données et variables

Nous aurons l’occasion de détailler plus loin les différents types de données numériques. Mais avant cela, nous pouvons dès à présent aborder un concept de grande importance :
L’essentiel du travail effectué par un programme d’ordinateur consiste à manipuler desdonnées . Ces données peuvent être très diverses (tout ce qui est numérisable , en fait7), mais dans la mémoire de l’ordinateur elles se ramènent toujours en définitive à une suite finie de nombres binaires.
Pour pouvoir accéder aux données, le programme d’ordinateur (quel que soit le langage dans lequel il est écrit) fait abondamment usage d’un grand nombre devariables de différents types.
Une variable apparaît dans un langage de programmation sous un nom de variable à peu près quelconque (voir ci-après), mais pour l’ordinateur il s’agit d’uneréférence désignant une adresse mémoire , c’est-à-dire un emplacement précis dans la mémoire vive.
A cet emplacement est stocké une valeur bien déterminée. C’est la donnée proprement dite, qui est donc stockée sous la forme d’une suite de nombres binaires, mais qui n’est pas nécessairement un nombre aux yeux du langage de programmation utilisé. Cela peut être en fait à peu près n’importe quel « objet » susceptible d’être placé dans la mémoire d’un ordinateur, par exemple : un nombre entier, un nombre réel, un nombre complexe, un vecteur, une chaîne de caractères typographiques, un tableau, une fonction, etc.
Pour distinguer les uns des autres ces divers contenus possibles, le langage de programmation fait usage de différents types de variables. (le type ‘entier’, le type ‘réel’, le type ‘chaîne de caractères’, le type ‘liste’, etc. ). Nous allons expliquer tout cela dans les pages suivantes.

Noms de variables et mots réservés

Les noms de variables sont des noms que vous choisissez vous-même assez librement. Efforcezvous cependant de bien les choisir : de préférence assez courts, mais aussi explicites que possible, de manière à exprimer clairement ce que la variable est censée contenir. Par exemple, des noms de variables tel que altitude, altit ou alt conviennent mieux que x pour exprimer une altitude.
Un bon programmeur doit veiller à ce que ses lignes d’instructions soient faciles à lire.
Sous Python, les noms de variables doivent en outre obéir à quelques règles simples :
Un nom de variable est une séquence de lettres (a ® z , A ® Z) et de chiffres (0 ® 9), qui doit toujours commencer par une lettre.
Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, à l’exception du caractère _ (souligné).
La casse est significative (les caractères majuscules et minuscules sont distingués). Attention : Joseph, joseph, JOSEPH sont donc des variables différentes. Soyez attentifs !
En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser comme noms de variables les 29 « mots réservés » ci-dessous (ils sont utilisés par le langage lui-même) :
and assert break class continue def
del elif else except exec finally
for from global if import in
is lambda not or pass print
raise return try while yield
8 Les noms commençant par une majuscule ne sont pas interdits, mais l’usage veut qu’on le réserve plutôt aux variables qui désignent des classes (le concept de classe sera abordé plus loin dans ces notes).

Affectation (ou assignation)

Nous savons désormais comment choisir judicieusement un nom de variable. Voyons à présent comment nous pouvons en définir une et lui affecter une valeur. Les termes « affecter une valeur » ou « assigner une valeur » à une variable sont équivalents. Ils désignent l’opération par laquelle on établit un lien entre le nom de la variable et sa valeur (son contenu).
En Python comme dans de nombreux autres langages, l’opération d’affectation est représentée par le signe égale:
n = 7# donner à n la valeur 7
msg = « Quoi de neuf ? » # affecter la valeur « Quoi de neuf ? » à msg
pi = 3.14159# assigner sa valeur à la variable pi
Les exemples ci-dessus illustrent des instructions d’affectation Python tout à fait classiques. Après qu’on les ait exécutées, il existe dans la mémoire de l’ordinateur, à des endroits différents :
trois noms de variables, à savoir n, msg et pi trois séquences d’octets, où sont encodées le nombre entier7, la chaîne de caractères Quoi de neuf ? et le nombre réel 3,14159.
Les trois instructions d’affectation ci-dessus ont eu pour effet chacune de réaliser plusieurs opérations dans la mémoire de l’ordinateur :
créer et mémoriser un nom de variable ;
lui attribuer un type bien déterminé (ce point sera explicité à la page suivante) ;
créer et mémoriser une valeur particulière ;
établir un lien (par un système interne de pointeurs) entre le nom de la variable et l’emplacement mémoire de la valeur correspondante.
On peut mieux se représenter tout cela par un diagramme d’état tel que celui-ci :
n msg pi
# # #
7 Quoi de neuf ? 3.14159
Les trois noms de variables sont des références , mémorisées dans une zone particulière de la mémoire que l’on appelle espace de noms, alors que les valeurs correspondantes sont situées ailleurs, dans des emplacements parfois fort éloignés les uns des autres. Nous aurons l’occasion de préciser ce concept plus loin dans ces pages.
9 Il faut bien comprendre qu’il ne s’agit en aucune façon d’une égalité, et que l’on aurait très bien pu choisir un autre symbolisme, tel que n # 7 par exemple, comme on le fait souvent dans certains pseudo-langages servant à décrire des algorithmes, pour bien montrer qu’il s’agit de relier un contenu (la valeur 7) à un contenant (la variable n).

Afficher la valeur d’une variable

A la suite de l’exercice ci-dessus, nous disposons donc des trois variablesn, msg et pi.
Pour afficher leur valeur à l’écran, il existe deux possibilités. La première consiste à entrer au clavier le nom de la variable, puis <Enter>. Python répond en affichant la valeur correspondante :
n
7
msg
« Quoi de neuf ? »
pi
3.14159
-31-
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l’obtention préalable de l’autorisation de l’auteur.
http://python.developpez.com/cours/TutoSwinnen/
Apprendre à programmer avec Python par
Il s’agit cependant là d’une fonctionnalité secondaire de l’interpréteur, qui est destinée à vous faciliter la vie lorsque vous faites de simples exercices à la ligne de commande. A l’intérieur d’un programme, vous utiliserez toujours l’instructionprint :
print msg Quoi de neuf ?
Remarquez la subtile différence dans les affichages obtenus avec chacune des deux méthodes. L’instructionprint n’affiche strictement que la valeur de la variable, telle qu’elle a été encodée, alors que l’autre méthode (celle qui consiste à entrer seulement le nom de la variable) affiche aussi des guillemets (afin de vous rappeler le type de la variable : nous y reviendrons).

Typage des variables

Sous Python, il n’est pas nécessaire d’écrire des lignes de programme spécifiques pour définir le type des variables avant de pouvoir les utiliser. Il vous suffit en effet d’assigner une valeur à un nom de variable pour que celle-ci soit automatiquement créée avec le type qui correspond au mieux à la valeur fournie . Dans l’exercice précédent, par exemple, les variables n, msg et pi ont été créées automatiquement chacune avec un type différent (« nombre entier » pour n, « chaîne de caractères » pour msg, « nombre à virgule flottante » (ou « float », en anglais) pour pi).
Ceci constitue une particularité intéressante de Python, qui le rattache à une famille particulière de langages où l’on trouve aussi par exemple Lisp, Scheme, et quelques autres. On dira à ce sujet que le typage des variables sous Python est un typage dynamique, par opposition au typage statique qui est de règle par exemple en C++ ou en Java. Dans ces langages, il faut toujours – par des instructions distinctes – d’abord déclarer (définir) le nom et le type des variables, et ensuite seulement leur assigner un contenu, lequel doit bien entendu être compatible avec le type déclaré.
Le typage statique est préférable dans le cas des langages compilés, parce qu’il permet d’optimiser l’opération de compilation (dont le résultat est un code binaire « figé »).
Le typage dynamique quant à lui permet d’écrire plus aisément des constructions logiques de niveau élevé (métaprogrammation, réflexivité), en particulier dans le contexte de la programmation orientée objet (polymorphisme). Il facilite également l’utilisation de structures de données très riches telles que les listes et les dictionnaires.

Affectations multiples

Sous Python, on peut assigner une valeur à plusieurs variables simultanément. Exemple :
x = y = 7
On peut aussi effectuer des affectations parallèles à l’aide d’un seul opérateur :
a, b = 4, 8.33
a
4
b
8.33
Dans cet exemple, les variables a et b prennent simultanément les nouvelles valeurs 4 et 8,33.
Attention : les francophones que nous sommes avons pour habitude d’utiliser la virgule comme séparateur décimal, alors que les langages de programmation utilisent toujours la convention en vigueur dans les pays de langue anglaise, c’est-à-dire le point décimal. La virgule, quant à elle, est très généralement utilisée pour séparer différents éléments (arguments, etc.) comme on le voit dans notre exemple, pour les variables elles-mêmes ainsi que pour les valeurs qu’on leur attribue.
(2) Exercices
2.1. Décrivez le plus clairement et le plus complètement possible ce qui se passe à chacune des trois lignes de l’exemple ci-dessous :
largeur = 20
hauteur = 5 * 9.3
largeur * hauteur
930
2.2. Assignez les valeurs respectives 3, 5, 7 à trois variables a, b, c.
Effectuez l’opération a – b/c . Le résultat est-il mathématiquement correct ?
Si ce n’est pas le cas, comment devez-vous procéder pour qu’il le soit ?

Opérateurs et expressions

On manipule les valeurs et les variables qui les référencent, en les combinant avec des opérateurs pour former des expressions. Exemple :
a, b = 7.3, 12
y = 3*a + b/5
Dans cet exemple, nous commençons par affecter aux variables a et b les valeurs 7,3 et 12. Comme déjà expliqué précédemment, Python assigne automatiquement le type « réel » à la variable a, et le type « entier » à la variable b.
La seconde ligne de l’exemple consiste à affecter à une nouvelle variable y le résultat d’une expression qui combine les opérateurs * , + et / avec les opérandes a, b, 3 et 5. Les opérateurs sont les symboles spéciaux utilisés pour représenter des opérations mathématiques simples, telles l’addition ou la multiplication. Les opérandes sont les valeurs combinées à l’aide des opérateurs.
Python évalue chaque expression qu’on lui soumet, aussi compliquée soit-elle, et le résultat de cette évaluation est toujours lui-même une valeur. A cette valeur, il attribue automatiquement un type, lequel dépend de ce qu’il y a dans l’expression. Dans l’exemple ci-dessus,ysera du type réel, parce que l’expression évaluée pour déterminer sa valeur contient elle-même au moins un réel.
Les opérateurs Python ne sont pas seulement les quatre opérateurs mathématiques de base. Il faut leur ajouter l’opérateur ** pour l’exponentiation, ainsi qu’un certain nombre d’opérateurs logiques, des opérateurs agissant sur les chaînes de caractères, des opérateurs effectuant des tests d’identité ou d’appartenance, etc. Nous reparlerons de tout cela plus loin.
Signalons au passage la disponibilité de l’opérateurmodulo, représenté par le symbole %.
Cet opérateur fournit le reste de la division entière d’un nombre par un autre. Essayez par exemple :
10 % 3## (et prenez note de ce qui se passe !)
10%5
Cet opérateur vous sera très utile plus loin, notamment pour tester si un nombre a est divisible par un nombre b. Il suffira en effet de vérifier que a % b donne un résultat égal à zéro.
Exercice :
2.3. Testez les lignes d’instructions suivantes. Décrivez dans votre cahier ce qui se passe :
r , pi = 12, 3.14159
s = pi * r**2
print s
print type(r), type(pi), type(s)
Quelle est, à votre avis, l’utilité de lafonction type() ?
(Note : les fonctions seront décrites en détail, plus loin dans ce cours).

Priorité des opérations

Lorsqu’il y a plus d’un opérateur dans une expression, l’ordre dans lequel les opérations doivent être effectuées dépend de règles de priorité . Sous Python, les règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de mathématique. Vous pouvez les mémoriser aisément à l’aide d’un « truc » mnémotechnique, l’acronymePEMDAS :
P pour parenthèses . Ce sont elles qui ont la plus haute priorité. Elles vous permettent donc de « forcer » l’évaluation d’une expression dans l’ordre que vous voulez.
Ainsi 2*(3-1) = 4 , et (1+1)**(5-2) = 8.
E pour exposants. Les exposants sont évalués ensuite, avant les autres opérations.
Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).
M et D pour multiplication et division, qui ont la même priorité. Elles sont évaluées avant l’addition A et la soustraction S, lesquelles sont donc effectuées en dernier lieu.
Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -1 (Rappelez-vous que par défaut Python effectue une division entière ).
Si deux opérateurs ont la même priorité, l’évaluation est effectuée de gauche à droite.
Ainsi dans l’expression59*100/60, la multiplication est effectuée en premier, et la machine doit donc ensuite effectuer 5900/60, ce qui donne 98. Si la division était effectuée en premier, le résultat serait 59 (rappelez-vous ici encore qu’il s’agit d’une division entière).

Composition

Jusqu’ici nous avons examiné les différents éléments d’un langage de programmation, à savoir : lesvariables, les expressions et les instructions, mais sans traiter de la manière dont nous pouvons les combiner les unes avec les autres.
Or l’une des grandes forces d’un langage de programmation de haut niveau est qu’il permet de construire des instructions complexes par assemblage de fragments divers. Ainsi par exemple, si vous savez comment additionner deux nombres et comment afficher une valeur, vous pouvez combiner ces deux instructions en une seule :
print 17 + 3
Cela n’a l’air de rien, mais cette fonctionnalité qui paraît si évidente va vous permettre de programmer des algorithmes complexes de façon claire et concise. Exemple :
h, m, s = 15, 27, 34
print « nombre de secondes écoulées depuis minuit = « , h*3600 + m*60 + s
Attention cependant : il y a une limite à ce que vous pouvez combiner ainsi :
Ce que vous placez à la gauche du signe égale dans une expression doit toujours être une variable, et non une expression. Cela provient du fait que le signe égale n’a pas ici la même signification qu’en mathématique : comme nous l’avons déjà signalé, il s’agit d’un symbole d’affectation (nous plaçons un certain contenu dans une variable) et non un symbole d’égalité. Le symbole d’égalité (dans un test conditionnel, par exemple) sera évoqué un peu plus loin.
Ainsi par exemple, l’instructionm + 1 = b est tout à fait illégale .
Par contre, écrire a = a + 1 est inacceptable en mathématique, alors que cette forme d’écriture est très fréquente en programmation. L’instructiona = a + 1 signifie en l’occurrence « augmenter la valeur de la variablea d’une unité » (ou encore : « incrémenter a »).
Nous aurons l’occasion de revenir bientôt sur ce sujet. Mais auparavant, il nous faut encore aborder un autre concept de grande importance.

Introduction
Choix d’un premier langage de programmation
Présentation du langage Python, par Stéfane Fermigier.
Plusieurs versions différentes ?
Distribution de Python – Bibliographie
Pour le professeur qui souhaite utiliser cet ouvrage comme support de cours
Exemples du livre
Remerciements
Chapitre 1 : Penser comme un programmeur
1.1 – La démarche du programmeur
1.2 – Langage machine, langage de programmation
1.3 – Compilation et interprétation
1.4 – Mise au point d’un programme – Recherche des erreurs (« debug »)
1.5 – Recherche des erreurs et expérimentation
1.6 – Langages naturels et langages formels
Chapitre 2 : Premiers pas
2.1 – Calculer avec Python
2.2 – Données et variables
2.3 – Noms de variables et mots réservés
2.4 – Affectation (ou assignation)
2.5 – Afficher la valeur d’une variable
2.6 – Typage des variables
2.7 – Affectations multiples
2.8 – Opérateurs et expressions
2.9 – Priorité des opérations
2.10 – Composition
Chapitre 3 : Contrôle du flux d’instructions
3.1 – Séquence d’instructions
3.2 – Sélection ou exécution conditionnelle
3.3 – Opérateurs de comparaison
3.4 – Instructions composées # Blocs d’instructions
3.5 – Instructions imbriquées
3.6 – Quelques règles de syntaxe Python
Chapitre 4 : Instructions répétitives
4.1 – Ré-affectation
4.2 – Répétitions en boucle – l’instruction while
4.3 – Élaboration de tables
4.4 – Construction d’une suite mathématique
4.5 – Premiers scripts, ou : Comment conserver nos programmes ?
4.6 – Remarque concernant les caractères accentués et spéciaux :
Chapitre 5 : Principaux types de données
5.1 – Les données numériques
5.2 – Les données alphanumériques
5.3 – Les listes (première approche)
Chapitre 6 : Fonctions prédéfinies
6.1 – Interaction avec l’utilisateur : la fonction input()
6.2 – Importer un module de fonctions
6.3 – Un peu de détente avec le module turtle
6.4 – Véracité/fausseté d’une expression
6.5 – Révision
Chapitre 7 : Fonctions originales
7.1 – Définir une fonction
7.2 – Variables locales, variables globales
7.3 – « Vraies » fonctions et procédures
7.4 – Utilisation des fonctions dans un script
7.5 – Modules de fonctions
7.6 – Typage des paramètres
7.7 – Valeurs par défaut pour les paramètres
7.8 – Arguments avec étiquettes
Chapitre 8 : Utilisation de fenêtres et de graphismes
8.1 – Interfaces graphiques (GUI)
8.2 – Premiers pas avec Tkinter
8.3 – Programmes pilotés par des événements
8.4 – Les classes de widgets Tkinter
8.5 – Utilisation de la méthode grid() pour contrôler la disposition des widgets
8.6 – Composition d’instructions pour écrire un code plus compact
8.7 – Modification des propriétés d’un objet – Animation
8.8 – Animation automatique – Récursivité
Chapitre 9 : Les fichiers
9.1 – Utilité des fichiers
9.2 – Travailler avec des fichiers
9.3 – Noms de fichiers – Répertoire courant
9.4 – Les deux formes d’importation
9.5 – Écriture séquentielle dans un fichier
9.6 – Lecture séquentielle d’un fichier
9.7 – L’instruction break pour sortir d’une boucle
9.8 – Fichiers texte
9.9 – Enregistrement et restitution de variables diverses
9.10 – Gestion des exceptions. Les instructions try # except – else
Chapitre 10 : Approfondir les structures de données
10.1 – Le point sur les chaînes de caractères
10.2 – Le point sur les listes
10.3 – Les tuples
10.4 – Les dictionnaires
Chapitre 11 : Classes, objets, attributs
11.1 – Utilité des classes
11.2 – Définition d’une classe élémentaire
11.3 – Attributs (ou variables) d’instance
11.4 – Passage d’objets comme arguments lors de l’appel d’une fonction
11.5 – Similitude et unicité
11.6 – Objets composés d’objets
11.7 – Objets comme valeurs de retour d’une fonction
11.8 – Les objets sont modifiables
Chapitre 12 : Classes, méthodes, héritage
12.1 – Définition d’une méthode
12.2 – La méthode « constructeur »
12.3 – Espaces de noms des classes et instances
12.4 – Héritage
12.5 – Héritage et polymorphisme
12.6 – Modules contenant des bibliothèques de classes
Chapitre 13 : Classes & Interfaces graphiques
13.1 – « Code des couleurs » : un petit projet bien encapsulé
13.2 – « Petit train » : héritage, échange d’informations entre classes
13.3 – « OscilloGraphe » : un widget personnalisé
13.4 – « Curseurs » : un widget composite
13.5 – Intégration de widgets composites dans une application synthèse
Chapitre 14 : Et pour quelques widgets de plus …
14.1 – Les « boutons radio »
14.2 – Utilisation des cadres (frames) pour la composition d’une fenêtre
14.3 – Comment déplacer des dessins à l’aide de la souris
14.4 – Python Mega Widgets
14.5 – Fenêtres avec menus
Chapitre 15 : Analyse de programmes concrets
15.1 – Jeu des bombardes
15.2 – Jeu de Ping
Chapitre 16 : Gestion d’une base de données
16.1 – Les bases de données
16.2 – Mise en oeuvre d’une base de données simple avec Gadfly
16.3 – Ébauche d’un logiciel client pour MySQL
Chapitre 17 : Applications web
17.1 – Pages web interactives
17.2 – L’interface CGI
17.3 – Un serveur web en pur Python !
Chapitre 18 : Communications à travers un réseau
18.1 – Les sockets
18.2 – Construction d’un serveur élémentaire
18.3 – Construction d’un client rudimentaire
18.4 – Gestion de plusieurs tâches en parallèle à l’aide des threads
18.5 – Client gérant l’émission et la réception simultanées
18.6 – Serveur gérant les connexions de plusieurs clients en parallèle
18.7 – Jeu des bombardes, version réseau
18.8 – Utilisation de threads pour optimiser les animations
Chapitre 19 : Annexes
19.1 – Installation de Python
19.2 – Sous Windows
19.3 – Sous Linux
19.4 – Sous MacOS
19.5 – Installation de SciTE (Scintilla Text Editor)
19.6 – Installation des Python méga-widgets
19.7 – Installation de Gadfly (système de bases de données)