DESCRIPTION.

Convertie une méthode de classe en une méthode appelable.

SYNTAXE.

@classmethod 

def FNC_Methode ( self , ... ) : 

@classmethod ⇨ décoration de la méthode de classe [ OBLIGATOIRE ]

def FNC_Methode ( self , ... ) : ⇨ méthode de classe pouvant être convertie [ OBLIGATOIRE ]

CLS_Classe.alias = classmethod ( CLS_Classe.FNC_Methode )

CLS_Classe.alias = ⇨ alias pour la méthode de classe [ OBLIGATOIRE ]

classmethod ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

CLS_Classe.FNC_Methode ⇨ méthode de classe à exécuter [ OBLIGATOIRE ]

REMARQUES.

Avec Python 3, les méthodes classmethod ( ) et stacticmethod ( ) sont devenues non-Pythonesque, et sont remplacées par les décorateurs de méthode @classmethod  et  @stacticmethod.

Une méthode de classe est une méthode définie dans une classe. Elle sera donc présente dans, et pour, chacune des instances de la classe créées. Pour utiliser l'une de ces méthodes, il faut l'appelée depuis la classe, avec la forme classe.methode ( ), ou depuis l'instance avec la forme instance ( ).methode ( ). Si, lors de sa définition dans la classe, la méthode a été décorée par, précédée du décorateur, @classmethod, alors il sera possible de la convertir en un méthode depuis le script et de l'utiliser comme une méthode utilisateur. 

Une méthode recevant le décorateur @classmethod, doit recevoir, obligatoirement comme premier argument, la référence à la classe ou l'instance elle-même. Alors que si elle est introduite par le décorateur @stacticmethod, cette référence n'est pas requise.

Voir la documentation de Python pour plus d'informations sur les décorateurs des méthodes de classe, @classmethod et @stacticmethod.

EXEMPLES.

1. Ancienne procédure : avec la méthode classmethod ( ).

class CLS_Math ( ) :

def __init__ ( self , Q ) :

self.valeur = Q

def FNC_Exposant ( cls , Q = None ) :

kvaleur = Q if Q != None else self.valeur

return ( kvaleur ** 2 , kvaleur ** 3 )

Deux = CLS_Math ( 2 )

print ( Deux.valeur ) retourne 2 

print ( Deux.FNC_Exposant ( ) ) retourne (4, 8) 

L'objet Deux étant une instance la classe CLS_Math ( ), il peut utiliser librement sa méthode FNC_Exposant qui lui a été transmise à sa création.

CLS_Math.utiliser = classmethod ( CLS_Math.FNC_Exposant )

print ( CLS_Math.utiliser ( 2 ) ) retourne (4, 8) 

print ( CLS_Math.utiliser ( 7 ) ) retourne (49, 343) 

La référence CLS_Math.utiliser permet maintenant d'utiliser la méthode FNC_Exposant de la classe CLS_Math ( ), avec des objet qui ne sont pas des instance de la classe CLS_Math ( ). 

Dans les deux cas, la méthode FNC_Exposant attend deux arguments. Le premier est l'indication de la classe elle-même et est généré automatiquement (cls). Le deuxième est l'attribut qui sera utilisé pour le traitement des calculs, selon les cas il sera passé en unique argument, avec la forme CLS_Math.utiliser ( ) ou proviendra de l'attribut de l'objet, avec la forme CLS_Math ( ).FNC_Exposant ( ). La définition de la méthode doit donc prévoir ces différentes options.

2. Comparaison entre @classmethod et @staticmethod.

La classe CLS_Paves ( ) permet de créer des objets correspondants à des pavés.

Lors de sa création, un pavé doit donner 3 int ( ) en attributs. 

class CLS_Paves ( ) :

def __init__ ( self , Qlongueur , Qlargeur , Qhauteur ) :

self.longueur = Qlongueur

self.largeur = Qlargeur

self.hauteur = Qhauteur

def FNC_Volume ( self ) :

kvolume = self.longueur * self.largeur * self.hauteur

return kvolume

@classmethod

def FNC_Avec ( cls , Qlongueur , Qlargeur , Qhauteur ) :

kvolume = Qlongueur * Qlongueur * Qlongueur

return kvolume

@staticmethod

def FNC_Sans ( Qlongueur , Qlargeur , Qhauteur ) :

kvolume = Qlongueur * Qlongueur * Qlongueur

return kvolume

@classmethod

def FNC_Creation ( cls , Qlongueur , Qlargeur , Qhauteur ) :

kpave = CLS_Paves ( Qlongueur , Qlargeur , Qhauteur )

kvolume = kpave.FNC_Volume ( )

print ( f"Ce pave de { kpave.longueur } * { kpave.largeur } * { kpave.hauteur } a pour volume {  kvolume }" ) 

return kpave

Pour connaitre les valeurs des attributs d'une instance de CLS_Paves, après création, il suffit de les appeler. 

Caisse = CLS_Paves ( 87 , 9 , 3 )

print ( type ( Caisse ) ) retourne <class '__main__.CLS_Paves'>

print ( Caisse.longueur , Caisse.largeur , Caisse.hauteur ) retourne 87 9 3

La méthode FNC_Volume ( ), définie dans la classe CLS_Paves, permet de retourner le volume du pavé, objet de type CLS_Paves. Pour le calcul, elle utilise les attributs de l'objet appelant (.longueur ,.largeur ,.hauteur), qui donne son identité (Caisse) automatiquement, et qui est récupérée dans la variable self durant le traitement de la fonction. 

print ( Caisse.FNC_Volume ( ) ) retourne 2349

La méthode FNC_Avec ( ), définie, elle aussi, dans la classe CLS_Paves, permet de retourner le volume d'un objet appelant. Comme la création de cette méthode de classe est précédée de la décoration @classmethod, elle est disponible pour tout objet quelque soit son type. Dans la définition de FNC_Avec ( ), le premier paramètre (cls) désigne la classe où est définie la méthode décorée (CLS_Paves ( )). Cet attribut n'est pas à donner lors de l'appel, car il est identifié dans la première partie de l’invocation :

- soit en nommant cette classe elle-même, comme dans  CLS_Paves.FNC_Avec ( 87 , 9 , 3 ) ;

- soit en utilisant un enfant de cette classe, comme dans Caisse.FNC_Avec ( 87 , 9 , 3 ).

Contenaire = CLS_Paves.FNC_Avec ( 87 , 9 , 3 )

print ( Contenaire ) retourne 2349

print ( type ( Contenaire ) ) retourne <class 'int'>

Wagon = Caisse.FNC_Avec ( 87 , 9 , 3 )

print ( Wagon ) retourne 2349

print ( type ( Wagon ) ) retourne <class 'int'>

La méthode FNC_Sans ( ), définie, dans la classe CLS_Paves, permet de retourner le volume d'un objet appelant. Comme elle est précédée de la décoration @staticmethod, elle est disponible pour tout objet quelque soit son type. Mais dans la définition de  FNC_Sans ( ), la classe où est définie la méthode décorée (CLS_Paves ( )) n'est pas requise, contrairement à la méthode FNC_Avec ( ). 

Citerne = CLS_Paves.FNC_Sans ( 87 , 9 , 3 )

print ( Citerne ) retourne 2349

print ( type ( Citerne ) ) retourne <class 'int'>

Mais une méthode @classmethod pourra faire appel aux fonctions définies dans la classe elle-même, et aux attributs de l'objet appelants, si nécessaire. Alors qu'une méthode @staticmethod n'y aura pas accès, puisse qu'elle d'identifie aucune parenté avec l'objet l'appelant.

L'objet Soute, a été créé en appelant la @classmethod FNC_Création ( ) de la classe CLS_Paves ( ) alors que l'objet Piscine, a été créé en appelant la @classmethod FNC_Création ( ) de Caisse, une instance de la classe CLS_Paves ( ) . Dans les deux cas FNC_Création ( ) : 

- a créé un objet temporaire kpave de type CLS_Paves ( ), puis ;

- a appelée la méthode FNC_Volume ( ) de kpave, et enfin la méthode ; 

- a retourné kpave pour la création de Soute et de Piscine.

Soute = CLS_Paves.FNC_Creation ( 23 , 12 , 7 ) retourne Ce pave de 23 * 12 * 7 a pour volume 1932           

print ( Soute.longueur , Soute.largeur , Soute.hauteur ) retourne 23 12 7

print ( type ( Soute ) ) retourne <class '__main__.CLS_Paves'>

Piscine = Caisse.FNC_Creation ( 23 , 12 , 7 ) retourne Ce pave de 23 * 12 * 7 a pour volume 1932           

print ( Piscine.longueur , Piscine.largeur , Piscine.hauteur ) retourne 23 12 7

print ( Caisse.longueur , Caisse.largeur , Caisse.hauteur ) retourne 87 9 3