$course$/QCM de NSI/Première/Modules Python Notion de module, importation (import,
from ... import), modules standards (math,
random, os, csv...), création de ses propres
modules, espaces de noms, alias.

]]> Modules Python — Q01 : Qu'est-ce qu'un module ? En Python, qu'est-ce qu'un module ?

]]> La modularité est un principe central en génie
logiciel : organiser le code en unités
cohérentes et réutilisables, plutôt qu'un seul
gros fichier.

]]> 1.0 0.0 0 true true abc Un type de données spécialisé dans les calculs mathématiques

]]> Erreur : un module est un fichier, pas un
type de données ; et il peut contenir du
code de toute nature, pas seulement du
calcul.

]]> Un fichier .py regroupant du code réutilisable

]]> Bonne réponse : un module rassemble des
fonctions ou constantes réutilisables. On
peut l'importer dans un autre programme
pour utiliser ses fonctions sans les
recoder.

]]> Une boucle imbriquée exécutée à l'intérieur d'une fonction

]]> Une boucle imbriquée est
une construction de
contrôle interne à une
fonction. Un module est
au contraire une unité
d'organisation du code,
stockée dans un fichier.

]]> Une variable globale accessible dans tout le programme

]]> Une variable globale est
une variable accessible
dans tout un programme.
Un module, lui, est une
unité d'organisation du
code, contenue dans un
fichier source distinct.

]]> Modules Python — Q02 : Import Comment importer le module math en Python ?

]]> import math charge le module et le rend
accessible sous le nom math. Pour des
fonctions précises sans préfixe :
from math import sqrt.

]]> 1.0 0.0 0 true true abc require math

]]> Erreur : c'est la syntaxe JavaScript / Ruby.

]]> use math

]]> Erreur : c'est la syntaxe Perl.

]]> include math

]]> Erreur : c'est la syntaxe C/C++.

]]> import math

]]> Bonne réponse : l'instruction import rend
accessible le contenu du module via le
préfixe math. (ex. math.sqrt(2)).

]]> Modules Python — Q03 : Utilisation après import Après import math, comment appelle-t-on la
fonction sqrt (racine carrée) ?

]]> Préfixe = espace de noms. Évite les
conflits si plusieurs modules ont des
fonctions de même nom.

]]> 1.0 0.0 0 true true abc math->sqrt(2)

]]> Erreur : -> est la syntaxe Perl/PHP.

]]> math.sqrt(2)

]]> Bonne réponse : on utilise le préfixe
module.fonction.

]]> sqrt(2)

]]> Erreur : sans préfixe math., Python ne
connaît pas sqrt.

]]> math::sqrt(2)

]]> Erreur : :: est la syntaxe C++ ou Ruby.

]]> Modules Python — Q04 : from import Que fait from math import sqrt ?

]]> Variantes : from math import sqrt, pi (deux
noms) ou from math import * (tout, mais à
éviter, pollue l'espace de noms).

]]> 1.0 0.0 0 true true abc Importe l'intégralité du module math dans le programme

]]> Erreur : on importe seulement sqrt.

]]> Importe seulement sqrt, appelable directement

]]> Bonne réponse : on écrit alors sqrt(2)
sans préfixe. Utile quand on n'a besoin
que de quelques fonctions et qu'on veut
éviter le préfixe.

]]> Provoque une erreur, sqrt devant rester préfixé

]]> Erreur : la syntaxe est parfaitement
valide ; c'est même elle qui permet de se
passer du préfixe math..

]]> Renomme le module math en sqrt pour la suite

]]> Le renommage à
l'importation utilise
le mot-clé as, par
exemple import math as
m. La syntaxe from ...
import ne renomme rien,
elle expose un symbole
précis.

]]> Modules Python — Q05 : Constante pi Comment obtenir la valeur de π en Python ?

]]> Constantes utiles dans math : math.pi,
math.e, math.inf, math.nan.

]]> 1.0 0.0 0 true true abc math.PI

]]> Erreur : Python distingue majuscules et
minuscules ; math.PI n'existe pas
(AttributeError). La constante s'écrit
math.pi.

]]> math.pi

]]> Bonne réponse : après import math,
math.pi vaut environ 3.141592653589793,
la meilleure approximation flottante
disponible.

]]> Math.pi

]]> Erreur : Math avec une majuscule est
l'objet de JavaScript ; en Python le module
s'appelle math (NameError sinon).

]]> math.pi()

]]> Erreur : math.pi est une constante (un
flottant), pas une fonction : les
parenthèses provoquent TypeError
(« 'float' object is not callable »).

]]> Modules Python — Q06 : Module random Quel module de la bibliothèque standard permet
de générer des nombres aléatoires ?

]]> random est très utilisé en NSI Première
pour les jeux, les simulations, le tirage
aléatoire.

]]> 1.0 0.0 0 true true abc time

]]> Erreur : time sert à mesurer ou à attendre une durée,
par exemple avec time.time(), pas à tirer des
nombres au hasard.

]]> math

]]> Erreur : math est pour les fonctions
mathématiques classiques.

]]> random

]]> Bonne réponse : random.randint(a, b),
random.choice(liste), random.shuffle(...),
etc.

]]> stochastic

]]> Erreur : pas de module standard de ce nom.

]]> Modules Python — Q07 : Tirage aléatoire Que fait random.randint(1, 6) ?

]]> Distinction subtile : random.randint(a, b)
→ bornes incluses ; random.randrange(a,
b) → b exclue (comme range).

]]> 1.0 0.0 0 true true abc Renvoie 6 (le maximum)

]]> Erreur : c'est aléatoire, pas
systématiquement le max.

]]> Renvoie une liste de 6 éléments

]]> Erreur : un seul entier.

]]> Renvoie un nombre flottant entre 1 et 6

]]> Erreur : randint renvoie un entier.

]]> Renvoie un entier aléatoire entre 1 et 6, inclus

]]> Bonne réponse : simule un dé à 6 faces.
Attention : contrairement à range, les
deux bornes sont incluses.

]]> Modules Python — Q08 : Alias avec as Que fait import math as m ?

]]> L'alias ne change rien au contenu du module : il
raccourcit seulement le préfixe à écrire devant
chaque fonction, ce qui allège le code quand le
module est utilisé souvent.

]]> 1.0 0.0 0 true true abc Importe deux modules, math et m

]]> Erreur : un seul module est chargé ; m n'est
qu'un second nom pour le désigner.

]]> Importe math mais le rend accessible sous le nom m

]]> Bonne réponse : as m crée un alias. On
écrit ensuite m.sqrt(2) ; le nom math seul
n'est pas défini et math.sqrt(2) lève
NameError. Pratique pour raccourcir un nom
de module long.

]]> Provoque une erreur de syntaxe à cause du mot as

]]> Erreur : la syntaxe import x as y est
valide et courante.

]]> Importe seulement la fonction m du module math

]]> Erreur : c'est tout math qui est importé,
simplement accessible via m. Importer un
seul nom s'écrit from math import sqrt.

]]> Modules Python — Q09 : Bibliothèque standard Que signifie « bibliothèque standard de Python » ?

]]> Un module de la bibliothèque standard, comme
math ou random, s'importe sans aucune
installation préalable : il suffit d'écrire
import math.

]]> 1.0 0.0 0 true true abc Une norme ISO obligatoire

]]> Erreur : pas de normalisation officielle.

]]> La documentation de référence officielle du langage

]]> Confusion : la bibliothèque standard est un
ensemble de modules, pas la doc.

]]> Les modules livrés avec Python, sans installation

]]> Bonne réponse : math, random, csv ou
time sont prêts à l'emploi, sans rien
installer. C'est l'une des grandes forces
de Python.

]]> Les modules que l'on écrit soi-même pour son projet

]]> Erreur : un fichier .py écrit pour son projet
est bien un module, mais il ne fait pas partie
de la bibliothèque standard, qui regroupe les
modules fournis avec Python.

]]> Modules Python — Q10 : Exemple complet 
import math
print(math.sqrt(16))

Que produit ce code ?

]]> Pour un entier, utiliser int(math.sqrt(16))
ou math.isqrt(16) (entier directement, sans
passer par un flottant).

]]> 1.0 0.0 0 true true abc Affiche 16.0

]]> Erreur : sqrt calcule la racine, pas
l'identité.

]]> Affiche 4.0

]]> Bonne réponse : math.sqrt(16) = 4.0
(flottant, même pour un carré parfait).

]]> Lève une erreur

]]> Erreur : code valide.

]]> Affiche 4

]]> Pas tout à fait : sqrt renvoie un
flottant (4.0), pas un entier.

]]> Modules Python — Q11 : Espace de noms Pourquoi est-il déconseillé d'utiliser
from math import * ?

]]> Bonne pratique : import math (préfixe) ou
from math import sqrt, pi (sélectif).
Éviter from x import * sauf pour des
modules conçus pour cela.

]]> 1.0 0.0 0 true true abc Parce que ce mode d'importation est nettement trop lent à l'exécution

]]> Erreur : performance équivalente.

]]> Parce que les noms importés peuvent masquer des fonctions existantes

]]> Bonne réponse : tous les noms du module
sont importés d'un coup (collisions
possibles). Par exemple, si vous aviez une
variable pow, elle serait écrasée par
math.pow. Source de bugs subtils.

]]> Parce que cette syntaxe est interdite depuis Python 3

]]> Erreur : la syntaxe reste parfaitement
autorisée, elle est seulement déconseillée.

]]> Parce que seule la première fonction du module est importée

]]> Erreur : c'est tout l'inverse, l'étoile
importe tous les noms publics du
module d'un seul coup.

]]> Modules Python — Q12 : Créer son module Comment créer son propre module
mes_outils.py et l'importer ?

]]> Cette simplicité est l'un des grands atouts
de Python pour la modularité. Un projet est
naturellement organisé en plusieurs fichiers
.py.

]]> 1.0 0.0 0 true true abc Il faut placer un mot-clé module au début du fichier source

]]> Erreur : aucun mot-clé spécial n'est
nécessaire, tout fichier .py est
d'office un module.

]]> Il faut compiler mes_outils.py avant de pouvoir l'importer

]]> Erreur : Python est interprété, aucune
compilation explicite n'est demandée au
programmeur.

]]> Écrire le fichier, puis faire import mes_outils

]]> Bonne réponse : tout fichier .py est un
module. On crée mes_outils.py avec ses
fonctions, et import mes_outils suffit.
Aucune déclaration spéciale n'est
nécessaire.

]]> Il faut placer le fichier dans le dossier d'installation de Python

]]> Erreur : un module placé dans le même dossier
que le programme qui l'importe est trouvé
directement ; aucun déplacement n'est
nécessaire.

]]> Modules Python — Q13 : Lire la documentation de uniform La documentation du module random indique :
« random.uniform(a, b) renvoie un nombre flottant choisi au
hasard entre a et b, bornes comprises. »
Après import random, quelle expression simule une température
à virgule comprise entre $18$ et $25$ degrés ?

]]> Lire la documentation suffit à choisir la bonne fonction :
uniform(a, b) pour un flottant entre deux bornes,
randint(a, b) pour un entier, random() sans argument
pour un flottant entre $0$ et $1$.

]]> 1.0 0.0 0 true true abc random.uniform(18, 25)

]]> Bonne réponse : d'après la documentation,
uniform(18, 25) renvoie un flottant compris
entre $18$ et $25$, par exemple 21.73.

]]> random.randint(18, 25)

]]> Erreur : randint ne renvoie que des entiers
($18$, $19$, …, $25$). La température n'aurait
jamais de partie décimale.

]]> random.random(18, 25)

]]> Erreur : random.random() ne prend aucun
argument et renvoie un flottant entre $0$ et $1$.
Cet appel lève TypeError.

]]> 18 + random.random() * 25

]]> Erreur : random.random() * 25 est compris entre
$0$ et $25$, donc le résultat va de $18$ à $43$.
Il faudrait multiplier par $25 - 18 = 7$.

]]> Modules Python — Q14 : Choix aléatoire Quelle fonction du module random permet de
choisir un élément au hasard dans une liste ?

]]> Autres fonctions utiles : random.choices
(avec poids), random.sample (sans
remise), random.shuffle (mélange en place).

]]> 1.0 0.0 0 true true abc random.select(liste)

]]> Erreur : pas de fonction de ce nom.

]]> random.random(liste)

]]> Erreur : random.random() renvoie un
flottant entre 0 et 1, sans paramètre.

]]> random.choice(liste)

]]> Bonne réponse : choice renvoie un
élément aléatoire de la liste (chaque
élément a la même probabilité d'être
choisi).

]]> random.pick(liste)

]]> Erreur : la fonction n'a pas ce nom.

]]> Modules Python — Q15 : Réutiliser la fonction d'un camarade Pour son projet, Lina veut utiliser la fonction moyenne du
module stats.py écrit par un camarade, sans lire son code.
Que lui faut-il connaître pour l'appeler correctement ?

]]> Un module sert à réutiliser du code. Pour appeler une de ses
fonctions, il suffit de connaître sa spécification : nom,
paramètres, préconditions éventuelles et valeur renvoyée.
C'est ce que doit fournir sa documentation.

]]> 1.0 0.0 0 true true abc Sa spécification : ses paramètres et ce qu'elle renvoie

]]> Bonne réponse : le nom de la fonction, ses paramètres
(avec leurs éventuelles préconditions) et la valeur
renvoyée suffisent. C'est l'intérêt d'un module bien
documenté : on le réutilise sans en lire le code.

]]> Le nom des variables utilisées dans le corps de la fonction

]]> Erreur : ces variables sont internes à la fonction.
Lina n'en a pas besoin, et le camarade peut les
renommer sans rien changer pour elle.

]]> Le nom du dossier où le camarade a écrit le module

]]> Erreur : ce qui compte, c'est que stats.py soit
dans le dossier du programme de Lina au moment de
l'import, pas l'endroit où il a été écrit.

]]> Rien : import stats affiche la liste des paramètres attendus

]]> Erreur : import stats charge le module sans rien
afficher sur ses fonctions. C'est leur documentation
qui indique comment les appeler.

]]> Modules Python — Q16 : Documentation interactive Comment obtenir l'aide d'une fonction d'un
module en mode interactif ?

]]> help(math.sqrt) fonctionne après
import math. Pour une lecture plus
complète, la documentation officielle
(docs.python.org) décrit chaque module.

]]> 1.0 0.0 0 true true abc help(math.sqrt)

]]> Bonne réponse : la fonction native help
affiche la documentation de la fonction
reçue en argument. Très utile pour
découvrir un module.

]]> man math.sqrt

]]> Erreur : man est une commande Unix.

]]> info(math.sqrt)

]]> Erreur : pas de fonction info en Python.

]]> math.sqrt.help()

]]> Erreur : help n'est pas rangée dans la
fonction sqrt ; c'est une fonction native
qui reçoit en argument la fonction à
documenter. Cet appel lève AttributeError.

]]> Modules Python — Q17 : Importation sélective Quel code utilise pi correctement après
from math import pi ?

]]> import math → math.pi ; from math import
pi → pi. Choisir selon ses préférences.

]]> 1.0 0.0 0 true true abc math.pi

]]> Erreur : avec from ... import, on
n'utilise pas le préfixe.

]]> pi

]]> Bonne réponse : pi est importé
directement dans l'espace de noms local.
On peut écrire 2 * pi.

]]> import.pi

]]> Erreur : syntaxe invalide.

]]> from.pi

]]> Erreur : syntaxe invalide.

]]> Modules Python — Q18 : Conflit de noms 
from math import sqrt

def sqrt(x):
    return x ** 0.5

print(sqrt(16))

Quelle fonction est appelée ?

]]> Bonne pratique : éviter de redéfinir des
noms importés. Si on doit le faire, l'import
avec préfixe (import math) protège.

]]> 1.0 0.0 0 true true abc La fonction sqrt importée du module math

]]> Erreur : la définition locale, postérieure
à l'import, écrase le nom importé.

]]> Les deux fonctions sqrt, appelées l'une après l'autre

]]> Erreur : un nom ne désigne qu'une seule
fonction à la fois ; un seul appel a lieu.

]]> La fonction sqrt définie localement

]]> Bonne réponse : la dernière définition
gagne, et le programme affiche 4.0. Les
deux fonctions calculent ici la même chose
(la racine carrée), donc le résultat est
identique, mais en général c'est un piège :
la définition locale masque silencieusement
l'import.

]]> Aucune, Python lève une erreur de conflit de noms

]]> Erreur : Python ne signale rien, il écrase
silencieusement l'ancien nom. C'est
précisément ce qui rend ce piège dangereux.

]]> Modules Python — Q19 : Reproductibilité Pourquoi utilise-t-on random.seed(42) ?

]]> Pour les simulations et les jeux, fixer
la graine permet de rejouer exactement la
même suite de tirages pendant la mise au
point.

]]> 1.0 0.0 0 true true abc Pour rendre les tirages plus aléatoires

]]> Erreur : c'est l'inverse, on les rend
déterministes.

]]> Pour accélérer significativement le générateur de nombres

]]> Erreur : pas d'effet sur la performance.

]]> Pour rendre les tirages reproductibles

]]> Bonne réponse : même graine, même séquence
de tirages. Utile pour le débogage, les
tests, la reproductibilité scientifique.

]]> Pour limiter les tirages aux valeurs inférieures à 42

]]> Erreur : la graine initialise l'état du
générateur, elle ne borne pas les valeurs
produites.

]]> Modules Python — Q20 : Imports d'un module importé Le fichier outils.py contient :

import math

def aire_disque(r):
    return math.pi * r ** 2

Dans le même dossier, le programme main.py
contient :

import outils

print(outils.aire_disque(2))
print(math.pi)

Que se passe-t-il quand on exécute main.py ?

]]> Chaque module a son propre espace de noms. Les
imports faits dans outils.py ne sont visibles que
dans outils.py : pour utiliser math.pi dans
main.py, il faut y écrire aussi import math.

]]> 1.0 0.0 0 true true abc Les deux lignes s'affichent, car import outils importe aussi math

]]> Erreur : l'import de math a lieu dans
l'espace de noms d'outils, pas dans celui
de main.py. Le nom math n'existe pas dans
le programme principal, et print(math.pi)
lève NameError.

]]> Le premier affichage échoue, car main.py n'a pas importé math

]]> Erreur : aire_disque est définie dans
outils.py, où math est bien importé. Elle
s'exécute sans problème et affiche
12.566370614359172. C'est la ligne suivante
qui échoue.

]]> Le premier affichage réussit, puis print(math.pi) lève NameError

]]> Bonne réponse : 12.566370614359172 s'affiche,
car aire_disque trouve math dans son propre
module. Puis main.py cherche le nom math
dans son espace de noms, où il n'a jamais été
importé, et Python lève
NameError: name 'math' is not defined.

]]> La ligne import outils échoue, car un module ne peut pas en importer un autre

]]> Erreur : un module peut importer d'autres
modules, c'est même courant. import outils
réussit et exécute import math à l'intérieur
d'outils.

]]> Modules Python — Q21 : Une précondition vérifiée dans un module Le fichier geometrie.py contient :
def aire_rectangle(longueur, largeur):
    assert longueur >= 0 and largeur >= 0
    return longueur * largeur

Dans le même dossier, main.py contient :
import geometrie
print(geometrie.aire_rectangle(4, 3))
print(geometrie.aire_rectangle(-4, 3))

Que se passe-t-il à l'exécution de main.py ?

]]> Une assertion placée en tête de fonction garantit sa
précondition, que la fonction soit appelée depuis son
propre fichier ou depuis un programme qui importe le
module. Un appel qui ne la respecte pas lève
AssertionError.

]]> 1.0 0.0 0 true true abc 12 s'affiche, puis le second appel lève AssertionError

]]> Bonne réponse : le premier appel respecte la
précondition et affiche 12. Au second,
longueur >= 0 est faux : l'assertion échoue,
Python lève AssertionError et le programme
s'arrête.

]]> 12 puis -12 : les assertions d'un module importé sont ignorées

]]> Erreur : une fonction importée s'exécute
exactement comme si elle était écrite dans
main.py. L'assertion est vérifiée à chaque
appel et échoue pour -4.

]]> Rien ne s'affiche : l'erreur survient dès la ligne import geometrie

]]> Erreur : l'import ne fait que définir la
fonction ; l'assertion n'est évaluée qu'à
l'appel. Le premier appel affiche donc 12
avant que le second échoue.

]]> 12 puis 0 : l'assertion remplace la longueur négative par zéro

]]> Erreur : assert ne corrige aucune valeur. Elle
vérifie une condition et arrête le programme
avec AssertionError si celle-ci est fausse.

]]> Modules Python — Q22 : La précondition de random.choice La documentation du module random indique :

« random.choice(seq) renvoie un élément choisi au hasard dans
la séquence non vide seq. »

Après import random, lequel de ces appels ne respecte pas
cette précondition ?

]]> Une précondition décrit ce que doivent vérifier les
arguments. Pour random.choice, seul compte le fait que
la séquence contienne au moins un élément, quelles que
soient les valeurs qu'elle contient.

]]> 1.0 0.0 0 true true abc random.choice([])

]]> Bonne réponse : la liste vide ne contient aucun
élément à choisir. La précondition « non vide »
n'est pas respectée, et Python lève IndexError.

]]> random.choice("abc")

]]> Erreur : une chaîne de caractères est une
séquence, indexée comme une liste. L'appel est
valide et renvoie "a", "b" ou "c".

]]> random.choice(["pile"])

]]> Erreur : une liste d'un seul élément n'est pas
vide. L'appel est valide et renvoie toujours
"pile".

]]> random.choice([0, 0])

]]> Erreur : la liste contient deux éléments, même
s'ils valent $0$. Elle n'est pas vide, et l'appel
renvoie 0.

]]> Modules Python — Q23 : Deux imports étoilés Pourquoi le code suivant peut-il être
problématique ?
from random import *
from math import *

]]> Préférer import math et import random, puis
écrire math.sqrt ou random.randint : le
préfixe indique d'où vient chaque nom et évite
tout écrasement.

]]> 1.0 0.0 0 true true abc Parce que des fonctions de même nom s'écrasent silencieusement

]]> Bonne réponse : from module import * copie
tous les noms du module dans le programme.
Si deux modules, ou le programme lui-même,
définissent un même nom, le dernier import le
remplace sans prévenir, et à la lecture on ne
sait plus d'où vient chaque fonction.

]]> Parce que ces importations sont beaucoup trop lentes à charger

]]> Erreur : le coût de chargement est
négligeable, la performance n'est pas le
problème.

]]> Parce que l'on ne peut pas importer deux modules dans un fichier

]]> Erreur : on peut importer autant de
modules qu'on veut dans un même fichier.

]]> Parce que math doit impérativement être importé avant random

]]> Erreur : Python n'impose aucun ordre
d'importation entre modules indépendants.

]]> Modules Python — Q24 : Ordre des imports Dans un fichier Python bien organisé, où
placer les import ?

]]> Convention de lecture : voir tout de suite
les dépendances en haut du fichier. Un nom
importé plus bas ne serait pas disponible pour
le code situé au-dessus.

]]> 1.0 0.0 0 true true abc À l'intérieur d'une fonction main appelée au démarrage du programme

]]> Erreur : c'est possible, mais exceptionnel.
Par convention, les imports se placent en haut
du fichier.

]]> À la fin du fichier

]]> Erreur : tous les noms importés ne seraient
pas disponibles avant.

]]> N'importe où dans le fichier

]]> Techniquement possible, mais déconseillé.

]]> En haut du fichier, avant le reste du code

]]> Bonne réponse : placés en tête, les imports
sont exécutés avant toute utilisation des noms
importés, et le lecteur voit tout de suite de
quels modules dépend le programme.

]]> Modules Python — Q25 : Synthèse Parmi les affirmations suivantes, laquelle est
fausse ?

]]> Les modules de la bibliothèque standard et ceux
que l'on écrit soi-même s'importent de la même
façon ; leurs fonctions s'utilisent avec le
préfixe du module ou après un import sélectif.

]]> 1.0 0.0 0 true true abc from math import pi importe la constante pi sans préfixe

]]> Vrai : importation sélective.

]]> La bibliothèque standard de Python contient des modules pour les fichiers, le réseau, les dates, le hasard, etc.

]]> Vrai : « batteries included », l'une des
forces de Python.

]]> Un fichier .py écrit par l'élève ne peut pas être importé comme module

]]> Faux (donc bonne réponse) : tout fichier .py
est un module. Placé dans le dossier du
programme, il s'importe avec
import nom_du_fichier, sans l'extension.

]]> import math rend les fonctions accessibles via le préfixe math.

]]> Vrai : c'est le rôle de import.

]]> Modules Python — Q26 : random.random et random.randint Quelle est la différence entre random.random() et
random.randint(a, b) ?

]]> Pour mémoriser : random.random() $\to [0\,;\, 1[$
(flottant) ; random.randint(a, b) $\to [a\,;\, b]$
(entier) ; random.randrange(a, b) $\to [a\,;\, b[$
(entier) ; random.choice(seq) $\to$ un élément de
la séquence. Pour la reproductibilité d'un tirage,
fixer random.seed(...) au début du programme.

]]> 1.0 0.0 0 true true abc Les deux renvoient un entier, random() entre 0 et 1 et randint(a, b) entre a et b

]]> Erreur : la fonction random.random() renvoie un
flottant, pas un entier (un entier entre 0 et 1
n'aurait d'ailleurs que deux valeurs possibles).
Seule randint(a, b) renvoie un entier.

]]> random() renvoie un flottant de $[0\,;\, 1[$, randint(a, b) un entier de $[a\,;\, b]$

]]> Bonne réponse : random.random() produit un
flottant tiré uniformément, strictement
inférieur à $1$, tandis que
random.randint(a, b) renvoie un entier avec
les deux bornes incluses (alors que la
plupart des intervalles Python excluent la
borne droite).

]]> random.randint(a, b) renvoie un entier de $[a\,;\, b[$, borne b exclue

]]> Erreur : c'est précisément la particularité de
randint parmi les fonctions du module : la borne
droite est incluse. Pour exclure la borne, il
faudrait utiliser random.randrange(a, b).

]]> random.random() renvoie un flottant de $[0\,;\, 1]$, borne $1$ comprise

]]> Erreur : la borne droite est exclue :
random.random() peut renvoyer $0$ mais jamais
exactement $1$, comme la plupart des intervalles
en Python.

]]> Modules Python — Q27 : Fonctions du module math Parmi les expressions suivantes, laquelle ne renvoie
pas $5$ après l'instruction import math ?

]]> Quelques fonctions usuelles du module math :
sqrt (racine carrée), floor et ceil
(arrondis vers le bas et vers le haut).
Constante : math.pi.

]]> 1.0 0.0 0 true true abc math.ceil(4.3)

]]> La fonction ceil arrondit vers le haut. Pour
$4{,}3$, le résultat est $5$.

]]> math.floor(4.9)

]]> Bonne réponse : math.floor arrondit vers le
bas, même quand la partie décimale est proche
de $1$. Pour $4{,}9$, le résultat est $4$, et
non $5$.

]]> math.sqrt(25)

]]> La racine carrée de $25$ vaut bien $5$. Cette
expression renvoie donc $5$ (au flottant
$5{,}0$ près).

]]> math.floor(5.7)

]]> La fonction floor arrondit vers le bas (partie
entière inférieure). Pour $5{,}7$, le résultat
est $5$.

]]> Modules Python — Q28 : Mesurer une durée d'exécution On souhaite mesurer la durée d'exécution d'une
portion de code. Quelle structure utilise le module
time de manière correcte ?

]]> La différence entre deux appels à time.time()
mesure une durée réelle : elle peut varier
légèrement d'une exécution à l'autre, selon ce
que fait l'ordinateur au même moment.

]]> 1.0 0.0 0 true true abc import time debut = time.time() # ... code à mesurer ... duree = time.time()]]> Erreur : il manque la soustraction finale.
Ici duree contient l'heure de fin (nombre de
secondes depuis 1970), pas la durée écoulée :
il faut écrire duree = time.time() - debut.

]]> import time debut = time.time() # ... code à mesurer ... duree = debut - time.time()]]> Erreur : la soustraction est dans le mauvais
sens. debut est antérieur à l'heure de fin,
donc duree est négative. Il faut écrire
time.time() - debut.

]]> import time debut = time.time() # ... code à mesurer ... duree = time.time() - time.time()]]> Erreur : debut n'est jamais utilisé. Les deux
appels à time.time() sont quasi simultanés :
duree vaut presque 0 quel que soit le code
mesuré.

]]> import time debut = time.time() # ... code à mesurer ... duree = time.time() - debut]]> Bonne réponse : time.time() renvoie le nombre
de secondes écoulées depuis le $1^{\text{er}}$
janvier $1970$. La différence entre deux
appels donne la durée écoulée en secondes
(avec une précision de l'ordre de la
microseconde sur les systèmes modernes).

]]> Modules Python — Q29 : Le préfixe après un import sélectif Après from math import sqrt, que produit math.sqrt(16) ?

]]> import math donne accès à math.sqrt ; from math import sqrt
donne accès à sqrt seul. Les deux formes ne se mélangent pas.

]]> 1.0 0.0 0 true true abc Une erreur, le nom math n'étant pas importé

]]> Bonne réponse : from math import sqrt n'introduit que le nom
sqrt. Le module math lui-même reste inconnu, et il faut
écrire sqrt(16).

]]> 4.0, math restant accessible

]]> Erreur : sqrt(16) donnerait 4.0, mais pas math.sqrt, le
nom math étant absent.

]]> 16, la racine n'étant pas appliquée

]]> Erreur : aucune racine n'est calculée, l'expression échoue avant.

]]> 4, la racine d'un entier étant un entier

]]> Erreur : outre le nom manquant, sqrt renvoie un flottant.

]]> Modules Python — Q30 : Un module importé deux fois Un programme contient deux fois la ligne import random, dans deux
fichiers différents du projet. Que se passe-t-il ?

]]> Chaque fichier qui utilise un module l'importe ; Python se charge
de ne le lire qu'une seule fois.

]]> 1.0 0.0 0 true true abc Le module n'est chargé qu'une fois, le second import le réutilisant

]]> Bonne réponse : Python garde en mémoire les modules déjà
chargés. Un nouvel import ne fait que rendre le nom
disponible dans le fichier courant.

]]> Une erreur, un module ne pouvant être importé qu'une fois

]]> Erreur : importer plusieurs fois est permis et courant dans un
projet à plusieurs fichiers.

]]> Le module est chargé deux fois et occupe deux fois plus de mémoire

]]> Erreur : le second import retrouve le module déjà chargé.

]]> Les fonctions du module sont dupliquées sous deux noms

]]> Erreur : les noms restent les mêmes, random.randint par
exemple.

]]> Modules Python — Q31 : Arrondir vers le bas ou vers le haut Après import math, que valent math.floor(3.7) et
math.ceil(3.7) ?

]]> math.floor, math.ceil et round arrondissent différemment ; le
choix dépend de ce que l'on veut compter.

]]> 1.0 0.0 0 true true abc 3 et 4

]]> Bonne réponse : floor arrondit vers le bas, ceil vers le
haut, et les deux renvoient un entier.

]]> 4 et 3

]]> Erreur : floor est le plancher, ceil le plafond.

]]> 3 et 3

]]> Erreur : ceil monte à l'entier supérieur dès que la partie
décimale n'est pas nulle.

]]> 3.7 et 3.7

]]> Erreur : les deux fonctions renvoient des entiers.

]]> Modules Python — Q32 : Le module pour lire un fichier CSV Quel module de la bibliothèque standard facilite la lecture d'un
fichier CSV ?

]]> La bibliothèque standard couvre les besoins courants : csv,
math, random, time sont parmi les modules les plus utilisés en
première.

]]> 1.0 0.0 0 true true abc csv

]]> Bonne réponse : csv.reader découpe chaque ligne en champs en
tenant compte du séparateur et des guillemets.

]]> math

]]> Erreur : math fournit des fonctions mathématiques.

]]> random

]]> Erreur : random sert aux tirages aléatoires.

]]> time

]]> Erreur : time mesure des durées et donne l'heure.

]]> Modules Python — Q33 : La racine d'un nombre négatif Après import math, que produit math.sqrt(-1) ?

]]> Les fonctions d'un module ont des préconditions, indiquées par leur
documentation : les respecter évite les erreurs à l'exécution.

]]> 1.0 0.0 0 true true abc Une erreur, l'argument devant être positif

]]> Bonne réponse : la fonction a pour précondition un argument
positif ou nul. Elle refuse -1 au lieu de renvoyer un résultat
sans sens pour les réels.

]]> -1.0, l'argument étant renvoyé tel quel

]]> Erreur : aucun réel n'a pour carré -1, et la fonction ne
renvoie pas l'argument.

]]> 1.0, le signe étant ignoré

]]> Erreur : sqrt n'ignore pas le signe, elle signale l'erreur.

]]> 0.0, valeur par défaut en cas de problème

]]> Erreur : 0.0 est la racine de 0, pas de -1.

]]> Modules Python — Q34 : Le nom d'un module écrit soi-même Lina a écrit ses fonctions dans un fichier outils.py, placé dans
le même dossier que son programme. Comment les importe-t-elle ?

]]> Tout fichier .py est un module : il suffit qu'il soit dans le
dossier du programme pour être importé par son nom.

]]> 1.0 0.0 0 true true abc import outils

]]> Bonne réponse : le nom du module est le nom du fichier sans
l'extension .py. Les fonctions s'appellent ensuite
outils.nom_de_fonction.

]]> import outils.py

]]> Erreur : l'extension ne fait pas partie du nom du module ; cette
écriture chercherait un sous-module py.

]]> import "outils.py"

]]> Erreur : import attend un nom, pas une chaîne de caractères.

]]> open("outils.py")

]]> Erreur : open lit le texte du fichier, il n'exécute pas son
code.

]]> Modules Python — Q35 : Ce qui s'exécute à l'import Le fichier outils.py contient une définition de fonction suivie
de print("module chargé"). Que se passe-t-il quand un programme
exécute import outils ?

]]> Un module bien écrit ne contient que des définitions et des
constantes, pour que son import n'ait aucun effet visible.

]]> 1.0 0.0 0 true true abc Le message s'affiche, le code du module étant exécuté

]]> Bonne réponse : importer un module exécute son fichier de haut
en bas. Les définitions créent les fonctions, et les autres
instructions, comme ce print, s'exécutent aussi.

]]> Rien ne s'affiche, seules les définitions étant lues

]]> Erreur : Python ne distingue pas les définitions du reste, il
exécute tout.

]]> Le message s'affiche à chaque appel d'une fonction du module

]]> Erreur : le print est au niveau du module, pas dans une
fonction ; il ne s'exécute qu'à l'import.

]]> Une erreur, un module ne pouvant contenir que des fonctions

]]> Erreur : un module peut contenir n'importe quelle instruction,
même si l'usage est d'y mettre surtout des définitions.

]]> Modules Python — Q36 : Un module qui dépend d'un autre Le module stats.py de Sami commence par import graphiques, un
module écrit par un camarade. Lina copie stats.py seul sur son
ordinateur et exécute import stats. Que se passe-t-il ?

]]> Un module hérite des dépendances des modules qu'il importe ;
partager son code suppose de fournir aussi les modules dont il
dépend.

]]> 1.0 0.0 0 true true abc Une erreur dès l'import, graphiques étant introuvable

]]> Bonne réponse : importer stats exécute sa première ligne, qui
tente d'importer graphiques. Faute de ce fichier, l'import
échoue avant que stats ne soit utilisable.

]]> stats s'importe, mais ses fonctions échouent à l'appel

]]> Erreur : l'échec survient dès la ligne import graphiques, donc
dès l'import de stats.

]]> Python recherche graphiques.py sur l'ordinateur de Sami

]]> Erreur : Python ne cherche que dans les dossiers de la machine
où il s'exécute.

]]> stats s'importe normalement, graphiques étant ignoré

]]> Erreur : un import qui échoue arrête l'exécution du module.

]]>