06 - Fonctions (1)

Les exercices se font dans Thonny, dans le fichier 06_fonctions_1.py.

Cours associé : 08 - Fonctions .

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 : une fonction complète, de la documentation aux tests

On veut une fonction qui calcule l’aire d’un rectangle. Sa documentation est déjà écrite :

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
    """
    ...

1. Remplacer ... par l’instruction qui renvoie l’aire.

   Indice

   L’aire d’un rectangle est le produit de ses deux dimensions : écrire return suivi de ce calcul.

2. Que vaut aire_rectangle(5, 3) ? Et aire_rectangle(2.5, 4) ?

3. Écrire trois lignes assert qui vérifient ces deux résultats et l’aire d’un carré de côté 10, puis exécuter le programme.

   Indice

   assert condition ne fait rien quand la condition est vraie, et arrête le programme avec une erreur sinon. Par exemple : assert aire_rectangle(5, 3) == 15.

4. Pourquoi la fonction renvoie-t-elle l’aire avec return au lieu de l’afficher avec print ?

   Indice

   Une valeur renvoyée peut être rangée dans une variable, comparée dans un assert ou réutilisée dans un calcul : est-ce possible avec un simple affichage ?

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
    """
    return longueur * largeur

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

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

   Indice

   Trois conditions à vérifier ensemble avec and, la première étant a < b + c. La fonction peut renvoyer directement la condition complète, qui vaut True ou False.

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.

   Indice

   Calculer d’abord p, puis la racine carrée avec math.sqrt, après import math en tête du programme.

   Code à copier puis compléter

   import math
   
   def aire_triangle(a, b, c):
       p = ...
       return math.sqrt(...)
   

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)
    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")