\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Modularité et paradigmes}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Modularité et paradigmes} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{terminalemodulariteparadigmes}{
  \begin{question}{q01}
    Qu'appelle-t-on la \textbf{modularité} d'un
programme ?
    \begin{choices}
    \wrongchoice{Sa qualité esthétique}
    \wrongchoice{Sa taille mesurée en nombre de lignes}
    \wrongchoice{Sa rapidité d'exécution}
    \correctchoice{Sa décomposition en modules (fonctions, classes, fichiers) cohérents et faiblement couplés entre eux}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q02}
    Qu'est-ce que le \textbf{paradigme impératif}
en programmation ?
    \begin{choices}
    \wrongchoice{Une simple variante du paradigme fonctionnel}
    \wrongchoice{Un style de programmation interdit par la loi}
    \wrongchoice{Un paradigme inventé en $2020$}
    \correctchoice{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{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q03}
    Qu'est-ce que le \textbf{paradigme
fonctionnel} en programmation ?
    \begin{choices}
    \wrongchoice{Un paradigme dédié à la gestion des erreurs}
    \correctchoice{Un style fondé sur l'évaluation de fonctions sans effet de bord, l'immuabilité des données et la composition de fonctions}
    \wrongchoice{Tout simplement un programme qui fonctionne correctement}
    \wrongchoice{Le même paradigme que l'impératif}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q04}
    Qu'est-ce que la \textbf{programmation
orientée objet} ?
    \begin{choices}
    \wrongchoice{Le fait de coder en utilisant des objets physiques}
    \wrongchoice{Un paradigme aujourd'hui obsolète}
    \wrongchoice{Une bibliothèque graphique}
    \correctchoice{Un style structurant le code autour d'objets (instances de classes) qui combinent données (les attributs) et comportements (les méthodes)}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q05}
    Qu'appelle-t-on \textbf{abstraction} en
programmation ?
    \begin{choices}
    \wrongchoice{Un paradigme de programmation particulier}
    \wrongchoice{Une notion appartenant aux mathématiques}
    \correctchoice{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}
    \wrongchoice{Une obligation imposée par la loi}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q06}
    Pourquoi \textbf{découper un programme} en
plusieurs fonctions ou modules ?
    \begin{choices}
    \correctchoice{Pour améliorer la lisibilité, la réutilisation, la testabilité et la maintenance du code}
    \wrongchoice{Pour gagner quelques secondes lors de la compilation}
    \wrongchoice{Pour rendre le code plus complexe}
    \wrongchoice{Aucune raison particulière ne le justifie}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q07}
    Quel paradigme \textbf{dominant} caractérise
le langage Python ?
    \begin{choices}
    \correctchoice{Python est un langage multi-paradigmes : il permet de combiner les styles impératif, objet et fonctionnel selon les besoins}
    \wrongchoice{Uniquement le paradigme objet}
    \wrongchoice{Uniquement le paradigme impératif}
    \wrongchoice{Uniquement le paradigme fonctionnel}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q08}
    En Python, comment \textbf{importe-t-on} des
fonctions définies dans un module
\texttt{outils.py} situé à côté du fichier
principal ?
    \begin{choices}
    \wrongchoice{Avec une directive \texttt{include outils.py}}
    \correctchoice{Avec \texttt{import outils} (puis \texttt{outils.fonction()}), ou avec \texttt{from outils import fonction}}
    \wrongchoice{Avec l'instruction \texttt{use outils}}
    \wrongchoice{Aucune syntaxe ne permet ce type d'import}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q09}
    Quel est le \textbf{principal avantage} de la
réutilisation de code déjà écrit ?
    \begin{choices}
    \wrongchoice{Le code s'exécute plus rapidement}
    \correctchoice{On code plus rapidement, et avec moins de bugs, car le code réutilisé a déjà été testé}
    \wrongchoice{Aucun avantage particulier}
    \wrongchoice{Le code occupe moins d'espace}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q10}
    Pour calculer la moyenne d'une liste
de notes lue dans un fichier au format
CSV, quelle décomposition est la \textbf{plus
propre} ?
    \begin{choices}
    \wrongchoice{N'utiliser aucune fonction}
    \wrongchoice{Tout placer dans une seule fonction}
    \correctchoice{Trois fonctions distinctes, par exemple \texttt{lire\_csv}, \texttt{calculer\_moyenne} et \texttt{afficher\_resultat}}
    \wrongchoice{Une seule fonction qui ne fait qu'un appel à \texttt{print}}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q11}
    En Python, comment crée-t-on un objet
(une \textbf{instance}) à partir de la
classe \texttt{Voiture} ?
    \begin{choices}
    \wrongchoice{Avec \texttt{v = Voiture.instance()}}
    \correctchoice{Avec la syntaxe \texttt{v = Voiture()}}
    \wrongchoice{Avec \texttt{v = create(Voiture)}}
    \wrongchoice{Avec la syntaxe \texttt{v = new Voiture()}}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q12}
    Soit l'instance
\texttt{v = Voiture("Peugeot", 2020)}. Comment
accède-t-on à l'attribut \texttt{marque} de
cet objet ?
    \begin{choices}
    \wrongchoice{Avec la notation \texttt{v::marque}}
    \wrongchoice{Avec la notation \texttt{v[marque]}}
    \correctchoice{Avec la notation \texttt{v.marque}}
    \wrongchoice{Avec la notation \texttt{v->marque}}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q13}
    Qu'est-ce qu'une \textbf{fonction pure}, au
sens du paradigme fonctionnel ?
    \begin{choices}
    \wrongchoice{Une fonction qui ne prend aucun paramètre}
    \wrongchoice{Une fonction écrite dans un langage mathématique}
    \wrongchoice{Une fonction qui ne contient aucun bug}
    \correctchoice{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{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q14}
    Que recommande le principe
« \textbf{une fonction, une
responsabilité} » ?
    \begin{choices}
    \wrongchoice{Un programme ne doit posséder qu'une seule fonction}
    \wrongchoice{Chaque fichier doit contenir une seule fonction}
    \wrongchoice{Chaque fonction doit prendre exactement un seul paramètre}
    \correctchoice{Chaque fonction doit accomplir une seule tâche clairement définie}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q15}
    Que désigne l'\textbf{interface} d'un
module ou d'une fonction ?
    \begin{choices}
    \wrongchoice{Uniquement la documentation du module}
    \correctchoice{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}
    \wrongchoice{Le code source du module}
    \wrongchoice{Sa couleur d'affichage dans l'éditeur}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q16}
    Laquelle de ces écritures est la plus
\textbf{proche du style fonctionnel} ?
    \begin{choices}
    \correctchoice{\begin{lstlisting}
carres = list(map(lambda x: x * x, liste))
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
carres = liste.map(square)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
carres = []
for x in liste:
    carres.append(x * x)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
carres = [x * x for x in liste]
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q17}
    Pourquoi est-il préférable de
privilégier les \textbf{bibliothèques
standard} plutôt que de tout coder
soi-même ?
    \begin{choices}
    \wrongchoice{Aucun avantage à utiliser des bibliothèques}
    \wrongchoice{Parce que les bibliothèques standard sont obligatoires à utiliser}
    \wrongchoice{Pour ralentir volontairement le programme}
    \correctchoice{Le code des bibliothèques standard est de qualité, testé par de nombreux utilisateurs, documenté et maintenu}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q18}
    Dans la définition d'une méthode
Python, à quoi sert le premier
paramètre, traditionnellement nommé
\texttt{self} ?
    \begin{choices}
    \wrongchoice{C'est un mot-clé réservé qu'il ne faut jamais modifier}
    \wrongchoice{Il représente la classe elle-même, pas l'instance}
    \wrongchoice{Il est rempli automatiquement avec la valeur $0$}
    \correctchoice{Il désigne l'instance sur laquelle la méthode est appelée}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q19}
    Quelle est la différence entre une
\textbf{classe} et une \textbf{instance} ?
    \begin{choices}
    \wrongchoice{Aucune différence}
    \wrongchoice{La notion d'instance est aujourd'hui obsolète}
    \correctchoice{La classe est le « plan » général (la description abstraite). L'instance est un objet concret créé à partir de ce plan}
    \wrongchoice{La classe s'exécute plus rapidement que l'instance}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q20}
    Quel paradigme de programmation
faut-il privilégier ?
    \begin{choices}
    \wrongchoice{Le paradigme objet, dans tous les cas}
    \wrongchoice{Le paradigme fonctionnel, dans tous les cas}
    \wrongchoice{N'importe quel paradigme convient toujours}
    \correctchoice{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{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q21}
    Qu'appelle-t-on le \textbf{couplage} entre
modules ?
    \begin{choices}
    \wrongchoice{Le nombre de fonctions définies dans chaque module}
    \wrongchoice{Une union solennelle entre deux modules}
    \wrongchoice{Une opération mathématique sur les modules}
    \correctchoice{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{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q22}
    Quel est un \textbf{piège classique} de la
programmation orientée objet ?
    \begin{choices}
    \wrongchoice{Coder de manière trop simple}
    \wrongchoice{La programmation orientée objet ne présente aucun piège}
    \correctchoice{Modéliser sous forme de classes des situations qui ne le justifient pas, ce qui complique inutilement le code}
    \wrongchoice{Utiliser des fonctions classiques}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q23}
    Quel squelette permet de définir une
classe \texttt{Point} avec deux attributs \texttt{x}
et \texttt{y} initialisés à la création ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def Point(x, y):
    self.x = x
    self.y = y
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Point(x, y):
    return x, y
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Point:
    x, y
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q24}
    En quoi le paradigme \textbf{déclaratif}
se distingue-t-il du paradigme
impératif ?
    \begin{choices}
    \wrongchoice{Aucune différence n'existe entre les deux paradigmes}
    \wrongchoice{Le paradigme déclaratif n'existe pas}
    \correctchoice{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}
    \wrongchoice{Le paradigme déclaratif est plus rapide à exécuter}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q25}
    Parmi les affirmations suivantes
sur la modularité et les
paradigmes, laquelle est
\textbf{fausse} ?
    \begin{choices}
    \correctchoice{Python est un langage purement fonctionnel}
    \wrongchoice{La modularité améliore la maintenabilité du code}
    \wrongchoice{Une fonction pure n'a pas d'effet de bord}
    \wrongchoice{Le paradigme objet structure le code autour d'objets combinant données et comportements}
    \end{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q26}
    Que désigne le principe
d'\textbf{encapsulation} en programmation
orientée objet ?
    \begin{choices}
    \wrongchoice{Réutiliser les classes
d'un autre programme
}
    \wrongchoice{Mettre tout le code d'une
application dans un seul fichier
}
    \wrongchoice{Compresser un fichier avant de
l'envoyer
}
    \correctchoice{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{choices}
  \end{question}
}

\element{terminalemodulariteparadigmes}{
  \begin{question}{q27}
    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) ?
    \begin{choices}
    \wrongchoice{En écrivant le nom en majuscules
}
    \wrongchoice{En préfixant le nom par un dièse
(\texttt{\#nom})
}
    \correctchoice{En préfixant son nom par un
unique caractère de soulignement
(par exemple \texttt{\_etat\_interne})
}
    \wrongchoice{Avec le mot-clé \texttt{private}
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{terminalemodulariteparadigmes}
  \insertgroup{terminalemodulariteparadigmes}
}

\end{document}
