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

\begin{document}

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

% Q1 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 1 \textemdash{} Définir une fonction}
    Comment définit-on une fonction \texttt{carre} qui
prend \texttt{x} en paramètre et renvoie \texttt{x * x} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def carre(x) -> x * x
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
carre = x * x
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
function carre(x) {
    return x * x
}
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def carre(x):
    return x * x
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q1 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 1 \textemdash{} Définir une fonction}
    Comment définit-on une fonction \texttt{carre} qui
prend \texttt{x} en paramètre et renvoie \texttt{x * x} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def carre(x) -> x * x
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
carre = x * x
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
function carre(x) {
    return x * x
}
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def carre(x):
    return x * x
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q2 - Réponse en A
\begin{frame}[fragile]{Question 2 \textemdash{} Appel de fonction}
    Après \texttt{def carre(x): return x * x}, comment
appelle-t-on cette fonction sur la valeur 5 ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{carre(5)}}
        \item[B.] \texttt{carre 5}
        \item[C.] \texttt{call carre(5)}
        \item[D.] \texttt{carre[5]}
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Mot-clé return}
    À quoi sert l'instruction \texttt{return} ?\medskip
    \begin{itemize}
        \item[A.] À redémarrer la fonction
        \item[\alert<2>{B.}] \alert<2>{À renvoyer une valeur à l'appelant et terminer la fonction}
        \item[C.] À afficher le résultat sur la console
        \item[D.] À déclarer une variable globale
    \end{itemize}
\end{frame}

% Q4 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 4 \textemdash{} Paramètres}
    Quelle fonction a \textbf{deux} paramètres ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def f(x):
    return x
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def f():
    return 0
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def f(x; y):
    return x + y
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def f(x, y):
    return x + y
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q4 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 4 \textemdash{} Paramètres}
    Quelle fonction a \textbf{deux} paramètres ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def f(x):
    return x
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def f():
    return 0
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def f(x; y):
    return x + y
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def f(x, y):
    return x + y
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q5 - Réponse en A
\begin{frame}[fragile]{Question 5 \textemdash{} Fonction sans return}
    Que renvoie une fonction qui ne contient \textbf{aucun
\texttt{return}} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{None}}
        \item[B.] Une erreur
        \item[C.] Une chaîne vide \texttt{""}
        \item[D.] \texttt{0}
    \end{itemize}
\end{frame}

% Q6 - Réponse en A
\begin{frame}[fragile]{Question 6 \textemdash{} Fonctions natives}
    Parmi les suivants, lequel n'est \textbf{pas} une
fonction native de Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{carre(...)}}
        \item[B.] \texttt{type(...)}
        \item[C.] \texttt{len(...)}
        \item[D.] \texttt{max(...)}
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 7 \textemdash{} Plusieurs appels}
    \begin{lstlisting}
def double(x):
    return x * 2

a = double(3)
b = double(double(5))
\end{lstlisting}
Que valent \texttt{a} et \texttt{b} ?\medskip
    \begin{itemize}
        \item[A.] a = 6, b = 20
        \item[B.] a = 6, b = 25
        \item[C.] a = 3, b = 5
        \item[D.] a = 6, b = 10
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 7 \textemdash{} Plusieurs appels}
    \begin{lstlisting}
def double(x):
    return x * 2

a = double(3)
b = double(double(5))
\end{lstlisting}
Que valent \texttt{a} et \texttt{b} ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{a = 6, b = 20}
        \item[B.] a = 6, b = 25
        \item[C.] a = 3, b = 5
        \item[D.] a = 6, b = 10
    \end{itemize}
\end{frame}

% Q8 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 8 \textemdash{} Docstring}
    Que fait la première ligne en triples
guillemets dans une fonction ?
\begin{lstlisting}
def carre(x):
    """Renvoie le carré de x."""
    return x * x
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] C'est une docstring : la documentation de la fonction, accessible par \texttt{help(carre)} ou \texttt{carre.\_\_doc\_\_}
        \item[B.] C'est obligatoire pour que la fonction marche
        \item[C.] C'est un commentaire ignoré par Python
        \item[D.] C'est un test unitaire
    \end{itemize}
\end{frame}

% Q8 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 8 \textemdash{} Docstring}
    Que fait la première ligne en triples
guillemets dans une fonction ?
\begin{lstlisting}
def carre(x):
    """Renvoie le carré de x."""
    return x * x
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{C'est une docstring : la documentation de la fonction, accessible par \texttt{help(carre)} ou \texttt{carre.\_\_doc\_\_}}
        \item[B.] C'est obligatoire pour que la fonction marche
        \item[C.] C'est un commentaire ignoré par Python
        \item[D.] C'est un test unitaire
    \end{itemize}
\end{frame}

% Q9 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 9 \textemdash{} Variable locale}
    Le code suivant lève-t-il une erreur ?
\begin{lstlisting}
def f():
    x = 5

f()
print(x)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Non, il affiche \texttt{0}
        \item[B.] Non, mais il affiche \texttt{None}
        \item[C.] Non, il affiche 5
        \item[D.] Oui : \texttt{NameError} car \texttt{x} n'est pas définie hors de \texttt{f}
    \end{itemize}
\end{frame}

% Q9 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 9 \textemdash{} Variable locale}
    Le code suivant lève-t-il une erreur ?
\begin{lstlisting}
def f():
    x = 5

f()
print(x)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Non, il affiche \texttt{0}
        \item[B.] Non, mais il affiche \texttt{None}
        \item[C.] Non, il affiche 5
        \item[\alert{D.}] \alert{Oui : \texttt{NameError} car \texttt{x} n'est pas définie hors de \texttt{f}}
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que fait ce code ?
\begin{lstlisting}
def saluer(nom):
    print("Bonjour", nom)

saluer("Alice")
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Lève une erreur
        \item[B.] Affiche \texttt{Bonjour Alice}
        \item[C.] Renvoie la chaîne \texttt{"Bonjour Alice"} mais sans afficher
        \item[D.] N'affiche rien
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    Que fait ce code ?
\begin{lstlisting}
def saluer(nom):
    print("Bonjour", nom)

saluer("Alice")
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Lève une erreur
        \item[\alert{B.}] \alert{Affiche \texttt{Bonjour Alice}}
        \item[C.] Renvoie la chaîne \texttt{"Bonjour Alice"} mais sans afficher
        \item[D.] N'affiche rien
    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Paramètre par défaut}
    Que donne ce code ?
\begin{lstlisting}
def saluer(nom="ami"):
    return "Bonjour " + nom

print(saluer())
print(saluer("Alice"))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
Erreur
Bonjour Alice
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
Bonjour ami
Bonjour Alice
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
Bonjour ami
Bonjour ami
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
Bonjour
Bonjour Alice
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Paramètre par défaut}
    Que donne ce code ?
\begin{lstlisting}
def saluer(nom="ami"):
    return "Bonjour " + nom

print(saluer())
print(saluer("Alice"))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
Erreur
Bonjour Alice
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
Bonjour ami
Bonjour Alice
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
Bonjour ami
Bonjour ami
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
Bonjour
Bonjour Alice
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile]{Question 12 \textemdash{} Paramètres nommés}
    Quelle est la différence entre
\texttt{puissance(2, 10)} et
\texttt{puissance(base=2, exposant=10)} ?\medskip
    \begin{itemize}
        \item[A.] La seconde forme ne marche que pour les fonctions natives
        \item[B.] La première forme est obsolète
        \item[C.] La seconde forme est plus rapide
        \item[\alert<2>{D.}] \alert<2>{Aucune, les deux sont équivalents si la fonction est \texttt{def puissance(base, exposant):}}
    \end{itemize}
\end{frame}

% Q13 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Variable globale}
    Quel est le résultat ?
\begin{lstlisting}
x = 10

def f():
    return x + 1

print(f())
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Erreur (x non défini)
        \item[B.] 11
        \item[C.] Aucune sortie
        \item[D.] 10
    \end{itemize}
\end{frame}

% Q13 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Variable globale}
    Quel est le résultat ?
\begin{lstlisting}
x = 10

def f():
    return x + 1

print(f())
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Erreur (x non défini)
        \item[\alert{B.}] \alert{11}
        \item[C.] Aucune sortie
        \item[D.] 10
    \end{itemize}
\end{frame}

% Q14 - Réponse en B
\begin{frame}[fragile]{Question 14 \textemdash{} Modifier une globale}
    Pour modifier une variable globale dans une
fonction, quel mot-clé utiliser ?\medskip
    \begin{itemize}
        \item[A.] \texttt{nonlocal}
        \item[\alert<2>{B.}] \alert<2>{\texttt{global}}
        \item[C.] \texttt{outer}
        \item[D.] \texttt{var}
    \end{itemize}
\end{frame}

% Q15 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Retour multiple}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(liste):
    return min(liste), max(liste)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Un tuple \texttt{(min, max)}
        \item[B.] Une liste de deux éléments
        \item[C.] Un dictionnaire
        \item[D.] Erreur : on ne peut pas avoir deux retours
    \end{itemize}
\end{frame}

% Q15 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Retour multiple}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(liste):
    return min(liste), max(liste)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Un tuple \texttt{(min, max)}}
        \item[B.] Une liste de deux éléments
        \item[C.] Un dictionnaire
        \item[D.] Erreur : on ne peut pas avoir deux retours
    \end{itemize}
\end{frame}

% Q16 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Fonction comme valeur}
    \begin{lstlisting}
def carre(x): return x * x

f = carre
print(f(3))
\end{lstlisting}
Que se passe-t-il ?\medskip
    \begin{itemize}
        \item[A.] Erreur : on ne peut pas affecter une fonction
        \item[B.] Affiche 3
        \item[C.] Affiche 9
        \item[D.] Affiche \texttt{<function carre>}
    \end{itemize}
\end{frame}

% Q16 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Fonction comme valeur}
    \begin{lstlisting}
def carre(x): return x * x

f = carre
print(f(3))
\end{lstlisting}
Que se passe-t-il ?\medskip
    \begin{itemize}
        \item[A.] Erreur : on ne peut pas affecter une fonction
        \item[B.] Affiche 3
        \item[\alert{C.}] \alert{Affiche 9}
        \item[D.] Affiche \texttt{<function carre>}
    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Portée locale}
    \begin{lstlisting}
x = 10

def f():
    x = 20
    print(x)

f()
print(x)
\end{lstlisting}
Qu'affiche ce code ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
10
10
\end{lstlisting}

        \item[B.] Une exception
        \item[C.]~\\
\begin{lstlisting}
20
20
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
20
10
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Portée locale}
    \begin{lstlisting}
x = 10

def f():
    x = 20
    print(x)

f()
print(x)
\end{lstlisting}
Qu'affiche ce code ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
10
10
\end{lstlisting}

        \item[B.] Une exception
        \item[C.]~\\
\begin{lstlisting}
20
20
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
20
10
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile]{Question 18 \textemdash{} Renvoyer ou afficher ?}
    Quelle est la différence entre une fonction qui
\textbf{renvoie} une valeur et une fonction qui
\textbf{affiche} une valeur ?\medskip
    \begin{itemize}
        \item[A.] \texttt{print} est plus rapide que \texttt{return}
        \item[\alert<2>{B.}] \alert<2>{Une fonction qui renvoie produit une valeur réutilisable par l'appelant via \texttt{return} ; une fonction qui affiche écrit à l'écran avec \texttt{print} mais ne renvoie rien d'utilisable}
        \item[C.] \texttt{return} n'existe pas en Python
        \item[D.] Aucune différence
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} print vs return}
    Pourquoi ce code n'affiche-t-il \textbf{rien} sur la
console ?
\begin{lstlisting}
def carre(x):
    return x * x

carre(5)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que la fonction n'est pas appelée
        \item[B.] Parce que \texttt{5} n'est pas un entier
        \item[C.] Parce que \texttt{return} ne fait pas d'affichage : la valeur 25 est calculée puis ignorée
        \item[D.] Parce que la fonction est buggée
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} print vs return}
    Pourquoi ce code n'affiche-t-il \textbf{rien} sur la
console ?
\begin{lstlisting}
def carre(x):
    return x * x

carre(5)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que la fonction n'est pas appelée
        \item[B.] Parce que \texttt{5} n'est pas un entier
        \item[\alert{C.}] \alert{Parce que \texttt{return} ne fait pas d'affichage : la valeur 25 est calculée puis ignorée}
        \item[D.] Parce que la fonction est buggée
    \end{itemize}
\end{frame}

% Q20 - Réponse en C
\begin{frame}[fragile]{Question 20 \textemdash{} Décomposer}
    Pourquoi est-il recommandé de \textbf{décomposer} un
programme en fonctions ?\medskip
    \begin{itemize}
        \item[A.] Pour économiser de la mémoire
        \item[B.] Parce que le compilateur le demande
        \item[\alert<2>{C.}] \alert<2>{Pour la lisibilité, la réutilisation et la testabilité : chaque fonction fait une chose, on peut la tester séparément}
        \item[D.] Parce que c'est plus court d'écrire
    \end{itemize}
\end{frame}

% Q21 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Piège de portée}
    \begin{lstlisting}
x = 10

def f():
    x = 20
    return x

print(f())
print(x)
\end{lstlisting}
Quel est le résultat ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
10
10
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
20
20
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
20
10
\end{lstlisting}

        \item[D.] Erreur
    \end{itemize}
\end{frame}

% Q21 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Piège de portée}
    \begin{lstlisting}
x = 10

def f():
    x = 20
    return x

print(f())
print(x)
\end{lstlisting}
Quel est le résultat ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
10
10
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
20
20
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
20
10
\end{lstlisting}

        \item[D.] Erreur
    \end{itemize}
\end{frame}

% Q22 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Retours multiples}
    \begin{lstlisting}
def signe(x):
    if x > 0:
        return 1
    if x < 0:
        return -1
    return 0
\end{lstlisting}
Pourquoi ce code marche-t-il sans \texttt{elif} ?\medskip
    \begin{itemize}
        \item[A.] Parce que \texttt{return} interrompt la fonction : si \texttt{x > 0}, le premier \texttt{return 1} empêche l'exécution des suivants
        \item[B.] Parce que Python comprend automatiquement
        \item[C.] Parce que les \texttt{if} sont équivalents à des \texttt{elif}
        \item[D.] Parce qu'il n'y a qu'un seul \texttt{else}
    \end{itemize}
\end{frame}

% Q22 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Retours multiples}
    \begin{lstlisting}
def signe(x):
    if x > 0:
        return 1
    if x < 0:
        return -1
    return 0
\end{lstlisting}
Pourquoi ce code marche-t-il sans \texttt{elif} ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Parce que \texttt{return} interrompt la fonction : si \texttt{x > 0}, le premier \texttt{return 1} empêche l'exécution des suivants}
        \item[B.] Parce que Python comprend automatiquement
        \item[C.] Parce que les \texttt{if} sont équivalents à des \texttt{elif}
        \item[D.] Parce qu'il n'y a qu'un seul \texttt{else}
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Paramètre mutable}
    \begin{lstlisting}
def ajouter(liste, x):
    liste.append(x)

ma_liste = [1, 2]
ajouter(ma_liste, 3)
print(ma_liste)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[3]}
        \item[B.] \texttt{[1, 2, 3]}
        \item[C.] Erreur
        \item[D.] \texttt{[1, 2]}
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Paramètre mutable}
    \begin{lstlisting}
def ajouter(liste, x):
    liste.append(x)

ma_liste = [1, 2]
ajouter(ma_liste, 3)
print(ma_liste)
\end{lstlisting}
Que produit ce code ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[3]}
        \item[\alert{B.}] \alert{\texttt{[1, 2, 3]}}
        \item[C.] Erreur
        \item[D.] \texttt{[1, 2]}
    \end{itemize}
\end{frame}

% Q24 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 24 \textemdash{} Piège du défaut mutable}
    \begin{lstlisting}
def ajouter(x, liste=[]):
    liste.append(x)
    return liste

print(ajouter(1))
print(ajouter(2))
\end{lstlisting}
Quel résultat (surprenant) ?\medskip
    \begin{itemize}
        \item[A.] Erreur
        \item[B.]~\\
\begin{lstlisting}
[1]
[1, 2]
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
[1, 2]
[1, 2]
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
[1]
[2]
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q24 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 24 \textemdash{} Piège du défaut mutable}
    \begin{lstlisting}
def ajouter(x, liste=[]):
    liste.append(x)
    return liste

print(ajouter(1))
print(ajouter(2))
\end{lstlisting}
Quel résultat (surprenant) ?\medskip
    \begin{itemize}
        \item[A.] Erreur
        \item[\alert{B.}]~\\
\begin{lstlisting}
[1]
[1, 2]
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
[1, 2]
[1, 2]
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
[1]
[2]
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q25 - Réponse en D
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes sur les
fonctions Python, laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] Les fonctions Python peuvent être passées comme paramètres d'autres fonctions
        \item[B.] On peut renvoyer plusieurs valeurs avec un tuple (ex. \texttt{return a, b}).
        \item[C.] Une fonction sans \texttt{return} renvoie implicitement \texttt{None}
        \item[\alert<2>{D.}] \alert<2>{Les variables locales d'une fonction sont accessibles depuis l'extérieur}
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Composition d'appels de fonctions}
    On considère le code suivant :

\begin{lstlisting}
def carre(x):
    return x * x

def incremente(x):
    return x + 1

a = carre(incremente(3))
\end{lstlisting}

Quelle est la valeur de \texttt{a} après l'exécution ?\medskip
    \begin{itemize}
        \item[A.] $10$
        \item[B.] $7$
        \item[C.] $9$
        \item[D.] $16$
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Composition d'appels de fonctions}
    On considère le code suivant :

\begin{lstlisting}
def carre(x):
    return x * x

def incremente(x):
    return x + 1

a = carre(incremente(3))
\end{lstlisting}

Quelle est la valeur de \texttt{a} après l'exécution ?\medskip
    \begin{itemize}
        \item[A.] $10$
        \item[B.] $7$
        \item[C.] $9$
        \item[\alert{D.}] \alert{$16$}
    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Annotations de type}
    On lit la signature suivante :

\begin{lstlisting}
def aire(longueur: float, largeur: float) -> float:
\end{lstlisting}

Que signifie la flèche \texttt{->} et l'annotation \texttt{float}
qui la suit ?\medskip
    \begin{itemize}
        \item[A.] C'est une annotation indiquant que la fonction est censée renvoyer un flottant ; cela documente l'intention sans imposer de vérification à l'exécution
        \item[B.] La syntaxe est invalide en Python
        \item[C.] La flèche transforme le résultat en flottant avant de le renvoyer
        \item[D.] La fonction renvoie obligatoirement un nombre flottant, sinon Python lève une exception
    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Annotations de type}
    On lit la signature suivante :

\begin{lstlisting}
def aire(longueur: float, largeur: float) -> float:
\end{lstlisting}

Que signifie la flèche \texttt{->} et l'annotation \texttt{float}
qui la suit ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{C'est une annotation indiquant que la fonction est censée renvoyer un flottant ; cela documente l'intention sans imposer de vérification à l'exécution}
        \item[B.] La syntaxe est invalide en Python
        \item[C.] La flèche transforme le résultat en flottant avant de le renvoyer
        \item[D.] La fonction renvoie obligatoirement un nombre flottant, sinon Python lève une exception
    \end{itemize}
\end{frame}

% Q28 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Effet de bord sur une liste paramètre}
    On exécute le code suivant :

\begin{lstlisting}
def ajouter_zero(t):
    t.append(0)

ma_liste = [1, 2, 3]
ajouter_zero(ma_liste)
print(ma_liste)
\end{lstlisting}

Que va afficher \texttt{print} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[1, 2, 3, 0]}
        \item[B.] Le code lève une erreur car \texttt{t} n'est pas connu en dehors de la fonction
        \item[C.] \texttt{[1, 2, 3]}
        \item[D.] \texttt{[0, 1, 2, 3]}
    \end{itemize}
\end{frame}

% Q28 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Effet de bord sur une liste paramètre}
    On exécute le code suivant :

\begin{lstlisting}
def ajouter_zero(t):
    t.append(0)

ma_liste = [1, 2, 3]
ajouter_zero(ma_liste)
print(ma_liste)
\end{lstlisting}

Que va afficher \texttt{print} ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{\texttt{[1, 2, 3, 0]}}
        \item[B.] Le code lève une erreur car \texttt{t} n'est pas connu en dehors de la fonction
        \item[C.] \texttt{[1, 2, 3]}
        \item[D.] \texttt{[0, 1, 2, 3]}
    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Fonction prédicat}
    On souhaite écrire une fonction \texttt{est\_pair(n)} qui
renvoie \texttt{True} si l'entier \texttt{n} est pair, \texttt{False}
sinon. Quelle écriture est la plus claire et la plus
idiomatique ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def est_pair(n):
    if n % 2 == 0:
        return True
    else:
        return False
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def est_pair(n):
    return n % 2 == 0
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def est_pair(n):
    return n / 2
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def est_pair(n):
    print(n % 2 == 0)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Fonction prédicat}
    On souhaite écrire une fonction \texttt{est\_pair(n)} qui
renvoie \texttt{True} si l'entier \texttt{n} est pair, \texttt{False}
sinon. Quelle écriture est la plus claire et la plus
idiomatique ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def est_pair(n):
    if n % 2 == 0:
        return True
    else:
        return False
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
def est_pair(n):
    return n % 2 == 0
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def est_pair(n):
    return n / 2
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def est_pair(n):
    print(n % 2 == 0)
\end{lstlisting}

    \end{itemize}
\end{frame}

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

\end{document}
