\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{Modularité et paradigmes}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

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

% Q1 - Réponse en D
\begin{frame}[fragile]{Question 1 \textemdash{} Modularité d'un programme}
    Qu'appelle-t-on la \textbf{modularité} d'un
programme ?\medskip
    \begin{itemize}
        \item[A.] Sa qualité esthétique
        \item[B.] Sa taille mesurée en nombre de lignes
        \item[C.] Sa rapidité d'exécution
        \item[\alert<2>{D.}] \alert<2>{Sa décomposition en modules (fonctions, classes, fichiers) cohérents et faiblement couplés entre eux}
    \end{itemize}
\end{frame}

% Q2 - Réponse en D
\begin{frame}[fragile]{Question 2 \textemdash{} Paradigme impératif}
    Qu'est-ce que le \textbf{paradigme impératif}
en programmation ?\medskip
    \begin{itemize}
        \item[A.] Une simple variante du paradigme fonctionnel
        \item[B.] Un style de programmation interdit par la loi
        \item[C.] Un paradigme inventé en $2020$
        \item[\alert<2>{D.}] \alert<2>{Un style de programmation où l'on donne des instructions à exécuter dans l'ordre, en modifiant l'état du programme par l'intermédiaire de variables}
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Paradigme fonctionnel}
    Qu'est-ce que le \textbf{paradigme
fonctionnel} en programmation ?\medskip
    \begin{itemize}
        \item[A.] Un paradigme dédié à la gestion des erreurs
        \item[\alert<2>{B.}] \alert<2>{Un style fondé sur l'évaluation de fonctions sans effet de bord, l'immuabilité des données et la composition de fonctions}
        \item[C.] Tout simplement un programme qui fonctionne correctement
        \item[D.] Le même paradigme que l'impératif
    \end{itemize}
\end{frame}

% Q4 - Réponse en D
\begin{frame}[fragile]{Question 4 \textemdash{} Paradigme objet}
    Qu'est-ce que la \textbf{programmation
orientée objet} ?\medskip
    \begin{itemize}
        \item[A.] Le fait de coder en utilisant des objets physiques
        \item[B.] Un paradigme aujourd'hui obsolète
        \item[C.] Une bibliothèque graphique
        \item[\alert<2>{D.}] \alert<2>{Un style structurant le code autour d'objets (instances de classes) qui combinent données (les attributs) et comportements (les méthodes)}
    \end{itemize}
\end{frame}

% Q5 - Réponse en C
\begin{frame}[fragile]{Question 5 \textemdash{} Abstraction}
    Qu'appelle-t-on \textbf{abstraction} en
programmation ?\medskip
    \begin{itemize}
        \item[A.] Un paradigme de programmation particulier
        \item[B.] Une notion appartenant aux mathématiques
        \item[\alert<2>{C.}] \alert<2>{Le fait de cacher les détails d'une implémentation derrière une interface simple, de sorte que l'utilisateur d'une fonction n'ait pas à savoir comment elle est codée}
        \item[D.] Une obligation imposée par la loi
    \end{itemize}
\end{frame}

% Q6 - Réponse en A
\begin{frame}[fragile]{Question 6 \textemdash{} Pourquoi découper un programme ?}
    Pourquoi \textbf{découper un programme} en
plusieurs fonctions ou modules ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour améliorer la lisibilité, la réutilisation, la testabilité et la maintenance du code}
        \item[B.] Pour gagner quelques secondes lors de la compilation
        \item[C.] Pour rendre le code plus complexe
        \item[D.] Aucune raison particulière ne le justifie
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} Paradigmes du langage Python}
    Quel paradigme \textbf{dominant} caractérise
le langage Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Python est un langage multi-paradigmes : il permet de combiner les styles impératif, objet et fonctionnel selon les besoins}
        \item[B.] Uniquement le paradigme objet
        \item[C.] Uniquement le paradigme impératif
        \item[D.] Uniquement le paradigme fonctionnel
    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Importer un module}
    En Python, comment \textbf{importe-t-on} des
fonctions définies dans un module
\texttt{outils.py} situé à côté du fichier
principal ?\medskip
    \begin{itemize}
        \item[A.] Avec une directive \texttt{include outils.py}
        \item[\alert<2>{B.}] \alert<2>{Avec \texttt{import outils} (puis \texttt{outils.fonction()}), ou avec \texttt{from outils import fonction}}
        \item[C.] Avec l'instruction \texttt{use outils}
        \item[D.] Aucune syntaxe ne permet ce type d'import
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Avantage de la réutilisation}
    Quel est le \textbf{principal avantage} de la
réutilisation de code déjà écrit ?\medskip
    \begin{itemize}
        \item[A.] Le code s'exécute plus rapidement
        \item[\alert<2>{B.}] \alert<2>{On code plus rapidement, et avec moins de bugs, car le code réutilisé a déjà été testé}
        \item[C.] Aucun avantage particulier
        \item[D.] Le code occupe moins d'espace
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile]{Question 10 \textemdash{} Décomposition typique}
    Pour calculer la moyenne d'une liste
de notes lue dans un fichier au format
CSV, quelle décomposition est la \textbf{plus
propre} ?\medskip
    \begin{itemize}
        \item[A.] N'utiliser aucune fonction
        \item[B.] Tout placer dans une seule fonction
        \item[\alert<2>{C.}] \alert<2>{Trois fonctions distinctes, par exemple \texttt{lire\_csv}, \texttt{calculer\_moyenne} et \texttt{afficher\_resultat}}
        \item[D.] Une seule fonction qui ne fait qu'un appel à \texttt{print}
    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile]{Question 11 \textemdash{} Instancier une classe}
    En Python, comment crée-t-on un objet
(une \textbf{instance}) à partir de la
classe \texttt{Voiture} ?\medskip
    \begin{itemize}
        \item[A.] Avec \texttt{v = Voiture.instance()}
        \item[\alert<2>{B.}] \alert<2>{Avec la syntaxe \texttt{v = Voiture()}}
        \item[C.] Avec \texttt{v = create(Voiture)}
        \item[D.] Avec la syntaxe \texttt{v = new Voiture()}
    \end{itemize}
\end{frame}

% Q12 - Réponse en C
\begin{frame}[fragile]{Question 12 \textemdash{} Accéder à un attribut}
    Soit l'instance
\texttt{v = Voiture("Peugeot", 2020)}. Comment
accède-t-on à l'attribut \texttt{marque} de
cet objet ?\medskip
    \begin{itemize}
        \item[A.] Avec la notation \texttt{v::marque}
        \item[B.] Avec la notation \texttt{v[marque]}
        \item[\alert<2>{C.}] \alert<2>{Avec la notation \texttt{v.marque}}
        \item[D.] Avec la notation \texttt{v->marque}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile]{Question 13 \textemdash{} Fonction pure}
    Qu'est-ce qu'une \textbf{fonction pure}, au
sens du paradigme fonctionnel ?\medskip
    \begin{itemize}
        \item[A.] Une fonction qui ne prend aucun paramètre
        \item[B.] Une fonction écrite dans un langage mathématique
        \item[C.] Une fonction qui ne contient aucun bug
        \item[\alert<2>{D.}] \alert<2>{Une fonction qui, pour les mêmes paramètres, renvoie toujours la même valeur, sans aucun effet de bord (pas de modification d'une variable globale, pas d'entrée-sortie)}
    \end{itemize}
\end{frame}

% Q14 - Réponse en D
\begin{frame}[fragile]{Question 14 \textemdash{} Une fonction, une responsabilité}
    Que recommande le principe
« \textbf{une fonction, une
responsabilité} » ?\medskip
    \begin{itemize}
        \item[A.] Un programme ne doit posséder qu'une seule fonction
        \item[B.] Chaque fichier doit contenir une seule fonction
        \item[C.] Chaque fonction doit prendre exactement un seul paramètre
        \item[\alert<2>{D.}] \alert<2>{Chaque fonction doit accomplir une seule tâche clairement définie}
    \end{itemize}
\end{frame}

% Q15 - Réponse en B
\begin{frame}[fragile]{Question 15 \textemdash{} Interface d'un module}
    Que désigne l'\textbf{interface} d'un
module ou d'une fonction ?\medskip
    \begin{itemize}
        \item[A.] Uniquement la documentation du module
        \item[\alert<2>{B.}] \alert<2>{L'ensemble des points d'accès publics (signature, paramètres attendus, valeurs renvoyées, exceptions levées) que les utilisateurs peuvent consulter sans connaître l'implémentation}
        \item[C.] Le code source du module
        \item[D.] Sa couleur d'affichage dans l'éditeur
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Style fonctionnel}
    Laquelle de ces écritures est la plus
\textbf{proche du style fonctionnel} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
carres = list(map(lambda x: x * x, liste))
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
carres = liste.map(square)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
carres = []
for x in liste:
    carres.append(x * x)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
carres = [x * x for x in liste]
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Style fonctionnel}
    Laquelle de ces écritures est la plus
\textbf{proche du style fonctionnel} ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
carres = list(map(lambda x: x * x, liste))
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
carres = liste.map(square)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
carres = []
for x in liste:
    carres.append(x * x)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
carres = [x * x for x in liste]
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile]{Question 17 \textemdash{} Bibliothèques standard}
    Pourquoi est-il préférable de
privilégier les \textbf{bibliothèques
standard} plutôt que de tout coder
soi-même ?\medskip
    \begin{itemize}
        \item[A.] Aucun avantage à utiliser des bibliothèques
        \item[B.] Parce que les bibliothèques standard sont obligatoires à utiliser
        \item[C.] Pour ralentir volontairement le programme
        \item[\alert<2>{D.}] \alert<2>{Le code des bibliothèques standard est de qualité, testé par de nombreux utilisateurs, documenté et maintenu}
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile]{Question 18 \textemdash{} Le paramètre self}
    Dans la définition d'une méthode
Python, à quoi sert le premier
paramètre, traditionnellement nommé
\texttt{self} ?\medskip
    \begin{itemize}
        \item[A.] C'est un mot-clé réservé qu'il ne faut jamais modifier
        \item[B.] Il représente la classe elle-même, pas l'instance
        \item[C.] Il est rempli automatiquement avec la valeur $0$
        \item[\alert<2>{D.}] \alert<2>{Il désigne l'instance sur laquelle la méthode est appelée}
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile]{Question 19 \textemdash{} Classe et instance}
    Quelle est la différence entre une
\textbf{classe} et une \textbf{instance} ?\medskip
    \begin{itemize}
        \item[A.] Aucune différence
        \item[B.] La notion d'instance est aujourd'hui obsolète
        \item[\alert<2>{C.}] \alert<2>{La classe est le « plan » général (la description abstraite). L'instance est un objet concret créé à partir de ce plan}
        \item[D.] La classe s'exécute plus rapidement que l'instance
    \end{itemize}
\end{frame}

% Q20 - Réponse en D
\begin{frame}[fragile]{Question 20 \textemdash{} Choisir un paradigme}
    Quel paradigme de programmation
faut-il privilégier ?\medskip
    \begin{itemize}
        \item[A.] Le paradigme objet, dans tous les cas
        \item[B.] Le paradigme fonctionnel, dans tous les cas
        \item[C.] N'importe quel paradigme convient toujours
        \item[\alert<2>{D.}] \alert<2>{Le choix dépend du problème : le paradigme objet pour modéliser des entités complexes ; le paradigme fonctionnel pour des transformations de données ; le paradigme impératif pour des algorithmes simples et directs}
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile]{Question 21 \textemdash{} Couplage entre modules}
    Qu'appelle-t-on le \textbf{couplage} entre
modules ?\medskip
    \begin{itemize}
        \item[A.] Le nombre de fonctions définies dans chaque module
        \item[B.] Une union solennelle entre deux modules
        \item[C.] Une opération mathématique sur les modules
        \item[\alert<2>{D.}] \alert<2>{Le degré de dépendance entre modules. On vise un couplage faible, c'est-à-dire des modules peu liés, modifiables indépendamment les uns des autres}
    \end{itemize}
\end{frame}

% Q22 - Réponse en C
\begin{frame}[fragile]{Question 22 \textemdash{} Piège classique de la programmation orientée objet}
    Quel est un \textbf{piège classique} de la
programmation orientée objet ?\medskip
    \begin{itemize}
        \item[A.] Coder de manière trop simple
        \item[B.] La programmation orientée objet ne présente aucun piège
        \item[\alert<2>{C.}] \alert<2>{Modéliser sous forme de classes des situations qui ne le justifient pas, ce qui complique inutilement le code}
        \item[D.] Utiliser des fonctions classiques
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Définir une classe}
    Quel squelette permet de définir une
classe \texttt{Point} avec deux attributs \texttt{x}
et \texttt{y} initialisés à la création ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def Point(x, y):
    self.x = x
    self.y = y
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Point(x, y):
    return x, y
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
class Point:
    x, y
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Définir une classe}
    Quel squelette permet de définir une
classe \texttt{Point} avec deux attributs \texttt{x}
et \texttt{y} initialisés à la création ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def Point(x, y):
    self.x = x
    self.y = y
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Point(x, y):
    return x, y
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
class Point:
    x, y
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q24 - Réponse en C
\begin{frame}[fragile]{Question 24 \textemdash{} Paradigme déclaratif}
    En quoi le paradigme \textbf{déclaratif}
se distingue-t-il du paradigme
impératif ?\medskip
    \begin{itemize}
        \item[A.] Aucune différence n'existe entre les deux paradigmes
        \item[B.] Le paradigme déclaratif n'existe pas
        \item[\alert<2>{C.}] \alert<2>{Le paradigme déclaratif dit ce que l'on veut, sans préciser comment l'obtenir (SQL, HTML, expressions régulières) ; le paradigme impératif, à l'inverse, décrit comment faire étape par étape}
        \item[D.] Le paradigme déclaratif est plus rapide à exécuter
    \end{itemize}
\end{frame}

% Q25 - Réponse en A
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes
sur la modularité et les
paradigmes, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Python est un langage purement fonctionnel}
        \item[B.] La modularité améliore la maintenabilité du code
        \item[C.] Une fonction pure n'a pas d'effet de bord
        \item[D.] Le paradigme objet structure le code autour d'objets combinant données et comportements
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile]{Question 26 \textemdash{} Encapsulation}
    Que désigne le principe
d'\textbf{encapsulation} en programmation
orientée objet ?\medskip
    \begin{itemize}
        \item[A.] Réutiliser les classes
d'un autre programme

        \item[B.] Mettre tout le code d'une
application dans un seul fichier

        \item[C.] Compresser un fichier avant de
l'envoyer

        \item[\alert<2>{D.}] \alert<2>{Regrouper dans un même objet les
données (attributs) et les
traitements (méthodes) qui
s'appliquent à ces données, en
masquant à l'extérieur les
détails d'implémentation
}
    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile]{Question 27 \textemdash{} Convention de visibilité en Python}
    En Python, comment indique-t-on
conventionnellement qu'un attribut
ou une méthode est destiné à un
usage \textbf{interne} (et ne fait pas
partie de l'interface publique) ?\medskip
    \begin{itemize}
        \item[A.] En écrivant le nom en majuscules

        \item[B.] En préfixant le nom par un dièse
(\texttt{\#nom})

        \item[\alert<2>{C.}] \alert<2>{En préfixant son nom par un
unique caractère de soulignement
(par exemple \texttt{\_etat\_interne})
}
        \item[D.] Avec le mot-clé \texttt{private}

    \end{itemize}
\end{frame}

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

\end{document}
