Accueil

Tutoriel Python - sommaire

Nos premiers programmes : structures de contrôle

Nous n'allons plus utiliser l'interpréteur (de commande) mais l'interface de programmation qui est appelé 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 et une autre avec la trace de l'exécution de ce programme voire une troisième fenêtre avec le graphique éventuel.
Pour lancer l'iDDLE sous Windows 10, il suffit de cliquer sur l'une des deux raccourcis dans la barre de tâches. Si vous n'avez pas créé ces raccourcis, il suffit de tapez "py" dans la zone de commandes puis de sélectionner IDLE.

Un programme Python est stocké dans un fichier d'extension .py
Dans le dossier "documents" de votre ordinateur, créez un sous-dossier "python" dans lequel vous sauvegarderez désormais toutes vos créations algorithmiques.

Premier programme nommé "test_input.py"

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

Le code source

Tapez le code suivant dans la fenêtre :

# nom du programme : test_input.py
#saisie tant que variable = 'fin'
while True :
    nombre  =input("tapez un nombre ou  'fin' : ")
    print('type : ', type(nombre))
    if nombre == 'fin' :
        break
print('fin de programme')

Surtout respectez l'indentation.
L'instruction while True: crée une boucle. Un bloc d'instructions sera donc répété plusieurs fois.
Toutes les lignes de ce bloc doivent donc être en retrait par rapport à "while True :"
Attention l'instruction print('fin de programme') doit être exécutée qu'une fois (en dehors du bloc). Donc cette ligne ne doit pas être en retrait par rapport à while True: mais au même niveau !

L'instruction while true: crée une boucle infinie mais heureusement l'utilisateur peut intervenir pour mettre fin à cette boucle.

Sauvegarde du programme

Tant qu'il n'a pas été sauvegardé sous forme d'un fichier, un programme ne peut ê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 "prog python", que vous aviez déjà créé, donner un nom au fichier : "test_input.py".

Exécution du programme

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 ...

Comme le montre la fenêtre d'exécution, même si on saisit une suite de chiffres dans "nombre" , cette saisie est considérée comme de type string.

Deuxième programme

Il faut donc créer un nouveau fichier avec la commande File/New File ...

Code source à saisir

# nom du programme : cumul_saisies.py
#saisie tant que variable = 'fin'
somme = 0
while True :
    nombre =input("tapez un nombre ou  'fin' : ")
    if nombre == 'fin' :
        break
    somme = somme + eval(nombre)
print('cumul nombre saisis' , somme)

Ce programme permet de cumuler les valeurs saisies.
Il faut encore que les valeurs saisies soient transformée en nombre d'où l'instruction : somme = somme + eval(variable)
La fonction eval(chaine) convertit une chaine en nombre si c'est possible c'est à dire si la chaine a un format numérique (suite de chiffres avec éventuellement un point en guise de séparateur décimal).

Exécution

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

Les structures conditionnelles ou tests

Vous avez déjà eu un aperçu des tests dans les deux petits programmes. 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 (break).
Mais les tests peuvent 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 bien codé 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
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 Python.

#nom programme : test_if.py
moyenne = input('tapez la moyenne')
moyenne = eval(moyenne) 	 #conversion chaine en nombre
if moyenne >= 12 : 
	print("bon trimestre")

Notez qu'en programmation Python il y a une ligne supplémentaire par rapport à l'algorithme.
En effet 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.
Ceux qui connaissent le langage JavaScript savent qu'on a le même problème avec la fonction prompt (équivalent de input).
Il y a aussi des lignes de commentaires ou des commentaires en fin de ligne.

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 
SI moyenne ≥ = 12 ALORS AFFICHER "bon trimestre"
SINON AFFICHER "peux mieux faire"

Codage en Python :

 
# nom du programme : test_if_else.py
moyenne = input('tapez la moyenne')
moyenne = eval(moyenne) 	 #conversion chaine en nombre
if moyenne >= 12: 
	print("bon trimestre")
else: 
	print("peut mieux faire")

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 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 
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 faux donc on passe au suivant, deuxième test vrai donc affichage "très bien".
moyenne = 9 : premier test faux donc on passe au deuxième, deuxième test faux donc on passe au troisième qui est aussi faux donc on passe au quatrième qui est vrai donc affichage de "insuffisant".

Code source

A partir de cet algorithme vous pouvez saisir directement dans l'IDLE le programme en Python.
SAISIR -> input() ; SI -> if ; SINON SI -> elif ; AFFICHER-> print()
Attention n'oubliez pas de rajouter la conversion de la saisie de type string en un réel.
Vous nommerez ce programme "test_if_elif.py".

Amélioration du programme

C'est bien gentil 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 le code du programme nommé "test_if_elif_plus.py"

#nom programme : test_if_elif_plus.py
while True: 
    moyenne =input("saisir moyenne ou 'fin' : ")
    if moyenne =='fin':
        break
    moyenne =eval(moyenne) #conversion chaine en nombre
    if moyenne >= 18:
        print('excellent')
    elif moyenne >=14:
        print('très bien')
    elif moyenne >=10:
        print('correct')
    elif moyenne >=6:
        print('insuffisant')
    else:
        print('très faible')
    print("-----------------------")
print('fin du boulot')

Bien évidemment pour produire cette version améliorée il ne faut surtout 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 :

  if moyenne =='fin':
        break

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.

Tapez le code suivant dans un nouveau fichier.

# nom programme : nombre_a_trouver.py
from random import *
nbre_secret = randint(1,100)
while True
    nbre_propose = input('propose un nombre : ')
    if nbre_secret ==int(nbre_propose):
        print ('correct')
        break
    elif nbre_secret > int(nbre_propose)
        print('trop petit')
    else
        print('trop grand')

Sauvegarde 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!).
Ne vous contentez pas de corriger les bugs. Mais faites en sorte que vous puissiez jouer plusieurs fois de suite jusqu'à ce que vous soyez las. Vous tapez alors "stop" en guise de nombre proposé.
Solution en fin de chapitre.

Les boucles

Nous savons déjà faire une boucle infinie et comment sortir de cette boucle.
Je vous rappelle le code correspondant.

While True: 
	if variable == "fin" : 
		break
		suite du bloc d'instructions 

Il s'agit d'une astuce programmatique qui suppose que le langage dispose de la commande break.

Travail à faire

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

Première solution

Nous allons utiliser la structure while ... (tant que ... en pseudo-code).
Code source :

#nom du programme : test_while.py
gars = ['Alain', 'Bernard', 'Claude', 'Didier', 'Emile']
i = 0
while i < 5:
        print(gars[i])
        i = i + 1

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 ...(pour ... en pseudo-code).

# nom programme : test_for.py
filles = ['Alice', 'Béatrice', 'Claudine', 'Delphine', 'Emma']
for i in range(5): #pour i de 0 à 4
    print(filles[i])

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.
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 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 :

# nom programme : impairs.py
for i in range(1,50): #pour i de 1 à 49
    if i%2 !=0:
        print(i, " est un nombre impair")
    else:
        continue
print("fin programme")

"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é

# nom programme : nombre_a_trouver_plus.py

from random import *
choix ="O"
while choix in "oO": 
    nbre_secret = randint(1,100)

    while True:
        nbre_joueur = input('propose un nombre : ')
        if nbre_secret ==int(nbre_joueur):
            print ('correct')
            break
        elif nbre_secret > int(nbre_joueur):
            print('trop petit')
        else:
            print('trop grand')
    choix =input('encore jouer ? O/N : ')

À la question "encore jouer ?" l'utilisateur peut saisir o majuscule ou minuscule.
D'où l'instruction : while choix in "oO":

Parcours de liste

Parcours avec une structure for ...

Le programme :

 
#nom programme : parcours_liste.py
#objet : parcours d'une liste selon une méthode classique
ma_liste = ["Pierre", "Paul", "Jean", "Jacques", "Henri", "Bernard"]
for i in range(len(ma_liste)):
    print (ma_liste[i])

Notez la syntaxe "for i in range(len(nomListe))"

Trace de l'exécution :

Pierre
Paul
Jean
Jacques
Henri
Bernard

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

Parcours d'une liste avec enumerate()

Sous Python une liste peut être parcourue avec une structure particulière basée sur for ... et la fonction enumerate().

Le code :

#nom prog parcours_liste_plus.py
#objet : parcours d'une liste avec enumerate

ma_liste = ["Pierre", "Paul", "Jean", "Jacques", "Henri", "Bernard"]
for elt in enumerate(ma_liste):
    print(elt)

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 :

(0, 'Pierre')
(1, 'Paul')
(2, 'Jean')
(3, 'Jacques')
(4, 'Henri')
(5, 'Bernard')

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.

Le chapitre est terminé !

Dans le chapitre suivant nous allons aborder des programmes un peu plus complexes et en particulier des programmes de cryptage.
A cet occasion vous voir tout l'intérêt de maitriser les chaines et les listes.