\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{Spécification}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

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

% Q1 - Réponse en D
\begin{frame}[fragile]{Question 1 \textemdash{} Spécification}
    Qu'est-ce que la \textbf{spécification} d'une
fonction ?\medskip
    \begin{itemize}
        \item[A.] Son code source complet
        \item[B.] Son nombre total de lignes
        \item[C.] Sa vitesse d'exécution
        \item[\alert<2>{D.}] \alert<2>{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{itemize}
\end{frame}

% Q2 - Réponse en B
\begin{frame}[fragile]{Question 2 \textemdash{} Signature}
    Qu'appelle-t-on la \textbf{signature} d'une fonction ?\medskip
    \begin{itemize}
        \item[A.] Le nom de l'auteur de la fonction
        \item[\alert<2>{B.}] \alert<2>{Son nom, ses paramètres (avec leurs types) et son type de retour}
        \item[C.] Le numéro de ligne où la fonction est définie
        \item[D.] La date de création
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Précondition}
    Qu'est-ce qu'une \textbf{précondition} ?\medskip
    \begin{itemize}
        \item[A.] Une condition d'arrêt de boucle
        \item[\alert<2>{B.}] \alert<2>{Une condition qui doit être vraie avant l'appel de la fonction (sur les paramètres)}
        \item[C.] Une condition après l'appel
        \item[D.] Une condition tirée au hasard
    \end{itemize}
\end{frame}

% Q4 - Réponse en C
\begin{frame}[fragile]{Question 4 \textemdash{} Postcondition}
    Qu'est-ce qu'une \textbf{postcondition} ?\medskip
    \begin{itemize}
        \item[A.] Une condition tirée au hasard
        \item[B.] Le type de retour de la fonction
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] Une condition avant l'appel
    \end{itemize}
\end{frame}

% Q5 - Réponse en B
\begin{frame}[fragile]{Question 5 \textemdash{} Docstring}
    Comment \textbf{documenter} une fonction Python
conformément à la PEP 257 ?\medskip
    \begin{itemize}
        \item[A.] Avec un commentaire placé en fin de fonction
        \item[\alert<2>{B.}] \alert<2>{Avec une docstring (chaîne entre triples guillemets) en première instruction du corps}
        \item[C.] Avec un commentaire \texttt{\#} au-dessus
        \item[D.] Dans un fichier README placé à part
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Exemple complet}
    Quelle est la \textbf{bonne pratique} pour spécifier
une fonction Python \texttt{valeur\_absolue(x)} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
# x est un nombre
# renvoie sa valeur absolue
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}

        \item[C.]~\\
\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}

        \item[D.]~\\
\begin{lstlisting}
def valeur_absolue(x):
    # implementation
    pass
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Exemple complet}
    Quelle est la \textbf{bonne pratique} pour spécifier
une fonction Python \texttt{valeur\_absolue(x)} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
# x est un nombre
# renvoie sa valeur absolue
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def valeur_absolue(x):
    return abs(x)
\end{lstlisting}

        \item[\alert{C.}]~\\
\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}

        \item[D.]~\\
\begin{lstlisting}
def valeur_absolue(x):
    # implementation
    pass
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile]{Question 7 \textemdash{} Pourquoi spécifier ?}
    Pourquoi spécifier une fonction \textbf{avant} de
l'écrire ?\medskip
    \begin{itemize}
        \item[A.] Parce que c'est obligatoire
        \item[B.] Pour ralentir l'exécution du code
        \item[\alert<2>{C.}] \alert<2>{Pour clarifier le but de la fonction, faciliter la conception, permettre les tests, et servir de documentation}
        \item[D.] Pour utiliser davantage de mémoire
    \end{itemize}
\end{frame}

% Q8 - Réponse en D
\begin{frame}[fragile]{Question 8 \textemdash{} Annotations de type}
    Que produisent les \textbf{annotations de type} en
Python (\texttt{x: int}) ?\medskip
    \begin{itemize}
        \item[A.] Une erreur de syntaxe
        \item[B.] Une vérification automatique à l'exécution
        \item[C.] Une transformation du type
        \item[\alert<2>{D.}] \alert<2>{Une documentation du type attendu, vérifiable par des outils externes (\texttt{mypy})}
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Doctest}
    À quoi servent les exemples \texttt{>>> ...} dans une
docstring ?\medskip
    \begin{itemize}
        \item[A.] À déclarer des constantes du programme
        \item[\alert<2>{B.}] \alert<2>{À fournir des exemples d'utilisation qui peuvent être exécutés automatiquement comme tests par le module \texttt{doctest}}
        \item[C.] À rendre la documentation plus jolie visuellement
        \item[D.] À signaler une erreur dans le code
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile]{Question 10 \textemdash{} Cas limites}
    Quels sont les \textbf{cas limites} typiques à
considérer en spécifiant une fonction sur une
liste ?\medskip
    \begin{itemize}
        \item[A.] Une liste constituée d'éléments imaginaires
        \item[\alert<2>{B.}] \alert<2>{Liste vide, liste à un élément, liste très longue}
        \item[C.] Une liste de couleurs
        \item[D.] Aucun, le cas général suffit
    \end{itemize}
\end{frame}

% Q11 - Réponse en C
\begin{frame}[fragile]{Question 11 \textemdash{} Programmation par contrat}
    Que signifie « \textbf{programmation par contrat} » ?\medskip
    \begin{itemize}
        \item[A.] Rédiger un contrat juridique pour chaque programme
        \item[B.] Programmer à plusieurs au sein d'une même équipe
        \item[\alert<2>{C.}] \alert<2>{Concevoir chaque fonction avec un contrat explicite (préconditions, postconditions, invariants), respecté par l'appelant et par la fonction}
        \item[D.] Programmer en échange d'une rémunération financière
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Identifier la précondition}
    Pour la fonction
\begin{lstlisting}
def diviser(a, b):
    return a / b
\end{lstlisting}
Quelle est une \textbf{précondition} essentielle ?\medskip
    \begin{itemize}
        \item[A.] Aucune précondition n'est nécessaire
        \item[B.] \texttt{a > 0}
        \item[C.] \texttt{a == b}
        \item[D.] \texttt{b != 0}
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Identifier la précondition}
    Pour la fonction
\begin{lstlisting}
def diviser(a, b):
    return a / b
\end{lstlisting}
Quelle est une \textbf{précondition} essentielle ?\medskip
    \begin{itemize}
        \item[A.] Aucune précondition n'est nécessaire
        \item[B.] \texttt{a > 0}
        \item[C.] \texttt{a == b}
        \item[\alert{D.}] \alert{\texttt{b != 0}}
    \end{itemize}
\end{frame}

% Q13 - Réponse en A
\begin{frame}[fragile]{Question 13 \textemdash{} Bonne docstring}
    Que devrait contenir une \textbf{bonne docstring} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une description du but, des paramètres (avec types), de la valeur renvoyée, des conditions d'utilisation et idéalement des exemples}
        \item[B.] Uniquement le nom de l'auteur de la fonction
        \item[C.] Le code source intégral de la fonction
        \item[D.] Un poème ou un texte décoratif
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile]{Question 14 \textemdash{} help()}
    Que fait \texttt{help(ma\_fonction)} en Python ?\medskip
    \begin{itemize}
        \item[A.] Elle lance la documentation en ligne sur Internet
        \item[B.] Elle exécute la fonction donnée en argument
        \item[\alert<2>{C.}] \alert<2>{Affiche la signature de la fonction et sa docstring (si elle en a une)}
        \item[D.] Renvoie le code source
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile]{Question 15 \textemdash{} Programmation défensive}
    Que signifie « programmation défensive » ?\medskip
    \begin{itemize}
        \item[A.] Programmer un système de sécurité physique
        \item[B.] S'abstenir d'écrire du code
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] Ajouter des virus de défense au programme
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile]{Question 16 \textemdash{} Type de retour}
    Pourquoi spécifier le \textbf{type de retour} d'une
fonction ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour clarifier ce que reçoit l'appelant et permettre les vérifications statiques (\texttt{mypy})}
        \item[B.] Pour économiser de la mémoire à l'exécution
        \item[C.] Cela rend la fonction plus rapide à l'exécution
        \item[D.] C'est obligatoire en Python
    \end{itemize}
\end{frame}

% Q17 - Réponse en C
\begin{frame}[fragile]{Question 17 \textemdash{} Bonne signature}
    Quelle signature est la \textbf{plus claire} pour
« calculer la moyenne d'une liste de notes » ?\medskip
    \begin{itemize}
        \item[A.] \texttt{def m(l):}
        \item[B.] \texttt{def moyenne(x):}
        \item[\alert<2>{C.}] \alert<2>{\texttt{def moyenne(notes: list[float]) -> float:}}
        \item[D.] \texttt{def calc(*args, kwargs):}
    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile]{Question 18 \textemdash{} Cas particuliers}
    Pour la fonction \texttt{moyenne(notes)}, quel \textbf{cas
limite} poserait problème ?\medskip
    \begin{itemize}
        \item[A.] Une liste de cent notes
        \item[\alert<2>{B.}] \alert<2>{La liste vide, qui provoque une division par zéro}
        \item[C.] Une note décimale, par exemple $12{,}5$
        \item[D.] Une note négative
    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile]{Question 19 \textemdash{} Spec et robustesse}
    Comment une bonne spécification améliore-t-elle
la \textbf{robustesse} d'un programme ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{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}
        \item[B.] En réduisant le nombre de lignes
        \item[C.] En écrivant le code plus rapidement
        \item[D.] En obligeant à utiliser des types forts
    \end{itemize}
\end{frame}

% Q20 - Réponse en A
\begin{frame}[fragile]{Question 20 \textemdash{} Outils Python}
    Quels \textbf{outils Python} aident à respecter une
spécification ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{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)}
        \item[B.] Aucun
        \item[C.] Un compilateur
        \item[D.] Seulement \texttt{print}
    \end{itemize}
\end{frame}

% Q21 - Réponse en B
\begin{frame}[fragile]{Question 21 \textemdash{} Spécification ambiguë}
    Quel problème a la spécification suivante ?
« La fonction \texttt{chercher(liste, valeur)} cherche
la valeur dans la liste. »\medskip
    \begin{itemize}
        \item[A.] Aucun
        \item[\alert<2>{B.}] \alert<2>{Plusieurs zones d'ombre : que renvoyer si trouvée (indice, booléen) ? Si plusieurs occurrences (la première, toutes) ? Si absente (None, -1, exception) ?}
        \item[C.] La fonction n'a pas assez de paramètres
        \item[D.] Le nom de la fonction est trop long
    \end{itemize}
\end{frame}

% Q22 - Réponse en C
\begin{frame}[fragile]{Question 22 \textemdash{} Cas d'erreur}
    Comment doit-on \textbf{spécifier le comportement en
cas d'erreur} d'une fonction ?\medskip
    \begin{itemize}
        \item[A.] Faire planter le programme
        \item[B.] Renvoyer aléatoirement
        \item[\alert<2>{C.}] \alert<2>{Décider explicitement : valeur de retour spéciale (\texttt{None}, \texttt{-1}), exception levée, ou contrat (précondition que l'utilisateur doit garantir)}
        \item[D.] Ne pas y penser
    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile]{Question 23 \textemdash{} Spec et évolution}
    Pourquoi une spécification claire facilite-t-elle
la \textbf{maintenance} d'un programme ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Parce qu'on peut réécrire l'implémentation sans changer le contrat, donc sans casser le code qui l'utilise}
        \item[B.] Parce qu'une spécification est jolie à lire
        \item[C.] Parce que le code obtenu est plus court
        \item[D.] Parce qu'elle élimine totalement les bugs
    \end{itemize}
\end{frame}

% Q24 - Réponse en C
\begin{frame}[fragile]{Question 24 \textemdash{} Développement piloté par les tests}
    En quoi consiste l'approche dite de
\textbf{développement piloté par les tests} ?\medskip
    \begin{itemize}
        \item[A.] Tester manuellement le programme une fois qu'il est entièrement écrit
        \item[B.] Faire générer automatiquement les tests par un programme d'intelligence artificielle
        \item[\alert<2>{C.}] \alert<2>{É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}
        \item[D.] Exécuter les tests sur un seul ordinateur, plutôt que sur plusieurs
    \end{itemize}
\end{frame}

% Q25 - Réponse en A
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes sur la
spécification, laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La précondition est une condition que la fonction doit garantir au moment de l'appel}
        \item[B.] La docstring permet d'accéder à la documentation via \texttt{help()}
        \item[C.] La signature comprend nom, paramètres et type de retour
        \item[D.] Une bonne spécification facilite la maintenance et la robustesse
    \end{itemize}
\end{frame}

% Q26 - Réponse en A
\begin{frame}[fragile]{Question 26 \textemdash{} Effet de bord vs valeur de retour}
    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 ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{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)})
}
        \item[B.] La distinction se fait au moment de l'exécution, en fonction de la mémoire disponible
        \item[C.] La distinction est purement esthétique et n'a pas d'effet réel
        \item[D.] La distinction n'a pas d'importance, l'utilisateur s'adapte au comportement obtenu
    \end{itemize}
\end{frame}

% Q27 - Réponse en B
\begin{frame}[fragile]{Question 27 \textemdash{} Précondition, postcondition, invariant}
    Dans une fonction qui parcourt une liste avec
une boucle, comment se distinguent
\textbf{précondition}, \textbf{postcondition} et
\textbf{invariant de boucle} ?\medskip
    \begin{itemize}
        \item[A.] L'invariant de boucle remplace la précondition et la postcondition
        \item[\alert<2>{B.}] \alert<2>{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
}
        \item[C.] La précondition est une postcondition imprécise
        \item[D.] Ce sont trois noms différents pour la même notion
    \end{itemize}
\end{frame}

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

\end{document}
