Tutoriel Python : définir les attributs
Rédigé par Ismail BOUZIANE, Publié le 05 Octobre 2020, Mise à jour le Dimanche, 15 Novembre 2020 16:13
Table des matières
Les attributs et les paramètres
Définir les attributs par défaut
Les attributs par défaut d’une fonction
Les attributs par défaut d’une classe
Rappel sur l’instanciation des attributs d’une classe
Définir les attributs par défaut d’une classe
Correction de l’exercice d’application
Introduction :
Les attributs sont présents sur de différents langages de programmation, et plus particulièrement dans les classes et les fonctions, ainsi, il est indispensable de les maitriser afin d’avoir un programme efficace.
Ce tutoriel englobera une introduction sur la notion d’attribut et sa définition, et par la suite, on va engager son utilité et son rapport avec les classes sur Python.
Ainsi, on va présenter quelques exemples et un exercice d’application, pour bien assimiler ce concept et pouvoir l’adapter dans votre code Python.
Les attributs et les paramètres :
Les paramètres représentent les variables mises entre parenthèses dans une fonction ou une classe lors de sa définition.
D’une autre part, Les attributs représentent les valeurs attribuées à ces paramètres lors de l’appel d’une classe ou d’une fonction.
Il est possible d’avoir autant d’attributs dans une classe ou fonction tant qu’on les a définis.
En d’autres termes, les paramètres sont des espaces réservés aux arguments.
Exemple :
On va illustrer la différence entre un argument et un paramètre dans l’exemple suivant :
Syntaxe :
# Définir une fonction d'addition de 3 nombres :
def addition_3nombres (a, b, c) :
# a et b et c représentent les paramètres de la fonction.
return a + b + c
x = addition_3nombres (15, 12, 19)
print (x)
# les nombres 15 et 12 et 19 représentent les attributs.
Résultat d’exécution :
Définir les attributs par défaut :
Les attributs par défaut d’une fonction :
Il est recommandé de définir les valeurs par défaut des paramètres d’une classe ou d’une fonction lors de sa création, afin de ne pas engendrer une erreur si vous décidez d’appeler la fonction sans attributs ou avec moins d’attributs définis dans la fonction.
Exemple :
En reprenant l’exemple précédent, une erreur s’affichera en essayant d’appeler la fonction avec seulement deux attributs.
Syntaxe :
# Définir une fonction d'addition de 3 nombres :
def addition_3nombres (a , b, c ) :
return a + b + c
x = addition_3nombres (15, 30)
print (x)
Résultat d’exécution :
Mais, en attribuant les valeurs par défaut aux paramétres de cette fonction, on peut l’appeler sans arguments, ou pour additionner seulement deux nombres tel que :
Syntaxe :
# Définir une fonction d'addition de 3 nombres
def addition_3nombres (a = 0, b = 0, c = 0) :
return a + b + c
x = addition_3nombres ()
y = addition_3nombres (15)
z = addition_3nombres (15, 30)
print ("x = ", x)
print ("y = ", y)
print ("z = ", z)
Résultat d’exécution :
Les attributs par défaut d’une classe :
Rappel sur l’instanciation des attributs d’une classe :
Afin d’instancier les attributs d’une classe, on définit le constructeur (ou la méthode __init__ ) lors de la création de la classe.
Exemple :
Syntaxe :
class Matière :
# les méthodes de classe doivent commencer par le paramètre "self"
def __init__ (self, nom, prof, classe, notes) :
self.nom = nom
self.prof = prof
self.classe = classe
self.notes = notes
Matière = Matière ("Python", "Ismail", 24, [12, 15, 13, 17])
print(Matière.nom)
print(Matière.prof)
print(Matière.classe)
print(Matière.notes)
Résultat d’exécution :
Définir les attributs par défaut d’une classe :
Tout comme les fonctions, Il est également recommandé de définir les valeurs par défaut des paramètres d’une classe lors de sa création, afin de ne pas engendrer une erreur si vous décidez de supprimer un attribut de la classe.
Exemple :
Syntaxe :
class Matière :
nom = "nom de la matière"
prof = "aucun prof enseigne cette matière"
classe = "aucune classe n'étudie cette matière"
notes = ["liste des notes"]
def __init__ (self, nom, prof, classe, notes) :
self.nom = nom
self.prof = prof
self.classe = classe
self.notes = notes
Matière = Matière ("Python", "Ismail", 24, [12, 15, 13, 17])
print(Matière.nom)
print(Matière.prof)
print(Matière.classe)
print(Matière.notes)
print()
del Matière.prof
print(Matière.prof)
print()
del Matière.classe
print(Matière.classe)
Résultat d’exécution :
Les attributs de classe :
Les attributs privés :
Afin de protéger l’accès à un ou plusieurs attributs d’une classe, on utilise les attributs privés, pour en créer, on ajoute deux underscore « __ » avant le nom de l’attribut.
Exemple :
Sur l’exemple de ce tutoriel (classe Matière) ; on définit les notes comme attribut privés, qui limitera l’accès et la modification de cet attribut.
Remarque : Afin d’affecter l’accès à un attribut privé, on utilise les mutateurs « setters » pour les modifier et les accesseurs « getters » pour renvoyer sa valeur. On verra ces notions dans la suite de ce tutoriel.
Syntaxe :
class Matière :
nom = "nom de la matière"
prof = "aucun prof enseigne cette matière"
classe = "aucune classe n'étudie cette matière"
notes = ["liste des notes"]
def __init__ (self, nom, prof, classe, notes) :
self.nom = nom
self.prof = prof
self.classe = classe
# on définit les attributs privés en ajoutant deux underscore __ :
self.__notes = notes
Matière = Matière ("Python", "Ismail", 24, [12, 15, 13, 17])
print(Matière.notes)
Résultat d’exécution :
Les accesseurs « getters » :
Les méthodes d’une classe nommées accesseurs « getters » sont des méthodes permettant de renvoyer la valeur d’un attribut lié à un objet d’une classe définie.
Les accesseurs se définissent généralement et par convention sous la forme get_NomAttribut (self).
Exemple :
En reprenant l’exemple de la classe Matière, on définit les accesseurs des attributs de cette classe :
Syntaxe :
class Matière :
nom = "nom de la matière"
prof = "aucun prof enseigne cette matière"
classe = "aucune classe n'étudie cette matière"
notes = ["liste des notes"]
def __init__ (self, nom, prof, classe, notes) :
self.nom = nom
self.prof = prof
self.classe = classe
self.__notes = notes
# généralement, on nomme les accesseurs par "get_" suivie du nom d'attribut :
def get_nom (self) :
return self.nom
def get_prof (self) :
return self.prof
def get_classe (self) :
return self.classe
def get_notes (self) :
return self.__notes
Matière = Matière ("Python", "Ismail", 24, [12, 15, 13, 17])
print(Matière.get_nom())
print(Matière.get_prof())
print(Matière.get_classe())
# on va pouvoir avoir accès à l'attribut privé notes grâce à l'accesseur
print(Matière.get_notes())
Résultat d’exécution :
Les mutateurs « setters » :
Les méthodes d’une classe nommées mutateurs « setters » sont des méthodes permettant de modifier la valeur d’un attribut ou paramètre lié à un objet d’une classe définie.
Les mutateurs se définissent généralement et par convention sous la forme set_NomAttribut (self, NomAttribut).
Exemple :
On complète l’exemple précédent de la classe Matière en définissant aussi les mutateurs de cette classe :
Syntaxe :
class Matière :
nom = "nom de la matière"
prof = "aucun prof enseigne cette matière"
classe = "aucune classe n'étudie cette matière"
notes = ["liste des notes"]
def __init__ (self, nom, prof, classe, notes) :
self.nom = nom
self.prof = prof
self.classe = classe
self.__notes = notes
# Les accesseurs :
def get_nom (self) :
return self.nom
def get_prof (self) :
return self.prof
def get_classe (self) :
return self.classe
def get_notes (self) :
return self.__notes
# Les mutateurs :
def set_nom (self, nom) :
self.nom = nom
def set_prof (self, prof) :
self.prof = prof
def set_classe (self, classe) :
self.classe = classe
def set_notes (self, notes) :
self.__notes = notes
Matière = Matière ("Python", "Ismail", 24, [12, 15, 13, 17])
Matière.set_nom("Java")
print(Matière.get_nom())
# on va pouvoir modifier l'attribut privé 'notes' grâce au mutateur :
Matière.set_notes([19, 12, 10])
print(Matière.get_notes())
Résultat d’exécution :
Exercice d’application :
Une usine de fabrication de table souhaite informatiser leur gestion de produits afin d’organiser et accéder aux informations de chaque produit plus efficacement.
En analysant leur produit (table), ils concluent que chaque table dispose de neuf paramètres : la référence, la matière de la table, le poids de la table, la hauteur de la table, la longueur de la table, la largeur de la table, le prix de vente, le prix de fabrication et enfin le nombre de table en stock.
En examinant ses paramètres, créez un programme ayant les instructions suivantes :
- Une classe Table.
- Des attributs par défaut.
- Un constructeur (la méthode __init__) en limitant l’accès aux attributs : prix de fabrication et le nombre de table en stock.
- Des accesseurs « getters ».
- Des mutateurs « setters ».
- Une méthode d’affichage comprenant les attributs suivants : la référence, la matière de la table, la longueur x largeur x hauteur (cm) et le poids de la table, ainsi que le prix de vente.
- Une méthode de calcul de gain prévu par rapport au stock.
- Testez la classe en créant des exemples d’objets.
Correction de l’exercice d’application :
Syntaxe :
# Création de la classe Table :
class Table :
# Définir les attributs par défaut :
ref = "la référence de la table"
matière = "la matière de la table"
poids = "le poids de la table"
hauteur = "la hauteur de la table en cm"
longueur = "la longueur de la table en cm"
largeur = "la largeur de la table en cm"
vente = "le prix de vente"
fabri = "le prix de fabrication"
stock = "le nombre de table en stock"
# Définir le constructeur de la classe :
def __init__ (self, ref, matière, poids, longueur, largeur, hauteur, vente, fabri, stock) :
self.ref = ref
self.matière = matière
self.poids = poids
self.hauteur = hauteur
self.longueur = longueur
self.largeur = largeur
self.vente = vente
self.__fabri = fabri
self.__stock = stock
# Définir les accesseurs "getters" :
def get_ref (self) :
return self.ref
def get_matière (self) :
return self.matière
def get_poids (self) :
return self.poids
def get_hauteur (self) :
return self.hauteur
def get_longueur (self) :
return self.longueur
def get_largeur (self) :
return self.largeur
def get_vente (self) :
return self.vente
def get_fabri (self) :
return self.__fabri
def get_stock (self) :
return self.__stock
# Définir les mutateurs "setters" :
def set_ref (self, ref) :
self.ref = ref
def set_matière (self, matière) :
self.matière = matière
def set_poids (self, poids) :
self.poids = poids
def set_hauteur (self, hauteur) :
self.hauteur = hauteur
def set_longueur (self, longueur) :
self.longueur = longueur
def set_largeur (self, largeur) :
self.largeur = largeur
def set_vente (self, vente) :
self.vente = vente
def set_fabri (self, fabri) :
self.__fabri = fabri
def set_stock (self, stock) :
self.__stock = stock
# Définir la méthode d'affichage :
def affichage (self) :
print ("La table de référence :", self.ref, "\nSes caractéristiques : " )
print ("\tmatière =", self.matière)
print ("\tpoids =", self.poids, "Kg")
print ("\tdimensions (longueur x largeur x hauteur) en cm =", self.longueur,"x", self.largeur,"x", self.hauteur)
print ("\tprix =", self.vente)
# Définir la méthode de calcul de gain prévu par rapport au stock.
def calcul_gain (self) :
return (self.vente - self.__fabri) * self.__stock
# Test de classe et création d'objet :
table1 = Table ("A12345", "bois", 60, 170, 90, 80, 1500, 1200, 20)
table2 = Table ("CT789645", "acier", 20, 160, 80, 80, 900, 700, 50)
table1.affichage()
print ("le gain par rapport au lot est :", table1.calcul_gain())
table2.affichage()
print ("le gain par rapport au lot est :", table2.calcul_gain())
Résultat d’exécution :
Conclusion :
Afin de rendre votre code Python efficace et DRY, il est nécessaire de bien maitriser la notion d’attribut, cette maitrise vient en pratiquant cette notion pour présenter de différents objets inspirés du monde réel, et les associer sur un programme contenant leurs paramètres et comportements.
On verra par la suite de nouvelles notions sur les classes telle que l’héritage qui sont également avantageux lors de création de plusieurs classes ayant des caractéristiques en commun. Bonne chance !