Priorité des opérateurs surchargés dans un cas ambigu

Version imprimable

20/05/2014, 19h30
armapython

Priorité des opérateurs surchargés dans un cas ambigu

J'ai créé une classe Matrice et une classe Fraction qui gèrent chacune la surcharge des opérateurs qui leur sont compatibles.
L'opérateur * est surchargé pour la classe Matrice par les deux méthodes __mul__et __rmul__.
La première effectue le produit de deux matrices et lève une exception si le second argument n'est pas une matrice.
La seconde permet de multiplier la matrice par un scalaire de type int ou Fraction.
Seulement voilà si j'exécute : ma_fraction * ma_matrice ; ça déclenche Fraction.__mul__ et non Matrice.__rmul__ comme escompté. Evidemment Fraction.__mul__ n'est pas conçue pour recevoir une instance de Matrice donc plante.
(Je précise que si j'exécute: ma_matrice.__rmul__(ma_fraction) ça marche parfaitement, c'est donc bien un problème de priorité)
Comment faire pour établir une priorité entre les différentes surcharges de l'opérateur * dans ce cas ambigu? (il s'agit de deux classes qui ne sont pas liées par héritage)

Merci d'avance pour vos réponses! :D
20/05/2014, 19h44
Invité

Citation:

Envoyé par armapython

J'ai créé une classe Matrice et une classe Fraction qui gèrent chacune la surcharge des opérateurs qui leur sont compatibles.
L'opérateur * est surchargé pour la classe Matrice par les deux méthodes __mul__et __rmul__.
La première effectue le produit de deux matrices et lève une exception si le second argument n'est pas une matrice.
La seconde permet de multiplier la matrice par un scalaire de type int ou Fraction.
Seulement voilà si j'exécute : ma_fraction * ma_matrice ; ça déclenche Fraction.__mul__ et non Matrice.__rmul__ comme escompté. Evidemment Fraction.__mul__ n'est pas conçue pour recevoir une instance de Matrice donc plante.
(Je précise que si j'exécute: ma_matrice.__rmul__(ma_fraction) ça marche parfaitement, c'est donc bien un problème de priorité)
Comment faire pour établir une priorité entre les différentes surcharges de l'opérateur * dans ce cas ambigu? (il s'agit de deux classes qui ne sont pas liées par héritage)

Merci d'avance pour vos réponses! :D

Bonjour,

l'interpréteur Python évalue l'opérateur * de gauche à droite e.g. dans a * b, c'est d'abord a qui est évalué, puis *, puis b et l'interpréteur remplace cette expression par a.__mul__(b)

si l'opérateur * signifie multiplication pour les nombres et donc est commutatif pour les nombres, ce n'est pas le cas pour les objets.

ainsi, lorsque vous écrivez ma_fraction * ma_matrice, vous écrivez en réalité ma_fraction.__mul__(ma_matrice).

de même, lorsque vous écrivez ma_matrice * ma_fraction, vous écrivez en réalité ma_matrice.__mul__(ma_fraction).

dans le cas des objets, l'opérateur * n'est pas commutatif.

vous voyez comment tout cela fonctionne ?

@+.

Salut,

Il faut faire comme çà:

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
>>> class A:
...     def __mul__(self, other):
...         print ('A mul')
...     def __rmul__(self, other):
...         print ('A rmul')
...
>>> class B:
...     def __mul__(self, other):
...         if not isinstance(other, B):
...             print ('B mul route: ', end='')
...             return NotImplemented
...         print ('B mul')
...
>>> a, b = A(), B()
>>>
>>> a * b
A mul
>>> b * a
B mul route: A rmul
>>> b * b
B mul
>>> a * a
A mul
>>>

Dit autrement, b * a est d'abord évalué suivant b.__operator__(a).
Le "return NotImplemented" force le passage par le __rmul__

- W

20/05/2014, 20h25
Invité

Citation:

Envoyé par wiztricks

Salut,
Le "return NotImplemented" force le passage par le __rmul__

- W

je viens d'apprendre une chose intéressante, là. :merci:

@+.
20/05/2014, 22h42
Delbor

Alors là je comprend pas ce qu'il se passe...

Comment "return NotImplemented" 'force la passage par __rmul__', d'abord, et qu' est-ce qu'il se passe lors du print dans la méthode __mul__ de B (c'est quoi ce 'end' ?).
21/05/2014, 00h14
wiztricks

Citation:

Envoyé par Delbor

Alors là je comprend pas ce qu'il se passe...

Comment "return NotImplemented" 'force la passage par __rmul__', d'abord, et qu' est-ce qu'il se passe lors du print dans la méthode __mul__ de B (c'est quoi ce 'end' ?).

C'est ce que dit la documentation: emulating-numeric-types
Pour la commande print c'est ici.

- W
21/05/2014, 06h31
Invité

Citation:

Envoyé par wiztricks

C'est ce que dit la documentation: emulating-numeric-types
Pour la commande print c'est ici.

- W

Ah oui : __rmul__ --> reflected (swapped) operand multiplication !

Je ne comprenais pas d'où venait le "r" de __rmul__. :D

:merci:
21/05/2014, 10h06
Delbor

Ok. Je confondais "return NotImplemented" et "raise NotImplementedError".

Pour le print j'aurais pu chercher moi-même, mais il était un peu tard :oops:

Merci maestro!
21/05/2014, 12h22
armapython

à tarball:
j'ai bien compris que:

Citation:

l'interpréteur Python évalue l'opérateur * de gauche à droite e.g. dans a * b, c'est d'abord a qui est évalué, puis *, puis b et l'interpréteur remplace cette expression par a.__mul__(b)

C'est justement l'intérêt du préfixe r- (__rmul__ , __radd__,etc..) qui permet d'évaluer de droite à gauche quand ça ne marche pas de gauche à droite : dans mon exemple (qui ne marche pas pour l'instant avec les fractions mais marche avec les entiers) j'imagine que ça se passe comme ça:
Quand je rentre entier*matrice le programme appelle d'abord la méthode __mul__ de l'entier (entier.__mul__(matrice)) qui signale qu'elle ne sait pas quoi faire d'une instance de la classe Matrice, il appelle donc ensuite la méthode __rmul__ de la matrice (matrice.__rmul__(entier)) qui est implémentée pour multiplier un scalaire (entier ou fraction)avec une matrice.
21/05/2014, 12h30
armapython

à wiztricks:
Ca marche parfaitement, merci beaucoup!
:merci: