$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. Pour des usages cryptographiques,
préférer secrets (plus sûr).

]]> 1.0 0.0 0 true true abc numpy

]]> Existe et a un sous-module random, mais
ce n'est pas la bibliothèque standard
(à installer séparément).

]]> 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 » ?

]]> Pour les modules externes (numpy, pandas,
matplotlib, requests...), il faut installer
avec pip install nom_du_module.

]]> 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, os,
sys, csv, json, datetime,
urllib... tous prêts à l'emploi. C'est
l'une des grandes forces de Python
(« batteries included »).

]]> La bibliothèque physique d'Anthropic

]]> La bibliothèque standard
de Python est un ensemble
de modules logiciels
maintenu par la Python
Software Foundation. Elle
n'a aucun lien avec
Anthropic ni avec une
collection physique.

]]> 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 d'abord publier le module sur PyPI pour l'importer

]]> Erreur : PyPI ne sert qu'au partage
public. Localement, le fichier suffit.

]]> Modules Python — Q13 : Import une seule fois Si l'on écrit import math deux fois dans le
même programme, que se passe-t-il ?

]]> Pour vraiment recharger un module modifié
(rare), utiliser importlib.reload. Sinon,
le cache simplifie la vie.

]]> 1.0 0.0 0 true true abc Cela lève une erreur

]]> Erreur : pas d'erreur.

]]> Le module est entièrement dupliqué une seconde fois en mémoire

]]> Erreur : un seul exemplaire en mémoire.

]]> Le module n'est chargé qu'une fois ; le second import ne fait rien

]]> Bonne réponse : Python tient un cache des
modules déjà chargés (sys.modules).
Performance optimale.

]]> Le module est rechargé à chaque fois (lent)

]]> Erreur : Python optimise.

]]> 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 : Bloc principal Que signifie l'idiome if __name__ == "__main__": ?

]]> Schéma standard pour rendre un fichier
réutilisable comme module sans déclencher
ses tests/démos lors de l'import.

]]> 1.0 0.0 0 true true abc Que le programme a passé tous ses tests sans erreur

]]> La présence de cette
condition n'apporte
aucune garantie sur la
correction du programme.
Elle distingue uniquement
un script exécutable d'un
module importable.

]]> Que le bloc s'exécute seulement si le fichier est lancé directement

]]> Bonne réponse : __name__ vaut
"__main__" en exécution directe et le
nom du module en cas d'import (le bloc est
alors ignoré). Cet idiome permet d'avoir
des fichiers à la fois modules et
scripts.

]]> Que le programme s'exécute en mode débogage pas à pas

]]> Aucun mode de débogage
n'est associé à cette
construction. La variable
__name__ reflète le
contexte d'exécution :
script lancé directement
ou module importé.

]]> Que la fonction nommée main doit obligatoirement être définie

]]> Pas tout à fait : main n'est qu'une
convention, pas obligatoire.

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

]]> Autre forme utile en interactif : ?math.sqrt
(en IPython/Jupyter). Et toujours la
documentation officielle :
docs.python.org.

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

]]> Bonne réponse : la fonction native help
affiche la docstring et les annotations
de la fonction. Très utile en exploration.

]]> man math.sqrt

]]> Erreur : man est une commande Unix.

]]> info(math.sqrt)

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

]]> google math.sqrt

]]> Aucune commande google
n'existe dans la console
Python. La documentation
intégrée s'obtient avec
la fonction help, qui
affiche directement la
docstring associée.

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

]]> Important : random n'est pas
cryptographiquement sûr (utiliser secrets
pour cela). Mais pour les simulations et
jeux, c'est parfait.

]]> 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 : Installer un module externe Comment installe-t-on un module externe (par
exemple pygame) qui n'est pas dans la
bibliothèque standard ?

]]> pip gère aussi les dépendances entre
modules. Pour un projet, un fichier
requirements.txt listant les dépendances
facilite la reproductibilité.

]]> 1.0 0.0 0 true true abc Avec pip install pygame dans le terminal

]]> Bonne réponse : pip est l'outil
d'installation officiel de Python.
pip install nom télécharge depuis PyPI
(Python Package Index).

]]> Avec l'instruction download pygame exécutée dans Python

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

]]> Avec import pygame

]]> Erreur : import charge un module déjà installé, ne l'installe pas.

]]> Il faut le télécharger manuellement et le copier

]]> C'était possible historiquement, mais
pip automatise tout cela.

]]> Modules Python — Q22 : Package Quelle est la différence entre un module et
un package en Python ?

]]> En NSI Première, on travaille surtout avec
des modules simples. Les packages sont une
structuration plus avancée pour les gros
projets.

]]> 1.0 0.0 0 true true abc Un module s'exécute plus rapidement qu'un package

]]> Erreur : il n'y a aucune différence de
performance entre les deux.

]]> Un package est un module compilé en code machine

]]> Erreur : aucune compilation en jeu ; la
différence est purement structurelle.

]]> Aucune, les deux mots désignent la même chose

]]> Erreur : ce sont deux notions différentes,
l'une est un fichier, l'autre un répertoire.

]]> Un package est un répertoire regroupant plusieurs modules

]]> Bonne réponse : un module est un fichier
.py, un package un répertoire qui regroupe
plusieurs modules. Les grandes bibliothèques
scientifiques sont organisées ainsi ; on
accède à un sous-module avec la notation
pointée, paquet.sousmodule.

]]> Modules Python — Q23 : Pollution du namespace Pourquoi le code suivant peut-il être
problématique ?
from random import *
from math import *

]]> Maxime PEP 20 : « Explicit is better than
implicit. » Préférer les imports explicites
pour la traçabilité.

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

]]> Bonne réponse : les deux modules ont par
exemple chacun une fonction pow, et le
second import écrase la première sans
prévenir. Conflit silencieux, source de
bugs très difficiles à diagnostiquer.

]]> 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.
Beaucoup d'éditeurs (et d'analyseurs
statiques) vérifient cet ordre.

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

]]> Possible (chargement paresseux) mais
exceptionnel. Convention : en haut.

]]> À 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, regroupés (standards / externes / locaux)

]]> Bonne réponse : convention PEP 8 :
d'abord les imports standards (math,
os...), puis les externes (numpy,
pandas...), puis les modules locaux du
projet, séparés par une ligne vide.

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

]]> Le cache de modules garantit la cohérence
(un seul exemplaire en mémoire) et la
performance.

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

]]> Tout module importé est systématiquement rechargé à chaque exécution du programme

]]> Faux (donc bonne réponse) : Python met
en cache les modules dans sys.modules.
Un module n'est chargé qu'une seule fois par exécution, même si on l'importe
dans plusieurs fichiers.

]]> 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
bas et haut), log (logarithme népérien),
log10 (logarithme décimal), exp (exponentielle),
sin/cos/tan (trigonométrie en radians).
Constantes : math.pi, math.e, math.inf.

]]> 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.log(100)

]]> Bonne réponse : math.log calcule le logarithme
naturel par défaut, pas le logarithme
décimal. On a $\ln(100) \approx 4{,}605$, et non
$5$. Pour le logarithme en base $10$, il faut
écrire math.log10(100) ou
math.log(100, 10).

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

]]> Pour des mesures plus précises ou de très courtes
durées, préférer time.perf_counter() à
time.time(). Pour comparer la performance de
plusieurs implémentations, le module timeit est
adapté : il exécute le code plusieurs fois et
atténue les fluctuations.

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

]]>