Classe dérivée de 'list' avec un membre en plus.

Bonjour,

je souhaite créer un classe qui hérite de la classe "list" mais qui en plus soit capable de me donner le nombre max d'éléments qu'elle a contenu.

Si j'écris

Code:

---

1 2 3

class my_list ( list ): def __init__ (self): self.max_len = 0

---

Il me dit (avec raison) que 'list' n'a pas d'attribut 'max_len'.

max_len doit bien sûr contenir le nb max d'éléments (i.e. à chaque accroissement de la liste,
il faut le mettre à jour avec un truc du genre max_len = max( max_len,len( self ))

Si j'agrège (au lieu de dériver)

Code:

---

1 2 3 4

class my_list : def __init__ (self): self.the_list = [] self.max_len = 0

---

Il me faudra réécrire toutes les méthodes de 'list' !

Y a-t-il un moyen de faire ce que je veux ?

Merci d'avance !

Salut

Toujours appeler le constructeur de la classe parent ;)

Code:

---

1 2 3 4 5 6

>>> class MyList(list): ... def __init__(self): ... list.__init__(self) ... self.maxLen = 0 ... >>> l = MyList()

---

Edit: Si tu travailles avec Python 2.2 ou inférieur, http://docs.python.org/release/2.5.2...-UserList.html

Je peux te donner un exemple simple

Code:

---

1 2 3 4 5 6 7 8 9

class Rectangle(object): def __init__(self, longueur, largeur): self.longueur=longueur self.largeur=largeur def aire(self): print self.longueur*self.largeur class Carre(Rectangle): def __init__(self, cote): Rectangle.__init__(self, cote, cote)

---

Résultat :

Citation:

---

>>> r=Rectangle(12, 5)
>>> r.aire()
60
>>> c=Carre(4)
>>> c.aire()
16

---

OK ! ça marche !
merci

Salut,

En sous-classant "list", il va être difficile de ne pas ré-écrire les méthodes pour réactualiser la longueur max.
Le proxy est une bonne idée, mais je ne vois pas comment faire sans la petite indirection ci dessous.
- W
PS: Il y aura certainement des "bordures" à refaire suivant ce qu'on veut faire, mais l'idée est là

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class B(object): def __init__(self, v=None): self._list = list(v) self._max_count = len(self._list)   def __getattr__(self, key): def proxy(*args, **kwds): getattr(self._list, key)(*args, **kwds) self._max_count = max(self._max_count, len(self._list)) return self return proxy   def __str__(self): return 'max: %d, contents: %r' % (self._max_count, self._list)   a = B([1, 2, 3]) print a a.append([6]) print a

---

Si si ! c'est possible !
Il suffit d'écrire les méthodes qui peuvent allonger la liste (dont le constructeur). Ici, je n'ai écrit que insert.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class my_list ( list ):   def __init__(self,*arg): list.__init__(self,*arg) self.max_len = len( self )   def insert (self,*args ): res = list.insert( self,*args ) self.max_len = max( self.max_len,len( self )) return res   def max (self): return self.max_len   l = my_list( [1,2,3] ) print l,len( l ),l.max() l.insert( 1,8 ) print l,len( l ),l.max() del l[1:3] print l,len( l ),l.max()

---

donne bien

Code:

---

1 2 3

[1, 2, 3] 3 3 [1, 8, 2, 3] 4 4 [1, 3] 2 4

---

A noter, la syntaxe d'appel du insert pour lever l'ambiguïté et éviter la récursion infinie.
Mais ce qui me chiffonne, c'est comment différencier le self qui n'est qu'une liste (sur lequel on peut faire un len) et le self qui est mon instance de my_list avec le membre max_len en plus ?

Et tu peux même surcharger les opérateurs:

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

class my_list ( list ):   def __init__(self,*arg): list.__init__(self,*arg) self.max_len = len( self )   def insert (self,*args ): res = list.insert( self,*args ) self.max_len = max( self.max_len,len( self )) return res def __add__(self,other): self+=other self.max_len+=len(other) return self   def max (self): return self.max_len   l = my_list( [1,2,3] ) print l,len( l ),l.max() l=l+[4,5] print l,len( l ),l.max() l.pop(0) print l,len( l ),l.max() l=l+l print l,len( l ),l.max()

---

Le second argument de l'opérateur peut être soit une 'list' soit une 'mylist'

Citation:

---

Si si ! c'est possible !
Il suffit d'écrire les méthodes qui peuvent allonger la liste (dont le constructeur). Ici, je n'ai écrit que insert.

---

Qui a dit le contraire? Juste que c'est ch... de trouver tous ces méthodes pour encapsuler l'appel au père permettant de recalculer la longueur...
Non seulement, il n'est jamais certain de les avoir toutes re-écrites mais ce n'est pas utile.

Citation:

---

Mais ce qui me chiffonne, c'est comment différencier le self qui n'est qu'une liste (sur lequel on peut faire un len) et le self qui est mon instance de my_list avec le membre max_len en plus ?

---

Les self sont identiques. Ce que vous essayez de différencier, ce sont les méthodes appliquées dessus: votre insert ou l'insert 'parent'?

Dans le cas de "len", pas d'ambiguité tant que vous ne redéfinirez pas __len__ dans my_list.

Citation:

---

A noter, la syntaxe d'appel du insert pour lever l'ambiguïté et éviter la récursion infinie.

---

Préférez super(my_list, self).insert(*args) à list.insert(self, *args)
- W