__init__, accès aux attributs etVoiture,Voiture distincts, chacun avec# en Python etVoiture, desmarque, modele,couleur, vitesse. Chaquenom ou l'age d'une Personne]]>Voiture, desaccelerer, freiner,afficher. Elles agissentself.]]>self etVoitureVoiture,MaSuperClasse), tandis que lesma_fonction, ma_variable).]]>class Voiture:
pass]]>class,pass permet de signaler unnew 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)]]>getattr(v,
"marque") existe en Python,v["marque"]]]>selfthis, qui estself est un paramètre localself n'est pas unsuper(). Leself désigneself le premierv.demarrer(), Pythonvself.]]>__init__ d'une classe ?]]>__nom__)__init__,__str__ ou __len__. Parmi__init__ est de loin la__del__,__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 manipulent__str__ ?]]>def __str__(self):
return f"Point({self.x}, {self.y})"print(Point(3, 4))Point(3, 4).]]>__del__. La méthode__str__ produit une__int__.__str____str__print(obj) et str(obj)]]>__str__, l'instructionprint(p) afficherait<__main__.Point object at
0x...>. Avec une __str__Point(3, 4).]]>valeur, gauche, droite pour un nœud d'arbre) et les opérations (parcours, recherche, insertion) en une seule entité]]>Noeud, par exemple,enfiler, defiler)type(p)p est une instance dePoint ?]]>isinstance(p, Point)True si p estPoint outype(p) == Point.]]><class 'Point'>]]>type renvoieobject]]>object est lap.]]>Point]]>Point, mais sa<class 'Point'>. Letype(p) == PointTrue.]]>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(42) ou même(42).__class__. Ce modèletype(42) renvoie<class 'int'>, ettype("a") renvoie<class 'str'>. Mêmetype.]]>None lorsqu'ilsdef Noeud(val, gauche, droite):
return val]]>class Noeud:
pass]]>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 Voiture:
marques = []
def __init__(self, marque):
Voiture.marques.append(marque)
v1 = Voiture("Renault")
v2 = Voiture("Peugeot")
print(Voiture.marques)['Peugeot']]]>__init__, et reste donc['Renault', 'Peugeot']]]>marques est[]]]>__init__, qui ajoutent__init__]]>__init__.]]>compte.solde = -1000 au lieu de passer par une méthode comme compte.deposer(...)]]>__init__ est appelée automatiquement à la création d'une instance]]>__init__.]]>self doit obligatoirement s'appeler self]]>this, obj ouclass 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__eq__ ?]]>__init__ (constructeur),__str__ (affichage parprint), __repr____eq__ et __lt____len__len),__getitem__ (accès indexé viaobj[i]). Elles permettent àPoint devient__eq__ ne rend pas la classe__nom__) sont les méthodesPoint(1, 2) ==
Point(1, 2) renverra TrueFalse__eq__,is),__eq__, on== pour__lt__,__hash__, __len__,__str__, etc.) qui permettentPoint ne pourront__eq__ n'a aucun__init__. Elle agitCompte 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érificationdef Compte(solde):
return solde]]>deposer,retirer, ni encapsulationclass Compte:
solde = 0
def deposer(montant):
solde += montant
def retirer(montant):
solde -= montant]]>self est absentsolde est un attribut desolde += ...self..]]>