__init__, accès aux attributs etVoiture,Voiture distincts, chacun avec# en Python etVoiture, desmarque, modele,couleur, vitesse. ChaqueVoiture, desaccelerer, freiner,afficher. Elles agissentself.]]>self etVoitureclass, 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.]]>class Voiture:
pass]]>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.]]>new class Voiture {}]]>Voiture = class()]]>class suivi du nom de ladef Voiture():
pass]]>def introduit uneclass.]]>Voiture en Python ?]]>Voiture désigne la classeVoiture()v = new Voiture()]]>new n'existe pasv = create Voiture]]>create n'existev = Voiture]]>v reçoit la classev = Voiture()]]>__init__, s'il est défini)v est une instance de la classeVoiture possédant un attributmarque, comment lit-on la valeur dev.marque]]>v.demarrer().]]>v->marque]]>get(v, marque)]]>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.]]>v["marque"]]]>selfthis, qui estself est un paramètre localself n'est pas unself ne désigne pas une classe : il désigne l'objet sur lequel la méthode est appelée.]]>self le premierv.demarrer(), Pythonvself.]]>__init__ d'une classe ?]]>__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.]]>__init__ intervient à la création de l'objet, pas à sa disparition : elle fixe les valeurs initiales de ses attributs.]]>__init__ estimport,__init__.]]>class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(3, 4)
print(p.x, p.y)__init__ qui prend les valeursself à l'aideself.attr = ....]]>Point(3, 4)]]>print(p.x,
p.y) n'affiche pas l'objet3 4]]>Point(3, 4)__init__ initialiseself.x = 3 etself.y = 4. La fonctionprint affiche les deux7]]>print n'effectuedistance_origine à la classePoint, qui renvoie la distancep.distance_origine(). Pythonpself.]]>class Point:
def distance_origine():
return ...]]>self en première position.def distance_origine(p):
return (p.x ** 2 + p.y ** 2) ** 0.5]]>class Point:
...
def distance_origine(self):
return (self.x ** 2 + self.y ** 2) ** 0.5]]>self comme premierself.x et self.y.]]>class Point:
distance_origine = (x ** 2 + y ** 2) ** 0.5]]>x et y ne sontv1 = Voiture("Renault"),v2 = Voiture("Peugeot"), etPileempiler et depiler. Quel__init__ choisir ?]]>__init__ initialiseself.nom = valeur. Sans leself., on ne créedef __init__(self):
return []]]>__init__ neNone). On y initialisedef __init__():
elements = []]]>self manque,elements n'est ici__init__. Il faudraitself.elements = []def __init__(self):
elements = []]]>self., leelements désigne une__init__. Il fautself.elements = [].]]>def __init__(self):
self.elements = []]]>empiler et depilerself.elements.]]>Pile, par exemple, lesempiler etdepiler manipulentclass 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))p.distance(q), l'objet placé avant le point devient self, et l'argument entre parenthèses devient autre.]]>7]]>p.distance(q), self désigne p et autre désigne q. La méthode calcule $|1 - 4| + |2 - 6| = 3 + 4 = 7$.]]>5]]>distance attend deux arguments et n'en reçoit qu'un]]>self n'est pas à fournir : Python lui donne automatiquement l'objet p. Le seul argument écrit, q, correspond au paramètre autre.]]>self]]>autre.x désigne l'attribut x de q, accessible par la notation pointée.]]>Noeud, par exemple,enfiler, defiler)type(p)p est une instance dePoint ?]]>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(...).]]>Point]]>type renvoie la classe de l'objet passé en paramètre, ici Point : le test type(p) == Point vaut True.]]>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.]]>"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.]]>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.]]>class Compteur:
def __init__(self):
self.n = 0
def incrementer(self):
self.n += 1
c = Compteur()
c.incrementer()
c.incrementer()
print(c.n)self.attr.]]>2]]>n à $0$.incrementer ajoute $1$self.n. Après deux0]]>incrementer, qui1]]>incrementertype 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.]]>sorted pour choisir la clé de tri.]]>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.]]>None lorsqu'ilsdef Noeud(val, gauche=None, droite=None):
return {"val": val, "gauche": gauche, "droite": droite}]]>Noeudn["val"] au lieu den.val et n'a aucuneclass Noeud:
def __init__(self, val, gauche=None, droite=None):
val = val
gauche = gauche
droite = droite]]>__init__. Sans écrireself.val = val, l'objetn.val provoqueAttributeError.]]>class Noeud:
def __init__(self, val, gauche=None, droite=None):
self.val = val
self.gauche = gauche
self.droite = droite]]>val,gauche et droite. LesNone (ce qui correspondNoeud, ceclass Noeud:
val = 0
gauche = None
droite = None]]>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 ?
]]>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 1 1]]>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 2]]>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.]]>b n'a pas été créé par Compteur()]]>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.]]>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.]]>self, doivent être respectées pour la lisibilité du code.]]>__init__ est appelée automatiquement à la création d'une instance]]>__init__.]]>self doit obligatoirement s'appeler self]]>this, obj ouCompte représentant un comptedeposer(montant) etretirer(montant)self.solde),deposer et retirerFalse plutôt que de laisser leFalse.]]>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]]>deposerretirer vérifie queFalse. Lesclass Compte:
def __init__(self):
self.solde = 0
def __retirer__(self, m):
self.solde -= m]]>__retirer__ n'est__init__,__str__, etc.). Ici, ilretirer. De plus,deposer ni de vérificationclass 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]]>retirer ne vérifiedeposer.]]>class Compte:
solde = 0
def deposer(montant):
solde += montant
def retirer(montant):
solde -= montant]]>self est absentsolde est un attribut desolde += ...self..]]>File range ses éléments dans la liste self.elements,append. Quelledefiler, qui retire et renvoie le plusreturn self.elements.pop(0)]]>pop(0) le retire et le renvoie.]]>return self.elements.pop()]]>pop retire le dernier arrivé ; cereturn self.elements[0]]]>return self.elements.remove(0)]]>remove(0) cherche la valeur $0$, pas l'indice, et neest_vide d'unePile dont les éléments sont dans la listeself.elements ?]]>return len(self.elements) == 0]]>True quandreturn self.elements == None]]>None ; ce test répondFalse.]]>return len(self.elements)]]>True.]]>return self.elements.pop() is None]]>pop sur une listea.plus(b) ?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)selfRationnel(5, 6), un nouvel objet, a et b restant intacts]]>Rationnel(2, 5), les numérateurs et dénominateurs s'ajoutant]]>Rationnel(1, 6), le produit des deux fractions]]>Rationnel(...) commeclass Eleve:
def __init__(self, nom, note):
self.nom = nom
self.note = note
eleves = [Eleve("Ana", 15), Eleve("Bob", 12)]
print(eleves[1].note)12, la note du second élève de la liste]]>eleves[1] est le second objet, et .note lit15, la note du premier élève de la liste]]>eleves[1] est leBob, le nom du second élève]]>note qui est affiché, pas nom.]]>class Panier:
def __init__(self):
self.articles = []
p1 = Panier()
p2 = Panier()
p1.articles.append("pain")
print(len(p2.articles))__init__ appartiennent à chaque objet :0, chaque appel de __init__ créant une liste distincte]]>[] est évalué à chaque construction ; p1 etp2 ont chacun leur liste, et seule celle de p1 a reçu un1, la liste étant partagée par toutes les instances]]>__init__, une fois par objet.]]>p2.articles n'existant pas encore]]>__init__ a créé l'attribut de p2 à saNone, la liste de p2 n'ayant jamais été remplie]]>v est un objet de la classe Voiture, qui possède un attributvitesse. Que fait l'instruction v.vitesse = 50 ?]]>objet.attribut y accède en lecture comme en écriture.]]>50 à l'attribut vitesse de l'objet v]]>vitesse valant 50]]>v. désigne l'attribut de l'objet, pas une50 à la vitesse de toutes les voitures]]>v est concerné.]]>class Personne:
def __init__(self, nom):
nom = nom
p = Personne("Ada")
print(p.nom)self.AttributeError, l'attribut nom n'ayant jamais été créé]]>nom = nom réaffecte la variable locale duself.nom = nom.]]>Ada, Python ajoutant self. automatiquement]]>self.]]>nom = nom est une affectation valide, inutile maisNone, l'attribut existant sans valeur]]>Rectangle a une méthode aire qui renvoie le produitr.aire, sans parenthèses ?]]>r.aire et r.aire() sont deux expressions différentes : la<bound method ...>.r.aire() effectue le calcul.]]>aire n'existant pas]]>aire existe bien, c'est une méthode.]]>None, la méthode n'ayant pas encore été appelée]]>r.aire vaut-il $40$ ?class Rectangle:
def __init__(self, largeur, hauteur):
self.largeur = largeur
self.hauteur = hauteur
self.aire = largeur * hauteur
r = Rectangle(2, 4)
r.largeur = 10aire garde $8$, calculé une seule fois à la construction]]>aire est une valeur stockée, pas unelargeur ne le recalcule pas. Une méthodeaire() qui calcule à la demande évite ce décalage.]]>largeur ne pouvant être modifié après la construction]]>aire a été défini après largeur]]>__init__ ne crée aucune dépendance__init__ ?class Point:
pass
p = Point()__init__ sert à initialiser, pas à créer ;p.x = 3 ajoute un attribut après coup. Écrire un constructeur__init__ est obligatoire pour toute classe instanciable]]>Point() renvoie None faute de constructeur défini]]>Point() renvoie bien un objet de type Point.]]>class Point:
def __init__(self, x, y):
self.x = x
self.y = y
print(Point(1, 2) == Point(1, 2))== compare les attributs, la classe doit définir saFalse, == comparant par défaut l'identité des objets]]>== compare l'identité des objets, comme is. DeuxTrue, les attributs x et y ayant les mêmes valeurs]]>== ne s'appliquant pas aux objets d'une classe]]>== s'applique à tout, mais avec un sens par défautNone, la comparaison n'étant pas définie pour cette classe]]>