Mise à jour automatique de variables d’instances ?

Version imprimable

Bonsoir,

Comment faire pour que la valeur d’une variable d’instance V2 qui dépend d’une autre variable V1 de la même instance change de valeur automatiquement quand la valeur de V1 change ?

Par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class A: def __init__(self,texte,numero): self.bla = texte self.long = len(texte) a = A('aramis le mousquetaire',2) print a.bla print a.long print a.bla = 'tintin' print a.bla print a.long
Citation:

aramis le mousquetaire
22

tintin
22

Je voudrais que ça affiche

Citation:

tintin
6

grâce à des properties :), voici un exemple de la façon "traditionnelle" de proceder:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> class Foo(object):
	def _get(s):
		return len(s.foo)
	#on pourrait definier une méthode set egalement, et même une del
	len = property(_get)
	def __init__(s,name):
		s.foo=name
 
 
>>> a=Foo('123456789')
>>> a.len
9
>>> a.foo='12'
>>> a.len
2

Mais perso, je trouve vraiment très moche et pas très lisible... Je préfère passer par une metaclass que j'ai enregistrer comme module, que voici:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MetaProperty(type):
    '''Classes which have this class as metaclass
    will must have a get and a set method, they will 
    become properties, not classes.
    The goal of this metaclass is purely esthetic'''
    def __new__(cls,nm,bs,at):
        if nm=='Prop':
            return type.__new__(cls,nm,bs,at)
        else:
            return property(fget=(at['get'] if 'get' in at else None),
                            fset=(at['set'] if 'set' in at else None))
 
class Prop(object):
    '''to be quicker, the properties created via
    metaclass MetaProperty, can inherit from this
    class instead of defining the __metaclass__
    attribute'''
    __metaclass__=MetaProperty

Ainsi, une fois importé, il suffit de faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> class Foo(object):
	class len(Prop):
		def get(s): return len(s.foo)
	def __init__(s,name):
		s.foo=name
 
 
>>> a=Foo('12345')
>>> a.len
5
>>> a.foo='123'
>>> a.len
3

Bonjour,

personnellement, je trouve ça très propre avec une property:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class A(object):
    def __init__(self,texte):
        self.long = 0
        self.bla = texte
    def _set_bla(self,value):
        self._bla = value
        self.long = len(value)
    def _get_bla(self):
        return self._bla
    bla = property(fset=_set_bla,fget=_get_bla)
 
a = A('aramis le mousquetaire')
 
print a.bla
print a.long
 
a.bla = 'tintin'
print a.bla
print a.long

on peut bien entendu utiliser des métaclasses en plus mais le mécanisme des property peut suffire.

Bonjour,

Je propose aussi une property, mais avec des décorateurs :
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 30 31 32 33 34 35 36 37 38 39 # Equivalent au 1° code de N.tox class Spam(object): def __init__(self, name): self.name = name @property def len(self): return len(self.name) # Equivalent au code de kango class Eggs(object): def __init__(self, name): self.name = name @property def name(self): return self._name @name.setter def name(self, value): self._name = value self.len = len(value) if __name__ == '__main__': for klass in (Spam, Eggs): print '=' * 30 print 'Essais avec la classe', klass.__name__ s = klass('Corto Maltese') print s.name, s.len s.name = 'Tintin' print s.name, s.len
Ca correspond exactement aux codes proposés, mais c'est présenté d'une façon que je trouve beaucoup + compréhensible, grâce aux décorateurs.

Citation:

Envoyé par eyquem

Comment faire pour que la valeur d’une variable d’instance V2 qui dépend d’une autre variable V1 de la même instance change de valeur automatiquement quand la valeur de V1 change ?

Hé bien, si on veut répondre exactement à ta question, il faut choisir la deuxième version (classe Eggs, code de kango).
Cela dit, je trouve la première version (classe Spam, code de N.tox) beaucoup + simple et moins prise de tête à comprendre. De plus, j'estime qu'on n'a pas besoin de recalculer quelque chose tant qu'on ne veut pas savoir sa valeur. Oserais-je sortir le terme de "lazy evaluation" ?

Cela dit, je vais jeter un coup d'oeil à la métaclasse proposée, ça m'intrigue, et ça me permettra d'enfin me lancer dans les métaclasses.