\documentclass[a4paper,11pt]{article}

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

\title{Spécification}
\date{Numérique et sciences informatiques}

\begin{document}

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

\bigskip

\element{premierespecification}{
  \begin{question}{q01}
    Qu'est-ce que la \textbf{spécification} d'une
fonction ?
    \begin{choices}
    \wrongchoice{Son code source complet}
    \wrongchoice{Son nombre total de lignes}
    \wrongchoice{Sa vitesse d'exécution}
    \correctchoice{La description précise de ce que la fonction doit faire (paramètres attendus, valeur renvoyée, conditions d'utilisation), indépendamment de l'implémentation}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q02}
    Qu'appelle-t-on la \textbf{signature} d'une fonction ?
    \begin{choices}
    \wrongchoice{Le nom de l'auteur de la fonction}
    \correctchoice{Son nom, ses paramètres (avec leurs types) et son type de retour}
    \wrongchoice{Le numéro de ligne où la fonction est définie}
    \wrongchoice{La date de création}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q03}
    Qu'est-ce qu'une \textbf{précondition} ?
    \begin{choices}
    \wrongchoice{Une condition d'arrêt de boucle}
    \correctchoice{Une condition qui doit être vraie avant l'appel de la fonction (sur les paramètres)}
    \wrongchoice{Une condition après l'appel}
    \wrongchoice{Une condition tirée au hasard}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q04}
    Qu'est-ce qu'une \textbf{postcondition} ?
    \begin{choices}
    \wrongchoice{Une condition tirée au hasard}
    \wrongchoice{Le type de retour de la fonction}
    \correctchoice{Ce que la fonction garantit sur la valeur de retour (ou sur l'effet) après son exécution, si la précondition est respectée}
    \wrongchoice{Une condition avant l'appel}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q05}
    Comment \textbf{documenter} une fonction Python
conformément à la PEP 257 ?
    \begin{choices}
    \wrongchoice{Avec un commentaire placé en fin de fonction}
    \correctchoice{Avec une docstring (chaîne entre triples guillemets) en première instruction du corps}
    \wrongchoice{Avec un commentaire \texttt{\#} au-dessus}
    \wrongchoice{Dans un fichier README placé à part}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q06}
    Quelle est la \textbf{bonne pratique} pour spécifier
une fonction Python \texttt{valeur\_absolue(x)} ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
# x est un nombre
# renvoie sa valeur absolue
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def valeur_absolue(x: float) -> float:
    """Renvoie la valeur absolue de x.

    Précondition : x est un nombre.
    Postcondition : le résultat est >= 0.
    """
    return abs(x)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def valeur_absolue(x):
    # implementation
    pass
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q07}
    Pourquoi spécifier une fonction \textbf{avant} de
l'écrire ?
    \begin{choices}
    \wrongchoice{Parce que c'est obligatoire}
    \wrongchoice{Pour ralentir l'exécution du code}
    \correctchoice{Pour clarifier le but de la fonction, faciliter la conception, permettre les tests, et servir de documentation}
    \wrongchoice{Pour utiliser davantage de mémoire}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q08}
    Que produisent les \textbf{annotations de type} en
Python (\texttt{x: int}) ?
    \begin{choices}
    \wrongchoice{Une erreur de syntaxe}
    \wrongchoice{Une vérification automatique à l'exécution}
    \wrongchoice{Une transformation du type}
    \correctchoice{Une documentation du type attendu, vérifiable par des outils externes (\texttt{mypy})}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q09}
    À quoi servent les exemples \texttt{>>> ...} dans une
docstring ?
    \begin{choices}
    \wrongchoice{À déclarer des constantes du programme}
    \correctchoice{À fournir des exemples d'utilisation qui peuvent être exécutés automatiquement comme tests par le module \texttt{doctest}}
    \wrongchoice{À rendre la documentation plus jolie visuellement}
    \wrongchoice{À signaler une erreur dans le code}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q10}
    Quels sont les \textbf{cas limites} typiques à
considérer en spécifiant une fonction sur une
liste ?
    \begin{choices}
    \wrongchoice{Une liste constituée d'éléments imaginaires}
    \correctchoice{Liste vide, liste à un élément, liste très longue}
    \wrongchoice{Une liste de couleurs}
    \wrongchoice{Aucun, le cas général suffit}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q11}
    Que signifie « \textbf{programmation par contrat} » ?
    \begin{choices}
    \wrongchoice{Rédiger un contrat juridique pour chaque programme}
    \wrongchoice{Programmer à plusieurs au sein d'une même équipe}
    \correctchoice{Concevoir chaque fonction avec un contrat explicite (préconditions, postconditions, invariants), respecté par l'appelant et par la fonction}
    \wrongchoice{Programmer en échange d'une rémunération financière}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q12}
    Pour la fonction
\begin{lstlisting}
def diviser(a, b):
    return a / b
\end{lstlisting}
Quelle est une \textbf{précondition} essentielle ?
    \begin{choices}
    \wrongchoice{Aucune précondition n'est nécessaire}
    \wrongchoice{\texttt{a > 0}}
    \wrongchoice{\texttt{a == b}}
    \correctchoice{\texttt{b != 0}}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q13}
    Que devrait contenir une \textbf{bonne docstring} ?
    \begin{choices}
    \correctchoice{Une description du but, des paramètres (avec types), de la valeur renvoyée, des conditions d'utilisation et idéalement des exemples}
    \wrongchoice{Uniquement le nom de l'auteur de la fonction}
    \wrongchoice{Le code source intégral de la fonction}
    \wrongchoice{Un poème ou un texte décoratif}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q14}
    Que fait \texttt{help(ma\_fonction)} en Python ?
    \begin{choices}
    \wrongchoice{Elle lance la documentation en ligne sur Internet}
    \wrongchoice{Elle exécute la fonction donnée en argument}
    \correctchoice{Affiche la signature de la fonction et sa docstring (si elle en a une)}
    \wrongchoice{Renvoie le code source}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q15}
    Que signifie « programmation défensive » ?
    \begin{choices}
    \wrongchoice{Programmer un système de sécurité physique}
    \wrongchoice{S'abstenir d'écrire du code}
    \correctchoice{Vérifier explicitement dans la fonction que les préconditions sont respectées (lever une exception si ce n'est pas le cas), au lieu de faire confiance à l'appelant}
    \wrongchoice{Ajouter des virus de défense au programme}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q16}
    Pourquoi spécifier le \textbf{type de retour} d'une
fonction ?
    \begin{choices}
    \correctchoice{Pour clarifier ce que reçoit l'appelant et permettre les vérifications statiques (\texttt{mypy})}
    \wrongchoice{Pour économiser de la mémoire à l'exécution}
    \wrongchoice{Cela rend la fonction plus rapide à l'exécution}
    \wrongchoice{C'est obligatoire en Python}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q17}
    Quelle signature est la \textbf{plus claire} pour
« calculer la moyenne d'une liste de notes » ?
    \begin{choices}
    \wrongchoice{\texttt{def m(l):}}
    \wrongchoice{\texttt{def moyenne(x):}}
    \correctchoice{\texttt{def moyenne(notes: list[float]) -> float:}}
    \wrongchoice{\texttt{def calc(*args, kwargs):}}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q18}
    Pour la fonction \texttt{moyenne(notes)}, quel \textbf{cas
limite} poserait problème ?
    \begin{choices}
    \wrongchoice{Une liste de cent notes}
    \correctchoice{La liste vide, qui provoque une division par zéro}
    \wrongchoice{Une note décimale, par exemple $12{,}5$}
    \wrongchoice{Une note négative}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q19}
    Comment une bonne spécification améliore-t-elle
la \textbf{robustesse} d'un programme ?
    \begin{choices}
    \correctchoice{En forçant à réfléchir aux entrées valides, aux cas limites et aux comportements attendus, ce qui réduit les bugs et facilite les tests}
    \wrongchoice{En réduisant le nombre de lignes}
    \wrongchoice{En écrivant le code plus rapidement}
    \wrongchoice{En obligeant à utiliser des types forts}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q20}
    Quels \textbf{outils Python} aident à respecter une
spécification ?
    \begin{choices}
    \correctchoice{Annotations de type + \texttt{mypy} (vérification statique), \texttt{assert} (vérification à l'exécution), \texttt{doctest} (tests d'exemples), \texttt{unittest}/\texttt{pytest} (tests unitaires)}
    \wrongchoice{Aucun}
    \wrongchoice{Un compilateur}
    \wrongchoice{Seulement \texttt{print}}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q21}
    Quel problème a la spécification suivante ?
« La fonction \texttt{chercher(liste, valeur)} cherche
la valeur dans la liste. »
    \begin{choices}
    \wrongchoice{Aucun}
    \correctchoice{Plusieurs zones d'ombre : que renvoyer si trouvée (indice, booléen) ? Si plusieurs occurrences (la première, toutes) ? Si absente (None, -1, exception) ?}
    \wrongchoice{La fonction n'a pas assez de paramètres}
    \wrongchoice{Le nom de la fonction est trop long}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q22}
    Comment doit-on \textbf{spécifier le comportement en
cas d'erreur} d'une fonction ?
    \begin{choices}
    \wrongchoice{Faire planter le programme}
    \wrongchoice{Renvoyer aléatoirement}
    \correctchoice{Décider explicitement : valeur de retour spéciale (\texttt{None}, \texttt{-1}), exception levée, ou contrat (précondition que l'utilisateur doit garantir)}
    \wrongchoice{Ne pas y penser}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q23}
    Pourquoi une spécification claire facilite-t-elle
la \textbf{maintenance} d'un programme ?
    \begin{choices}
    \correctchoice{Parce qu'on peut réécrire l'implémentation sans changer le contrat, donc sans casser le code qui l'utilise}
    \wrongchoice{Parce qu'une spécification est jolie à lire}
    \wrongchoice{Parce que le code obtenu est plus court}
    \wrongchoice{Parce qu'elle élimine totalement les bugs}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q24}
    En quoi consiste l'approche dite de
\textbf{développement piloté par les tests} ?
    \begin{choices}
    \wrongchoice{Tester manuellement le programme une fois qu'il est entièrement écrit}
    \wrongchoice{Faire générer automatiquement les tests par un programme d'intelligence artificielle}
    \correctchoice{Écrire d'abord les tests à partir de la spécification, puis le code juste suffisant pour les faire passer, et enfin retravailler la structure du code à tests inchangés}
    \wrongchoice{Exécuter les tests sur un seul ordinateur, plutôt que sur plusieurs}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q25}
    Parmi les affirmations suivantes sur la
spécification, laquelle est \textbf{fausse} ?
    \begin{choices}
    \correctchoice{La précondition est une condition que la fonction doit garantir au moment de l'appel}
    \wrongchoice{La docstring permet d'accéder à la documentation via \texttt{help()}}
    \wrongchoice{La signature comprend nom, paramètres et type de retour}
    \wrongchoice{Une bonne spécification facilite la maintenance et la robustesse}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q26}
    Une fonction de tri peut être spécifiée de
deux façons différentes. Comment la
spécification doit-elle distinguer
explicitement ces deux choix ?
    \begin{choices}
    \correctchoice{La spécification indique clairement si la
fonction modifie la liste reçue (effet
de bord, exemple : \texttt{liste.sort()} qui
renvoie \texttt{None}), ou si elle construit
une nouvelle liste triée sans toucher à
la liste d'entrée (exemple : \texttt{sorted(liste)})
}
    \wrongchoice{La distinction se fait au moment de l'exécution, en fonction de la mémoire disponible}
    \wrongchoice{La distinction est purement esthétique et n'a pas d'effet réel}
    \wrongchoice{La distinction n'a pas d'importance, l'utilisateur s'adapte au comportement obtenu}
    \end{choices}
  \end{question}
}

\element{premierespecification}{
  \begin{question}{q27}
    Dans une fonction qui parcourt une liste avec
une boucle, comment se distinguent
\textbf{précondition}, \textbf{postcondition} et
\textbf{invariant de boucle} ?
    \begin{choices}
    \wrongchoice{L'invariant de boucle remplace la précondition et la postcondition}
    \correctchoice{La précondition porte sur les paramètres
au moment de l'appel ; la postcondition
porte sur la valeur renvoyée ou l'état
final ; l'invariant de boucle porte sur
une propriété conservée à chaque
itération de la boucle interne
}
    \wrongchoice{La précondition est une postcondition imprécise}
    \wrongchoice{Ce sont trois noms différents pour la même notion}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{premierespecification}
  \insertgroup{premierespecification}
}

\end{document}
