\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{Classes et programmation objet}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

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

% Q1 - Réponse en A
\begin{frame}[fragile]{Question 1 \textemdash{} Notion de classe}
    En programmation orientée objet, qu'est-ce
qu'une \textbf{classe} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Un modèle ou « plan » qui décrit la structure (les attributs) et le comportement (les méthodes) d'objets de même nature}
        \item[B.] Un fichier source Python
        \item[C.] Un type particulier d'erreur Python
        \item[D.] Une simple variable du programme
    \end{itemize}
\end{frame}

% Q2 - Réponse en A
\begin{frame}[fragile]{Question 2 \textemdash{} Notion d'objet}
    Qu'est-ce qu'un \textbf{objet} (ou
\textbf{instance}) d'une classe ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une réalisation concrète d'une classe, possédant ses propres valeurs d'attributs}
        \item[B.] Un commentaire inséré dans le code source
        \item[C.] Un fichier de configuration du programme
        \item[D.] Un type primitif comme un entier ou un flottant
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Attribut}
    Qu'est-ce qu'un \textbf{attribut} d'une
classe ?\medskip
    \begin{itemize}
        \item[A.] Une fonction définie à l'intérieur de la classe
        \item[B.] Un module de la bibliothèque Python
        \item[\alert<2>{C.}] \alert<2>{Une donnée propre à un objet, par exemple le \texttt{nom} ou l'\texttt{age} d'une \texttt{Personne}}
        \item[D.] Un type particulier de boucle
    \end{itemize}
\end{frame}

% Q4 - Réponse en A
\begin{frame}[fragile]{Question 4 \textemdash{} Méthode}
    Qu'est-ce qu'une \textbf{méthode} d'une
classe ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une fonction définie dans la classe, qui peut accéder aux attributs des instances et agir sur eux}
        \item[B.] Un fichier dédié aux tests automatisés
        \item[C.] Un attribut un peu particulier
        \item[D.] Un type de variable particulier
    \end{itemize}
\end{frame}

% Q5 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 5 \textemdash{} Définir une classe}
    Quelle est la syntaxe Python correcte
pour \textbf{définir} une classe \texttt{Voiture}
vide ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
class Voiture:
    pass
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
new class Voiture {}
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
Voiture = class()
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def Voiture():
    pass
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q5 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 5 \textemdash{} Définir une classe}
    Quelle est la syntaxe Python correcte
pour \textbf{définir} une classe \texttt{Voiture}
vide ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
class Voiture:
    pass
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
new class Voiture {}
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
Voiture = class()
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def Voiture():
    pass
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q6 - Réponse en D
\begin{frame}[fragile]{Question 6 \textemdash{} Créer une instance}
    Comment \textbf{crée-t-on une instance} de
la classe \texttt{Voiture} en Python ?\medskip
    \begin{itemize}
        \item[A.] Avec la syntaxe \texttt{v = new Voiture()}
        \item[B.] Avec la syntaxe \texttt{v = create Voiture}
        \item[C.] Avec la syntaxe \texttt{v = Voiture}
        \item[\alert<2>{D.}] \alert<2>{Avec la syntaxe \texttt{v = Voiture()}}
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} Accéder à un attribut}
    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 ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Avec la notation \texttt{v.marque}}
        \item[B.] Avec la notation \texttt{v->marque}
        \item[C.] Avec un appel \texttt{get(v, marque)}
        \item[D.] Avec la notation \texttt{v["marque"]}
    \end{itemize}
\end{frame}

% Q8 - Réponse en D
\begin{frame}[fragile]{Question 8 \textemdash{} Le paramètre self}
    À quoi sert le paramètre \textbf{\texttt{self}}
dans les méthodes d'une classe Python ?\medskip
    \begin{itemize}
        \item[A.] C'est une variable globale du programme
        \item[B.] Il s'agit d'un mot-clé réservé sans signification particulière
        \item[C.] Il fait référence à la classe parente
        \item[\alert<2>{D.}] \alert<2>{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{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile]{Question 9 \textemdash{} La méthode \texttt{\_\_init\_\_}}
    Quel est le rôle de la méthode
spéciale \textbf{\texttt{\_\_init\_\_}} d'une classe ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Initialiser les attributs d'un nouvel objet au moment de sa création (rôle de constructeur)}
        \item[B.] Détruire l'objet en fin de vie
        \item[C.] Initialiser l'ensemble du programme
        \item[D.] Importer un module dans le programme
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    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}\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{Point(3, 4)}
        \item[B.] Il affiche \texttt{3 4}
        \item[C.] Il affiche \texttt{7}
        \item[D.] Il déclenche une erreur de syntaxe
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Trace simple}
    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}\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{Point(3, 4)}
        \item[\alert{B.}] \alert{Il affiche \texttt{3 4}}
        \item[C.] Il affiche \texttt{7}
        \item[D.] Il déclenche une erreur de syntaxe
    \end{itemize}
\end{frame}

% Q11 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Définir une méthode}
    Comment ajouter une méthode
\texttt{distance\_origine} à la classe
\texttt{Point}, qui renvoie la distance
du point à l'origine $(0, 0)$ ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
class Point:
    def distance_origine():
        return ...
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def distance_origine(p):
    return (p.x ** 2 + p.y ** 2) ** 0.5
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
class Point:
    ...
    def distance_origine(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Point:
    distance_origine = (x ** 2 + y ** 2) ** 0.5
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q11 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Définir une méthode}
    Comment ajouter une méthode
\texttt{distance\_origine} à la classe
\texttt{Point}, qui renvoie la distance
du point à l'origine $(0, 0)$ ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
class Point:
    def distance_origine():
        return ...
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def distance_origine(p):
    return (p.x ** 2 + p.y ** 2) ** 0.5
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
class Point:
    ...
    def distance_origine(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Point:
    distance_origine = (x ** 2 + y ** 2) ** 0.5
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q12 - Réponse en B
\begin{frame}[fragile]{Question 12 \textemdash{} Combien d'instances ?}
    Combien d'instances peut-on créer à
partir d'une seule classe ?\medskip
    \begin{itemize}
        \item[A.] Au plus dix instances
        \item[\alert<2>{B.}] \alert<2>{Autant d'instances que nécessaire, chacune ayant ses propres valeurs d'attributs}
        \item[C.] Une seule instance par classe
        \item[D.] Aucune instance ne peut être créée
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Constructeur pour une classe Pile}
    On souhaite écrire une classe \texttt{Pile}
(de type LIFO) avec les méthodes
\texttt{empiler} et \texttt{depiler}. Quel
\texttt{\_\_init\_\_} choisir ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def __init__(self):
    return []
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def __init__():
    elements = []
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def __init__(self):
    elements = []
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def __init__(self):
    self.elements = []
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Constructeur pour une classe Pile}
    On souhaite écrire une classe \texttt{Pile}
(de type LIFO) avec les méthodes
\texttt{empiler} et \texttt{depiler}. Quel
\texttt{\_\_init\_\_} choisir ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def __init__(self):
    return []
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def __init__():
    elements = []
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def __init__(self):
    elements = []
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def __init__(self):
    self.elements = []
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q14 - Réponse en B
\begin{frame}[fragile]{Question 14 \textemdash{} Données et comportements groupés}
    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 ?\medskip
    \begin{itemize}
        \item[A.] Le code est plus court mais devient moins lisible
        \item[\alert<2>{B.}] \alert<2>{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}
        \item[C.] Les données sont automatiquement enregistrées sur le disque
        \item[D.] Le programme s'exécute plus rapidement
    \end{itemize}
\end{frame}

% Q15 - Réponse en D
\begin{frame}[fragile]{Question 15 \textemdash{} La méthode \texttt{\_\_str\_\_}}
    À quoi sert la méthode spéciale
\textbf{\texttt{\_\_str\_\_}} ?\medskip
    \begin{itemize}
        \item[A.] À supprimer l'objet
        \item[B.] À convertir l'objet en entier
        \item[C.] À déclarer une variable
        \item[\alert<2>{D.}] \alert<2>{À définir la représentation textuelle de l'objet, utilisée par \texttt{print(obj)} et \texttt{str(obj)}}
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} Programmation objet et structures de données}
    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 ?\medskip
    \begin{itemize}
        \item[A.] Aucune raison particulière
        \item[\alert<2>{B.}] \alert<2>{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é}
        \item[C.] Elle est plus rapide à exécuter
        \item[D.] Elle est obligatoire dans le programme officiel
    \end{itemize}
\end{frame}

% Q17 - Réponse en C
\begin{frame}[fragile]{Question 17 \textemdash{} Interface et implémentation}
    Quelle est la différence entre
l'\textbf{interface} et
l'\textbf{implémentation} d'une
structure de données ?\medskip
    \begin{itemize}
        \item[A.] Aucune différence
        \item[B.] L'implémentation est aujourd'hui une notion obsolète
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] L'interface s'exécute plus rapidement que l'implémentation
    \end{itemize}
\end{frame}

% Q18 - Réponse en A
\begin{frame}[fragile]{Question 18 \textemdash{} La fonction type appliquée à une instance}
    Que renvoie l'appel \texttt{type(p)}
lorsque \texttt{p} est une instance de
\texttt{Point} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{<class 'Point'>}}
        \item[B.] \texttt{object}
        \item[C.] \texttt{Point}
        \item[D.] Une exception
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Une méthode qui modifie l'objet}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Il déclenche une erreur
        \item[B.] Il affiche \texttt{2}
        \item[C.] Il affiche \texttt{0}
        \item[D.] Il affiche \texttt{1}
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Une méthode qui modifie l'objet}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Il déclenche une erreur
        \item[\alert{B.}] \alert{Il affiche \texttt{2}}
        \item[C.] Il affiche \texttt{0}
        \item[D.] Il affiche \texttt{1}
    \end{itemize}
\end{frame}

% Q20 - Réponse en C
\begin{frame}[fragile]{Question 20 \textemdash{} Tout est objet en Python}
    Laquelle des affirmations
suivantes est correcte au sujet
des objets en Python ?\medskip
    \begin{itemize}
        \item[A.] Les fonctions ne sont pas des objets
        \item[B.] Seules les classes définies par l'utilisateur produisent des objets
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] Aucune des affirmations précédentes n'est correcte
    \end{itemize}
\end{frame}

% Q21 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Une classe Noeud}
    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 ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def Noeud(val, gauche, droite):
    return val
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Noeud:
    pass
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
class Noeud:
    def __init__(self, val, gauche=None, droite=None):
        self.val = val
        self.gauche = gauche
        self.droite = droite
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Noeud:
    val = 0
    gauche = None
    droite = None
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q21 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Une classe Noeud}
    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 ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def Noeud(val, gauche, droite):
    return val
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Noeud:
    pass
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
class Noeud:
    def __init__(self, val, gauche=None, droite=None):
        self.val = val
        self.gauche = gauche
        self.droite = droite
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Noeud:
    val = 0
    gauche = None
    droite = None
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Attribut de classe et attribut d'instance}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{['Peugeot']}
        \item[B.] Il affiche \texttt{['Renault', 'Peugeot']}
        \item[C.] Il affiche \texttt{[]}
        \item[D.] Il déclenche une erreur
    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Attribut de classe et attribut d'instance}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Il affiche \texttt{['Peugeot']}
        \item[\alert{B.}] \alert{Il affiche \texttt{['Renault', 'Peugeot']}}
        \item[C.] Il affiche \texttt{[]}
        \item[D.] Il déclenche une erreur
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile]{Question 23 \textemdash{} Pratique déconseillée}
    Quelle pratique est
\textbf{déconseillée} en programmation
orientée objet ?\medskip
    \begin{itemize}
        \item[A.] Utiliser des méthodes pour modifier les attributs d'un objet
        \item[B.] Définir un constructeur \texttt{\_\_init\_\_}
        \item[C.] Donner un nom en CamelCase à la classe
        \item[\alert<2>{D.}] \alert<2>{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{itemize}
\end{frame}

% Q24 - Réponse en D
\begin{frame}[fragile]{Question 24 \textemdash{} Quand utiliser une classe ?}
    Dans quel cas est-il \textbf{judicieux}
d'utiliser une classe plutôt
qu'une simple fonction ?\medskip
    \begin{itemize}
        \item[A.] Jamais, les classes ne servent à rien en pratique
        \item[B.] Pour calculer la somme d'une liste de notes
        \item[C.] Toujours, car c'est l'approche la plus moderne
        \item[\alert<2>{D.}] \alert<2>{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{itemize}
\end{frame}

% Q25 - Réponse en B
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes
sur la programmation orientée
objet en Python, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] La méthode \texttt{\_\_init\_\_} est appelée automatiquement à la création d'une instance
        \item[\alert<2>{B.}] \alert<2>{Le paramètre \texttt{self} doit obligatoirement s'appeler \texttt{self}}
        \item[C.] En Python, toutes les valeurs (entiers, chaînes, listes, fonctions, classes) sont des objets
        \item[D.] Une classe est un modèle ; une instance est une réalisation concrète
    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Méthodes spéciales}
    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\_\_} ?\medskip
    \begin{itemize}
        \item[A.] La classe \texttt{Point} devient
immuable

        \item[B.] Aucun effet : Python ignore les
méthodes commençant par un
double soulignement

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

        \item[D.] Les objets \texttt{Point} ne pourront
plus être créés

    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Méthodes spéciales}
    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\_\_} ?\medskip
    \begin{itemize}
        \item[A.] La classe \texttt{Point} devient
immuable

        \item[B.] Aucun effet : Python ignore les
méthodes commençant par un
double soulignement

        \item[\alert{C.}] \alert{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
}
        \item[D.] Les objets \texttt{Point} ne pourront
plus être créés

    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Classe Compte bancaire}
    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 ?\medskip
    \begin{itemize}
        \item[A.]~\\
\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}

        \item[B.]~\\
\begin{lstlisting}
class Compte:
    def __init__(self):
        self.solde = 0
    def __retirer__(self, m):
        self.solde -= m
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def Compte(solde):
    return solde
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Compte:
    solde = 0
    def deposer(montant):
        solde += montant
    def retirer(montant):
        solde -= montant
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Classe Compte bancaire}
    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 ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\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}

        \item[B.]~\\
\begin{lstlisting}
class Compte:
    def __init__(self):
        self.solde = 0
    def __retirer__(self, m):
        self.solde -= m
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def Compte(solde):
    return solde
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
class Compte:
    solde = 0
    def deposer(montant):
        solde += montant
    def retirer(montant):
        solde -= montant
\end{lstlisting}

    \end{itemize}
\end{frame}

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

\end{document}
