et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
class A (object):
pass
a1 = A()
a2 = A()
je veux pouvoir tester
a1 < a2
c'est forcement tout con mais j'ai du mal à le trouver dasn la doc...
et il vaut mieux redefinir
__cmp__( self, other)
ou alors le paquet ?
__lt__( self, other)
__le__( self, other)
__eq__( self, other)
__ne__( self, other)
__gt__( self, other)
__ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__
tous les autres operateurs pouvant etres deduits:
a > b si b < a
a != b si a < b et b < a
a <= b si not(b < a)
a >= b si not(a < b)
a == b si not (a != b)
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Maric Michaud
class A (object): pass
a1 = A() a2 = A()
je veux pouvoir tester a1 < a2
c'est forcement tout con mais j'ai du mal à le trouver dasn la doc...
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tu veux n'en redéfinir qu'un c'est __cmp__, sinon les autres ne valent que pour un seul opérateur.
La déduction n'est pas voulue, on peut imaginer des arithmétiques où ce serait faux, et certains utilisent ces opérateurs riches pour autre chose que de la comparaison (effet de bord, notation à la iostream en C++).
class A (object):
pass
a1 = A()
a2 = A()
je veux pouvoir tester
a1 < a2
c'est forcement tout con mais j'ai du mal à le trouver dasn la doc...
et il vaut mieux redefinir
__cmp__( self, other)
ou alors le paquet ?
__lt__( self, other)
__le__( self, other)
__eq__( self, other)
__ne__( self, other)
__gt__( self, other)
__ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui
ferait que l'on ai besoin que de redefinir __gt__
tous les autres operateurs pouvant etres deduits:
a > b si b < a
a != b si a < b et b < a
a <= b si not(b < a)
a >= b si not(a < b)
a == b si not (a != b)
Si tu veux n'en redéfinir qu'un c'est __cmp__, sinon les autres ne
valent que pour un seul opérateur.
La déduction n'est pas voulue, on peut imaginer des arithmétiques où ce
serait faux, et certains utilisent ces opérateurs riches pour autre
chose que de la comparaison (effet de bord, notation à la iostream en C++).
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tu veux n'en redéfinir qu'un c'est __cmp__, sinon les autres ne valent que pour un seul opérateur.
La déduction n'est pas voulue, on peut imaginer des arithmétiques où ce serait faux, et certains utilisent ces opérateurs riches pour autre chose que de la comparaison (effet de bord, notation à la iostream en C++).
Eric Brunel
On Tue, 29 May 2007 15:19:06 +0200, JBB wrote: [snip]
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
(Attention: maths devant!) __cmp_ ne permet de définir que des relations d'ordre total, c'est à dire que deux instances de ta classe doivent toujours être comparables. Les autres te permettent aussi de définir des relations d'ordre partiel, c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été introduites pour les ensembles, dans lesquelles la relation d'ordre "naturelle" est la relation d'inclusion, qui est une relation d'ordre partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne veut pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a (Heu..., a < b et b < a est normalement toujours faux; sinon, ta relation
d'ordre a un sacré coup dans l'aile...)
a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que ton ordre est total. Donc utilise __cmp__.
HTH -- python -c "print ''.join([chr(154 - ord(c)) for c in 'U(17zX(%,5.zmz5(17l8(%,5.Z*(93-965$l7+-'])"
On Tue, 29 May 2007 15:19:06 +0200, JBB <nospam@nospam.com> wrote:
[snip]
et il vaut mieux redefinir
__cmp__( self, other)
ou alors le paquet ?
__lt__( self, other)
__le__( self, other)
__eq__( self, other)
__ne__( self, other)
__gt__( self, other)
__ge__( self, other)
(Attention: maths devant!)
__cmp_ ne permet de définir que des relations d'ordre total, c'est à dire
que deux instances de ta classe doivent toujours être comparables.
Les autres te permettent aussi de définir des relations d'ordre partiel,
c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au
début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été
introduites pour les ensembles, dans lesquelles la relation d'ordre
"naturelle" est la relation d'inclusion, qui est une relation d'ordre
partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne veut
pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui
ferait que l'on ai besoin que de redefinir __gt__
tous les autres operateurs pouvant etres deduits:
a > b si b < a
a != b si a < b et b < a
(Heu..., a < b et b < a est normalement toujours faux; sinon, ta relation
d'ordre a un sacré coup dans l'aile...)
a <= b si not(b < a)
a >= b si not(a < b)
a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que
ton ordre est total. Donc utilise __cmp__.
HTH
--
python -c "print ''.join([chr(154 - ord(c)) for c in
'U(17zX(%,5.zmz5(17l8(%,5.Z*(93-965$l7+-'])"
On Tue, 29 May 2007 15:19:06 +0200, JBB wrote: [snip]
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
(Attention: maths devant!) __cmp_ ne permet de définir que des relations d'ordre total, c'est à dire que deux instances de ta classe doivent toujours être comparables. Les autres te permettent aussi de définir des relations d'ordre partiel, c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été introduites pour les ensembles, dans lesquelles la relation d'ordre "naturelle" est la relation d'inclusion, qui est une relation d'ordre partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne veut pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a (Heu..., a < b et b < a est normalement toujours faux; sinon, ta relation
d'ordre a un sacré coup dans l'aile...)
a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que ton ordre est total. Donc utilise __cmp__.
HTH -- python -c "print ''.join([chr(154 - ord(c)) for c in 'U(17zX(%,5.zmz5(17l8(%,5.Z*(93-965$l7+-'])"
JBB
On Tue, 29 May 2007 15:19:06 +0200, JBB wrote: [snip]
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
(Attention: maths devant!) __cmp_ ne permet de définir que des relations d'ordre total, c'est à dire que deux instances de ta classe doivent toujours être comparables. Les autres te permettent aussi de définir des relations d'ordre partiel, c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été introduites pour les ensembles, dans lesquelles la relation d'ordre "naturelle" est la relation d'inclusion, qui est une relation d'ordre partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne veut pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a (Heu..., a < b et b < a est normalement toujours faux; sinon, ta
relation d'ordre a un sacré coup dans l'aile...) a != b si a < b ou b < a
j'ai ecrit un peu vite
a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que ton ordre est total. Donc utilise __cmp__.
HTH
On Tue, 29 May 2007 15:19:06 +0200, JBB <nospam@nospam.com> wrote:
[snip]
et il vaut mieux redefinir
__cmp__( self, other)
ou alors le paquet ?
__lt__( self, other)
__le__( self, other)
__eq__( self, other)
__ne__( self, other)
__gt__( self, other)
__ge__( self, other)
(Attention: maths devant!)
__cmp_ ne permet de définir que des relations d'ordre total, c'est à
dire que deux instances de ta classe doivent toujours être comparables.
Les autres te permettent aussi de définir des relations d'ordre partiel,
c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au
début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été
introduites pour les ensembles, dans lesquelles la relation d'ordre
"naturelle" est la relation d'inclusion, qui est une relation d'ordre
partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne
veut pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose
qui ferait que l'on ai besoin que de redefinir __gt__
tous les autres operateurs pouvant etres deduits:
a > b si b < a
a != b si a < b et b < a
(Heu..., a < b et b < a est normalement toujours faux; sinon, ta
relation d'ordre a un sacré coup dans l'aile...)
a != b si a < b ou b < a
j'ai ecrit un peu vite
a <= b si not(b < a)
a >= b si not(a < b)
a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que
ton ordre est total. Donc utilise __cmp__.
On Tue, 29 May 2007 15:19:06 +0200, JBB wrote: [snip]
et il vaut mieux redefinir __cmp__( self, other) ou alors le paquet ? __lt__( self, other) __le__( self, other) __eq__( self, other) __ne__( self, other) __gt__( self, other) __ge__( self, other)
(Attention: maths devant!) __cmp_ ne permet de définir que des relations d'ordre total, c'est à dire que deux instances de ta classe doivent toujours être comparables. Les autres te permettent aussi de définir des relations d'ordre partiel, c'est à dire que not(a < b) n'implique pas a >= b. Ca a l'air bizarre au début, mais je subodore (je n'ai pas vérifié) que ces méthodes ont été introduites pour les ensembles, dans lesquelles la relation d'ordre "naturelle" est la relation d'inclusion, qui est une relation d'ordre partiel (si l'ensemble E1 n'est pas inclus dans l'ensemble E2, ça ne veut pas dire que E2 est inclus dans E1).
et n'y aurait il pas un moyen d'importer (ou deriver) quelque chose qui ferait que l'on ai besoin que de redefinir __gt__ tous les autres operateurs pouvant etres deduits: a > b si b < a a != b si a < b et b < a (Heu..., a < b et b < a est normalement toujours faux; sinon, ta
relation d'ordre a un sacré coup dans l'aile...) a != b si a < b ou b < a
j'ai ecrit un peu vite
a <= b si not(b < a) a >= b si not(a < b) a == b si not (a != b)
Si tous ça est forcément toujours vrai (à part le second...), c'est que ton ordre est total. Donc utilise __cmp__.
