02 - Types de base

Réponse : B. En Python, l’opérateur / effectue toujours une division flottante, même entre deux entiers. Le résultat de 7 / 2 est 3.5, de type float.

• A est faux : 7 // 2 donnerait un int (division entière), pas 7 / 2. Confusion entre / et //.
• C est faux : une division ne produit jamais une chaîne de caractères.
• D est faux : un booléen résulte d’une comparaison, pas d’une opération arithmétique.

Réponse : B. La fonction int() appliquée à un flottant effectue une troncature (suppression de la partie décimale), pas un arrondi.

• A est faux : c’est l’erreur classique de confusion entre int() (troncature) et round() (arrondi).
• C est faux : int() renvoie un entier, pas un flottant.
• D est faux : int(4.9) est parfaitement valide.

Réponse : B. En Python, les valeurs « vides » ou « nulles » sont considérées comme fausses : 0, 0.0, '', None. Tout le reste est vrai.

• A est faux : seules les chaînes non vides sont converties en True. Par exemple, bool('False') vaut True car la chaîne contient des caractères.
• C est faux : bool() renvoie toujours un booléen.
• D est faux : bool('') est une conversion valide.

Réponse : C. L’opérateur + entre deux chaînes effectue une concaténation (mise bout à bout). '3' + '4' donne la chaîne '34', pas le nombre 7.

• A est faux : il faudrait int('3') + int('4') pour obtenir 7. Confusion entre addition numérique et concaténation.
• B est faux : le résultat est bien 34, mais c’est une chaîne de caractères, pas un entier.
• D est faux : la concaténation de deux chaînes est valide.

Réponse : D. Python ne convertit pas implicitement une chaîne en nombre, ni un nombre en chaîne. On ne peut pas additionner un int et un str. Il faut convertir explicitement : 3 + int('4') ou str(3) + '4'.

• A est faux : il faudrait convertir '4' en entier d’abord.
• B est faux : il faudrait convertir 3 en chaîne d’abord.
• C est faux : le mélange de types provoque une erreur.

1. Python calcule d’abord ce qui est entre parenthèses : 3 * 5 est la multiplication de deux int, dont le résultat est 15, de type int.

2. str(15) convertit ce nombre en chaîne : le résultat est '15', de type str.

3. Il reste '15' + ' km' : c’est la concaténation de deux chaînes. Le résultat est '15 km', de type str.

4. Python calcule 3 * 5, puis doit faire 15 + ' km' : il s’arrête sur une erreur (TypeError), car on ne peut pas additionner un int et un str.

5. Dans la console :

print(str(3 * 5) + ' km')        # 15 km
print(type(str(3 * 5) + ' km'))  # <class 'str'>

1. int(4.9) → 4 (type int). Troncature, pas arrondi.
2. float(3) → 3.0 (type float). Ajout de la partie décimale.
3. str(42) + str(8) → '428' (type str). Concaténation des chaînes '42' et '8'.
4. int('12') + int('8') → 20 (type int). Conversion puis addition.
5. bool(0) → False. Zéro est la seule valeur entière fausse.
6. bool('False') → True. Piège : la chaîne 'False' est non vide, donc considérée comme vraie. Seule la chaîne vide '' est fausse.

1. 0.1 + 0.2 donne 0.30000000000000004, et non 0.3. En effet, $0{,}1$ n’a pas de représentation binaire exacte (tout comme $\frac{1}{3}$ n’a pas d’écriture décimale finie). Le résultat de 0.1 + 0.2 == 0.3 est False.

2. 0.1 + 0.1 + 0.1 - 0.3 donne 5.551115123125783e-17, un nombre extrêmement petit mais pas exactement zéro.

3. On compare la valeur absolue de la différence à un seuil très petit (appelé epsilon) :

   a = 0.1 + 0.2
   b = 0.3
   print(abs(a - b) < 1e-9)   # True : a et b sont égaux à un milliardième près
   

   On peut aussi utiliser math.isclose(a, b, abs_tol=1e-9) qui fait exactement cela.

Morale : ne jamais tester l’égalité exacte entre deux flottants avec ==. Toujours utiliser une comparaison approchée.

celsius = float(input("Température en °C : "))
fahrenheit = celsius * 1.8 + 32
print(f"{celsius} °C = {round(fahrenheit, 1)} °F")

Application : pour la saisie 180, le programme affiche 180.0 °C = 356.0 °F.

Points importants :

• input() renvoie une chaîne → il faut convertir avec float().
• round(valeur, 1) arrondit à un chiffre après la virgule.
• Le résultat est de type float.

masse = float(input("Masse en kg : "))
taille_cm = float(input("Taille en cm : "))
taille_m = taille_cm / 100  # conversion cm → m
imc = masse / taille_m ** 2

print(f"IMC = {round(imc, 1)}")

if imc < 18.5:
    print("Insuffisance pondérale")
elif imc < 25:
    print("Corpulence normale")
else:
    print("Surpoids")

Points importants :

• Conversion cm → m : diviser par 100 (résultat float).
• L’opérateur ** pour la puissance.
• Enchaînement de conditions avec if / elif / else.
• L’IMC est de type float.

Erreur 1 (ligne 2) : 2026 - age. input() renvoie un str, on ne peut pas soustraire un str d’un int. → age = int(input(...)).

Erreur 2 (ligne 5) : poids / taille ** 2. poids est un str ('70'), on ne peut pas diviser un str par un float. → poids = 70 (sans guillemets) ou poids = float('70').

Erreur 3 (ligne 6) : "Né(e) en " + annee_naissance. On ne peut pas concaténer un str et un int. → "Né(e) en " + str(annee_naissance) ou utiliser une f-string.

Erreur 4 (ligne 7) : "IMC : " + imc. imc est un float, on ne peut pas le concaténer à un str. → "IMC : " + str(imc) ou utiliser une f-string.

Erreur 5 (ligne 9) : "Majeur : " + resultat. resultat est un bool, on ne peut pas le concaténer à un str. → "Majeur : " + str(resultat).

Sans lien avec les types, le programme corrigé remplace aussi age > 18 par age >= 18, car on est majeur dès 18 ans.

Programme corrigé :

age = int(input("Quel âge as-tu ? "))
annee_naissance = 2026 - age
taille = 1.75
poids = 70
imc = poids / taille ** 2
print(f"Né(e) en {annee_naissance}")
print(f"IMC : {round(imc, 1)}")
resultat = age >= 18
print(f"Majeur : {resultat}")