Bonjour à tous et à toutes,
 
j'ai besoin d'une classe dérivée de list qui puisse appeler une fonction d'alerte à chaque fois que l'objet est modifié; quelque chose comme :

 
J'ai donc écrit ceci : une classe dérivée de list qui redéfinit TOUTES les fonctions associées à l'objet list avec un appel à la fonction d'alerte à la fin du travail :

 
Le tout fonctionne bien mais m'oblige à redéfinir un grand nombre de fonctions (__add__, __iadd__, ..., insert, etc.). Je me demandais s'il existait un moyen plus rapide et plus élégant ?
 
Merci d'avance !

http://docs.python.org/reference/d [...] ttribute__

Mais ça fait pas la différence entre un append qui modifie ta liste et un __getitem__ qui ne la modifie pas, et ça va flinguer tes perfs.

Pourquoi tu veux faire ce truc?

Merci Masklinn pour ta réponse; je vais examiner ton lien pour en comprendre le contenu.
J'ai besoin d'une liste d'objets, liste qui doit être triée de manière complexe; pour éviter d'oublier de trier ma liste et d'utiliser une liste non triée, je voulais appeler ma fonction tri à chaque fois que je modifiais ma liste.

Mais j'ai l'impression de réinventer la roue et je trouve mon code crade...

Une meilleure idée ?

NB : au fait, je travaille avec Python 3.

En adoptant l'idée de Masklinn, voici le code que j'obtiens; pour le moment, l'objet ne "réagit" qu'aux appels à append et pop, mais c'est pour l'exemple :
 

 
Bon, c'est moche mais ça marche. Un souci : les fonctions spéciales comme __iadd__ ne semblent pas attrapées. C'est bien ce qui est dit dans la doc :

(http://docs.python.org/py3k/reference/datamodel.html)
 
Ce qui me surprend est que personne(?) n'a l'air d'avoir rencontré le même problème que moi. Est-ce que je fais fausse route ?

Un tri quand tu as besoin d'utiliser ta liste (d'autant plus si l'insertion est plus fréquente que la lecture), ou bien alors une liste naturellement triée (il n'y en à ma connaissance pas dans la stdlib), ou le discutablement nommé bisect qui permet d'insérer une nouvelle valeur à sa place (triée) dans la liste.
 
Regardes aussi du côté de heapq.

Un grand merci à Masklinn pour m'avoir fait découvrir bisect et heapq; pour le moment j'aimerais éviter de les utiliser (j'ai un problème pour personnaliser la comparaison entre mes objets).

Je crois que j'ai un début de solution à mon problème; c'est pas super propre mais je pense que c'est acceptable (Masklinn, ne t'énerve pas, question perf' ça doit en effet être affreux). En particulier j'attrape les appels aux fonctions spéciales (__add__, ...)

L'idée est de détecter la lecture ou l'écriture dans .data qui est hérité de UserList; bien sûr je détecte pêle-mêle des modifications et de simples lectures mais je suis ainsi sûr de ne pas rater une écriture dans mon objet.

Je suis toujours preneur d'idées meilleures. Merci de m'avoir lu !

Pourquoi?

import collections
 
class L(collections.UserList):
 
    def __init__(self,arg):
        collections.UserList.__init__(self,arg)
 
    def __getattribute__(self,arg):
        if arg=="data":
            self.fonction_d_alerte()
        return collections.UserList.__getattribute__(self,arg)
 
    def fonction_d_alerte(self):
        print("lecture ou écriture dans .data" )

   
 
1. Tu peux hériter de `list`, pas besoin d'hériter de `UserList`. D'ailleurs je sais même pas d'où tu l'as sorti, je l'ai plus dans Python 2.6
2. Le code n'a aucun rapport avec la description d'en dessous, c'est normal docteur?
3. Pourquoi ne pas juste décorer une instance de `list`, si tu veux vraiment pas utiliser une collection faite pour?

> Pour de mauvaises raisons : je n'arrive pour l'instant pas à les utiliser. Mais j'y viendrai, c'est juste une question de temps.
 

UserList est encore dans la doc' de Python3 (http://docs.python.org/py3k/librar [...] s.UserDict). Bon, ce n'est pas un argument en soi...
 

> désolé, j'ai moi-même du mal à comprendre ce que je code.
 

> si j'utilise juste une instance de list (appelons-la data), je perds la possibilité d'écrire : l.append(...) et je devrai écrire l.data.append(...)
> si je fais dériver ma classe L de list, j'ai mon L.__getattribute__ qui ne détecte plus la lecture/modification de l'objet via les fonctions spéciales (__add__, ...)
 
Désolé d'être aussi peu clair : merci pour ta patience.
Bon, je reprendrai cela un peu plus tard. Excusez-moi pour le bordel, mais j'ai une réunion.

Non, tu réimplémentes les accès que tu veux intercepter dans le décorateur et tu forward le reste à coup de __getattr__:

class LoggingList:
    def __init__(self, iterable=None):
        self.lst = list(iterable) if iterable else []
    def append(self, value):
        # zomg edition
        return self.lst.append(value)
    def extend(self, iterable):
        # zomg edition
        return self.lst.extend(iterable)
    def insert(self, index, value):
        # zomg edition
        return self.lst.insert(index, value)
    # idem pour pop, remove, reverse et sort, ainsi que __iadd__ je présume (et ptet __add__ et __radd__ mais bon...)
    def __getattr__(self, attr):
        return getattr(self.lst, attr)

et voilà, c'est plus long mais c'est clair et clean. Si besoin tu peux même te créer une fonction ou un descripteur qui va bien pour faire une partie du boulot pour quoi.

Merci Masklinn pour ta dernière réponse; il m'a fallu du temps pour la digérer.
 
Si je comprends bien, "ta" classe LoggingList oblige :
- à définir les fonctions qui modifient l'objet : append, extend...
- à définir les fonctions spéciales, qu'elles modifient ou non l'objet : __getitem__, __setitem__ (ces fonctions ne sont pas attrapées par __getattr__)
Par contre d'autres fonctions (comme count) ne sont pas à écrire; elles passent par __getattr__ qui les renvoient au type list.
 
Pour simplifier le code, pourquoi ne pas faire hériter LoggingList du type list ? Il faudrait alors :
- à définir les fonctions qui modifient l'objet : append, extend...
Par contre aucune autre fonctions n'est à réécrire; les autres fonctions (spéciales ou non) passent directement par le type list.
 
On pourrait avoir quelque chose comme :

class LoggingList(list):
    
    def __init__(self, iterable=None):
        list.__init__(self,iterable)
        
    def append(self, value):        
        fonction_d_alerte()  # <- appel à une fonction d'alerte quelconque
        return list.append(self,value)

 
Bon, je sais que je reviens à l'un de tes conseils de départ (avec la classe héritée de list); désolé d'avoir mis du temps à comprendre.