def get_operator(op):
if not op: return None
if "ge" in op or ">=" in op:
opr = operator.__ge__
elif "gt" in op or ">" in op:
opr = operator.__gt__
elif "le" in op or "<=" in op:
opr = operator.__le__
elif "lt" in op or "<" in op:
opr = operator.__lt__
elif "eq" in op or "=" in op or "==" in op:
opr = operator.eq
elif "ne" in op or "!=" in op or "<>" in op:
opr = operator.ne
return opr
python类__le__()的实例源码
def __le__(self, rhs):
return op_relational(self, rhs, operator.__le__)
def __le__(self, rhs):
return op_relational(self, rhs, operator.__le__)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
def __cmp__(self_, other): raise RuntimeError, "expected"
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
self.assertRaises(RuntimeError, cmp, a, b)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
def __cmp__(self_, other): raise RuntimeError, "expected"
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
self.assertRaises(RuntimeError, cmp, a, b)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
def __cmp__(self_, other): raise RuntimeError, "expected"
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
self.assertRaises(RuntimeError, cmp, a, b)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
def __cmp__(self_, other): raise RuntimeError, "expected"
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
self.assertRaises(RuntimeError, cmp, a, b)
def __le__(self, other):
return self.x <= other
def __le__(self, other):
return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
def lessThanOrEqual(typeA, typeB):
if operator.__le__(typeA.number.getNum(), typeB.number.getNum()):
return True
else:
return False
def __le__(self, other):
return self.__comparator__(other, operator.__le__)
def test_le(self):
self._test_incompatible_types_fail(operator.__le__)
self.assertTrue(no_flags <= no_flags)
self.assertTrue(no_flags <= all_flags)
self.assertTrue(no_flags <= f0)
self.assertTrue(no_flags <= f1)
self.assertTrue(no_flags <= f2)
self.assertTrue(no_flags <= f01)
self.assertTrue(no_flags <= f02)
self.assertTrue(no_flags <= f12)
self.assertFalse(f0 <= no_flags)
self.assertTrue(f0 <= all_flags)
self.assertTrue(f0 <= f0)
self.assertFalse(f0 <= f1)
self.assertFalse(f0 <= f2)
self.assertTrue(f0 <= f01)
self.assertTrue(f0 <= f02)
self.assertFalse(f0 <= f12)
self.assertFalse(f01 <= no_flags)
self.assertTrue(f01 <= all_flags)
self.assertFalse(f01 <= f0)
self.assertFalse(f01 <= f1)
self.assertFalse(f01 <= f2)
self.assertTrue(f01 <= f01)
self.assertFalse(f01 <= f02)
self.assertFalse(f01 <= f12)
self.assertTrue(no_flags <= all_flags)
self.assertTrue(all_flags <= all_flags)
self.assertTrue(f0 <= all_flags)
self.assertTrue(f1 <= all_flags)
self.assertTrue(f2 <= all_flags)
self.assertTrue(f01 <= all_flags)
self.assertTrue(f02 <= all_flags)
self.assertTrue(f12 <= all_flags)
