QCM : Fonctions Python et calculs

[enonce]
Ce QCM porte sur l'utilisation des fonctions Python pour effectuer des calculs : appels, fonctions par morceaux et fonctions contenant des boucles. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
On définit la fonction Python ci-dessous :

def carre(x) :
    return x * x

Que vaut carre(7) ?
[qcm]
[option]$14$[/option]
[option correct="true"]$49$[/option]
[option]$7$[/option]
[option]$2$[/option]
[reponse statut="correct"]Exact !
La fonction renvoie $x \times x$. Pour $x = 7$ : $7 \times 7 = 49$.[/reponse]
[reponse motif="$14$"]Non.
$14 = 2 \times 7$ : vous avez effectué le double, pas le carré. Le carré est $x \times x$, pas $2x$.[/reponse]
[reponse motif="$7$"]Non.
$7$ est la valeur passée en paramètre, pas la valeur renvoyée. La fonction effectue bien une multiplication.[/reponse]
[reponse motif="$2$"]Non.
$2$ n'apparaît nulle part dans la fonction. Remplacer x par $7$ dans l'expression x * x.[/reponse]
[reponse statut="incorrect"]Non.
Remplacer x par $7$ dans l'expression x * x.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def f(x) :
    if x < 0 :
        return -x
    else :
        return x ** 2

Que vaut f(-3) ?
[qcm]
[option]$-3$[/option]
[option]$9$[/option]
[option correct="true"]$3$[/option]
[option]$-9$[/option]
[reponse statut="correct"]Bonne réponse !
Comme $-3 < 0$, la condition du if est vraie et la fonction renvoie $-x = -(-3) = 3$.[/reponse]
[reponse motif="$-3$"]Non.
La fonction renvoie -x, c'est-à-dire l'opposé de $x$. L'opposé de $-3$ est $+3$, pas $-3$.[/reponse]
[reponse motif="$9$"]Non.
$9 = (-3)^2$ correspond à la formule de la branche else. Or $-3 < 0$, donc c'est la première branche qui s'exécute, pas le else.[/reponse]
[reponse motif="$-9$"]Non.
Ce résultat ne correspond à aucune des deux formules de la fonction. Identifier d'abord quelle branche s'applique pour $x = -3$.[/reponse]
[reponse statut="incorrect"]Non.
Étape 1 : évaluer la condition pour savoir quelle branche s'exécute. Étape 2 : appliquer la formule.[/reponse]
[/qcm]
[/etape]

[etape]
On reprend la même fonction Python :

def f(x) :
    if x < 0 :
        return -x
    else :
        return x ** 2

Que vaut f(4) ?
[qcm]
[option]$-4$[/option]
[option]$8$[/option]
[option correct="true"]$16$[/option]
[option]$4$[/option]
[reponse statut="correct"]Bravo !
Comme $4 \geqslant 0$, la condition x < 0 est fausse : c'est la branche else qui s'exécute. La fonction renvoie donc $x^2 = 4^2 = 16$.[/reponse]
[reponse motif="$-4$"]Non.
$-4$ correspondrait à la branche x < 0 qui renvoie -x. Or $4 \geqslant 0$, c'est l'autre branche qui s'applique.[/reponse]
[reponse motif="$8$"]Non.
$8 = 2 \times 4$ : le symbole ** n'est pas une multiplication, c'est la puissance. $x^{**}2$ signifie $x^2$, donc $4^2 = 16$.[/reponse]
[reponse motif="$4$"]Non.
$4$ est la valeur passée en paramètre, pas celle renvoyée. La fonction applique une opération ; ici, elle élève au carré.[/reponse]
[reponse statut="incorrect"]Non.
Pour $x \geqslant 0$, la fonction renvoie x ** 2, c'est-à-dire $x^2$.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def somme_carres(n) :
    S = 0
    for i in range(1, n+1) :
        S = S + i**2
    return S

Que vaut somme_carres(3) ?
[qcm]
[option]$6$[/option]
[option correct="true"]$14$[/option]
[option]$9$[/option]
[option]$36$[/option]
[reponse statut="correct"]Parfait !
range(1, 4) fait parcourir à i les valeurs $1, 2, 3$. La fonction calcule donc $1^2 + 2^2 + 3^2 = 1 + 4 + 9 = 14$.[/reponse]
[reponse motif="$6$"]Non.
$6 = 1 + 2 + 3$ est la somme des entiers, pas celle des carrés. L'instruction i**2 élève i au carré avant de l'ajouter.[/reponse]
[reponse motif="$9$"]Non.
$9 = 3^2$ est le dernier carré ajouté, pas le total. La variable S cumule tous les carrés depuis $1^2$.[/reponse]
[reponse motif="$36$"]Non.
$36 = (1 + 2 + 3)^2 = 6^2$ correspond au carré de la somme. Ici on calcule la somme des carrés : $1^2 + 2^2 + 3^2 = 14$, ce n'est pas la même chose.[/reponse]
[reponse statut="incorrect"]Non.
Lister les valeurs de i dans range(1, n+1) puis sommer les carrés un à un.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

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

Que vaut somme(somme(2, 3), somme(4, 5)) ?
[qcm]
[option]$9$[/option]
[option]$20$[/option]
[option correct="true"]$14$[/option]
[option]$5$[/option]
[reponse statut="correct"]Exactement !
On évalue les appels internes d'abord : somme(2, 3) = 5 et somme(4, 5) = 9. Puis l'appel externe : somme(5, 9) = 14.[/reponse]
[reponse motif="$9$"]Non.
$9$ est le résultat de somme(4, 5), pas le résultat de l'appel externe. Il faut encore additionner avec somme(2, 3) = 5.[/reponse]
[reponse motif="$20$"]Non.
$20 = 2 + 3 + 4 + 5 + 6$ ou similaire : ce total ne correspond pas à l'expression. Seules quatre valeurs apparaissent : $2, 3, 4, 5$, dont la somme est $14$.[/reponse]
[reponse motif="$5$"]Non.
$5$ est le résultat de somme(2, 3), un sous-calcul. L'appel complet additionne ce résultat à somme(4, 5).[/reponse]
[reponse statut="incorrect"]Non.
Évaluer d'abord les appels internes (somme(2, 3) et somme(4, 5)), puis l'appel externe.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def compter_pairs(n) :
    c = 0
    for i in range(1, n+1) :
        if i % 2 == 0 :
            c = c + 1
    return c

Que vaut compter_pairs(10) ?
[qcm]
[option]$10$[/option]
[option correct="true"]$5$[/option]
[option]$4$[/option]
[option]$0$[/option]
[reponse statut="correct"]Tu as raison !
La boucle fait parcourir à i les valeurs $1, 2, 3, \ldots, 10$. Les valeurs paires sont $2, 4, 6, 8, 10$ : il y en a $5$. La fonction renvoie donc $5$.[/reponse]
[reponse motif="$10$"]Non.
$10$ est le nombre total d'entiers parcourus, pas le nombre d'entiers pairs. Le compteur n'est incrémenté que si la condition est vraie.[/reponse]
[reponse motif="$4$"]Non.
Piège : dans range(1, n+1) avec $n=10$, on parcourt $1, 2, \ldots, 10$ (avec $10$). $10$ est pair : il doit être compté.[/reponse]
[reponse motif="$0$"]Non.
La condition i % 2 == 0 est vraie au moins une fois (dès que $i = 2$). Le compteur est donc bien incrémenté.[/reponse]
[reponse statut="incorrect"]Non.
Lister les entiers de $1$ à $10$ et compter les pairs.[/reponse]
[/qcm]
[/etape]

QCM : Définition et appel de fonctions en Python

[enonce]
Ce QCM porte sur la définition et l'appel de fonctions en Python : mot-clé def, paramètres, instruction return et différence avec print. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Quel mot-clé Python permet de définir une nouvelle fonction ?
[qcm]
[option]function[/option]
[option]fun[/option]
[option correct="true"]def[/option]
[option]return[/option]
[reponse statut="correct"]Exact !
En Python, on utilise le mot-clé def (abréviation de define) pour définir une nouvelle fonction, suivi du nom de la fonction et de ses paramètres.[/reponse]
[reponse motif="function"]Non.
function est utilisé dans d'autres langages (JavaScript par exemple), mais pas en Python. Python utilise un mot-clé plus court.[/reponse]
[reponse motif="fun"]Non.
fun n'existe pas en Python. Le mot-clé est def (abréviation de define).[/reponse]
[reponse motif="return"]Non.
return sert à renvoyer une valeur à l'intérieur d'une fonction, mais pas à la définir. C'est un autre mot-clé qui crée la fonction.[/reponse]
[reponse statut="incorrect"]Non.
Syntaxe : def nom_fonction(paramètres) : suivi du corps indenté.[/reponse]
[/qcm]
[/etape]

[etape]
Quelle est la différence principale entre return et print dans une fonction Python ?
[qcm]
[option]Il n'y a aucune différence[/option]
[option correct="true"]return renvoie une valeur au programme appelant ; print l'affiche à l'écran[/option]
[option]return affiche ; print renvoie[/option]
[option]return est utilisé uniquement avec des entiers ; print avec des chaînes[/option]
[reponse statut="correct"]Bonne réponse !
return met fin à la fonction et transmet une valeur au programme qui l'a appelée (valeur réutilisable). print se contente d'afficher à l'écran, sans rien renvoyer.[/reponse]
[reponse motif="Il n'y a aucune différence"]Non.
La différence est fondamentale : return renvoie une valeur utilisable, print se contente d'afficher. Un print ne peut pas être stocké dans une variable pour être réutilisé.[/reponse]
[reponse motif="return affiche ; print renvoie"]Non.
C'est l'inverse. print affiche à l'écran ; return renvoie une valeur.[/reponse]
[reponse motif="return est utilisé uniquement avec des entiers ; print avec des chaînes"]Non.
Les deux fonctionnent avec tous les types (int, float, str, bool, listes, etc.). Le type n'est pas le critère de distinction.[/reponse]
[reponse statut="incorrect"]Non.
Retenir : print affiche, return renvoie. Seule la valeur renvoyée par return peut être stockée et réutilisée.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def f(x) :
    return x + 1

Que vaut f(5) ?
[qcm]
[option]$5$[/option]
[option]$1$[/option]
[option correct="true"]$6$[/option]
[option]Rien (la fonction n'affiche rien)[/option]
[reponse statut="correct"]Bravo !
Lors de l'appel f(5), le paramètre x reçoit la valeur $5$. La fonction renvoie alors $x + 1 = 5 + 1 = 6$.[/reponse]
[reponse motif="$5$"]Non.
$5$ est la valeur passée en paramètre, pas la valeur renvoyée. La fonction effectue une opération : elle ajoute $1$.[/reponse]
[reponse motif="$1$"]Non.
$1$ est la constante ajoutée, pas le résultat. Il faut faire la somme $x + 1$ avec $x = 5$.[/reponse]
[reponse motif="Rien (la fonction n'affiche rien)"]Non.
La fonction ne fait pas de print, mais elle renvoie une valeur grâce à return. f(5) produit donc bien une valeur utilisable.[/reponse]
[reponse statut="incorrect"]Non.
Remplacer x par la valeur passée en paramètre, puis appliquer la formule du return.[/reponse]
[/qcm]
[/etape]

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

def saluer() :
    print("Bonjour")

Laquelle des instructions suivantes appelle correctement cette fonction ?
[qcm]
[option]saluer[/option]
[option]def saluer()[/option]
[option correct="true"]saluer()[/option]
[option]call saluer()[/option]
[reponse statut="correct"]Exactement !
Pour appeler une fonction sans argument, on écrit son nom suivi de parenthèses vides. Les parenthèses sont obligatoires, même s'il n'y a pas de paramètre.[/reponse]
[reponse motif="saluer"]Non.
Sans les parenthèses, on ne lance pas la fonction : on y fait simplement référence. Les parenthèses sont nécessaires pour exécuter la fonction.[/reponse]
[reponse motif="def saluer()"]Non.
def sert à définir la fonction, pas à l'appeler. Une fois définie, on l'appelle en écrivant simplement son nom suivi de parenthèses.[/reponse]
[reponse motif="call saluer()"]Non.
Le mot-clé call n'existe pas en Python. Pour appeler une fonction, il suffit d'écrire son nom suivi de parenthèses.[/reponse]
[reponse statut="incorrect"]Non.
Appel d'une fonction : nom_fonction(arguments). Les parenthèses sont obligatoires, même vides.[/reponse]
[/qcm]
[/etape]

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

def f(x) :
    print(x * x)

a = f(3)
print(a)

Que s'affiche-t-il à l'écran (en deux lignes) ?
[qcm]
[option]9 puis 9[/option]
[option]9 puis 3[/option]
[option correct="true"]9 puis None[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]Parfait !
La fonction f affiche $9$ (avec print) mais ne renvoie rien avec return. Elle renvoie donc la valeur spéciale None. La variable a contient None, et print(a) l'affiche.[/reponse]
[reponse motif="9 puis 9"]Non.
print affiche à l'écran mais ne renvoie pas la valeur : la fonction f ne renvoie rien. Par conséquent, a ne contient pas $9$.[/reponse]
[reponse motif="9 puis 3"]Non.
$3$ est la valeur du paramètre, pas celle renvoyée par la fonction. La fonction ne renvoie d'ailleurs rien explicitement.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
On peut parfaitement affecter à une variable le résultat d'une fonction sans return : elle contiendra simplement None.[/reponse]
[reponse statut="incorrect"]Non.
Distinction importante : une fonction sans return renvoie None, même si elle utilise print.[/reponse]
[/qcm]
[/etape]

[etape]
On définit la fonction Python ci-dessous :

def moyenne(a, b, c) :
    return (a + b + c) / 3

Que vaut moyenne(4, 6, 8) ?
[qcm]
[option]$18$[/option]
[option correct="true"]$6.0$[/option]
[option]$6$[/option]
[option]$4.0$[/option]
[reponse statut="correct"]C'est bien ça !
$(4 + 6 + 8) / 3 = 18 / 3 = 6.0$. L'opérateur / renvoie toujours un float en Python, même si la division tombe juste.[/reponse]
[reponse motif="$18$"]Non.
$18$ est le total des trois nombres, pas la moyenne. Il faut diviser par $3$ (le nombre de valeurs).[/reponse]
[reponse motif="$6$"]Non.
La valeur est juste, mais pas exactement le type attendu : Python affiche 6.0 (avec un point décimal) car / renvoie toujours un float.[/reponse]
[reponse motif="$4.0$"]Non.
$4$ est le plus petit des trois nombres, pas leur moyenne. La moyenne est plus grande, elle tombe « au milieu » des valeurs.[/reponse]
[reponse statut="incorrect"]Non.
Moyenne = somme divisée par le nombre de valeurs. Attention : / en Python renvoie un float.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Modules et combinaisons de fonctions (niveau 3)

[enonce]
Pour chaque affirmation suivante sur les modules Python et les combinaisons de fonctions, indiquez si elle est Vraie ou Fausse.
[/enonce]

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

import math
print(math.sqrt(9))

Affirmation : Ce programme affiche $3{,}0$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
La fonction sqrt du module math calcule la racine carrée, qui est ici $\sqrt{9} = 3$.
Le résultat est renvoyé sous forme de float, soit $3{,}0$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : math.sqrt renvoie toujours un float.
$\sqrt{9} = 3$, affiché sous la forme $3{,}0$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. math.sqrt(9) renvoie $3{,}0$ (float).
[/solution]
[/etape]

[etape]
On considère l'instruction Python suivante :

from random import randint
x = randint(1, 6)

Affirmation : La variable x peut prendre les valeurs $1, 2, 3, 4$ ou $5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Exactement !
La fonction randint(a, b) renvoie un entier aléatoire entre a et b, bornes incluses.
randint(1, 6) peut donc donner $1, 2, 3, 4, 5$ ou $6$ (simulation d'un dé à 6 faces).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à bien distinguer randint de range : randint(a, b) inclut la borne b.
La valeur $6$ est donc possible ; c'est d'ailleurs la fonction qui sert à simuler un dé à $6$ faces.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. randint(1, 6) inclut les deux bornes : $x$ peut aussi valoir $6$.
[/solution]
[/etape]

[etape]
Affirmation : Après avoir écrit from math import sqrt, on peut utiliser sqrt(25) sans préfixe.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
L'instruction from math import sqrt importe uniquement la fonction sqrt et permet de l'appeler directement, sans le préfixe math.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il ne faut pas confondre import math (qui impose le préfixe math.sqrt) et from math import sqrt (qui rend sqrt accessible directement).
Avec from math import sqrt, sqrt(25) renvoie $5{,}0$ sans préfixe.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. from math import sqrt permet d'appeler directement sqrt(...) sans écrire math..
[/solution]
[/etape]

[etape]
On considère le programme Python ci-dessous :

def carre(x) :
    return x*x

def somme_carres(a, b) :
    return carre(a) + carre(b)

print(somme_carres(3, 4))

Affirmation : Ce programme affiche $25$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Tu as raison !
Une fonction peut en appeler une autre.
somme_carres(3, 4) calcule carre(3) + carre(4) = $9 + 16 = 25$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : une fonction peut utiliser d'autres fonctions dans son corps.
somme_carres(3, 4) renvoie $3^2 + 4^2 = 9 + 16 = 25$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. somme_carres(3, 4) renvoie $9 + 16 = 25$.
[/solution]
[/etape]

[etape]
Affirmation : Pour utiliser la fonction cos du module math sans préfixe, il faut écrire import math.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
import math impose le préfixe : il faut écrire math.cos(...).
Pour appeler cos sans préfixe, il faut utiliser from math import cos ou from math import *.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à la différence entre import module et from module import fonction.
Avec import math, on doit écrire math.cos(0). Pour l'appeler sans préfixe, il faut from math import cos.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. import math impose le préfixe math.cos. Pour l'éviter, il faut écrire from math import cos.
[/solution]
[/etape]

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

from random import randint

def lance_de() :
    nb_six = 0
    for i in range(6) :
        if randint(1, 6) == 6 :
            nb_six = nb_six + 1
    return nb_six

Affirmation : L'appel lance_de() renvoie toujours $1$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Correct !
La fonction simule $6$ lancers d'un dé et compte les $6$ obtenus. Ce nombre est aléatoire : il peut valoir $0$, $1$, $2$, …, jusqu'à $6$.
Ce n'est pas parce que l'espérance est proche de $1$ que le résultat est toujours $1$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est de confondre fréquence théorique ($1/6$) et résultat d'une simulation.
Sur $6$ lancers, on peut très bien obtenir $0$, $2$ ou même $6$ fois le $6$ : le résultat varie d'un appel à l'autre.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Le résultat est aléatoire : il peut prendre toute valeur entière entre $0$ et $6$, pas toujours $1$.
[/solution]
[/etape]

Vrai/Faux : Définir une fonction Python (niveau 1)

[enonce]
Pour chaque affirmation suivante sur la définition et l'appel d'une fonction Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
Affirmation : En Python, on définit une fonction à l'aide du mot-clé def.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bonne réponse !
Le mot-clé def introduit la définition d'une fonction, suivi du nom, des paramètres entre parenthèses et de deux-points.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : toute définition de fonction Python commence par def suivi du nom, des paramètres entre parenthèses et de deux-points.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La syntaxe est def nom(paramètres) : suivie d'un bloc indenté.
[/solution]
[/etape]

[etape]
Affirmation : Une fonction Python doit obligatoirement comporter une instruction return.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bravo !
L'instruction return est facultative. Une fonction peut simplement exécuter des actions (par exemple afficher un message avec print) sans rien renvoyer.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Il ne faut pas confondre retourner une valeur (avec return) et exécuter des actions.
Une fonction sans return est autorisée : elle renvoie alors la valeur spéciale None.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. return est facultatif. Une fonction sans return renvoie None par défaut.
[/solution]
[/etape]

[etape]
Affirmation : Une fonction Python peut recevoir plusieurs paramètres, séparés par des virgules.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
Par exemple, def moyenne(a, b, c) : définit une fonction à trois paramètres.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : une fonction peut avoir $0$, $1$ ou plusieurs paramètres.
Les paramètres sont placés entre parenthèses et séparés par des virgules, par exemple def f(x, y) :.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. On peut définir autant de paramètres que nécessaire, séparés par des virgules.
[/solution]
[/etape]

[etape]
On considère le programme Python ci-dessous :

def double(x) :
    return 2*x

print(double(7))

Affirmation : Ce programme affiche $14$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
L'appel double(7) exécute la fonction avec x = 7 et renvoie $2 \times 7 = 14$, qui est ensuite affiché.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : un appel de fonction remplace x par la valeur passée en argument.
double(7) calcule $2 \times 7 = 14$ et renvoie $14$, que print affiche.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. double(7) renvoie $2 \times 7 = 14$, qui est affiché.
[/solution]
[/etape]

[etape]
Affirmation : Pour appeler une fonction sans paramètre, on peut omettre les parenthèses.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Tu as raison !
Les parenthèses sont obligatoires lors de l'appel d'une fonction, même sans argument (parenthèses vides).
Par exemple, pour appeler afficher, on écrit afficher() et non afficher.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est d'oublier les parenthèses pour les fonctions sans paramètre.
Sans parenthèses, Python ne déclenche pas l'exécution : il se contente de référencer la fonction. L'appel nécessite toujours ().[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Les parenthèses sont obligatoires pour appeler une fonction, même sans argument : ma_fonction().
[/solution]
[/etape]

[etape]
On considère le programme Python ci-dessous :

def ajoute(x, y) :
    return x + y

a = ajoute(4, 3)
print(a)

Affirmation : Ce programme affiche $43$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Correct !
Les arguments 4 et 3 sont affectés aux paramètres x et y, puis la fonction renvoie leur somme. Le programme affiche donc $7$, et non $43$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention : la fonction calcule x + y, une addition, pas une mise côte à côte des chiffres.
Reprendre le calcul de ajoute(4, 3).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. ajoute(4, 3) renvoie $4 + 3 = 7$ ; la variable a vaut $7$, donc le programme affiche $7$ et non $43$.
[/solution]
[/etape]

Python : Simulation de lancers de dés

On souhaite simuler le lancer d'un dé équilibré à six faces à l'aide de Python.
Le module random fournit la fonction randint(a, b) qui renvoie un entier aléatoire compris (au sens large) entre $ a $ et $ b $.

  1. Écrire une fonction lancer(), sans argument, qui simule le lancer d'un dé à six faces.

    1. Tester la fonction en l'exécutant plusieurs fois dans la console.
  2. Écrire une fonction somme_deux_des() qui simule le lancer de deux dés et renvoie la somme des deux faces obtenues. Quelles sont les valeurs possibles renvoyées par cette fonction ?
  3. Écrire une fonction liste_lancers(n) qui renvoie la liste des résultats de $ n $ lancers successifs d'un dé.

    1. Indication : on pourra partir d'une liste vide L = [] et y ajouter chaque nouveau résultat avec L.append(...).
  4. En utilisant la fonction précédente, écrire un programme qui simule $ 1~000 $ lancers d'un dé et calcule la moyenne des résultats. Comparer cette moyenne avec l'espérance théorique $ \dfrac{1+2+3+4+5+6}{6} = 3{,}5 $.

Corrigé

  1. On importe la fonction randint puis on l'utilise avec les bornes $ 1 $ et $ 6 $ :

    from random import randint
    
    def lancer():
        return randint(1, 6)

    L'appel lancer() renvoie un entier aléatoire parmi $ 1, 2, 3, 4, 5, 6 $.

  2. On appelle deux fois la fonction randint et on additionne les résultats :

    def somme_deux_des():
        return randint(1, 6) + randint(1, 6)

    La plus petite somme possible est $ 1 + 1 = 2 $, la plus grande est $ 6 + 6 = 12 $. La fonction peut donc renvoyer tous les entiers de $ 2 $ à $ 12 $.

  3. On utilise une boucle for pour ajouter $ n $ résultats à une liste initialement vide :

    def liste_lancers(n):
        L = []
        for i in range(n):
            L.append(randint(1, 6))
        return L

    Par exemple, liste_lancers(5) peut renvoyer [3, 1, 6, 4, 2] (le résultat change à chaque exécution car il est aléatoire).

  4. On calcule la moyenne avec sum et len :

    L = liste_lancers(1000)
    moyenne = sum(L) / len(L)
    print(moyenne)

    On obtient une valeur proche de $ 3{,}5 $, par exemple $ 3{,}487 $ ou $ 3{,}521 $. Cette moyenne change à chaque exécution mais reste proche de l'espérance théorique : c'est une illustration de la loi des grands nombres.

Pour réviser : Importer et utiliser un module (math, random)