05 - Fonctions (1)

Exercice 1 : QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Quelle est la différence entre print() et return dans une fonction ?

• A. Il n’y a aucune différence
• B. print() affiche un résultat ; return renvoie une valeur utilisable par le programme
• C. return affiche un résultat ; print() renvoie une valeur
• D. return ne peut être utilisé que dans la console

2. Que renvoie cette fonction si on l’appelle avec f(3, 5) ?

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

• A. Rien (la fonction ne fait que calculer)
• B. 8
• C. (3, 5)
• D. "35"

3. Que vaut x après l’exécution du code suivant ?

def doubler(n):
    return n * 2

x = doubler(7)

• A. 7
• B. 14
• C. None
• D. Erreur

4. Que se passe-t-il si une fonction ne contient pas d’instruction return ?

• A. Erreur de syntaxe
• B. La fonction renvoie 0
• C. La fonction renvoie None
• D. La fonction ne s’exécute pas

Exercice 2 : exemple travaillé – écrire une fonction complète

Problème : écrire une fonction qui calcule l’aire d’un rectangle.

Étape 1. Prototype (signature et documentation) :

def aire_rectangle(longueur, largeur):
    """Calcule l'aire d'un rectangle.

    Paramètres :
        longueur (float) : longueur du rectangle (> 0)
        largeur (float) : largeur du rectangle (> 0)

    Retour :
        float : l'aire du rectangle
    """

Étape 2. Corps de la fonction :

    return longueur * largeur

Étape 3. Tests pour vérifier :

# Tests
assert aire_rectangle(5, 3) == 15
assert aire_rectangle(10, 10) == 100
assert aire_rectangle(2.5, 4) == 10.0
print("Tous les tests passent.")

Points importants :

• La docstring (entre """) documente ce que fait la fonction, ses paramètres et son retour.
• Les assertions (assert) vérifient automatiquement que la fonction donne le bon résultat.
• On sépare toujours le calcul (return) de l’affichage (print()).

Exercice 3 : fonctions guidées

3.1 Maximum de deux nombres

Compléter la fonction suivante :

def max2(a, b):
    """Renvoie le plus grand des deux nombres a et b."""
    if ___:
        return ___
    else:
        return ___

# Tests
assert max2(3, 7) == 7
assert max2(10, 2) == 10
assert max2(5, 5) == 5

def max2(a, b):
    """Renvoie le plus grand des deux nombres a et b."""
    if a >= b:
        return a
    else:
        return b

assert max2(3, 7) == 7
assert max2(10, 2) == 10
assert max2(5, 5) == 5
print("Tests OK")

3.2 Réutilisation de fonctions

En utilisant max2, écrire max3(a, b, c) qui renvoie le plus grand de trois nombres.

def max3(a, b, c):
    """Renvoie le plus grand des trois nombres."""
    return max2(max2(a, b), c)

assert max3(1, 2, 3) == 3
assert max3(5, 1, 3) == 5
assert max3(2, 8, 4) == 8
print("Tests OK")

Exercice 4 : fonctions avec domaines variés

4.1 Indice de masse corporelle (biologie)

Écrire une fonction imc(masse, taille) qui prend la masse en kg et la taille en mètres, et renvoie l’IMC arrondi à une décimale.

Formule : $\text{IMC} = \frac{\text{masse}}{\text{taille}^2}$

# Exemples :
print(imc(70, 1.75))  # 22.9
print(imc(85, 1.80))  # 26.2

def imc(masse, taille):
    """Calcule l'IMC.

    Paramètres :
        masse (float) : masse en kg
        taille (float) : taille en m

    Retour :
        float : IMC arrondi à 1 décimale
    """
    return round(masse / taille ** 2, 1)

assert imc(70, 1.75) == 22.9
assert imc(85, 1.80) == 26.2
print("Tests OK")

4.2 Vitesse moyenne (sport)

Écrire une fonction vitesse(distance_km, temps_min) qui calcule la vitesse moyenne en km/h.

# Exemples :
print(vitesse(10, 50))   # 12.0  (10 km en 50 min)
print(vitesse(42.195, 125))  # 20.3  (marathon en 2h05)

def vitesse(distance_km, temps_min):
    """Calcule la vitesse moyenne en km/h."""
    temps_h = temps_min / 60
    return round(distance_km / temps_h, 1)

assert vitesse(10, 50) == 12.0
assert vitesse(42.195, 125) == 20.3
print("Tests OK")

4.3 Conversion de recette (cuisine)

Écrire une fonction adapter_recette(quantite, nb_personnes_base, nb_personnes_cible) qui adapte une quantité d’ingrédient d’une recette prévue pour un certain nombre de personnes.

# 200 g de farine pour 4, combien pour 6 ?
print(adapter_recette(200, 4, 6))  # 300.0

def adapter_recette(quantite, nb_base, nb_cible):
    """Adapte une quantité d'ingrédient au nombre de personnes."""
    return round(quantite * nb_cible / nb_base, 1)

assert adapter_recette(200, 4, 6) == 300.0
assert adapter_recette(150, 4, 2) == 75.0
print("Tests OK")

Exercice 5 : constructibilité d’un triangle (mathématiques)

1. Écrire une fonction constructible(a, b, c) qui renvoie True si un triangle de côtés $a$, $b$, $c$ est constructible (inégalité triangulaire : chaque côté est strictement inférieur à la somme des deux autres).

2. Écrire une fonction aire_triangle(a, b, c) qui calcule l’aire d’un triangle à l’aide de la formule de Héron : $$A = \sqrt{p(p-a)(p-b)(p-c)}$$ où $p = \frac{a+b+c}{2}$ est le demi-périmètre.

3. Tester avec un triangle rectangle 3-4-5 (aire attendue : 6).

import math

def constructible(a, b, c):
    """Vérifie si un triangle de côtés a, b, c est constructible."""
    return a < b + c and b < a + c and c < a + b

def aire_triangle(a, b, c):
    """Calcule l'aire par la formule de Héron."""
    assert constructible(a, b, c), "Triangle non constructible"
    p = (a + b + c) / 2
    return round(math.sqrt(p * (p - a) * (p - b) * (p - c)), 2)

assert constructible(3, 4, 5) == True
assert constructible(1, 1, 10) == False
assert aire_triangle(3, 4, 5) == 6.0
print("Tests OK")

Exercice 6 : synthèse – bulletin scolaire

On modélise les notes d’un élève sous forme de liste de tuples (matière, note, coefficient).

notes = [
    ("Maths", 14, 7),
    ("NSI", 16, 6),
    ("Français", 12, 5),
    ("Anglais", 15, 3),
    ("EPS", 17, 2),
]

1. Écrire une fonction moyenne_ponderee(notes) qui calcule la moyenne pondérée.
2. Écrire une fonction meilleure_matiere(notes) qui renvoie le nom de la matière ayant la meilleure note.
3. Écrire une fonction bulletin(notes) qui affiche un bulletin formaté et la moyenne générale.

def moyenne_ponderee(notes):
    """Calcule la moyenne pondérée."""
    total = sum(note * coef for _, note, coef in notes)
    total_coef = sum(coef for _, _, coef in notes)
    return round(total / total_coef, 2)

def meilleure_matiere(notes):
    """Renvoie le nom de la matière avec la meilleure note."""
    meilleure = notes[0]
    for matiere, note, _ in notes:
        if note > meilleure[1]:
            meilleure = (matiere, note, 0)
    return meilleure[0]

def bulletin(notes):
    """Affiche le bulletin formaté."""
    print("=== BULLETIN ===")
    for matiere, note, coef in notes:
        print(f"{matiere:12} : {note}/20 (coef {coef})")
    print(f"{'Moyenne':12} : {moyenne_ponderee(notes)}/20")
    print(f"Meilleure matière : {meilleure_matiere(notes)}")

bulletin(notes)

=== BULLETIN ===
Maths        : 14/20 (coef 7)
NSI          : 16/20 (coef 6)
Français     : 12/20 (coef 5)
Anglais      : 15/20 (coef 3)
EPS          : 17/20 (coef 2)
Moyenne      : 14.48/20
Meilleure matière : EPS