# Notion de fonction : maths Seconde

Chapitre 12 du programme de mathématiques de Seconde (thème : Algorithmique et programmation). Ressource gratuite OptiTAB.

- Cours : https://www.optitab.net/ressources-gratuites/maths/seconde/notion-de-fonction/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/seconde/notion-de-fonction/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/seconde/notion-de-fonction/exercices/

## Cours

**Objectifs : - Définir et appeler une fonction Python à un ou plusieurs arguments ; distinguer `return` et `print`.**
- Lire, comprendre, compléter et modifier une fonction donnée.
- Écrire une fonction qui renvoie le résultat d’une expérience aléatoire.
- Répéter une expérience pour obtenir une fréquence, une moyenne, un écart type (sans liste).

## I. Définir et appeler une fonction

**Définition : Fonction Python**
Une **fonction** est un bloc d’instructions nommé. Elle reçoit des **arguments** (les données d’entrée), effectue des instructions et **renvoie** un résultat avec `return`.

- On la **définit** avec la ligne `def nom(arguments):` suivie d’un bloc **indenté** (décalé de quatre espaces).
- On l’**appelle** en écrivant `nom(valeurs)` : les valeurs prennent la place des arguments.

**Exemple : Traduire une fonction mathématique**
La fonction mathématique $f : x \mapsto 3x + 2$ s’écrit en Python :

```python
def f(x):
    return 3 * x + 2
```

L’appel `f(4)` remplace `x` par $4$ : il renvoie $3 \times 4 + 2 = 14$, l’image de $4$ par $f$.

![Schéma d’une fonction Python : l’argument 4 entre dans la fonction f, qui renvoie 3 × 4 + 2 = 14](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n178_co220_1_machine_fonction.png)

**Attention : return ou print ?**
- `return` **renvoie** une valeur : on peut la stocker (`y = f(4)`), l’utiliser dans un calcul (`f(4) + 1`) ou dans une autre fonction. Dès qu’un `return` est exécuté, la fonction s’arrête.
- `print` se contente d’**afficher** à l’écran : la valeur n’est pas récupérable. Une fonction sans `return` renvoie la valeur spéciale `None`.

## II. Plusieurs arguments, plusieurs instructions

Une fonction peut avoir plusieurs arguments (séparés par des virgules), aucun argument, et contenir des tests `if` ou des boucles.

```python
def prix_ttc(ht, t):
    return ht * (1 + t / 100)

def est_pair(n):
    return n % 2 == 0

def tarif(age):
    if age < 12:
        return 5
    elif age < 18:
        return 8
    else:
        return 11
```

**Exemple : Appels**
- `prix_ttc(50, 20)` renvoie $50 \times 1{,}2 = 60$ (affiché `60.0`).
- `est_pair(7)` renvoie `False`, car le reste de la division de $7$ par $2$ vaut $1$.
- `tarif(15)` renvoie `8` : le test `age < 12` est faux, le test `age < 18` est vrai.

**Attention : L’ordre des arguments compte**
Les valeurs sont affectées aux arguments **dans l’ordre** : `prix_ttc(20, 50)` calcule le prix d’un article à $20$ € avec une taxe de $50\,\%$, soit $30$, et non $60$.

**Méthode : Écrire une fonction**
1. **Entrées** : de quelles données a-t-on besoin ? Ce sont les arguments.
2. **Sortie** : quel résultat veut-on ? C’est ce qui suit `return`.
3. **Test** : on appelle la fonction sur un exemple dont on connaît la réponse.

## III. Fonctions renvoyant un nombre aléatoire

**Définition : Le module random**
Après la ligne `from random import randint, random` :

- `randint(a, b)` renvoie un **entier** au hasard entre $a$ et $b$, **bornes incluses** ;
- `random()` renvoie un **nombre décimal** au hasard dans l’intervalle ${[0\,;1[}$.

```python
from random import randint
from random import random

def lancer():
    return randint(1, 6)

def epreuve(p):
    if random() < p:
        return 1
    return 0
```

**Propriété : Simuler un événement de probabilité $p$**
Pour $0 \le p \le 1$, la condition `random() < p` est vraie avec la probabilité $p$. La fonction `epreuve(p)` renvoie donc $1$ (succès) avec la probabilité $p$ et $0$ (échec) avec la probabilité $1 - p$.

## IV. Répéter une expérience : fréquence

Pour répéter $n$ fois une expérience, on utilise une boucle `for` et un **compteur** initialisé à $0$.

```python
def frequence_six(n):
    k = 0
    for i in range(n):
        if lancer() == 6:
            k = k + 1
    return k / n
```

**Exemple : Fréquence du 6**
La figure montre la fréquence du 6 obtenue pour $n$ allant de $10$ à $3\,000$ lancers simulés. Pour les petites valeurs de $n$, elle varie beaucoup ; quand $n$ devient grand, elle se stabilise autour de la probabilité $\frac{1}{6} \approx 0{,}167$.

![Fréquence du 6 en fonction du nombre de lancers simulés, de 10 à 3 000 : la courbe se stabilise autour de 1/6](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n178_co220_2_frequence_six.png)

**À retenir : Plus le nombre $n$ de répétitions est grand, plus la fréquence d’un événement est, en général, proche de sa probabilité. Deux appels `frequence_six(1000)` donnent en général deux résultats différents : c’est la **fluctuation d’échantillonnage**.**

## V. Moyenne et écart type, sans liste

Pour une série $x_1, x_2, \ldots, x_n$, on note $m$ la moyenne, $V$ la variance et $\sigma$ l’écart type :

$$m = \frac{x_1 + x_2 + \cdots + x_n}{n} \qquad \sigma = \sqrt{V}$$

$$V = \frac{x_1^2 + x_2^2 + \cdots + x_n^2}{n} - m^2$$

Il suffit donc d’accumuler la **somme** des valeurs et la **somme de leurs carrés** : aucune liste n’est nécessaire.

```python
from random import randint
from math import sqrt

def moyenne_ecart_type(n):
    s = 0
    s2 = 0
    for i in range(n):
        x = randint(1, 6)
        s = s + x
        s2 = s2 + x * x
    m = s / n
    v = s2 / n - m * m
    return m, sqrt(v)
```

**Exemple : Interpréter le résultat**
L’appel `moyenne_ecart_type(10000)` renvoie un couple proche de $(3{,}5\,;\,1{,}71)$ : en moyenne un lancer de dé donne $3{,}5$, et les résultats s’écartent de cette moyenne d’environ $1{,}7$. On récupère les deux valeurs avec `m, e = moyenne_ecart_type(10000)`.

**Attention : Les accumulateurs**
Les variables qui accumulent (`k`, `s`, `s2`) s’initialisent à $0$ **avant** la boucle, jamais à l’intérieur ; le `return` se place **après** la boucle (non indenté sous le `for`), sinon la fonction s’arrête dès le premier tour.

**À retenir : - `def nom(arguments):` puis un bloc indenté ; `return` renvoie le résultat et arrête la fonction.**
- On appelle une fonction avec des valeurs, dans l’ordre des arguments.
- `randint(a, b)` et `random()` simulent le hasard ; `random() < p` est vrai avec la probabilité $p$.
- Une boucle répète l’expérience : compteur pour une fréquence, sommes pour une moyenne et un écart type.

## Fiche de révision

**Objectifs : L’essentiel pour écrire, appeler et lire une fonction Python, simuler le hasard et répéter une expérience. Programme de Seconde.**

## I. Écrire et appeler une fonction

```python
def f(x):
    return 3 * x + 2
```

![Schéma d’une fonction Python : l’argument 4 entre dans la fonction f, qui renvoie 3 × 4 + 2 = 14](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n178_fi136_1_machine_fonction.png)

- `def nom(arguments):` puis un bloc indenté de quatre espaces.
- `return` renvoie le résultat **et arrête** la fonction ; `print` ne fait qu’afficher.
- Appel : `nom(valeurs)`, valeurs dans **l’ordre** des arguments.

## II. Simuler le hasard

**Définition : Le module random**
Après `from random import randint, random` :

- `randint(a, b)` : entier au hasard entre $a$ et $b$, bornes incluses.
- `random()` : décimal au hasard dans ${[0\,;1[}$ ; `random() < p` est vrai avec la probabilité $p$.

## III. Répéter une expérience

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

- Compteur `k` à $0$ **avant** la boucle ; fréquence = `k / n`.
- Quand $n$ est grand, la fréquence se rapproche de la probabilité (ici $\frac{1}{6}$).
- Moyenne et écart type sans liste : accumuler `s` (somme) et `s2` (somme des carrés), puis $m = \frac{s}{n}$, $V = \frac{s_2}{n} - m^2$, $\sigma = \sqrt{V}$.

![Fréquence du 6 en fonction du nombre de lancers simulés, de 10 à 3 000 : la courbe se stabilise autour de 1/6](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n178_fi136_2_frequence_six.png)

## IV. Les pièges à éviter

**Attention : Les 4 erreurs classiques**
1. `print` au lieu de `return` : le résultat n’est pas réutilisable.
2. Oublier l’import de `randint`, `random` ou `sqrt`.
3. Initialiser un compteur **dans** la boucle : il repart à $0$ à chaque tour.
4. Placer le `return` **dans** la boucle : la fonction s’arrête dès le premier tour.

**Conseil : Réflexe**
Entrée → arguments, sortie → `return`. Toujours tester la fonction sur un cas dont on connaît la réponse.

## Exercices corrigés

### Exercice 1 : Définir et appeler une fonction à un argument

On écrit et on utilise des fonctions Python à un seul argument.

1. Écrire une fonction `triple` qui prend un nombre `x` en argument et renvoie son triple.
2. Que renvoie l’appel `triple(4)` ? Que vaut `y` après l’instruction `y = triple(4) + 1` ?
3. Un élève écrit la fonction ci-dessous. Il exécute `y = triple_b(4)` : l’écran affiche `12`. Que contient la variable `y` ? Expliquer la différence entre `return` et `print`.

   ```python
   def triple_b(x):
       print(3 * x)
   ```

4. On considère la fonction suivante. Que renvoie `suivant(10)` ?

   ```python
   def suivant(n):
       return n + 1
   ```

5. Écrire une fonction `carre` qui prend un nombre `x` et renvoie $x^2$. Que renvoie `carre(-3)` ?

#### Correction détaillée

## Question 1 : Écrire la fonction `triple`

**Méthode : En-tête `def nom(argument):`, puis un bloc indenté qui se termine par `return`.**

**Etape : En-tête**
La fonction s’appelle `triple` et reçoit un nombre `x` : `def triple(x):`.

**Etape : Corps**
Le triple de `x` s’écrit `3 * x` ; on le renvoie avec `return`.

**Resultat : ```python**
def triple(x):
    return 3 * x
```

**Attention : Le produit s’écrit avec `*` : `3x` provoque une erreur de syntaxe en Python.**

## Question 2 : Appeler `triple`

**Méthode : Remplacer l’argument `x` par la valeur donnée dans l’appel.**

**Etape : Appel triple(4)**
`x` prend la valeur $4$ ; la fonction renvoie $3 \times 4 = 12$.

![Schéma de la fonction triple : l'argument 4 entre dans la fonction, qui renvoie 3 × 4 = 12](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n178_ex1936_1_machine_triple.png)

**Etape : Réutiliser le résultat**
`triple(4) + 1` vaut $12 + 1 = 13$ : la valeur renvoyée s’utilise dans un calcul.

**Resultat : `triple(4)` renvoie $12$ et `y` vaut $13$.**

## Question 3 : `return` ou `print` ?

**Méthode : Se demander si la fonction **renvoie** une valeur ou se contente de l’**afficher**.**

**Etape : Ce que fait triple_b(4)**
L’instruction `print(3 * x)` affiche `12` à l’écran. La fonction ne contient aucun `return` : elle renvoie la valeur spéciale `None` (« rien »).

**Etape : Contenu de y**
`y` reçoit la valeur renvoyée, donc `None`. Le calcul `triple_b(4) + 1` provoquerait une erreur.

![Comparaison : triple(4) avec return renvoie 12, donc y vaut 12 ; triple_b(4) avec print affiche 12 à l'écran mais renvoie None, donc y vaut None](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n178_ex1936_2_print_return_triple.png)

**Resultat : `y` contient `None`. `return` renvoie une valeur réutilisable (variable, calcul) ; `print` ne fait que l’afficher.**

**À retenir : Une fonction qui calcule un résultat doit le **renvoyer** avec `return`.**

## Question 4 : Que renvoie `suivant(10)` ?

**Méthode : Remplacer `n` par $10$ dans l’instruction `return`.**

**Etape : Calcul**
`n + 1` devient $10 + 1 = 11$.

**Resultat : `suivant(10)` renvoie $11$.**

## Question 5 : Écrire la fonction `carre`

**Méthode : Le carré de `x` s’écrit `x ** 2` (ou `x * x`).**

**Etape : Écrire la fonction**
En-tête `def carre(x):`, puis `return x ** 2`.

**Etape : Tester avec −3**
$(-3)^2 = (-3) \times (-3) = 9$.

**Resultat : ```python**
def carre(x):
    return x ** 2
```

`carre(-3)` renvoie $9$.

**Attention : La puissance s’écrit `**` en Python ; le symbole `^` a un autre sens et donne un résultat faux.**

#### Réponses

1. `def triple(x):` puis `return 3 * x`.
2. `triple(4)` renvoie $12$ ; `y` vaut $13$.
3. `y` contient `None` : `print` affiche seulement, `return` renvoie une valeur réutilisable.
4. `suivant(10)` renvoie $11$.
5. `def carre(x):` puis `return x ** 2` ; `carre(-3)` renvoie $9$.

### Exercice 2 : Compléter, corriger et modifier une fonction

On complète, on corrige et on modifie des fonctions Python.

1. Compléter la fonction suivante pour qu’elle renvoie le périmètre d’un cercle de rayon `r` ($P = 2\pi r$). La constante $\pi$ est fournie par le module `math`. Donner une valeur approchée de `perimetre(5)`.

   ```python
   from math import pi

   def perimetre(r):
       return ...
   ```

2. La fonction suivante doit renvoyer l’aire d’un triangle de base `b` et de hauteur `h`. Elle renvoie $12$ pour `aire_triangle(4, 3)`. Trouver l’erreur et la corriger.

   ```python
   def aire_triangle(b, h):
       return b * h
   ```

3. On donne la fonction ci-dessous.

   ```python
   def f(x):
       y = x ** 2
       y = y - 4 * x
       y = y + 3
       return y
   ```

   - a) Que renvoie `f(1)` ? Que renvoie `f(3)` ?
   - b) Quelle est l’expression mathématique de $f(x)$ ?

4. Modifier la fonction `f` pour qu’elle programme $g(x) = x^2 - 4x + 7$. Que renvoie alors l’appel pour $x = 1$ ?
5. Écrire une fonction `distance` qui prend quatre arguments `xA`, `yA`, `xB`, `yB` et renvoie la distance entre les points $A(x_A\,;y_A)$ et $B(x_B\,;y_B)$. Tester avec $A(0\,;0)$ et $B(3\,;4)$.

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

#### Correction détaillée

## Question 1 : Compléter `perimetre`

**Méthode : Traduire la formule $P = 2\pi r$ avec `*` pour chaque produit.**

**Etape : Écrire le return**
$2\pi r$ s’écrit `2 * pi * r` ; `pi` est disponible grâce à `from math import pi`.

**Etape : Tester avec r = 5**
$2 \times \pi \times 5 = 10\pi \approx 31{,}42$.

**Resultat : ```python**
from math import pi

def perimetre(r):
    return 2 * pi * r
```

`perimetre(5)` renvoie environ $31{,}42$.

## Question 2 : Corriger `aire_triangle`

**Méthode : Comparer avec la formule $\mathcal{A} = \dfrac{b \times h}{2}$ et avec un cas connu.**

**Etape : Repérer l’erreur**
Pour $b = 4$ et $h = 3$, l’aire vaut $\dfrac{4 \times 3}{2} = 6$, mais la fonction renvoie $12$ : la division par $2$ manque.

**Resultat : ```python**
def aire_triangle(b, h):
    return b * h / 2
```

`aire_triangle(4, 3)` renvoie alors `6.0`.

**Attention : Tester une fonction sur un cas dont on connaît la réponse permet de détecter ce type d’erreur.**

## Question 3 : Exécuter `f` et trouver son expression

**Méthode : Remplacer `x` par la valeur et suivre les trois affectations de `y`.**

**Etape : Appel f(1)**
- `y = 1 ** 2` : `y` vaut $1$ ;
- `y = y - 4 * x` : `y` vaut $1 - 4 = -3$ ;
- `y = y + 3` : `y` vaut $-3 + 3 = 0$.

**Etape : Appel f(3)**
- `y = 3 ** 2` : `y` vaut $9$ ;
- `y = y - 4 * x` : `y` vaut $9 - 12 = -3$ ;
- `y = y + 3` : `y` vaut $-3 + 3 = 0$.

**Etape : Expression de f(x)**
On part de $x^2$, on retranche $4x$, puis on ajoute $3$ : $f(x) = x^2 - 4x + 3$.
**Points : $(x\,;f(x))$ calculés par la fonction pour $x$ allant de $-1$ à $5$ : la courbe coupe l’axe des abscisses en $1$ et en $3$, ce qui confirme `f(1)` et `f(3)` égaux à $0$.**

![Points (x ; f(x)) calculés par la fonction f pour x de −1 à 5 et parabole de f(x) = x² − 4x + 3, qui coupe l'axe des abscisses en 1 et en 3](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n178_ex1939_1_points_f_1939.png)

**Resultat : a) `f(1)` renvoie $0$ et `f(3)` renvoie $0$. b) $f(x) = x^2 - 4x + 3$.**

## Question 4 : Programmer $g(x) = x^2 - 4x + 7$

**Méthode : Comparer $g(x)$ et $f(x)$ : seule la constante change ($7$ au lieu de $3$).**

**Etape : Modifier une seule ligne**
On remplace `y = y + 3` par `y = y + 7`.

**Etape : Tester avec x = 1**
$1 - 4 + 7 = 4$.

**Resultat : ```python**
def g(x):
    y = x ** 2
    y = y - 4 * x
    y = y + 7
    return y
```

`g(1)` renvoie $4$.

![Parabole de g(x) = x² − 4x + 7 avec les points calculés par g, au-dessus de celle de f (en pâle) : une flèche +4 montre le décalage vers le haut](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n178_ex1939_2_points_g_1939.png)

Chaque valeur renvoyée par `g` vaut $4$ de plus que celle de `f` : la courbe de $g$ est celle de $f$ décalée de $4$ vers le haut.

## Question 5 : Écrire `distance`

**Méthode : Calculer les écarts des abscisses et des ordonnées, puis appliquer la formule avec `sqrt` (module `math`).**

**Etape : Écrire la fonction**
Deux variables intermédiaires `dx` et `dy` rendent le code lisible.

```python
from math import sqrt

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

**Etape : Tester avec A(0 ; 0) et B(3 ; 4)**
$$\sqrt{(3 - 0)^2 + (4 - 0)^2} = \sqrt{9 + 16} = \sqrt{25} = 5$$

**Resultat : `distance(0, 0, 3, 4)` renvoie `5.0`.**

**Attention : L’ordre des arguments doit être respecté à l’appel : `xA, yA, xB, yB`.**

#### Réponses

1. `return 2 * pi * r` ; `perimetre(5)` $\approx 31{,}42$.
2. La division par $2$ manque : `return b * h / 2`.
3. a) `f(1)` renvoie $0$ et `f(3)` renvoie $0$ ; b) $f(x) = x^2 - 4x + 3$.
4. Remplacer `y = y + 3` par `y = y + 7` ; l’appel pour $x = 1$ renvoie $4$.
5. `dx = xB - xA`, `dy = yB - yA`, `return sqrt(dx**2 + dy**2)` ; `distance(0, 0, 3, 4)` renvoie `5.0`.

### Exercice 3 : Simuler une tombola

Lors d’une tombola, chaque participant tire au hasard un numéro entier de $1$ à $20$ (tous les numéros ont la même probabilité). Le gain dépend du numéro tiré :

| Numéro tiré | Gain |
|---|---|
| $20$ | $50$ € |
| $5$, $10$ ou $15$ | $10$ € |
| autre numéro | $0$ € |

1. Écrire une fonction `tirage`, sans argument, qui simule un tirage et renvoie le **gain** du participant.
2. Écrire une fonction `nb_gagnants` qui prend un entier `n` (nombre de participants) et renvoie le nombre de participants ayant un gain strictement positif.
3. Écrire une fonction `gains` qui prend un entier `n` et renvoie le couple `(total, moyenne)` : somme des gains distribués et gain moyen par participant.
4. On suppose que les $5$ tirages de l’appel `gains(5)` donnent $7$, $10$, $20$, $3$ et $15$. Que renvoie cet appel ?
5. Calculer la probabilité qu’un participant gagne un lot. Vers quelle valeur la fréquence `nb_gagnants(n) / n` devrait-elle se stabiliser pour un très grand nombre de participants ?

#### Correction détaillée

## Question 1 : Écrire `tirage`

**Méthode : Tirer un numéro avec `randint(1, 20)`, puis tester les cas avec `if`, `elif`, `else`.**

**Etape : Tirer le numéro**
`num = randint(1, 20)` donne un entier de $1$ à $20$.

**Etape : Ordre des tests**
On teste d’abord le cas particulier `num == 20`, puis le cas « multiple de $5$ » avec `num % 5 == 0`, et enfin tous les autres numéros.

**Resultat : ```python**
from random import randint

def tirage():
    num = randint(1, 20)
    if num == 20:
        return 50
    elif num % 5 == 0:
        return 10
    else:
        return 0
```

**Attention : Si l’on testait `num % 5 == 0` en premier, le numéro $20$ (multiple de $5$) rapporterait $10$ € au lieu de $50$ € : dans une suite `if` / `elif`, seul le **premier** test vrai est exécuté.**

## Question 2 : Écrire `nb_gagnants`

**Méthode : Compteur initialisé à $0$, boucle de `n` tours, test `tirage() > 0`.**

**Resultat : ```python**
def nb_gagnants(n):
    k = 0
    for i in range(n):
        if tirage() > 0:
            k = k + 1
    return k
```

## Question 3 : Écrire `gains`

**Méthode : Accumuler les gains dans `total`, puis calculer la moyenne **après** la boucle et renvoyer un couple.**

**Etape : Accumuler**
Le total `tot` vaut $0$ avant la boucle ; à chaque tour, `tot = tot + tirage()`.

**Etape : Moyenne et couple**
Après la boucle : `moy = tot / n`, puis `return tot, moy`.

**Resultat : ```python**
def gains(n):
    tot = 0
    for i in range(n):
        tot = tot + tirage()
    moy = tot / n
    return tot, moy
```

## Question 4 : Exécuter `gains(5)` à la main

**Méthode : Déterminer le gain de chaque tirage, puis faire la somme et la moyenne.**

**Etape : Gains de chaque tirage**
| Tirage | $7$ | $10$ | $20$ | $3$ | $15$ |
|---|---|---|---|---|---|
| Gain (€) | $0$ | $10$ | $50$ | $0$ | $10$ |

**Etape : Total**
$$0 + 10 + 50 + 0 + 10 = 70$$

**Etape : Moyenne**
$$\frac{70}{5} = 14$$

**Resultat : `gains(5)` renvoie `(70, 14.0)` : $70$ € distribués, soit $14$ € en moyenne par participant.**

## Question 5 : Probabilité de gagner un lot

**Méthode : Les $20$ numéros sont équiprobables : probabilité = nombre de numéros gagnants divisé par $20$.**

**Etape : Numéros gagnants**
Les numéros gagnants sont $5$, $10$, $15$ et $20$ : il y en a $4$.

**Etape : Probabilité**
$$
\begin{aligned}
P(\text{gagner}) &= \frac{4}{20} \\
&= \frac{1}{5} \\
&= 0{,}2
\end{aligned}
$$

**Etape : Fréquence pour un grand nombre de participants**
Quand `n` est très grand, la fréquence des gagnants se rapproche de la probabilité $0{,}2$. La courbe donne `nb_gagnants(n) / n` calculé par la fonction pour $n = 10$, $20$, …, $3\,000$.

![Fréquence des gagnants nb_gagnants(n) / n pour n de 10 à 3 000 : elle fluctue puis se resserre autour de 0,2](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n178_ex1943_1_freq_gagnants_1943.png)

**Resultat : La probabilité de gagner un lot est $0{,}2$ ; pour `n` très grand, `nb_gagnants(n) / n` est proche de $0{,}2$ (soit $20\,\%$ de gagnants).**

#### Réponses

1. `num = randint(1, 20)` ; renvoie $50$ si `num == 20`, $10$ si `num % 5 == 0`, $0$ sinon (tests dans cet ordre).
2. Compteur des appels vérifiant `tirage() > 0`.
3. Boucle qui accumule `tirage()` dans `tot`, puis `return tot, tot / n`.
4. `gains(5)` renvoie `(70, 14.0)`.
5. $P(\text{gagner}) = \frac{4}{20} = 0{,}2$ ; la fréquence des gagnants se stabilise autour de $0{,}2$.
