QCM : Conditions composées et prédictions de sortie

[enonce]
Ce QCM porte sur les conditions composées, les fonctions par morceaux et les pièges classiques autour des structures conditionnelles en Python. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
On exécute le programme Python ci-dessous :

age = 16
if age < 6 :
    tarif = 0
elif age < 12 :
    tarif = 5
elif age < 18 :
    tarif = 8
else :
    tarif = 12
print(tarif)

Que s'affiche-t-il ?
[qcm]
[option]$5$[/option]
[option correct="true"]$8$[/option]
[option]$12$[/option]
[option]$0$[/option]
[reponse statut="correct"]Exact !
Python teste les conditions dans l'ordre. age < 6 est fausse, age < 12 est fausse, age < 18 est vraie : $tarif$ reçoit donc la valeur $8$, et Python sort de la structure.[/reponse]
[reponse motif="$5$"]Non.
La condition age < 12 est fausse car $16 \geqslant 12$. Python passe à la condition suivante.[/reponse]
[reponse motif="$12$"]Non.
La branche else n'est exécutée que si toutes les conditions précédentes sont fausses. Ici, age < 18 est vraie.[/reponse]
[reponse motif="$0$"]Non.
age < 6 est fausse pour $age = 16$. Le programme teste ensuite les conditions suivantes.[/reponse]
[reponse statut="incorrect"]Non.
Tester les conditions dans l'ordre : s'arrêter à la première vraie.[/reponse]
[/qcm]
[/etape]

[etape]
Avec x = 4, que vaut l'expression (x > 0 and x < 5) or x == 10 en Python ?
[qcm]
[option]False[/option]
[option correct="true"]True[/option]
[option]$4$[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Bonne réponse !
On évalue d'abord l'intérieur des parenthèses : x > 0 est vraie et x < 5 est vraie, donc True and True = True. Le or avec x == 10 donne alors True or False = True.[/reponse]
[reponse motif="False"]Non.
La partie gauche de or est vraie : $x = 4$ vérifie bien $0 < x < 5$. Or or est vrai dès qu'une seule de ses deux branches est vraie.[/reponse]
[reponse motif="$4$"]Non.
Une expression booléenne renvoie toujours True ou False, jamais un entier.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
Combiner plusieurs comparaisons avec and et or est une écriture parfaitement valide en Python.[/reponse]
[reponse statut="incorrect"]Non.
Évaluer d'abord les parenthèses, puis combiner le résultat avec or x == 10.[/reponse]
[/qcm]
[/etape]

[etape]
Le programme Python ci-dessous affecte une valeur à b :

x = -3
b = (x >= 0)

Que vaut l'expression not b ?
[qcm]
[option]False[/option]
[option correct="true"]True[/option]
[option]$-3$[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Bravo !
Pour $x = -3$, l'expression x >= 0 vaut False. Donc b vaut False. L'inverse (avec not) vaut alors True.[/reponse]
[reponse motif="False"]Non.
Il faut d'abord évaluer b. Pour $x = -3$, la condition x >= 0 est fausse, donc b vaut False. Puis not inverse la valeur.[/reponse]
[reponse motif="$-3$"]Non.
b stocke le résultat de la comparaison, pas la valeur de $x$. Une comparaison renvoie toujours un booléen.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
Stocker un booléen dans une variable et lui appliquer not est une opération tout à fait valide.[/reponse]
[reponse statut="incorrect"]Non.
Deux étapes : évaluer b, puis inverser avec not.[/reponse]
[/qcm]
[/etape]

[etape]
On considère la fonction Python ci-dessous :

def f(x) :
    if x < -1 :
        return x**2
    elif x <= 1 :
        return 2*x
    else :
        return x + 3

Que vaut f(1) ?
[qcm]
[option]$1$[/option]
[option]$4$[/option]
[option correct="true"]$2$[/option]
[option]$-1$[/option]
[reponse statut="correct"]Parfait !
La condition x < -1 est fausse pour $x = 1$. La condition x <= 1 est vraie car $1 \leqslant 1$ (l'inégalité n'est pas stricte). Python exécute donc la deuxième branche : 2*x $= 2 \times 1 = 2$.[/reponse]
[reponse motif="$1$"]Non.
$1 = x^2$ pour $x = 1$, mais cette formule s'applique à la branche x < -1, qui est fausse ici.[/reponse]
[reponse motif="$4$"]Non.
$4 = 1 + 3$ est la formule de la branche else. Mais x = 1 vérifie x <= 1 (égalité admise), donc c'est la branche précédente qui s'exécute.[/reponse]
[reponse motif="$-1$"]Non.
Aucune branche ne renvoie $-1$ pour $x = 1$. Identifier quelle condition est vraie, puis appliquer la formule correspondante.[/reponse]
[reponse statut="incorrect"]Non.
Attention au <= (non strict). Python s'arrête à la première condition vraie dans l'ordre.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous (l'utilisateur saisit henri en minuscules) :

nom = input("Votre nom : ")
if nom == "Henri" :
    print("Bonjour Henri")
else :
    print("Bonjour inconnu")

Que s'affiche-t-il ?
[qcm]
[option]Bonjour Henri[/option]
[option correct="true"]Bonjour inconnu[/option]
[option]Bonjour henri[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Tu as raison !
Python distingue les majuscules des minuscules. Les chaînes « henri » et « Henri » sont donc différentes : la condition est fausse et c'est le bloc else qui s'exécute.[/reponse]
[reponse motif="Bonjour Henri"]Non.
Piège classique : Python est sensible à la casse. « henri » (minuscule) et « Henri » (majuscule) sont considérées comme deux chaînes différentes.[/reponse]
[reponse motif="Bonjour henri"]Non.
La chaîne affichée est celle écrite entre guillemets dans le print, pas celle saisie par l'utilisateur. Regarder ce que dit chaque branche.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
Comparer deux chaînes avec == est parfaitement valide : cela donne simplement True ou False.[/reponse]
[reponse statut="incorrect"]Non.
Python distingue strictement majuscules et minuscules dans les chaînes.[/reponse]
[/qcm]
[/etape]

[etape]
Avec x = 5 et y = 10, que vaut l'expression not (x > y) and y > 0 en Python ?
[qcm]
[option]False[/option]
[option]None[/option]
[option correct="true"]True[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Correct !
On évalue pas à pas. x > y signifie $5 > 10$, c'est False. not False = True. y > 0 signifie $10 > 0$, c'est True. Enfin, True and True = True.[/reponse]
[reponse motif="False"]Non.
Le not inverse la valeur de x > y (qui est fausse), donc cette partie vaut True. Puis True and True donne True.[/reponse]
[reponse motif="None"]Non.
None n'apparaît jamais comme résultat d'une combinaison and/or/not entre booléens.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
L'expression combine proprement not, and et des comparaisons : c'est parfaitement valide.[/reponse]
[reponse statut="incorrect"]Non.
Évaluer étape par étape : x > y, puis not (...), puis y > 0, puis combiner avec and.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Conditions composées et pièges (niveau 3)

[enonce]
Pour chaque affirmation suivante sur les conditions composées et les pièges classiques en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
Affirmation : La condition not (x >= 5) est équivalente à x > 5.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
La négation de x >= 5 ($x \geqslant 5$) est x < 5 ($x < 5$), pas x > 5.
Le contraire d'« au moins 5 » est « strictement inférieur à 5 ».[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à la négation des inégalités : la négation de $\geqslant$ est $<$ (et la négation de $\leqslant$ est $>$).
not (x >= 5) est équivalent à x < 5, pas à x > 5 (qui exclurait aussi $x = 5$).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. La négation de $x \geqslant 5$ est $x < 5$. La bonne équivalence est not (x >= 5) $\Leftrightarrow$ x < 5.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

x = 3
y = 7
if x > 0 and y < 5 :
    print("X")
else :
    print("Y")

Affirmation : Ce programme affiche X.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bravo !
and exige que les deux conditions soient vraies.
Ici, x > 0 est vraie, mais y < 5 est fausse (car $7$ n'est pas inférieur à $5$). Le programme affiche donc Y.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Rappel : avec and, les deux conditions doivent être simultanément vraies.
y < 5 est fausse (car $y = 7$), donc toute la condition est fausse, et c'est le bloc else qui s'exécute : Y.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. y < 5 est fausse, donc x > 0 and y < 5 est fausse. Le programme affiche Y.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

n = 5
if n < 0 :
    print("A")
elif n < 10 :
    print("B")
elif n < 100 :
    print("C")
else :
    print("D")

Affirmation : Ce programme affiche B puis C.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Exactement !
Dans une cascade if…elif…else, Python exécute au plus un seul bloc : le premier dont la condition est vraie.
$n < 0$ est faux, $n < 10$ est vrai : le programme affiche B et s'arrête.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est de croire que toutes les conditions vraies entraînent l'exécution de leur bloc.
En réalité, la cascade elif s'arrête à la première condition vraie : seul B s'affiche.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Seul le premier elif vrai est exécuté : le programme affiche B uniquement.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

a = 2
b = 5
if a == 1 or b == 5 :
    print("oui")
else :
    print("non")

Affirmation : Ce programme affiche oui.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
or exige qu'au moins une des deux conditions soit vraie.
a == 1 est fausse, mais b == 5 est vraie : la condition totale est donc vraie et oui s'affiche.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : avec or, il suffit qu'une seule condition soit vraie pour que le tout soit vrai.
b == 5 est vraie, donc la condition est satisfaite : le programme affiche oui.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. b == 5 est vraie, donc a == 1 or b == 5 est vraie : oui s'affiche.
[/solution]
[/etape]

[etape]
On considère la fonction mathématique définie par :

$f(x) = -x + 1$ si $x \leqslant 0$, et $f(x) = 3x + 1$ si $x > 0$

On exécute le programme Python ci-dessous :

x = -2
if x <= 0 :
    y = -x + 1
else :
    y = 3*x + 1
print(y)

Affirmation : Ce programme affiche $3$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Tu as raison !
Comme $x = -2 \leqslant 0$, le programme utilise la première branche : $y = -(-2) + 1 = 3$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il faut bien suivre la branche correspondant à la condition vraie.
$x = -2 \leqslant 0$ donc $y = -x + 1 = -(-2) + 1 = 2 + 1 = 3$. Le programme affiche $3$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. Puisque $x = -2 \leqslant 0$, on calcule $y = -(-2) + 1 = 3$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

x = 7
est_positif = (x > 0)
print(est_positif)

Affirmation : Ce programme affiche True.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Correct !
L'expression x > 0 est évaluée et renvoie un booléen.
Comme $7 > 0$, la variable est_positif reçoit la valeur True, qui est affichée.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : le résultat d'une comparaison est un booléen que l'on peut stocker dans une variable.
x > 0 vaut True (car $x = 7$), donc est_positif vaut True et s'affiche.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. x > 0 est évaluée et vaut True ; cette valeur est stockée dans est_positif puis affichée.
[/solution]
[/etape]

Python : Facture d’électricité à tranches

Un fournisseur d'électricité applique un tarif progressif par tranches selon la consommation annuelle $ x $ (en kWh) :

chaque kWh est facturé $ 0{,}20 $ € jusqu'à $ 100 $ kWh ;
au-delà de $ 100 $ kWh et jusqu'à $ 500 $ kWh, chaque kWh supplémentaire est facturé $ 0{,}15 $ € ;
au-delà de $ 500 $ kWh, chaque kWh supplémentaire est facturé $ 0{,}10 $ €.

Calculer « à la main » le montant de la facture pour une consommation de $ 80 $ kWh, puis de $ 300 $ kWh et enfin de $ 800 $ kWh.
Écrire une fonction Python facture qui prend en argument la consommation $ x $ (en kWh) et renvoie le montant à payer (en euros).
Vérifier à l'aide de la fonction les résultats de la question 1.

Corrigé

1. Pour $ x = 80 $ kWh, on est dans la première tranche : $ 80 \times 0{,}20 = \mathbf{16 \text{ €}} $.
2. Pour $ x = 300 $ kWh, on paye les $ 100 $ premiers kWh au tarif plein, puis $ 300 - 100 = 200 $ kWh au deuxième tarif :
  $ 100 \times 0{,}20 + 200 \times 0{,}15 = 20 + 30 = \mathbf{50 \text{ €}} $.
3. Pour $ x = 800 $ kWh, on paye les trois tranches :
  $ 100 \times 0{,}20 + 400 \times 0{,}15 + 300 \times 0{,}10 = 20 + 60 + 30 = \mathbf{110 \text{ €}} $.
On distingue les trois cas avec if, elif et else :
```
def facture(x):
    if x <= 100:
        return 0.20 * x
    elif x <= 500:
        return 20 + 0.15 * (x - 100)
    else:
        return 80 + 0.10 * (x - 500)
```
Dans la deuxième branche, les $ 100 $ premiers kWh coûtent $ 100 \times 0{,}20 = 20 $ €, puis on ajoute $ 0{,}15 $ € par kWh supplémentaire.
Dans la troisième branche, les $ 500 $ premiers kWh coûtent $ 20 + 400 \times 0{,}15 = 80 $ €, puis on ajoute $ 0{,}10 $ € par kWh supplémentaire.
On teste :
```
>>> facture(80)
16.0
>>> facture(300)
50.0
>>> facture(800)
110.0
```
Les résultats correspondent bien à ceux calculés à la question 1.

Python : Fonction définie par morceaux

On considère la fonction $ f $ définie sur $ \mathbb{R} $ par :

$ f(x) = \left\{ \begin{matrix} x & \texttt{si} & x < 0\\ x^2 - 1 &\texttt{si} & 0 \leqslant x<1 \\ x+5 & \texttt{si} & x \geqslant 1 \end{matrix} \right. $

Compléter le tableau de valeurs suivant :

$ x $ - 2 - 1 0 0,5 1 2 3

$ f (x) $
Écrire un programme Python qui demande à l'utilisateur d'entrer une valeur de $ x $ et qui calcule l'image de $ x $ par la fonction $ f $.
À l'aide de ce programme, vérifier les résultats de la question précédente.

Corrigé

- comme $ - 2<0 $, $ f ( - 2) = - 2 $
- comme $ - 1 < 0 $, $ f ( - 1) = - 1 $
- comme $ 0 \leqslant 0 < 1 $, $ f (0) =0^2 - 1= - 1 $
- comme $0 \leqslant 0{,}5 < 1$, $f(0{,}5) = 0{,}5^2 - 1 = -0{,}75$
- comme $ 1 \geqslant 1 $, $ f (1) =1+5=6 $
- comme $ 2 \geqslant 1 $, $ f (2) =2+5=7 $
- comme $ 3 \geqslant 1 $, $ f (3) =3+5=8 $
On obtient donc le tableau de valeurs suivant :

$ x $ - 2 - 1 0 0,5 1 2 3

$ f (x) $ - 2 - 1 - 1 - 0,75 6 7 8
Le programme Python devra exécuter les tâches suivantes :
- demander à l'utilisateur d'entrer en nombre décimal (penser à convertir en float)
- calculer l'image de $ x $ par la fonction $ f $ en distinguant les différents cas à l'aide d'une instruction if - elif - else
- afficher le résultat trouvé pour $ f (x) $.
Voici un exemple possible :
```
x=float(input("Entrer une valeur de x :"))
if x<0 :
   resultat = x
elif x<1 :
    resultat = x**2-1
else :
    resultat = x+5
print(resultat)
```

Remarque
En ligne 4., on aurait pu écrire également « elif x>=0 and x<1 », toutefois comme la condition « x<0 » a déjà été traité en ligne 2. on est sûr, lorsque l'on arrive en ligne 4, que « x>=0 » et il n'y a donc pas besoin de faire figurer alors la condition « x>=0 ».

$ x $	- 2	- 1	0	0,5	1	2	3
$ f (x) $

$ x $	- 2	- 1	0	0,5	1	2	3
$ f (x) $	- 2	- 1	- 1	- 0,75	6	7	8