relation d'ordre [__lt__] [__gt_

relation d'ordre [__lt__] [__gt__]

Bonjour, je code un environnement géométrique.
Pour cela j'implémente des objets point, droite, vecteur... J'ajoute à ces objets les lois oppératoires usuelles dont les relations d'ordres.
Seulement, je n'arrive pas a faire qu'une demi relation:calim2:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Point: def __gt__(self, objet): if type(objet) != Point: return NotImplemented else: ... class Vector: def __gt__(self, objet): if type(objet) != Vector: return NotImplemented else: ...
Or j'aimerai bien qu'une erreur soit retournee quand je fait 'point > vector', une erreur equivalente a celle que retourne python quand on fait:
Code:

1 2 3 None > [0] TypeError: unorderable types: NoneType() > list()
Seulement, pas moyen de faire apparaitre une exception, seul False est renvoyé.

Merci de me metre sur la bonne piste: je n'ai pas trouver ma reponse dans la documentation.

Si je prends ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class Point:
    def __gt__(self, objet):
        if type(objet) != Point:
            return NotImplemented
        else:
            print("ok point")
            return True
 
class Vector:
    def __gt__(self, objet):
        if type(objet) != Vector:
            return NotImplemented
        else:
 
            print("ok vector")
            return True
 
p = Point()
v = Vector()
 
print(p<v)
print(v<p)

Ca me génère 2 erreurs :

>>> 
Traceback (most recent call last):
  File "C:/Users/pgradot/Desktop/temp.py", line 22, in <module>
    print(p<v)
TypeError: '<' not supported between instances of 'Point' and 'Vector'
>>> 
Traceback (most recent call last):
  File "C:/Users/pgradot/Desktop/temp.py", line 23, in <module>
    print(v<p)
TypeError: '<' not supported between instances of 'Vector' and 'Point'
>>>

Idem avec >

He, je ne comprends pas! Quand je tape votre code, j'ai moi aussi cette erreur:

Code:

1
2
3
4
print(v<p)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: Vector() < Point()

mais par contre, avec les objets entièrement définis:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
class Vector:
	"""
        est un vecteur en n dimensions, vivant dans R**n uniquement
        un polinome ne fait pas l'affaire, bien qu'ils puissent constituer un espace vectoriel
        """
	def __init__(self, *coords):
		self.coords = coords
		self.__init__clean()	#fait des verifications
 
	def __init__clean(self):
		"""
                verifi que le point soit correct
                """
		if not len(self.coords):
			raise Exception("the vector must be define by some coordonates, no zero!")
		self.coords = tuple((sympy.sympify(c) for c in self.coords))
 
	def __abs__(self):
		"""
                retourne la norme de self. (appelle par 'abs(objet)')
                """
		return sympy.sqrt(self.module_square())
 
	def __add__(self, vector):
		"""
                retourne un vecteur somme des coordonnes des 2 vecteurs. (appelle par '+')
                """
		if type(vector) != Vector:
			return NotImplemented
		if vector.dim() != self.dim():
			raise Exception("The vectors must have the same dimension")
		return Vector(*(e1+e2 for e1,e2 in zip(self.coords, vector.coords)))
 
	def __bool__(self):
		"""
                retourne True si le vecteur est non nul. (appelle par 'if objet:')
                """
		for e in self.coords:
			if e:
				return True
		return False
 
	def __delitem__(self, index):
		"""
                supprimme la coordonne d'index 'index'. (appelle par 'del objet[index]')
                """
		coords = list(self.coords)
		del coords[index]
		self.coords = tuple(coords)
		self.__init__clean()
 
	def __eq__(self, vector):
		"""
                retourne True si self et 'vector' sont egaux. (appelle par '==')
                """
		if type(vector) != Vector:
			return NotImplemented
		if vector.dim() != self.dim():
			return False
		for e1, e2 in zip(self.coords, vector.coords):
			if e1 != e2:
				return False
		return True
 
	def __ge__(self, obj):
		"""
                retourne True si self superieur ou egal a l'objet. (appelle par '>=')
                """
		try:
			return not self.__lt__(obj)
		except:
			return NotImplemented
 
	def __getitem__(self, index):
		"""
                recupere et retourne la coordonnee de rang 'index'. (appelle par 'objet[index]')
                """
		return self.coords[index]
 
	def __gt__(self, obj):
		"""
                retourne True si self est strictement superieur a obj. (appelle par '>')
                """
		try:
			return abs(self) > abs(obj)
		except:
			return NotImplemented
 
	def __hash__(self):
		"""
                retourne le hash entier de cet objet
                afin qu'un point soit un hashable. (appelle par 'hash(objet)')
                """
		return hash(self.coords)
 
	def __le__(self, obj):
		"""
                retourne True si self inferieur ou egal a obj. (appelle par '<=')
                """
		try:
			return not self.__gt__(obj)
		except:
			return NotImplemented
 
	def __len__(self):
		"""
                renvoi la dimension du vecteur. (appelle par 'len(objet)')
                """
		return len(self.coords)
 
	def __lt__(self, obj):
		"""
                retourne True si self est strictement inferieur au vecteur. (appelle par '<')
                """
		print("je suis bien execute")
		return NotImplemented
		try:
			return abs(self) > abs(obj)
		except:
			return NotImplemented
 
	def __mul__(self, element):
		"""
                multipli le vecteur par un autre objet.
                si element est un autre vecteur, le produit est un produit scalaire. (appelle par 'objet*element')
                """
		if type(element) == Vector:
			if self.dim() == element.dim():
				somme = 0
				for e1, e2 in zip(self, element):
					somme += (e1*e2)
				return somme
			else:
				raise Exception("The vectors must have the same dimension")
		else:
			return self.__rmul__(element)
 
	def __neg__(self):
		"""
                renvoi l'oposse du vecteur. (appelle par '-objet')
                """
		return Vector(*(-e for e in self.coords))
 
	def __pos__(self):
		"""
                retourne la valeur positive de ce point (appelle par '+objet')
                """
		return self
 
	def __repr__(self):
		"""
                permet un affichage graphique un peu meilleur
                """
		if len(self.coords) == 0:
			return "vector nul"
		elif len(self.coords) == 1:
			return "vector "+str(self[0])
		elif len(self.coords) == 2:
			return "vector x:"+str(self[0])+" y:"+str(self[1])
		elif len(self.coords) == 3:
			return "vector x:"+str(self[0])+" y:"+str(self[1])+" z:"+str(self[2])
		return "vector "+",".join(map(str, self.coords))
 
	def __rmul__(self, element):
		"""
                multi le vecteur par un element d'un corp K. (appelle par 'k*objet')
                """
		try:
			return Vector(*(element*c for c in self.coords))
		except:
			return NotImplemented
 
	def __setitem__(self, index, coord):
		"""
                permet de remplacer la coordonnee de rang 'index' par la valeur 'coord'. (appelle par 'objet[index] = coord')
                """
		coords = list(self.coords)
		coords[index] = value
		self.coords = tuple(coords)
		self.__init__clean()
 
	def __sub__(self, vector):
		"""
                soustrait a ce vecteur, les coordonnes du vecteur (appelle par '-')
                """
		if type(vector) != Vector:
			raise TypeError("a Point object can not be sommed with a "+str(type(vector)))
		if vector.dim() != self.dim():
			raise Exception("The vectors must have the same dimension")
		return Point(*(e1-e2 for e1, e2 in zip(self.coords, vector.coords)))
 
	def dim(self):
		"""
                retourne la dimension du vecteur
                """
		return len(self.coords)
 
	def module_square(self):
		"""
                retourne la norme au carre
                """
		somme = 0
		for e in self.coords:
			somme += e**2
		return somme
 
class Point:
	"""
        represente un point dans R³
        """
	def __init__(self, *coords):
		self.coords = coords 	#tuple des coordonnes cartesienne
		self.__init__clean()	#fait des verifications
 
	def __init__clean(self):
		"""
                verifi que le point soit correct
                """
		if not len(self.coords):
			raise Exception("the point must be define by some coordonates, no zero!")
		self.coords = tuple((sympy.sympify(c) for c in self.coords))
 
	def __abs__(self):
		"""
                retourne le module de self. (appelle par 'abs(objet)')
                """
		return sympy.sqrt(self.module_square())
 
	def __add__(self, point):
		"""
                retourne une point somme des coordonnes des 2 points. (appelle par '+')
                """
		if type(point) != Point:
			raise TypeError("a Point object can not be sommed with a "+str(type(point)))
		if point.dim() != self.dim():
			raise Exception("The points must have the same dimension")
		return Point(*(e1+e2 for e1,e2 in zip(self.coords, point.coords)))
 
	def __bool__(self):
		"""
                retourne True si le point est non nul. (appelle par 'if objet:')
                """
		for e in self.coords:
			if e:
				return True
		return False
 
	def __delitem__(self, index):
		"""
                supprimme la coordonne d'index 'index'. (appelle par 'del objet[index]')
                """
		coords = list(self.coords)
		del coords[index]
		self.coords = tuple(coords)
		self.__init__clean()
 
	def __eq__(self, point):
		"""
                retourne True si self et le point sont egaux. (appelle par '==')
                """
		if type(point) != Point:
			return False
		if point.dim() != self.dim():
			return False
		for e1, e2 in zip(self.coords, point.coords):
			if e1 != e2:
				return False
		return True
 
	def __ge__(self, obj):
		"""
                retourne True si self superieur ou egal a l'objet. (appelle par '>=')
                """
		return not self.__lt__(obj)
 
	def __getitem__(self, index):
		"""
                recupere et retourne la coordonnee de rang 'index'. (appelle par 'objet[index]')
                """
		return self.coords[index]
 
	def __gt__(self, obj):
		"""
                retourne True si self est strictement superieur a obj. (appelle par '>')
                """
		return abs(self) > abs(obj)
 
	def __hash__(self):
		"""
                retourne le hash entier de cet objet
                afin qu'un point soit un hashable. (appelle par 'hash(objet)')
                """
		return hash(self.coords)
 
	def __le__(self, obj):
		"""
                retourne True si self inferieur ou egal a obj. (appelle par '<=')
                """
		return not self.__gt__(obj)
 
	def __len__(self):
		"""
                renvoi la dimension du point. (appelle par 'len(objet)')
                """
		return len(self.coords)
 
	def __lt__(self, obj):
		"""
                retourne True si self est strictement inferieur au point. (appelle par '<')
                """
		return abs(self) > abs(obj)
 
	def __neg__(self):
		"""
                renvoi l'oposse du point. (appelle par '-objet')
                """
		return Point(*(-e for e in self.coords))
 
	def __pos__(self):
		"""
                retourne la valeur positive de ce point (appelle par '+objet')
                """
		return self
 
	def __repr__(self):
		"""
                permet un affichage graphique un peu meilleur
                """
		if len(self.coords) == 0:
			return "point nul"
		elif len(self.coords) == 1:
			return "point "+str(self[0])
		elif len(self.coords) == 2:
			return "point x:"+str(self[0])+" y:"+str(self[1])
		elif len(self.coords) == 3:
			return "point x:"+str(self[0])+" y:"+str(self[1])+" z:"+str(self[2])
		return "point "+",".join(map(str, self.coords))
 
	def __setitem__(self, index, coord):
		"""
                permet de remplacer la coordonnee de rang 'index' par la valeur 'coord'. (appelle par 'objet[index] = coord')
                """
		coords = list(self.coords)
		coords[index] = value
		self.coords = tuple(coords)
		self.__init__clean()
 
	def __sub__(self, point):
		"""
                soustrait a ce point, les coordonnes du point (appelle par '-')
                """
		if type(point) != Point:
			raise TypeError("a Point object can not be sommed with a "+str(type(point)))
		if point.dim() != self.dim():
			raise Exception("The points must have the same dimension")
		return Point(*(e1-e2 for e1, e2 in zip(self.coords, point.coords)))
 
	def dim(self):
		"""
                retourne la dimension du point
                """
		return len(self.coords)
 
	def module_square(self):
		"""
                retourne le carre du module de ce nombre
                """
		somme = 0
		for e in self.coords:
			somme += e**2
		return somme
 
	def pprint(self):
		"""
                affiche joliment l'objet
                """
		if len(self.coords) == 0:
			print("point nul")
		elif len(self.coords) == 1:
			print("point ", end="")
			sympy.pprint(self[0])
		elif len(self.coords) == 2:
			print("point:")
			sympy.pprint(sympy.Eq(sympy.sympify("x"),self[0]))
			sympy.pprint(sympy.Eq(sympy.sympify("y"),self[1]))
		elif len(self.coords) == 3:
			print("point:")
			sympy.pprint(sympy.Eq(sympy.sympify("x"),self[0]))
			sympy.pprint(sympy.Eq(sympy.sympify("y"),self[1]))
			sympy.pprint(sympy.Eq(sympy.sympify("z"),self[2]))
		else:
			print("point:")
			for i, e in enumerate(self.coords):
				sympy.pprint(sympy.Eq(sympy.sympify("a"+str(i)), e))
 
	def plot(self, ax, label=None, color=None):
		"""
                prepare l'affichage en 3 d de ce point
                'color' est le code rgb de la fore '#ffee00'
                """
		if len(self.coords) == 1:
			Point(self[0], 0).plot(ax, label, color)
		elif len(self.coords) == 2:
			ax.scatter(float(self[0]), float(self[1]), label=label, color=color)
		elif len(self.coords) == 3:
			ax.scatter(float(self[0]), float(self[1]), float(self[2]), label=label, color=color)
		else:
			raise LookupError("plot only on dimenssion 1, 2 or 3, no "+str(len(self.coords)))
 
	def show(self, label="automatic", color=None):
		"""
                affiche le point dans un graphique en 3d
                """
		if label == "automatic":
			label = self.__repr__()
 
		if len(self.coords) == 1:
			Point(self[0], 0).show(label, color)
 
		elif len(self.coords) == 2:
			self.plot(plt, label, color)
			plt.legend()
			plt.xlabel("x")
			plt.ylabel("y")
			plt.show()
 
		elif len(self.coords) == 3:
			fig = plt.figure()
			ax = fig.gca(projection='3d')
			self.plot(ax, label, color)
			ax.legend()
			ax.set_xlabel("x")
			ax.set_ylabel("y")
			ax.set_zlabel("z")
			plt.show()
 
		else:
			raise LookupError("show only on dimenssion 1, 2 or 3, no "+str(len(self.coords)))

Je le mets en entier car je ne sais vraiment pas d'où peut venir cette non erreur.

Code:

1
2
3
4
5
>>>p1 = raisin.geometry.Point(0,0)
>>>v1 = raisin.geometry.Vector(1,2,3)
>>>print(v1 < p1)
je suis bien execute
False

Je suis sous python 3.5.2 sur linux mint. Je ne sais pas si c'est un facteur?

Citation:

Envoyé par robinechuca

Merci de me metre sur la bonne piste: je n'ai pas trouver ma reponse dans la documentation.

Tous les tutos qui parlent d'exceptions racontent qu'on lève une exception via "raise" (on ne la retourne pas via "return").

- W

Avec raise ou asert, j'arrive à lever une exception qui envoi un message bien determine. Ici, la documentation dit de ne pas lever une exception mais de metre return NotImplemented (enfin de ce que j'ai cru comprendre...). Le but, c'est que l'exception ne vienne pas directement de mon code. Cela fonctionne parfaitement dans l'exemple du haut, mais pas dans le code complet. Ou est la différence?

Citation:

Envoyé par robinechuca

Ou est la différence?

C'est import sympy qui fout la grouille.

- W

Heu... Merci pour la piste mais en l'enlevant ça ne change rien du tout. C'est quoi qui vous fait dire ça? Il y a surement un indice bon a prendre...

Citation:

Envoyé par robinechuca

Heu... Merci pour la piste mais en l'enlevant ça ne change rien du tout. C'est quoi qui vous fait dire ça? Il y a surement un indice bon a prendre...

Parce qu'il y a un bug report similaire.... et que le problème disparaît lorsqu'on met en commentaire de larges parties de votre code.
Ceci dit, je n'ai pas la patience de trouver le bout qui le fait réapparaître (et trouver une logique dans ce truc).

- W

Merci, je pense avoir trouvé le problème:
Je m'explique pour en faire part:

Code:

print(v1 < p1)

appel tout d'abord la methode chez v1. Si cette methode renvoi

Code:

NotImplemented

, python ne s'en contente pas. Au lieu de retourner un bouleen ou une erreur, il appelle la methode inverse (> au lieu de <) sur p1. C'est donc p1 qui a le dernier mot. C'est donc seulement dans le cas ou v1 ET p1 retournent

Code:

NotImplemented

que python renvoi une exception du type

Code:

TypeError: unorderable types: Vector() < Point()

.

Merci pour l'aide

Ah, oui... c'est expliqué en tout petit caractères dans la description de NotImplemented:

Citation:

When a binary (or in-place) method returns NotImplemented the interpreter will try the reflected operation on the other type (or some other fallback, depending on the operator). If all attempts return NotImplemented, the interpreter will raise an appropriate exception. Incorrectly returning NotImplemented will result in a misleading error message or the NotImplemented value being returned to Python code.

Et côté code, si on écrit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class A: def __lt__(self, obj): print ('A.__lt__') return NotImplemented class B: def __gt__(self, obj): print ('B.__gt__') return NotImplemented a = A() b = B() b > a
Code:

1 2 3 4 5 6 B.__gt__ # on passe par __gt__ A.__lt__ # puis par le "the reflected operation on the other type" Traceback (most recent call last): File "test.py", line 17, in <module> b > a TypeError: unorderable types: B() > A()
note: je comprends la mécanique mais je peine à en voir des cas d'utilisation intéressants... Pour comparer a et b, il va bien falloir se baser sur des propriétés communes et ce sera plus simple lorsque a et b dérivent d'une même classe (ou s/classe d'une même classe.
Là où j'en vois l'intérêt, c'est plutôt, par exemple, dans __mul__ qui permettra d’écrire 7 * 'a' ou 'a' * 7.

- W