01 - Types de base

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

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

1. Quel est le type de l’expression 7 / 2 en Python ?

A. int
B. float
C. str
D. bool

Correction

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.

2. Que vaut int(4.9) ?

A. 5 (arrondi au plus proche)
B. 4 (troncature)
C. 4.0
D. Erreur

Correction

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.

3. Que vaut bool('') (chaîne vide) ?

A. True
B. False
C. ''
D. Erreur

Correction

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.

4. Que produit l’expression '3' + '4' ?

A. 7
B. 34
C. '34'
D. Erreur

Correction

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.

5. Que produit 3 + '4' ?

A. 7
B. '34'
C. 34
D. Erreur (TypeError)

Correction

Réponse : D. Python ne convertit pas implicitement entre types. 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.

Exercice 2 : exemple travaillé – prédire types et valeurs

Voici comment analyser pas à pas le type et la valeur d’une expression Python.

Expression à analyser : str(3 * 5) + ' km'

Étape 1. On repère les sous-expressions et leur ordre d’évaluation (les parenthèses d’abord) :

3 * 5 → multiplication de deux int, résultat : 15 (type int)

Étape 2. On applique les fonctions de conversion :

str(15) → conversion en chaîne, résultat : '15' (type str)

Étape 3. On effectue l’opération restante :

'15' + ' km' → concaténation de deux chaînes, résultat : '15 km' (type str)

Résultat final : '15 km' de type str.

Piège courant : si on avait écrit 3 * 5 + ' km' sans str(), Python aurait levé un TypeError car on ne peut pas additionner un int et un str.

Exercice 3 : classement guidé d’expressions

Pour chaque expression, compléter le tableau en indiquant la valeur et le type. Procéder comme dans l’exemple travaillé.

Expression	Valeur	Type
`3 + 4`	…	…
`3 + 4.0`	…	…
`10 / 5`	…	…
`10 // 5`	…	…
`10 % 3 == 1`	…	…
`int('12') * 2`	…	…

Correction

Expression	Valeur	Type	Explication
`3 + 4`	`7`	`int`	Addition de deux entiers
`3 + 4.0`	`7.0`	`float`	Quand un `int` et un `float` sont mêlés, Python convertit en `float`
`10 / 5`	`2.0`	`float`	L’opérateur `/` renvoie toujours un `float`, même si le résultat est entier
`10 // 5`	`2`	`int`	L’opérateur `//` est la division entière entre deux `int`
`10 % 3 == 1`	`True`	`bool`	`10 % 3` vaut `1`, et `1 == 1` est `True`
`int('12') * 2`	`24`	`int`	`int('12')` vaut `12`, puis `12 * 2 = 24`

Exercice 4 : conversions explicites

Pour chacune des expressions suivantes, prédire le résultat et le type, puis vérifier en Python.

int(4.9)
float(3)
str(42) + str(8)
int('12') + int('8')
bool(0)
bool('False')

Correction

int(4.9) → 4 (type int). Troncature, pas arrondi.
float(3) → 3.0 (type float). Ajout de la partie décimale.
str(42) + str(8) → '428' (type str). Concaténation des chaînes '42' et '8'.
int('12') + int('8') → 20 (type int). Conversion puis addition.
bool(0) → False. Zéro est la seule valeur entière fausse.
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.

Exercice 5 : le piège des flottants

Les nombres à virgule sont représentés en mémoire de manière approximative (norme IEEE 754). Cela entraîne des résultats surprenants.

Calculer 0.1 + 0.2 en Python. Le résultat est-il exactement 0.3 ?
Calculer 0.1 + 0.1 + 0.1 - 0.3. Le résultat est-il exactement 0 ?
Proposer une méthode pour tester si deux flottants a et b sont « presque égaux » à $10^{-9}$ près.

Correction

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.
0.1 + 0.1 + 0.1 - 0.3 donne 5.551115123125783e-17, un nombre extrêmement petit mais pas exactement zéro.
On compare la valeur absolue de la différence à un seuil (appelé epsilon) :
```
def presque_egal(a, b, epsilon=1e-9):
    return abs(a - b) < epsilon
```
On peut aussi utiliser math.isclose(a, b) qui fait exactement cela.

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

Exercice 6 : applications concrètes

6.1 Convertisseur de température (cuisine)

Écrire un programme qui demande une température en degrés Celsius et affiche son équivalent en degrés Fahrenheit, arrondi à un chiffre après la virgule.

Formule : $F = C \times 1{,}8 + 32$.

Tester avec la température de cuisson d’un gâteau : $180,°\text{C}$.

Correction

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

Application : 180 °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.

6.2 Calcul d’IMC (biologie / santé)

L’indice de masse corporelle se calcule par : $\text{IMC} = \frac{\text{masse (kg)}}{\text{taille (m)}^2}$.

Écrire un programme qui demande la masse (en kg) et la taille (en cm), calcule l’IMC et affiche un message indiquant la catégorie :

IMC < 18,5 : insuffisance pondérale ;
18,5 ≤ IMC < 25 : corpulence normale ;
IMC ≥ 25 : surpoids.

Correction

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.

Exercice 7 : synthèse – débogage de types

Le programme suivant contient quatre erreurs liées aux types. Identifier chaque erreur, expliquer pourquoi elle se produit, puis proposer une correction.

age = input("Quel âge as-tu ? ")
annee_naissance = 2026 - age
taille = 1.75
poids = '70'
imc = poids / taille ** 2
print("Né(e) en " + annee_naissance)
print("IMC : " + imc)
resultat = age > 18
print("Majeur : " + resultat)

Correction

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 8) : "Majeur : " + resultat. resultat est un bool, on ne peut pas le concaténer à un str. → "Majeur : " + str(resultat).

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

02 - Python (1)