Accueil
Mes tutoriels sur la programmation

Traduction

Tutoriel Python - sommaire

Contenu de la page à la suite du 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 pour l'affichage du 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 :

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

Attention, 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 ... et on ne peut faire d'opérations à partir d'une chaine ...
Heureusement, on peut toujours convertir une chaine ayant un format numérique en un entier ou un flottant (nombre décimal).

Deuxième programme

Créer un nouveau fichier dans l'IDLE avec la commande par menu : File/New File ...

Code source à saisir

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(nombre)
La fonction eval(chaine) convertit une chaine (au format numérique) en un flottant.

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

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.

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 :

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 :

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é

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.

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

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" ; améliorez le code afin que l'utilisateur puisse jouer plusieurs fois. Il faut donc intégrer la boucle actuelle dans une autre boucle.

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

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é

Première proposition

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