Mise en Projet
À l'issue de ce chapitre, l'apprenant.e sera capable de maîtriser la mise en page des programmes en Python ainsi que d'utiliser les éléments de base de la syntaxe. Ce chapitre comportera les 20 énoncés déjà abordés en pseudo-code ainsi qu'une introduction aux listes.
ObjectifLes objectifs de ce chapitre sont :
- Pouvoir mettre en page correctement un programme en Python;
- Maîtriser les éléments de base de la syntaxe Python;
- Pouvoir refaire les 20 exercices de pseudo-code en Python et les exécuter pour les vérifier;
- Comprendre le fonctionnement des listes et rédiger des programmes avec des listes.
Nous avons vu dans le chapitre sur les Notions de Python que la mise en page jouait un rôle capital en Python. Nous allons commencer par quelques programmes en mode graphique. L'énorme avantage de cela est que la moindre erreur apparaît directement à l'écran et qu'il est moins compliqué de trouver la cause du problème que dans des programmes classiques.
Les programmes en bleu ci-dessous peuvent être "copiés-collés"* dans votre éditeur IDLE et être exécutés pour vérification. N'hésitez pas à les modifier afin de vous exercer au maximum.
* Pour copier-coller le programme, effectuez les opérations suivantes :
- Sélectionnez avec la souris l'ensemble du programme, à savoir le texte en bleu dans le cadre;
- Tapez au clavier la combinaison de touches "Ctrl + c" (copier) : enfoncez la touche "Ctrl", tapez la touche "c" et relâchez la touche "Ctrl";
- Ouvrez votre éditeur de programme IDLE
- Ouvrez un fichier vide "New File" ou tapez la combinaison de touches "Ctrl + n";
- Cliquez dans la fenêtre vide de ce nouveau fichier;
- Tapez la combinaison de touches "Ctrl + v" (coller)
- Exécutez le programme en tapant la touche "F5".
Sachez que toutes les lignes qui commencent par le signe # (dièse) est un commentaire. Ce sont des indications destinées au lecteur du programme mais qui sont ignorées par l'ordinateur au moment de l'exécution.
Boucler la boucle
Voici un cercle incomplet. Il y a au moins deux façons de fermer ce cercle... Pouvez-vous trouver deux façons de fermer ce cercle ?
|
from turtle import *
# Importation de toutes les commandes (*) de la bibliothèque turtle for i in range (30): forward (10) left (10) |
Surprenant
Exécutez ce programme. Pouvez-vous expliquer pourquoi une telle figure ?
|
from turtle import *
for j in range (2): for k in range (18): forward (10) right (5) right (90) |
Étrange
Exécutez ce programme. Pouvez-vous expliquer pourquoi les choses se passent ainsi ?
|
from turtle import *
def petale(): for j in range (2): for k in range (18): forward (10) right (5) right (90) for i in range (18): petale() right (20) |
Le mot réservé def permet de définir une fonction qui regroupe un certain nombre d'instructions à exécuter. Ici, ce sera le dessin d'un "pétale". L'avantage est que, du programme principal qui commence à la ligne rouge, il est possible d'appeler cette fonction autant de fois que l'on veut. Cela permet d'alléger considérablement les programmes.
Casse-tête : pouvez-vous démontrer pourquoi la rosace se ferme correctement ?
Maisonnettes
Ce programme est extrait de l'excellent livre L'informatique simplement, concepts de programmation de Juraj Hromkovič et Tobias Kohn aux Éditions LEP (Suisse).
Après avoir exécuté ce programme, quelle constatation pouvez-vous faire en comparant avec l'exercice de démarrage de Python sur le carré ?
|
from turtle import *
def maisonnette(): for i in range (4): forward (50) right (90) left (60) forward (50) right (120) forward (50) left (60) combien = int(input("Combien de maisonnettes sont à dessiner ? ")) up() backward(300) down() for i in range (combien): maisonnette() |
Le principe est le même que pour le programme précédent concernant l'utilisation d'une fonction. Le programme commence à se lire au niveau de la ligne rouge qui représente le début du programme principal.
Par rapport au programme du carré, la demande du nombre de maisonnettes se fait dans une fenêtre différente de celle du dessin, il s'agit de la fenêtre d'exécution du programme, celle qui sera utilisée dans les programmes non graphiques de la suite.
Vous constatez aussi quelques instructions inconnues jusqu'ici... Veuillez voir ci-dessous leur explication.
À vous de jouer !!!
Volez maintenant de vos propres ailes, dessinez un bateau, une rosace de 12, 18 ou 36 parallélogrammes, des polygones réguliers dont vous avez demandé le nombre de côtés à l'utilisateur... Inspirez-vous de dessins d'Internet...
Voici un certain nombre d'instructions que vous pouvez utiliser en mode graphique. Vous pouvez maintenant réaliser des exercices divers en utilisant ces différentes instructions.
| reset() | Efface tout ce qui a déjà été dessiné |
| goto(x,y) | Va à l'endroit des coordonnées x et y de l'écran |
| forward(distance) | Avance de la distance donnée |
| backward(distance) | Recule de la distance donnée |
| up() | Relève le crayon, la tortue avancera sans dessiner |
| down() | Abaisse le crayon pour dessiner (état par défaut) |
| color(couleur) | couleur peut être une chaîne prédéfinie ("red", "blue",...), RGB,... |
| left(angle) | Tourne sur place à gauche de angle degrés |
| right(angle) | Tourne sur place à droite de angle degrés |
| width(épaisseur) | Choisit l'épaisseur du trait en pixels |
| write(texte) | Écrit la chaîne de caractère texte (entre " ") sur l'écran graphique |
Jusqu'à présent, vous avez essentiellement recopié des textes de programmes, cela ne vous a pas beaucoup permis de pratiquer la mise en page ni la syntaxe.
Il est essentiel, à ce stade, de réaliser par vous-même des programmes de rosaces, des dessins,... afin de maîtriser correctement la mise en page des programmes en Python.
Les programmes en pseudo-codeVoici les 20 énoncés des exercices en pseudo-code. Avant d'aborder les programmes plus complexes, il serait judicieux de vous exercer en réalisant les programmes en Python de ces 20 énoncés.
Attention : dans certains cas, si vous cliquez sur le mot "Énoncé" d'un exercice, vous pouvez obtenir des explications sur sa résolution.
Énoncé 1 : le programme doit lire des nombres au clavier jusqu'à trouver la valeur 0 (zéro). Le programme doit alors signaler en quelle position ce 0 est apparu dans la liste des nombres lus. Une analyse préliminaire est indispensable (notamment pour identifier le(s) "tour(s) de main" requis).
Énoncé 2 : le programme doit lire au maximum 3 mots en arrêtant la lecture dès qu'il trouve le mot "stop". Le programme doit ensuite signaler si le mot "stop" figurait parmi les mots lus.
Énoncé 3 : le programme doit lire des mots jusqu'à trouver 1 mot demandé au préalable à l'utilisateur. Le programme doit ensuite signaler si ce mot était dans les 2 premiers mots lus, entre le 3ème et le 5ème ou plus loin dans la liste. (NB: "au préalable" veut dire "avant".)
Énoncé 4 : le programme doit lire des mots jusqu'à trouver le mot "stop" à condition d'avoir lu au moins une fois avant, à n'importe quelle position, le mot "attention". N'utilisez qu'un seul RÉPÈTE.
Commentaire : une manière de faire serait un premier Répète jusqu'à trouver "attention" et ensuite un second Répète jusqu'à trouver "stop". Il est préférable d'utiliser un tour de main avec une seule boucle Répète.
Énoncé 5 : le programme doit lire des nombres en s'arrêtant à un nombre demandé au préalable à l'utilisateur. Le programme doit alors signaler combien de fois il a rencontré le nombre 0 (zéro) dans la liste des nombres lus. (NB: "au préalable" veut dire "avant".)
Énoncé 6 : le programme doit demander 1 nombre compris entre 2 et 10 inclus (veillez à la robustesse de votre programme!). Le programme lit alors des nombres jusqu'à trouver 3 multiples du nombre demandé. Utilisez % (abrégé de modulo) pour trouver le reste de la division entière.
Énoncé 7 : le programme doit lire des mots jusqu'à rencontrer le mot "stop" à condition que le mot "attention" se trouve juste avant lui dans la liste. Signaler combien de fois le mot "attention" a été lu.
Énoncé 8 : le programme doit lire des nombres jusqu'à trouver le nombre 0 (zéro). Le programme affiche alors la moyenne de tous les nombres lus sans tenir compte du 0. Attention à la robustesse de votre programme.
Énoncé 9 : le programme doit lire des nombres entiers positifs en demandant au préalable à l'utilisateur combien de nombres seront à lire (robustesse!). Le programme affiche alors le plus petit et le plus grand des nombres lus.
Énoncé 10 : le programme doit lire des mots jusqu'à trouver le mot "stop" à condition que le mot "attention" se soit présenté au moins 1 fois dans la liste. Signaler les positions du premier et dernier "attention" lus dans la liste.
Énoncé 11 : le programme doit lire des nombres jusqu'à ce que la somme des nombres lus soit égale à un nombre demandé au préalable à l'utilisateur. Signaler combien de ces nombres étaient positifs, négatifs et égaux à 0.
Énoncé 12 : le programme doit lire des nombres jusqu'à trouver un nombre demandé au préalable à l'utilisateur pour autant que ce nombre soit égal à la somme des 2 derniers nombres précédents. Exemple: nombre d'arrêt = 12 et les nombres juste avant = 8 et 4 ou 6 et 6 ou 0 et 12.
Énoncé 13 : le programme doit lire des nombres entiers positifs jusqu'à trouver 3 multiples de 5. Le programme doit alors afficher ces 3 multiples dans l'ordre de leur lecture.
Énoncé 14 : le programme doit lire des nombres jusqu'à trouver 3 multiples d'un nombre demandé au préalable à l'utilisateur. Signaler combien de ces multiples étaient des nombres pairs.
Énoncé 15 : le programme doit simuler le jet d'un dé et afficher la valeur trouvée à chaque lancer. Le programme doit afficher le nombre de jets qui ont été nécessaires pour trouver un 6.
Énoncé 16 : le programme simule le jet d'un seul dé et affiche la valeur trouvée à chaque lancer jusqu'à trouver dans l'ordre les valeurs 4, 2 et 1. Il signale les positions de la première et la dernière paire trouvées (2 valeurs successives identiques).
Énoncé 17 : le programme simule, parmi les 13 cartes de pique (voir l'image ici), le tirage avec remise d'un nombre de cartes demandé au préalable à l'utilisateur. Tirage avec remise veut dire que la carte est remise dans le jeu avant le tirage suivant. Chaque carte doit être affichée en clair, il faut afficher "Dame de pique" et non "12 de pique". 1 = "As", 11 = "Valet", 12 = "Dame" et 13 = "Roi".
Commentaire : vous allez, bien entendu, utiliser une cascade de Si :O).
Énoncé 18 : le programme simule le jet d'un seul dé jusqu'à trouver successivement dans l'ordre ou le désordre deux nombres demandés au préalable à l'utilisateur (robustesse!). Le programme signale le nombre de paires de 6 rencontrées, c'est-à-dire deux 6 qui se suivent au lancer.
Énoncé 19 : le programme simule le jet d'une pièce d'1 euro jusqu'à ce que le nombre de "Pile" soit égal au nombre de "Face" + 3. Le programme affiche le résultat à chaque lancer et combien de lancers ont été nécessaires.
Énoncé 20 : le programme lance simultanément 3 dés en affichant leurs valeurs jusqu'à obtenir 421. 421 sera obtenu si la somme des 3 dés = 7 et leur produit = 8.
Les listes en PythonDurant tout l'apprentissage, nous avons utilisé des tableaux. L'avantage de cette structure est qu'elle est facilement intelligible, dans chaque "case" se trouve une donnée, on peut y accéder grâce à l'indice de la case. Le tout est dans une structure rigide qu'il est difficile d'allonger, de raccourcir,... Les classements nécessitent des procédures assez lourdes...
En Python, les tableaux n'existent pas en tant que tels, ils sont avantageusement remplacés par les listes. Dans une liste, chaque élément a son indice de classement, ce qui peut s'apparenter au numéro de la case d'un tableau. Mais l'énorme avantage des listes par rapport aux tableaux est que les listes sont beaucoup plus souples et dynamiques, c'est un peu comme si les séparations entre les cases des tableaux n'existaient pas et que les données étaient juste juxtaposées sans structures de séparation. Il sera plus facile de les classer, d'y ajouter ou d'enlever un élément à un endroit précis, de fusionner des listes... Voyons cela en détails.
Vous pouvez vous référer au livre "Apprendre à programmer avec Python 3" de Gérard Swinnen (Éditions Eyrolles), téléchargeable sur ce site au chapitre "1. Quel langage choisir ?", pages 137 à 148.
Voyez aussi notre résumé sur la théorie des listes.
Voici quelques exercices qu'il est relativement simple de résoudre grâce aux listes.
Énoncé 21 : Le programme simule le tirage du Lotto belge (chaque pays a ses particularités, vous pouvez l'adapter à votre pays). Un tambour contient 45 boules numérotées de 1 à 45. 6 boules sont tirées dans ce tambour sans remise (la boule tirée n'est pas remise dans le tambour avant le tirage suivant). Ensuite, un numéro complémentaire est tiré parmi les 39 boules restantes. Dans un premier temps, les numéros sont affichés dans l'ordre du tirage, le complémentaire étant affiché à part. Dans un second temps, les 6 premiers numéros sont affichés classés par ordre arithmétique croissant avec toujours le numéro complémentaire à part.
Énoncé 22 : réalisez un programme qui transforme un nombre décimal demandé à l'utilisateur en sa valeur binaire.
Énoncé 23 : réalisez un programme qui transforme un nombre binaire demandé à l'utilisateur en sa valeur décimale.
Énoncé 24 : sur base de l'énoncé 21, simulé le tirage de l'Euromillion. Il s'agit de tirer 5 numéros sans remise de 1 à 50 plus, à part, 2 "étoiles" sans remise de 1 à 12. Le tirage est affiché 2 fois, la première fois dans l'ordre des tirages et la seconde fois les numéros et les étoiles étant classées par ordre arithmétique croissant.
Énoncé 25 : sur base des énoncés 22 et 23, réalisez un programme qui permette de transformer un nombre décimal en octal et un autre programme qui permette de transformer un nombre octal en décimal.
Énoncé 26 : sur base des énoncés 22 et 23, réalisez un programme qui permette de transformer un nombre décimal en hexadécimal et un autre programme qui permette de transformer un nombre hexadécimal en décimal.
Bonne découverte et bon amusement.