\documentclass[a4paper,11pt]{article}

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

\title{Classes et programmation objet}
\date{Numérique et sciences informatiques}

\begin{document}

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

\bigskip

\element{terminaleclassesobjets}{
  \begin{question}{q01}
    En programmation orientée objet, qu'est-ce
qu'une \textbf{classe} ?
    \begin{choices}
    \correctchoice{Un modèle ou « plan » qui décrit la structure (les attributs) et le comportement (les méthodes) d'objets de même nature}
    \wrongchoice{Un fichier source Python}
    \wrongchoice{Un type particulier d'erreur Python}
    \wrongchoice{Une simple variable du programme}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q02}
    Qu'est-ce qu'un \textbf{objet} (ou
\textbf{instance}) d'une classe ?
    \begin{choices}
    \correctchoice{Une réalisation concrète d'une classe, possédant ses propres valeurs d'attributs}
    \wrongchoice{Un commentaire inséré dans le code source}
    \wrongchoice{Un fichier de configuration du programme}
    \wrongchoice{Un type primitif comme un entier ou un flottant}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q03}
    Qu'est-ce qu'un \textbf{attribut} d'une
classe ?
    \begin{choices}
    \wrongchoice{Une fonction définie à l'intérieur de la classe}
    \wrongchoice{Un module de la bibliothèque Python}
    \correctchoice{Une donnée propre à un objet, par exemple le \texttt{nom} ou l'\texttt{age} d'une \texttt{Personne}}
    \wrongchoice{Un type particulier de boucle}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q04}
    Qu'est-ce qu'une \textbf{méthode} d'une
classe ?
    \begin{choices}
    \correctchoice{Une fonction définie dans la classe, qui peut accéder aux attributs des instances et agir sur eux}
    \wrongchoice{Un fichier dédié aux tests automatisés}
    \wrongchoice{Un attribut un peu particulier}
    \wrongchoice{Un type de variable particulier}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q05}
    Quelle est la syntaxe Python correcte
pour \textbf{définir} une classe \texttt{Voiture}
vide ?
    \begin{choices}
    \correctchoice{\begin{lstlisting}
class Voiture:
    pass
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
new class Voiture {}
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
Voiture = class()
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def Voiture():
    pass
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q06}
    Comment \textbf{crée-t-on une instance} de
la classe \texttt{Voiture} en Python ?
    \begin{choices}
    \wrongchoice{Avec la syntaxe \texttt{v = new Voiture()}}
    \wrongchoice{Avec la syntaxe \texttt{v = create Voiture}}
    \wrongchoice{Avec la syntaxe \texttt{v = Voiture}}
    \correctchoice{Avec la syntaxe \texttt{v = Voiture()}}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q07}
    Si \texttt{v} est une instance de la classe
\texttt{Voiture} possédant un attribut
\texttt{marque}, comment lit-on la valeur de
cet attribut ?
    \begin{choices}
    \correctchoice{Avec la notation \texttt{v.marque}}
    \wrongchoice{Avec la notation \texttt{v->marque}}
    \wrongchoice{Avec un appel \texttt{get(v, marque)}}
    \wrongchoice{Avec la notation \texttt{v["marque"]}}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q08}
    À quoi sert le paramètre \textbf{\texttt{self}}
dans les méthodes d'une classe Python ?
    \begin{choices}
    \wrongchoice{C'est une variable globale du programme}
    \wrongchoice{Il s'agit d'un mot-clé réservé sans signification particulière}
    \wrongchoice{Il fait référence à la classe parente}
    \correctchoice{Il représente l'instance courante sur laquelle la méthode est appelée. Il permet d'accéder aux attributs et aux autres méthodes de l'objet}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q09}
    Quel est le rôle de la méthode
spéciale \textbf{\texttt{\_\_init\_\_}} d'une classe ?
    \begin{choices}
    \correctchoice{Initialiser les attributs d'un nouvel objet au moment de sa création (rôle de constructeur)}
    \wrongchoice{Détruire l'objet en fin de vie}
    \wrongchoice{Initialiser l'ensemble du programme}
    \wrongchoice{Importer un module dans le programme}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q10}
    Que produit ce code ?
\begin{lstlisting}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
print(p.x, p.y)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Il affiche \texttt{Point(3, 4)}}
    \correctchoice{Il affiche \texttt{3 4}}
    \wrongchoice{Il affiche \texttt{7}}
    \wrongchoice{Il déclenche une erreur de syntaxe}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q11}
    Comment ajouter une méthode
\texttt{distance\_origine} à la classe
\texttt{Point}, qui renvoie la distance
du point à l'origine $(0, 0)$ ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
class Point:
    def distance_origine():
        return ...
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def distance_origine(p):
    return (p.x ** 2 + p.y ** 2) ** 0.5
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
class Point:
    ...
    def distance_origine(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Point:
    distance_origine = (x ** 2 + y ** 2) ** 0.5
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q12}
    Combien d'instances peut-on créer à
partir d'une seule classe ?
    \begin{choices}
    \wrongchoice{Au plus dix instances}
    \correctchoice{Autant d'instances que nécessaire, chacune ayant ses propres valeurs d'attributs}
    \wrongchoice{Une seule instance par classe}
    \wrongchoice{Aucune instance ne peut être créée}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q13}
    On souhaite écrire une classe \texttt{Pile}
(de type LIFO) avec les méthodes
\texttt{empiler} et \texttt{depiler}. Quel
\texttt{\_\_init\_\_} choisir ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def __init__(self):
    return []
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def __init__():
    elements = []
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def __init__(self):
    elements = []
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def __init__(self):
    self.elements = []
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q14}
    Quel est l'intérêt principal de
regrouper, dans une même classe,
les \textbf{attributs} (les données) et
les \textbf{méthodes} (les
comportements) qui les manipulent ?
    \begin{choices}
    \wrongchoice{Le code est plus court mais devient moins lisible}
    \correctchoice{Les opérations qui agissent sur une donnée sont placées à côté de cette donnée, ce qui rend le code plus cohérent et plus facile à faire évoluer}
    \wrongchoice{Les données sont automatiquement enregistrées sur le disque}
    \wrongchoice{Le programme s'exécute plus rapidement}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q15}
    À quoi sert la méthode spéciale
\textbf{\texttt{\_\_str\_\_}} ?
    \begin{choices}
    \wrongchoice{À supprimer l'objet}
    \wrongchoice{À convertir l'objet en entier}
    \wrongchoice{À déclarer une variable}
    \correctchoice{À définir la représentation textuelle de l'objet, utilisée par \texttt{print(obj)} et \texttt{str(obj)}}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q16}
    Pourquoi la programmation orientée
objet est-elle particulièrement
utile pour implémenter des
\textbf{structures de données} comme les
arbres ou les graphes ?
    \begin{choices}
    \wrongchoice{Aucune raison particulière}
    \correctchoice{Elle permet de regrouper proprement les données (par exemple \texttt{valeur}, \texttt{gauche}, \texttt{droite} pour un nœud d'arbre) et les opérations (parcours, recherche, insertion) en une seule entité}
    \wrongchoice{Elle est plus rapide à exécuter}
    \wrongchoice{Elle est obligatoire dans le programme officiel}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q17}
    Quelle est la différence entre
l'\textbf{interface} et
l'\textbf{implémentation} d'une
structure de données ?
    \begin{choices}
    \wrongchoice{Aucune différence}
    \wrongchoice{L'implémentation est aujourd'hui une notion obsolète}
    \correctchoice{L'interface désigne l'ensemble des opérations disponibles (les signatures des méthodes). L'implémentation désigne la manière dont ces opérations sont effectivement réalisées en code}
    \wrongchoice{L'interface s'exécute plus rapidement que l'implémentation}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q18}
    Que renvoie l'appel \texttt{type(p)}
lorsque \texttt{p} est une instance de
\texttt{Point} ?
    \begin{choices}
    \correctchoice{\texttt{<class 'Point'>}}
    \wrongchoice{\texttt{object}}
    \wrongchoice{\texttt{Point}}
    \wrongchoice{Une exception}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q19}
    \begin{lstlisting}
class Compteur:
    def __init__(self):
        self.n = 0
    def incrementer(self):
        self.n += 1

c = Compteur()
c.incrementer()
c.incrementer()
print(c.n)
\end{lstlisting}
Que produit ce code ?
    \begin{choices}
    \wrongchoice{Il déclenche une erreur}
    \correctchoice{Il affiche \texttt{2}}
    \wrongchoice{Il affiche \texttt{0}}
    \wrongchoice{Il affiche \texttt{1}}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q20}
    Laquelle des affirmations
suivantes est correcte au sujet
des objets en Python ?
    \begin{choices}
    \wrongchoice{Les fonctions ne sont pas des objets}
    \wrongchoice{Seules les classes définies par l'utilisateur produisent des objets}
    \correctchoice{En Python, tout est un objet : les entiers, les chaînes, les listes, les fonctions et même les classes sont des instances de classes prédéfinies}
    \wrongchoice{Aucune des affirmations précédentes n'est correcte}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q21}
    Pour représenter un \textbf{nœud
d'arbre binaire} comportant une
valeur, un sous-arbre gauche et
un sous-arbre droit, quelle
définition de classe est
correcte ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def Noeud(val, gauche, droite):
    return val
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Noeud:
    pass
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
class Noeud:
    def __init__(self, val, gauche=None, droite=None):
        self.val = val
        self.gauche = gauche
        self.droite = droite
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Noeud:
    val = 0
    gauche = None
    droite = None
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q22}
    \begin{lstlisting}
class Voiture:
    marques = []
    def __init__(self, marque):
        Voiture.marques.append(marque)

v1 = Voiture("Renault")
v2 = Voiture("Peugeot")
print(Voiture.marques)
\end{lstlisting}
Que produit ce code ?
    \begin{choices}
    \wrongchoice{Il affiche \texttt{['Peugeot']}}
    \correctchoice{Il affiche \texttt{['Renault', 'Peugeot']}}
    \wrongchoice{Il affiche \texttt{[]}}
    \wrongchoice{Il déclenche une erreur}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q23}
    Quelle pratique est
\textbf{déconseillée} en programmation
orientée objet ?
    \begin{choices}
    \wrongchoice{Utiliser des méthodes pour modifier les attributs d'un objet}
    \wrongchoice{Définir un constructeur \texttt{\_\_init\_\_}}
    \wrongchoice{Donner un nom en CamelCase à la classe}
    \correctchoice{Modifier directement les attributs internes d'un objet depuis l'extérieur, par exemple en écrivant \texttt{compte.solde = -1000} au lieu de passer par une méthode comme \texttt{compte.deposer(...)}}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q24}
    Dans quel cas est-il \textbf{judicieux}
d'utiliser une classe plutôt
qu'une simple fonction ?
    \begin{choices}
    \wrongchoice{Jamais, les classes ne servent à rien en pratique}
    \wrongchoice{Pour calculer la somme d'une liste de notes}
    \wrongchoice{Toujours, car c'est l'approche la plus moderne}
    \correctchoice{Pour modéliser une entité avec un état qui change au cours du temps et plusieurs comportements liés : par exemple un compte bancaire, une voiture, ou une structure de données comme une pile}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q25}
    Parmi les affirmations suivantes
sur la programmation orientée
objet en Python, laquelle est
\textbf{fausse} ?
    \begin{choices}
    \wrongchoice{La méthode \texttt{\_\_init\_\_} est appelée automatiquement à la création d'une instance}
    \correctchoice{Le paramètre \texttt{self} doit obligatoirement s'appeler \texttt{self}}
    \wrongchoice{En Python, toutes les valeurs (entiers, chaînes, listes, fonctions, classes) sont des objets}
    \wrongchoice{Une classe est un modèle ; une instance est une réalisation concrète}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q26}
    On définit la classe suivante :
\begin{lstlisting}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __eq__(self, autre):
        return self.x == autre.x and self.y == autre.y
\end{lstlisting}
Quel est l'effet d'avoir défini la
méthode \texttt{\_\_eq\_\_} ?
    \begin{choices}
    \wrongchoice{La classe \texttt{Point} devient
immuable
}
    \wrongchoice{Aucun effet : Python ignore les
méthodes commençant par un
double soulignement
}
    \correctchoice{La comparaison \texttt{Point(1, 2) ==
Point(1, 2)} renverra \texttt{True}
(deux points avec mêmes
coordonnées sont considérés
égaux), au lieu de \texttt{False}
comme c'était le cas par défaut
}
    \wrongchoice{Les objets \texttt{Point} ne pourront
plus être créés
}
    \end{choices}
  \end{question}
}

\element{terminaleclassesobjets}{
  \begin{question}{q27}
    On souhaite implémenter une classe
\texttt{Compte} représentant un compte
bancaire avec un solde, une
méthode \texttt{deposer(montant)} et
une méthode \texttt{retirer(montant)}
qui refuse l'opération si le
solde devient négatif. Quel
code est correct ?
    \begin{choices}
    \correctchoice{\begin{lstlisting}
class Compte:
    def __init__(self, solde_initial=0):
        self.solde = solde_initial
    def deposer(self, montant):
        if montant > 0:
            self.solde += montant
    def retirer(self, montant):
        if 0 < montant <= self.solde:
            self.solde -= montant
            return True
        return False
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Compte:
    def __init__(self):
        self.solde = 0
    def __retirer__(self, m):
        self.solde -= m
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def Compte(solde):
    return solde
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Compte:
    solde = 0
    def deposer(montant):
        solde += montant
    def retirer(montant):
        solde -= montant
\end{lstlisting}
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{terminaleclassesobjets}
  \insertgroup{terminaleclassesobjets}
}

\end{document}
