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

Corrigé

  1. 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} $.
  2. 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)
  3. 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} $.
  4. 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)
  5. 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 : Modules math et random en Python

[enonce]
Ce QCM porte sur les modules Python math et random : import, fonctions sqrt, randint, random et simulations. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Pour utiliser la fonction sqrt (racine carrée), laquelle des instructions suivantes est correcte ?
[qcm]
[option]import sqrt[/option]
[option correct="true"]from math import sqrt[/option]
[option]include math.sqrt[/option]
[option]math.sqrt()[/option]
[reponse statut="correct"]Exact !
sqrt appartient au module math. On peut l'importer directement avec from math import sqrt, puis l'utiliser sans préfixe : sqrt(9) renvoie 3.0.[/reponse]
[reponse motif="import sqrt"]Non.
sqrt n'est pas un module autonome, c'est une fonction du module math. Il faut préciser de quel module on l'importe.[/reponse]
[reponse motif="include math.sqrt"]Non.
include n'existe pas en Python (c'est un mot-clé d'autres langages). Le mot-clé Python pour charger un module est import.[/reponse]
[reponse motif="math.sqrt()"]Non.
Cette écriture est un appel de fonction, pas un import. On ne peut l'utiliser que si le module math a été importé avant (avec import math).[/reponse]
[reponse statut="incorrect"]Non.
Deux syntaxes possibles : import math (puis math.sqrt(...)) ou from math import sqrt (puis sqrt(...) directement).[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

from random import randint
n = randint(2, 5)

Parmi les valeurs suivantes, laquelle peut être affectée à n ?
[qcm]
[option]$1$[/option]
[option]$6$[/option]
[option correct="true"]$3$[/option]
[option]$2.5$[/option]
[reponse statut="correct"]Bonne réponse !
randint(a, b) renvoie un entier aléatoire compris entre $a$ et $b$, bornes incluses. Les valeurs possibles sont donc $2, 3, 4, 5$. Seule $3$ est dans cet ensemble.[/reponse]
[reponse motif="$1$"]Non.
La borne inférieure est $2$ : randint(2, 5) ne peut pas renvoyer une valeur strictement inférieure à $2$.[/reponse]
[reponse motif="$6$"]Non.
La borne supérieure est $5$, et randint l'inclut. $6$ est donc hors de l'intervalle possible.[/reponse]
[reponse motif="$2.5$"]Non.
randint renvoie un entier, pas un décimal. Pour un décimal aléatoire, on utilise random().[/reponse]
[reponse statut="incorrect"]Non.
randint(a, b) : entier aléatoire, $a \leqslant n \leqslant b$, les deux bornes incluses.[/reponse]
[/qcm]
[/etape]

[etape]
Que renvoie la fonction random() du module random en Python ?
[qcm]
[option]Un entier aléatoire entre $0$ et $1$[/option]
[option]Un décimal aléatoire entre $0$ et $1$, les deux bornes incluses[/option]
[option correct="true"]Un décimal aléatoire dans $[0\,;\,1[$ (borne supérieure exclue)[/option]
[option]Un décimal aléatoire entre $-1$ et $1$[/option]
[reponse statut="correct"]Bravo !
random() renvoie un nombre réel aléatoire appartenant à $[0\,;\,1[$ : le $0$ est possible, mais le $1$ est exclu.[/reponse]
[reponse motif="Un entier aléatoire entre $0$ et $1$"]Non.
random() renvoie un décimal, pas un entier. Pour un entier, il faut utiliser randint.[/reponse]
[reponse motif="Un décimal aléatoire entre $0$ et $1$, les deux bornes incluses"]Non.
La borne supérieure $1$ est exclue : random() peut renvoyer des valeurs arbitrairement proches de $1$, mais jamais $1$ exactement.[/reponse]
[reponse motif="Un décimal aléatoire entre $-1$ et $1$"]Non.
random() ne renvoie jamais de valeur négative. L'intervalle est $[0\,;\,1[$, pas $[-1\,;\,1]$.[/reponse]
[reponse statut="incorrect"]Non.
random() : décimal dans $[0\,;\,1[$, $0$ inclus et $1$ exclu.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

def carre(x) :
    return x * x

def double(x) :
    return 2 * x

print(carre(double(3)))

Que s'affiche-t-il ?
[qcm]
[option]$12$[/option]
[option]$18$[/option]
[option correct="true"]$36$[/option]
[option]$6$[/option]
[reponse statut="correct"]Parfait !
On évalue d'abord l'appel interne : double(3) $= 2 \times 3 = 6$. Puis l'appel externe : carre(6) $= 6 \times 6 = 36$.[/reponse]
[reponse motif="$12$"]Non.
$12 = 2 \times 2 \times 3$ : il semble que vous ayez appliqué double deux fois. Ici, c'est double puis carre : lire les parenthèses de l'intérieur vers l'extérieur.[/reponse]
[reponse motif="$18$"]Non.
$18 = 2 \times 3^2$ : les opérations ont été effectuées dans le mauvais ordre. L'appel interne double(3) s'évalue en premier, donne $6$, puis on passe $6$ à carre.[/reponse]
[reponse motif="$6$"]Non.
$6 = double(3)$ est un résultat intermédiaire, pas la valeur finale. La fonction carre est encore appelée dessus.[/reponse]
[reponse statut="incorrect"]Non.
Pour des appels imbriqués f(g(x)), on évalue toujours l'appel interne g(x) en premier, puis l'appel externe.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

from math import sqrt
print(sqrt(16) + sqrt(9))

Que s'affiche-t-il ?
[qcm]
[option]$5$[/option]
[option]$25$[/option]
[option correct="true"]$7.0$[/option]
[option]$5.0$[/option]
[reponse statut="correct"]C'est bien ça !
$\sqrt{16} = 4$ et $\sqrt{9} = 3$. La somme vaut $4 + 3 = 7$. En Python, sqrt renvoie toujours un float, donc l'affichage est 7.0.[/reponse]
[reponse motif="$5$"]Non.
$5 = \sqrt{16 + 9} = \sqrt{25}$ : attention, $\sqrt{a} + \sqrt{b} \neq \sqrt{a + b}$. Il faut calculer les deux racines séparément, puis additionner.[/reponse]
[reponse motif="$25$"]Non.
$25 = 16 + 9$ : vous avez additionné les arguments, sans prendre les racines. La fonction sqrt applique la racine carrée à chaque nombre.[/reponse]
[reponse motif="$5.0$"]Non.
Même erreur que pour $5$ : vous avez calculé $\sqrt{16 + 9}$ au lieu de $\sqrt{16} + \sqrt{9}$. La racine carrée ne se distribue pas sur une somme.[/reponse]
[reponse statut="incorrect"]Non.
Calculer $\sqrt{16}$ et $\sqrt{9}$ séparément, puis additionner. sqrt renvoie toujours un float.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous sur un ordinateur puissant :

from random import randint

def frequence_six(n) :
    nb = 0
    for i in range(n) :
        if randint(1, 6) == 6 :
            nb = nb + 1
    return nb / n

print(frequence_six(100000))

Quelle valeur approximative s'affiche typiquement ?
[qcm]
[option]$0.1$ exactement[/option]
[option]$0.5$ environ[/option]
[option correct="true"]$0.167$ environ (proche de $1/6$)[/option]
[option]$6$ environ[/option]
[reponse statut="correct"]Exactement !
La probabilité d'obtenir $6$ avec un dé équilibré est $\dfrac{1}{6} \approx 0{,}1667$. Sur un grand nombre de lancers, la fréquence observée se rapproche de cette probabilité (loi des grands nombres).[/reponse]
[reponse motif="$0.1$ exactement"]Non.
La fréquence observée n'est jamais exactement égale à une valeur simple, elle varie d'une simulation à l'autre. De plus, $\dfrac{1}{6} \neq 0{,}1$.[/reponse]
[reponse motif="$0.5$ environ"]Non.
$0{,}5$ correspondrait à une pièce équilibrée (probabilité d'obtenir « pile »), pas à un dé à $6$ faces. Le dé a $6$ issues équiprobables, donc chacune a une probabilité de $\dfrac{1}{6}$.[/reponse]
[reponse motif="$6$ environ"]Non.
La fonction renvoie nb / n : c'est une fréquence comprise entre $0$ et $1$. Elle ne peut pas dépasser $1$.[/reponse]
[reponse statut="incorrect"]Non.
Sur un grand nombre de lancers, la fréquence d'un événement se rapproche de sa probabilité théorique. Ici : $\dfrac{1}{6}$.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Modules et combinaisons de fonctions (niveau 3)

[enonce]
Pour chaque affirmation suivante sur les modules Python et les combinaisons de fonctions, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
On exécute le programme Python ci-dessous :

import math
print(math.sqrt(9))

Affirmation : Ce programme affiche $3{,}0$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
La fonction sqrt du module math calcule la racine carrée, qui est ici $\sqrt{9} = 3$.
Le résultat est renvoyé sous forme de float, soit $3{,}0$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : math.sqrt renvoie toujours un float.
$\sqrt{9} = 3$, affiché sous la forme $3{,}0$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. math.sqrt(9) renvoie $3{,}0$ (float).
[/solution]
[/etape]

[etape]
On considère l'instruction Python suivante :

from random import randint
x = randint(1, 6)

Affirmation : La variable x peut prendre les valeurs $1, 2, 3, 4$ ou $5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Exactement !
La fonction randint(a, b) renvoie un entier aléatoire entre a et b, bornes incluses.
randint(1, 6) peut donc donner $1, 2, 3, 4, 5$ ou $6$ (simulation d'un dé à 6 faces).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à bien distinguer randint de range : randint(a, b) inclut la borne b.
La valeur $6$ est donc possible ; c'est d'ailleurs la fonction qui sert à simuler un dé à $6$ faces.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. randint(1, 6) inclut les deux bornes : $x$ peut aussi valoir $6$.
[/solution]
[/etape]

[etape]
Affirmation : Après avoir écrit from math import sqrt, on peut utiliser sqrt(25) sans préfixe.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
L'instruction from math import sqrt importe uniquement la fonction sqrt et permet de l'appeler directement, sans le préfixe math.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il ne faut pas confondre import math (qui impose le préfixe math.sqrt) et from math import sqrt (qui rend sqrt accessible directement).
Avec from math import sqrt, sqrt(25) renvoie $5{,}0$ sans préfixe.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. from math import sqrt permet d'appeler directement sqrt(...) sans écrire math..
[/solution]
[/etape]

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

def carre(x) :
    return x*x

def somme_carres(a, b) :
    return carre(a) + carre(b)

print(somme_carres(3, 4))

Affirmation : Ce programme affiche $25$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Tu as raison !
Une fonction peut en appeler une autre.
somme_carres(3, 4) calcule carre(3) + carre(4) = $9 + 16 = 25$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : une fonction peut utiliser d'autres fonctions dans son corps.
somme_carres(3, 4) renvoie $3^2 + 4^2 = 9 + 16 = 25$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. somme_carres(3, 4) renvoie $9 + 16 = 25$.
[/solution]
[/etape]

[etape]
Affirmation : Pour utiliser la fonction cos du module math sans préfixe, il faut écrire import math.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
import math impose le préfixe : il faut écrire math.cos(...).
Pour appeler cos sans préfixe, il faut utiliser from math import cos ou from math import *.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à la différence entre import module et from module import fonction.
Avec import math, on doit écrire math.cos(0). Pour l'appeler sans préfixe, il faut from math import cos.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. import math impose le préfixe math.cos. Pour l'éviter, il faut écrire from math import cos.
[/solution]
[/etape]

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

from random import randint

def lance_de() :
    nb_six = 0
    for i in range(6) :
        if randint(1, 6) == 6 :
            nb_six = nb_six + 1
    return nb_six

Affirmation : L'appel lance_de() renvoie toujours $1$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Correct !
La fonction simule $6$ lancers d'un dé et compte les $6$ obtenus. Ce nombre est aléatoire : il peut valoir $0$, $1$, $2$, …, jusqu'à $6$.
Ce n'est pas parce que l'espérance est proche de $1$ que le résultat est toujours $1$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est de confondre fréquence théorique ($1/6$) et résultat d'une simulation.
Sur $6$ lancers, on peut très bien obtenir $0$, $2$ ou même $6$ fois le $6$ : le résultat varie d'un appel à l'autre.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Le résultat est aléatoire : il peut prendre toute valeur entière entre $0$ et $6$, pas toujours $1$.
[/solution]
[/etape]

Python : Simulation de lancers de dés

On souhaite simuler le lancer d'un dé équilibré à six faces à l'aide de Python.
Le module random fournit la fonction randint(a, b) qui renvoie un entier aléatoire compris (au sens large) entre $ a $ et $ b $.

  1. Écrire une fonction lancer(), sans argument, qui simule le lancer d'un dé à six faces.

    1. Tester la fonction en l'exécutant plusieurs fois dans la console.
  2. Écrire une fonction somme_deux_des() qui simule le lancer de deux dés et renvoie la somme des deux faces obtenues. Quelles sont les valeurs possibles renvoyées par cette fonction ?
  3. Écrire une fonction liste_lancers(n) qui renvoie la liste des résultats de $ n $ lancers successifs d'un dé.

    1. Indication : on pourra partir d'une liste vide L = [] et y ajouter chaque nouveau résultat avec L.append(...).
  4. En utilisant la fonction précédente, écrire un programme qui simule $ 1~000 $ lancers d'un dé et calcule la moyenne des résultats. Comparer cette moyenne avec l'espérance théorique $ \dfrac{1+2+3+4+5+6}{6} = 3{,}5 $.

Corrigé

  1. On importe la fonction randint puis on l'utilise avec les bornes $ 1 $ et $ 6 $ :

    from random import randint
    
    def lancer():
        return randint(1, 6)

    L'appel lancer() renvoie un entier aléatoire parmi $ 1, 2, 3, 4, 5, 6 $.

  2. On appelle deux fois la fonction randint et on additionne les résultats :

    def somme_deux_des():
        return randint(1, 6) + randint(1, 6)

    La plus petite somme possible est $ 1 + 1 = 2 $, la plus grande est $ 6 + 6 = 12 $. La fonction peut donc renvoyer tous les entiers de $ 2 $ à $ 12 $.

  3. On utilise une boucle for pour ajouter $ n $ résultats à une liste initialement vide :

    def liste_lancers(n):
        L = []
        for i in range(n):
            L.append(randint(1, 6))
        return L

    Par exemple, liste_lancers(5) peut renvoyer [3, 1, 6, 4, 2] (le résultat change à chaque exécution car il est aléatoire).

  4. On calcule la moyenne avec sum et len :

    L = liste_lancers(1000)
    moyenne = sum(L) / len(L)
    print(moyenne)

    On obtient une valeur proche de $ 3{,}5 $, par exemple $ 3{,}487 $ ou $ 3{,}521 $. Cette moyenne change à chaque exécution mais reste proche de l'espérance théorique : c'est une illustration de la loi des grands nombres.

Pour réviser : Importer et utiliser un module (math, random)

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} $.
  1. Calculer « à la main » le discriminant puis les solutions de l'équation $ 2x^2 + x - 1 = 0 $.
  2. É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.
  3. 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é

  1. 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} $.
  2. 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)
  3. 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} $
  1. Calculer « à la main » la distance $ AB $ avec $ A(1\,;\,2) $ et $ B(4\,;\,6) $.
  2. É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) $.
  3. Utiliser la fonction pour vérifier le résultat de la question 1.
  4. Calculer la distance $ CD $ avec $ C(-2\,;\,3) $ et $ D(5\,;\,-1) $. On donnera une valeur arrondie à $ 0{,}01 $ près.

Corrigé

  1. 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} $.
  2. 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)
  3. Test :

    >>> distance(1, 2, 4, 6)
    5.0

    On retrouve bien $ AB = 5 $.

  4. 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 : 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 $.

  1. Que renvoie l'instruction Python ci-dessous ?

    from math import pi
    print(pi)
  2. Écrire une fonction disque(r) qui prend en argument le rayon $ r $ et renvoie le couple $ (P, A) $.
  3. Exécuter disque(3) et interpréter le résultat.
  4. 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é

  1. 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
  2. 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
  3. 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).

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