Python operator 模块，__ge__() 实例源码

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

def __ge__(self, rhs):
        return op_relational(self, rhs, operator.__ge__)

def __ge__(self, rhs):
        return op_relational(self, rhs, operator.__ge__)

def __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 __ge__(self, other):
        return self.x >= other

def __ge__(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 greaterThanOrEqual(typeA, typeB):
    if operator.__ge__(typeA.number.getNum(), typeB.number.getNum()):
        return True
    else:
        return False

def __ge__(self, other):
        return self.__comparator__(other, operator.__ge__)

def test_ge(self):
        self._test_incompatible_types_fail(operator.__ge__)

        self.assertTrue(no_flags >= no_flags)
        self.assertFalse(no_flags >= all_flags)
        self.assertFalse(no_flags >= f0)
        self.assertFalse(no_flags >= f1)
        self.assertFalse(no_flags >= f2)
        self.assertFalse(no_flags >= f01)
        self.assertFalse(no_flags >= f02)
        self.assertFalse(no_flags >= f12)

        self.assertTrue(f0 >= no_flags)
        self.assertFalse(f0 >= all_flags)
        self.assertTrue(f0 >= f0)
        self.assertFalse(f0 >= f1)
        self.assertFalse(f0 >= f2)
        self.assertFalse(f0 >= f01)
        self.assertFalse(f0 >= f02)
        self.assertFalse(f0 >= f12)

        self.assertTrue(f01 >= no_flags)
        self.assertFalse(f01 >= all_flags)
        self.assertTrue(f01 >= f0)
        self.assertTrue(f01 >= f1)
        self.assertFalse(f01 >= f2)
        self.assertTrue(f01 >= f01)
        self.assertFalse(f01 >= f02)
        self.assertFalse(f01 >= f12)

        self.assertFalse(no_flags >= all_flags)
        self.assertTrue(all_flags >= all_flags)
        self.assertFalse(f0 >= all_flags)
        self.assertFalse(f1 >= all_flags)
        self.assertFalse(f2 >= all_flags)
        self.assertFalse(f01 >= all_flags)
        self.assertFalse(f02 >= all_flags)
        self.assertFalse(f12 >= all_flags)