\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Modules Python}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en B
\begin{frame}[fragile]{Question 1 \textemdash{} Qu'est-ce qu'un module ?}
    En Python, qu'est-ce qu'un \textbf{module} ?\medskip
    \begin{itemize}
        \item[A.] Un type de données
        \item[\alert<2>{B.}] \alert<2>{Un fichier \texttt{.py} contenant des fonctions, des classes ou des constantes réutilisables}
        \item[C.] Une boucle imbriquée
        \item[D.] Une variable globale
    \end{itemize}
\end{frame}

% Q2 - Réponse en D
\begin{frame}[fragile]{Question 2 \textemdash{} Import}
    Comment \textbf{importer} le module \texttt{math} en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{require math}
        \item[B.] \texttt{use math}
        \item[C.] \texttt{include math}
        \item[\alert<2>{D.}] \alert<2>{\texttt{import math}}
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Utilisation après import}
    Après \texttt{import math}, comment appelle-t-on la
fonction \texttt{sqrt} (racine carrée) ?\medskip
    \begin{itemize}
        \item[A.] \texttt{math->sqrt(2)}
        \item[\alert<2>{B.}] \alert<2>{\texttt{math.sqrt(2)}}
        \item[C.] \texttt{sqrt(2)}
        \item[D.] \texttt{math::sqrt(2)}
    \end{itemize}
\end{frame}

% Q4 - Réponse en B
\begin{frame}[fragile]{Question 4 \textemdash{} from import}
    Que fait \texttt{from math import sqrt} ?\medskip
    \begin{itemize}
        \item[A.] Importe tout le module \texttt{math}
        \item[\alert<2>{B.}] \alert<2>{Importe seulement la fonction \texttt{sqrt}, qui devient appelable directement comme \texttt{sqrt(2)}}
        \item[C.] Cela ne fonctionne pas
        \item[D.] Renomme \texttt{math} en \texttt{sqrt}
    \end{itemize}
\end{frame}

% Q5 - Réponse en B
\begin{frame}[fragile]{Question 5 \textemdash{} Constante pi}
    Comment obtenir la valeur de π en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{PI}
        \item[\alert<2>{B.}] \alert<2>{\texttt{math.pi} (après \texttt{import math})}
        \item[C.] \texttt{3.14}
        \item[D.] \texttt{pi}
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile]{Question 6 \textemdash{} Module random}
    Quel module de la bibliothèque standard permet
de générer des nombres aléatoires ?\medskip
    \begin{itemize}
        \item[A.] \texttt{numpy}
        \item[B.] \texttt{math}
        \item[\alert<2>{C.}] \alert<2>{\texttt{random}}
        \item[D.] \texttt{stochastic}
    \end{itemize}
\end{frame}

% Q7 - Réponse en D
\begin{frame}[fragile]{Question 7 \textemdash{} Tirage aléatoire}
    Que fait \texttt{random.randint(1, 6)} ?\medskip
    \begin{itemize}
        \item[A.] Renvoie 6 (le maximum)
        \item[B.] Renvoie une liste de 6 éléments
        \item[C.] Renvoie un nombre flottant entre 1 et 6
        \item[\alert<2>{D.}] \alert<2>{Renvoie un entier aléatoire entre 1 et 6, inclus}
    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Alias avec as}
    Que fait \texttt{import numpy as np} ?\medskip
    \begin{itemize}
        \item[A.] Importe deux modules \texttt{numpy} et \texttt{np}
        \item[\alert<2>{B.}] \alert<2>{Importe \texttt{numpy} mais le renomme en \texttt{np}}
        \item[C.] Erreur de syntaxe
        \item[D.] Importe seulement \texttt{np} (pas \texttt{numpy} au complet)
    \end{itemize}
\end{frame}

% Q9 - Réponse en C
\begin{frame}[fragile]{Question 9 \textemdash{} Bibliothèque standard}
    Que signifie « bibliothèque standard de Python » ?\medskip
    \begin{itemize}
        \item[A.] Une norme ISO obligatoire
        \item[B.] La documentation officielle
        \item[\alert<2>{C.}] \alert<2>{Les modules livrés avec Python, disponibles sans installation supplémentaire}
        \item[D.] La bibliothèque physique d'Anthropic
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Exemple complet}
    \begin{lstlisting}
import math
print(math.sqrt(16))
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] Affiche \texttt{16.0}
        \item[B.] Affiche \texttt{4.0}
        \item[C.] Lève une erreur
        \item[D.] Affiche \texttt{4}
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Exemple complet}
    \begin{lstlisting}
import math
print(math.sqrt(16))
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] Affiche \texttt{16.0}
        \item[\alert{B.}] \alert{Affiche \texttt{4.0}}
        \item[C.] Lève une erreur
        \item[D.] Affiche \texttt{4}
    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile]{Question 11 \textemdash{} Espace de noms}
    Pourquoi est-il \textbf{déconseillé} d'utiliser
\texttt{from math import *} ?\medskip
    \begin{itemize}
        \item[A.] Parce que c'est trop lent
        \item[\alert<2>{B.}] \alert<2>{Parce que cela importe tous les noms dans le scope global, ce qui peut masquer des variables/fonctions existantes (collisions)}
        \item[C.] Parce que c'est interdit par Python
        \item[D.] Parce que cela ne fonctionne pas
    \end{itemize}
\end{frame}

% Q12 - Réponse en C
\begin{frame}[fragile]{Question 12 \textemdash{} Créer son module}
    Comment créer son propre module
\texttt{mes\_outils.py} et l'importer ?\medskip
    \begin{itemize}
        \item[A.] Il faut un mot-clé \texttt{module} dans le fichier
        \item[B.] Il faut compiler le module avant de l'importer
        \item[\alert<2>{C.}] \alert<2>{Créer un fichier \texttt{mes\_outils.py} contenant des fonctions, puis dans un autre fichier du même répertoire : \texttt{import mes\_outils}}
        \item[D.] Il faut publier le module sur PyPI
    \end{itemize}
\end{frame}

% Q13 - Réponse en C
\begin{frame}[fragile]{Question 13 \textemdash{} Import une seule fois}
    Si l'on écrit \texttt{import math} deux fois dans le
même programme, que se passe-t-il ?\medskip
    \begin{itemize}
        \item[A.] Cela lève une erreur
        \item[B.] Le module est dupliqué en mémoire
        \item[\alert<2>{C.}] \alert<2>{Le module n'est chargé qu'une seule fois ; la deuxième instruction ne fait rien}
        \item[D.] Le module est rechargé à chaque fois (lent)
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile]{Question 14 \textemdash{} Choix aléatoire}
    Quelle fonction du module \texttt{random} permet de
choisir un élément au hasard dans une liste ?\medskip
    \begin{itemize}
        \item[A.] \texttt{random.select(liste)}
        \item[B.] \texttt{random.random(liste)}
        \item[\alert<2>{C.}] \alert<2>{\texttt{random.choice(liste)}}
        \item[D.] \texttt{random.pick(liste)}
    \end{itemize}
\end{frame}

% Q15 - Réponse en B
\begin{frame}[fragile]{Question 15 \textemdash{} Bloc principal}
    Que signifie l'idiome \texttt{if \_\_name\_\_ == "\_\_main\_\_":} ?\medskip
    \begin{itemize}
        \item[A.] Que le programme est sans bug
        \item[\alert<2>{B.}] \alert<2>{Que le bloc s'exécute uniquement quand le fichier est lancé directement, pas quand il est importé comme module}
        \item[C.] Que le programme est en mode débogage
        \item[D.] Que la fonction \texttt{main} doit être définie
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile]{Question 16 \textemdash{} Documentation interactive}
    Comment obtenir l'aide d'une fonction d'un
module en mode interactif ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{help(math.sqrt)}}
        \item[B.] \texttt{man math.sqrt}
        \item[C.] \texttt{info(math.sqrt)}
        \item[D.] \texttt{google math.sqrt}
    \end{itemize}
\end{frame}

% Q17 - Réponse en B
\begin{frame}[fragile]{Question 17 \textemdash{} Importation sélective}
    Quel code utilise \texttt{pi} correctement après
\texttt{from math import pi} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{math.pi}
        \item[\alert<2>{B.}] \alert<2>{\texttt{pi}}
        \item[C.] \texttt{import.pi}
        \item[D.] \texttt{from.pi}
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Conflit de noms}
    \begin{lstlisting}
from math import sqrt

def sqrt(x):
    return x ** 0.5

print(sqrt(16))
\end{lstlisting}
Quelle fonction est appelée ?\medskip
    \begin{itemize}
        \item[A.] La fonction de \texttt{math} (4.0)
        \item[B.] Les deux fonctions sont appelées
        \item[C.] La fonction \texttt{sqrt} définie localement, qui retourne aussi \texttt{4.0} puisqu'elle calcule également la racine carrée
        \item[D.] Erreur : conflit de noms
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Conflit de noms}
    \begin{lstlisting}
from math import sqrt

def sqrt(x):
    return x ** 0.5

print(sqrt(16))
\end{lstlisting}
Quelle fonction est appelée ?\medskip
    \begin{itemize}
        \item[A.] La fonction de \texttt{math} (4.0)
        \item[B.] Les deux fonctions sont appelées
        \item[\alert{C.}] \alert{La fonction \texttt{sqrt} définie localement, qui retourne aussi \texttt{4.0} puisqu'elle calcule également la racine carrée}
        \item[D.] Erreur : conflit de noms
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile]{Question 19 \textemdash{} Reproductibilité}
    Pourquoi utilise-t-on \texttt{random.seed(42)} ?\medskip
    \begin{itemize}
        \item[A.] Pour rendre les tirages plus aléatoires
        \item[B.] Pour accélérer le générateur
        \item[\alert<2>{C.}] \alert<2>{Pour rendre les tirages reproductibles : avec la même graine, on obtient toujours la même séquence}
        \item[D.] Pour générer le nombre 42
    \end{itemize}
\end{frame}

% Q20 - Réponse en A
\begin{frame}[fragile]{Question 20 \textemdash{} Modules variés}
    Lequel de ces modules de la bibliothèque
standard est utilisé pour manipuler des
\textbf{fichiers JSON} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{json}}
        \item[B.] \texttt{csv}
        \item[C.] \texttt{math}
        \item[D.] \texttt{os}
    \end{itemize}
\end{frame}

% Q21 - Réponse en A
\begin{frame}[fragile]{Question 21 \textemdash{} Installer un module externe}
    Comment installe-t-on un module externe (par
exemple \texttt{numpy}) qui n'est pas dans la
bibliothèque standard ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Avec la commande \texttt{pip install numpy} (dans le terminal)}
        \item[B.] Avec \texttt{download numpy} dans Python
        \item[C.] Avec \texttt{import numpy}
        \item[D.] Il faut le télécharger manuellement et le copier
    \end{itemize}
\end{frame}

% Q22 - Réponse en D
\begin{frame}[fragile]{Question 22 \textemdash{} Package}
    Quelle est la différence entre un \textbf{module} et
un \textbf{package} en Python ?\medskip
    \begin{itemize}
        \item[A.] Un module est plus rapide
        \item[B.] Un package est un module compilé
        \item[C.] Aucune
        \item[\alert<2>{D.}] \alert<2>{Un module est un fichier \texttt{.py} ; un package est un répertoire contenant plusieurs modules (et un fichier \texttt{\_\_init\_\_.py})}
    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Pollution du namespace}
    Pourquoi le code suivant peut-il être
problématique ?
\begin{lstlisting}
from random import *
from math import *
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que les deux modules peuvent avoir des fonctions de même nom (par exemple \texttt{pow}), et le second import écrase silencieusement le premier
        \item[B.] Parce que c'est trop lent
        \item[C.] Parce que l'on ne peut pas importer plusieurs modules
        \item[D.] Parce que \texttt{math} doit être importé avant \texttt{random}
    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Pollution du namespace}
    Pourquoi le code suivant peut-il être
problématique ?
\begin{lstlisting}
from random import *
from math import *
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Parce que les deux modules peuvent avoir des fonctions de même nom (par exemple \texttt{pow}), et le second import écrase silencieusement le premier}
        \item[B.] Parce que c'est trop lent
        \item[C.] Parce que l'on ne peut pas importer plusieurs modules
        \item[D.] Parce que \texttt{math} doit être importé avant \texttt{random}
    \end{itemize}
\end{frame}

% Q24 - Réponse en D
\begin{frame}[fragile]{Question 24 \textemdash{} Ordre des imports}
    Dans un fichier Python bien organisé, où
placer les \texttt{import} ?\medskip
    \begin{itemize}
        \item[A.] Dans une fonction \texttt{main}
        \item[B.] À la fin du fichier
        \item[C.] N'importe où dans le fichier
        \item[\alert<2>{D.}] \alert<2>{En haut du fichier, regroupés (standards / externes / locaux)}
    \end{itemize}
\end{frame}

% Q25 - Réponse en C
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{from math import pi} importe la constante \texttt{pi} sans préfixe
        \item[B.] La bibliothèque standard de Python contient des modules pour les fichiers, le réseau, les dates, le hasard, etc.
        \item[\alert<2>{C.}] \alert<2>{Tout module importé est systématiquement rechargé à chaque exécution du programme}
        \item[D.] \texttt{import math} rend les fonctions accessibles via le préfixe \texttt{math.}
    \end{itemize}
\end{frame}

% Q26 - Réponse en B
\begin{frame}[fragile]{Question 26 \textemdash{} random.random et random.randint}
    Quelle est la différence entre \texttt{random.random()} et
\texttt{random.randint(a, b)} ?\medskip
    \begin{itemize}
        \item[A.] Les deux renvoient un entier compris entre 0 et 1
        \item[\alert<2>{B.}] \alert<2>{\texttt{random.random()} renvoie un flottant tiré uniformément dans $[0\,;\, 1[$ ; \texttt{random.randint(a, b)} renvoie un entier tiré uniformément dans $[a\,;\, b]$ (bornes incluses)}
        \item[C.] La fonction \texttt{random.randint(a, b)} exclut la borne \texttt{b}
        \item[D.] \texttt{random.random()} renvoie l'heure courante ; \texttt{random.randint} lit la mémoire
    \end{itemize}
\end{frame}

% Q27 - Réponse en B
\begin{frame}[fragile]{Question 27 \textemdash{} Fonctions du module math}
    Parmi les expressions suivantes, laquelle ne renvoie
\textbf{pas} $5$ après l'instruction \texttt{import math} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{math.ceil(4.3)}
        \item[\alert<2>{B.}] \alert<2>{\texttt{math.log(100)}}
        \item[C.] \texttt{math.sqrt(25)}
        \item[D.] \texttt{math.floor(5.7)}
    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} 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
\texttt{time} de manière correcte ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
import time
duree = time.mesure(code)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
import time
duree = time.now()
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
import time
duree = time.sleep(10)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
import time
debut = time.time()
# ... code à mesurer ...
duree = time.time() - debut
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} 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
\texttt{time} de manière correcte ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
import time
duree = time.mesure(code)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
import time
duree = time.now()
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
import time
duree = time.sleep(10)
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
import time
debut = time.time()
# ... code à mesurer ...
duree = time.time() - debut
\end{lstlisting}

    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
