Connexion Inscription

Fonction Python : moyenne et écart-type

On dispose d'une série de valeurs rangées dans une liste Python, par exemple les notes d'un élève : $ L = [12, 15, 9, 14, 10] $.
On rappelle que la moyenne $ \bar{x} $ d'une série de $ n $ valeurs $ x_1, x_2, \dots, x_n $ est :

$ \bar{x} = \dfrac{x_1 + x_2 + \dots + x_n}{n} $

La variance $ V $ mesure la dispersion autour de la moyenne, et l'écart-type $ \sigma $ est la racine carrée de la variance :

$ V = \dfrac{(x_1 - \bar{x})^2 + (x_2 - \bar{x})^2 + \dots + (x_n - \bar{x})^2}{n} \qquad \sigma = \sqrt{V} $

Calculer « à la main » la moyenne de la série $ L = [12, 15, 9, 14, 10] $.
Écrire une fonction Python moyenne(L) qui prend en argument une liste de valeurs et renvoie leur moyenne.
Calculer « à la main » la variance puis l'écart-type de la série $ L $. On donnera l'écart-type arrondi à $ 0{,}01 $ près.
Écrire une fonction Python ecart_type(L) qui renvoie l'écart-type de la liste $ L $.
Utiliser les deux fonctions pour vérifier les résultats des questions 1. et 3.

Corrigé

La série compte $ n = 5 $ valeurs. On additionne puis on divise par $ 5 $ :
$ \bar{x} = \dfrac{12 + 15 + 9 + 14 + 10}{5} = \dfrac{60}{5} = \mathbf{12} $.
On parcourt la liste pour cumuler la somme, puis on divise par le nombre d'éléments. La fonction len(L) renvoie le nombre de valeurs de la liste :
```
def moyenne(L):
    somme = 0
    for x in L:
        somme = somme + x
    return somme / len(L)
```
On utilise la moyenne $ \bar{x} = 12 $ trouvée à la question 1. On calcule les carrés des écarts à la moyenne :
$ V = \dfrac{(12-12)^2 + (15-12)^2 + (9-12)^2 + (14-12)^2 + (10-12)^2}{5} $.
$ V = \dfrac{0 + 9 + 9 + 4 + 4}{5} = \dfrac{26}{5} = 5{,}2 $.
L'écart-type est la racine carrée de la variance :
$ \sigma = \sqrt{5{,}2} \approx \mathbf{2{,}28} $.

On réutilise la fonction moyenne pour obtenir $ \bar{x} $, puis on cumule les carrés des écarts. On importe la fonction sqrt (racine carrée) du module math :

from math import sqrt

def ecart_type(L):
    m = moyenne(L)
    somme = 0
    for x in L:
        somme = somme + (x - m)**2
    variance = somme / len(L)
    return sqrt(variance)

On exécute les deux fonctions avec la liste de l'énoncé :
```
>>> L = [12, 15, 9, 14, 10]
>>> moyenne(L)
12.0
>>> ecart_type(L)
2.280350850198276
```
On retrouve bien une moyenne de $ 12 $ et un écart-type $ \sigma \approx \mathbf{2{,}28} $, ce qui confirme les calculs des questions 1. et 3.

Remarque

La fonction ecart_type appelle la fonction moyenne : on peut réutiliser une fonction déjà écrite à l'intérieur d'une autre, ce qui évite de réécrire le même calcul.

QCM : Fonctions Python et calculs

[enonce]
Ce QCM porte sur l'utilisation des fonctions Python pour effectuer des calculs : appels, fonctions par morceaux et fonctions contenant des boucles. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
On définit la fonction Python ci-dessous :

def carre(x) :
    return x * x

Que vaut carre(7) ?
[qcm]
[option]$14$[/option]
[option correct="true"]$49$[/option]
[option]$7$[/option]
[option]$2$[/option]
[reponse statut="correct"]Exact !
La fonction renvoie $x \times x$. Pour $x = 7$ : $7 \times 7 = 49$.[/reponse]
[reponse motif="$14$"]Non.
$14 = 2 \times 7$ : vous avez effectué le double, pas le carré. Le carré est $x \times x$, pas $2x$.[/reponse]
[reponse motif="$7$"]Non.
$7$ est la valeur passée en paramètre, pas la valeur renvoyée. La fonction effectue bien une multiplication.[/reponse]
[reponse motif="$2$"]Non.
$2$ n'apparaît nulle part dans la fonction. Remplacer x par $7$ dans l'expression x * x.[/reponse]
[reponse statut="incorrect"]Non.
Remplacer x par $7$ dans l'expression x * x.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def f(x) :
    if x < 0 :
        return -x
    else :
        return x ** 2

Que vaut f(-3) ?
[qcm]
[option]$-3$[/option]
[option]$9$[/option]
[option correct="true"]$3$[/option]
[option]$-9$[/option]
[reponse statut="correct"]Bonne réponse !
Comme $-3 < 0$, la condition du if est vraie et la fonction renvoie $-x = -(-3) = 3$.[/reponse]
[reponse motif="$-3$"]Non.
La fonction renvoie -x, c'est-à-dire l'opposé de $x$. L'opposé de $-3$ est $+3$, pas $-3$.[/reponse]
[reponse motif="$9$"]Non.
$9 = (-3)^2$ correspond à la formule de la branche else. Or $-3 < 0$, donc c'est la première branche qui s'exécute, pas le else.[/reponse]
[reponse motif="$-9$"]Non.
Ce résultat ne correspond à aucune des deux formules de la fonction. Identifier d'abord quelle branche s'applique pour $x = -3$.[/reponse]
[reponse statut="incorrect"]Non.
Étape 1 : évaluer la condition pour savoir quelle branche s'exécute. Étape 2 : appliquer la formule.[/reponse]
[/qcm]
[/etape]

[etape]
On reprend la même fonction Python :

def f(x) :
    if x < 0 :
        return -x
    else :
        return x ** 2

Que vaut f(4) ?
[qcm]
[option]$-4$[/option]
[option]$8$[/option]
[option correct="true"]$16$[/option]
[option]$4$[/option]
[reponse statut="correct"]Bravo !
Comme $4 \geqslant 0$, la condition x < 0 est fausse : c'est la branche else qui s'exécute. La fonction renvoie donc $x^2 = 4^2 = 16$.[/reponse]
[reponse motif="$-4$"]Non.
$-4$ correspondrait à la branche x < 0 qui renvoie -x. Or $4 \geqslant 0$, c'est l'autre branche qui s'applique.[/reponse]
[reponse motif="$8$"]Non.
$8 = 2 \times 4$ : le symbole ** n'est pas une multiplication, c'est la puissance. $x^{**}2$ signifie $x^2$, donc $4^2 = 16$.[/reponse]
[reponse motif="$4$"]Non.
$4$ est la valeur passée en paramètre, pas celle renvoyée. La fonction applique une opération ; ici, elle élève au carré.[/reponse]
[reponse statut="incorrect"]Non.
Pour $x \geqslant 0$, la fonction renvoie x ** 2, c'est-à-dire $x^2$.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def somme_carres(n) :
    S = 0
    for i in range(1, n+1) :
        S = S + i**2
    return S

Que vaut somme_carres(3) ?
[qcm]
[option]$6$[/option]
[option correct="true"]$14$[/option]
[option]$9$[/option]
[option]$36$[/option]
[reponse statut="correct"]Parfait !
range(1, 4) fait parcourir à i les valeurs $1, 2, 3$. La fonction calcule donc $1^2 + 2^2 + 3^2 = 1 + 4 + 9 = 14$.[/reponse]
[reponse motif="$6$"]Non.
$6 = 1 + 2 + 3$ est la somme des entiers, pas celle des carrés. L'instruction i**2 élève i au carré avant de l'ajouter.[/reponse]
[reponse motif="$9$"]Non.
$9 = 3^2$ est le dernier carré ajouté, pas le total. La variable S cumule tous les carrés depuis $1^2$.[/reponse]
[reponse motif="$36$"]Non.
$36 = (1 + 2 + 3)^2 = 6^2$ correspond au carré de la somme. Ici on calcule la somme des carrés : $1^2 + 2^2 + 3^2 = 14$, ce n'est pas la même chose.[/reponse]
[reponse statut="incorrect"]Non.
Lister les valeurs de i dans range(1, n+1) puis sommer les carrés un à un.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def somme(a, b) :
    return a + b

Que vaut somme(somme(2, 3), somme(4, 5)) ?
[qcm]
[option]$9$[/option]
[option]$20$[/option]
[option correct="true"]$14$[/option]
[option]$5$[/option]
[reponse statut="correct"]Exactement !
On évalue les appels internes d'abord : somme(2, 3) = 5 et somme(4, 5) = 9. Puis l'appel externe : somme(5, 9) = 14.[/reponse]
[reponse motif="$9$"]Non.
$9$ est le résultat de somme(4, 5), pas le résultat de l'appel externe. Il faut encore additionner avec somme(2, 3) = 5.[/reponse]
[reponse motif="$20$"]Non.
$20 = 2 + 3 + 4 + 5 + 6$ ou similaire : ce total ne correspond pas à l'expression. Seules quatre valeurs apparaissent : $2, 3, 4, 5$, dont la somme est $14$.[/reponse]
[reponse motif="$5$"]Non.
$5$ est le résultat de somme(2, 3), un sous-calcul. L'appel complet additionne ce résultat à somme(4, 5).[/reponse]
[reponse statut="incorrect"]Non.
Évaluer d'abord les appels internes (somme(2, 3) et somme(4, 5)), puis l'appel externe.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def compter_pairs(n) :
    c = 0
    for i in range(1, n+1) :
        if i % 2 == 0 :
            c = c + 1
    return c

Que vaut compter_pairs(10) ?
[qcm]
[option]$10$[/option]
[option correct="true"]$5$[/option]
[option]$4$[/option]
[option]$0$[/option]
[reponse statut="correct"]Tu as raison !
La boucle fait parcourir à i les valeurs $1, 2, 3, \ldots, 10$. Les valeurs paires sont $2, 4, 6, 8, 10$ : il y en a $5$. La fonction renvoie donc $5$.[/reponse]
[reponse motif="$10$"]Non.
$10$ est le nombre total d'entiers parcourus, pas le nombre d'entiers pairs. Le compteur n'est incrémenté que si la condition est vraie.[/reponse]
[reponse motif="$4$"]Non.
Piège : dans range(1, n+1) avec $n=10$, on parcourt $1, 2, \ldots, 10$ (avec $10$). $10$ est pair : il doit être compté.[/reponse]
[reponse motif="$0$"]Non.
La condition i % 2 == 0 est vraie au moins une fois (dès que $i = 2$). Le compteur est donc bien incrémenté.[/reponse]
[reponse statut="incorrect"]Non.
Lister les entiers de $1$ à $10$ et compter les pairs.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : return, print et fonctions par morceaux (niveau 2)

[enonce]
Pour chaque affirmation suivante sur return, print et les fonctions mathématiques Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
On considère le programme Python ci-dessous :

def carre(x) :
    print(x*x)

a = carre(5)
print(a)

Affirmation : Ce programme affiche $25$ puis $25$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
La fonction carre affiche $x \times x$ mais ne renvoie rien (pas de return).
a reçoit donc la valeur spéciale None. Le programme affiche $25$ puis None.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Il ne faut pas confondre print (qui affiche) et return (qui renvoie).
La fonction n'ayant pas de return, elle renvoie None. Le programme affiche $25$ (par le print interne) puis None (pour print(a)).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Sans return, la fonction renvoie None. Le programme affiche $25$ puis None.
[/solution]
[/etape]

[etape]
On considère le programme Python ci-dessous :

def carre(x) :
    return x*x

a = carre(5)
print(a + 1)

Affirmation : Ce programme affiche $26$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
carre(5) renvoie $25$. Cette valeur est stockée dans a, puis on affiche $a + 1 = 26$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : avec return, la valeur renvoyée peut être utilisée dans un calcul.
a reçoit $5 \times 5 = 25$ ; on affiche ensuite $25 + 1 = 26$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. carre(5) renvoie $25$, donc a vaut $25$ et a + 1 vaut $26$.
[/solution]
[/etape]

[etape]
On considère la fonction moyenne ci-dessous :

def moyenne(a, b, c) :
    m = (a + b + c) / 3
    return m

Affirmation : L'appel moyenne(10, 12, 14) renvoie $12{,}0$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
$(10 + 12 + 14) / 3 = 36 / 3 = 12$.
L'opérateur / renvoie toujours un float, donc le résultat est $12{,}0$ (avec un point décimal).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : / produit un float même quand le résultat est un entier.
$(10 + 12 + 14) / 3 = 12{,}0$ — la forme est décimale (float), pas entière.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La somme vaut $36$ ; divisée par $3$, elle donne $12{,}0$ (car / renvoie un float).
[/solution]
[/etape]

[etape]
On considère la fonction Python ci-dessous :

def f(x) :
    if x <= 0 :
        return -x + 1
    else :
        return 3*x + 1

Affirmation : L'appel f(5) renvoie $16$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Tu as raison !
$5 > 0$, donc la fonction utilise la branche else et renvoie $3 \times 5 + 1 = 16$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il faut bien identifier la branche choisie.
Comme $x = 5 > 0$, on prend la branche else et on calcule $3 \times 5 + 1 = 16$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. $5 > 0$, donc f(5) renvoie $3 \times 5 + 1 = 16$.
[/solution]
[/etape]

[etape]
On considère la fonction Python ci-dessous :

def f(x) :
    if x <= 0 :
        return -x + 1
    else :
        return 3*x + 1

Affirmation : L'appel f(-3) renvoie $-8$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Correct !
$-3 \leqslant 0$, donc la fonction utilise la branche if et renvoie $-(-3) + 1 = 3 + 1 = 4$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention au signe : $-x$ avec $x = -3$ donne $-(-3) = 3$ (et non $-3$).
Comme $-3 \leqslant 0$, on prend la première branche : $-x + 1 = -(-3) + 1 = 4$.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. $-3 \leqslant 0$, donc f(-3) renvoie $-(-3) + 1 = 4$, et non $-8$.
[/solution]
[/etape]

[etape]
On considère la fonction Python ci-dessous :

def test(x) :
    return x > 10

print(test(7))

Affirmation : Ce programme affiche True.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]C'est bien ça !
Une fonction peut renvoyer un booléen. L'expression x > 10 vaut False car $7 < 10$, et c'est cette valeur qui est affichée.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à la valeur du booléen : return renvoie le résultat de la comparaison x > 10.
Comparer $7$ et $10$ pour déterminer ce qui est affiché.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. x > 10 est un booléen ; test(7) renvoie False (car $7 < 10$), donc le programme affiche False et non True.
[/solution]
[/etape]

Python : Résolution d’une équation du second degré

On souhaite écrire un programme Python qui résout l'équation $ ax^2 + bx + c = 0 $ (avec $ a \neq 0 $).
On admet le résultat suivant, qui sera démontré en classe de première :
on pose $ \Delta = b^2 - 4ac $ (appelé discriminant).

Si $ \Delta < 0 $, l'équation n'a pas de solution réelle.
Si $ \Delta = 0 $, l'équation admet une unique solution $ x_0 = \dfrac{-b}{2a} $.
Si $ \Delta > 0 $, l'équation admet deux solutions $ x_1 = \dfrac{-b - \sqrt{\Delta}}{2a} $ et $ x_2 = \dfrac{-b + \sqrt{\Delta}}{2a} $.

Calculer « à la main » le discriminant puis les solutions de l'équation $ 2x^2 + x - 1 = 0 $.
Écrire une fonction Python resolution(a, b, c) qui affiche les solutions de l'équation $ ax^2 + bx + c = 0 $. La fonction distinguera les trois cas selon le signe du discriminant.
Tester la fonction avec les trois équations suivantes :
1. $ 2x^2 + x - 1 = 0 $ ;
2. $ x^2 - 2x + 1 = 0 $ ;
3. $ x^2 + x + 1 = 0 $.

Corrigé

Pour $ 2x^2 + x - 1 = 0 $, on a $ a = 2 $, $ b = 1 $, $ c = -1 $.
$ \Delta = b^2 - 4ac = 1^2 - 4 \times 2 \times (-1) = 1 + 8 = 9 $.
Comme $ \Delta > 0 $, l'équation admet deux solutions :
- $ x_1 = \dfrac{-1 - \sqrt{9}}{2 \times 2} = \dfrac{-1 - 3}{4} = \dfrac{-4}{4} = \mathbf{-1} $ ;
- $ x_2 = \dfrac{-1 + \sqrt{9}}{2 \times 2} = \dfrac{-1 + 3}{4} = \dfrac{2}{4} = \mathbf{0{,}5} $.

On importe sqrt puis on traduit les trois cas avec if, elif et else :

from math import sqrt

def resolution(a, b, c):
    delta = b**2 - 4 * a * c
    if delta < 0:
        print("Pas de solution réelle.")
    elif delta == 0:
        x0 = -b / (2 * a)
        print("Solution unique :", x0)
    else:
        x1 = (-b - sqrt(delta)) / (2 * a)
        x2 = (-b + sqrt(delta)) / (2 * a)
        print("Deux solutions :", x1, "et", x2)

Tests :
1. resolution(2, 1, -1) : $ \Delta = 9 > 0 $, l'équation a deux solutions.
```
Deux solutions : -1.0 et 0.5
```
  Cela confirme le résultat de la question 1.
2. resolution(1, -2, 1) : $ \Delta = (-2)^2 - 4 \times 1 \times 1 = 4 - 4 = 0 $. L'équation a une solution unique :
  $ x_0 = \dfrac{-(-2)}{2 \times 1} = \dfrac{2}{2} = 1 $.
```
Solution unique : 1.0
```
3. resolution(1, 1, 1) : $ \Delta = 1^2 - 4 \times 1 \times 1 = 1 - 4 = -3 < 0 $. L'équation n'a pas de solution réelle.
```
Pas de solution réelle.
```

Remarque
L'équation $ x^2 - 2x + 1 = 0 $ s'écrit aussi $ (x - 1)^2 = 0 $, ce qui confirme la solution unique $ x_0 = 1 $.

Python : Distance entre deux points du plan

Le plan est muni d'un repère orthonormé. Pour deux points $ A(x_A\,;\,y_A) $ et $ B(x_B\,;\,y_B) $, la distance $ AB $ est donnée par la formule :

$ AB = \sqrt{(x_B - x_A)^2 + (y_B - y_A)^2} $

Calculer « à la main » la distance $ AB $ avec $ A(1\,;\,2) $ et $ B(4\,;\,6) $.
Écrire une fonction Python distance(xA, yA, xB, yB) qui renvoie la distance entre les points $ A(x_A\,;\,y_A) $ et $ B(x_B\,;\,y_B) $.
Utiliser la fonction pour vérifier le résultat de la question 1.
Calculer la distance $ CD $ avec $ C(-2\,;\,3) $ et $ D(5\,;\,-1) $. On donnera une valeur arrondie à $ 0{,}01 $ près.

Corrigé

On applique la formule avec $ A(1\,;\,2) $ et $ B(4\,;\,6) $ :
$ AB = \sqrt{(4-1)^2 + (6-2)^2} = \sqrt{3^2 + 4^2} = \sqrt{9 + 16} = \sqrt{25} = \mathbf{5} $.

On importe la fonction sqrt (racine carrée) du module math :

from math import sqrt

def distance(xA, yA, xB, yB):
    return sqrt((xB - xA)**2 + (yB - yA)**2)

Test :
```
>>> distance(1, 2, 4, 6)
5.0
```
On retrouve bien $ AB = 5 $.
On applique la fonction aux points $ C(-2\,;\,3) $ et $ D(5\,;\,-1) $ :
$ CD = \sqrt{(5 - (-2))^2 + (-1 - 3)^2} = \sqrt{7^2 + (-4)^2} = \sqrt{49 + 16} = \sqrt{65} $.
Avec Python :
```
>>> distance(-2, 3, 5, -1)
8.06225774829855
```
On obtient donc $ CD \approx \mathbf{8{,}06} $.

Python : Calcul du montant TTC avec la TVA

En France, trois taux de TVA s'appliquent sur le prix hors taxes d'un produit ou d'un service :

le taux normal : $ 20~\% $ ;
le taux intermédiaire : $ 10~\% $ ;
le taux réduit : $ 5{,}5~\% $.

On rappelle que le prix toutes taxes comprises s'obtient en ajoutant la TVA au prix hors taxes :

$ \text{TTC} = \text{HT} \times \left(1 + \dfrac{\text{taux}}{100}\right) $

Calculer « à la main » le montant TTC d'un article à $ 2~500 $ € HT aux trois taux de TVA.
Écrire une fonction Python ttc(ht, taux) qui prend en arguments le prix hors taxes et le taux de TVA (en pourcentage), et qui renvoie le prix toutes taxes comprises.
Vérifier à l'aide de la fonction les trois résultats de la question 1.
Écrire une seconde fonction montant_tva(ht, taux) qui renvoie uniquement le montant de la TVA (et non le prix TTC).

Corrigé

On applique la formule :
1. Au taux normal ($ 20~\% $) : $ 2~500 \times 1{,}20 = \mathbf{3~000 \text{ €}} $.
2. Au taux intermédiaire ($ 10~\% $) : $ 2~500 \times 1{,}10 = \mathbf{2~750 \text{ €}} $.
3. Au taux réduit ($ 5{,}5~\% $) : $ 2~500 \times 1{,}055 = \mathbf{2~637{,}50 \text{ €}} $.

La fonction traduit directement la formule :

def ttc(ht, taux):
    return ht * (1 + taux / 100)

Test :

>>> ttc(2500, 20)
3000.0
>>> ttc(2500, 10)
2750.0
>>> ttc(2500, 5.5)
2637.5

Les trois résultats correspondent à ceux de la question 1.

Le montant de la TVA est $ \text{HT} \times \dfrac{\text{taux}}{100} $ :
```
def montant_tva(ht, taux):
    return ht * taux / 100
```
Par exemple, montant_tva(2500, 20) renvoie $ 500{,}0 $ € (la différence entre $ 3~000 $ € et $ 2~500 $ €).

Python : Calculer l’indice de masse corporelle

L'indice de masse corporelle (IMC) d'une personne est défini par la formule :

$ \text{IMC} = \dfrac{m}{t^2} $

où $ m $ désigne la masse en kilogrammes et $ t $ la taille en mètres.

Calculer « à la main » l'IMC d'une personne mesurant $ 1{,}75 $ m et pesant $ 70 $ kg. On arrondira le résultat à $ 0{,}1 $ près.
Écrire une fonction Python imc qui prend en arguments la masse $ m $ et la taille $ t $, et qui renvoie l'IMC arrondi à $ 0{,}1 $ près.
1. Indication : l'instruction round(x, 1) arrondit le nombre $ x $ à $ 0{,}1 $ près.
Utiliser la fonction pour calculer l'IMC des personnes suivantes :
1. Alice : $ 60 $ kg pour $ 1{,}67 $ m ;
2. Bastien : $ 85 $ kg pour $ 1{,}80 $ m.

Corrigé

On calcule $ 1{,}75^2 = 3{,}0625 $, puis $ \dfrac{70}{3{,}0625} \approx 22{,}857 $. Arrondi à $ 0{,}1 $ près, on obtient un IMC de $\mathbf{22{,}9}$.

La fonction prend deux arguments :

def imc(m, t):
    return round(m / t**2, 1)

1. Pour Alice : $ \text{imc}(60, 1.67) = \text{round}(60 / 1{,}67^2 ; 1) $. On calcule $ 1{,}67^2 = 2{,}7889 $, puis $ 60 \div 2{,}7889 \approx 21{,}513 $, arrondi à $\mathbf{21{,}5}$.
2. Pour Bastien : $ \text{imc}(85, 1.80) $. On calcule $ 1{,}80^2 = 3{,}24 $, puis $ 85 \div 3{,}24 \approx 26{,}234 $, arrondi à $\mathbf{26{,}2}$.

Remarque
En Python, on écrit la puissance avec l'opérateur **. L'instruction t**2 correspond donc à $ t^2 $.

Python : Périmètre et aire d’un disque

On souhaite écrire une fonction Python qui renvoie, pour un disque de rayon $ r $, son périmètre $ P $ et son aire $ A $.
On rappelle que $ P = 2 \pi r $ et $ A = \pi r^2 $.

Que renvoie l'instruction Python ci-dessous ?
```
from math import pi
print(pi)
```
Écrire une fonction disque(r) qui prend en argument le rayon $ r $ et renvoie le couple $ (P, A) $.
Exécuter disque(3) et interpréter le résultat.
Quel est le périmètre et l'aire d'un disque de rayon $ 1 $ m ? On donnera les résultats arrondis au centième.

Corrigé

L'instruction from math import pi importe la constante $ \pi $ depuis le module math. L'affichage donne une valeur approchée de $ \pi $ :
```
3.141592653589793
```

La fonction renvoie les deux valeurs séparées par une virgule :

from math import pi

def disque(r):
    P = 2 * pi * r
    A = pi * r**2
    return P, A

L'appel disque(3) renvoie le couple :
```
(18.84955592153876, 28.274333882308138)
```
Cela signifie que le disque de rayon $ 3 $ a pour périmètre $ P \approx 18{,}85 $ (unités de longueur) et pour aire $ A \approx 28{,}27 $ (unités d'aire).
Pour un disque de rayon $ 1 $ m, on utilise disque(1) qui renvoie $ (2\pi ,\, \pi) $.
- Périmètre : $ P = 2\pi \approx \mathbf{6{,}28} $ m.
- Aire : $ A = \pi \approx \mathbf{3{,}14} $ m².

Remarque
Une fonction Python peut renvoyer plusieurs valeurs en même temps : l'instruction return P, A renvoie un couple que l'on peut récupérer ainsi :

P, A = disque(3)