Barbazo Cahier Dalgo Mathématiques Terminales Spécialité - Corrigés Ed 2020 [PDF]

Zitiervorschau

le

SPÉCIALITÉ PROGRAMME 2020 C O L L E C T I O N B A R B A Z O

CAHIER d’ALGO Algorithmique et programmation en Python Sous la direction d’Éric Barbazo Fanny Plassin Nathalie Teulié

Sommaire

Introduction

PARTIE 1

Démarrage

1

Variables, fonctions et instruction conditionnelle ......................................................

8

2

Boucles bornées et non bornées......................................................................................

10

3

Listes .........................................................................................................................................

12

PARTIE 2

Entraînement et TP

1

Fonctions de référence : logarithme et exponentielle...............................................

14

2

Dénombrement et permutation ........................................................................................

16

TP Algèbre Dénombrements...................................................................................................

18

Suites et limites .....................................................................................................................

20

TP Suites numériques Suites, limites et recherche de seuils .........................................

22

TP Suites numériques Approximation de ln(2).....................................................................

24

Méthode de la sécante et de Newton ..............................................................................

26

TP Logarithme Algorithme de Briggs ...................................................................................

28

TP Équation différentielle Méthode d’Euler ..........................................................................

30

Calcul approché d’intégrales (rectangles, trapèzes) .................................................

32

TP Probabilités Méthode de Monte Carlo ............................................................................

34

Planche de Galton et simulation d’une variable aléatoire binomiale...................

36

TP Probabilités Marche aléatoire ..........................................................................................

38

3

4

5

6

450 g éq. CO2 2 › Sommaire

4

Découvrir l’algorithmique et la programmation ...................

© Hachette Livre 2020, 58 rue Jean Bleuzen, CS 700007, 92178 Vanves Cedex. www.hachette-education.com ISBN 978-2-01-786623-7 Tous droits de traduction, de reproduction et d’adaptation réservés pour tous pays.

Sommaire

PARTIE 3 1

Vers l’épreuve du Bac

Exercice type 1 .......................................................................................................................

40

• Limite de suites • Boucle bornée

2

Exercice type 2 .......................................................................................................................

40

• Limite de suites • Boucle bornée

3

Exercice type 3 .......................................................................................................................

41

• Logarithme • Boucle non bornée • Langage naturel

4

Exercice type 4 .......................................................................................................................

41

• Limite de suites • Boucle bornée

5

Exercice type 5 .......................................................................................................................

42

• Algorithme de dichotomie • Boucles non bornée et bornée • Variables et affectation

6

Exercice type 6 .......................................................................................................................

43

• Limite de suites • Boucles bornée et non bornée

7

Exercice type 7 .......................................................................................................................

44

• Comparaison de suites • Boucle non bornée

8

Exercice type 8 .......................................................................................................................

45

• Méthode des rectangles • Intégration • Boucle bornée

9

Exercice type 9 .......................................................................................................................

46

• Limite de suites • Boucle bornée • Variables et affectation

10

Exercice type 10.....................................................................................................................

46

• Théorème des valeurs intermédiaires • Équation • Langage naturel

11

Exercice type 11.....................................................................................................................

47

• Intégration • Boucle bornée

12

Exercice type 12..................................................................................................................... • Factorielle • Permutation • Boucle bornée Les fichiers des scripts sont disponibles dans le manuel numérique et sur le site lycee.hachette-education.com/Barbazo/cahier-tle

Fabrication : Miren Zapirain Mise en pages & schémas : STDI Couverture : Guylaine Moi Maquette intérieure : Anne-Danielle Naname Édition : Alexandre Bertin

48

Introduction

Découvrir l’algorithmique et la programmation 1 Les notions de base en algorithmique et en programmation ▶ Un algorithme est un ensemble d’instructions qui s’enchainent les unes après les autres, dans un ordre logique et bien déterminé. ▶ Une instruction est une série d’actions contenant des mots clés et des connecteurs logiques. Les instructions font également intervenir des variables. ▶ Un algorithme peut s’écrire en langage naturel (structure logique écrite en français) ou en

langage informatique (structure logique écrite dans un langage spécifique que les ordinateurs peuvent interpréter). ▶ La programmation est la mise au point d’un programme (aussi appelé script) dans un langage informatique pouvant être compris et utilisé par un ordinateur. Il existe plusieurs langages de programmation  : Python, Scilab, C++, etc.

2 Les principales structures algorithmiques en langage naturel L’affectation de variable ▶ Pour

affecter une valeur à une variable, c’est-à-dire donner une valeur à une variable, on utilise, en langage naturel, la syntaxe variable ← valeur. Exemple : base ← 10 signifie que la variable base reçoit la valeur 10.

Les instructions conditionnelles aiguiller dans différentes directions l’exécution d’un algorithme, on peut avoir recours à des instructions conditionnelles qui permettent de déterminer si les instructions qui suivent doivent être, ou non, exécutées. ▶ Pour

La syntaxe d’une instruction conditionnelle en langage naturel Si condition alors instruction(s) 1 Sinon instruction(s) 2 Fin Si

Exemple : Si prix > 200 alors prix ← prix × 0,8 Sinon prix ← prix × 0,9 Fin Si

La boucle bornée doit répéter une ou plusieurs instructions un nombre défini de fois connu à l’avance, on utilise une boucle bornée. ▶ Lorsqu’on

La syntaxe d’une boucle bornée en langage naturel Pour variable allant de valeur minimale à valeur maximale instruction(s) Fin Pour

Exemple : Pour i allant de 3 à 100 somme = somme + i Fin Pour

La boucle non bornée ▶ Lorsqu’on doit répéter une ou plusieurs instructions un nombre inconnu de fois, on utilise une boucle non bornée qui est parcourue jusqu’à ce qu’une certaine condition ne soit plus vraie.

La syntaxe d’une boucle non bornée en langage naturel Tant que condition faire instruction(s) Fin Tant que

4 › Découvrir l’algorithmique et la programmation

Exemple : Tant que M > 0 faire M←M–1 Fin Tant que

Introductio

n

3 Le logiciel EduPython et le langage Python ▶ Python est un langage de programmation qui peut être utilisé dans plusieurs environnements : EduPython, Pyso, Spyder, etc.

▶ Dans ce cahier, l’environnement utilisé est celui d’EduPython, un logiciel gratuit et téléchargeable en ligne à l’adresse : https://edupython.tuxfamily.org/

L’interface du logiciel EduPython Bouton permettant d’exécuter le script

Éditeur : zone d’écriture des programmes et des fonctions

Console : zone où le programme s’exécute

▶ L’éditeur permet d’écrire des programmes. Après l’écriture d’un programme ou d’une fonction, on l’exécute avec l’icône . Après l’exécution d’un programme, on peut utiliser la console pour connaître le contenu des variables calculées. ▶ La console permet de dialoguer directement avec le programme à l’aide du clavier. L’utilisateur saisit des instructions dans la console, tape sur la touche entrée et le programme affiche une donnée à l’écran en réponse. La console est ainsi le lieu où s’affichent les données des programmes écrits dans l’éditeur.

Exemple : Programme saisi dans l’éditeur et exécuté

Instruction saisie dans la console et affichage

La console peut aussi être utilisée comme une puissante calculatrice. Exemple : calcul de 2450

Introduction ‹ 5

Introduction 4 Les principales structures algorithmiques en Python ▶ Un langage informatique utilise une syntaxe qui lui est propre. Certains mots utilisés en langage naturel se traduisent en langage informatique par des mots clés, uniquement employés par ce langage. ▶ Python est un langage dont la base linguistique est anglo-saxonne. Sa syntaxe est donc constituée de mots anglais.

L’instruction conditionnelle if ▶ Le mot français Si du langage naturel se traduit par le mot anglais if en langage Python. ▶ Le mot français Alors du langage naturel ne se traduit pas par un mot en anglais en langage Python,

mais par un retour à la ligne, appelé indentation. ▶ Le mot français Sinon du langage naturel se traduit par le mot anglais else en langage Python. ▶ Une instruction conditionnelle peut exécuter une, deux ou plusieurs instructions selon la situation étudiée.

•

L’instruction conditionnelle en langage Python ci-dessous n’a qu’une seule condition. Si la condition n’est pas réalisée, le script n’effectue pas l’instruction.

Exemple :

Le programme affecte à la variable y une valeur égale à quatre fois celle de la variable x lorsque cette variable x est inférieure ou égale à 3. Rien ne se produit si la variable x est strictement supérieure à 3.

•

L’instruction conditionnelle en langage Python ci-dessous a une condition et une alternative. Si la condition est réalisée, le script effectue l’instruction 1 ; si la condition n’est pas réalisée, il effectue l’instruction 2.

Exemple :

Le programme affecte à la variable y une valeur égale à quatre fois celle de la variable x lorsque cette variable x est inférieure ou égale à 3. Sinon, il affecte à y la valeur 3x + 6. Dans cette instruction conditionnelle, tous les cas sur x sont étudiés.

La boucle bornée for ▶ Le mot français Pour du langage naturel se traduit par le mot anglais for en langage Python. ▶ La fonction range() permet d’énumérer le nombre de passages dans la boucle.

La boucle non bornée while ▶ Le mot français Tant que en langage naturel se traduit par le mot anglais while en langage Python.

6 › Découvrir l’algorithmique et la programmation

Introductio

n

5 Les bibliothèques de Python ▶ Certaines fonctions spécifiques au langage Python sont rangées dans des bibliothèques. Pour pouvoir les utiliser, on peut importer entièrement la bibliothèque ou seulement la ou les fonction(s) souhaitée(s).

• L’étoile * permet d’importer toutes les fonctions d’une bibliothèque. Exemple : from math import* importe toutes les fonctions de la bibliothèque math.

• On peut importer d’une bibliothèque seulement les fonctions dont on a besoin. Exemple : from math import sqrt importe la fonction racine carrée de la bibliothèque math.

le nom de la bibliothèque est très long, on peut lui définir un alias en ajoutant as suivi de quelques lettres formant l’alias. On peut ensuite utiliser toutes les fonctions de la bibliothèque en faisant précéder leur nom de l’alias.

▶ Lorsque

Exemple : import matplotlib.pyplot as plt L’instruction plt.plot(x,y) permet d’importer la fonction plot de la bibliothèque matplotlib.pyplot en utilisant l’alias plt. Type de bibliothèque

Nom de la bibliothèque math

from math import*

random

from random import*

matplotlib.pyplot

import matplotlib.pyplot as plt

pylab numpy

import pylab as pb import numpy as np

Principales fonctions mathématiques Fonctions des probabilités Fonctions graphiques

Syntaxe d’importation

6 Les graphiques ▶ Le langage Python est un langage informatique qui permet de réaliser des calculs qui sont trop longs et compliqués à faire manuellement, mais c’est également un traceur de courbes. Les graphiques permettent en général de conjecturer des solutions d’équations ou d’inéquations, de déterminer des coordonnées de points ou de faire de la géométrie. ▶ Pour réaliser des graphiques avec le langage Python, il faut utiliser plusieurs bibliothèques : matplotlib.pyplot, ou pylab et numpy. ▶ Lorsqu’on exécute un script de tracé de graphique, l’affichage se réalise dans une fenêtre qui s’ouvre indépendamment de l’environnement EduPython. Il faut fermer cette fenêtre après l’avoir visualisée.

Introduction ‹ 7

papier & crayon

Démarrage

d é b ra

nché

1. Variables, fonctions et instruction conditionnelle MÉMO Quand on programme en Python, on utilise des variables, des fonctions et des instructions. Les variables peuvent être de types différents : numériques entières, numériques flottantes (rationnelles ou réelles), listes, chaînes de caractères ou booléennes. Ne pas oublier l’indentation, c’est-à-dire le décalage du texte vers la droite, qui indique le début et la fin des instructions conditionnelles, des boucles et des instructions de la fonction. Langage naturel

Python

Variable De type numérique

rayon ← 2

De type chaîne de caractères

jour ← "lundi"

De type booléen

resultat ← vrai

Instruction conditionnelle Si condition1 Faire …….. Sinon Si condition2 Faire …….. Sinon Faire ……… Fin Si Fonction informatique Chaque fonction possède un nom, renvoie un résultat et peut avoir aucun, un ou plusieurs arguments.

1 Un magasin propose des réductions à ses clients. Si un client vient strictement plus de 4 jours par semaine, il a 15 % de réduction sur ses achats. S’il vient entre 2 et 4 jours compris, il a 8 %. S’il vient seulement 1 jour, il n’a que 1 % et s’il ne vient pas du tout, il n’a pas de réduction. Compléter la fonction reduction, d’arguments le nombre de jours déclarés par le client pour une semaine et le montant total de ses achats cette même semaine et qui renvoie le montant payé par le client après la réduction associée ou l’expression « Client pas venu ». 1 def reduction(jours,total): 2 if 4> sol(0.0001,0.01)

2

x=sqrt(e)

(1.0102212707001985, 16.79632127067449)

3

if 0=0:

Pour f ( x ) = −2,3 , la solution est 0,5273.

>>> sol(0.0001,-2.3)

Entraînement ‹ 15

papier & crayon

Entraînement

déb r

anch

é

2. Dénombrement et permutation 1 On considère dans un repère orthonormé, les points M ( x ; y ) avec x et y entiers naturel tels que 0 ! x ! 8 et 0 ! y !10.

1. Combien y a-t-il de points M ( x ; y ) ? Pour tout entier x compris entre 0 et 8, il y a

3. Modifier la fonction précédente en une fonction points2, avec quatre arguments, pour qu’elle affiche la liste des points M ( x ; y ) avec xmin ! x ! xmax et ymin ! y ! ymax et également le nombre de points M ( x ; y ) affichés.

9 points M ( x ; 0) . Comme il y a 11 lignes de points, on a alors en tout 99 points. 2. Compléter la fonction suivante, nommée points, sans argument, pour qu’elle renvoie la liste de tous les points M ( x ; y ) avec x et y entiers naturel tels que 0 ! x ! 8 et 0 ! y !10. 1

def points():

2

L=[]

3

for i in range( 9 ):

4

for j in range(11)

5 6

:

L.append( [i,j] ) return L

2 Écrire une fonction nommée factorielle, qui renvoie n! pour un entier naturel n entré en argument de la fonction.

3 On considère les algorithmes suivants écrits en langage naturel.

N ← 20

2. Écrire un calcul direct de la valeur de la variable resultat renvoyée par cet algorithme. 20 ×19 ×18

resultat ← 20 Pour i allant de 1 à 3 resultat ← resultat × ( N − i )

1. Quelle est la valeur de la variable resultat lorsque cet algorithme a été utilisé ? La variable résultat contient la valeur 6 840.

3. Compléter la fonction Python suivante pour qu’elle renvoie la valeur N × ( N −1)…× ( N −10) pour un entier N !10 entré en argument. 1

resultat=N

3

for i in range( 1 , 11 ):

4 5

16 › Dénombrement et permutation

def produit(N):

2

resultat=resultat*(N-i) return resultat

ordinateur

4 Une association veut élire son bureau constitué d’un président, d’un trésorier et d’un secrétaire. Il y a sept candidats qui postulent pour le bureau. On nomme les candidats A, B, C , D, E et F . Un candidat ne peut postuler que sur un seul poste du bureau. Afin de choisir au hasard les trois personnes du bureau, on procède en utilisant la fonction Python ci-contre. 1. Expliquer ce que renvoie cette fonction. La fonction renvoie trois lettres choisies au hasard dans la liste des 7 lettres. 2. Écrire cette fonction dans un éditeur et la tester plusieurs fois. Expliquer pourquoi elle ne peut pas servir pour constituer un bureau. Lorsqu’on l’utilise plusieurs fois, on trouve que la même lettre est renvoyée parfois. Or, personne ne peu postuler sur plusieurs postes dans le bureau. Il faut donc que les lettres renvoyées soient toutes distinctes.

3. On a transformé la fonction précédente comme ci-contre. Expliquer les lignes 7, 8, 9 et 10. La ligne 7 définit un entier aléatoire entre 0 et le rang maximal de la liste. La ligne 8 ajoute l’élément de la liste L de rang x et l’ajoute à la liste bureau. La ligne 9 élimine l’élément précédent de la liste L. La ligne 10 diminue le rang qui permettra de choisir un élément dans la liste L diminuée.

5 La fonction Python chr renvoie la lettre correspondant au code ASCII donné selon le tableau suivant. Code ASCII

65

66

67

…

90

Lettre

A

B

C

…

Z

1. Que renvoie l’instruction chr(67) ? Elle renvoie la lettre C

pour les lettres. On a, pour chacun de ces choix, 102 choix possibles pour les deux chiffres. On a alors en tout 1 757 600 codes possibles.

b. Compléter la fonction code ci-contre pour qu’elle génère un code sous la forme d’une liste à envoyer par sms lors d’une demande de paiement en ligne.

2. Pour sécuriser un paiement par carte bleu en ligne, on doit recevoir par sms un code constitué de trois lettres de l’alphabet (pas nécessairement distinctes) et deux chiffres compris entre 0 et 9 pas nécessairement distincts.

1

from random import randint

2

def code():

3

i=randint(65,90)

4

j=randint(65,90)

a. Combien de codes peut-on générer avec cette méthode ?

5

k=randint(65,90)

6

l=randint(0,9)

On a 26 possibilités pour chaque lettre et on a trois

7

m=randint(0,9)

lettres possibles. Il y a donc 263 choix possibles

8

return [chr(i),chr(j),chr(k),l,m]

Entraînement ‹ 17

Travaux Algèbre

PARTIE

1 1

Objectifs

pratiques

• Retrouver les propriétés des différents dénombrements.

Dénombrements

Factorielle et combinaison On rappelle que, pour tout entier naturel n , n! = 1× 2 × …× n. a. Compléter la fonction suivante, nommée factorielle, d’argument un entier naturel, pour qu’elle renvoie la valeur de n!. b. Que valent 7! ? 13! ?

1

def factorielle(n):

2

resultat=1

3

for k in range( 1 , n+1 ):

4

resultat=resultat*k

5

return resultat

7! = 5040 et 13! = 6227020800

2

On considère la nouvelle fonction factorielle2 ci-dessous.

a. Que renvoie cette fonction avec n = 13 ? La fonction renvoie 6227020800 comme la fonction précédente. b. Justifier que l’instruction de la ligne 5 permet d’affirmer que la fonction affichera n!. La fonction factorielle2 s’appelle elle-même. Elle s’appellera elle-même jusqu’à ce que la valeur de n −1 soit égale à 0. Alors elle multipliera le dernier résultat par 1 et le programme s’arrêtera.

3

n Compléter la fonction suivante, afin qu’elle renvoie la valeur de ⎛ ⎞ pour tous entiers natu⎝ k⎠ rels k et n entrés en arguments. On utilisera l’une des fonctions factorielles des questions précédentes. 1

def factorielle(n):

2

resultat=1

3

for k in range(1,n+1):

4 5

resultat=resultat*k return resultat

6 7

def combinaison(k,n):

8

if k>n:

9

resultat=False

10 else: 11

resultat=factorielle(n)/(factorielle(k)*factorielle(n-k))

12 return resultat

18 › Dénombrements

PARTIE

2

Nombre de parties d’un ensemble à n éléments

1

On considère un ensemble Ω à n éléments. a. Combien y a-t-il de parties de Ω à k éléments, pour un entier naturel k compris entre 0 et n ? n Il y a ⎛ ⎞ parties à k éléments. ⎝ k⎠

2

Compléter la fonction nbre_parties suivante, d’argument un entier naturel n , pour qu’elle renvoie le nombre total de parties de Ω . On utilisera les fonctions factorielle et combinaison écrites plus haut. 1

def factorielle(n):

2

resultat=1

3

for k in range(1,n+1):

4 5

resultat=resultat*k return resultat

6 7

def combinaison(k,n):

8

if k>n:

9 10 11 12

resultat=False else: resultat=factorielle(n)/(factorielle(k)*factorielle(n-k)) return resultat

13 14 def nbre_parties(n): 15

N=0

16

for k in range(n+1) :

17 18

PARTIE

3

N= N+combinaison(k,n)

return N

Triangle de Pascal On considère la fonction suivante.

Recopier cette fonction dans un éditeur et la tester avec n = 3 et n = 5. Qu’obtient-on ?

On obtient le triangle de Pascal jusqu’à la ligne n . Travaux pratiques ‹ 19

papier & crayon

Entraînement

déb r

anch

é

3. Suites et limites 1 On considère la suite ( un ) définie par u0 = 0 et, pour tout entier naturel n, un+1 = un + 3n − 7.

1. Calculer u1, u2, u3 et u4 . u1 = −7, u2 = −11, u3 = −12, u4 = −10 . 2. Compléter la fonction rangsuite ci-dessous pour qu’elle affiche le terme de rang n. 1

def rangsuite(n):

2

u=0

3

for k in range ( n ):

4 5

Quel sera l’affichage lorsqu’on saisit dans la console Python ? [0, -7, -11, -12, -10] 4. On admet que lim un = +∞. Écrire une fonction n→+∞

seuil qui permet de déterminer le plus petit entier n tel que un >1000.

u = u + 3*k - 7 return u

3. On considère la fonction ci-après écrite dans l’éditeur Python.

2 On considère la suite ( un ) définie par u0 = 9, u1 = 5 et, 1 pour tout entier naturel n non nul, un+1 = (4un − un−1) 3 11 29 83 , u4 = . 1. Calculer u2 , u3 et u4 . u2 = , u3 = 3 9 27 2. Compléter la fonction suiteu ci-contre pour qu’elle affiche le terme de rang n.

1

def suiteu(n):

2

u0,u1=9,5

3

for k in range(2,n+2 ):

4 5

u0,u1=u1,1/3*(4*u1-u0) return u0

3. Que permettent de conjecturer les affichages donnés par les instructions ci-contre écrites dans la console Python ? On conjecture que la suite converge vers 3.

3 Soit ( un ) la suite géométrique de premier terme

u0 = 400 et de raison q = 0,6 . On pose,pour tout entier naturel n, S n = u0 + u1 + …+ un . 1. Quelle est la limite de la suite ( un ) ? lim un = 0

n→+∞

2. Compléter la fonction sommesuite suivante pour qu’elle affiche le terme de rang n de la suite ( S n ) . 1

def sommesuite(n):

2

u,S=400,400

3

for k in range(1,n+1):

4

u=u*0.6

5

S=S+u

6

return S

20 › Suites et limites

3. Quelle est la limite de la suite ( S n ) ? lim S n = 1000

n→+∞

4. Écrire une fonction seuilS qui retourne le rang n à partir duquel S n > 998 . Cette fonction pourra utiliser sommesuite.

ordinateur

4 1. Donner la définition de la suite ( un ) définie par la fonction ci-dessous.

5. On considère la suite ( v n ) définie pour tout entier naturel n par v n = un+1 − un . Écrire une fonction v qui prend pour paramètre n et qui affiche les n + 1 premiers termes de la suite ( vn ) .

u0 = 0 et un+1 = un + 2n + 2 2. Compléter et recopier la fonction plotu qui affiche la représentation graphique des n + 1 premiers termes la suite ( un ) .

6. Que peut-on conjecturer sur la nature de la suite ( vn ) ? Donner son expression explicite. On conjecture que la suite est arithmétique.

1

import matplotlib.pyplot as plt

v n = 2 + 2n

2

def plotu(n):

7. En déduire l’expression explicite de la suite ( S n )

3 4 5

for k in range( n+1 ): plt.plot( k , u(k) ,'r.') plt.show()

n

définie par S n = ∑v k . k=0

( n +1)(4 + 2n )

3. En utilisant la fonction plotu, conjecturer le sens de variation de la suite ( un ) .

= ( n +1)(2 + n ) 2 8. En déduire l’expression explicite de un et démontrer le résultat par récurrence.

On conjecture que la suite est croissante.

On obtient un = S n−1 = n ( n +1)

4. Sous quelle forme semble être l’expression explicite de un ?

Preuve par récurrence.

Sn =

Sous la forme d’un polynôme de degré 2.

5 On se place dans un repère orthonormé et, pour tout

entier naturel n, on définit les points ( An ) par leurs coordonnées ( x n ; yn ) de la façon suivante : ⎧ x = x n − yn x0 = 4 ⎪ n+1 2 2 . et, pour tout entier naturel n, ⎨ y0 = 0 x y ⎪ yn+1 = n + n ⎩ 2 2 1. Compléter la fonction ci-dessous afin de construire les points A0 à An

{

1

import matplotlib.pyplot as plt

2

def points(n):

3

x,y = 4,0

4

plt.plot(x,y,'r.')

5

for k in range( n+1 ):

6

x,y = x/2-y/2,x/2+y/2

7

plt.plot(x,y,'r.')

8

plt.show()

2. Montrer que pour tout entier naturel n, An An+1 = OAn+1. x 2 y2 2 2 An An+12 = ( x n+1 − x n ) + ( yn+1 − yn ) = n + n = OAn+12 2 2 3. Écrire une fonction longueurligne qui prend pour paramètre n et qui retourne la longueur ℓ n de la ligne brisée A0 A1… An .

4. Conjecturer alors la limite de ℓ n lorsque n tend vers +∞. On conjecture que la suite tend vers environ 9,66. Entraînement ‹ 21

pratiques

Travaux Suites numériques

Objectif • Utiliser des boucles bornées et non bornées

Suites, limites et recherche de seuils

L’objet du travail ci-dessous est d’étudier l’évolution du stockage des caddies présents en fin de journée dans un supermarché. Ce supermarché dispose sur son parking de trois points d’attache (les points A et B situés aux abords du supermarché et le point C situé au fond du parking). Pour modéliser les flux de caddies, on fait les hypothèses suivantes. • Le nombre total de caddies reste constant. • Chaque jour, le point A perd 12 % de ses caddies mais reçoit 12 % des caddies du point B et 2 % des caddies du point C. • Chaque jour, le point B perd 12 % de ses caddies mais reçoit 12 % des caddies du point A et 2 % des caddies du point C. • Chaque jour, le point C perd 4 % de ses caddies. La veille de l’ouverture du supermarché, il y avait 450 caddies au point A, 250 au point B et 300 au point C. On désigne par an , bn et cn les nombres de caddies respectifs présents dans les points A, B et C le soir à la fermeture du supermarché n jours après la veille de l’ouverture. On admettra, pour l’étude mathématique, que les réels an , bn et cn peuvent ne pas être entiers.

PARTIE

1 1

Modélisation Calculer le nombre de caddies présents le soir dans chaque point un jour et deux jours après la veille de l’ouverture. a1 = 432, b1 = 280 et c1 = 288

2

3

a2 = 419,52, b2 = 304 et c2 = 276,48

Compléter la fonction caddies qui affiche les représentations graphiques des trois suites ainsi que les nombres de caddies dans chaque point le soir, n jours après la veille de l’ouverture. 1

import matplotlib.pyplot as plt

2

def caddies(n):

3

a,b,c = 450,250,300

4

plt.plot(0,a,'r.')

5

plt.plot(0,b,'k.')

6

plt.plot(0,c,'b.')

7

for k in range(1,n+1):

8

a,b,c = 0.88*a+0.12*b+0.02*c , 0.12*a+0.88*b+0.02*c , 0.96*c

9

plt.plot(k,a,'r.')

10

plt.plot(k,b,'k.' )

11

plt.plot(k,c,'b.')

12

plt.show()

13

return a,b,c

Exécuter ce programme plusieurs fois pour différentes valeurs de n. a. Quelles conjectures peut-on faire sur le sens de variation et les limites des suites ? La suite ( an ) est croissante à partir d’un certain rang et converge vers 500. La suite ( bn ) est croissante et converge vers 500 et la suite ( cn ) est décroissante et converge vers 0. b. Quelles sont les valeurs affichées lorsqu’on saisit caddies(100) ?

22 › Suites, limites et recherche de seuils

PARTIE

2

Expressions explicites des suites ( an ) , ( bn ) et ( c n )

On appelle d n la différence du nombre de caddies entre les points A et B, n jours après la veille de l’ouverture.

1

Compléter la fonction python suitedn de paramètre n qui retourne les valeurs prises par d k pour k allant de 0 à n. On pourra faire afficher les termes de la suite arrondis à 10−2 . 1

def suitedn(n):

2

a,b,c = 450,250,300

3

d = [a - b ]

4

for k in range ( 1,n+1 ):

5

a,b,c = 0.88*a+0.12*b+0.02*c, 0.12*a+0.88*b+0.02*c, 0.96*c

6

d.append(round(a-b,2))

7

2

return d

On a modifié la fonction précédente afin de pouvoir conjecturer la nature de la suite ( d n ) . Voici l’affichage obtenu dans la console Python lorsqu’on donne à n la valeur 5.

Écrire ci-dessous cette fonction suitedn modifiée.

3

a. Donner les expressions explicites des suites ( cn ) et ( d n ) . cn = 300 × 0,96n et d n = 200 × 0,76n b. En déduire les expressions explicites des suites ( an ) et ( bn ) puis leurs limites respectives. an = 500 +100 × 0,76n −150 × 0,96n

PARTIE

3

bn = 500 −100 × 0,76n −150 × 0,96n

Un seuil

1

Écrire une nouvelle fonction nommée seuilcaddies de paramètre M qui retourne le nombre de jours nécessaires après la veille de l’ouverture du supermarché à partir desquels le nombre de caddies dans les points A et B dépassera M.

2

Au bout de combien de jours après la veille de l’ouverture du supermarché y aura-t-il plus de 490 caddies dans les points A et B ? Au bout de 67 jours. Travaux pratiques ‹ 23

Objectif

pratiques

Travaux

• Utiliser des boucles bornées et non bornées

Approximation de ln(2)

Suites numériques

L’objectif de ce TP est de donner une approximation de ln(2) par deux méthodes différentes.

PARTIE

1

Utilisation d’une suite

On considère la fonction suite ci-contre écrite dans l’éditeur Python où n est un entier naturel non nul.

1

Quelle est parmi les propositions suivantes, la somme que cet algorithme permet de calculer ? n

1 k k=1

a. ∑

n

b.

1 ∑n k=1

n

c.

1 ∑n+k k=1

n+1

d.

1

∑n+k k=1

Dans la suite de cette partie, on notera, pour n entier naturel non nul, un la somme précédente. 1 1 1 7 1 1 1 37 u1 = , u2 = + = et u3 = + + = . 2 3 4 12 4 5 6 60

2

Donner les valeurs exactes de u1, u2 et u3 .

3

Recopier la fonction suite dans l’éditeur Python. Quel est le résultat affiché lorsqu’on écrit dans la console Python ? a. suite(10) ?

b. suite(100) ?

c. suite(1000) ?

4

Comparer les résultats précédents à ln(2). ln(2) ≈ 0,693. Les résultats précédents sont d’autant plus proches de ln(2) que n est grand.

5

1 Dans cette question, on admet que pour tout réel x strictement positif, 1− ! ln( x ) ! x −1. x k +1 a. En appliquant cet encadrement à x = , avec k entier naturel non nul, montrer que k 1 1 ! ln( k +1) − ln( k ) ! . k +1 k k k +1⎞ k +1 1 1 ! ln⎛ ! −1, soit, ! ln( k +1) − ln( k ) ! . On a 1− ⎝ k ⎠ k +1 k k +1 k b. Additionner les inégalités de la question 4. a. pour k allant de n à 2n −1 et en déduire un encadrement de ln(2) . 1 1 1 On obtient un ! ln(2n ) − ln( n ) ! un + − , soit, un ! ln(2) ! un + . n 2n 2n 1 c. En déduire que 0 ! ln(2) − un ! et justifier alors lim un . 2n n→+∞ 1 En soustrayant un à l’encadrement précédent, on obtient 0 ! ln(2) − un ! . 2n En utilisant le théorème des gendarmes, on en déduit que lim un = ln(2) . n→+∞

6

a. Écrire ci-contre et dans l’éditeur Python, une fonction valeurapprochée qui prend pour paramètre un entier naturel non nul p et qui renvoie le rang n ainsi que la valeur de un telle que ln(2) − un !10− p .

24 › Approximation de ln(2)

b. Quelle est la valeur affichée lorsqu’on écrit dans la console Python valeurappochée(3) ? valeurapprochée(5) ?

PARTIE

2

Utilisation de l’algorithme de Brouncker William Brouncker est un linguiste et mathématicien anglais du XVIIe siècle. Il est l’un des premiers mathématiciens à travailler sur l’aire du domaine D délimité par l’hyperbole, l’axe des abscisses et les droites d’équations x = 1 et x = 2.

1

2

y=

Donner la valeur exacte de l’aire de ce domaine D. 21 A ( D) = ∫ dx = ln(2) 1x Il approche l’aire du domaine D par la somme des aires des rectangles comme 1 1,5 dessinés ci-contre. On définit pour tout entier naturel n non nul, la suite ( v n ) par : n 1 1 1 + …+ =∑ . vn = (2n −1)2n k=1 (2k −1)2k 1× 2

2

x

a. Calculer v1, v2 et v3 . 1 1 1 1 7 1 1 1 37 v1 = = , v2 = + = et v3 = + + = . 1× 2 2 1× 2 3 × 4 12 1× 2 3 × 4 5 × 6 60 b. Quelle remarque peut-on faire ? On obtient les mêmes valeurs que u1, u2 et u3 .

3

a. Compléter et recopier dans l’éditeur Python la fonction suite_Brouncker ci-contre de paramètre n entier naturel non nul afin qu’elle renvoie une valeur approchée de v n .

1

def suite_Brouncker(n):

2

v=0

3

for k in range( 1,n+1:

4 5

):

v=v+1/((2*k-1)*2*k): return v

b. Quels sont les résultats affichés lorsqu’on écrit dans la console Python suite_ Brouncker(10) ? suite_Brouncker(100) ? suite_Brouncker(1000) ?

4

a. Écrire ci-contre et dans l’éditeur Python une fonction valeurapprochée_Brouncker qui prend pour paramètre un entier naturel non nul p et qui renvoie tous les termes de la suite ( v n ) et le plus petit rang n tel que ln(2) − v n !10− p . Cette fonction utilisera une liste et la fonction suite_Brouncker précédente. b. Quel est le résultat affiché lorsqu’on saisit dans la console Python valeurapprochée_ Brouncker(1) ?

Travaux pratiques ‹ 25

papier & crayon

Entraînement

déb r

anch

é

4. Méthodes de la sécante et de Newton 1 Soit f la fonction définie par f ( x ) = x 2 −10.

On note 𝒞f sa courbe représentative dans un repère du plan. Dans l’éditeur de Python, on a écrit la fonction suivante :

1. Justifier rapidement que l’équation f ( x ) = 0 admet une unique solution ℓ sur l’intervalle [0; 4 ]. f est strictement croissante et continue sur [0; 4 ]. De plus, f (0) < 0 et f (0) > 0. On peut alors appliquer le TVI. 2. Soit A ( a ; f ( a )) avec a ∈[0; 4 ] tel que f ( a ) < 0 et B (4 ; f (4 )). Noter ci-dessous l’abscisse du point d’intersection de la droite ( AB ) et de l’axe des abscisses. Faire les recherches au brouillon. af (4 ) − 4 f ( a ) On obtient x = . f (4 ) − f ( a )

et de l’axe des abscisses avec An ( an ; f ( an )) . Compléter la fonction ci-dessous afin qu’elle retourne la valeur de an , n étant choisi par l’utilisateur. 1

def secante(n):

2

a=0

3

for i in range( n ):

4 5

a=(a*f(4)-4*f(a))/(f(4)-f(a)) return a

4. On admet que la suite ( an ) précédente converge vers ℓ. Écrire ci-dessous une fonction nommée erreur de paramètre p, entier naturel, et qui retourne la plus petite valeur de n telle que an − ℓ 1. Noter ci-dessous l’abscisse du point d’intersection de la tangente à la courbe 𝒞f en A avec l’axe des abscisses. Faire les recherches au brouillon. f (u ) On obtient x = u − 2 . 3u − 3

7

x→+∞

3. Algorithme de Newton On construit la suite de points An ( un ; f ( un )) tels que u0 = 1,1 et un+1 est l’abscisse du point 26 › Méthodes de la sécante et de Newton

return L

4. On admet que la suite ( un ) converge vers ℓ. Voici l’affichage obtenu lorsqu’on saisit dans la console Python newtonliste(6). Quelle conjecture peut-on faire ? On conjecture que ℓ ≈ 1,53

ordinateur

3 On considère la fonction f définie sur ]0; + ∞[ par f (x) + ln( x ) . On admet que l’équation f ( x ) = 0 admet une unique solution dans l’intervalle ]0;2] . = e− x

1. Écrire dans l’éditeur de Python une fonction f de paramètre x qui retourne l’image de x par f, puis, compléter ci-dessous la fonction qui permet d’obtenir la courbe de la fonction f sur l’intervalle ]0;2] .

1

import matplotlib.pyplot as plt

2

def graphef():

3

plt.axis([0,2,-1,1])

4

plt.grid()

5.

x=[ k*1/100 for k in range( 1,201 )]

6

y=[f(i) for i in x]

7

z=[ 0 for i in x]

8

plt.plot(x,y,'r',linewidth=2)

9

plt.plot(x,z,'k')

10

plt.show()

3. En s’inspirant de l’algorithme de la sécante précédent, écrire une fonction nommée secanteliste de paramètre n qui retourne les valeurs de b0 à bn , où b0 = 2 et bn+1 est l’abscisse du point d’intersection de la droite ( ABn ) et de l’axe des abscisses.

4. Écrire le dernier élément de la liste lorsqu’on saisit dans la console Python secanteliste(5). 5. Écrire une fonction nommée plusieursécantes de paramètre n entier naturel non nul qui permet d’afficher la courbe de f, les n sécantes ( ABn−1) et la valeur de bn . Cette fonction utilisera les trois fonctions précédentes.

2. Recopier et compléter la fonction ci-dessous qui permet de tracer la droite passant par les points A (0,2; f (0,2)) et B ( b ; f ( b )) . 1

def secante(b):

2

x=[0.2,b ]

3

y=[f(0.2) ,f(b) ]

4

plt.plot(x,y,'b--')

4 On considère la fonction f définie sur ℝ par f ( x ) = 2 − x 3 . On admet que l’équation f ( x ) = 0 admet une unique solution sur l’intervalle [ −1; 3].

6. Quel est le résultat affiché lorsqu’on saisit dans la console Python plusieursécantes(7) ?

2. En vous inspirant de l’algorithme de Newton précédent, écrire une fonction newtonliste de paramètres u et n qui retourne les valeurs de u0 à un , où u0 = u.

1. En s’inspirant de l’exercice précédent, écrire une fonction graphef qui affiche la courbe de f sur [ −1; 3].

3. Quel est le résultat affiché lorsqu’on saisit dans la console newtonliste(-0.5,3) ? newtonliste(-1,1) ?

Entraînement ‹ 27

Travaux

Objectif

pratiques

• Calculer des logarithmes

Algorithme de Briggs

Logarithme

Briggs a travaillé sur le logarithme de base 10 (log). Le principe de l’algorithme de Briggs est le suivant. 1 1 1 On prend x >1. On sait que ln( x ) = ln( x ) c’est-à-dire ln x 2 = ln( x ) . 2 2 1 1 1 On en déduit : ln x 4 = ln x = ln( x ) = ln( x ) . 2 4 1 1 n En itérant le procédé, on obtient ln x 2 = n ln( x ) . Pour n assez grand ce résultat est proche 2

( )

( )

(

)

( )

1

1

de 0, donc x 2n sera proche de 1. Comme x >1, on a x 2n = 1+ h , avec h proche de 0. ln(1+ h ) Comme lim = 1, on en déduit que lorsque h est proche de 0, on a ln(1+ h ) ≈ h , donc h h→0

( ) 1

ln x 2n ≈ h, d’où ln( x ) ≈ 2n h . Résultat qui constitue l’approximation de ln( x ) selon Briggs.

PARTIE

1

1

Utilisation d’une suite

On considère la suite ( un ) , définie par u0 = x et un+1 = un , où x >1. On montre par récurrence que, pour tout n , un >1. On en déduit que ( un ) est décroissante, et converge donc vers un réel l . On prouve ensuite que l = 1. Cas particulier : x = 2 a. Compléter la fonction suite(prec) ci-contre afin qu’elle renvoie le nombre d’itérations nécessaires pour que un −1< prec, ainsi que le terme un correspondant. b. En utilisant la fonction suite(prec), quelle instruction doit-on saisir dans la console pour que seul l’affichage de un se fasse ?

1

from math import sqrt

2

def suite(prec):

3

u=2

4

n=0

5

while u-1>=prec :

suite(prec)[0]

6

u=sqrt(u)

c. Quel résultat obtient-on si on utilise l’instruction suite(prec)[1] ?

7

n=n+1

On n’obtient que la valeur de n telle que un −1< prec.

8

return u,n

d. Implanter la fonction dans l’éditeur Python et compléter le tableau (arrondir à 10−9 près). 0,01

0,0001

10–8

10–9

suite(prec)[0 ]

1,000677131

1,000084616

1,000000005

1,000000001

suite(prec)[1]

10

13

27

30

prec

e. Compléter les égalités suivantes. = 0,6933818297000016 = 0,6933818297000016 En utilisant l’algorithme de Briggs, de quelle valeur obtient-on des valeurs approchées ?

( ) 1

On a, pour x = 2, ln 22n ≈ h, où n = suite(prec)[1] et 1 + h = suite(prec)[0], donc h = suite(prec)[0]-1. On a des approximations de ln(2).

2

Cas général Modifier la fonction précédente en créant une fonction suite(prec,x) afin qu’elle affiche le plus petit entier n ainsi que la valeur de un en ayant comme paramètre la précision souhaitée ainsi qu’une valeur de x , où x >1.

28 › Algorithme de Briggs

PARTIE

2 1 2

PARTIE

3

1

Algorithme de Briggs Compléter la fonction briggs ci-contre afin qu’elle renvoie une valeur approchée de ln( x ) avec la précision prec.

def briggs(x,prec):

2

n=suite(prec,x)[1]

3

h=suite(prec,x)[0]-1

4

return h*2**n

Dans le préambule on a choisi d’éliminer les réels x tels que x ∈ ]0;1] . Utiliser la fonction briggs afin de créer une fonction briggs_tout qui renvoie une valeur approchée de ln( x ) pour tout x de ]0; +∞[ .

Avec calculatrice Dans les années 1950, les premiers calculateurs « de poche » sont apparus. Afin d’optimiser des algorithmes pour que les calculs puissent se faire rapidement, Volder, ingénieur américain, créa le premier algorithme de CORDIC (COordinate Rotation Digital Computing) pour le logarithme, algorithme implanté dans les calculatrices et qui utilise les techniques de Briggs. Le principe de l’algorithme de CORDIC est le suivant. Soit x ∈  ]1;10[ . On suppose connu les valeurs de ln(10) et ln(1+10−i ) , où i est un entier compris entre 0 et 10. Grace à ces valeurs on peut calculer tous les autres logarithmes. n Pour tout entier i compris entre 0 et 10, on a lim (1+10−i ) = +∞ , on en déduit qu’il existe n→+∞

un entier naturel N tel que x (1+10−i ) !10 ! x (1+10−i ) . On peut démontrer que N !10. D’où ln(10) − ( N +1)ln(1+10−i ) ! ln( x ) ! ln(10) − Nln(1+10−i ) . N

1

N +1

L’algorithme de CORDIC, pour x ∈  ]1;10[ . L’appel de la variable y permet d’obtenir une valeur approchée de ln( x ) . a. Dans cet algorithme, combien de logarithmes sont utilisés ? Quels sont ces logarithmes ? ln(10) ;ln(1+100 ) = ln(2) ;ln(1,01) ;ln(1,01) ;… ; ln(1+10−10 ) ,

y ← ln(10) Pour i allant de 0 à 10 : z ←1+10−i Tant que xz !10: x ← xz y ← y − ln( z ) Fin Tant que Fin pour

soit 12 logarithmes. b. Implanter cet algorithme dans un éditeur Python sous forme d’une fonction cordic(x).

2

On souhaite utiliser l’algorithme de CORDIC pour calculer une valeur approchée de n’importe quelle valeur de x où x ∈ ]0; +∞[ . Pour pallier les valeurs de x telles que x >10, on propose la fonction reduc ci-contre. a. Sans écrire la fonction dans un éditeur Python, prévoir ce que va retourner l’appel dans la console de l’instruction (on pourra proposer un tableau d’états). x

103,24

10,324

k

1

2

1,0324 3

Résultats : 1,0324 , 2. b. Écrire la fonction reduc dans un éditeur Python et retrouver le résultat précédent. Travaux pratiques ‹ 29

Travaux

Objectifs

pratiques

Équation différentielle

• Approximation de la courbe représentative d’une solution d’une équation différentielle

Méthode d’Euler

Un circuit électrique comprend un générateur de force électromotrice E = 5 volts, un dipôle (R, C) (association d’un condensateur de capacité C = 1 farad et d’un conducteur ohmique R = 100 ohms) et un interrupteur. À tout instant t en secondes, on note q(t) la charge du condensateur en coulombs. 1 On admet que la charge q du condensateur est telle que : R q ′ ( t ) + q ( t ) = E avec q (0) = 0 C (on admet que cette équation différentielle admet une unique solution q définie sur [0; +∞[ ). Mettre cette équation sous la forme q ′ ( t ) = m q ( t ) + b où m et b sont des constantes à préciser. On obtient q ′ ( t ) = −0,01 q ( t ) + 0,05.

PARTIE

1

(*)

Méthode d’Euler Cette méthode nous permet d’obtenir une approximation de la courbe représentative de la fonction q. On va construire un nuage de points de coordonnées ( t n ; yn ) tels que les réels t n appartiennent à l’intervalle [0 ; 600] et yn proche de q ( t n ) .

1

Quelques rappels On considère la figure ci-contre dans laquelle C est la courbe représentative d’une fonction f dérivable sur [0; +∞[ et d est la tangente à C au point A d’abscisse a. a. Donner l’équation réduite de la droite d. y = f ′ ( a )( x − a ) + f ( a ) b. En déduire l’ordonnée du point N de la droite d d’abscisse a + h avec h non nul.

𝒞 d

M N

f(a)

A

L’ordonnée de N est f ( a ) + hf ′ ( a ) . 0

a

a+h

c. Donner l’ordonnée du point M. L’ordonnée de M est f ( a + h ). d. Que peut-on dire des deux valeurs précédentes lorsque h tend vers 0 ? Lorsque h tend vers 0, les deux valeurs précédentes sont très proches. e. En déduire une approximation de f ( a + h ) qui utilise f ( a ) , f ′ ( a ) et h. f ( a + h ) ≈ f ( a ) + hf ′ ( a )

2

Retour au problème a. Soit t un réel positif et h un réel strictement positif, en utilisant l’équation (*) et le résultat de la question 5, donner une approximation de q ( t + h ) qui utilise q ( t ) et h. On obtient q ( t + h ) ≈ q ( t ) + h (0,05 − 0,01q ( t )) . b. Compléter alors le tableau ci-dessous.

30 › Méthode d’Euler

n

tn

q(tn) ≈ yn

0

t0 = 0

q(t0) = q(0) = 0 = y0

1

t1 = t0 + h = h

q(t1) = q(t0 + h) ≈ y0 + h(0,05 − 0,01y0) = y1

2

t2 = t1 + h = 2h

q(t2) = q(t1 + h) ≈ y1 + h(0,05 − 0,01y1) = y2

PARTIE

2

Programmation de la méthode en Python

1

Écrire ci-dessous une fonction nommée Euler_ liste qui prend pour paramètre h et qui renvoie dans une liste les termes de la suite ( yn ) pour n 600 ⎞ allant de 0 à N où N = E ⎛ . ⎝ h ⎠

2

Écrire ci-dessous le dernier élément de la liste lorsqu’on saisit dans la console Python euler_ liste(10). La dernière valeur est 4.991014948500428.

3

On souhaite afficher une approximation de la courbe de la fonction q sur l’intervalle [0 ; 600]. Compléter la fonction graphe_q ci-dessous. Cette fonction utilisera la fonction euler_liste précédente. 1

4

def graphe_q(h):

2

N=floor( 600/h )

3

x=[k*h

for k in range( N+1 )]

4

y=euler_liste(h)

5

plt.plot(x,y)

6

plt.show()

Saisir dans la console Python graphe_q(5). Quelle conjecture peut-on faire sur la limite de la fonction q lorsque t tend vers +∞ ? On conjecture que lim q ( t ) = 5. t→+∞

PARTIE

3

La constante de temps La tension maximale du condensateur est Q = EC. Le temps nécessaire pour atteindre 63 % de la tension maximale du condensateur est appelé la constante de temps, notée τ .

1

Écrire ci-dessous une fonction nommée constante_temps de paramètre h qui retourne une approximation de cette constante de temps τ . Cette fonction utilisera la fonction euler_liste précédente.

2

Quelles sont les valeurs retournées lorsqu’on saisit dans la console Python constante_ temps(5) ? constante_temps(1) ? Pour constante_temps(5), il s’affiche 100 et pour constante_temps(1), il s’affiche 99.

3

On sait que la formule permettant de calculer cette constante de temps est τ = RC . Les résultats obtenus à la question 2 sont-ils cohérents avec cette formule ? Oui, car τ = RC = 100. Travaux pratiques ‹ 31

papier & crayon

Entraînement

déb r

anch

é

5. Calcul approché d’intégrales (rectangles, trapèzes) 1 Soit la fonction f définie sur [ −1;1] par f ( x ) = e− x . On note 𝒞 sa courbe représentative dans un repère du plan. On note 𝒟 le domaine délimité par la courbe 𝒞, l’axe des abscisses et les droites d’équations x = −1 et x = 1. On partage l’intervalle [ −1;1] en n 2 intervalles de même amplitude n et on construit sur chacun de ces intervalles deux rectangles comme sur la figure ci-contre.

F D

E C

1

def rectangle_sup(n):

2

aire=0

3

for k in range( n ):

4 5

A

B a

a+

1. Compléter la phrase ci-dessous. 2 Sur l’intervalle ⎡⎢ a ; a + ⎤⎥ , l’aire « sous la courbe de n⎦ ⎣ f » est comprise entre les aire des rectangles ABCD 2 2 et ABEF . Ces rectangles ont pour aires f ⎛ a + ⎞ ⎝ n n⎠ 2 et f ( a ) . n 2. On a écrit dans l’éditeur Python la fonction f ci-dessous.

aire=aire+2/n*f(-1+k*2/n) return aire

3. Voici l’affichage obtenu lorsqu’on écrit dans la console Python rectangle_sup(1000). Quelle conjecture peut-on faire ? L’aire du domaine 𝒟 est d’environ 2,35 unité d’aire. 4. a. Donner ci-dessous la valeur exacte de l’aire du domaine 𝒟. A ( D) = e1 − e −1 b. Écrire ci-dessous une fonction erreur de paramètre p qui retourne le nombre minimal n de rectangle à construire afin que la différence entre la somme des aires des n rectangles et l’aire exacte du domaine 𝒟 soit strictement inférieure à 10− p .

Compléter la fonction rectangle_sup ci-contre de paramètre n le nombre de rectangles construits sur l’intervalle [ −1;1] et qui retourne une valeur approchée par excès de l’aire du domaine 𝒟.

2 1. On écrit dans l’éditeur Python la fonction ci-dessous.

Écrire ci-dessous une fonction trapèze de paramètres n et a qui retourne la somme des aires de ces n trapèzes.

Quelle est l’expression de la fonction ainsi définie ? 2

1 − x2 e 2π 2. On note 𝒞 sa courbe représentative sur l’intervalle [ −a ; a ], où a est un entier naturel non nul. On note Da le domaine délimité par la courbe 𝒞, D C l’axe des abscisses et les droites d’équations x = −a et x = a. On partage l’intervalle [ −a ; a ] en n intervalles de même amplitude et on construit sur chacun de ces intervalles un trapèze comme sur la figure ci-contre. A B f (x) =

32 › Calcul approché d’intégrales (rectangles, trapèzes)

3. Voici l’affichage obtenu dans la console Python. Que peut-on conjecturer ? On conjecture que l’aire sous la courbe de f sur ℝ vaut 1.

ordinateur

3 1. Recopier dans l’éditeur Python, la fonction f de paramètre x de l’exercice 2 de la page précédente. Recopier et compléter la fonction graphe_f de paramètre a entier naturel non nul qui permet d’afficher la courbe de f sur l’intervalle [ −a ; a ]. 1

import matplotlib.pyplot as plt

2

def graphe_f(a):

3

plt.axis([-a,a,0,0.5])

4

x=[-a+k/1000 for k in range(2000*a )]

5

y=[f(i) for i in x ]

6

plt.plot(x,y,'k',linewidth=3)

7

plt.show()

2. Recopier et compléter la fonction un_trapèze de paramètres a et b qui permet de tracer comme sur la figure ci-contre le trapèze ABCD, où A et B ont pour abscisses respectives a et b et C et D sont sur la courbe de la fonction f.

D C

A

1 2

3. Écrire ci-contre 0,5 une fonction nommée graphe_tra- 0,4 pèze de paramètres 0,3 n et a qui permet d’afficher comme 0,2 sur la figure 0,1 ci-contre la courbe 0 –3 –2 –1 0 1 2 3 de la fonction f sur l’intervalle [ −a ; a ], les n trapèzes de même hauteur sur [ −a ; a ] et renvoie la somme des aires de ces n trapèzes. Cette fonction utilisera les fonctions graphe_f et un_trapèze précédentes.

B

4. Quel est l’affichage obtenu lorsqu’on saisit dans la console Python graphe_trapèze(8,3) ?

def un_trapèze(a,b): plt.plot([ a , a , b , b ],[ 0, f(a) , f(b) , 0],'r')

4 1. Recopier dans l’éditeur Python la fonction f de

paramètre x de l’exercice 1 de la page précédente puis recopier et compléter la fonction graphe_f qui permet d’afficher la courbe de la fonction f sur l’intervalle [ −1;1]. 1 2 3 4 5 6 7

import matplotlib.pyplot as plt def graphe_f(): plt.axis([-1,1,0,3]) x=[-1+k/1000 for k in range(2001 )] y=[f(i) for i in x ] plt.plot(x,y,'k',linewidth=3) plt.show()

2. Écrire ci-après une fonction nommée un_rectangle_inf de paramètres a et b et qui permettent de tracer (sans afficher) comme sur la figure ci-contre le rectangle ABCD, où A et B ont pour abscisses respectives a et b et les points C est sur la courbe de la fonction f.

3. Écrire ci-dessous une fonction nommée graphe_ rectangle de paramètre n qui permet d’afficher comme sur la figure ci-dessous la courbe de la fonction f, les n rectangles « inférieurs » sur l’intervalle [ −1;1] et renvoie une valeur approchée de l’aire du domaine délimité par la courbe de f, l’axe des abscisses et les droites d’équation x = −1 et x = 1. Cette fonction utilisera les fonctions précédentes.

C

D

A

B a

b

Entraînement ‹ 33

Travaux Probabilités

PARTIE

1

pratiques

Objectif • Approximer Pi et le volume d’une boucle

Méthode de Monte Carlo

Méthode de Monte Carlo dans le plan On considère une cible carrée de centre O comme dessinée sur la figure ci-contre. À l’intérieur est tracé un disque de centre O et de rayon 1.

1

2

3

PARTIE

2 1

1

On lance au hasard sur cette cible une fléchette. Quelle est la probabilité p que cette fléchette « tombe » dans le disque ? aire du disque π –1 O p= = aire du carré 4 On lance au hasard sur cette cible N fléchettes, où N est un entier naturel non nul. On note d le nombre de fléchettes obtenues dans le disque parmi les N fléchettes lancées. En –1 supposant N « grand », donner une approximation de p en fonction de N et d. d p≈ N Déduire des deux questions précédentes une approximation de π en fonction de d et N. π d d ≈ ⇔ π ≈4× 4 N N

1

Simulation de l’expérience avec Python On écrit dans la console Python les deux lignes ci-contre. Quelles sont les valeurs prises par les variables x et y ? x et y prennent des valeurs réelles aléatoires comprises entre −1 et 1. Que permet de simuler la deuxième ligne ? Elle simule le lancer au hasard d’une fléchette dans la cible carrée ci-dessus.

2

a. Après avoir importé le module random de la bibliothèque random, écrire dans l’éditeur Python une fonction nommée monte_carlo de paramètre N, nombre de fléchettes lancées dans la cible carrée ci-dessus, et qui retourne une approximation de pi.

b. Donner une valeur affichée lorsqu’on écrit dans la console Python monte_ carlo(5000000) ? Une valeur affichée possible est 3.1416776. 34 › Méthode de Monte Carlo

3

On souhaite visualiser la cible carrée dessinée dans la partie 1. Pour cela, on écrit dans l’éditeur Python la fonction cicontre. Expliquer le rôle des trois dernières lignes du programme. La première des trois dernières lignes permet de tracer le carré dont les sommets ont pour coordonnées ( −1; −1) , (1; −1) , (1;1) et ( −1;1) . La deuxième des trois dernières lignes permet de tracer le demi-cercle « supérieur » de centre O et de rayon 1. La dernière ligne permet de tracer le demi-cercle « inférieur » de centre O et de rayon 1.

4

a. Recopier la fonction 1 def graphe_monte_carlo(N): cible dans l’éditeur Py2 cible() thon. En s’inspirant de 3 d=0 la fonction monte_carlo 4 for k in range(N): précédente, compléter la 5 x,y=random()*2-1 ,random()*2-1 fonction graphe_monte_ 6 if : x**2+y**2 0,1 a+b m← 2 p ← f (a) × f (m) Si p > 0 alors a←m Sinon b←m

Compléter la troisième ligne du tableau ci-dessous correspondant au deuxième passage dans la boucle. m

Signe de p

Initialisation

a−b

b − a > 0,1

−4

−2

2

VRAI

−3

Négatif

−4

−3

1

VRAI

passage dans la boucle

− 3,5

Positif

− 3,5

−3

0,5

VRAI

Après le

2e

2. Compléter les fonctions Python f et algo suivantes dans un éditeur Python, pour qu’elles renvoient les valeurs finales de a et b calculées par l’algorithme précédent. 1

from math import exp

2

def f(x): return 1+(-4*x**2-10*x+8)*exp(-0.5*x)

4 5

b

passage dans la boucle

Après le

1er

3

a

3. En utilisant les fonctions précédentes, montrer que les valeurs de a et de b obtenues sont a = −3,1875 et b = −3,125 .

4. Interpréter le résultat. Cet algorithme est un algorithme de dichotomie. Il permet d’obtenir un encadrement de la solution α

def algo():

6

a=-4

de l’équation f ( x ) = 0 dans l’intervalle [ −4 ; −2].

7

b=-2

On peut donc affirmer que −3,1875 < α < −3,125.

8

while b-a>0.1 :

9

m=(a+b)/2

10

p=f(a)*f(m)

11

if p>0 :

12

a=m

13 14 15

else: b=m return , a ,b

42 › Vers l’épreuve du Bac

6 Exercice type 6

• Limite de suites

Un infographiste simule sur ordinateur la croissance d’un bambou. Il • Boucles bornée et non bornée prend pour modèle un bambou d’une taille initiale de 1 m dont la taille augmente d’un mois sur l’autre de 5 % auxquels s’ajoutent 20 cm. Pour tout entier naturel n ,non nul, on note un la taille, exprimée en centimètre, qu’aurait le bambou à la fin du n-ième mois, et u0 = 100. 1. Calculer u1 et u2 . Le coefficient multiplicateur associé à une augmentation de 5 % est 1,05 .

On a donc u1 = 1,05 × u0 + 20 = 125 et u2 = 1,05 × u1 + 20 = 151,25. 2. On admet que, pour tout entier naturel n , un+1 = 1,05un + 20. Écrire une fonction en Python, nommée taille, d’argument n, qui renvoie la taille du bambou au bout du n-ième mois.

3. En utilisant la fonction précédente, calculer la taille du bambou à la fin du 7e mois.

Le bambou mesurera environ 3,03 mètres. 4. On considère la fonction taille2 ci-dessous, écrite en Python.

Quelle valeur renvoie cet algorithme lorsqu’on l’utilise ? Interpréter le résultat dans le contexte de l’exercice. L’algorithme renvoie la valeur 4. La taille du bambou dépassera 2 mètres au bout de 4 mois. 5. Modifier la fonction précédente pour qu’elle détermine le nombre de mois qu’il faudrait à un bambou de 50 cm pour atteindre ou dépasser10 m. Combien trouve-t-on ?

On trouve 24 mois. Vers l’épreuve du Bac ‹ 43

du Bac e v u e r p é l’ s r e V 7 Exercice type 7

• Comparaison de suites

L’énergie houlomotrice est obtenue par exploitation de la force des • Boucle non bornée vagues. Il existe différents dispositifs pour produire de l’électricité à partir de cette énergie. Les installations houlomotrices doivent être capables de résister à des conditions extrêmes, ce qui explique que le coût actuel de production d’électricité par énergie houlomotrice est élevé. On estime qu’en 2019, le coût de production d’un kilowattheure (kWh) par énergie houlomotrice était de 24 centimes d’euro. C’est nettement plus que le coût de production d’un kilowattheure par énergie nucléaire, qui était de 6 centimes d’euro en 2018. On admet qu’à partir de 2018 les progrès technologiques permettront une baisse de 5 % par an du coût de production d’un kilowattheure par énergie houlomotrice. Pour tout entier naturel n , on note cn le coût de production, en centime d’euro, d’un kilowattheure d’électricité produite par énergie houlomotrice pour l’année 2019 + n. Ainsi, c0 = 24. 1. Calculer c1. Baisser de 5 % revient à multiplier par 0,95. On a donc c1 = 0,95c0 = 22,8. 2. Dans cette question, on admet que le coût de production d’un kilowattheure par énergie nucléaire reste constant et égal à 6 centimes d’euro. a. Écrire une fonction Python, nommé cout, sans argument, qui détermine l’année à partir de laquelle le coût d’un kilowattheure produit par énergie houlomotrice deviendra strictement inférieur au coût d’un kilowattheure produit par énergie nucléaire.

b. Quelle année trouve-t-on ?

3. Dans cette question, on admet que le coût de production d’un kilowattheure par énergie nucléaire augmente chaque année d’un centime. Compléter la fonction cout2 suivante pour qu’elle renvoie l’année à partir de laquelle le coût d’un kilowattheure produit par énergie houlomotrice deviendra strictement inférieur au coût d’un kilowattheure produit par énergie nucléaire. 1

def cout2():

2

c=24

3

D=6

4

n=0

5

while c>=D :

6

c=0.95*c

7

D=D+1

8

n=n+1

9

return 2019+n

4. Quelle année trouve-t-on ? On trouve l’année 2029. On trouve, en utilisant la fonction, l’année 2047.

44 › Vers l’épreuve du Bac

8 Exercice type 8

• Méthode des rectangles • Intégration • Boucle bornée

On considère la fonction f définie sur [1; 3] par : f ( x ) = xln( x ) . On a construit sa courbe représentative ci-dessous. 3,5 3 2,5 2 1,5 1 0,5 0

0

0,5

1

1,5

2

2,5

On construit la suite de nombre réels ( ai ) de la manière suivante. On partage l’intervalle [1; 3] en n parties égales. a0 = 1. 2 ai = a0 + × i pour tout entier naturel i compris entre 1 et n −1. n 2 On construit n rectangles de largeur et de hauteur f ( ai ) pour i = 0;…, n −1. n On pose : S n = a0 f ( a0 ) + a1 f ( a1) + …+ an−1 f ( an−1) . 1. Que représente S n ?

3

S n représente la somme des aires des n rectangles. 2. Écrire une fonction Python, nommée f qui renvoie la valeur de f ( x ) pour un réel x de l’intervalle [1; 3] .

3. Compléter la fonction nommée S suivante, d’argument n, qui renvoie la valeur de S n . 5

def S(n):

6

a=1

7

S=0

8

for i in range( 1 , n ):

9

a=1+i*2/n

10

S=S+2/n*f(a)

11

return S 3

4. En utilisant la fonction précédente, déterminer une valeur approchée de ∫ xln( x ) dx en utilisant 100 rectangles. 1

L’intégrale est environ égale à 2,91 au centième près.

Vers l’épreuve du Bac ‹ 45

du Bac e v u e r p é l’ s r e V 9 Exercice type 9

• Limite de suites

On considère la suite ( un ) définie par u0 = 1 et, pour tout entier naturel n , • Boucle bornée par : • Variables et affectation 1 un+1 = un + n − 2. 3 1. Compléter la fonction suivante pour qu’elle renvoie la valeur de un pour un entier naturel n entré en argument. 1

def suite(n):

2

u=1

3

for i in range( 1 , n+1 ):

4 5

u=u/3+i-3 return u

2. Conjecturer la limite de la suite ( un ) lorsque n tend vers +∞. On conjecture que un tend vers +∞.

10 Exercice type 10

• Théorème des valeurs intermédiaires

Dans une usine, on se propose de tester un prototype de hotte • Équation aspirante pour un local industriel. Avant de lancer la fabrication en • Langage naturel série, on réalise l’expérience suivante : dans un local clos équipé du prototype de hotte aspirante, on diffuse du dioxyde de carbone (CO2) à débit constant. Dans ce qui suit, t est le temps exprimé en minute. À l’instant t = 0, la hotte est mise en marche et on la laisse fonctionner pendant 20 minutes. Les mesures réalisées permettent de modéliser le taux (en pourcentage) de CO2 contenu dans le local au bout de t minutes de fonctionnement de la hotte par l’expression f ( t ) , où f est la fonction définie pour tout réel t de l’intervalle [0 ; 20] par : f ( t ) = (0,8t + 0,2)e −0,5t + 0,03. On admet que les variations de la fonction f sont les suivantes. t

0

f ′ (t ) f

1,75 +

0

20 −

0,23

1. Calculer une valeur approchée de f (1,75) et de f (20) .

a. Quelle est la valeur de la variable t à la fin de cet algorithme ?

f (1,75) ≈ 0,697 et f (20) ≈ 0,031

Par approximations successives, on trouve

2. On admet qu’il existe un unique temps T dans l’intervalle [1,75;20] à partir duquel le taux de CO2 devient inférieur ou égal à 3,5 %. On considère l’algorithme suivant :

f (15,65) ≈ 0,0351 et f (15,75) ≈ 0,0349 ;

t ←1,75 p ← 0,1 Tant que V > 0,035 t ←t+ p V ← (0,8t + 0,2)e −0,5t + 0,03

la valeur de t à la fin de l’algorithme est donc 15,75. b. Interpréter cette variable t dans le contexte de l’exercice. 15,75 est une valeur approchée du temps en minutes à partir duquel le taux de CO2 sera inférieur à 3,5 %. Ce temps est donc environ de 15 minutes et 45 secondes.

46 › Vers l’épreuve du Bac

11 Exercice type 11

On considère la fonction f définie pour tout réel x appartenant à l’intervalle [ −2,5;2,5] par : f ( x ) = ln( −2x 2 +13,5) . 2,5 On note I = ∫ f ( x ) dx .

• Intégration • Boucle bornée

0

1. On considère l’algorithme suivant : S ←0 Pour k variant de 1 à n faire : 2,5 2,5 × f ⎛⎜ × k ⎞⎟ R← ⎝ n ⎠ n S←S+R

Utiliser cet algorithme pour compléter les lignes du tableau suivant. On arrondira les résultats à 10−6 près. Initialisation

S = 0, n = 50

Boucle Pour

Étape k

R

S

1

0,130 116

0,130 116

2

0,130 060

0,260 176

3

0,129 968

0,390 144

4

0,129 837

0,519 981

2. Compléter les fonctions Python ci-dessous, nommées f d’argument x et Int d’argument n, pour qu’elles renvoient le résultat de l’algorithme précédent. 1

from math import log

2

def f(x):

3

return log(-2*x**2+13.5)

4 5

def Int(n):

6

S=0

7

for k in range( 1 , n+1) :

8

R=2.5/n*f(2.5/n*k)

9

S=S+R

10

return S

3. En utilisant ces fonctions, calculer la valeur de la variable S lorsque n = 50. Interpréter le résultat. On trouve La variable S est une valeur approchée par défaut de la valeur de I .

Vers l’épreuve du Bac ‹ 47

du Bac e v u e r p é l’ s r e V 12 Exercice type 12

Un groupe d’amis constitué de trois filles et quatre garçons veut se faire photographier par un photographe professionnel. Le photographe propose plusieurs types de photographies. Il dispose pour cela les membres du groupe assis côte à côte sur un banc.

• Factorielle • Permutation • Boucle bornée

1. Pour le premier type de photo, toutes les filles veulent rester ensemble côte à côte et tous les garçons aussi. Combien de photos différentes peut prendre le photographe ? Il y a 7 places sur le banc. Les filles veulent rester ensemble côte à côte et les garçons aussi. Il n’y a que 2 façons de répartir le groupe des filles côte à côte sur le banc : FFFGGGG ou GGGGFFF. Pour chacune de ces positions, il y a 3! permutations possibles pour les filles et 4 ! permutations possibles pour les garçons. Par le principe multiplicatif, il y a donc 2 × 3!× 4 ! = 288 photos différentes possibles. 2. Pour le deuxième type de photo, seules toutes les filles veulent rester ensemble côte à côte. Combien de photos différentes peut prendre le photographe ? Les filles veulent rester ensemble mais le groupe des filles peut s’intercaler entre deux garçons. Il y a donc 5 façons de répartir le groupe des filles côte à côte sur le banc : FFFGGGG ou GFFFGGG ou GGFFFGG ou GGGFFFG ou GGGGFFF . Pour chacune de ces positions, il y a 3! permutations possibles des filles. Et 4 ! permutations possibles des garçons. Par le principe multiplicatif, il y a donc 5 × 3!× 4! = 720 photos différentes possibles. 3. Pour le troisième type de photo, tout le monde peut se placer comme il souhaite sur le banc. Combien de photos différentes peut prendre le photographe ? Tout le monde peut s’installer où il veut sur le banc. Il y a donc 7 choix possibles pour la première personne, puis 6 choix possibles pour la deuxième personne, 5 choix pour la troisième personne, 4 choix pour la quatrième personne, 3 choix pour la cinquième personne, 2 choix pour la sixième personne et plus qu’un choix pour la septième personne. Il y a donc 7! = 5 040 photos différentes possibles. 4. Compléter la fonction nommée factorielle suivante, d’argument n, afin qu’elle renvoie le nombre n ! 1

def factorielle(n):

2

f=1

3

for i in range( 1 , n+1):

4

f=f*i

5

return f

48 › Vers l’épreuve du Bac

5. Retrouver, en utilisant cette fonction, les résultats des questions 1, 2 et 3.

Cahier d’algorithmique et de programmation

MÉMENTO DE POCHE COLLECTION BARBAZO Le principe de l’algorithmique porte a

mois b

x

if elif else

porte = ouverte + for //

Variable(s) Sorte de boîte pouvant contenir une valeur qui peut varier.

b = 14/5

% while

Instruction(s) Opération(s) Condition(s)

a = 0.55555

Résultat(s) Valeurs des différentes variables mises en jeu dans l’algorithme.

Edupython Lancer un programme

Arrêter une boucle infinie

Éditeur : lieu où les programmes sont écrits

Console : lieu où les programmes sont utilisés

‹1

Le langage naturel On peut écrire de l’algorithmique sans passer par un langage informatique, c’est ce qu’on appelle le langage naturel. Il sert à exprimer les programmes en français, avec peu de syntaxe spécifique, afin de pouvoir les écrire en langage informatique plus efficacement.

Affectation des variables a ← 7 affecte le nombre 7 à la variable a

Instructions conditionnelles Une seule condition

Si condition alors Instructions Fin Si

Deux conditions

Si condition alors Instructions 1 Sinon Instructions 2 Fin Si

Plusieurs conditions

Si condition alors Instructions 1 Sinon Instructions 2 … Sinon Instructions finales Fin Si

Boucle bornée Pour Pour i allant de valeur_min à valeur_max faire Instructions Fin Pour

Boucle non bornée Tant que Tant que condition faire Instructions Fin Tant que

‹2

Les bibliothèques de Python Syntaxe générale Depuis la bibliotheque on appelle la fonction.

Les fonctions les plus courantes Bibliothèque

Fonction *

math

sqrt pi sin, cos, tan

*

random

Explications Importe toutes les fonctions de la bibliothèque math qui contient toutes les fonctions mathématiques utilisées au lycée. Importe la fonction racine carrée. Importe la valeur de pi. Importe les trois fonctions trigonométriques principales. Importe toutes les fonctions de la bibliothèque random qui contient toutes les fonctions relatives aux statistiques et aux probabilités.

randint

Importe la fonction qui renvoie aléatoirement un nombre entier.

random

Importe la fonction qui renvoie aléatoirement un nombre décimal compris entre 0 et 1 exclus.

Définition générale d’une fonction

Une fonction peut avoir aucun, un ou plusieurs arguments. Le résultat renvoyé par une fonction est réutilisable dans un programme ou une autre fonction.

‹3

Les instructions sous Python Instruction conditionnelle if…elif…else if condition 1 : instruction(s) 1 elif condition 2 : instruction(s) 2 else : instruction(s) 3

Le mot clé « alors » n’existe pas en Python. C’est l’indentation, c’està-dire le décalage automatique du retour à la ligne vers la droite, qui le remplace.

• elif est la contraction de else if

La boucle bornée for for variable in range() : instruction(s)

La fonction range() permet d’énumérer le nombre de passages dans la boucle bornée.

La boucle peut être appelée de plusieurs façons : – range(n), où n est un entier, fait prendre à la variable les valeurs entières de 0 à n–1, donc n valeurs ; – range(n,m), où n et m sont des entiers, fait prendre à la variables les valeurs entières de n à m–1 ; – range(n,m,k), où n, m et k sont des entiers, fait prendre à la variable les valeurs entières de n à m–1, avec un pas de k.

La boucle non bornée while while condition : instruction(s)

Dès que la condition n’est plus vraie, la boucle s’arrête.

‹4

Affectations et manipulations de variables Affectation des variables numériques La variable compteur reçoit la valeur 0. La variable a reçoit la valeur 22 ; b reçoit la valeur 6.

Principales opérations en Python Pour effectuer certaines opérations, comme sqrt() ou randint(), on doit importer auparavant les fonctions des bibliothèques correspondantes (voir page 3). Addition des valeurs des variables a et b Soustraction des valeurs des variables a et b Produit des valeurs des variables a et b Quotient des valeurs des variables a et b Puissance entière de a Racine carrée de a Reste de la division euclidienne de a par b Quotient de la division euclidienne de a par b Renvoie aléatoirement un nombre entier entre 3 et 12 inclus. Renvoie aléatoirement un nombre décimal entre 0 et 1 exclus.

Outils de comparaison Si la variable a est strictement inférieure à 10 (respectivement > pour strictement supérieure) Si la variable a est inférieure ou égale à 10 (respectivement >= pour supérieure ou égale) Si la variable a est différente de 10 Si la variable a est strictement égale à 10

‹5

Les affichages et les graphiques La représentation graphique d’une fonction avec numpy et matplotlib.pyplot Le script suivant écrit dans l’éditeur utilise les fonctions usuelles. Importe les bibliothèques. Donne l’intervalle de variation de x, et le nombre de points calculés.

Détermine les dimensions des axes. Trace la courbe. Affiche la grille. Ouvre la fenêtre et affiche la courbe.

La courbe représentative d’une fonction La courbe suivante s’affiche lorsqu’on lance le programme.

Grille

Courbe

Dimensions des axes

‹6

Les affichages et les graphiques La représentation graphique d’une suite avec matplotlib.pyplot Le script suivant, écrit dans l’éditeur, utilise les fonctions usuelles et les listes. On veut tracer la représentation graphique de la suite ( un ) définie 3n +1 . pour tout entier naturel n par un = n+4 Importe la bibliothèque. Définit les axes : [ −1;22] sur l’axe des abscisses ; [ −1; 4 ] sur l’axe des ordonnées.

Définit les valeurs de l’entier n. Définit les valeurs des termes de la suite. Affiche le graphique.

Affiche la grille.

Trace le nuage de points ( x ; y ).

Le nuage de points d’une suite Le nuage de points suivant s’affiche lorsqu’on lance le programme.

‹7

Les variables listes Les caractéristiques des listes Une liste est une collection d’objets de différents types (variables numériques, chaînes de caractères, booléens, listes, etc.). Liste vide Liste contenant des objets de types différents Premier objet de la liste ou objet de rang 0 k + 1-ième objet de la liste ou objet de rang k Dernier objet de la liste Longueur ou nombre d’objets d’une liste Ajouter un objet en fin de liste Insérer un objet au rang k

Les opérations avec les listes • Additionner deux listes concatène (rassemble en une seule liste) les listes L1 et L2. • Générer une liste avec une suite numérique crée la liste des nombres de la forme 2n – 4 pour n variant de 0 à 9. • Parcourir les éléments d’une liste

La variable k parcourt les éléments de la liste pour des tests ou des instructions.

‹8

Dictionnaire abs : abréviation de absolute, absolu (renvoie la valeur absolue d’un nombre)

len : abréviation de length, longueur (d’une chaîne de caractères ou d’une liste)

and : et

or : ou

append : ajouter (un élément à une liste)

pi : nombre π

axis : axe (d’un repère) boxplot : tracé de boîte (affiche un diagramme en boîte) def : définition (d’une fonction) elif : contraction de else…if (sinon… si) else : sinon end : fin false : faux, variable de type booléen

plot : point (d’un repère) print : afficher randint : contraction de random integer (nombre aléatoire entier naturel) random : aléatoire range : portée, intervalle (de … à …) return : retourner (une valeur pour une fonction)

for … in … : pour … de … à

scatter : disperser, éparpiller (place des points isolés dans un nuage de points)

from : depuis (une bibliothèque)

show : montrer (un graphique)

grid : grille (dans un repère)

sort, sorted : trier, trié (une liste dans l’ordre croissant ou décroissant)

if : si import : importer (d’une bibliothèque) insert : insérer (un élément dans une liste à un certain rang) int : entier (valeur d’un entier naturel) in : dans (utile dans les boucles for)

sqrt : abréviation de square root (racine carrée) str : abréviation de string (chaîne de caractères) true : vrai, variable de type booléen while : tant que (boucle non bornée)

‹9

Les interactions programme-utilisateur L’entrée de valeurs par l’utilisateur Les instructions suivantes peuvent se rencontrer dans les programmes Python mais sont très peu utilisées dans ce cahier. Leur but est de rendre les programmes plus conviviaux. Affectation d’une valeur à une variable de type entier

La réponse doit être écrite dans la fenêtre qui s’ouvre :

Affectation d’une valeur à une variable de type flottant (décimal)

La réponse doit être écrite dans la fenêtre qui s’ouvre :

Affectation d’une valeur à une variable de type réel écrite sous la forme d’une racine carrée ou d’un quotient

La réponse doit être écrite dans la fenêtre qui s’ouvre :

‹ 10

Les principales opérations en langage Python La multiplication et la division sont prioritaires sur l’addition et la soustraction. Syntaxe a+b a*b a/b a ** b sqrt(a) a // b a%b

Opération Addition de a et b. (Si les variables a et b sont des chaînes de caractères, on parle de concaténation.) Multiplication de a et b. (Si la variable a ou b est une chaîne de caractères, on parle de répétition.) Division de a par b. Élévation de a à la puissance b. Racine carrée de a. (Il faut importer sqrt() depuis la bibliothèque math.) Quotient de la division euclidienne de a par b. Reste de la division euclidienne de a par b.

Affecter des valeurs aux variables Syntaxe

Rôle Affecte (stocke) simultanément la valeur 1.4 dans la variable x et la valeur 3.65 dans la x,y = 1.4,3.65 variable y (équivaut aux instructions x = 1.4 et y = 3.65). x,y = 3 *x+y, 4 *x-2 *y Affecte aux variables x et y les valeurs 3x+y et 4x-2y simultanément. x=x+1 Incrémente la variable x de 1.

Tests, conditions et opérateurs de comparaison en langage Python Syntaxe if condition : instruction(s) if condition : instruction(s) 1 else : instruction(s) 2 if condition 1 : instruction(s) 1 elif condition 2 : instruction(s) 2 else : instruction(s) 3 a == b a != b a < b (ou a > b) a = b) condition 1 and condition 2 condition 1 or condition 2

Rôle Teste la condition. Si la condition est vérifiée, exécute la (ou les) instruction(s) indentées. Teste la condition. Si la condition est vérifiée, exécute la (ou les) instruction(s) 1, sinon, exécute la (ou les) instruction(s) 2.

Teste la condition 1. Si la condition 1 est vérifiée, exécute la (ou les) instruction(s) 1, sinon, teste la condition 2. Si la condition 2 est vérifiée, exécute la (ou les) instruction(s) 2, sinon exécute la (ou les) instruction(s) 3. Teste si a est égal à b. Teste si a est différent de b. Compare si a est strictement inférieur à b (ou si a est strictement supérieur à b). Compare si a est inférieur ou égal à b (ou si a est supérieur ou égal à b). Teste si la condition 1 ET la condition 2 sont vérifiées. Teste si la condition 1 OU la condition 2 est vérifiée.

Les boucles en langage Python Syntaxe

Rôle

while condition : instruction(s) for variable in range(n) : instruction(s) for variable in range(n,m) : instruction(s) for variable in range(n,m,k) : instruction(s) for caractere in chaine : instruction(s)

Exécute en boucle la (ou les) instruction(s) tant que la condition est vérifiée. Exécute en boucle la (ou les) instruction(s) pour une variable allant de 0 à n–1. Exécute en boucle la (ou les) instruction(s) pour une variable allant de n à m–1. Exécute en boucle la (ou les) instruction(s) pour une variable allant de n à m–1 avec un pas de k. Exécute en boucle la (ou les) instruction(s) pour chaque caractere de la chaîne de caractères chaine.

Créer une fonction en langage Python Syntaxe def nom(p1,p2) : instruction(s) return resultat

Commentaires Une fonction est un programme qui porte un nom et qui peut utiliser plusieurs paramètres (p1,p2,...) ou aucun paramètre. Le mot-clé return est obligatoire à la fin d’une fonction. Le resultat renvoyé par une fonction peut être réutilisé dans un autre programme ou une autre fonction.

Les principales fonctions informatiques Syntaxe

Rôle

Commentaires

Fonctions mathématiques sqrt(a) Racine carrée de a. exp(x) log(x) pi

Exponentielle d’un nombre réel x. Logarithme népérien d’un nombre réel x.

e sin(a) cos(a) round(a,b) min(a,b) max(a,b)

Équivaut à la constante mathématique π. Constante e, image de 1 par la fonction exponentielle. Sinus d’un nombre a. Cosinus d’un nombre a. Renvoie la valeur a avec une précision de b nombres après la virgule. Renvoie le paramètre le plus petit parmi a et b. Renvoie le paramètre le plus grand parmi a et b.

Il faut importer sqrt(), exp(), log(), pi, e, sin() et cos() depuis la bibliothèque math.

round(a) renvoie un entier puisque b=0, c’est-àdire aucun chiffre après la virgule.

Probabilités randint(a,b) random() uniform(a,b) choice ("chaine")

Renvoie un nombre entier aléatoire compris entre deux entiers a et b inclus. Renvoie un nombre décimal aléatoire strictement compris entre 0 et 1. Renvoie un nombre décimal aléatoire compris entre deux nombres décimaux a et b. Renvoie aléatoirement un des éléments de la chaîne de caractères "chaine".

Il faut importer randint(), random(), uniform() et choice() de la bibliothèque random.

Reconnaît ou convertit le nombre ou la chaîne de caractères x en un entier. Reconnaît ou convertit le nombre ou la chaîne de caractères x en nombre flottant. Reconnaît ou convertit le nombre x en chaîne de caractères.

int(2.76) convertit la valeur 2.76 en donnant sa troncature : l’entier 2. float("235.76") convertit la chaîne de caractères "235.76" en nombre flottant : 235.76. str(176) convertit la valeur 176 en '176', une chaîne constituée des caractères 1 ; 7 et 6.

Conversion int(x) float(x) str(x)

Listes Syntaxe L = [] L = [3,"oui",False] L = [3,4.2,[0,1,2]] L[0] L[k] L[-1] len(L) L.append(objet) L.insert(rang,objet) L1+L2

Rôle Liste vide. Exemple de listes contenant des objets de types différents. Premier objet de la liste ou objet de rang 0 k + 1-ième objet de la liste ou objet de rang k. Dernier objet de la liste. Longueur ou nombre d’objets d’une liste. Ajoute un objet en fin de liste. Insère un objet au rang k. Concatène (rassemble) deux listes.

Graphiques Syntaxe

Rôle Commentaires grid() Affiche une grille dans un repère. Affiche un repère gradué de a à b sur l’axe des axis(a,b,c,d) abscisses et de c à d sur l’axe des ordonnées. Définit l’intervalle dans lequel varie x et le nombre Il faut importer les bibliothèques linspace(a,b, nbrepoints) pylab et numpy ou matplotlib. de points calculés pour tracer la courbe. pyplot. plt.plot(x,y) Trace le point de coordonnées (x ; y). plt.scatter(x,y) Trace un nuage de points. plt.show() Montre le graphique dans une nouvelle fenêtre.