$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 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.

]]> 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.

]]> 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.

]]> 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.

]]> 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 include math

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

]]> require math

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

]]> import math

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

]]> use math

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

]]> 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 C++ ou Ruby.

]]> sqrt(2)

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

]]> math.sqrt(2)

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

]]> math->sqrt(2)

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

]]> 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 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..

]]> 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.

]]> 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.

]]> Importe l'intégralité du module math dans le programme

]]> Erreur : on importe seulement sqrt.

]]> 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 : 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 »).

]]> math.pi

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

]]> math.PI

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

]]> 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.

]]> stochastic

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

]]> random

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

]]> 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 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.

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

]]> Erreur : un seul entier.

]]> 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 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.

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

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

]]> 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.

]]> Une norme ISO obligatoire

]]> Erreur : pas de normalisation officielle.

]]> Modules Python — Q10 : Exemple complet `python
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

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

]]> Lève une erreur

]]> Erreur : code valide.

]]> Affiche 4.0

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

]]> 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 cette syntaxe est interdite depuis Python 3

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

]]> 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 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 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 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 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 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.

]]> 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.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.random(18, 25)

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

]]> 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.pick(liste)

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

]]> random.random(liste)

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

]]> random.select(liste)

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

]]> 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).

]]> 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 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.

]]> 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.

]]> 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.

]]> 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.

]]> 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 man math.sqrt

]]> Erreur : man est une commande Unix.

]]> 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.

]]> 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.

]]> info(math.sqrt)

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

]]> 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 import.pi

]]> Erreur : syntaxe invalide.

]]> pi

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

]]> from.pi

]]> Erreur : syntaxe invalide.

]]> math.pi

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

]]> Modules Python — Q18 : Conflit de noms ``python
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 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.

]]> La fonction sqrt importée du module math

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

]]> 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.

]]> 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.

]]> 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 :

``python
import math

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

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

`python
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 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.

]]> 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.

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

Dans le même dossier, main.py contient :
python
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 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.

]]> 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.

]]> 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([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.

]]> 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([])

]]> 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.

]]> Modules Python — Q23 : Deux imports étoilés Pourquoi le code suivant peut-il être
problématique ?
`python
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 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 math doit impérativement être importé avant random

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

]]> 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 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.

]]> 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 À 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.

]]> À 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.

]]> 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 import math rend les fonctions accessibles via le préfixe math.

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

]]> 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.

]]> from math import pi importe la constante pi sans préfixe

]]> Vrai : importation sélective.

]]> 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.

]]> 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() → [0 ; 1[
(flottant) ; random.randint(a, b) → [a ; b]
(entier) ; random.randrange(a, b) → [a ; b[
(entier) ; random.choice(seq) → 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 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.

]]> 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).

]]> 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.

]]> 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.floor(5.7)

]]> La fonction floor arrondit vers le bas (partie
entière inférieure). Pour 5{,}7, le résultat
est 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(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.ceil(4.3)

]]> La fonction ceil arrondit vers le haut. Pour
4{,}3, 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 `python
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é.

]]> `python
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).

]]> `python
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.

]]> `python
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.

]]> 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 4.0, math restant accessible

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

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

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

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

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

]]> 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).

]]> 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.

]]> 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.

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

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

]]> 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 3

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

]]> 3 et 4

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

]]> 3.7 et 3.7

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

]]> 4 et 3

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

]]> 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 random

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

]]> time

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

]]> math

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

]]> csv

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

]]> 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.

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

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

]]> 1.0, le signe étant ignoré

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

]]> -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.

]]> 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.py

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

]]> 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 : 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 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, 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.

]]> 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 stats s'importe normalement, graphiques étant ignoré

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

]]> 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.

]]> 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.

]]>