Accueil
Mes tutoriels sur la programmation

Tutoriel Python - sommaire


Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site

Nos premiers programmes - les structures de contrôle

Nous n'allons plus utiliser l'interpréteur (de commande) mais l'interface de programmation qui est 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 avec le graphique éventuel.
Pour lancer l'IDLE sous Windows 10, il suffit de cliquer sur l'un 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 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
Dans le dossier "documents" de votre ordinateur, créez un sous-dossier nommé "python_prog" dans lequel vous sauvegarderez désormais toutes vos créations algorithmiques : programmes, fichiers de données, bases de données.

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 :

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

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 que vous avez créé spécialement pour stocker vos programme ; donner un nom au fichier-programme : "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 ...

Attetnion, comme le montre la fenêtre d'exécution, même si on saisit une suite de chiffres dans la variable "nombre" , cette saisie est considérée comme une chaine de caractères ...

Deuxième programme

Créer un nouveau fichier dans l'IDLE avec la commande par menu : 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 des nombres saisis' , somme)

Ce programme permet de cumuler les valeurs saisies.
Il faut alors que chaque valeur saisie soit convertie en nombre (entier ou décimal) d'où l'instruction : somme = somme + eval(variable)
La fonction eval(chaine) convertit une chaine (au format numérique) en un nombre.
Chaine au format numérique : suite de chiffres et éventuellement un point à l'intérieur 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 ( exécution du "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. Donc il faut effectuer une conversion.
Ceux qui connaissent le langage JavaScript savent qu'on a le même problème avec la fonction prompt.

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

Les règles de passage LDA à programmation en Python:
SAISIR -> input() ; SI -> if ; SINON SI -> elif ; AFFICHER-> print()
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 ci-dessous le code de la version améliorée : "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')

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 :

  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é.
La solution se trouve en fin de chapitre.

La fonction randint():
La fonction randint() permet de gérer de façon aléatoire un entier.
Cette fonction n'est pas disponible dans le module de base mais dans le module "random", qu'il faut donc importer.

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

# 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 not in "nN": 
    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 : ')

while choix not in "nN": à la question "encore jouer ?" l'utilisateur doit saisir "n" ou "N" pour sortir de la boucle.
Pour toutes autres saisie le test est FAUX donc le bouclage se poursuit. Un bon exemple d'emploi de l'opérateur "not in".

Parcours de liste

Je vous propose maintenant de petits programmes pour parcourir une 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))".
len(ma_liste) retourne 6. Donc bouclage pour i compris entre 0 et 5.

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 ... in enumerate(nomListe).
Le code :

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

maliste = ["Pierre", "Paul", "Jean", "Jacques", "Henri", "Bernard"]
for elt in enumerate(maliste):
    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.

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 :

# nom programme : table_multiplication.py
# objet : tables de multiplication
print("Les tables de multiplication")
for i in range(1,11): #pour ligne de 1 à 10
    print("Table par " , i )
    for j in range(1,11):
        produit = i * j
        print(i, " *", j, " = ", produit)
    print("----------------")

Extrait de la trace d'exécution :

Table par  2
2  * 1  =  2
2  * 2  =  4
2  * 3  =  6
2  * 4  =  8
2  * 5  =  10
2  * 6  =  12
2  * 7  =  14
2  * 8  =  16
2  * 9  =  18
2  * 10  =  20
----------------

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