Embed Size (px)
Citation preview
IREM de Lilleb Avenue Carl Gauss - Bât M1 - RdC
59655 Villeneuve d’AscqH +33 (0)3 20 43 41 82B [email protected] [email protected]
Scratch et Python, Programmer en MathsStage PAF 2018-2019
Aslı GRIMAUD et Philippe MARQUET
SommairePrésentation générale 3
1 Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
a Programmes du collège . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3b Programmes du lycée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 Contenu de la formation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1 Scratch et Python 61 Scratch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 Programmes de calcul et fonctions 81 En Scratch au collège . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Exercices niveau collège en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 En Python au lycée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3 Géométrie 161 En Scratch au collège . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 Exercices niveau collège en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 En Python au lycée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 Probabilité 271 En Scratch au collège . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 En Python au lycée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5 Nombres flottants en Python 331 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 Représentation des nombres flottants en Python avec la norme IEEE 754 . . . . . . . . . . . . . . 333 Quelles solutions alternatives ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
a Première alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34b Seconde alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35c Troisième alternative avec le package decimal . . . . . . . . . . . . . . . . . . . . . . . . . 35
6 Sujets à développer 361 En lien avec le programme du collège . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 En lien avec le programme du lycée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Bibliographie 38
Sommaire
2
Présentation générale1 OrganisationCe support a été élaboré par Aslı Grimaud pour le stage “Scratch et Python, programmer en Maths” de l’IREMde Lille, en collaboration avec Philippe Marquet.Le stage se déroule en mars et avril 2019 sur le campus cité scientifique de l’université de Lille.Les informations pratiques et les ressources proposées (dont le présent support) sont disponibles à partir de lapage http://fe.fil.univ-lille1.fr/sep19/.
2 ProgrammesLes activités proposées sont à l’articulation entre le collège et le lycée. Les éléments des programmes de maths ducollège et de la classe de seconde relatifs à la programmation sont rappelés ici.
a Programmes du collège
Bien que le collège comprend la dernière année du cycle 3 et les trois années du cycle 4, nous allons nous intéresserplutôt au cycle 4 et plus précisément au niveau 3e. Ceci étant dit, les activités proposées lors de ce stage peuventêtre adaptées aux niveaux inférieurs.Le programme du cycle 4 (voir [5] et [2]) est séparé en cinq thèmes principaux : “Nombres et calculs”, “Orga-nisation et gestion de données, fonctions”, “Grandeurs et mesures”, “Espace et géométrie”, “Algorithmique etprogrammation”.D’après les programmes officiels, au cycle 4, les élèves s’initient à la programmation, en développant dans unedémarche de projet quelques programmes simples, sans viser une connaissance experte et exhaustive d’un langageou d’un logiciel particulier. En créant un programme, ils développent des méthodes de programmation, revisitentles notions de variables et de fonctions sous une forme différente, et s’entraînent au raisonnement. Les attendusdu fin du cycle 4 sont : écrire, mettre au point et exécuter un programme simple.Connaissances :
— notion d’algorithme et de programme ;— notion de variable informatique ;— déclenchement d’une action par un événement ;— séquences d’instructions, boucles, instructions conditionnelles.
Compétences associées :— écrire un programme ;— mettre au point (tester, corriger) un programme ;— exécuter un programme en réponse à un problème donné.
b Programmes du lycée
Pour la partie lycée, nous allons nous intéresser plutôt à la classe de seconde (mais pas que), le but étant de fairele lien entre le collège et le lycée. Nous allons plus précisément travailler avec le programme de la classe de secondegénérale et technologique (voir [4]) mais les activités proposées peuvent être adaptées à tous les secondes et à tousles niveaux.Le programme de mathématiques définit un ensemble de connaissances et de compétences qui s’appuie sur leprogramme de collège, en réactivant les notions déjà étudiées et en y ajoutant un nombre raisonnable de nouvellesnotions, à étudier de manière suffisamment approfondie.L’utilisation des logiciels est mise en avance par le programme. L’utilisation de logiciels (calculatrice ou ordinateur),d’outils de visualisation et de représentation, de calcul (numérique ou formel), de simulation, de programmationdéveloppe la possibilité d’expérimenter, ouvre largement le dialogue entre l’observation et la démonstration etchange profondément la nature de l’enseignement.L’utilisation régulière de ces outils peut intervenir selon trois modalités :
— par le professeur, en classe, avec un dispositif de visualisation collective adapté ;3
— par les élèves, en classe, à l’occasion de la résolution d’exercices ou de problèmes ;— dans le cadre du travail personnel des élèves hors du temps de classe (par exemple au CDI ou à un autre
point d’accès au réseau local).Le programme s’organise en cinq grandes parties : “Nombres et calculs”, “Géométrie”, “Fonctions”, “Statistiqueset probabilités” et “Algorithmique et programmation”.Dans le cadre de la partie sur l’algorithmique et la programmation, les élèves s’exercent à :
— décrire des algorithmes en langage naturel ou dans un langage de programmation ;— en réaliser quelques-uns à l’aide d’un programme simple écrit dans un langage de programmation textuel ;— interpréter, compléter ou modifier des algorithmes plus complexes.
Un langage de programmation simple d’usage est nécessaire pour l’écriture des programmes informatiques. Lelangage choisi est Python, langage interprété, concis, largement répandu et pouvant fonctionner dans une diversitéd’environnements. Les élèves sont entraînés à passer du langage naturel à Python et inversement. L’algorithmiquea une place naturelle dans tous les champs des mathématiques et les problèmes ainsi traités doivent être en relationavec les autres parties du programme (fonctions, géométrie, statistiques et probabilité, logique) mais aussi avecles autres disciplines ou la vie courante.À l’occasion de l’écriture d’algorithmes et de petits programmes, il convient de transmettre aux élèves l’exigenced’exactitude et de rigueur, et de les entraîner aux pratiques systématiques de vérification et de contrôle. Enprogrammant, les élèves revisitent les notions de variables et de fonctions sous une forme différente. Nous visonsdeux sujets principaux : utiliser les variables et les instructions élémentaires et notion de fonction.Contenus :
— variables informatiques de type entier, booléen, flottant, chaîne de caractères ;— affectation (notée ← en langage naturel) ;— séquence d’instructions ;— instruction conditionnelle ;— boucle bornée (for), boucle non bornée (while) ;— fonctions à un ou plusieurs arguments ;— fonction renvoyant un nombre aléatoire. Série statistique obtenue par la répétition de l’appel d’une telle
fonction.Capacités attendues :
— choisir ou déterminer le type d’une variable (entier, flottant ou chaîne de caractères) ;— concevoir et écrire une instruction d’affectation, une séquence d’instructions, une instruction conditionnelle ;— écrire une formule permettant un calcul combinant des variables ;— programmer, dans des cas simples, une boucle bornée, une boucle non bornée ;— dans des cas plus complexes : lire, comprendre, modifier ou compléter un algorithme ou un programme ;— écrire des fonctions simples ; lire, comprendre, modifier, compléter des fonctions plus complexes. Appeler
une fonction ;— lire et comprendre une fonction renvoyant une moyenne, un écart type (aucune connaissance sur les listes
n’est exigée) ;— écrire des fonctions renvoyant le résultat numérique d’une expérience aléatoire, d’une répétition d’expériences
aléatoires indépendantes.
3 Contenu de la formationLors de cette formation, nous allons brièvement présenter le langage de programmation Scratch (voir [3] pourla version 2.0) qui est utilisé au collège en cycle 3 et 4 comme support des activités d’algorithmique et de pro-grammation. Nous présenterons ensuite tout aussi brièvement le langage de programmation Python (voir [1])utilisé au lycée pour la partie algorithmique et programmation du programme de maths. Nous utiliserons Thonny,un environnement de programmation Python adapté à l’enseignement. Toutefois, un autre environnement deprogrammation Python peut très bien le remplacer.Le but de ces deux journées est de pratiquer des activités Scratch et Python, de produire ensemble d’autresactivités qui pourront être utilisées en classe.Ce document présente des sujets étudiés du collège au lycée que nous allons programmer ensemble sur les troisthèmes suivants :
4
1. Programmes de calcul et fonctions2. Géométrie3. Probabilité
Ces sujets pourront être adaptés au besoin pour prendre en compte l’hétérogénéité des élèves.Dans un deuxième temps, ce sera aux stagiaires de choisir un ou plusieurs sujets et de produire des programmes,voire des fiches activités en autonomie, avec l’aide des deux intervenants.L’ensemble des ressources, sujets d’activités, programmes, etc. sera mis à disposition à partir de la pagehttp://fe.fil.univ-lille1.fr/sep19/.
5
Scratch et Python1 ScratchScratch est un langage de programmation graphique manipulable et exécutable par le logiciel de même nom àvocation éducative.Scratch 2.0 est la version utilisée depuis 2013, disponible en ligne et hors-ligne. La version actuelle est 3.0, disponibledepuis le 2 janvier 2019. Cette version est plus portable car écrite en JavaScript et utilisant HTML5 au lieu d’AdobeFlash Player. Le code est sous licence libre, de plus en plus permissive au fur et à mesure des versions.Dans ce stage, nous allons utiliser Scratch 3.0 directement dans un navigateur web à partir dehttps://scratch.mit.edu/. Scratch Desktop 3.0 peut également être téléchargé pour un travail sans connexionInternet depuis https://scratch.mit.edu/download (versions Windows 10+, macOS 10.13+ au 15 mars 2019).
Nous détaillerons l’interface de Scratch et présenterons le langage lors du stage. Néanmoins, et brièvement, sur lacapture d’écran ci-dessus, on remarque que la fenêtre est divisée en trois parties verticales :
— la première “colonne” montre les blocs disponibles sur Scratch. Le langage Scratch est constitué de multiplesbriques permettant d’exécuter une action précise. Il existe des catégories de briques différentes, classéespar couleurs : mouvement, apparence, son, événements, contrôle, capteurs, opérateurs, variables, mes blocs.Scratch 3.0 permet également d’ajouter des extensions. Par exemple, les blocs de stylos du Scratch 2.0 sonten extention ;
— la deuxième partie est la zone de travail où on crée les programmes ;— la troisième partie est la zone d’exécution où on voit le résultat de l’exécution des programmes.
2 PythonPython est un langage de programmation généraliste. Bien que Python soit un langage objet, dans le cadred’une initiation à la programmation, et dans le cadre de ce stage, nous considérerons les seuls aspects langage deprogrammation impératif de Python.Python est un langage interprété. Chaque “phrase” du langage est lue puis traduite en actions exécutées sur lamachine. On a en quelque sorte une exécution pas à pas des programmes. Cette caractéristique est particulièrementintéressante dans le cadre d’un enseignement.Le langage Python est placé sous une licence libre proche de la licence BSD (licence libre utilisée pour la distributionde logiciels).Pour ce stage, nous allons utiliser un environnement de programmation Python appelé Thonny. Thonny peut êtretéléchargé à https://thonny.org/, le téléchargement inclut la dernière version de Python (3.7.2 au 15 mars 2019).
6
D’autres environnements de programmation, ou simplement un terminal, peuvent être utilisés pour programmeren Python.
Sur cette capture d’écran de Thonny, on distingue plusieurs zones :— sur la gauche, la fenêtre supérieure est un éditeur de fichiers texte dans lequel on écrira des programmes
Python ;— sous cette fenêtre, l’interprète Python exécute le code Python saisi ;— les fenêtres de droite sont des aides à la programmation.
En intégrant Python dans les apprentissages, on transfert des notions informatiques aux élèves. On travaille sur lesvariables, l’affectation, les fonctions, les contrôles, les expressions fondamentales, les types de base, les itérations,les boucles, etc.
7
Programmes de calcul et fonctions1 En Scratch au collègeLe premier travail proposé dans ce chapitre vise le niveau 3e avec un travail sur les programmes de calcul faisantintervenir le calcul littéral et les fonctions. Ce travail permet à l’élève de voir plusieurs points du programme,entre autres :
— Algorithmique et programmation - Écrire, mettre au point, exécuter un programme en réponse à un problèmedonné.
— Organisation et gestion de données, fonctions - Connaître les différents modes de représentation d’une fonc-tion (expression symbolique, tableau de valeurs, représentation graphique, programme de calcul).
— Nombres et calculs - Utiliser le calcul littéral pour modéliser une situation, mettre un problème en équationen vue de sa résolution.
— Organisation et gestion de données, fonctions - Résoudre des problèmes modélisés par des fonctions.Il est prévu de proposer ce travail au niveau 3e après l’étude des programmes de calcul, de la notion de fonctionet éventuellement après la révision de la résolution des équations en classe. Il est conseillé de donner au moins 2hen salle informatique pour un travail individuel ou en binôme selon les niveaux des élèves.Ce travail guide les élèves dans la construction des programmes, prend en compte l’hétérogénéité des élèves, faitle lien entre les programmes de calcul et les fonctions, permet à l’élève de chercher et tester plusieurs solutions,modélise une situation de la vie quotidienne, révise la mise en équation et la résolution des équations dans un casconcret.
8
Programmes de calculs et fonctions
Compétences
D1.3 7.1 Expliquer le résultat produit par un algorithme simple.MATH 1.3 Tester, essayer plusieurs pistes de résolution.D1.3 2.2 Produire une expression littérale.
Créer un nouveau fichier Scratchet l’enregistrer dans le ré-pertoire Maths sous le nomprogramme-calcul-1.sb3.
Exercice 1 : Premier programme Scratch
1) Soit le programme ci-dessous. Attention : nombre est une variable crééedans l’onglet Variables.
quand est cliqué
demander Choisir un nombre. et attendre
mettre nombre à réponse
mettre résultat à 3 * nombre
dire regrouper Après calcul, on obtient : et résultat
2) Exécuter ce programme plusieurs fois. À quoi sert ce programme ?
.
Exercice 2 : Programme de calcul
Voici un autre programme de calcul et un programme Scratchassocié.
• Choisir un nombre.• Ajouter 7 au nombre donné.• Multiplier le résultat par 2.• Soustraire 14 au résultat.
quand est cliqué
demander Choisir un nombre. et attendre
mettre nombre à réponse
mettre résultat à 7 + nombre
mettre résultat à 2 * résultat
mettre résultat à résultat - 14
dire regrouper Après calcul, on obtient : et résultat
1) Que donne le programme de calcul ci-dessus si on choisit 4 comme nombre ? Détailler les calculs.
.
Créer un nouveau fichier Scratchet l’enregistrer dans le ré-pertoire Maths sous le nomprogramme-calcul-2.sb3.
2) À l’aide du programme Scratch ci-dessus, vérifier tes calculs dela question précédente.
3) Réécrire le programme Scratch donné ci-dessus en le simplifiant, c’est-à-dire en utilisant moins de blocs deScratch. Le programme doit toujours faire les mêmes calculs. Vérifier tes calculs de la première question.
4) Exécuter ce programme avec différentes valeurs de départ. Écrireles résultats dans la tableau ci-contre.
Nombre de départ Résultat obtenu
5) Quelle relation remarques-tu entre le nombre de départ choisi et le résultat obtenu en regardant le tableau dela question précédente ?.
9
6) Justifier ce résultat en exprimant le résultat obtenu en fonction du nombre de départ x.
.
7) Comment pourrait-on encore simplifier le dernier programme Scratch que tu as écrit ?
.
Exercice 3 : D’un degré à l’autre
Le degré Fahrenheit (symbole : ◦F ) est une unité de mesure de la température utilisée dans de nombreux paysanglo-saxons. En France, nous utilisons le degré Celsius (symbole : ◦C).
Pour trouver une température en degré Fahrenheit à partir de la température en degré Celsius, il faut multiplierle degré Celsius par 1,8 et ensuite ajouter 32 au résultat.1) À combien de degrés Fahrenheit l’eau bout-elle ? Écrire tes calculs ci-dessous.
.
2) Quelle est la température normale du corps en degré Fahrenheit ? Écrire tes calculs ci-dessous.
.
Créer un nouveau fichier Scratchet l’enregistrer dans le répertoireMaths sous le nom fahrenheit.sb3.
3) Construire un programme qui calcule une température en degré Fahrenheit en fonction d’une température endegré Celsius. Vérifier tes calculs des deux premières questions.4) Dupliquer et modifier le dernier programme Scratch pour écrire un programme qui permet de faire l’in-verse, c’est-à-dire d’exprimer en degré Celsius des températures exprimées en degré Fahrenheit. Tester ce nouveauprogramme avec les valeurs des deux premières questions.
Soit f la fonction qui exprime la température en degré Fahrenheit en fonctionde la température x en degré Celsius.
On a f(x) = 1, 8x+ 32.
5) Quelle est la température qui s’exprime avec le même nombre en degré Celsius et en degré Fahrenheit ? Trouverl’équation qui répond à cette question et la résoudre ci-dessous..
10
2 Exercices niveau collège en PythonUn même algorithme peut être codé dans différents langages de programmation. Dans cette section, nous allonsconsidérer les algorithmes et programmes réalisés dans les derniers exercices et en proposer une version Python.Le programme Scratch avec les attendus du collège est le suivant :
quand est cliqué
demander Quelle est la température en Celsius ? et attendre
mettre celsius à réponse
mettre fahr à 1.8 * celsius
ajouter 32 à fahr
dire regrouper La température en Fahrenheit est : et fahr
La définition d’un bloc Scratch celsius_en_fahrenheit qui accepte une entrée cels et produit sont résultatdans la variable resultat_celsius_en_fahrenheit est un premier pas vers la définition d’une fonction Python.On écrira :
définir celsius_en_fahrenheit : cels
mettre resultat_celsius_en_fahrenheit à 1.8 * cels
ajouter 32 à resultat_celsius_en_fahrenheit
quand est cliqué
demander Quelle est la température en Celsius ? et attendre
celsius_en_fahrenheit réponse
dire regrouper La température en Fahrenheit est : et resultat_celsius_en_fahrenheit
La définition de fonctions Python (fichier fahrenheit.py)
1 def celsius_en_fahrenheit(cels) :2 fahr = 1.8 * cels + 323 return fahr45 def fahrenheit_en_celsius(fahr) :6 cels = (fahr−32) / 1.87 return cels
permettra de mener les calculs suivants dans l’interprète Python :
>>> celsius_en_fahrenheit(100)212.0>>> celsius_en_fahrenheit(37)98.6>>> celsius_en_fahrenheit(−40)−40.0>>> fahrenheit_en_celsius(−40)−40.0
11
3 En Python au lycéeLe travail sur la dichotomie vise le niveau 2nd GT avec un travail sur les fonctions avec la recherche des coordonnéesdu point d’intersection de la courbe avec l’axe des ordonnées et la recherche d’un extremum. Ce travail permet àl’élève de voir plusieurs points du programme, entre autres :
— Fonctions - Exploiter un logiciel de géométrie dynamique ou de calcul formel, la calculatrice ou Python pourdécrire les variations d’une fonction donnée par une formule.
— Fonctions - Relier représentation graphique et tableau de variations.— Fonctions - Pour une fonction dont le tableau de variations est donné, algorithmes d’approximation numé-
rique d’un extremum (balayage, dichotomie).— Algorithmique et programmation - Écrire des fonctions simples ; lire, comprendre, modifier, compléter des
fonctions plus complexes. Appeler une fonction.Il est prévu de proposer ce travail au niveau 2nd GT après l’étude des fonctions surtout les représentationsgraphiques et les tableaux de variations. Il est également recommandé d’avoir évoqué la méthode de dichotomieen classe. Il est conseillé de donner au moins 2h en salle informatique pour un travail individuel ou en binômeselon les niveaux des élèves. Il est possible de donner les deux derniers exercices en devoir maison. Pour les élèvesà l’aise avec l’informatique, une extension de ce travail peut être proposée avec le calcul numérique des extremumdes fonctions avec dichotomie.Ce travail guide les élèves dans la construction des programmes, prend en compte l’hétérogénéité des élèves, révisele tableau de variations à l’aide du graphique, travaille sur les intervalles des nombres, permet à l’élève de chercheret tester plusieurs solutions en programmation, insiste sur les appels des fonctions.
12
DichotomieNous allons analyser la fonction f(x) = 4x2 − 10x+ 3.
Exercice 1 : Représentation graphique
Nous allons tracer la représentation graphique de la fonctionf(x) = 4x2 − 10x+ 3 avec Python.
Ouvrir un nouveau fichier Pythonavec le logiciel Thonny, l’enregistrerdans le répertoire Maths sous le nomtracer-courbe.py.
1) Soit le programme suivant :1 import matplotlib.pyplot as plt23 # une f o n c t i o n que l ’ on p o u r r a r e p r é s e n t e r4 def f(x) :5 ””” l a v a l e u r de n o t r e f o n c t i o n f en x ”””6 return 4*x*x − 10*x + 378 def tracer(fct, a, b, N) :9 ””” t r a c e l e g r a p h i q u e de l a f o n c t i o n f c t e n t r e a e t b a v e c N i n t e r v a l l e s ”””
1011 # l e s a x e s12 plt.axis([−5,5,−10, 40])13 plt.grid(True)1415 # l a l i s t e d e s a b s c i s s e s16 lx = [a+i*(b−a)/N for i in range(N+1)]17 # l a l i s t e d e s o r d o n n é e s18 ly = [fct(x) for x in lx]1920 # a f f i c h a g e21 plt.plot(lx,ly)22 plt.show()23 plt.close()
2) Dans la fenêtre de l’interprète, faire appel à la fonction>>> tracer(f, −5, 5, 100)
Observer le résultat.3) Quel est le rôle de la ligne 1 dans le programme ? (Supprimer ou commenter la ligne, observer.)4) Que fait-il la fonction f() définie à la ligne 4 ?5) Que fait-il la fonction tracer() définie à la ligne 8 ?6) À quoi correspondent les paramètres fct, a, b et N ?7) Que réalise l’appel de la fonction tracer() invoquée dans l’interprète ?8) Essayer d’autres valeurs des paramètres.
Exercice 2 : Tableau de variations et propriétés
1) Compléter le tableau de variations de la fonction f ci-dessous après avoir calculé les images f(−2), f(1, 25) etf(4). On pourra mener les calculs à la main ou utiliser l’interprète Python.
x -2 1,25 4
f(x)
2) Quelle propriété de la fonction f observes-tu sur l’intervalle [−2; 1, 25] ?3) Quelle propriété de la fonction f observes-tu sur l’intervalle [1, 25; 4] ?
13
• La fonction f est une fonction strictement monotone, continue et changeant de signe sur l’intervalle[−2; 1, 25], donc l’équation f(x) = 0 possède une solution réelle dans l’intervalle, c’est-à-dire il existeun zéro de la fonction f pour une valeur de x comprise entre −2 et 1, 25.• La fonction f est une fonction strictement monotone, continue et changeant de signe sur l’intervalle[1, 25; 4], donc l’équation f(x) = 0 possède une solution réelle dans l’intervalle.
Nous allons utiliser la dichotomie pour trouver ces valeurs.
Zéros de la fonction f
Exercice 3 : Dichotomie
La méthode de dichotomie permet la recherche d’un zéro d’une fonction. Elle consiste à répéter le partage d’unintervalle en deux parties puis à sélectionner le sous-intervalle dans lequel existe un zéro de la fonction.
On prend une fonction f : [a, b]→ R continue, avec a < b et f(a)× f(b) ≤ 0.
On regarde le signe de la valeur de la fonction f appliquée au point milieu de l’intervalle c =a+ b
2:
• si f(a)× f (c) ≤ 0 alors il existe x0 ∈ [a, c] tel que f(x0) = 0 ;• si f(a)× f (c) > 0 alors f (c)× f(b) ≤ 0 et donc il existe x0 ∈ [c, b] tel que f(x0) = 0.
On itère ce procédé jusqu’à s’approcher suffisamment de la valeur réelle.
Nous allons travailler dans un nou-veau fichier dichotomie.py du ré-pertoire Maths.
1) Compléter le code Python suivant qui définit une fonction dichotomie. Cette dérnière renvoie un zéro d’unefonction mathématiques donnée sur un intervalle précisé :
1 def dichotomie(fct, a, b, precision) :2 while b−a > precision :3 c = (a+b)/24 if <= 0 :5 b =6 else :7 a =8 return (a + b) / 2
2) En appellant la fonction dichotomie avec les bons paramètres, trouver une valeur approchée à 0,01 près duzéro de la fonction f(x) dans l’intervalle [2; 1, 25].3) En appellant la fonction dichotomie avec les bons paramètres, trouve une valeur approchée à 0,01 près duzéro de la fonction f(x) dans l’intervalle [1, 25; 4].
14
Exercice 4 : Dichotomie récursive
Une version dite récursive de la dichotomie peut être proposée. Le qualificatif recursif indique que l’algorithmeou la fonction va s’appeler elle-même.Pour la dichotomie, la récursivité peut s’exprimer ainsi : pour trouver le zéro de la fonction sur un intervalle, oncherche le zéro de la fonction sur un sous-intervalle.Considérer l’implémentation suivante de la dichotomie et tester le code.
1 def dichotomie_rec(fct, a, b, precision) :2 if b−a <= precision :3 return (a + b) / 24 else :5 c = (a + b) / 26 if fct(a) * fct(c) <= 0 :7 return dichotomie_rec(fct, a, c, precision)8 else :9 return dichotomie_rec(fct, c, b, precision)
Exercice 5 : Approximation de√2
En utilisant les fonctions définies dans les exercices précédents, calculer une valeur approchée de√2 avec une
précision de 0,001.Indication : considérer la fonction g(x) = x2 − 2.
15
Géométrie1 En Scratch au collègeLes deux activités proposées pour le niveau 3e permettent à l’élève de voir plusieurs points du programme, entreautres :
— Algorithmique et programmation - Écrire, mettre au point, exécuter un programme en réponse à un problèmedonné.
— Espace et géométrie - (Se) Repérer dans le plan muni d’un repère orthogonal.— Espace et géométrie - Mettre en oeuvre un protocole de construction d’une figure géométrique.
Nous proposons deux travaux pour le collège concernant la géométrie. Au cycle 4, on fait beaucoup de figuresgéométriques et cela permet d’une part d’apprendre à s’orienter dans un programme et d’autre part réviser lespropriétés de ces figures. Il faut avoir fait au préalable des activités sur l’orientation dans le plan.Dans la première activité, nous proposons donc de réviser les propriétés basiques des figures usuelles au niveau3e mais le travail peut très facilement être adapté aux niveaux inférieurs. Une heure en salle informatique estsuffisante pour cette activité qui peut être terminée en autonomie. Selon les connaissances des élèves, tous lesélèves ne pourront peut-être pas arriver au bout mais l’essentiel est d’avancer dans les questions en ayant compris.La deuxième activité se repose uniquement sur l’orientation dans un plan mais avec un but ludique. Le travaildemande au moins deux heures de programmation mais la totalité de l’activité peut être encore une fois terminéeen autonomie une fois l’idée comprise.Ces travaux guident les élèves dans la construction des programmes, prennent en compte l’hétérogénéité des élèves,consolident l’acquisition de l’orientation dans le plan, permettent à l’élève de chercher et tester plusieurs solutions,révisent les propriétés des figures usuelles et modélisent une situation de la vie quotidienne.
16
Figures usuelles
Compétences
D1.3 7.1 Expliquer le résultat produit par un algorithme simple.D1.3 7.3 Mettre au point un programme pour apporter une amélioration.D2 9.1 Être autonome dans son travail.
Exercice 1 : Figures usuelles
Créer un nouveau fichier Scratchet l’enregistrer dans le répertoireMaths sous le nom figures.sb3.
1) Soit le programme Scratch ci-contre. Le saisir et l’exécuter. Quelle figurepermet-il de construire ?.
2) On souhaite écrire ce programme de façon plus compacte. Modifier ce pro-gramme en remplaçant une partie des instructions par la boucle ci-dessous :
avancer de 100 pas
tourner de 90 degrés
répéter 4 fois
Vérifier que le programme fonctionne toujours.3) Écrire un programme pour tracer un rectangle qui n’est pas un carré.4) Écrire un programme pour tracer un triangle équilatéral.
Quand est cliqué
aller à x : 0 y : 0
s’orienter en direction de 90
effacer tout
stylo en position d’écriture
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
relever le stylo
Quand est cliqué
aller à x : 0 y : 0
s’orienter en direction de 90
effacer tout
stylo en position d’écriture
avancer de 100 pas
tourner de 60 degrés
attendre 1 secondes
avancer de 70 pas
tourner de 120 degrés
attendre 1 secondes
avancer de 100 pas
tourner de 60 degrés
attendre 1 secondes
avancer de 70 pas
s’orienter en direction de 90
relever le stylo
Exercice 2 : Parallélogrammes
Créer un nouveau fichier Scratchet l’enregistrer dans le ré-pertoire Maths sous le nomparallelogramme.sb3.
1) Saisir et exécuter le programme Scratch ci-contre. Quelle figure permet-il deconstruire ?.
2) Modifier ce programme pour obtenir un losange.3) Modifier ce programme pour obtenir un carré.4) Modifier ce programme pour obtenir un rectangle.
Exercice 3 : Cercle
Créer un nouveau fichier Scratchet l’enregistrer dans le répertoireMaths sous le nom cercle.sb3.
1) Écrire un programme Scratch pour tracer un cercle. Indice : Un cercle n’estpas un polygone mais tu vas devoir t’aider des polygones pour le tracer surScratch.2) Écrire un programme Scratch pour tracer un cercle avec un rayon donné.Indice : Ne pas hésiter à utiliser le périmètre d’un cercle dans ton programme.
17
Date digitale
Compétences
D1.3 7.1 Expliquer le résultat produit par un algorithme simple.D1.3 7.3 Mettre au point un programme pour apporter une amélioration.D2 9.1 Être autonome dans son travail.
Quand est cliqué
aller à x : 0 y : 0
s’orienter en direction de 90
effacer tout
stylo en position d’écriture
avancer de 50 pas
relever le stylo
avancer de -50 pas
tourner de 90 degrés
stylo en position d’écriture
avancer de 50 pas
tourner de 90 degrés
avancer de 50 pas
tourner de 90 degrés
avancer de 50 pas
tourner de 90 degrés
avancer de 50 pas
relever le stylo
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
avancer de 70 pas
Exercice 1 : Mise en route
Créer un nouveau fichier Scratchet l’enregistrer dans le ré-pertoire Maths sous le nomdate_digitale.sb3.
1) Le programme ci-contre permet de dessiner le chiffre 5 à la façon des horlogesdigitales. Saisir le programme sur Scratch.2) Dessiner ci-dessous à main levée le résultat de ce programme. Marquer parune croix le point de départ du tracé et par une autre croix le point d’arrivéedu tracé.
Exercice 2 : Blocs
1) Créer un nouveau bloc cinq et lui attacher le code qui permet de dessinerle chiffre 5.
définir cinq
2) Coder un programme principal qui affiche le chiffre 5 en appelant le bloccinq.
Exercice 3 : Date1) Programmer chaque chiffre restant dans un nouveau bloc.2) Programmer un bloc pour tracer un point.3) Dans la définition de chaque bloc dessinant un chiffre, ajoute un paramètre pour préciser la couleur du stylo.Les paramètres sont appelés entrée (nombre ou texte) dans l’interface Scratch.
mettre la couleur du stylo à number or text
4) Afficher la date d’aujourd’hui dans un programme principal au milieu de l’écran avec la couleur de ton choix.
18
2 Exercices niveau collège en PythonLe module turtle de Python permet de commander une tortue qui va tracer des segments. Il est bien évidementinspiré du fameux langage Logo développé par Seymour Papert dans les années 60. Le module étant en anglais,cela permettra de travailler en pluridisciplinaire.L’utilisation du module est une possible transition depuis ce que font les élèves avec le chat Scratch au collège. Àl’aide de ce module, il est par exemple possible de reprendre le travail de tracé de figures géométriques ou de ladate digitale.On utilise les fonctions du module après un import turtle.Il est possible de commander le paramétrage du crayon par :
— turtle.down() qui abaisse le stylo ;— turtle.up() qui relève le stylo ;— turtle.pencolor(color) qui change la couleur ("red", "green", "blue", etc.).
On déplace la tortue avec :— turtle.forward(length) qui avance d’un nombre de pas donné ;— turtle.backward(length) qui recule ;— turtle.right(angle) qui tourne vers la droite d’un angle donné (en degrés) ;— turtle.left(angle) qui tourne vers la gauche.
On peut également déplacer la tortue à un point donné ou modifier son orientation avec :
— turtle.goto(x,y) qui déplace la tortue jusqu’au point (x, y) ;— turtle.setheading(angle) qui oriente la tortue à l’angle donné en degrés, le 0◦ étant à l’est, le 90◦ au
nord, etc.
La fenêtre par défaut est 950 pixels en largeur et 800 pixels en hauteur. Le point (0, 0) est au centre de l’écran.Au départ, la tortue est en (0, 0), orientée à 0◦.Voici un exemple :
1 import turtle23 def spriral(n) :4 turtle.pencolor("red")5 for i in range(n) :6 turtle.forward(i * 10)7 turtle.right(144)
Essayez :
>>> spiral(20)
19
3 En Python au lycéeAu lycée, les attendus en géométrie sont un peu différents, les notions abordées sont relatives à géométrie analy-tique.Les deux activités proposées pour le niveau 2nd GT permettent à l’élève de voir plusieurs points du programme,entre autres :
— Géométrie - Établir que trois points sont alignés ou non.— Géométrie - Déterminer une équation de droite à partir de deux points, un point et un vecteur directeur ou
un point et la pente.— Fonctions - Algorithme de calcul approché de longueur d’une portion de courbe représentative de fonction.— Algorithmique et programmation - Concevoir et écrire une instruction d’affectation, une séquence d’instruc-
tions, une instruction conditionnelle.— Algorithmique et programmation - Écrire une formule permettant un calcul combinant des variables.— Algorithmique et programmation - Programmer, dans des cas simples, une boucle bornée, une boucle non
bornée.— Algorithmique et programmation - Dans des cas plus complexes : lire, comprendre, modifier ou compléter
un algorithme ou un programme.Dans la première activité, nous proposons de réviser quelques notions de la géométrie analytique tout en pro-grammant des fonctions : la distance entre deux points, le milieu d’un segment, l’alignement de trois points dansle plan et l’équation d’une droite passant par deux points. Beaucoup de sujets sont révisés dans cette activité àtravers l’algorithmique.La deuxième activité est un travail plutôt sur l’algorithmique. D’ailleurs, avant de vouloir programmer, la com-préhension de l’algorithme sur l’approximation de la longueur de l’arc de la parabole doit se faire en classe enamont. Le travail en salle informatique démarre à partir de l’exercice 2.Ce travail guide les élèves dans la construction des programmes, prend en compte l’hétérogénéité des élèves, révisedes notions de la géométrie analytique, renforce les notions d’algorithmique, permet à l’élève de chercher et testerplusieurs solutions en programmation, insiste sur les appels des fonctions et les tests.
20
PointsAvec Thonny, créer un nouveau fi-chier Python points.py dans le ré-pertoire Maths.Exercice 1 : Distance entre deux points
Nous allons écrire une fonction qui calcule la distance entre deux points dans un plan.Soient P1 (x1, y1) et P2 (x2, y2) deux points. La distance entre ces deux points est donnée par la formule :
d =
√(x2 − x1)
2 + (y2 − y1)2
.1) Compléter le code suivant de définition de la fonction distance().Pour la racine carrée, on utilisera la fonction sqrt() définie dans la bibliothèque math.
1 def distance (x1, y1, x2, y2) :2 ””” l a d i s t a n c e e n t r e l e s p o i n t s ( x1 , y1 ) e t ( x2 , y2 ) ”””3 d =4 return d
2) Utiliser cette fonction distance() pour calculer la distance entre les points A(4;−6) et B(3; 7, 5).
Exercice 2 : Milieu d’un segment
Nous allons écrire une fonction qui calcule les coordonnées du milieu d’un segment dont les coordonnées desextrémités sont données.Soient P1 (x1, y1) et P2 (x2, y2) les deux points d’extrémités d’un segment. Les coordonnées du point milieu M(x, y)sont données par les formules :
x =x1 + x2
2, y =
y1 + y22
1) Compléter dans le fichier points.py le code ci-dessous de définition de la fonction milieu().1 def milieu(x1, y1, x2, y2) :2 ””” Renv o i e l e p o i n t m i l e u du segmen t ( x1 , y1 )−( x2 , y2 ) ”””3 x =4 y =5 return x, y
2) Utiliser cette fonction milieu() pour calculer les coordonnées du point milieu du segment dont les extrémitéssont A(4;−6) et B(3; 7, 5).
Exercice 3 : Alignement de trois points dans le plan
Nous allons écrire une fonction qui retourne vrai (True) si et seulement si trois points donnés sont alignés dansun plan. Cette fonction retournera faux (False) sinon.Soient P1 (x1, y1), P2 (x2, y2) et P3 (x3, y3) les trois points dont on cherche l’alignement dans le plan. Les pointsP1, P2 et P3 sont alignés si le point P3 appartient à la droite (P1P2) c’est-à-dire si les droites (P1P2) et (P1P3)
sont parallèles. Autrement dit, si les vecteurs −−−→P1P2 et −−−→P1P3 sont colinéaires.−−−→P1P2
(x2 − x1y2 − y1
)et −−−→P1P3
(x3 − x1y3 − y1
)sont colinéaires
si et seulement sileur déterminant est nul :
(x2 − x1)(y3 − y1)− (y2 − y1)(x3 − x1) = 0.
1) Compléter dans le fichier points.py la définition de la fonction ci-dessous.1 def sont_alignes(x1, y1, x2, y2, x3, y3) :2 ””” r e t o u r n e v r a i s s i l e s 3 p o i n t s ( x1 , y1 ) , ( x2 , y2 ) , ( x3 , y3 ) s o n t a l i g n é s ”””34 return
2) Utiliser cette fonction sont_alignes() pour savoir si les groupes des trois points suivants sont alignés ou pas :X(1; 0), Y (2; 1), Z(3; 2) et X(1; 0), Y (2; 1), T (3; 3).
21
Exercice 4 : Équation d’une droite passant par deux points
Nous allons écrire une fonction qui retourne l’équation d’une droite passant par deux points donnés.Soient P1 (x1, y1) et P2 (x2, y2) les deux points en question.
— Si x1 = x2 alors l’équation est de la forme x = x1 ;— Sinon nous allons chercher les valeurs du cœfficient directeur (m) et de l’ordonnée à l’origine (p) de l’équation
réduite de la forme y = mx+ p avec
m =y2 − y1x2 − x1
et p = y1 −m× x1
1) Compléter dans le fichier points.py la définition de la fonction ci-dessous.
1 def est_horizontale(x1, y1, x2, y2) :2 ””” r e n v o i e True s i l a d r o i t e p a s s a n t par l e s deux p o i n t s ( x1 , y1 )3 e t ( x2 , y2 ) e s t h o r i z o n t a l e , F a l s e s i n o n . ”””45 return
2) La fonction suivant renvoie le coefficient directeur et l’ordonnée à l’origine de la droite passant par deux points.On ne pourra appeler cette fonction que si la droite n’est pas horizontale, ce que l’utilisateur pourra vérifier avecla fonction précédente.
1 def droite(x1, y1, x2, y2) :2 ””” r e n v o i e l e c o e f f i c i e n t d i r e c t e u r m, e t l ’ o r don née à l ’ o r i g i n e p ,3 de l a d r o i t e p a s s a n t par l e s p o i n t s ( x1 , y1 ) e t ( x2 , y2 ) ”””45 return m, p
3) Utiliser cette fonction droite() pour trouver l’équation des droites passant par les groupes de points suivants :X(1; 0), Y (2; 1) et K(3; 4), L(3; 6).
22
Longueur d’un arc de parabole
Le but de cette activité est d’approcher la longueur de l’arc AB de la parabole d’équation y = x2 où A et Bsont deux points d’abscisses positives tel que xA < xB.
Nous allons approcher la longueur de l’arc AB en faisant la somme des distances entre des points que nousallons choisir sur la parabole. Les abscisses de ces points seront régulièrement réparties dans l’intervalle
[xA, xB] selon le nombre n de points intermédiares souhaités.
Exercice 1 : Compréhension de l’algorithme
Les figures ci-dessous permettent de visualiser l’idée de l’algorithme que nous allons programmer. Soient A(0, 2; 0, 22)
et B(1; 12) les deux points entre lesquels nous allons approcher la longueur de l’arc AB de la parabole.
n = 0 n = 1 n = 2 n = 3
n ligne brisée approximation de l’arc AB
0 AB AB
1 AP1B AP1 + P1B
2 AP1P2B AP1 + P1P2 + P2B
34
1) Compléter le tableau ci-dessus.2) Calculer les coordonnées des points qui manquent ci-dessous selon la valeur de n au centième près.
n = 0
• A(xA, xA2) avec xA = 0, 2
• B(xB, xB2) avec xB = 1
n = 1
• A(xA, xA2) avec xA = 0, 2
• P1(x1, x12) avec x1 = xA +
xB − xAn
= 0, 6
• B(xB, xB2) avec xB = 1
n = 2
• A(xA, xA2) avec xA = 0, 2
• P1(x1, x12) avec x1 = xA +
xB − xAn
≈ 0, 47
• P2(x2, x22) avec x2 = xA + 2× xB − xA
n≈ 0, 73
• B(xB, xB2) avec xB = 1
23
n = 3
• A(xA, xA2) avec xA = 0, 2
• P1(x1, x12) avec x1 = xA +
xB − xAn
=
• P2(x2, x22) avec x2 = xA + 2× xB − xA
n=
• P3(x3, x32) avec x3 = xA + 3× xB − xA
n=
• B(xB, xB2) avec xB = 1
n = 4
• A(xA, xA2) avec xA = 0, 2
• P1(x1, x12) avec x1 =
• P2(x2, x22) avec x2 =
• P3(x3, x32) avec x3 =
• P4(x4, x42) avec x4 =
• B(xB, xB2) avec xB = 1
Ouvrir une nouveau Python avecThonny et l’enregistrer dans lerépertoire Maths sous le nomapproximation_parabole.py.
Exercice 2 : Distance entre deux points
Nous allons avoir besoin de calculer la distance entre deux points dont on connaît les coordonnées. Nous allonsutiliser la fonction distance() déjà écrite dans l’activité Points - ex 1 qui est ci-dessous.
1 from math import sqrt23 def distance (x1, y1, x2, y2) :4 d = sqrt((x1−x2)*(x1−x2) + (y1−y2)*(y1−y2))5 return d
Exercice 3 : Première fonction pour n = 1
Cette fonction permet de calculer la longueur de l’arc en utilisant qu’un seul point intermédiaire.1) Compléter le code ci-dessous.
1 def approximation_n_1 (xA,xB) :2 pas = (xB−xA) / 23 x1 =4 approx =5 return approx
2) Utiliser cette fonction approximation_n_1() pour calculer une approximation de la longueur de l’arc AB dela parabole y = x2 entre les points A(0, 2; 0, 22) et B(1; 12).
Exercice 4 : Deuxième fonction pour n = 2
Cette fonction permet de calculer la longueur de l’arc en utilisant deux points intermédiaires.1) Compléter le code ci-dessous.
1 def approximation_n_2(xA,xB) :2 pas = (xB−xA) / 33 x1 =4 x2 =5 approx =6 return approx
2) Utiliser fonction approximation_n_2() pour calculer une approximation de la longueur de l’arc AB de laparabole y = x2 entre les points A(0, 2; 0, 22) et B(1; 12).
24
Exercice 5 : Troisième fonction pour n = 3
Cette fonction permet de calculer la longueur de l’arc en utilisant trois points intermédiaires.1) En s’aidant des questions précédentes, écrire la fonction approximation_n_3(xA,xB).2) Utiliser celle fonction approximation_n_3() pour calculer une approximation de la longueur de l’arc AB dela parabole y = x2 entre les points A(0, 2; 0, 22) et B(1; 12).
Exercice 6 : Approximation pour un nombre quelconque de points intermédiaires
Le but de l’activité est d’utiliser de plus en plus de points intermédiaires pour approcher le plus possible la longueurde l’arc souhaité. Il faut donc automatiser l’utilisation du nombre de points intermédiares.1) Compléter le code ci-dessous.
1 def approximation_n(xA,xB,n) :2 pas = (xB−xA) / n3 approx = 04 x1 = xA5 for i in range(n) : # de 0 j u s q u ’ à n−16 x2 = x1 + pas7 approx =8 x1 = x29 return approx
2) Utiliser cette fonction approximation_n() pour calculer une approximation de la longueur de l’arc AB de laparabole y = x2 entre les points A(0, 2; 0, 22) et B(1; 12) avec différentes valeurs de n.
Exercice 7 : Vérification des résultats obtenus
Le fichier verification.py contient la fonction longueur_arc() qui permet de calculer la longueur de l’arc duparabole y = x2 entre deux points d’abscisses positives. En appelant cette fonction, vérifie les résultats de tesfonctions précédentes. Les approximations que tu obtiens doivent s’approcher de cette longueur au fur et à mesureque tu augmentes le nombre de points intermédiaires utilisés dans ton algorithme.
25
Explications du fichier verification.py pour les professeurs
La longueur AB, que nous souhaitons calculer, est décomposée en segments élémentaires de longueur dl. Sur lafigure, dans MHM ′ triangle rectangle en H,on a :
MM ′ ≈ MM ′ =√MH2 +HM ′2
(dl)2 = (dx)2 + (dy)2
=
(1 +
(dydx
)2)(dx)2
dl =√1 + y′2 dx
donc nous avons :AB =
∫ b
a
√1 + y′2 dx
Pour nous, la longueur souhaitée est donc donnée par :
L =
∫ 1
0,2
√1 + 4x2dx
car y′2 = ((x2)′)2 = (2x)2 = 4x2.En posant u = 2x, cela donne :
L =1
2
∫ 2
0,4
√1 + u2 du
Or, on sait qu’après des calculs (intégration par parties, primitives, Arg sh x, etc. ) une primitive de x 7→√1 + x2
est F (x) =1
2
[x√1 + x2 + ln
(x+√1 + x2
)].
Cela veut dire que la valeur que nous recherchons est : L =F (2)− F (0, 4)
2.
26
Probabilité1 En Scratch au collègeL’activité proposée sur la fréquence d’apparition des sommes lorsqu’on lance deux dés est un travail qui fait lelien entre la fréquence et la probabilité. Après un travail en amont, elle peut être proposée aux élèves de niveau3e ou 4e. Cette activité permet à l’élève de voir plusieurs points du programme, entre autres :
— Algorithmique et programmation - Écrire, mettre au point, exécuter un programme en réponse à un problèmedonné.
— Organisation et gestion de données, fonctions - Calculer des fréquences.— Organisation et gestion de données, fonctions - Aborder les questions relatives au hasard à partir de problèmes
simples.— Organisation et gestion de données, fonctions - Calculer des probabilités dans des cas simples.— Organisation et gestion de données, fonctions - Faire le lien entre fréquence et probabilité.
Au cycle 4, on aborde les bases de la probabilité qui est par la suite développée et élargie au lycée. Il est importantde proposer aux élèves différents types de support afin de s’assurer la bonne compréhension des notions. Avant cetravail, il serait intéressant de proposer aux élèves une activité où ils vont vraiment piocher des cubes ou lancerdes dés pour bien assimiler la notion d’expérience. Pour les élèves qui sont à l’aise avec la programmation et lanotion de probabilité, on peut leur proposer de faire un autre programme mais cette fois-ci avec le lancer de troisdés à la fois ou bien en utilisant des dés à huit faces par exemple. Ceci les incitera à consolider leurs connaissancessur l’activité.Ce travail guide les élèves dans la construction des programmes, prend en compte l’hétérogénéité des élèves, imposeà l’élève à s’organiser, permet à l’élève de chercher et tester plusieurs solutions, modélise une situation de la viequotidienne, révise les notions de fréquence et de probabilité.
27
Fréquence et probabilité
Compétences
MATH 2.3 Comprendre et utiliser une simulation numérique.D1.3 5.2 Calculer des probabilités dans un contexte simple.D1.3 5.3 Faire le lien entre fréquence et probabilité.
Le but de cette activité est d’analyser la somme qu’on obtient quand on lancedeux dés équilibrés à six faces indiscernables de l’un de l’autre. Nous allonstravailler sur la fréquence d’obtention de ces sommes et leur probabilité.
Exercice 1 : Préparation sur feuille
1) Quelles sont les sommes que nous pouvons obtenir en lançant deux dés équilibrés à 6 faces ? Énumérer ci-dessouschaque possibilité en écrivant le(les) addition(s) qui permet(tent) de les obtenir. Attention, il faut distinguer leschiffres du premier dé des chiffres du deuxième dé.
1+ 1 = 21+ 2 = 3
2) Calculer la probabilité d’obtenir chaque somme que tu as trouvé dans la question précédente au millième près.
p(“obtenir 2”) =
p(“obtenir 3”) =
Exercice 2 : Préparation sur Scratch Créer un nouveau fichier Scratchet l’enregistrer dans le ré-pertoire Maths sous le nomfrequence_probabilite.sb3.
1) Le résultat du lancer du premier dé sera stocké dans la variable dé1. Créer la variable dé1.2) Le résultat du lancer du premier dé sera stocké dans la variable dé2. Créer la variable dé2.3) La somme des deux lancers sera stockée dans la variable somme. Créer la variable somme.4) L’expérience consiste à lancer deux dés et noter la somme des lancers. Le nombre d’expériences sera stockédans la variable expériences. Créer la variable expériences. Initialiser le nombre des expériences à 100 avec lebloc suivant :
mettre expreiences à 100
5) Nous utiliserons la variable i comme un compteur. Créer la variable i et l’initialiser à 1 avec le bloc suivant :
mettre i à 1
28
6) Pour stocker le nombre de fois que chaque somme a été réalisée, nous avons besoin de 12variables. Cela fait beaucoup ! Alors nous allons créer une liste résultats qui contiendra12 cases. Tu peux l’imaginer comme ci-contre.Dans cet exemple, sur 100 expériences, la somme 1 a été obtenue 0 fois, la somme 2 a étéobtenue 4 fois, la somme 3 a été obtenue 7 fois, la somme 4 a été obtenue 11 fois, etc.Créer la liste résultats. Ensuite il faut créer chaque élément de la liste (le bloc “ajouter”)et l’initialiser à 0 (le bloc “ajouter”). Pour cela, utiliser les blocs suivants :
supprimer tous les éléments de la liste résultats
ajouter 0 à résultats
ajouter 1 à i
répéter jusqu’à ce que i > 12
Exercice 3 : Expériences
1) Mettre à la variable dé1 un nombre aléatoire entre 1 et 6. Ceci simule le lancer du premier dé. Tu peux utiliserle bloc opératoire nombre aléatoire entre 1 et 6.2) Mettre à la variable dé2 un nombre aléatoire entre 1 et 6. Ceci simule le lancer du deuxième dé.3) Mettre à la variable somme la somme des lancers des deux dés.4) Il faut ensuite augmenter de 1 le nombre de la liste correspondant à la somme obtenue avec le bloc suivant :
remplacer l’élément somme de la liste résultat par élément somme de résultats + 1
5) Nous souhaitons répéter cette expérience plusieurs fois. Pour cela, il suffit de répéter ces quatre dernièresétapes autant de fois que la variable expériences. Faire le nécessaire sur Scratch.
Exercice 4 : Calcul des fréquences
1) Calculer et afficher la fréquence d’apparition de la somme 12 en utilisant la formule suivante :
nombre d’apparition de la somme 12nombre total d’expériences
2) Quelle fréquence as-tu obtenue ? Comparer le résultat à la probabilité d’obtenir 12 que tu as calculée dans lepremier exercice..
3) Changer le nombre d’expérience à 1 000 000 et refaire la même comparaison. Qu’est-ce que tu remarques ?
.
29
2 En Python au lycéeCette activité peut être proposée aux élèves de première puisque, dans les programmes, elle fait partie des exemplesd’algorithmes proposés à ce niveau. Ceci dit, elle permet de réviser aux élèves de 2nd GT le calcul des fréquences etles fait travailler sur les types chaîne de caractères et liste de Python. Les élèves ne sont pas tenus de l’apprentissagedes listes en 2nd GT mais ils peuvent profiter de certaines activités pour se familiariser avec ces types. Les chaînesde caractères font parties des types de base de la programmation. La construction d’un histogramme permetégalement de visualiser et de donner un sens aux calculs. Les notions suivantes sont travaillées :
— Algorithmique et programmation - Écrire, mettre au point, exécuter un programme en réponse à un problèmedonné.
— Algorithmique et programmation - Choisir et déterminer le type d’une variable.— Algorithmique et programmation - Programmer dans des cas simples, une boucle bornée.— Algorithmique et programmation - Lire, comprendre, modifier ou compléter un algorithme ou un programme.
Ce travail guide les élèves dans la construction des programmes, prend en compte l’hétérogénéité des élèves,renforce les notions d’algorithmique sur différents typages, permet à l’élève de chercher et tester plusieurs solutionsen programmation, insiste sur les appels des fonctions et les tests.
30
Fréquence d’apparition des lettres dans un texte
Dans cette activité, nous allons nous intéresser à la fréquence d’apparition des lettres dans un texte donné. On neconsidérera pas les éventuels lettres accentuées, les signes de ponctuations et les espaces. On ne considérera queles lettres minuscules.
Exercice 1 : Fréquence d’une lettre On travaillera avec Thonny dans lefichier Python lettres.py du ré-pertoire Maths.
1) Dans ton compte, tu trouveras un fichier lettres.py qui contient une chaîne decaractère issue de la lettre de Van Gogh écrite le 17 Juin 1890 à Paul Gaugin. Cettelettre ne lui a jamais été envoyée et a été retrouvée dans les papiers du peintre aprèssa mort. Ouvrir ce fichier.2) Nous souhaitons écrire une fonction qui parcourt une chaîne de caractères, comptele nombre d’occurrences d’une lettre donnée en paramètre, et renvoie la fréquenced’apparition de la lettre dans le texte. Compléter le code ci-dessous.
1 def frequence(lalettre , texte) :2 nlettre = 0 # nombre de l e t t r e s du t e x t e3 compt = 0 # nombre d ’ o c c u r e n c e de l a l e t t r e4 for l in texte :5 nlettres =6 if :7 compt =8 return compt/nlettres
3) À l’aide de la fonction frequence(), trouver la fréquence d’apparition de la lettre e dans la chaîne de caractèresLettreVanGogh.4) Comparer le résultat avec celui de la fonction prédéfinie count() de la bibliothèque Python :
>>> texte.count(lettre)
Exercice 2 : Fréquences de toutes les lettres
1) En utilisant la fonction frequence() de l’exercice précédent, saisir et compléter le code ci-dessous.
1 alphabet = ’abcdefghijklmnopqrstuvwxyz’23 def liste_frequences(texte) :4 freq = []5 for i in :6 freq.append( )7 return freq
2) Pour aller plus loin. Cette fonction balaye le texte en entier pour chacune des lettres de l’alphabet. Quelleamélioration peut-on apporter aux fonctions frequence() et liste_frequence() pour remédier à ce problème ?Expliquer et programmer cette amélioration.
31
Exercice 3 : HistogrammeLa liste retournée dans l’exercice précédent est difficile à interpréter. Le code ci-dessous permet d’obtenir unhistogramme. La fonction plot_frequence() permet de créer un histogramme sans l’afficher. Il faut appeler lafonction plot_afficher() une seule fois pour visualiser les histogrammes créés.Le saisir, l’appeler avec l’alphabet et la liste de fréquence des lettres du texte de Van Gogh et commenter le visuel.
1 def plot_frequence(alph, flist) :2 # n u m é r o t a t i o n de 0 à 25 pour l e s l e t t r e s3 legendes = [i for i in alph]4 # c o n s t r u c t i o n de l ’ h i s t o g ramme5 plt.figure()6 plt.bar(legendes , flist, 0.5)7 plt.xlabel(’Lettres’)8 plt.ylabel(’Fréquences’)9
10 def plot_afficher() :11 plt.show()12 plt.close()
Exercice 4 : Plusieurs langues
Dans le fichier lettres.py tu trouveras également trois listes freq_fr, freq_en et freq_es qui donnent lafréquence d’appartition des lettres en français, en anglais et en espagnol.En utilisant ces listes et les fonctions plot_frequence() et plot_afficher() comment peut-on décider si untexte est écrit en français, en anglais ou en espagnol ?
Exercice 5 : Texte sans accents
Pour pouvoir décider la langue dans laquelle un texte est écrit, il nous faut un texte sans accent. Écrire la fonctionsans_accent(texte_avec_accent) qui prend en paramètre une chaîne de caractère écrite normalement et qui letransforme en un texte sans aucun accent.
32
Nombres flottants en PythonEn Python, comme dans beaucoup d’autres langages, les nombres réels sont approximés par des nombres flottants.Ces nombres flottants sont représentés selon la norme IEEE 754.
1 ProblématiqueLe code suivant (écrit le premier jour de ce stage) implémente un algorithme d’approximation de la racine dedeux. La fonction approximation_racine_2() calcule un intervalle dans lequel se trouve
√2 avec une précision
donnée.
1 def approximation_racine_2(a, b, precision) :2 while b−a > precision :3 c = a + precision4 d = b − precision5 if c*c < 2 :6 a = c7 if d*d > 2 :8 b = d9 return a,b
L’exécution de cette fonction pour chercher la racine de 2 entre 1, 4 et 1, 5 avec une précision de 0, 01 devraitrenvoyer l’intervalle [1, 41; 1, 42]. Or l’exécution de cet appel de la fonction ne s’arrête pas. Essayez :
>>> approximation_racine_2(1.4, 1.5, 0.01)
L’algorithme est pourtant correct. Le problème vient de la représentation des nombres décimaux utilisée parPython. En effet :
>>> 1.42−1.410.010000000000000009
2 Représentation des nombres flottants en Python avec la norme IEEE 754Le mathématicien pourrait considérer que le résultat précédent est faux. Ce n’est pas le cas. Ce résultat qui peutparaître étrange s’explique par la représentation des nombres flottants.La norme IEEE 754, utilisée par Python, définit la représentation des nombres flottants dans les machines sousla forme d’une séquence de 64 bits (double précision).Cette norme réduit un nombre réel à une approximation de ce nombre écrite avec 3 nombres entiers codés chacunpar un nombre fini de bits comme sur la figure ci-dessous (source Wikipédia).
Cette représentation (voir par exemple [6] section “Nombres flottants” pour plus de détails) repose sur le fait quetout nombre réel x non nul peut se mettre de façon unique sous la forme :
x = (−1)s × 2E ×M
où
• s = ±1 représente le signe ;• E ∈ Z représente l’ exposant ;• M ∈ [1; 2[ représente la partie significative (en binaire) appelé la mantisse.
33
Par exemple, avec x = −1
3on a : x = (−1)1 × 2—2 × 4
3d’où
• s = −1 puisque x est négatif ;• E = −2 ;
• M =4
3.
Codage de l’exposant s. Notre nombre est négatif et donc s = 1.
Codage de l’exposant E. Dans un codage à 64 bits, les 11 bits réservés à l’exposant ne sont pas directementla représentation binaire de E, mais du nombre E′ = E + 210 − 1. Pour nous, puisque E = −2, on aE′ = −2 + 1023 = 1021. Donc pour les 11 bits, on a :
01111111101
Codage de l’exposant M. On a :
M =4
3=
1
1− 1
4
=
+∞∑k=0
1
4k
donc l’écriture binaire de M est :1, 010101010101...
La mantisse étant toujours un nombre réel dans [1; 2[, le bit avant la virgule est toujours 1, et il est inutile de lecoder puisqu’on le connaît. Seuls les bits après la virgule sont codés. Et comme on ne dispose que de m bits pourreprésenter la mantisse, on tronque et on ne garde que les m premiers bits après la virgule. Ainsi, dans un codagede 64 bits, la mantisse du réel x = −1
3est codée avec 52 bits alternant 0 et 1 :
0101010101010101010101010101010101010101010101010101
La représentation complète de x sur 64 bits est finalement :
1011111111010101010101010101010101010101010101010101010101010101
Cette norme permet également de représenter les NaN (Not a Number) et les infinis en mettant tous les bits del’exposant à 1 (2047), mais distingués en mettant l’ensemble des 52 bits de la mantisse à 0 pour les infinis et aumoins un de ces 52 bits à 1 pour les NaN.
3 Quelles solutions alternatives ?a Première alternative
Une des solutions possibles est de travailler avec un algorithme qui arrête la boucle d’itérations lorsque les extre-mums de l’intervalle recherché ne changent pas. On peut écrire :
1 def approximation_racine_2_v2(a, b, precision) :2 cont = True3 while cont :4 c = a + precision5 d = b − precision6 if c*c < 2 :7 a = c8 if d*d > 2 :9 b = d
10 if a != c and b != d :11 cont = False12 return a, b
Exécutez cette fonction pour les valeurs suivantes des paramètres. Expliquez :34
>>> approximation_racine_2_v2(1.4, 1.5, 0.01)
puis
>>> approximation_racine_2_v2(1.4, 1.5, 0.001)
b Seconde alternative
Puisque l’approximation de 0.01 se fait avec une partie excédantaire, il est possible de modifier le test de la bouclewhile :
1 def approximation_racine_2_v3(a, b, precision) :2 while b > a+precision :3 c = a + precision4 d = b − precision5 if c*c < 2 :6 a = c7 if d*d > 2 :8 b = d9 return a, b
c Troisième alternative avec le package decimal
Le package decimal de Python permet de représenter les nombres décimaux d’une façon exacte à un certain nombrede décimaux près (au maximum 56 chiffres). Dans ce cas, chaque chiffre est représenté sur 4 bits. Ceci permet detravailler d’une façon plus précise mais utilise plus de mémoire et de temps pour exécuter les programmes.On notera la nécessaire conversion du résultat de type “decimal()” en nombre flottant avec float. Le mêmealgorithme peut être implémenté en utilisant le package decimal comme ceci :
1 from decimal import *2 getcontext().prec=10 #j u s q u e 56 c h i f f r e s34 def approximation_racine_2_v4(a, b, precision) :5 while Decimal(b)−Decimal(a) > Decimal(precision) :6 c = Decimal(a) + Decimal(precision)7 d = Decimal(b) − Decimal(precision)8 if Decimal(c*c) < 2 :9 a = Decimal(c)
10 if Decimal(d*d) > 2 :11 b = Decimal(d)12 return float(a),float(b)
35
Sujets à développer1 En lien avec le programme du collègeLe programme du cycle 4 permet de travailler sur l’algorithmique et la programmation sur des divers sujets. Voicicertains exemples de sujets à développer avec Scratch :
• Arithmétique (divisibilité, nombres premiers, etc.)• ÉTUDIÉ Programmes de calcul.• ÉTUDIÉ Calcul littéral.• ÉTUDIÉ Fréquence et probabilité.• ÉTUDIÉ Tracer des figures usuelles.• ÉTUDIÉ Fonctions.• Transformations de l’espace.• Figures géométriques artistiques.• Statistiques (moyenne, médiane, étendue).• Tâches complexes sur divers sujets (par exemple calcul de l’IMC).• Mise en scène avec des dialogues entre lutins.
2 En lien avec le programme du lycéeLe programme (voir [4]) du BO spécial n°1 du 22 Janvier 2019 donne des exemples d’algorithmes à développerpour plusieurs niveaux au lycée. Voici certains de ces sujets proposés à travailler avec Python :
• Déterminer par balayage un encadrement de√2 d’amplitude inférieure ou égale à 10−n (page 162).
• Déterminer si un entier naturel a est multiple d’un entier naturel b (page 163).• Pour des entiers a et b donnés, déterminer le plus grand multiple de a inférieur ou égal à b (page 163).• Déterminer si un entier naturel est premier (page 163).• Déterminer la première puissance d’un nombre positif donné supérieure ou inférieure à une valeur donnée
(page 164).• ÉTUDIÉ. Étudier l’alignement de trois points dans le plan (page 166).• ÉTUDIÉ. Déterminer une équation de droite passant par deux points donnés (page 166).• ÉTUDIÉ. Pour une fonction dont le tableau de variations est donné, algorithmes d’approximation numérique
d’un extremum (balayage, dichotomie) (page 168).• ÉTUDIÉ. Algorithme de calcul approché de longueur d’une portion de courbe représentative de fonction
(page 168).• Algorithme de calcul d’image pour des fonctions définies par morceaux (page 252).• Calculer une valeur approchée d’une solution d’une équation par balayage (page 253).• Pour des données réelles ou issues d’une simulation, lire et comprendre une fonction écrite en Python ren-
voyant la moyenne m, l’écart type s et la proportion d’éléments appartenant à [m–2s,m+ 2s] (page 256).• Lire et comprendre une fonction Python renvoyant le nombre ou la fréquence de succès dans un échantillon
de taille n pour une épreuve de Bernoulli de paramètre p (page 257).• Calculer un terme de rang donné d’une suite, une somme finie de termes (page 270).• Déterminer une liste de termes d’une suite et les représenter (page 270).• Déterminer le rang à partir duquel les termes d’une suite sont supérieurs ou inférieurs à un seuil donné, ou
aux termes de même rang d’une autre suite (page 270).• Calculer une valeur approchée d’une solution d’une équation par balayage (page 271).• À partir de deux listes représentant deux caractères d’individus, déterminer un sous- ensemble d’individus
répondant à un critère (filtre, utilisation des ET, OU, NON) (page 273).36
• Dresser le tableau croisé de deux variables catégorielles à partir du fichier des individus et calculer desfréquences conditionnelles ou marginales (page 273).• Simuler des échantillons de taille n d’une loi de Bernoulli à partir d’un générateur de nombres aléatoires
entre 0 et 1 (page 275).• Représenter par un histogramme ou par un nuage de points les fréquences observées des 1 dans N échantillons
de taille n d’une loi de Bernoulli (page 275).• Compter le nombre de valeurs situées dans un intervalle de la forme [p − ks; p + ks] pour k ∈ 1; 2; 3 (page
275).• Calcul de termes d’une suite, de sommes de termes, de seuil (page 468).• Calcul de factorielle (page 468).• Liste des premiers termes d’une suite : suites de Syracuse, suite de Fibonacci (page 468).• Écrire la liste des coefficients directeurs des sécantes pour un pas donné (page 470).• Méthode de Newton, en se limitant à des cas favorables (page 471).• Construction de l’exponentielle par la méthode d’Euler. Détermination d’une valeur approchée de e à l’aide
de la suite((
1 +1
n
)n)(page 471).
• Approximation de π par la méthode d’Archimède (page 472).• Méthode de Monte-Carlo : estimation de l’aire sous la parabole, estimation du nombre π (page 475).• Algorithme renvoyant l’espérance, la variance ou l‘écart type d’une variable aléatoire.• ÉTUDIÉ Fréquence d’apparition des lettres d’un texte donné, en français, en anglais (page 475).• Construire différents points d’une approximation de courbe intégrale par la méthode d’Euler (page 647, 780).
37
Bibliographie[1] Arnaud Bodin. Python Au Lycée. Exo7, 2018. =http ://exo7.emath.fr/cours/livre-python1.pdf.[2] Conseil supérieur des programmes. Projets d’ajustement et de clarification des programmes de quatre
enseignements pour la scolarité obligatoire (cycles 2, 3 et 4). Projet d’ajustement et de clarification desprogrammes de mathématiques des cycles 2, 3 et 4, 2018. https://www.education.gouv.fr/cid131635/projets-d-ajustement-et-de-clarification-des-programmes-de-quatre-enseignements-pour-la-scolarite-obligatoire.html.
[3] IREM de Lille. Scratch au Collège : Algorithme et programmation. Exo7, 2018. http://exo7.emath.fr/cours/livre-scratch.pdf.
[4] Éducation Nationale, Bulletin officiel spécial n°1 du 22 janvier 2019. Programme d’enseignement de mathé-matiques de la classe de seconde générale et technologique, janvier 2019. https://www.education.gouv.fr/pid285/bulletin_officiel.html?cid_bo=138131.
[5] Éducation Nationale, Bulletin officiel spécial n°11 du 26 novembre 2015 . Programmes d’enseignement du cycledes apprentissages fondamentaux (cycle 2), du cycle de consolidation (cycle 3) et du cycle des approfondisse-ments (cycle 4). Annexe 3 Programme d’enseignement du cycle des approfondissements (cycle 4), novembre2015. https://www.education.gouv.fr/pid285/bulletin_officiel.html?cid_bo=96710.
[6] Philippe Marquet, Anne Parrain, Éric Wegrzynowski et les collègues formateurs de l’Académie de Lille. Al-gorithmique et programmation au lycée - Python, janvier-avril 2019. http://fe.fil.univ-lille1.fr/apl/2018/, licence Creative Commons Attribution.
38
