Quiz — Python

Question 1 : Après les instructions `a = 4`, `b = 7`, `c = a + b**2` puis `a = a + 1`, que valent `a` et `c` ?

• `a` vaut 4 et `c` vaut 53
• ✓ `a` vaut 5 et `c` vaut 53
• `a` vaut 5 et `c` vaut 54
• `a` vaut 5 et `c` vaut 18

Explication : `c = 4 + 7**2 = 4 + 49 = 53`. Ensuite `a = a + 1` donne `a = 5`, mais `c` n'est pas recalculé : il garde la valeur 53. Une affectation ne crée pas de lien permanent entre les variables.

Question 2 : Quel est le type de la variable `x` après `x = 7 / 2` ?

• `int` (entier)
• `str` (chaîne de caractères)
• ✓ `float` (flottant)
• `bool` (booléen)

Explication : L'opérateur `/` effectue une division décimale : `7 / 2` vaut `3.5`, qui est un flottant. Pour obtenir le quotient entier 3, on utilise `7 // 2`.

Question 3 : Que renvoie `17 % 5` ?

• 3
• ✓ 2
• 3.4
• 0

Explication : `17 % 5` est le reste de la division euclidienne de 17 par 5 : $17 = 5 \times 3 + 2$, le reste est 2. Le quotient `17 // 5` vaut 3 et `17 / 5` vaut 3.4.

Question 4 : Que renvoie l'appel `f(3, 5)` pour la fonction `def f(a, b): return 2 * a + b` ?

• 16
• 13
• ✓ 11
• 10

Explication : Les arguments sont affectés dans l'ordre : `a = 3` et `b = 5`, donc la fonction renvoie `2 * 3 + 5 = 11`. Avec `f(5, 3)`, on aurait obtenu 13.

Question 5 : Combien de fois s'exécute l'instruction `print(k)` dans la boucle `for k in range(2, 9): print(k)` ?

• 9
• 8
• 6
• ✓ 7

Explication : `range(2, 9)` produit les entiers 2, 3, 4, 5, 6, 7, 8 : la borne 9 est exclue. Cela fait $9 - 2 = 7$ valeurs, donc 7 exécutions.

Question 6 : Que renvoie la fonction suivante ? `def s(): s = 0` puis `for k in range(1, 5): s = s + k` puis `return s`

• ✓ 10
• 15
• 5
• 4

Explication : `k` prend les valeurs 1, 2, 3, 4 (5 exclu) et `s` cumule : $1 + 2 + 3 + 4 = 10$.

Question 7 : Que renvoie `seuil()` définie par `n = 0` puis `while 3**n <= 100: n = n + 1` puis `return n` ?

• 4
• 3
• 6
• ✓ 5

Explication : $3^4 = 81 \leq 100$ donc la boucle continue et `n` passe à 5 ; $3^5 = 243 > 100$, la condition devient fausse et la boucle s'arrête. La fonction renvoie 5, le plus petit entier tel que $3^n > 100$.

Question 8 : Que renvoie `note(15)` pour la fonction : `if x > 15: return 'super'` `elif x >= 10: return 'bien'` `else: return 'insuffisant'` ?

• `'super'`
• ✓ `'bien'`
• `'insuffisant'`
• Une erreur : 15 vérifie deux conditions

Explication : `15 > 15` est faux, on passe au `elif` : `15 >= 10` est vrai, la fonction renvoie `'bien'`. Dans un `if / elif / else`, seul le premier bloc dont la condition est vraie est exécuté.

Question 9 : On veut simuler le lancer d'un dé équilibré à 6 faces. Quelle instruction convient (après `from random import *`) ?

• `randint(0, 6)`
• `randint(1, 5)`
• ✓ `randint(1, 6)`
• `random() * 6`

Explication : `randint(a, b)` renvoie un entier aléatoire entre `a` et `b` **inclus** : `randint(1, 6)` donne bien 1, 2, 3, 4, 5 ou 6 avec la même probabilité. `randint(0, 6)` inclurait 0, et `random() * 6` renvoie un flottant.

Question 10 : Quelle valeur `frequence(1000)` renvoie-t-elle approximativement, pour `c = 0` puis `for k in range(n): if randint(1, 6) == 6: c = c + 1` puis `return c / n` ?

• Environ 6
• Environ 0,5
• Exactement 0,1667
• ✓ Environ 0,17

Explication : La fonction compte le nombre de 6 obtenus en 1000 lancers et renvoie la fréquence. D'après la loi des grands nombres, cette fréquence est proche de la probabilité $\dfrac{1}{6} \approx 0{,}17$, sans lui être exactement égale : le résultat varie d'une exécution à l'autre.