Vous pouvez me contacter via Facebook (questions, critiques constructives) : page Facebook relative à mon site
De même que Monsieur Jourdain faisait de la prose sans le savoir, vous faites avec Python, de la Programmation Oriénté Objet tout en l'ignorant.
Vous manipulez dès le départ des instances de classe, des méthodes de classes.
Regardez attentivement cette suite de commandes :
Quand vous écrivez type(maliste) l'interface retourne le message : class 'list'.
Vous avez créé une instance de la classe 'list'.
Ensuite vous manipulez cet objet de la classe 'list' et alors vous rencontrez deux syntaxes différentes :
Len() est une fonction générique (ou native ou standard) qui peut s'appliquer à des objets de
types différents (appartenant à différentes classes).
Vous connaissez d'autres fonctions natives : abs(), dir(), round(), print(), type(), range(), input(), range(), etc.
Par contre count() & index() sont des fonctions spécifiques la classe 'list'. On parle plus précisément de méthodes de classe.
Pour appliquer une méthode de classe à un objet de ladite classe, il faut utiliser la notation pointée : nomObjet.méthode(arguments éventuels).
Nous attaquons dans ce chapitre un gros morceau qui peut faire peur : la POO (Programmation Orientée Objet).
Rassurez vous, comme vous êtes déjà familiarisé avec les classes, les instances de classe et les méthodes de classe, ça devrait pas poser
pour vous de grosses difficultés.
Prenons un exemple tiré de la vie courante pour illustrer la POO.
Médor est un chien. Pendant une journée typique, il fait diverses actions: il mange, il court, il dort, etc.
En POO on utilise les termes suivants : classe, instance de classe (ou objet), attributs et méthodes de classe.
La relation entre un attribut OU une méthode et l’objet est indiquée par un point écrit entre les deux. C'est ce qu'on appelle la notation pointée.
La POO correspond à une autre manière d’imaginer, de construire et d’organiser son code.
Python est résolument orienté objet, tout est construit autour de la notion d'objet.
Pour véritablement maitriser Python il est donc indispensable de comprendre la composante orientée objet.
# nom programme : p_classe_personne # création classe Personne avec deux attributs class Personne: def __init__(self,n,a): self.nom = n self.age = a # création d'une instance dans la classe Personne p1 = Personne("Albert",27) print("nom et âge de p1 : ", p1.nom , " " , p1.age) # création d'un nouvel objet de type Personne p2 =Personne("Evelyne",47) print("nom et âge de p2 : " ,p2.nom, " " , p2.age) # modifier les attributs de objet p1 p1.age = 28 p1.nom =" Einstein" print("nom et âge modifiés de p1 : " , p1.nom, " " ,p1.age)
Il crée une classe nommée "Personne" puis :
Le précédent programme ne définissait pour la nouvelle classe que des attributs. Dans celui-ci on définit aussi des méthodes de classe.
#classe Rectangle avec deux attributs class Rectangle: def __init__(self,L,l): self.Longueur=L self.Largeur=l # méthodes de classe ci-dessous def surface(self): return self.Longueur*self.Largeur def perimetre(self): return (self.Longueur* 2) + (self.Largeur*2) # création d'un rectangle de longueur 7 et de largeur 5 rect1 = Rectangle(7,5) print("La surface de mon rectangle est : ", rect1.surface()) print("le périmètre du rectangle est : " ,rect1.perimetre()) # modifier les attributs d'une instance de classe rect1.Longueur = 9 rect1.largeur = 6 print ("Nouveaux périmètre et surface de rect1 : ", rect1.surface(), rect1.perimetre()) # créer une nouvelle instance de classe longueur = eval(input("longueur : ")) largeur = eval(input("largeur : ")) rect2 = Rectangle(longueur, largeur) print( "Caractéristiques de rect2" , end=":") print( rect2.Longueur, " " , rect2.Largeur, " ", rect2.surface(), " " , rect2.perimetre() )
Il crée une classe nommée "Rectangle".
Il définit pour cette classe :
Maintenant que vous avez observé attentivement le code de ces deux programmes on peut présenter la syntaxe Python dans le cadre de la POO
Syntaxe : class Nomclasse:
Par convention le nom d’une classe commence toujours par une majuscule, mais ce n'est pas une obligation. N'oubliez pas les : pour début de bloc
Dans le même bloc il faut définir les attributs et méthodes de la classe.
def __init__(self,param1, param2, ...): self.variable1=param1 self.variable2=param2 ...
Le mot "self" est obligatoire.
def méthode(self): return expression
Il faut au minimum le paramètre "self". Le mot "self" sera expliqué plus bas.
L'expression est construite à partir des attributs.
Syntaxe : nomObjet = NomClasse(arguments)
Syntaxe : nomObjet.attribut = nouvelle valeur
Syntaxe : nomObjet.méthode()
Il faut expliquer ce que signifie ce mot "self" qui est omniprésent dans la syntaxe.
Une des particularités des méthodes est que l’objet qui l’appelle est passé comme premier argument de la fonction telle que définie dans
la classe. Ainsi, lorsqu’on écrit rect1.surface() par exemple, l’objet "rect1" est passé de manière implicite à "surface()".
Aussi une méthode possède toujours à minima le paramètre "self" et lorsqu'on appelle ladite méthode, il n'y a aucun argument à saisir.
Si la fonction --init--() comprend trois paramètres (dont self), il faut alors passer deux arguments pour créer une nouvelle instance de classe.
Les classes nous permettent de mettre en place ce qu'on appelle l'encapsulation du code c'est à dire le compartimentage des variables et des fonctions.
En effet chaque objet créé à partir d’une classe posséde ses attributs et méthodes qui ne sont pas accessibles à l'extérieur de l'objet.
En POO on dit qu’un objet “hérite” des méthodes de sa classe ; cela signifie qu'une instance de classe a accès aux méthodes de cette classe.
Ainsi une instance de la classe Rectangle a accès aux méthodes surface() et perimetre().
Une classe peut "hériter" d'une autre classe : une classe dite "fille" hérite de toutes les variables et fonctions de la classe parent (et notamment de sa fonction __init__())
# nom programme : heritage.py #création d'une classe Personne avec deux attributs class Personne: def __init__(self,nom,age): self.nom = nom self.age=age # La classe Etudiant hérite de la classe mère Personne class Etudiant(Personne): # définition des attributs def __init__(self,nom,age,filiere): # héritage des attributs depuis la classe mère Personne Personne.__init__(self,nom,age) # ajout d'un nouvel attribut filiere à la classe Etudiant self.filiere = filiere etudiant1 = Etudiant("Albert",27,"math") print("nom, âge, filière : " ,etudiant1.nom, " ", etudiant1.age, " " ,etudiant1.filiere) #créer d'une nouvelle instance de la classe Etudiant etudiant2 =Etudiant("Isabelle",21,"informatique") print("nom, âge, filière : " ,etudiant2.nom, " ", etudiant2.age, " " ,etudiant2.filiere)
Création d'une classe "Personne" avec deux attributs : nom & age
Création de la classe "Etudiant" à partir de "Personne"
Cette classe récupère les attributs de la classe mère
Ajout d'un troisième attribut
Création d'une première instance de Etudiant : etudiant1
Création d'une deuxième objet : etudiant2
Les paramètres de la fonction –init--() peuvent être identiques aux noms des variables (attributs) définis par cette fonction.
Exemple :
def __init__(self,nom,age): self.nom = nom self.age=age
class Etudiant(Personne): cette instruction signifie que la classe "Etudiant" hérite de la classe "Personne".
Personne.__init__(self,nom,age) : instruction pour récupérer les attributs nom et age de Personne
self.filiere = filiere : instruction pour créer un troisième attribut.
# nom programme : heritage.py #création d'une classe Personne class Personne: def __init__(self,nom,age): self.nom = nom self.age=age # La classe fille Etudiant hérite de la classe mère Personne class Etudiant(Personne): # définition des attributs def __init__(self,nom,age,filiere): # héritage des attributs depuis la classe mère Personne Personne.__init__(self,nom,age) # ajout d'un troisième attribut self.filiere = filiere #ajout d'une méthode def affiche(self): return self.nom + " " + str(self.age) + " "+ self.filiere #créer une instance de Etudiant etudiant1 = Etudiant("Albert",27,"math") print("Nom, âge, filière : " ,etudiant1.nom, " ", etudiant1.age, " " ,etudiant1.filiere) #modifier les attributs d'un objet etudiant1.nom ="Alberta" etudiant1.age = 28 #utiliser la méthode affiche() à l'objet etudiant1 print("nom, âge, filière : " ,etudiant1.affiche()) #créer d'une nouvelle instance de Etudiant etudiant2 =Etudiant("Isabelle",21,"informatique") #utiliser la méthode affiche() à l'objet etudiant2 print("Nom, âge,filiere :", etudiant2.affiche())
Il définit dans la classe Etudiant une méthode affiche() qui produit la fiche de l'étudiant.
Il est en effet beaucoup plus simple d'écrire print(nomObjet.affiche()) que
print(nomObjet.nom , " ", nomObjet.age , " ", nomObjet.filiere)
Et encore, ici il n'y a que trois variables. Mais s'il y en avait 10 ...