Accueil

Traduction

Tutoriel Python - sommaire

Tutoriel Python - recherche

L'auteur : Patrick Darcheville

Vous pouvez me contacter via Facebook pour questions & suggestions : Page Facebook relative à mon site

Nos premiers programmes - les structures de contrôle

Jusqu'à présent nous n'avons utilisé Python en mode interactif (mode console).
Le gros inconvénient : aucune sauvegarde de notre travail. Il est temps de passer au mode script (ou mode programmé)
Un script est un fichier qui contient une suite de commandes interdépendantes constituant un traitement basé sur un algorithme.
Dans ce chapitre nous allons utiliser l'interface de programmation appelée IDLE (Integrated DeveLoppment Environnement)  c'est à dire  "environnement de développement intégré".
Dans cet "environnement de développement" vous aurez pour un projet plusieurs fenêtres : une pour le code source, une autre pour l'exécution de ce programme voire une troisième fenêtre pour l'affichage du graphique éventuel.
Pour lancer l'IDLE sous Windows 10, il suffit de cliquer sur l'un des icônes dans la barre de tâches légendée "IDLE ... ". Si vous n'avez pas créé ces raccourcis, il suffit de tapez "py" dans la zone de recherche de Windows puis de sélectionner "IDLE" dans la liste des applications proposées.

Un programme Python est stocké dans un fichier d'extension .py
Créez un dossier "python_prog" à la racine du disque dur C:

Votre premier programme en Python

Démarrez l'IDLE. ; une fenêtre légendée "untitled" s'affiche

Le code source

Tapez le code suivant dans cette fenêtre :

Surtout respectez l'indentation.
L'instruction while True: crée une boucle infinie. N'oubliez pas les deux points après "while true" pour signifier un début de bloc.
Toutes les lignes de ce bloc doivent donc être en retrait par rapport l'instruction introductive.
Attention l'instruction print('fin de programme') doit être exécutée qu'une fois; elle est donc en dehors du bloc. Donc cette instruction ne doit pas être en retrait, mais au même niveau que "while true :".

L'instruction while true: crée une boucle infinie mais (et heureusement) l'utilisateur peut intervenir pour en sortir grâce à un bloc qui contient l'instruction break (sortie de boucle).

Sauvegarde du programme

Tant qu'il n'a pas été sauvegardé sous forme d'un fichier, un programme ne peut pas être exécuté.

Produisez la commmande File/Save ..." : une boite de dialogue s'ouvre pour enregistrer votre programme sous forme d'un fichier.
Sélectionnez le dossier que vous avez créé spécialement pour stocker vos programme ; donner un nom au fichier-programme : "test_input.py".

Exécution du programme

Pour appeler l'interpréteur Python à partir de l'IDLE il suffit de produire la commande "Run/Run module".
Une fenêtre d'exécution s'affiche et une invite s'affiche : tapez un nombre ou 'fin : ' 
Votre saisie s'affiche à côté de l'invite, vous appuyez sur ENTER et le programme continue ...

Attention, comme le montre la capture d'écran, même si on saisit une suite de chiffres dans la variable "nombre" , cette saisie est considérée comme une chaine.
Or on ne peut pas faire d'opérations arithmétiques sur une chaine ... Heureusement, on peut convertir une chaine composée de chiffres en un nombre : voir le programme suivant.

Deuxième programme

Dans un second programme je vais vous montrer comment convertir une chaine numérique (composée d'une suite de chiffres) en un nombre.
Créer un nouveau fichier dans l'IDLE avec la commande : File/New File ...

Le code source

Ce programme permet de cumuler les valeurs saisies.
Il faut que chaque valeur saisie soit convertie en nombre d'où l'instruction : somme = somme + eval(nombre)
La fonction native eval(chaine) convertit une chaine (au format numérique) en un flottant.
J'aurai pu écrire : somme +=eval(nombre) ; voir ci-dessous les opérateurs d'affection complexes en Python.
À la place de la fonction eval() j'aurais pu utiliser float().

Exécution

Ci-dessous la fenêtre d'exécution :

Il y a bien cumul des trois nombres dont deux décimaux.

Attention à la saisie d'un nombre décimal !

Pour Python 12,5 est un tuple (comprenant deux entiers : 12 & 5) et pas un nombre décimal ; le séparateur décimal doit être le point (et non pas la virgule) ! Il faut donc saisir 12.5.

Les structures conditionnelles ou tests

Vous avez déjà eu un aperçu des tests dans les deux programmes précédents. Dans chacun, on teste à chaque passage dans la boucle la saisie effectuée. Si la variable nommée "nombre" contient "fin" alors sortie de la boucle (par exécution du "break").
Mais les tests peuvent être beaucoup plus complexes ...
C'est l'occasion d'introduire le pseudo-code.

Algorithme en pseudo-code

Le pseudo-code, également appelé LDA (pour Langage de Description d'Algorithmes), est une façon de décrire un algorithme en langage presque naturel, sans référence à un langage de programmation en particulier.
L'écriture de l'algorithme en pseudo-code précède donc le codage proprement dit.
C'est l'étape la plus importante ; un programme respectant la syntaxe du langage, mais reposant sur un mauvais algorithme sera toujours un mauvais programme.

Si … alors

Exercice : si moyenne est supérieure ou égale à 12 il faut afficher "bon trimestre".
En pseudo-code :

SAISIR moyenne
CONVERTIR en flottant
SI moyenne ≥ = 12 ALORS AFFICHER  "bon trimestre" 

En pseudo-code il y a des mots réservés. L'usage veut qu'il soient écris en majuscules.
Maintenant je peux coder avec la syntaxe Python.

Je rappelle que toute saisie avec la fonction input est de type string même s'il s'agit d'une saisie au format numérique. Donc il faut effectuer une conversion.
moyenne = eval(moyenne) : la variable moyenne contient d'abord une chaine puis un flottant.
Remarquez que dans l'instruction la variable moyenne est utilisée deux fois !

Si … alors … sinon

Exercice : si la moyenne est supérieure ou égale à 12 il faut afficher "bon trimestre" sinon afficher "doit mieux faire"
Algorithme en pseudo-code :

 
SAISIR moyenne 
CONVERTIR moyenne
SI moyenne ≥ = 12 ALORS AFFICHER "bon trimestre"
SINON AFFICHER "peux mieux faire"

Codage en Python :

Remarque : n'oubliez pas les ":" à la fin du "if" et du "else" pour annoncer un début de bloc.

Si … ALORS ... SINON SI ...

Exercice : barème de l'appréciation en fonction de la moyenne du trimestre.

Intervalleappréciation
>=18Excellent
[14 à 18[ Très bien
[10 à 14[ Correct
[6 à 10[ Insuffisant
< à 6 Très faible

Algorithme en pseudo-code - première solution

C'est celui qui vient à l'esprit en lisant le barème :

SAISIR moyenne  et CONVERTIR
SI moyenne > = 18  ALORS AFFICHER "excellent"
SINON SI moyenne >= 14 ET < 18   ALORS AFFICHER "très bien"
SINON SI moyenne >= 10 ET  < 14 ALORS AFFICHER "correct"
SINON SI moyenne >= 6  ET < 10 ALORS AFFICHER "insuffisant"
SINON AFFICHER "très faible" 

Cet algorithme est correct mais lourd. Puisqu' à chaque fois il faut comparer la moyenne à deux valeurs et donc introduire un opérateur logique.
Il existe une solution beaucoup plus simple : la technique des bornes décroissantes. C'est à dire comparer la moyenne à 18 puis à 14 puis à 10 et enfin à 6.

Algorithme amélioré

SAISIR moyenne & CONVERTIR
SI moyenne >= 18  ALORS AFFICHER "excellent"
SINON SI moyenne >= 14 ALORS AFFICHER "très bien"
SINON SI moyenne >= 10 ALORS AFFICHER "correct"
SINON SI moyenne >= 6 ALORS AFFICHER "insuffisant"
SINON AFFICHER "très faible" 

Supposons que :
moyenne = 15 : premier test retourne FALSE donc on passe au suivant, deuxième test est TRUE donc affichage "très bien".
moyenne = 9 : premier test est FALSE donc on passe au deuxième test qui est FALSE donc on passe au troisième qui est aussi FALSE donc on passe au quatrième qui est TRUE donc affichage de "insuffisant".

Code source

A partir de cet algorithme vous pouvez saisir directement dans l'IDLE le programme en Python.

Vous nommerez ce programme "test_if_elif.py".

Amélioration du programme

C'est bien gentil ce programme, mais si vous voulez déterminer l'appréciation pour toute une classe de 30 élèves, vous devez ouvrir 30 fois le programme et lancer 30 fois son exécution ... Donc "c'est galère !"
En fait c'est très facile d'améliorer ce programme pour que la routine de tests soit exécutée tant qu'on n'est pas fatigué. Il suffit d'intégrer le code du programme précédent dans une boucle infinie.

Je vous communique ci-dessous le code de la version améliorée.

Pour produire cette version améliorée il ne faut surtout pas tout ressaisir. Il suffit de copier tout le code de la première version dans un nouveau fichier puis de rajouter l'instruction "while True" mais aussi deux lignes :

Il faut aussi indenter toutes les lignes qui doivent être exécutées à chaque passage dans la boucle.
Attention la ligne "print('fin de boulot')" est hors bloc (ne doit être exécutée qu'une fois) donc elle doit être au même niveau que "while True".

Un jeu

Le programme génère de façon aléatoire un entier inférieur à 100.
Ce nombre généré n'est pas affiché ; l'utilisateur doit le deviner, il fait des propositions. A chaque fois le programme répond : "trop grand" OU "trop petit" OU "correct" et alors le programme s'arrête.

Le code du jeu

La fonction randint() du module random permet de gérer de façon aléatoire un entier.

Sauvegarde du programme sous le nom "nombre_a_trouver.py"
Lancez l'exécution mais ça ne fonctionne pas car il y a des erreurs de syntaxe.
Cherchez les erreurs (il y a en 3!).

Correction

J'avais oublié les ":" à la fin de la ligne introduisant un bloc.

Exécuter un programme à partir du terminal windows

Jusqu'à présent nous avons lancé l'exécution d'un programme à partir de l'IDLE or il y a une autre solution : à partir du terminal windows.
Rappel : le terminal s'affiche après avoir tapé la commande cmd : une fenêtre à fond noir avec comme titre "invite de commandes".

Il faut d'abord changer de répertoire courant via la commande DOS cd (change directory)
Pour lancer le programme (stocké dans c:\prog_pyton) il faut tapez python nomduprogramme
Les instructions input & print s'affichent dans le terminal.

Les boucles

Vous savez déjà faire une boucle infinie et aussi comment sortir de cette boucle infinie. Voyons maintenant comment boucler un nombre fini de fois.

Objectif

On veut afficher successivement les cinq éléments d'une liste.

Première solution

Nous allons utiliser la structure while ...
Code source :

L'instruction i = i + 1 dans le bloc est indispensable sinon i sera toujours inférieur à 5 et donc bouclage à l'infini.

Deuxième solution

Le code source sera plus simple en utilisant avec la structure for ...

Lorsque l’on souhaite répéter un nombre donné de fois le même bloc d’instructions, la commande FOR est la plus appropriée.
On retrouve souvent dans l'instruction FOR la fonction RANGE().
Par rapport à la première solution il y a deux instructions de moins.
"for i in range(5)" signifie : pour i de 0 à 5 exclu (donc pour i de 0 à 4) avec un pas de 1 ; donc l'incrémentation est gérée par l'instruction.

Autre exemple avec for ...

Affichage successif des 25 premiers impairs.
Le code source :

"for i in range(1,50)" signifie : pour i de 1 à 49
Si le reste de la division entière du nombre par 2 est différent de 0, ce nombre est impair. Il faut l'afficher.
Sinon il faut passer à l'itération suivante : instruction continue

Correction de l'exercice : le jeu de devinette amélioré

Non seulement le programme est débuggé mais de plus on peut jouer plusieurs fois.

Première proposition

la variable nbre_joueur récupère le nombre saisi par le joueur.

while choix in "oO": à la question "encore jouer ?" l'utilisateur doit saisir une valeur différente de "o" minuscule ou majuscule pour sortir de la boucle. Donc si par erreur, il appuie sur 0 (zéro) le test est faux et il ne peut plus jouer.

Deuxième proposition plus ergonomique

Extrait du programme (le reste inchangé par rapport à la version précédente):

while choix not in "nN": : tant que le contenu de choix est différent de "n" ou "N" alors on reste dans la boucle. Donc si par erreur, l'utilisateur saisit 0 (zéro) il peut continuer de jouer.
Pensez à initialiser choix avec une valeur différente de "n" ou "N" afin qu'il y ait au moins un passage dans la boucle externe.

Parcours de liste

Je vous propose maintenant de petits programmes pour parcourir une liste.

Parcours avec une structure for ...

Le programme :

Notez la syntaxe "for i in range(len(nomListe))".
len(ma_liste) retourne 6. Donc bouclage pour i compris entre 0 et 5.

Trace de l'exécution :

Seuls les éléments s'affichent mais pas l'indice correspondant à chaque élément.

Parcours d'une liste avec la fonction enumerate()

Sous Python une liste peut être parcourue avec une structure particulière basée sur for ... in enumerate(nomListe).
Le code :

La fonction enumerate() compte le nombre d'éléments (elt) de la liste
La structure for ... va boucler n fois (n : nombre d'éléments).

Trace de l'exécution :

L'instruction "print(elt)" retourne des tuples.
Chaque tuple indique l'indice de l'élément puis l'élément. J'aurai l'occasion de revenir sur les tuples.

Plusieurs boucles imbriquées

Vous connaissez tous les tables de multiplication.
Et bien sachez que le programme Python pour les produire est très très court : deux boucles FOR imbriquées.
Le code :

Extrait de la trace d'exécution :

En imbriquant deux boucles FOR l'instruction " print(i, " *", j, " = ", produit)" est exécutée 100 fois (10 par 10).

Les mots clé break & continue

Dans une boucle (créée avec for ... OU while ...) on peut trouver les mots clés break ou continue.

Sauter avec continue

Exemple ;

L'item 7 n'est pas affiché.

Quitter la boucle prématurément avec break

Exemple :

La structure range n'est pas affichée complètement.