$course$/QCM de NSI/Terminale/Classes et programmation objet Vocabulaire de la programmation objet en Python :
classes, attributs, méthodes, objets (instances),
constructeur __init__, accès aux attributs et
méthodes, premiers exemples (Point, Voiture,
Pile). Lien avec les structures de données.

]]> Classes et programmation objet — Q01 : Notion de classe En programmation orientée objet, qu'est-ce
qu'une classe ?

]]> Une analogie classique : la classe
est comparable à un moule à
gâteaux ; les objets, ses instances,
sont les gâteaux fabriqués avec ce
moule. Tous les gâteaux partagent
la même forme (les méthodes), mais
chacun peut avoir sa propre
garniture (ses attributs).

]]> 1.0 0.0 0 true true abc Un fichier source Python enregistré avec l'extension .py

]]> Un fichier source Python est un
module, pas une classe. Un
module peut d'ailleurs contenir
plusieurs classes.

]]> Une variable ordinaire contenant une valeur du programme

]]> Une classe est bien plus qu'une
variable : c'est un modèle qui
décrit la structure et le
comportement d'objets de même
nature.

]]> Un modèle décrivant attributs et méthodes d'objets

]]> La classe constitue
l'abstraction. Les objets
concrets sont les instances
de cette classe.

]]> Un type particulier d'erreur signalée à l'exécution

]]> Une classe n'a aucun rapport avec
une erreur. Les erreurs sont
plutôt signalées par des
exceptions.

]]> Classes et programmation objet — Q02 : Notion d'objet Qu'est-ce qu'un objet (ou
instance) d'une classe ?

]]> En Python, tout est un objet :
les entiers, les chaînes, les
listes, les fonctions, voire les
classes elles-mêmes sont des
instances de classes prédéfinies.

]]> 1.0 0.0 0 true true abc Un commentaire inséré dans le code source

]]> Les commentaires sont précédés
du caractère # en Python et
n'ont aucun effet à
l'exécution. Un objet, en
revanche, est manipulé pendant
l'exécution.

]]> Un fichier de configuration du programme

]]> Un objet est une entité
créée à l'exécution à partir
d'une classe, et non un fichier
stocké sur le disque.

]]> Un type primitif comme un entier ou un flottant

]]> Un objet est créé à partir
d'une classe, généralement
définie par le programmeur.
Cela dit, en Python, les
entiers et les flottants sont
eux-mêmes des objets, instances
de classes prédéfinies.

]]> Une réalisation concrète d'une classe

]]> On utilise indifféremment les
mots « objet » et « instance ».
À partir d'une classe Voiture,
on peut créer plusieurs objets
Voiture distincts, chacun avec
ses propres caractéristiques.

]]> Classes et programmation objet — Q03 : Attribut Qu'est-ce qu'un attribut d'une
classe ?

]]> Pour une classe Voiture, des
attributs typiques pourraient
être : marque, modele,
couleur, vitesse. Chaque
voiture aura ses propres valeurs
pour chacun de ces attributs.

]]> 1.0 0.0 0 true true abc Un type particulier de boucle

]]> Les boucles relèvent du
contrôle de flux, pas des
objets. Un attribut est un
composant d'un objet.

]]> Un module de la bibliothèque Python

]]> Un module est un fichier
Python, et non un attribut.
Les attributs appartiennent à
des objets.

]]> Une donnée propre à un objet (nom, âge)

]]> Les attributs caractérisent
l'état d'un objet. Chaque
instance possède ses propres
valeurs d'attributs.

]]> Une fonction définie à l'intérieur de la classe

]]> Cette description correspond à
une méthode, et non à un
attribut. Les méthodes
définissent le comportement,
les attributs représentent les
données.

]]> Classes et programmation objet — Q04 : Méthode Qu'est-ce qu'une méthode d'une
classe ?

]]> Pour la classe Voiture, des
méthodes typiques pourraient
être : accelerer, freiner,
afficher. Elles agissent
directement sur l'état de l'objet
par l'intermédiaire de self.

]]> 1.0 0.0 0 true true abc Un attribut un peu particulier

]]> Une méthode est en réalité une
fonction, et non un attribut.
Les méthodes définissent le
comportement des objets, les
attributs définissent leur
état.

]]> Un type de variable particulier

]]> Une méthode n'est pas une
variable, mais une fonction
attachée à une classe.

]]> Un fichier dédié aux tests automatisés

]]> Les fichiers de tests
contiennent typiquement des
fonctions de test. Une méthode,
elle, est une fonction définie
au sein d'une classe.

]]> Une fonction de la classe agissant sur l'objet

]]> Les méthodes définissent le
comportement des objets.
Par convention, leur premier
paramètre se nomme self et
désigne l'instance sur
laquelle la méthode est
appelée.

]]> Classes et programmation objet — Q05 : Définir une classe Quelle est la syntaxe Python correcte
pour définir une classe Voiture
vide ?

]]> Une définition de classe commence par le mot-clé class, le nom de la classe et deux-points. Le corps indenté contient ensuite les méthodes, comme __init__, ou simplement pass s'il est vide.

]]> 1.0 0.0 0 true true abc `python
new class Voiture {}
`

]]> Cette syntaxe correspond à
Java ou à C++, mais pas à
Python.

]]> `python
class Voiture:
pass
`

]]> On utilise le mot-clé class, puis le nom de la classe, suivi de deux-points et d'un corps indenté. L'instruction pass permet de signaler un corps vide.

]]> `python
def Voiture():
pass
`

]]> Le mot-clé def introduit une
fonction, et non une
classe. Pour une classe, il
faut utiliser class.

]]> `python
Voiture = class()
`

]]> Cette syntaxe n'existe pas en
Python. La définition d'une
classe se fait avec le mot-clé
class suivi du nom de la
classe.

]]> Classes et programmation objet — Q06 : Créer une instance Comment crée-t-on une instance de
la classe Voiture en Python ?

]]> Une distinction subtile : le nom
Voiture désigne la classe
elle-même (un objet de type
classe), tandis que Voiture()
désigne une instance qu'on vient
de créer.

]]> 1.0 0.0 0 true true abc Avec la syntaxe v = create Voiture

]]> La syntaxe create n'existe
pas en Python. La création
d'une instance se fait
simplement en appelant la
classe avec des parenthèses.

]]> Avec la syntaxe v = Voiture()

]]> On appelle la classe comme
une fonction. Cet appel
déclenche le constructeur
(__init__, s'il est défini)
et renvoie le nouvel objet
créé.

]]> Avec la syntaxe v = new Voiture()

]]> Le mot-clé new n'existe pas
en Python. Cette syntaxe est
utilisée en Java, en JavaScript
ou en C++.

]]> Avec la syntaxe v = Voiture

]]> Sans les parenthèses, la
variable v reçoit la classe
elle-même, et non une instance.
Pour créer un objet, il faut
appeler la classe.

]]> Classes et programmation objet — Q07 : Accéder à un attribut Si v est une instance de la classe
Voiture possédant un attribut
marque, comment lit-on la valeur de
cet attribut ?

]]> La notation pointée est la
syntaxe standard et la plus
lisible pour accéder aux attributs
comme aux méthodes d'un objet.

]]> 1.0 0.0 0 true true abc Avec la notation v["marque"]

]]> Cette syntaxe sert à accéder
à une valeur dans un
dictionnaire ou à un élément
d'une liste, et non à un
attribut d'objet.

]]> Avec la notation v->marque

]]> Cette syntaxe est utilisée en
C++ ou en PHP, mais pas en
Python.

]]> Avec la notation v.marque

]]> La notation pointée permet
d'accéder aux attributs d'un
objet. Elle est aussi utilisée
pour appeler les méthodes :
v.demarrer().

]]> Avec un appel get(v, marque)

]]> Aucune fonction get ne lit ainsi un attribut, et marque sans guillemets désignerait une variable inexistante. On accède aux attributs d'un objet avec la notation pointée.

]]> Classes et programmation objet — Q08 : Le paramètre self À quoi sert le paramètre self
dans les méthodes d'une classe Python ?

]]> La convention est forte mais non
obligatoire. Le paramètre
pourrait techniquement s'appeler
autrement, mais ce serait
vivement déconseillé. En Java ou
en C++, le rôle équivalent est
tenu par this, qui est
implicite.

]]> 1.0 0.0 0 true true abc C'est une variable globale du programme

]]> self est un paramètre local
à chaque méthode, et non une
variable globale.

]]> Il fait référence à la classe parente

]]> Le paramètre self ne désigne pas une classe : il désigne l'objet sur lequel la méthode est appelée.

]]> L'instance courante, donnant accès à ses attributs

]]> Par convention en Python, on
nomme self le premier
paramètre des méthodes.
Lorsqu'on écrit
v.demarrer(), Python
transmet automatiquement v
comme paramètre self.

]]> Il s'agit d'un mot-clé réservé sans signification particulière

]]> Le nom self n'est pas un
mot-clé réservé. C'est un
paramètre comme un autre,
utilisé par convention pour
désigner l'instance courante.

]]> Classes et programmation objet — Q09 : La méthode `__init__` Quel est le rôle de la méthode
spéciale __init__ d'une classe ?

]]> Les noms encadrés de doubles soulignés, comme __init__, désignent des méthodes que Python appelle de lui-même : __init__ est exécutée automatiquement à chaque création d'un objet de la classe.

]]> 1.0 0.0 0 true true abc Initialiser l'ensemble du programme

]]> La méthode __init__ est
locale à la classe : elle ne
concerne que la création des
instances de cette classe.

]]> Détruire l'objet en fin de vie

]]> La méthode __init__ intervient à la création de l'objet, pas à sa disparition : elle fixe les valeurs initiales de ses attributs.

]]> Importer un module dans le programme

]]> L'import de modules se fait
avec l'instruction import,
et n'a aucun rapport avec
__init__.

]]> Initialiser les attributs d'un nouvel objet

]]> Cette méthode est appelée
automatiquement au moment de
l'instanciation. C'est dans
son corps qu'on définit
l'état initial de l'objet.

]]> Classes et programmation objet — Q10 : Trace simple Que produit ce code ?
`python
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(3, 4)
print(p.x, p.y)
`

]]> Voici le motif de base d'une
classe simple : une méthode
__init__ qui prend les valeurs
initiales en paramètres et les
stocke dans self à l'aide
d'instructions de la forme
self.attr = ....

]]> 1.0 0.0 0 true true abc Il affiche Point(3, 4)

]]> L'instruction print(p.x,
p.y) n'affiche pas l'objet
tout entier, mais
uniquement la valeur de ses
deux attributs.

]]> Il déclenche une erreur de syntaxe

]]> Ce code est parfaitement
valide. Aucune erreur n'est
levée.

]]> Il affiche 7

]]> La fonction print n'effectue
pas d'addition entre les
arguments qui lui sont
passés. Elle se contente de
les afficher tels quels.

]]> Il affiche 3 4

]]> L'expression Point(3, 4)
crée une instance ; la
méthode __init__ initialise
les attributs self.x = 3 et
self.y = 4. La fonction
print affiche les deux
valeurs séparées par un
espace.

]]> Classes et programmation objet — Q11 : Définir une méthode Comment ajouter une méthode
distance_origine à la classe
Point, qui renvoie la distance
du point à l'origine (0, 0) ?

]]> L'appel se fait simplement avec
p.distance_origine(). Python
transmet automatiquement p
comme paramètre self.

]]> 1.0 0.0 0 true true abc `python
class Point:
distance_origine = (x 2 + y 2) ** 0.5
`

]]> Cette écriture est invalide.
Les noms x et y ne sont
pas définis au niveau de la
classe ; il faut une méthode
qui s'applique à une
instance.

]]> `python
class Point:
def distance_origine():
return ...
`

]]> Il manque le paramètre
self en première position.
Sans lui, la méthode ne peut
pas accéder aux attributs
de l'instance.

]]> `python
class Point:
...
def distance_origine(self):
return (self.x 2 + self.y 2) ** 0.5
`

]]> La méthode est définie dans le
corps de la classe, avec
self comme premier
paramètre. On accède aux
attributs de l'instance par
self.x et self.y.

]]> `python
def distance_origine(p):
return (p.x 2 + p.y 2) ** 0.5
`

]]> Cette écriture définit une
fonction externe, et non une
méthode de la classe. Elle
fonctionne, mais elle est
moins idiomatique en
programmation orientée
objet.

]]> Classes et programmation objet — Q12 : Combien d'instances ? Combien d'instances peut-on créer à
partir d'une seule classe ?

]]> Une classe sans instance n'a
aucune utilité. On crée autant
d'instances que la situation
l'exige.

]]> 1.0 0.0 0 true true abc Au plus dix instances

]]> Aucune limite particulière
n'est imposée par le langage.
Le nombre d'instances n'est
contraint que par la mémoire
disponible.

]]> Aucune instance ne peut être créée

]]> Une classe sans instance ne
servirait à rien. Le rôle
d'une classe est précisément
de servir de patron pour
créer des objets.

]]> Une seule instance par classe

]]> Cette limite n'existe pas en
Python. On peut créer autant
d'instances que nécessaire à
partir d'une même classe.

]]> Autant que nécessaire, chacune indépendante

]]> La classe est un modèle. On
peut écrire par exemple
v1 = Voiture("Renault"),
v2 = Voiture("Peugeot"), et
ainsi de suite. Chaque
instance reste indépendante.

]]> Classes et programmation objet — Q13 : Constructeur pour une classe Pile On souhaite écrire une classe Pile
(de type LIFO) avec les méthodes
empiler et depiler. Quel
__init__ choisir ?

]]> Le motif standard est le
suivant : __init__ initialise
les attributs avec
self.nom = valeur. Sans le
préfixe self., on ne crée
qu'une variable locale, qui ne
survit pas à l'appel.

]]> 1.0 0.0 0 true true abc `python
def __init__(self):
elements = []
`

]]> Sans le préfixe self., le
nom elements désigne une
simple variable locale, qui
ne persiste pas après la fin
de __init__. Il faut
écrire self.elements = [].

]]> `python
def __init__(self):
return []
`

]]> La méthode __init__ ne
renvoie rien (la valeur
renvoyée est implicitement
None). On y initialise
simplement les attributs de
l'instance.

]]> `python
def __init__():
elements = []
`

]]> Le paramètre self manque,
et elements n'est ici
qu'une variable locale, qui
disparaîtra à la fin de
__init__. Il faudrait
écrire self.elements = []
pour stocker la liste dans
l'instance.

]]> `python
def __init__(self):
self.elements = []
`

]]> On initialise une liste vide,
qui contiendra les éléments
empilés. Les méthodes
empiler et depiler
manipuleront ensuite
self.elements.

]]> Classes et programmation objet — Q14 : Données et comportements groupés Quel est l'intérêt principal de
regrouper, dans une même classe,
les attributs (les données) et
les méthodes (les
comportements) qui les manipulent ?

]]> Une classe regroupe l'état
(les attributs) et les
opérations (les méthodes) liés
à un même concept. Dans une
classe Pile, par exemple, les
méthodes empiler et
depiler manipulent
directement la liste interne.
L'utilisateur n'a qu'à
connaître ces méthodes.

]]> 1.0 0.0 0 true true abc Le programme s'exécute plus rapidement

]]> La performance n'est pas
l'avantage principal de la
programmation orientée
objet. Son intérêt est avant
tout structurel.

]]> Les données sont automatiquement enregistrées sur le disque

]]> La programmation orientée
objet n'a aucun lien direct
avec la persistance des
données sur le disque, qui
relève de mécanismes
séparés.

]]> Les opérations sont au plus près des données

]]> On peut alors lire ou
modifier les attributs
uniquement par les méthodes
prévues à cet effet. Cela
permet de changer
l'implémentation interne
sans impacter le code qui
utilise la classe.

]]> Le code est plus court mais devient moins lisible

]]> C'est en général l'inverse.
La lisibilité augmente, car
les opérations sont
regroupées au plus près des
données qu'elles
manipulent.

]]> Classes et programmation objet — Q15 : Une méthode qui reçoit un autre objet On considère le programme suivant :
`python
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def distance(self, autre):
return abs(self.x - autre.x) + abs(self.y - autre.y)
p = Point(1, 2)
q = Point(4, 6)
print(p.distance(q))
`
Qu'affiche ce programme ?

]]> Une méthode peut prendre en paramètre un autre objet de la même classe. Dans l'appel p.distance(q), l'objet placé avant le point devient self, et l'argument entre parenthèses devient autre.

]]> 1.0 0.0 0 true true abc 7

]]> Dans l'appel p.distance(q), self désigne p et autre désigne q. La méthode calcule |1 - 4| + |2 - 6| = 3 + 4 = 7.

]]> 5

]]> 5 serait la distance à vol d'oiseau, √3² + 4². La méthode écrite ici additionne simplement les deux écarts, 3 + 4.

]]> Une erreur, car une méthode ne peut lire que les attributs de self

]]> Une méthode peut lire les attributs de tout objet qu'elle reçoit : autre.x désigne l'attribut x de q, accessible par la notation pointée.

]]> Une erreur, car distance attend deux arguments et n'en reçoit qu'un

]]> Le paramètre self n'est pas à fournir : Python lui donne automatiquement l'objet p. Le seul argument écrit, q, correspond au paramètre autre.

]]> Classes et programmation objet — Q16 : Programmation objet et structures de données Pourquoi la programmation orientée
objet est-elle particulièrement
utile pour implémenter des
structures de données comme les
arbres ou les graphes ?

]]> Le programme officiel de
Terminale, dans la rubrique
Structures de données, cite
explicitement la
programmation orientée objet
comme outil possible pour ces
implémentations.

]]> 1.0 0.0 0 true true abc Regrouper données et opérations en une seule entité

]]> Cette modélisation est
naturelle. Une classe
Noeud, par exemple,
encapsule l'état et les
comportements d'un nœud
d'arbre. Le code est plus
clair et plus
réutilisable.

]]> Elle est plus rapide à exécuter

]]> La programmation orientée
objet n'est pas
systématiquement plus
rapide. Son intérêt est
avant tout structurel et
conceptuel.

]]> Elle est strictement obligatoire dans le programme officiel

]]> Le programme officiel ne
rend pas la programmation
orientée objet obligatoire
pour l'implémentation de
ces structures. C'est une
option, parmi d'autres.

]]> Aucune raison particulière

]]> La programmation orientée
objet apporte au contraire
de réels bénéfices pour
l'implémentation des
structures de données,
comme expliqué dans la
bonne réponse.

]]> Classes et programmation objet — Q17 : Interface et implémentation Quelle est la différence entre
l'interface et
l'implémentation d'une
structure de données ?

]]> Cette distinction est
cruciale en programmation
modulaire. On programme
contre l'interface ; on
peut alors changer
l'implémentation sans
conséquence pour les
utilisateurs du module.

]]> 1.0 0.0 0 true true abc L'interface liste les opérations, l'implémentation les code

]]> On peut, par exemple,
implémenter une file (de
type FIFO) avec une seule
liste, ou bien avec deux
piles. L'interface
(enfiler, defiler)
reste la même, mais les
implémentations sont
différentes.

]]> L'interface s'exécute plus rapidement que l'implémentation

]]> Cette comparaison n'a pas
de sens. L'interface n'est
pas exécutée
indépendamment ; elle
décrit simplement les
opérations disponibles.

]]> L'implémentation est aujourd'hui une notion obsolète

]]> L'implémentation reste une
notion absolument
centrale. Tout programme
implémente concrètement
une ou plusieurs
interfaces.

]]> Aucune différence

]]> La distinction est au
contraire fondamentale en
programmation, comme
expliqué dans la bonne
réponse.

]]> Classes et programmation objet — Q18 : La fonction type appliquée à une instance Que renvoie l'appel type(p)
lorsque p est une instance de
Point ?

]]> La fonction type permet de vérifier la classe d'un objet : type(42) == int vaut True, et de même type(p) == Point vaut True lorsque p a été créé par Point(...).

]]> 1.0 0.0 0 true true abc La classe Point

]]> La fonction type renvoie la classe de l'objet passé en paramètre, ici Point : le test type(p) == Point vaut True.

]]> La classe object

]]> type ne renvoie pas une classe générale : il renvoie la classe précise à partir de laquelle l'objet a été créé, ici Point.

]]> Une erreur, car type ne s'applique qu'aux entiers, flottants et chaînes

]]> type s'applique à toute valeur, y compris aux objets créés à partir d'une classe écrite par le programmeur. Le code ne provoque aucune erreur.

]]> La chaîne "p", nom de la variable

]]> type ne s'intéresse pas au nom de la variable : il renvoie la classe de l'objet que cette variable désigne.

]]> Classes et programmation objet — Q19 : Une méthode qui modifie l'objet `python
class Compteur:
def __init__(self):
self.n = 0
def incrementer(self):
self.n += 1
c = Compteur()
c.incrementer()
c.incrementer()
print(c.n)
`
Que produit ce code ?

]]> Le changement d'état des
objets est l'un des piliers
de la programmation orientée
objet. Les méthodes
modifient les attributs en
réaffectant self.attr.

]]> 1.0 0.0 0 true true abc Il affiche 2

]]> Le constructeur initialise
l'attribut n à 0.
Chaque appel à
incrementer ajoute 1
à self.n. Après deux
appels, l'attribut vaut
donc 2.

]]> Il déclenche une erreur

]]> Le code est parfaitement
valide et s'exécute sans
erreur.

]]> Il affiche 1

]]> La méthode incrementer
est appelée deux fois
successives, pas 1.

]]> Il affiche 0

]]> Cette réponse ignore les
deux appels successifs à
incrementer, qui
modifient bien la valeur
de l'attribut.

]]> Classes et programmation objet — Q20 : Tout est objet en Python Laquelle des affirmations
suivantes est correcte au sujet
des objets en Python ?

]]> Une conséquence de cette uniformité : la fonction type s'applique à toute valeur, qu'il s'agisse d'un entier, d'une chaîne ou d'un objet créé à partir d'une classe écrite par le programmeur. Ce modèle donne au langage Python une grande cohérence.

]]> 1.0 0.0 0 true true abc Les fonctions ne sont pas des objets

]]> Les fonctions Python sont elles aussi des objets : on peut par exemple les ranger dans une variable ou en donner une en argument à sorted pour choisir la clé de tri.

]]> Aucune de ces affirmations n'est correcte

]]> L'affirmation « en Python, tout est un objet, même les classes » est correcte : entiers, chaînes, listes, fonctions et classes sont tous des objets.

]]> En Python, tout est un objet, même les classes

]]> Par exemple, l'appel type(42) renvoie <class 'int'>, et type("a") renvoie <class 'str'>. Les entiers, les chaînes, les fonctions et même les classes sont des objets.

]]> Seules les classes définies par l'utilisateur produisent des objets

]]> En Python, les entiers,
les chaînes et les listes
sont eux aussi des objets.
Ils sont des instances de
classes prédéfinies par
le langage.

]]> Classes et programmation objet — Q21 : Une classe Noeud Pour représenter un nœud d'arbre binaire comportant une
valeur, un sous-arbre gauche et
un sous-arbre droit, quelle
définition de classe est
correcte ?

]]> Cette modélisation
récursive est typique des
arbres binaires : chaque
nœud porte une valeur et
possède au plus deux fils,
qui sont eux-mêmes des
nœuds (ou None lorsqu'ils
sont absents).

]]> 1.0 0.0 0 true true abc `python
class Noeud:
def __init__(self, val, gauche=None, droite=None):
val = val
gauche = gauche
droite = droite
`

]]> Le constructeur affecte des
variables locales, qui
disparaissent dès la fin de
__init__. Sans écrire
self.val = val, l'objet
créé ne possède aucun
attribut : n.val provoque
une AttributeError.

]]> `python
def Noeud(val, gauche=None, droite=None):
return {"val": val, "gauche": gauche, "droite": droite}
`

]]> Cette définition est une
fonction, et non une
classe : aucun type Noeud
n'est créé. Le dictionnaire
renvoyé s'utilise avec
n["val"] au lieu de
n.val et n'a aucune
méthode propre aux nœuds.

]]> `python
class Noeud:
def __init__(self, val, gauche=None, droite=None):
self.val = val
self.gauche = gauche
self.droite = droite
`

]]> Cette classe définit trois
attributs : val,
gauche et droite. Les
fils sont par défaut à
None (ce qui correspond
à une feuille). Les fils
sont eux-mêmes des
instances de Noeud, ce
qui produit une structure
récursive.

]]> `python
class Noeud:
val = 0
gauche = None
droite = None
`

]]> Ces attributs sont
déclarés au niveau de la
classe, et seraient donc
partagés par toutes les instances, au lieu
d'être propres à chacune.
Il s'agit d'un bug subtil
mais important.

]]> Classes et programmation objet — Q23 : Affectation d'un objet à une autre variable On considère le programme suivant :

``python
class Compteur:
def __init__(self):
self.valeur = 0

def incrementer(self):
self.valeur = self.valeur + 1

a = Compteur()
b = a
c = Compteur()
a.incrementer()
b.incrementer()
c.incrementer()
print(a.valeur, b.valeur, c.valeur)
``

Qu'affiche ce programme ?

]]> Seul l'appel Compteur() crée un objet. L'affectation b = a donne simplement un second nom au même objet : toute modification faite par l'un des noms est visible par l'autre.

]]> 1.0 0.0 0 true true abc 1 1 1

]]> L'affectation b = a ne copie pas l'objet : a et b désignent le même compteur. Il est donc incrémenté deux fois, par a puis par b.

]]> 2 2 1

]]> a et b désignent le même objet, incrémenté deux fois : sa valeur est 2, lue par a.valeur comme par b.valeur. c est un autre objet, incrémenté une fois.

]]> 2 2 2

]]> Chaque appel à Compteur() crée un nouvel objet : c est un compteur distinct, incrémenté une seule fois. Seuls a et b partagent le même objet.

]]> Une erreur, car b n'a pas été créé par Compteur()

]]> La variable b désigne l'objet créé pour a ; on peut appeler ses méthodes exactement comme avec a. Le programme s'exécute sans erreur.

]]> Classes et programmation objet — Q24 : Quand utiliser une classe ? Dans quel cas est-il judicieux
d'utiliser une classe plutôt
qu'une simple fonction ?

]]> Une maxime utile : « une
classe quand il y a un état
et un ensemble de
comportements ; une
fonction sinon ». Une
classe ne contenant qu'une
seule méthode est souvent
le signe qu'une simple
fonction aurait suffi.

]]> 1.0 0.0 0 true true abc Pour calculer la simple somme d'une liste de notes

]]> Une fonction simple suffit
pour ce calcul. Définir
une classe serait
disproportionné.

]]> Toujours, car c'est l'approche la plus moderne

]]> Cette position est trop
dogmatique. Aucun
paradigme n'est
universellement
supérieur ; le choix
dépend du problème
traité.

]]> Jamais, les classes ne servent à rien en pratique

]]> Cette position est tout
aussi catégorique. Les
classes apportent de
réels bénéfices dans de
nombreuses situations,
comme expliqué dans la
bonne réponse.

]]> Modéliser une entité avec état et comportements

]]> La programmation orientée
objet est particulièrement
adaptée pour modéliser des
entités du monde réel, ou
des structures de données
complexes. Pour des
calculs simples sans
état, une fonction est
plus directe.

]]> Classes et programmation objet — Q25 : Synthèse Parmi les affirmations suivantes
sur la programmation orientée
objet en Python, laquelle est
fausse ?

]]> Convention contre règle : la syntaxe Python est assez permissive, mais les conventions partagées, comme le nom self, doivent être respectées pour la lisibilité du code.

]]> 1.0 0.0 0 true true abc En Python, toutes les valeurs (entiers, chaînes, listes, fonctions, classes) sont des objets

]]> Cette affirmation est
correcte. C'est l'une
des caractéristiques
fondamentales du modèle
de Python.

]]> Une classe est un modèle ; une instance est une réalisation concrète

]]> Cette affirmation est
correcte. C'est la
distinction essentielle
entre les deux notions.

]]> La méthode __init__ est appelée automatiquement à la création d'une instance

]]> Cette affirmation est
correcte. C'est le rôle
de constructeur joué
par __init__.

]]> Le paramètre self doit obligatoirement s'appeler self

]]> Cette affirmation est
fausse (donc c'est la
bonne réponse). Il
s'agit d'une convention forte en Python, mais
pas d'une obligation
syntaxique. On pourrait
écrire this, obj ou
tout autre nom, même si
c'est très vivement
déconseillé pour la
lisibilité du code.

]]> Classes et programmation objet — Q27 : Classe Compte bancaire On souhaite implémenter une classe
Compte représentant un compte
bancaire avec un solde, une
méthode deposer(montant) et
une méthode retirer(montant)
qui refuse l'opération si le
solde devient négatif. Quel
code est correct ?

]]> Cet exemple illustre les principes
essentiels de la programmation
orientée objet : encapsulation
(état dans self.solde),
invariants (vérifications dans
les méthodes), interface publique
claire (deposer et retirer
avec une signification précise),
gestion des erreurs (renvoyer
False plutôt que de laisser le
solde devenir négatif). Une
version plus avancée pourrait
lever une exception explicite
au lieu de renvoyer False.

]]> 1.0 0.0 0 true true abc `python
class Compte:
def __init__(self):
self.solde = 0
def __retirer__(self, m):
self.solde -= m
`

]]> Erreur : __retirer__ n'est
pas une méthode spéciale
reconnue par Python. Les
doubles soulignements sont
réservés aux méthodes spéciales
du langage (__init__,
__str__, etc.). Ici, il
faut simplement nommer la
méthode retirer. De plus,
il n'y a pas de méthode
deposer ni de vérification
du solde.

]]> `python
class Compte:
def __init__(self, solde_initial=0):
self.solde = solde_initial
def deposer(self, montant):
self.solde += montant
def retirer(self, montant):
self.solde -= montant
`

]]> Erreur : ce code s'exécute,
mais retirer ne vérifie
rien : le solde peut devenir
négatif, ce que la
spécification interdit
explicitement. Il manque
aussi le contrôle de
positivité des montants dans
deposer.

]]> `python
class Compte:
solde = 0
def deposer(montant):
solde += montant
def retirer(montant):
solde -= montant
`

]]> Plusieurs erreurs ici. (1) Le
paramètre self est absent
dans les méthodes, donc Python
appellerait avec un mauvais
nombre de paramètres. (2)
solde est un attribut de
classe partagé entre toutes
les instances, pas un attribut
d'instance (bug subtil). (3)
Aucune vérification du
montant. (4) Les solde += ...
dans les méthodes
n'atteindront pas l'attribut
d'instance sans self..

]]> `python
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
`

]]> Bonne réponse : le constructeur
initialise le solde, deposer
ajoute si le montant est
positif, retirer vérifie que
le compte ne devient pas
négatif et signale l'échec en
renvoyant False. Les
contraintes sont vérifiées
dans les méthodes, ce qui
garantit l'invariant « solde
≥ 0 » sans avoir à faire
confiance au code utilisateur.

]]> Classes et programmation objet — Q28 : La méthode de défilement d'une classe File La classe File range ses éléments dans la liste self.elements,
les nouveaux étant ajoutés en fin de liste par append. Quelle
ligne complète la méthode defiler, qui retire et renvoie le plus
ancien élément ?

]]> Écrire une structure de données en classe, c'est traduire chaque
opération de l'interface en une méthode sur l'attribut interne.

]]> 1.0 0.0 0 true true abc return self.elements.pop()

]]> Erreur : sans argument, pop retire le dernier arrivé ; ce
serait une pile.

]]> return self.elements.pop(0)

]]> Bonne réponse : le plus ancien est en tête de liste, à l'indice
0 ; pop(0) le retire et le renvoie.

]]> return self.elements.remove(0)

]]> Erreur : remove(0) cherche la valeur 0, pas l'indice, et ne
renvoie rien.

]]> return self.elements[0]

]]> Erreur : l'élément est lu mais reste dans la file.

]]> Classes et programmation objet — Q29 : Une méthode qui teste si la pile est vide Quelle ligne complète correctement la méthode est_vide d'une
classe Pile dont les éléments sont dans la liste
self.elements ?

]]> Une méthode de test renvoie un booléen et ne modifie pas l'objet.

]]> 1.0 0.0 0 true true abc return self.elements == None

]]> Erreur : une liste vide n'est pas None ; ce test répond
toujours False.

]]> return len(self.elements) == 0

]]> Bonne réponse : la comparaison renvoie un booléen, True quand
la liste est vide.

]]> return len(self.elements)

]]> Erreur : la méthode renverrait un entier, nul précisément quand
la pile est vide, soit l'inverse d'un True.

]]> return self.elements.pop() is None

]]> Erreur : tester ne doit rien retirer, et pop sur une liste
vide provoque une erreur.

]]> Classes et programmation objet — Q30 : Une méthode qui renvoie un nouvel objet Que renvoie a.plus(b) ?
``python
class Rationnel:
def __init__(self, n, d):
self.n = n
self.d = d

def plus(self, autre):
return Rationnel(self.n autre.d + autre.n self.d,
self.d * autre.d)

a = Rationnel(1, 2)
b = Rationnel(1, 3)
``

]]> Une méthode qui renvoie un nouvel objet au lieu de modifier self
laisse les opérandes inchangés, comme les nombres.

]]> 1.0 0.0 0 true true abc Rationnel(2, 5), les numérateurs et dénominateurs s'ajoutant

]]> Erreur : ce n'est pas ce que calcule le code, ni la règle des
fractions.

]]> Rationnel(1, 6), le produit des deux fractions

]]> Erreur : le numérateur calculé est une somme de deux produits,
pas un seul produit.

]]> Rationnel(5, 6), un nouvel objet, a et b restant intacts

]]> Bonne réponse : la méthode applique la règle d'addition des
fractions, 1 × 3 + 1 × 2 = 5 sur
2 × 3 = 6, sans simplifier, et construit un
troisième objet.

]]> Une erreur, une méthode ne pouvant créer un objet de sa propre classe

]]> Erreur : une méthode peut appeler Rationnel(...) comme
n'importe quel code.

]]> Classes et programmation objet — Q31 : Une liste d'objets Qu'affiche ce programme ?
``python
class Eleve:
def __init__(self, nom, note):
self.nom = nom
self.note = note

eleves = [Eleve("Ana", 15), Eleve("Bob", 12)]
print(eleves[1].note)
``

]]> Les objets se rangent dans les listes et les dictionnaires comme
toute autre valeur ; on accède à leurs attributs après l'indexation.

]]> 1.0 0.0 0 true true abc Une erreur, une liste ne pouvant contenir des objets

]]> Erreur : une liste contient des valeurs de tout type, objets
compris.

]]> Bob, le nom du second élève

]]> Erreur : c'est l'attribut note qui est affiché, pas nom.

]]> 15, la note du premier élève de la liste

]]> Erreur : les indices commencent à 0, eleves[1] est le
second.

]]> 12, la note du second élève de la liste

]]> Bonne réponse : eleves[1] est le second objet, et .note lit
son attribut.

]]> Classes et programmation objet — Q32 : Chaque instance a sa propre liste Qu'affiche ce programme ?
``python
class Panier:
def __init__(self):
self.articles = []

p1 = Panier()
p2 = Panier()
p1.articles.append("pain")
print(len(p2.articles))
``

]]> Les attributs créés dans __init__ appartiennent à chaque objet :
deux instances ne partagent rien par défaut.

]]> 1.0 0.0 0 true true abc 0, chaque appel de __init__ créant une liste distincte

]]> Bonne réponse : [] est évalué à chaque construction ; p1 et
p2 ont chacun leur liste, et seule celle de p1 a reçu un
article.

]]> Une erreur, p2.articles n'existant pas encore

]]> Erreur : __init__ a créé l'attribut de p2 à sa
construction.

]]> 1, la liste étant partagée par toutes les instances

]]> Erreur : la liste n'est pas définie dans la classe mais créée
dans __init__, une fois par objet.

]]> None, la liste de p2 n'ayant jamais été remplie

]]> Erreur : une liste vide a une longueur, 0.

]]> Classes et programmation objet — Q33 : Modifier un attribut depuis l'extérieur de la classe v est un objet de la classe Voiture, qui possède un attribut
vitesse. Que fait l'instruction v.vitesse = 50 ?

]]> Un attribut est une variable attachée à un objet : la notation
objet.attribut y accède en lecture comme en écriture.

]]> 1.0 0.0 0 true true abc Elle donne la valeur 50 à l'attribut vitesse de l'objet v

]]> Bonne réponse : un attribut se lit et se modifie par la
notation pointée, depuis la classe ou depuis l'extérieur.

]]> Elle donne la valeur 50 à la vitesse de toutes les voitures

]]> Erreur : seul l'objet v est concerné.

]]> Elle provoque une erreur, un attribut ne se modifiant que par une méthode

]]> Erreur : Python n'impose pas de passer par une méthode, même si
c'est souvent préférable.

]]> Elle crée une variable globale vitesse valant 50

]]> Erreur : le préfixe v. désigne l'attribut de l'objet, pas une
variable.

]]> Classes et programmation objet — Q34 : Un `self` oublié dans le constructeur Que se passe-t-il à la dernière ligne ?
``python
class Personne:
def __init__(self, nom):
nom = nom

p = Personne("Ada")
print(p.nom)
``

]]> Dans une méthode, seules les variables préfixées par self.
appartiennent à l'objet ; les autres disparaissent à la fin de
l'appel.

]]> 1.0 0.0 0 true true abc Une AttributeError, l'attribut nom n'ayant jamais été créé

]]> Bonne réponse : nom = nom réaffecte la variable locale du
constructeur, sans toucher à l'objet. Il fallait écrire
self.nom = nom.

]]> L'affichage de Ada, Python ajoutant self. automatiquement

]]> Erreur : rien n'est automatique, un attribut doit être créé
explicitement sur self.

]]> L'affichage de None, l'attribut existant sans valeur

]]> Erreur : l'attribut n'existe pas du tout.

]]> Une erreur de syntaxe dès la définition de la classe

]]> Erreur : nom = nom est une affectation valide, inutile mais
valide.

]]> Classes et programmation objet — Q35 : Une méthode appelée sans parenthèses La classe Rectangle a une méthode aire qui renvoie le produit
de la largeur par la hauteur. Que vaut r.aire, sans parenthèses ?

]]> r.aire et r.aire() sont deux expressions différentes : la
seconde seule déclenche l'exécution.

]]> 1.0 0.0 0 true true abc Une erreur, l'attribut aire n'existant pas

]]> Erreur : aire existe bien, c'est une méthode.

]]> La méthode elle-même, pas le résultat du calcul

]]> Bonne réponse : sans parenthèses, on désigne la méthode sans
l'appeler ; son affichage ressemble à <bound method ...>.
r.aire() effectue le calcul.

]]> None, la méthode n'ayant pas encore été appelée

]]> Erreur : l'expression a une valeur, la méthode.

]]> Le résultat du calcul, les parenthèses étant facultatives

]]> Erreur : un appel exige des parenthèses, même sans argument.

]]> Classes et programmation objet — Q36 : Un attribut qui ne suit pas les autres Après ces instructions, r.aire vaut-il 40 ?
``python
class Rectangle:
def __init__(self, largeur, hauteur):
self.largeur = largeur
self.hauteur = hauteur
self.aire = largeur * hauteur

r = Rectangle(2, 4)
r.largeur = 10
``

]]> Stocker une valeur dérivée expose à l'incohérence ; la calculer
dans une méthode garantit qu'elle est toujours à jour.

]]> 1.0 0.0 0 true true abc Non, aire garde 8, calculé une seule fois à la construction

]]> Bonne réponse : l'attribut aire est une valeur stockée, pas une
formule ; modifier largeur ne le recalcule pas. Une méthode
aire() qui calcule à la demande évite ce décalage.

]]> Oui, Python recalcule les attributs qui dépendent d'autres attributs

]]> Erreur : aucun lien n'est conservé entre les attributs.

]]> Une erreur, largeur ne pouvant être modifié après la construction

]]> Erreur : la modification est permise, c'est son effet qui est
incomplet.

]]> Oui, mais seulement si aire a été défini après largeur

]]> Erreur : l'ordre dans __init__ ne crée aucune dépendance
durable.

]]> Classes et programmation objet — Q37 : Une classe sans constructeur Peut-on créer un objet d'une classe définie sans méthode
__init__ ?
``python
class Point:
pass

p = Point()
``

]]> Le constructeur n'est qu'une méthode appelée juste après la
création ; sans lui, l'objet naît vide.

]]> 1.0 0.0 0 true true abc Non, Point() renvoie None faute de constructeur défini

]]> Erreur : Point() renvoie bien un objet de type Point.

]]> Oui, mais l'objet ne pourra jamais recevoir le moindre attribut

]]> Erreur : les attributs peuvent être ajoutés à tout moment.

]]> Oui, l'objet naît sans attribut, on peut lui en ajouter ensuite

]]> Bonne réponse : __init__ sert à initialiser, pas à créer ;
p.x = 3 ajoute un attribut après coup. Écrire un constructeur
reste préférable pour que tous les objets aient les mêmes
attributs.

]]> Non, __init__ est obligatoire pour toute classe instanciable

]]> Erreur : Python fournit un constructeur par défaut, sans
paramètre.

]]> Classes et programmation objet — Q38 : Comparer deux objets avec l'opérateur d'égalité Qu'affiche ce programme ?
``python
class Point:
def __init__(self, x, y):
self.x = x
self.y = y

print(Point(1, 2) == Point(1, 2))
``

]]> Pour que == compare les attributs, la classe doit définir sa
propre règle d'égalité ; sinon, seul le même objet est égal à
lui-même.

]]> 1.0 0.0 0 true true abc False, == comparant par défaut l'identité des objets

]]> Bonne réponse : sans règle d'égalité définie dans la classe,
== compare l'identité des objets, comme is. Deux
constructions donnent deux objets différents, malgré des
attributs identiques.

]]> None, la comparaison n'étant pas définie pour cette classe

]]> Erreur : la comparaison renvoie un booléen.

]]> True, les attributs x et y ayant les mêmes valeurs

]]> Erreur : Python ne compare pas les attributs de lui-même.

]]> Une erreur, == ne s'appliquant pas aux objets d'une classe

]]> Erreur : == s'applique à tout, mais avec un sens par défaut
qui surprend.

]]>