$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 modèle ou « plan » qui décrit la structure (les attributs) et le comportement (les méthodes) d'objets de même nature

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

]]> Un fichier source Python

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

]]> Un type particulier d'erreur Python

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

]]> Une simple variable 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, comme expliqué dans la
bonne réponse.

]]> 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 Une réalisation concrète d'une classe, possédant ses propres valeurs d'attributs

]]> 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.

]]> 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.

]]> 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 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.

]]> 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, par exemple le nom ou l'age d'une Personne

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

]]> 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.

]]> 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 Une fonction définie dans la classe, qui peut accéder aux attributs des instances et agir sur eux

]]> 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.

]]> 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.

]]> 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.

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

]]> Conventions Python : les noms de
classes s'écrivent en
CamelCase (Voiture,
MaSuperClasse), tandis que les
noms de fonctions et de variables
s'écrivent en snake_case
(ma_fonction, ma_variable).

]]> 1.0 0.0 0 true true abc `python
class Voiture:
pass
`

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

]]> `python
new class Voiture {}
`

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

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

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

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

]]> 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 = 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 = 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

]]> 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.

]]> 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éé.

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

]]> 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 la notation v->marque

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

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

]]> Une fonction getattr(v,
"marque") existe en Python,
mais on lui préfère
systématiquement la notation
pointée, plus simple et plus
lisible.

]]> 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.

]]> 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 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.

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

]]> Pour faire référence à la
classe parente, on utilise la
fonction super(). Le
paramètre self désigne
l'instance, et non une
classe.

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

]]> 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.

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

]]> Convention : les noms encadrés de
doubles soulignés (__nom__)
désignent des méthodes spéciales
en Python, comme __init__,
__str__ ou __len__. Parmi
elles, __init__ est de loin la
plus utilisée.

]]> 1.0 0.0 0 true true abc Initialiser les attributs d'un nouvel objet au moment de sa création (rôle de constructeur)

]]> 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.

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

]]> La destruction d'un objet est
plutôt prise en charge par la
méthode spéciale __del__,
rarement utilisée en Python en
raison du ramasse-miettes.

]]> 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.

]]> Importer un module dans le programme

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

]]> 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 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.

]]> 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 déclenche une erreur de syntaxe

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

]]> 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:
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
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.

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

]]> 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.

]]> Autant d'instances que nécessaire, chacune ayant ses propres valeurs d'attributs

]]> 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.

]]> 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.

]]> 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.

]]> 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):
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):
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):
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 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.

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

]]> 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.

]]> 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.

]]> 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.

]]> Classes et programmation objet — Q15 : La méthode `__str__` À quoi sert la méthode spéciale
__str__ ?

]]> Exemple typique :
`python
def __str__(self):
return f"Point({self.x}, {self.y})"

L'instruction print(Point(3, 4))
affichera alors Point(3, 4)`.

]]> 1.0 0.0 0 true true abc À supprimer l'objet

]]> La suppression d'un objet
relève plutôt de la méthode
__del__. La méthode
__str__ produit une
chaîne descriptive.

]]> À convertir l'objet en entier

]]> Cette conversion serait
plutôt assurée par la
méthode spéciale __int__.
La méthode __str__
concerne la représentation
textuelle.

]]> À déclarer une variable

]]> La déclaration d'une
variable n'a rien à voir
avec une méthode spéciale.
La méthode __str__
retourne une chaîne de
caractères.

]]> À définir la représentation textuelle de l'objet, utilisée par print(obj) et str(obj)

]]> Sans __str__, l'instruction
print(p) afficherait
quelque chose comme
<__main__.Point object at
0x...>. Avec une __str__
bien définie, on peut par
exemple obtenir
Point(3, 4).

]]> 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 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.

]]> Elle permet de regrouper proprement les données (par exemple valeur, gauche, droite pour un nœud d'arbre) et les opérations (parcours, recherche, insertion) 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 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.

]]> 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 Aucune différence

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

]]> 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.

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

]]> 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.

]]> 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 ?

]]> Une variante utile :
isinstance(p, Point)
renvoie True si p est
une instance de Point ou
d'une éventuelle sous-classe.
Cette forme est plus
souple que type(p) == Point.

]]> 1.0 0.0 0 true true abc <class 'Point'>

]]> La fonction type renvoie
la classe de l'objet
passé en paramètre. Elle
permet de connaître la
nature exacte d'un objet.

]]> object

]]> La classe object est la
classe ancêtre de toutes
les classes Python, mais
ce n'est pas la classe
précise de p.

]]> Point

]]> L'appel renvoie bien la
classe Point, mais sa
représentation textuelle
dans la console est
<class 'Point'>. Le
test type(p) == Point
renvoie cependant
True.

]]> Une exception

]]> Le code est parfaitement
valide et ne lève aucune
exception.

]]> 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 déclenche une erreur

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

]]> 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 affiche 0

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

]]> Il affiche 1

]]> La méthode incrementer
est appelée deux fois
successives, et non une
seule.

]]> 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é : on peut écrire
type(42) ou même
(42).__class__. Ce modèle
« tout est objet » donne au
langage Python une grande
cohérence et autorise des
constructions puissantes.

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

]]> Les fonctions Python sont
des objets de première
classe : elles peuvent
être passées en
paramètre, stockées dans
une variable, ou
renvoyées par d'autres
fonctions.

]]> 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.

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

]]> Par exemple, l'appel
type(42) renvoie
<class 'int'>, et
type("a") renvoie
<class 'str'>. Même
les classes elles-mêmes
sont des objets, qui sont
des instances de la
métaclasse type.

]]> Aucune des affirmations précédentes n'est correcte

]]> La deuxième proposition
est précisément correcte,
comme expliqué dans la
bonne réponse.

]]> 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
def Noeud(val, gauche, droite):
return val
`

]]> Cette définition est une
fonction, et non une
classe. De plus, elle ne
renvoie que la valeur,
sans construire de
structure d'arbre.

]]> `python
class Noeud:
pass
`

]]> Cette classe est vide :
elle ne permet pas de
stocker la valeur, le
sous-arbre gauche ni le
sous-arbre droit.

]]> `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 — Q22 : Attribut de classe et attribut d'instance ``python
class Voiture:
marques = []
def __init__(self, marque):
Voiture.marques.append(marque)

v1 = Voiture("Renault")
v2 = Voiture("Peugeot")
print(Voiture.marques)
``
Que produit ce code ?

]]> Distinction essentielle :
les attributs de classe
sont partagés entre toutes
les instances, alors que
les attributs
d'instance appartiennent
à un objet particulier. La
confusion est fréquente,
surtout avec des listes
mutables placées en
attribut de classe.

]]> 1.0 0.0 0 true true abc Il affiche ['Peugeot']

]]> La marque « Renault » est
également ajoutée par le
premier appel à
__init__, et reste donc
dans la liste.

]]> Il affiche ['Renault', 'Peugeot']

]]> L'attribut marques est
déclaré au niveau de la
classe, et non d'une
instance : il est donc
partagé par toutes les
voitures. Les ajouts
successifs s'accumulent
dans la même liste.

]]> Il affiche []

]]> Cette réponse ignore les
deux appels à
__init__, qui ajoutent
chacun une marque à la
liste partagée.

]]> Il déclenche une erreur

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

]]> Classes et programmation objet — Q23 : Pratique déconseillée Quelle pratique est
déconseillée en programmation
orientée objet ?

]]> Le principe est le
suivant : on interagit avec
un objet à travers son
interface publique. Les
détails internes peuvent
ainsi évoluer sans affecter
le code utilisateur, tant
que l'interface reste
stable.

]]> 1.0 0.0 0 true true abc Utiliser des méthodes pour modifier les attributs d'un objet

]]> C'est au contraire une
bonne pratique. Les
méthodes encapsulent les
modifications et peuvent
y ajouter des
vérifications.

]]> Définir un constructeur __init__

]]> C'est au contraire une
bonne pratique standard
que de définir
explicitement les
attributs d'un objet
dans __init__.

]]> Donner un nom en CamelCase à la classe

]]> Le CamelCase est
précisément la
convention recommandée
en Python pour les noms
de classes.

]]> Modifier directement les attributs internes d'un objet depuis l'extérieur, par exemple en écrivant compte.solde = -1000 au lieu de passer par une méthode comme compte.deposer(...)

]]> Ce contournement
court-circuite les
vérifications éventuelles
(par exemple, garantir
que le solde reste
positif). On préfère
exposer des méthodes qui
maintiennent les
invariants de l'objet.

]]> 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 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.

]]> Pour calculer la 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é.

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

]]> 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 (comme le
style PEP 8 ou les
idiomes communs) doivent
être respectées pour la
lisibilité et la
maintenabilité du code.

]]> 1.0 0.0 0 true true abc 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.

]]> 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.

]]> Classes et programmation objet — Q26 : Méthodes spéciales On définit la classe suivante :
`python
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

Quel est l'effet d'avoir défini la
méthode __eq__` ?

]]> Quelques méthodes spéciales
utiles : __init__ (constructeur),
__str__ (affichage par
print), __repr__
(représentation détaillée),
__eq__ et __lt__
(comparaisons), __len__
(longueur via len),
__getitem__ (accès indexé via
obj[i]). Elles permettent à
Python de manipuler les objets
personnalisés comme des objets
natifs.

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

]]> Erreur : la définition de
__eq__ ne rend pas la classe
immuable. Pour cela, il
faudrait écrire des méthodes
spécifiques qui empêchent la
modification des attributs
(par exemple en utilisant des
property en lecture seule).

]]> Aucun effet : Python ignore les
méthodes commençant par un
double soulignement

]]> Erreur : c'est exactement
l'inverse. Les méthodes encadrées
de doubles soulignements
(__nom__) sont les méthodes
spéciales que Python appelle
automatiquement dans certaines
situations (création d'objet,
comparaison, affichage, etc.).

]]> La comparaison Point(1, 2) ==
Point(1, 2) renverra True
(deux points avec mêmes
coordonnées sont considérés
égaux), au lieu de False
comme c'était le cas par défaut

]]> Bonne réponse : sans __eq__,
Python compare les objets par
identité (l'opérateur is),
donc deux instances distinctes
sont différentes même si elles
ont les mêmes attributs. En
définissant __eq__, on
surcharge l'opérateur == pour
comparer par valeur. C'est
l'une des nombreuses méthodes
spéciales (avec __lt__,
__hash__, __len__,
__str__, etc.) qui permettent
de personnaliser le
comportement des objets.

]]> Les objets Point ne pourront
plus être créés

]]> Erreur : __eq__ n'a aucun
effet sur la création d'objets,
qui reste régie par
__init__. Elle agit
uniquement sur la comparaison
d'égalité.

]]> 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, 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.

]]> `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
def Compte(solde):
return solde
`

]]> Erreur : ce code définit une
fonction, pas une classe. Il
n'y a ni méthode deposer,
ni retirer, ni encapsulation
de l'état. C'est juste une
fonction qui renvoie son
paramètre.

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

]]>