Script et programme

Identification

Infoforall

5 - Créer un programme en Python


Nous avons vu comment stocker des informations dans des variables.

Nous allons voir comment stocker les instructions dans un programme. Cela nous évitera d'avoir à retaper des instructions que nous avons déjà exécuté à chaque fois qu'on veut refaire la même chose.

Logiciel nécessaire pour l'activité : Thonny

Evaluation ✎ : question 11 uniquement

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

1 - Créer un script

Nous allons maintenant voir comment programmer et enregistrer plutôt que d'exécuter immédiatement le code dans la console. Nous allons commencer par utiliser Thonny. Nous verrons néanmoins dans une autre activité qu'un simple éditeur de texte suffit la plupart du temps.

Nous allons créer au début un petit programme qui ne fait que 2 choses :

  1. Créer une variable a et y mémoriser 200
  2. Créer une variable b et y mémoriser le double de a, soit 400

01° Copier/coller le code suivant dans la zone du haut de Thonny, celle permettant de créer le script (celle sans les trois chevrons ):

1 2
a = 200 b = a * 2

02° Utiliser FILE - SAVE AS pour enregistrer le fichier (qui doit être un .py) dans un dossier que vous parviendrez à retrouver facilement. Le mieux est donc de le mettre dans votre dossier personnel.

03° Exécuter le programme en utilisant la flèche verte RUN ou le menu RUN - RUN CURRENT SCRIPT ou la touche F5.

Si ce n'est pas fait, visualiser les variables à l'aide du menu VIEW-VARIABLES.

Vous devriez constater qu'on a bien créé deux variables a et b contenant 200 et 400.

Vous devriez donc voir ceci s'afficher dans Thonny : la console de Thonny est vide !

>>> %Run acti_programme.py >>>

Actions à réaliser : vous pourriez visualiser le contenu des variables en demandant gentimment via la console :

>>> a 200 >>> b 400

On retrouve donc bien l'histoire de la séquentialité des instructions.

C'est comme si vous aviez tapé ceci dans la console SAUF que si vous voulez refaire pareil, il suffit de réappuyer sur la flèche verte pour relancer le script.

1 2 3
a = 200 b = a * 2 fin du programme

CLIQUEZ ICI POUR VOIR LE DEROULEMENT :

Déroulement séquentiel

Comme on peut le voir, le programme se déroule séquentiellement : une ligne à la fois, en partant de la ligne du haut et en se dirigeant vers le bas. L'ordinateur va donc évaluer et exécuter une ligne à la fois.

2 - Mode pas à pas

Thonny permet d'observer la séquence d'exécution : il suffit de cliquer sur le bouton à droite de run, DEBUG CURRENT SCRIPT ou d'utiliser le menu RUN DEBUG CURRENT SCRIPT ou CTRL+F5. Vous pourrez alors voir le déroulé du script.

Avec la nouvelle version de Thonny, vous pouvez choisir la première des possiblités : DEBUG CURRENT SCRIPT (Nicer).

04° Suivre le déroulé proposé de façon à parvenir à exécuter le programme pas à pas à l'aide de Thonny. Commencez par lancer le mode pas à pas en utilisant la flèche à droite de la flèche du RUN.

La ligne en jaune correspond à la prochaine ligne qui va être exécutée.

.

Rien ne s'est passé. C'est normal, nous sommes sur la première ligne mais elle n'est pas encore exécutée.

Il suffit alors de cliquer sur STEP OVER (la flèche vers le bas, celle située encore une position à droite de la précédente) ou d'appuyer sur F6 pour exécuter cette ligne et passer encore à la suivante :

On peut voir qu'on vient de créer la variable a.

En cliquant encore une fois, on réalise alors cette dernière instruction :

Cette fois, on vient de créer la variable b.

Le programme est terminé : aucune ligne de code n'est en attente d'exécution.

Les lignes ont toutes été interprétées à tour de rôle, du haut vers le bas, comme lorsqu'on lit un texte.

05° Réfléchir sur ce que va faire ce programme, pas à pas. Que va afficher ce programme ? a ? b ? c ? Rien ? Tout ? Lancer ensuite le mode DEBUG pour vérifier votre réponse. Activer le panneau VARIABLES pour les voir se créer au fur et à mesure.

1 2 3 4
a = 5 b = 10 c = a + b c

Et voici la correction avec les explications en mode pas à pas. :

Nous voici d'abord sur la première ligne avant qu'elle ne soit interprétée.

Rien de particulier, il ne s'est rien passé, puisque la ligne n'est pas executée.

Une fois  a = 5  executée, on voit apparaître une variable a en mémoire puisqu'on utilise une affectation. Lors d'une affectation, rien ne s'affiche automatiquement.

Une fois  b = 10  executée, on voit apparaître une variable b en mémoire puisqu'on utilise une affectation. Rien ne s'affiche. Normal, c'est juste une affectation.

Nous venons de voir s'exécuter  c = a + b .

La variable  c  contient donc 15, la somme de ce que contiennent  a  et  b  à ce moment précis.

Reste à voir ce que vous provoquer l'exécution de la dernière ligne ne contenant que  c 

Grosse différence avec le cas shell : le fait d'avoir tapé  c  ne semble pas avoir d'effet visible : on demande bien d'évaluer cette expression (et cela va renvoyer 15). Mais on n'exécute pas cela dans le shell mais dans un programme. Résultat : l'interpréteur Python évalue votre expression et n'en fait rien puisque vous ne lui dites pas d'en faire quelque chose !

Différence entre mode interactif et programme

Cas de la console

Si on demande à la console de simplement évaluer quelque chose, elle va afficher par défaut le résultat :

>>> a = 10 >>> b = a + 2
>>> a = 10 >>> b = a + 2 >>> b 12

Cas du programme

1 2 3
a = 10 b = a + 2 b

Si on place ce code dans un programme, il va

  • Ligne 1 : placer la variable a en mémoire,
  • Ligne 2 : évaluer la somme puis placer le résultat dans une variable b,
  • Ligne 3 : évaluer b et... c'est tout. Il l'évalue. Pas d'affichage, rien, nada.

Si vous voulez voir le contenu des variables, vous avez deux possibilités :

  • Soit vous regardez dans l'onglet VARIABLES de Thonny
  • Soit vous passez par la console interactive, un fois le programme exécuté

06° On remarquera qu'à la fin de l'exécution de votre script, les variables restent en mémoire. Utiliser le code suivant dans un programme. Que vaut  c  à la fin du programme à votre avis ? Vérifier et expliquer le résultat.

1 2 3 4
a = 5 b = 10 c = a + b a = 100

...CORRECTION...

c est affectée à 15 sur la ligne 3 à l'aide de la valeur de a à ce moment là.

On change la valeur de a sur la ligne 4. Ok, a change.

Par contre, la variable c reste à 15 : on ne l'affecte pas avec un nouveau résultat. Ce n'est pas parce que a a servi à définir ligne 3 que son changement ligne 4 modifie quoi que ce soit. SEQUENTIALITE.

Attention : dans un script, il faut utiilser la fonction native print si vous voulez forcer l'affichage d'un résultat à destination d'un lecteur humain. Noter juste c ne suffit pas.

Voici le même programme mais avec un affichage final destiné à un humain.

1 2 3 4
a = 5 b = 10 c = a + b print(c)

07° Quelqu'un réalise ce programme là. Il déclare qu'il est plus court que le précédent et fait la même chose puisqu'il affiche la même chose. Expliquez lui pourquoi ce programme ne fait pas la même chose que celui juste au dessus !

1 2 3
a = 5 b = 10 print(a + b)

...CORRECTION...

Ce nouveau programme ne fait pas la même chose : on ne mémorise pas le résultat de l'addition.

On affiche simplement le résultat pour qu'un humain puisse le visualiser. Mais on ne pourra pas continuer à travailler avec ce résultat puisqu'il n'a pas été mémorisé dans une variable.

Utilisation de print en mode Interactif

Nous avions vu que la fonction native print n'avait aucun intérêt lors de l'utilisation de la console interactive, sauf pour visualiser un string qui contient des caractères d'échappement permettant de réaliser des tablulations ou des passages à la ligne.

Moralité : ça je veux bien :

>>> a = "Nom\tPrenom\tAge" >>> print(a) Nom Prenom Age >>> print("Nom\nPrenom\nAge") Nom Prenom Age >>> print("Voilà un antislash \\") Voilà un antislash \

Par contre, jamais du code similaire à ceci dans vos copies s'il vous plait :

>>> a = 5 >>> print(a) 5

En effet, il suffit d'écrire ceci :

>>> a = 5 >>> a 5
Utilisation de print en mode Script

Lorsqu'on utilise un script Python, le print devra être limité aux cas suivants :

  1. Volonté délibérée du programme d'afficher quelque chose à l'utilisateur humain (le résultat final ou autre)
  2. Affichage temporaire du contenu d'une variable si le programme ne fait pas ce que vous voulez ! On peut alors visualiser des résultats intermédiaires.

Par contre, il est fondamental de comprendre ceci : un print n'enregistre absolument pas le résultat en mémoire. Il s'agit bien d'un simple affichage temporaire et ne permet pas d'utilisation ultérieure du résultat affiché.

Si votre but est de stocker l'information, vous vous trompez d'outil : il faut affecter le résulat à une variable.

3 - Commentaires et mise en forme

L’un des points fondamentaux de la programmation est la clarté : votre code sera certainement un jour utilisé ou modifié par quelqu’un d’autre. Ou par vous même quelques mois ou années plus tard.

Lorsqu’un programme est simple, pas besoin d’explication. Mais lorsque le code commence à gonfler, on regrette souvent de ne plus savoir pourquoi on a codé ceci ou cela quelques semaines avant… Les commentaires servent à donner des explications sur ce que fait le code ou sur ce que doit contenir telle ou telle variable. Autre cas courant : la personne qui lit le code n’est pas celui qui l’a codé. Sans commentaire, pas facile de comprendre le but de chaque ligne de code.

Point important : les commentaires sont destinés à un lecteur humain. L'interpréteur Python ne tentera pas de les exécuter. Si vous lancez Thonny en mode Debug, vous pourrez voir qu'il ne s'arrête absolument pas sur les commentaires.

Commentaires dans un code Python

Pour rajouter un commentaire, on utilise simplement le caractère dièse  #  de façon adaptée :

1 2 3
# Toute cette ligne est un commentaire. print("Bonjour le monde") # Ceci est également un commentaire print("Cette ligne ne contient pas de # commentaire")

La ligne 1 comporte un commentaire sur toute la ligne.

la ligne 2 comporte un commentaire uniquement sur la fin de ligne : l'instruction devant le commentaire sera exécuté.

Voici le résultat de ce programme dans la console : il n'affiche pas les commentaires.

>>> %Run progcommentaires.py Bonjour le monde Cette ligne ne contient pas de # commentaire >>>

Pour l'instant, le code se suffit à lui même : inutile de rajouter un commentaire. Retenez qu'un commentaire ne doit pas juste paraphraser le code mais fournir des indications éclairantes sur son fonctionnement.

A titre d'exemple, voici un script :

1 2 3
budget = 78 unite = 8 nombre = budget // unite + 2

On comprend vaguement qu'il fait le calcul de quelque chose...

Exemple d'utilisation correcte de commentaires :

1 2 3 4 5
# budget : le budget disponible en euros budget = 78 # unite : prix à l'unité et en euro d'un paquet de gateaux unite = 8 nombre = budget // unite + 2 # On rajoute 2 paquets achetés pour avoir de la marge, certains mangent beaucoup !

Ici, les commentaires sont utiles car ils donnent des indications non visibles dans le code : prix en euros et explication du +2.

Exemple d'utilisation incorrecte de commentaires :

1 2 3 4 5
# budget contient le budget pour acheter les gateaux budget = 78 # unite contient le prix à l'unité unite = 8 nombre = budget//unite + 2 # Le nombre de paquets à acheter pour la soirée

Ici, les commentaires sont clairement inutiles : ils n'ont rien rajoutés à la compréhension réelle du code. Par exemple, on ne sait pas pourquoi on rajoute 2...

07° A titre d'exercice final, on vous demande de lire le script ci-dessous, d'en comprendre l'exécution ligne par ligne.

Questions

  • Combien contient-il de lignes d'instruction (à comprendre sous le sens "pas une ligne de commentaires ou une ligne vide") ?
  • Noter la valeur finale de nouveau_nombre.

Vérifier en mode debug que votre compréhension était bonne.

1 2 3 4 5 6 7 8 9 10 11 12
# budget contient le budget pour acheter les gateaux budget = 500 # unite : prix à l'unité d'un paquet de gateaux unite = 10.0 # nombre de paquets à acheter pour la soirée, marge de 2 supplémentaires. nombre = budget//unite + 2 budget = 5000 unite = 1.0 nouveau_nombre = nombre * 2 # c'est fini !

...CORRECTION...

6 lignes d'instructions.

On remarque bien d'abord que Thonny ne stoppe pas sur la première ligne, le commentaire mais sur la seconde.

Ensuite :

  1. Ligne 2 : On crée budget en lui affectant 500
  2. Ligne 5 : On crée unite en lui affectant 10.0
  3. Ligne 7 : On crée nombre en lui affectant le résultat de 500//10.0 + 2, évalué à 52.0, un float.
  4. Ligne 9 : On écrase budget en lui affectant 5000
  5. Ligne 10 : On fait de même avec unite en lui affectant 1.0
  6. Ligne 11 : On crée nouveau_nombre en lui nombre * 2 :
    ATTENTION AU 'PIEGE' de l'intuition humaine : nombre n'a pas été recalculée sous prétexte que les variables qui ont servi à le trouver la première fois ont changé ! On garde donc 52.0. On affecte donc 104.0 à cette variable.

08° Expliquer ce que contient autorisation ci-dessous. La variable recu contient le mot de passe reçu. La variable mdp contient le vrai mot de passe attendu.

1 2 3
recu = "1234" mdp = "12345" autorisation = recu == mdp

4 - Programme de dessin

Si vous vous souvenez bien, dessiner, c'était assez pénible en mode interactif-console : il fallait constamment retaper la même chose. Nous allons ici utiliser les deux notions fondamentales que sont les variables et les programmes.

Pour rappel, voici une documentation partielle du module Turtle :

Quelques commandes disponibles avec Turtle

N'oubliez pas d'importer au préalable le module Turtle avec import turtle as trt.

Voici quelques méthodes qu'on peut appliquer aux objets de classe Turtle, qu'on crée à l'aide de crayon = trt.Turtle().

Pour avancer : crayon.forward(50) permet d'avancer de 50.

Pour reculer : crayon.backward(50) permet de reculer de 50.


Pour tourner à droite : crayon.right(45) permet de tourner de 45° à droite depuis l'angle actuel.

Pour tourner à gauche : crayon.left(45) permet de tourner de 45° à gauche depuis l'angle actuel.

Pour placer la tortue à un certain angle : crayon.setheading(20) permet de fixer l'angle de la tortue à 20°, sachant que 0° correspond à la tortue regardant à droite.


Pour aller faire un mouvement linéaire jusqu'au point de coordonnées (x,y) : crayon.setposition(x,y).

Pour faire un mouvement horizontal jusqu'à atteindre la valeur donnée en x : crayon.setx(x).

Pour faire un mouvement vertical jusqu'à atteindre la valeur donnée en y : crayon.sety(y).

Pour revenir au point d'origine : crayon.home().


Pour dessiner un cercle de rayon x : crayon.circle(x).

Pour dessiner un arc de cercle d'angle a et de rayon x : crayon.circle(x,a).

Pour tracer des polygones de "rayon" x possèdant y côtés : crayon.circle(x,360,y).

Pour placer un point de rayon x et de couleur précise : crayon.dot(x,"red").


Pour modifier la vitesse x, x variant de 1 à 10 : crayon.speed(x), x=0 veut dire pas d'animation.


Pour lever la pointe du crayon : crayon.penup().

Pour abaisser la pointe du crayon : crayon.pendown().

Pour changer la couleur du crayon : crayon.pencolor("red").

Pour augmenter la taille du crayon : crayon.pensize(5).


Pour définir une couleur de remplissage : crayon.fillcolor("yellow").

Pour remplir votre dessin d'une couleur de remplissage, c'est en deux temps :

  • Pour signaler qu'on doit commencer à surveiller la surface créée : crayon.begin_fill().
  • Pour signaler qu'on a atteint la fin de la surface et qu'il faut remplir : crayon.end_fill().

Cela nous suffira mais vous pouvez aller voir la documentation Python pour voir ce que le module peut faire d'autre : DOCUMENTATION TURTLE PYTHON.

09° Utiliser le code suivant pour créer un premier dessin.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
import turtle as trt taille = 5 # Epaisseur du trait couleur1 = 'red' # On note couleur1 mais ça contient bien 'red' couleur2 = 'blue' longueur = 200 crayon = trt.Turtle() # Création du crayon 1 crayon.fillcolor('black') crayon.begin_fill() crayon.pensize(taille) crayon.pencolor(couleur1) crayon.forward(longueur) crayon.left(90) crayon.pensize(taille*2) crayon.pencolor(couleur2) crayon.forward(longueur) crayon.left(90) crayon.pensize(taille*3) crayon.pencolor(couleur1) crayon.forward(longueur) crayon.left(90) crayon.pensize(taille*4) crayon.pencolor(couleur2) crayon.forward(longueur) crayon.left(90) crayon.end_fill()

Pourquoi mettre la variable crayon en orange plutôt qu'en bleu ? Il s'agit d'une variable faisant référence à des objets propres à l'interface graphique Turtle. Il s'agit donc d'une variable un peu particulière. Cela vous permettra de voir clairement où se trouvent les parties du code propre à turtle.

10° Utiliser le deuxième programme utilisant cette fois des arcs de cercle.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
import turtle as trt rayon = 50 # Epaisseur du trait couleur1 = 'red' # On note couleur1 mais ça contient bien 'red' couleur2 = 'blue' epaisseur = 10 crayon = trt.Turtle() # Création du crayon 1 crayon.pensize(epaisseur) crayon.circle(rayon, 180) crayon.pensize(epaisseur-2) crayon.circle(rayon-10, 180) crayon.pensize(epaisseur-4) crayon.circle(rayon-20, 180) crayon.pensize(epaisseur-6) crayon.circle(rayon-30, 180)

✎ 11° Question finale notée : réaliser le plus beau dessin du monde avec un bon script Python. La notation tient compte des couleurs, de l'utilisation de variables et des commentaires explicatifs.

Maintenant que nous avons vu comment créer un programme, nous allons voir dans les activité suivantes comment parvenir à stocker des informations rentrées au clavier par l'utilisateur et comment répondre différemment en fonction de sa réponse. Il s'agit des conditions exprimées avec un IF (SI en français).

Activité publiée le 28 08 2019
Dernière modification : 19 07 2020
Auteur : ows. h.