Ajout de méthodse à une classe sans dérivation

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

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:

---

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()

---

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

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:

---

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:

---

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:

---

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.

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:

---

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.

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

Code:

---

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... :mouarf:;)