Créer une nouvelle classe

ghmesnil   21 mars 2016   Commentaires fermés sur Créer une nouvelle classe

Python est un langage orienté objet. S’il existe dans ce langage des objets qu’on utilise classiquement comme les listes ou les chaînes de caractères, on peut aussi en fabriqué de nouveaux.

Définition simple d’une classe d’objets

On peut, par exemple, créer un objet informatique qui serait un rectangle. Un rectangle est caractérisé par sa largeur et sa longueur (exprimés en pixels). Ces deux caractéristiques s’appellent des attributs.

Voici le code pour créer une classe de rectangles dont les attributs longueur et largeur seraient par défaut égaux à 4 et 3 respectivement.

class rectangle :
    def __init__(self):
        self.longueur = 4
        self.largeur = 3

( ‘__’ s’écrit à l’aide de deux « tirets du 8 »)

Lorsque la classe rectangle est définie, on peut créer autant d’objets de ce type qu’on le souhaite :

rect1=rectangle()
rect2=rectangle()

Ici, rect1 et rect2 sont deux objets de type rectangle ayant par défaut une longueur de 3 pixels et une largeur de 4 pixels.
Vérifiez cela :

print(rect1.longueur, rect1.largeur)
print(rect2.longueur, rect2.largeur)

Il est possible de modifier la valeur des attributs longueur et largeur pour chaque objet de manière très simple à n’importe quel endroit du programme :

rect1.longueur=7
rect2.largeur=2
rect2.longueur=rect1.longueur
print(rect1.longueur, rect1.largeur)
print(rect2.longueur,rect2.largeur)

Définition d’une classe d’objets avec arguments

Il est possible de créer une classe d’objets sans que l’on donne par défaut une valeur à leurs attributs. Ceux-ci n’auront de valeur qu’à la création effective de l’objet.

Par exemple, pour la classe d’objets Eleve définie ci-dessous, les attributs nom et prenom ne sont pas définis par défaut, contrairement à l’attribut spe :

class Eleve:
    def __init__(self, valN, valP):
        self.nom=valN
        self.prenom=valP
        self.spe='ISN'

A=Eleve('Thomas','Dupont')
print(A.nom)
print(A.prenom)
print(A.spe)

Il est possible par la suite, à tout moment dans le programme de modifier les attributs de l’objet :

A.nom='Queneau'
A.prenom='Raymond'
print(A.prenom,A.nom)

Certains attributs peuvent être définis à partir d’autres. On peut ainsi modifier la classe Eleve comme suit pour créer un attribut nom_complet :

class Eleve:
    def __init__(self, valN, valP):
        self.nom=valN
        self.prenom=valP
        self.nom_complet=self.prenom+self.nom
        self.spe='ISN'

Lorsque l’on créera un nouvel objet Eleve,  l’attribut nom_complet prendra sa valeur en fonction des attributs longueur et largeur. Mais il ne sera pas modifié si, par la suite, ces deux attributs changent de valeur. Essayez l’exemple suivant :

A=Eleve('Thomas','Dupont')
print(A.nom_complet)

A.nom='Queneau'
A.prenom='Raymond'
print(A.prenom,A.nom)
print(A.nom_complet)

Définir des méthodes propres à la classe

Les méthodes sont des fonctions qui font partie des caractéristiques d’une classe d’objet.

Par exemple, pour la classe rectangle, on pourrait définir trois méthodes pour obtenir l’aire et le périmètre de l’objet ou pour augmenter ses dimensions d’une proportion p. Voici comment on déclare alors cette classe :

class rectangle :
    def __init__(self,larg,long):
        self.largeur=larg
        self.longueur=long

    def aire(self):
        return(self.largeur*self.longueur)

    def perimetre(self):
        return(2*(self.largeur+self.longueur))

    def augmenter(self,p):
        self.largeur=self.largeur*(1+p)
        self.longueur=self.longueur*(1+p)

Pour un nouvel objet rect1 de classe rectangle, son périmètre s’obtient par l’instruction rect1.perimetre() et son aire par rect1.aire(). Essayez le code ci-dessous :

rect1=rectangle(5,7)
print('Aire du rectangle :', rect1.aire())
print('Périmètre du rectangle :', rect1.perimetre())

Lorsque l’on modifie un des attributs de l’objet rect1, son périmètre et son aire sont recalculés lorsqu’on les appelle :

rect1.largeur=4
print('Aire du rectangle :', rect1.aire())
print('Périmètre du rectangle :', rect1.perimetre())

Pour augmenter les dimensions du rectangle A, on lui applique la méthode augmenter :

A=rectangle(4,6)
print(A.longueur,A.largeur)
A.augmenter(0.5)
print(A.longueur,A.largeur)
A.augmenter(-0.5)
print(A.longueur,A.largeur)

Exemples de programmes utilisant des classes