\documentclass[a4paper,11pt]{article}

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

\title{Fonctions}
\date{Numérique et sciences informatiques}

\begin{document}

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

\bigskip

\element{premierefonctions}{
  \begin{question}{q01}
    Comment définit-on une fonction \texttt{carre} qui
prend \texttt{x} en paramètre et renvoie \texttt{x * x} ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def carre(x) -> x * x
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
carre = x * x
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
function carre(x) {
    return x * x
}
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def carre(x):
    return x * x
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q02}
    Après \texttt{def carre(x): return x * x}, comment
appelle-t-on cette fonction sur la valeur 5 ?
    \begin{choices}
    \correctchoice{\texttt{carre(5)}}
    \wrongchoice{\texttt{carre 5}}
    \wrongchoice{\texttt{call carre(5)}}
    \wrongchoice{\texttt{carre[5]}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q03}
    À quoi sert l'instruction \texttt{return} ?
    \begin{choices}
    \wrongchoice{À redémarrer la fonction}
    \correctchoice{À renvoyer une valeur à l'appelant et terminer la fonction}
    \wrongchoice{À afficher le résultat sur la console}
    \wrongchoice{À déclarer une variable globale}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q04}
    Quelle fonction a \textbf{deux} paramètres ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def f(x):
    return x
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def f():
    return 0
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def f(x; y):
    return x + y
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def f(x, y):
    return x + y
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q05}
    Que renvoie une fonction qui ne contient \textbf{aucun
\texttt{return}} ?
    \begin{choices}
    \correctchoice{\texttt{None}}
    \wrongchoice{Une erreur}
    \wrongchoice{Une chaîne vide \texttt{""}}
    \wrongchoice{\texttt{0}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q06}
    Parmi les suivants, lequel n'est \textbf{pas} une
fonction native de Python ?
    \begin{choices}
    \correctchoice{\texttt{carre(...)}}
    \wrongchoice{\texttt{type(...)}}
    \wrongchoice{\texttt{len(...)}}
    \wrongchoice{\texttt{max(...)}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q07}
    \begin{lstlisting}
def double(x):
    return x * 2

a = double(3)
b = double(double(5))
\end{lstlisting}
Que valent \texttt{a} et \texttt{b} ?
    \begin{choices}
    \correctchoice{a = 6, b = 20}
    \wrongchoice{a = 6, b = 25}
    \wrongchoice{a = 3, b = 5}
    \wrongchoice{a = 6, b = 10}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q08}
    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}
    \begin{choices}
    \correctchoice{C'est une docstring : la documentation de la fonction, accessible par \texttt{help(carre)} ou \texttt{carre.\_\_doc\_\_}}
    \wrongchoice{C'est obligatoire pour que la fonction marche}
    \wrongchoice{C'est un commentaire ignoré par Python}
    \wrongchoice{C'est un test unitaire}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q09}
    Le code suivant lève-t-il une erreur ?
\begin{lstlisting}
def f():
    x = 5

f()
print(x)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Non, il affiche \texttt{0}}
    \wrongchoice{Non, mais il affiche \texttt{None}}
    \wrongchoice{Non, il affiche 5}
    \correctchoice{Oui : \texttt{NameError} car \texttt{x} n'est pas définie hors de \texttt{f}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q10}
    Que fait ce code ?
\begin{lstlisting}
def saluer(nom):
    print("Bonjour", nom)

saluer("Alice")
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Lève une erreur}
    \correctchoice{Affiche \texttt{Bonjour Alice}}
    \wrongchoice{Renvoie la chaîne \texttt{"Bonjour Alice"} mais sans afficher}
    \wrongchoice{N'affiche rien}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q11}
    Que donne ce code ?
\begin{lstlisting}
def saluer(nom="ami"):
    return "Bonjour " + nom

print(saluer())
print(saluer("Alice"))
\end{lstlisting}
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
Erreur
Bonjour Alice
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
Bonjour ami
Bonjour Alice
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
Bonjour ami
Bonjour ami
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
Bonjour
Bonjour Alice
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q12}
    Quelle est la différence entre
\texttt{puissance(2, 10)} et
\texttt{puissance(base=2, exposant=10)} ?
    \begin{choices}
    \wrongchoice{La seconde forme ne marche que pour les fonctions natives}
    \wrongchoice{La première forme est obsolète}
    \wrongchoice{La seconde forme est plus rapide}
    \correctchoice{Aucune, les deux sont équivalents si la fonction est \texttt{def puissance(base, exposant):}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q13}
    Quel est le résultat ?
\begin{lstlisting}
x = 10

def f():
    return x + 1

print(f())
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Erreur (x non défini)}
    \correctchoice{11}
    \wrongchoice{Aucune sortie}
    \wrongchoice{10}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q14}
    Pour modifier une variable globale dans une
fonction, quel mot-clé utiliser ?
    \begin{choices}
    \wrongchoice{\texttt{nonlocal}}
    \correctchoice{\texttt{global}}
    \wrongchoice{\texttt{outer}}
    \wrongchoice{\texttt{var}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q15}
    Que renvoie cette fonction ?
\begin{lstlisting}
def min_max(liste):
    return min(liste), max(liste)
\end{lstlisting}
    \begin{choices}
    \correctchoice{Un tuple \texttt{(min, max)}}
    \wrongchoice{Une liste de deux éléments}
    \wrongchoice{Un dictionnaire}
    \wrongchoice{Erreur : on ne peut pas avoir deux retours}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q16}
    \begin{lstlisting}
def carre(x): return x * x

f = carre
print(f(3))
\end{lstlisting}
Que se passe-t-il ?
    \begin{choices}
    \wrongchoice{Erreur : on ne peut pas affecter une fonction}
    \wrongchoice{Affiche 3}
    \correctchoice{Affiche 9}
    \wrongchoice{Affiche \texttt{<function carre>}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q17}
    \begin{lstlisting}
x = 10

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

f()
print(x)
\end{lstlisting}
Qu'affiche ce code ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
10
10
\end{lstlisting}
}
    \wrongchoice{Une exception}
    \wrongchoice{\begin{lstlisting}
20
20
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
20
10
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q18}
    Quelle est la différence entre une fonction qui
\textbf{renvoie} une valeur et une fonction qui
\textbf{affiche} une valeur ?
    \begin{choices}
    \wrongchoice{\texttt{print} est plus rapide que \texttt{return}}
    \correctchoice{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}
    \wrongchoice{\texttt{return} n'existe pas en Python}
    \wrongchoice{Aucune différence}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q19}
    Pourquoi ce code n'affiche-t-il \textbf{rien} sur la
console ?
\begin{lstlisting}
def carre(x):
    return x * x

carre(5)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Parce que la fonction n'est pas appelée}
    \wrongchoice{Parce que \texttt{5} n'est pas un entier}
    \correctchoice{Parce que \texttt{return} ne fait pas d'affichage : la valeur 25 est calculée puis ignorée}
    \wrongchoice{Parce que la fonction est buggée}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q20}
    Pourquoi est-il recommandé de \textbf{décomposer} un
programme en fonctions ?
    \begin{choices}
    \wrongchoice{Pour économiser de la mémoire}
    \wrongchoice{Parce que le compilateur le demande}
    \correctchoice{Pour la lisibilité, la réutilisation et la testabilité : chaque fonction fait une chose, on peut la tester séparément}
    \wrongchoice{Parce que c'est plus court d'écrire}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q21}
    \begin{lstlisting}
x = 10

def f():
    x = 20
    return x

print(f())
print(x)
\end{lstlisting}
Quel est le résultat ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
10
10
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
20
20
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
20
10
\end{lstlisting}
}
    \wrongchoice{Erreur}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q22}
    \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} ?
    \begin{choices}
    \correctchoice{Parce que \texttt{return} interrompt la fonction : si \texttt{x > 0}, le premier \texttt{return 1} empêche l'exécution des suivants}
    \wrongchoice{Parce que Python comprend automatiquement}
    \wrongchoice{Parce que les \texttt{if} sont équivalents à des \texttt{elif}}
    \wrongchoice{Parce qu'il n'y a qu'un seul \texttt{else}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q23}
    \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 ?
    \begin{choices}
    \wrongchoice{\texttt{[3]}}
    \correctchoice{\texttt{[1, 2, 3]}}
    \wrongchoice{Erreur}
    \wrongchoice{\texttt{[1, 2]}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q24}
    \begin{lstlisting}
def ajouter(x, liste=[]):
    liste.append(x)
    return liste

print(ajouter(1))
print(ajouter(2))
\end{lstlisting}
Quel résultat (surprenant) ?
    \begin{choices}
    \wrongchoice{Erreur}
    \correctchoice{\begin{lstlisting}
[1]
[1, 2]
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
[1, 2]
[1, 2]
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
[1]
[2]
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q25}
    Parmi les affirmations suivantes sur les
fonctions Python, laquelle est \textbf{fausse} ?
    \begin{choices}
    \wrongchoice{Les fonctions Python peuvent être passées comme paramètres d'autres fonctions}
    \wrongchoice{On peut renvoyer plusieurs valeurs avec un tuple (ex. \texttt{return a, b}).}
    \wrongchoice{Une fonction sans \texttt{return} renvoie implicitement \texttt{None}}
    \correctchoice{Les variables locales d'une fonction sont accessibles depuis l'extérieur}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q26}
    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 ?
    \begin{choices}
    \wrongchoice{$10$}
    \wrongchoice{$7$}
    \wrongchoice{$9$}
    \correctchoice{$16$}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q27}
    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 ?
    \begin{choices}
    \correctchoice{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}
    \wrongchoice{La syntaxe est invalide en Python}
    \wrongchoice{La flèche transforme le résultat en flottant avant de le renvoyer}
    \wrongchoice{La fonction renvoie obligatoirement un nombre flottant, sinon Python lève une exception}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q28}
    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} ?
    \begin{choices}
    \correctchoice{\texttt{[1, 2, 3, 0]}}
    \wrongchoice{Le code lève une erreur car \texttt{t} n'est pas connu en dehors de la fonction}
    \wrongchoice{\texttt{[1, 2, 3]}}
    \wrongchoice{\texttt{[0, 1, 2, 3]}}
    \end{choices}
  \end{question}
}

\element{premierefonctions}{
  \begin{question}{q29}
    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 ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def est_pair(n):
    if n % 2 == 0:
        return True
    else:
        return False
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def est_pair(n):
    return n % 2 == 0
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def est_pair(n):
    return n / 2
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def est_pair(n):
    print(n % 2 == 0)
\end{lstlisting}
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{premierefonctions}
  \insertgroup{premierefonctions}
}

\end{document}
