Discussion :

[plxpy]

Bonjour

Est-il possible, en Python, d'ajouter des méthodes à une classe MAIS :
1 - sans modifier le source de la classe
2 - sans la dériver
(comme le permet Objective C par exemple avec ses "extensions" de classe)

Ces contraintes viennent du fait que :

- j'utilise un package que je ne maintiens pas moi-même et de nouvelles versions/révisions sont régulièrement disponibles : je ne souhaite pas modifier ce source (qui de plus fait essentiellement un interfaçage avec une bibliothèque C/C++ et dont le code est - disons - "velu")

- les objets de ces différentes classes "de base" se contiennent un peu les uns les autres, de nombreuses méthodes retournent des objets de ces classes, bref : une dérivation n'est pas satisfaisante

[DelphiManiac]

A priori oui, mais ça demande tout de même des tests plus évolués que les 20 lignes de codes que je viens de pondre !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
class Test():
    def test(self):
        self.mavar = 12
        print self
        print 'coucou'
 
def test1(self):
    print self
    print self.mavar
    print 'coucou1'
 
Test.__dict__['test1'] = test1
 
t = Test()
t.test()
t.test1()

[plxpy]

Merci pour la réponse : s'attaquer au __dict__ de la classe ne me serait pas venu à l'esprit.

Effectivement, il faut creuser un peu plus avec des classes un peu plus "péchues" (celles que j'utilise sont issues du package Shapely qu'on trouve dans les packages de www.python.org et qui manipulent des objets géométriques).

Je creuse un peu plus pour vérifier que ce n'est pas trop "effet de bord" et je rajouterai un message avec mes conclusions.

Encore merci

[plxpy]

Même avec des classes un peu plus fournies, ça marche.

J'ai trouvé un article qui approfondit le sujet en passant, entre autres, par des décorateurs. Je ne suis pas allé jusqu'à lire toutes les solutions proposées ni à les tester.

Je ne reprends pas l'ensemble des tests effectués avec les classes que j'utilise mais voici un squelette de trois modules (je n'attaque pas directement __dict__ mais utilise la fonction setattr):

Le module chargé d'ajouter les méthodes (extra.py):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
from module import MaClasse
 
def add_method(cls,**kw):
    for k,v in kw.iteritems():
        setattr(cls,k,v)
 
def coucou(comme_self,texte=""):
    print "AJOUTE",texte
 
add_method(MaClasse,methode_ajoutee=coucou)

Le module avec le code de la classe (module.py) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class MaClasse():
 
    def methode_de_base(self,texte=""):
        print "methode_de_base",texte

et enfin , l'application main.py

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
from module import MaClasse
import extra
 
class MaClasseDeriveeSimple(MaClasse):
    pass
 
class MaClasseDeriveeSurcharge(MaClasse):
    def methode_ajoutee(self,texte=""):
        print "SURCHARGE",texte
 
objetBasique = MaClasse()
objetBasique.methode_de_base("objet de la classe")
objetBasique.methode_ajoutee("objet de la classe")
 
objetDerive = MaClasseDeriveeSimple()
objetDerive.methode_de_base("objet de la classe derivee")
objetDerive.methode_ajoutee("objet de la classe derivee")
 
objetSurcharge = MaClasseDeriveeSurcharge()
objetSurcharge.methode_de_base("objet de la classe derivee avec surcharge")
objetSurcharge.methode_ajoutee("objet de la classe derivee avec surcharge")

On voit de plus que, si on dérive la classe, la méthode ajoutée est encore disponible. On peut même, dans une autre dérivation, la surcharger.

Reste à espérer que ce n'est pas un effet de bord/une faille qui pourrait disparaitre avec les nouvelles versions. Un cas analogue est relaté dans un mail de van Rossum (himself) et, j'ai testé, en 2.5, ça ne fonctionne plus. Mais là, il s'agissait d'ajouter une méthode à la classe prédéfinie str.

Dans mon cas, cette solution apporte suffisamment de souplesse, sans être trop "tordue", pour que je prenne le risque.

[DelphiManiac]

De mon coté, j'ai continué à jouer un peu avec les dict. On peut par ce biais remplacer une classe existante par la sienne sans pour autant en dériver.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/python
# -*- coding: utf-8 -*-

 
class ClasseOrigine:
    def __init__(self):
        print 'in init de ClasseOrigine'
        
    def test(self):
        self.mavar = 12
        print 'in test de ClasseOrigine'
 
def test1(self):
    print u'in test1 ajouté à Classe origine %s avec comme valeur de mavar :' % self.mavar

class NouvelleClasse(object):
    def __new__(cls):
        print 'in new de NouvelleClasse'
        return oldClasseOrigine()

ClasseOrigine.__dict__['test1'] = test1
globals()['oldClasseOrigine'] = globals()['ClasseOrigine']
globals()['ClasseOrigine'] = NouvelleClasse


t1 = ClasseOrigine() # on ne créer pas directement une instance de la classe
print t1
t1.test()
t1.test1()

Ici quand je fais t1 = ClasseOrigine(), je ne créer pas directement une instance de la classe, mais j'appelle indirectement le __new__ de NouvelleClasse(), ce qui me permets de changer tout ce que je veux avant l'instantation de la classe réelle.

Tout code existant précédemment, et dont on a pas la maitrise, passera automatiquement par notre NouvelleClasse sans qu'il le sache.

[N.tox]

Comme Delphimaniac viens de me poster un lien vers ce sujet qui traite ce que je recherchais, je poste une autre solution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
>>> class A(object): pass
>>> import re
>>> def meth(className,functionCode):
    comp=re.compile('def (.*?)\(')
    methodName=comp.findall(functionCode)[0]
    exec(functionCode)
    exec("setattr({0},'{1}',classmethod({1}))".format(className,methodName))
>>> meth('A','def foo(cls): print "foo"')
>>> A.foo()
foo

Bon, on peut raccourcir évidement la fonction en virant comp, methodName et en ne faisant qu'un seul exec, mais j'avais la flemme...