De nombreux traitements informatiques peuvent se schématiser suivant
les trois étapes suivantes:
Pour bien comprendre le sens des termes lecture, traitement et affichage,
mettez vous à la place de l'ordinateur.
Votre rôle est d'additionner mentalement deux nombres pour un sourd-muet qui ne sait pas calculer
(l'utilisateur).
Comme il ne peut pas parler, il vous écrit les deux nombres à additionner sur un bout de papier,
qui joue le role de l'écran.
Vous ne pouvez pas additionner les deux nombres si vous ne les connaissez pas.
Il faut donc commencer par les lire. C'est la première étape de lecture des données.
A présent, les deux nombres à additionner sont dans votre mémoire. Vous pouvez donc effectuer le traitement,
qui consiste à additionner mentalement ces deux nombres.
C'est l'étape de traitement des données.
Vous avez le résultat. Mais si vous ne le communiquez pas à l'utilisateur, c'est comme si vous n'aviez
rien fait. Comme il est sourd vous allez écrire le résultat sur le bout de papier. C'est la troisième étape:
l'affichage des résultats du traitement.
Pour un ordinateur c'est un peu la même chose:
- Lire les données signifie transférer des informations affichées à l'écran vers la mémoire, ou plus
précisémment vers une variable-donnée, c'est à dire
une variable prévue pour stocker une donnée du traitement.
- Traiter les données signifie grosso-modo faire des calculs qui dépendent des
données pour produire des résultats. En principe, mais ce n'est pas obligatoire,
chaque résultat est stockée dans une variable-résultat.
- Si les résultats ont été sauvegardés dans des variables résultats,
Afficher les résultats signifie afficher la valeur de chacune de ces variables
à l'écran. Il est également possible d'afficher les résultats d'un traitement sans les avoir
au préalable sauvegardés dans des variables. Mais il serait difficile pour l'instant d'expliquer comment.
Nous verrons cela un peu plus loin.
Voyons à présent comment tout cela peut être réalisé en Python.
Reprenons l'exemple du programme d'addition de deux nombres que vous avez utilisé dans la
prise en main
de Wing.
Dans ce programme, Lire les données signifie lire les valeurs des deux nombres à additionner
pour les stocker dans deux variables données x et y.
Traiter les données signifie additionner les valeurs des variables x et y,
puis mémoriser
le résultat dans une variable résultat somme.
Enfin, afficher les résultats signifie afficher la valeur de la variable somme à l'écran:
Voici le code du programme:
x = int( input("Valeur de x :"))
y = int( input("Valeur de y :"))
somme = x + y
print("x + y = ", somme)
Les deux premières instructions réalisent la lecture des données. La troisième fait le traitement et la quatrième,
l'affichage du résultat.
Voyons tout cela plus en détails.
Saisie des données
En Python, la lecture d'une donnée se fait à l'aide de la fonction input et d'une affectation.
La première instruction du programme d'addition est une instruction de ce type:
x = int( input("Valeur de x :") )
On reconnait ici une instruction d'affectation. A gauche du signe = figure le nom de
la variable donnée qui servira à stocker le premier nombre à additionner. L'expression en blanc utilise la fonction
input. Elle peut être
considérée comme une expression de type chaine de caractères dont la valeur est le texte saisi par
l'utilisateur. Le texte qui figure entre guillemets sert à indiquer à l'utilisateur quelle donnée est attendue.
L'évaluation de l'expression input (".....") se déroule en trois phases.
Phase1: le texte figurant entre guillemet est affiché puis l'exécution du programme
est suspendue afin de permettre à l'utilisateur de saisir la donnée demandée:
Phase2: l'utilisateur saisi la donnée en appuyant sur différentes touches du clavier.
Dans notre exemple, il tape les quatre chiffres du nombre 1961.
Cette phase est gèré par le système d'exploitation. Chaque touche
de clavier appuyée génère une
interruption.
Le système gère ces interruptions en affichant les chiffres à l'écran et en les enregistrant en mémoire dans un
buffer (plage mémoire réservée aux
entrées-sorties).
Phase3: elle est declenchée dès que l'utilisateur appuie sur la
touche entrée. C'est à ce moment là que le programme
reprend son exécution. La valeur de l'expression input(".....") est alors constituée de la chaine de caractères
contenu dans le buffer. Dans notre cas, il s'agit de "1961".
Etant donné que nous souhaitons utiliser cette donnée comme un nombre entier, cette chaine de caractères est traduite
en nombre entier à l'aide de la
fonction conversion int:
x = int( input("Valeur de x :") )
L'expression figurant à droite du signe = est donc une expression numérique dont la valeur est 1961. Cette valeur est
affectée à la variable x. La lecture de la donnée x est terminée.
La lecture de la donnée y suit exactement le même principe.
Traitement des données
Les données sont à présent en mémoire. Nous pouvons donc les traiter.
Dans cet exemple le traitement se fait en une seule instruction:
somme = x + y
Les deux nombres x et y sont additionnés et le résultat du calcul est affecté à la
variable résultat somme.
Affichage des résultats
En Python, l'affichage des résultats se fait à l'aide de l'instruction print.
Elle permet d'afficher les valeurs de plusieurs expressions sur une même ligne:
print (expression, expression, ......, expression)
Les expressions peuvent être de type quelconque. Avant de les afficher, l'interprèteur les traduit automatiquement en chaine
de caractères.
Voici l'affichage du résultat dans notre exemple:
print("x + y =", somme)
Ici, nous avons une expression de type chaine de caractères (le littéral "x + y =", suivie d'une expression de type numérique (la variable somme).
La valeur de la variable somme est automatiquement traduite en chaine de caractères avant d'être affichée. Par exemple, si somme = 2013, la chaine de caractères
"2013" sera automatiquement affichée à la suite de la chaine "x + y =".
Remarque: les valeurs des différentes expressions sont automatiquement séparées par un espace. Dans notre exemple:
il y a un espace entre le = et le nombre 2013.
Si vous souhaitez ne pas avoir cette
séparation, il suffit de séparer les expressions à afficher, non pas par des virgules, mais par des +.
Mais attention: dans ce cas, vous utilisez la
concaténation
de chaines de caractères. Il faudra donc penser à convertir les expressions numériques en chaines de caractères à l'aide de
str.
Par exemple, avec l'instruction:
print("x + y ="+str(somme))
on obtient:
Le deuxième exemple se trouve
dans le fichier
Exemple-Python-Premieres-Notions/Population. Par rapport à l'exemple précédent, il est un plus
complet au niveau des fonctions de conversion de type. Mais, il n'apporte rien de plus en ce qui concerne le
fonctionnement de input et de print.
Il s'agit d'un programme avec trois variable-données:
- Ville est destinée à contenir le nom d'une ville.
- NH pour le nombre d'habitants de la ville
exprimé en milliers. Remarquez que ce nombre n'est pas forcément entier : 264.2 représente par exemple
264200 habitants.
- S pour la superficie en km2. On supposera que S est un nombre entier.
et une variable résultat:
- Densite : la densité de population en nombre d'habitants par km2. On souhaiterait que ce résultat
soit un nombre entier.
Voici un exemple d'exécution du programme :
Les données entrées par l'utilisateur sont Strasbourg, 277.3 et 78.
Tout le reste est affiché par le programme.
Le traitement des données consiste ici à calculer la densité de la population à partir du nombre d'habitants
et de la superficie de la ville.
Voici le code du programme:
Ville = input("Ville : ")
NH = float(input("Nombre d'habitants (en milliers) : "))
S = int(input("Superficie (en km2): "))
Densite = int(NH*1000/S)
print("A "+ Ville + " il y a " + str(Densite) + " habitants/km2")
On constate que la saisie de la variable Ville ne nécessite aucune conversion de type. Normal, puisque Ville est
destiné à contenir une chaine de caractères.
La saisie du nombre d'habitant utilise float car le nombre introduit par l'utilisateur n'est pas forcément entier.
Le traitement des données est réalisée par l'instruction:
Densite = int(NH*1000/S)
Le calcul NH*1000 / S aurait à priori suffit à calculer la densité de population. Mais la valeur de cette expression
n'est pas forcément un nombre entier. Nous avons donc utilisé ici la fonction de conversion int pour la convertir
en nombre entier.
Nous présentons ici un troisième exemple de programme utilisant les caractère de passage à la ligne
et de tabulation pour la mise
en forme de l'affichage.
Cet exemple se trouve dans le fichier Exemple-Python-Premieres-Notions/PoidsIdeal.py.
Il s'agit d'un programme permettant de
calculer le poids idéal d'une personnne en fonction de sa taille et de son age.
Voici, un exemple d'exécution du programme:
Les données définies par l'utilisateur sont : le prénom, le nom, la taille et l'age.
On remarque que le texte affiché est espacé. L'affichage démarre à la troisième ligne. Les résultats (deux dernières lignes) sont
séparés des données par deux lignes vides. Ceci est réalisé grâce à l'utilisation du caractère de saut de ligne.
Il se note \n.
De plus, le texte n'est pas collé sur le bord gauche de la
fenêtre d'exécution.
Il y a une marge à gauche. Ceci est réalisé à l'aide du caractère de tabulation
qui se note \t.
Voici les instructions de saisie des données:
prenom = input("\n\n\tPrenom : ")
nom = input("\tNom : ")
taille = int(input("\tTaille (cm) : "))
age = int(input("\tAge : "))
Ce sont les deux caractères de saut de ligne dans le premier input qui permettent de démarrer
l'affichage en troisième ligne.
Le caractère \t qui suit les deux \n, provoque un décalage du texte vers la droite de huit caractères.
Plus exactement, tout se passe comme si on
avait mis huit blancs avant Prenom. On pourrait donc penser que le caractère de tabulation n'est que l'équivalent
d'une chaine de caractères constituée de huit blancs. En réalité, le principe de fonctionnement de ce caractère
est un peu plus compliqué que cela. Nous verrons cela plus en détails un peu plus loin.
Enfin, voilà les instructions d'affichage des résultats:
print("\n\n\t"+prenom+ " "+nom+" : age ",end="")
print(str(age)+" ans, taille "+ str(taille)+ " cm")
print("\tPoids ideal : ",end="")
print(str((taille - 100 + age/10.)*0.9) + " kg\n")
L'effet des caractères \n et \t situé dans les chaines de caractères est le même que dans les
instructions input. En particulier, les deux vides séparant la lecture des données de l'affichage des résultats
est obtenu par les deux \n dans la première instruction print.
On constate par ailleur qu'il y a quatre instructions d'affichage, alors que le programme affiche les résultats sur deux
lignes. Cela s'explique de la manière suivante: la première instruction print se termine par ,end="". Elle
indique à Python que le prochain print doit se faire sur la même ligne.
Par conséquent, la deuxième instruction print affiche les caractères sur la même ligne que la première à la suite
des caractères déjà affichés.
Le même principe, utilisé dans le troisième print, permet de découper l'affichage de la deuxième ligne de résultat
en deux instructions print
.
Dans la dernière instruction print:
print(str((taille - 100 + age/10.)*0.9) + " kg\n")
on trouve l'affichage d'une expression numérique.
Elle permet de calculer le poids idéal
à partir de la taille et de l'age. Cet exemple montre que le traitement des données peut s'effectuer
à l'intérieur des instructions d'affichage. Il n'est donc pas toujours nécessaire d'utiliser des
variables résultat pour stocker les résultats des traitements avant de les afficher, mais il est préférable
de procéder de cette manière pour une raison de lisibilité du code.
Dans cet exemple, on aurait gagné en lisibilité en utilisant une variable résultat PoidsIdeal
et en séparant le traitement des données de l'affichage comme ceci:
PoidsIdeal= (taille - 100 + age/10.)*0.9
print(str(PoidsIdeal) + " kg\n")
Nous revenons ici sur la mise en forme de l'affichage du texte avec les caractères spéciaux de passage à la ligne
et de tabulation.
Le curseur est une sorte de trait blanc clignotant qui apparait lorsque le programme est interrompu par
une lecture de donnée (ou un input si vous préférez) :
Au démarrage d'un programme, le curseur se situe au début de la première ligne de la
fenêtre d'exécution.
Dès qu'un caractère est affiché, que ce soit par une instruction du programme ou par une touche appuyée par l'utilisateur, il
est affiché à l'emplacement du curseur, puis le curseur se place juste après ce caractère. C'est à dire sur la même ligne
à droite du caractère affiché
ou, si le caractère se situe en fin de ligne (tout à droite de la fenêtre d'exécution), au début de la ligne
suivante.
Il y a toutefois une exception pour les caractères \n et \t, qui
provoquent simplement un déplacement du curseur.
Dans le cas d'un \n, le curseur est déplacé au début de la ligne suivante.
Dans le cas d'un \t, le curseur se déplace horizontalement jusqu'à la prochaine position de tabulation.
Les positions de tabulation sont espacées régulièrement de huit caractères. La première se situe au 9ème caractère de la ligne,
la seconde au 17ème, etc....