我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用operator.lt()。
def get_op(cls, op): ops = { symbol.test: cls.test, symbol.and_test: cls.and_test, symbol.atom: cls.atom, symbol.comparison: cls.comparison, 'not in': lambda x, y: x not in y, 'in': lambda x, y: x in y, '==': operator.eq, '!=': operator.ne, '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, } if hasattr(symbol, 'or_test'): ops[symbol.or_test] = cls.test return ops[op]
def test_richcompare_crash(self): # gh-4613 import operator as op # dummy class where __array__ throws exception class Foo(object): __array_priority__ = 1002 def __array__(self,*args,**kwargs): raise Exception() rhs = Foo() lhs = np.array(1) for f in [op.lt, op.le, op.gt, op.ge]: if sys.version_info[0] >= 3: assert_raises(TypeError, f, lhs, rhs) else: f(lhs, rhs) assert_(not op.eq(lhs, rhs)) assert_(op.ne(lhs, rhs))
def test_negationnormalform(self): self.assertEqual(NOT(AP("a")).negationnormalform(), NOT(AP("a"))) self.assertEqual(NOT(NOT(AP("a"))).negationnormalform(), AP("a")) self.assertEqual(NOT(NEXT(AP("a"))).negationnormalform(), NEXT(NOT(AP("a")))) self.assertEqual(NOT(AP(None, None, operator.ge, 42, 'x')).negationnormalform(), AP(None, None, operator.lt, 42, 'x')) self.assertEqual(NOT(AP(None, None, operator.le, 42, 'x')).negationnormalform(), AP(None, None, operator.gt, 42, 'x')) self.assertEqual(NOT(AP(None, None, operator.gt, 42, 'x')).negationnormalform(), AP(None, None, operator.le, 42, 'x')) self.assertEqual(NOT(AP(None, None, operator.lt, 42, 'x')).negationnormalform(), AP(None, None, operator.ge, 42, 'x')) self.assertEqual(NOT(AP(None, None, operator.eq, 42, 'x')).negationnormalform(), AP(None, None, operator.ne, 42, 'x')) self.assertEqual(NOT(AP(None, None, operator.ne, 42, 'x')).negationnormalform(), AP(None, None, operator.eq, 42, 'x')) self.assertEqual(NOT(AND(AP("a"), AP("b"))).negationnormalform(), OR(NOT(AP("a")), NOT(AP("b")))) self.assertEqual(NOT(OR(AP("a"), AP("b"))).negationnormalform(), AND(NOT(AP("a")), NOT(AP("b")))) self.assertEqual(NOT(IMPLIES(AP("a"), AP("b"))).negationnormalform(), AND(AP("a"), NOT(AP("b"))))
def test_direct_parse(self): self.assertEqual(parse('(1,2,3)^T (x, y, z) <= 42'), AP(None, (1, 2, 3), operator.le, 42., ('x', 'y', 'z'))) self.assertEqual(parse('(1,2,3)^T (x, y, z) >= 42'), AP(None, (1, 2, 3), operator.ge, 42., ('x', 'y', 'z'))) self.assertEqual(parse('(1,2,3)^T (x, y, z) < 42'), AP(None, (1, 2, 3), operator.lt, 42., ('x', 'y', 'z'))) self.assertEqual(parse('G a'), GLOBALLY(AP("a"))) self.assertEqual(parse('F a'), FINALLY(AP("a"))) self.assertEqual(parse('N a'), NEXT(AP("a"))) self.assertEqual(parse('G (a)'), GLOBALLY(AP("a"))) self.assertEqual(parse('a&b'), AND(AP("a"), AP("b"))) self.assertEqual(parse('(a) & (b)'), AND(AP("a"), AP("b"))) self.assertEqual(parse('a | b'), OR(AP("a"), AP("b"))) self.assertEqual(parse('(a) | (b)'), OR(AP("a"), AP("b"))) self.assertEqual(parse('a->b'), IMPLIES(AP("a"), AP("b"))) self.assertEqual(parse('(a) -> (b)'), IMPLIES(AP("a"), AP("b"))) self.assertEqual(parse('a U b'), UNTIL(AP("a"), AP("b"))) self.assertEqual(parse('(a)U(b)'), UNTIL(AP("a"), AP("b"))) self.assertEqual(parse('a R b'), RELEASE(AP("a"), AP("b"))) self.assertEqual(parse('(a) R (b)'), RELEASE(AP("a"), AP("b")))
def __iter__(self): """ Examples -------- >>> list(range(1)) [0] >>> list(range(5)) [0, 1, 2, 3, 4] >>> list(range(1, 5)) [1, 2, 3, 4] >>> list(range(0, 5, 2)) [0, 2, 4] >>> list(range(5, 0, -1)) [5, 4, 3, 2, 1] >>> list(range(5, 0, 1)) [] """ n = self.start stop = self.stop step = self.step cmp_ = op.lt if step > 0 else op.gt while cmp_(n, stop): yield n n += step
def operator(self): """Supported Filter Operators + EQ - Equal To + NE - Not Equal To + GT - Greater Than + GE - Greater Than or Equal To + LT - Less Than + LE - Less Than or Equal To + SW - Starts With + IN - In String or Array + NI - Not in String or Array """ return { 'EQ': operator.eq, 'NE': operator.ne, 'GT': operator.gt, 'GE': operator.ge, 'LT': operator.lt, 'LE': operator.le, 'SW': self._starts_with, 'IN': self._in, 'NI': self._ni # not in }
def test_complex(self): # comparisons with complex are special: equality and inequality # comparisons should always succeed, but order comparisons should # raise TypeError. z = 1.0 + 0j w = -3.14 + 2.7j for v in 1, 1.0, F(1), D(1), complex(1): self.assertEqual(z, v) self.assertEqual(v, z) for v in 2, 2.0, F(2), D(2), complex(2): self.assertNotEqual(z, v) self.assertNotEqual(v, z) self.assertNotEqual(w, v) self.assertNotEqual(v, w) for v in (1, 1.0, F(1), D(1), complex(1), 2, 2.0, F(2), D(2), complex(2), w): for op in operator.le, operator.lt, operator.ge, operator.gt: self.assertRaises(TypeError, op, z, v) self.assertRaises(TypeError, op, v, z)
def testBigComplexComparisons(self): self.assertFalse(F(10**23) == complex(10**23)) self.assertRaises(TypeError, operator.gt, F(10**23), complex(10**23)) self.assertRaises(TypeError, operator.le, F(10**23), complex(10**23)) x = F(3, 8) z = complex(0.375, 0.0) w = complex(0.375, 0.2) self.assertTrue(x == z) self.assertFalse(x != z) self.assertFalse(x == w) self.assertTrue(x != w) for op in operator.lt, operator.le, operator.gt, operator.ge: self.assertRaises(TypeError, op, x, z) self.assertRaises(TypeError, op, z, x) self.assertRaises(TypeError, op, x, w) self.assertRaises(TypeError, op, w, x)
def test_values(self): # check all operators and all comparison results self.checkvalue("lt", 0, 0, False) self.checkvalue("le", 0, 0, True ) self.checkvalue("eq", 0, 0, True ) self.checkvalue("ne", 0, 0, False) self.checkvalue("gt", 0, 0, False) self.checkvalue("ge", 0, 0, True ) self.checkvalue("lt", 0, 1, True ) self.checkvalue("le", 0, 1, True ) self.checkvalue("eq", 0, 1, False) self.checkvalue("ne", 0, 1, True ) self.checkvalue("gt", 0, 1, False) self.checkvalue("ge", 0, 1, False) self.checkvalue("lt", 1, 0, False) self.checkvalue("le", 1, 0, False) self.checkvalue("eq", 1, 0, False) self.checkvalue("ne", 1, 0, True ) self.checkvalue("gt", 1, 0, True ) self.checkvalue("ge", 1, 0, True )
def test_dicts(self): # Verify that __eq__ and __ne__ work for dicts even if the keys and # values don't support anything other than __eq__ and __ne__ (and # __hash__). Complex numbers are a fine example of that. import random imag1a = {} for i in range(50): imag1a[random.randrange(100)*1j] = random.randrange(100)*1j items = list(imag1a.items()) random.shuffle(items) imag1b = {} for k, v in items: imag1b[k] = v imag2 = imag1b.copy() imag2[k] = v + 1.0 self.assertEqual(imag1a, imag1a) self.assertEqual(imag1a, imag1b) self.assertEqual(imag2, imag2) self.assertTrue(imag1a != imag2) for opname in ("lt", "le", "gt", "ge"): for op in opmap[opname]: self.assertRaises(TypeError, op, imag1a, imag2)
def test_richcompare(self): self.assertIs(complex.__eq__(1+1j, 1<<10000), False) self.assertIs(complex.__lt__(1+1j, None), NotImplemented) self.assertIs(complex.__eq__(1+1j, 1+1j), True) self.assertIs(complex.__eq__(1+1j, 2+2j), False) self.assertIs(complex.__ne__(1+1j, 1+1j), False) self.assertIs(complex.__ne__(1+1j, 2+2j), True) for i in range(1, 100): f = i / 100.0 self.assertIs(complex.__eq__(f+0j, f), True) self.assertIs(complex.__ne__(f+0j, f), False) self.assertIs(complex.__eq__(complex(f, f), f), False) self.assertIs(complex.__ne__(complex(f, f), f), True) self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented) self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented) self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented) self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented) self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j) self.assertRaises(TypeError, operator.le, 1+1j, 2+2j) self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j) self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j) self.assertIs(operator.eq(1+1j, 1+1j), True) self.assertIs(operator.eq(1+1j, 2+2j), False) self.assertIs(operator.ne(1+1j, 1+1j), False) self.assertIs(operator.ne(1+1j, 2+2j), True)
def test_dicts(self): # Verify that __eq__ and __ne__ work for dicts even if the keys and # values don't support anything other than __eq__ and __ne__ (and # __hash__). Complex numbers are a fine example of that. import random imag1a = {} for i in range(50): imag1a[random.randrange(100)*1j] = random.randrange(100)*1j items = imag1a.items() random.shuffle(items) imag1b = {} for k, v in items: imag1b[k] = v imag2 = imag1b.copy() imag2[k] = v + 1.0 self.assertTrue(imag1a == imag1a) self.assertTrue(imag1a == imag1b) self.assertTrue(imag2 == imag2) self.assertTrue(imag1a != imag2) for opname in ("lt", "le", "gt", "ge"): for op in opmap[opname]: self.assertRaises(TypeError, op, imag1a, imag2)
def test_operator(self): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) with test_support.check_py3k_warnings(): self.assertIs(operator.isCallable(0), False) self.assertIs(operator.isCallable(len), True) self.assertIs(operator.isNumberType(None), False) self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) self.assertIs(operator.isSequenceType(0), False) self.assertIs(operator.isSequenceType([]), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) self.assertIs(operator.isMappingType(1), False) self.assertIs(operator.isMappingType({}), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) self.assertIs(operator.is_(True, False), False) self.assertIs(operator.is_not(True, True), False) self.assertIs(operator.is_not(True, False), True)
def number_of_args(fn): """Return the number of positional arguments for a function, or None if the number is variable. Looks inside any decorated functions.""" try: if hasattr(fn, '__wrapped__'): return number_of_args(fn.__wrapped__) if any(p.kind == p.VAR_POSITIONAL for p in signature(fn).parameters.values()): return None else: return sum(p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) for p in signature(fn).parameters.values()) except ValueError: # signatures don't work for built-in operators, so check for a few explicitly UNARY_OPS = [len, op.not_, op.truth, op.abs, op.index, op.inv, op.invert, op.neg, op.pos] BINARY_OPS = [op.lt, op.le, op.gt, op.ge, op.eq, op.ne, op.is_, op.is_not, op.add, op.and_, op.floordiv, op.lshift, op.mod, op.mul, op.or_, op.pow, op.rshift, op.sub, op.truediv, op.xor, op.concat, op.contains, op.countOf, op.delitem, op.getitem, op.indexOf] TERNARY_OPS = [op.setitem] if fn in UNARY_OPS: return 1 elif fn in BINARY_OPS: return 2 elif fn in TERNARY_OPS: return 3 else: raise NotImplementedError("Bult-in operator {} not supported".format(fn))
def op(operation, column): if operation == 'in': def comparator(column, v): return column.in_(v) elif operation == 'like': def comparator(column, v): return column.like(v + '%') elif operation == 'eq': comparator = _operator.eq elif operation == 'ne': comparator = _operator.ne elif operation == 'le': comparator = _operator.le elif operation == 'lt': comparator = _operator.lt elif operation == 'ge': comparator = _operator.ge elif operation == 'gt': comparator = _operator.gt else: raise ValueError('Operation {} not supported'.format(operation)) return comparator # TODO: fix comparators, keys should be something better
def sink(xs, ys, i, n, reverse=False): cmp = operator.gt if reverse else operator.lt lchild = 2 * i + 1 while lchild < n: rchild = lchild + 1 if rchild < n and cmp(ys[rchild], ys[lchild]): child = rchild else: child = lchild if not cmp(ys[child], ys[i]): break xs[child], xs[i] = xs[i], xs[child] ys[child], ys[i] = ys[i], ys[child] i, lchild = child, 2 * child + 1
def _get_nearest_indexer(self, target, limit, tolerance): """ Get the indexer for the nearest index labels; requires an index with values that can be subtracted from each other (e.g., not strings or tuples). """ left_indexer = self.get_indexer(target, 'pad', limit=limit) right_indexer = self.get_indexer(target, 'backfill', limit=limit) target = np.asarray(target) left_distances = abs(self.values[left_indexer] - target) right_distances = abs(self.values[right_indexer] - target) op = operator.lt if self.is_monotonic_increasing else operator.le indexer = np.where(op(left_distances, right_distances) | (right_indexer == -1), left_indexer, right_indexer) if tolerance is not None: indexer = self._filter_indexer_tolerance(target, indexer, tolerance) return indexer
def test_comparators(self): index = self.dateIndex element = index[len(index) // 2] element = _to_m8(element) arr = np.array(index) def _check(op): arr_result = op(arr, element) index_result = op(index, element) self.assertIsInstance(index_result, np.ndarray) tm.assert_numpy_array_equal(arr_result, index_result) _check(operator.eq) _check(operator.ne) _check(operator.gt) _check(operator.lt) _check(operator.ge) _check(operator.le)
def test_timestamp_compare(self): # make sure we can compare Timestamps on the right AND left hand side # GH4982 df = DataFrame({'dates1': date_range('20010101', periods=10), 'dates2': date_range('20010102', periods=10), 'intcol': np.random.randint(1000000000, size=10), 'floatcol': np.random.randn(10), 'stringcol': list(tm.rands(10))}) df.loc[np.random.rand(len(df)) > 0.5, 'dates2'] = pd.NaT ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'} for left, right in ops.items(): left_f = getattr(operator, left) right_f = getattr(operator, right) # no nats expected = left_f(df, Timestamp('20010109')) result = right_f(Timestamp('20010109'), df) assert_frame_equal(result, expected) # nats expected = left_f(df, Timestamp('nat')) result = right_f(Timestamp('nat'), df) assert_frame_equal(result, expected)
def get_default_operators(): """ generate a mapping of default operators allowed for evaluation """ return { 'u-': Func(1, operator.neg), # unary negation 'u%': Func(1, lambda a: a / Decimal(100)), # unary percentage '&': Func(2, operator.concat), '^': Func(2, operator.pow), '+': Func(2, op_add), '-': Func(2, operator.sub), '/': Func(2, operator.truediv), '*': Func(2, operator.mul), '=': Func(2, operator.eq), '<>': Func(2, lambda a, b: not operator.eq(a, b)), '>': Func(2, operator.gt), '<': Func(2, operator.lt), '>=': Func(2, operator.ge), '<=': Func(2, operator.le), }
def test_symbols(): N, C, H, W = 2,3,4,5 a = np.random.random((N, C, H, W)) b = np.random.random((N, C, H, W)) [la, lb] = L.Data([a,b]) eq = M.equal(la, lb) ne = M.not_equal(la, lb) ge = M.greater_equal(la, lb) gt = M.greater(la, lb) le = M.less_equal(la, lb) lt = M.less(la, lb) lops = [eq,ne,ge,gt,le,lt] ops = [operator.eq, operator.ne, operator.ge, operator.gt, operator.le, operator.lt] for l, op in zip(lops, ops): assert l.op == op
def test_compare(): N, C, H, W = 2,3,4,5 a = np.random.random((N, C, H, W)) b = np.random.random((N, C, H, W)) a_copy = a.copy() [la, lb, lac] = L.Data([a,b,a_copy]) ops = [operator.ge, operator.gt, operator.le, operator.lt] for op in ops: l = op(la, lb) l2 = op(la, lac) assert np.allclose(l.eval(), op(a,b)) assert np.allclose(l2.eval(), op(a,a_copy)) l.backward() l2.backward() assert np.allclose(l.dX[0], np.zeros(l.X[0].shape)) assert np.allclose(l.dX[1], np.zeros(l.X[1].shape)) assert np.allclose(l2.dX[0], np.zeros(l2.X[0].shape)) assert np.allclose(l2.dX[1], np.zeros(l2.X[1].shape))
def test_compare_symbols(): N, C, H, W = 2,3,4,5 a = np.random.random((N, C, H, W)) b = np.random.random((N, C, H, W)) [la, lb] = L.Data([a,b]) eq = M.equal(la, lb) ne = M.not_equal(la, lb) ge = (la >= lb) gt = (la > lb) le = (la <= lb) lt = (la < lb) lops = [eq,ne,ge,gt,le,lt] ops = [operator.eq, operator.ne, operator.ge, operator.gt, operator.le, operator.lt] for l, op in zip(lops, ops): assert l.op == op
def __lt__(self, trc): return self.apply_op2(trc, operator.lt).binarize()
def all_pairs_matching_predicate(values, pred): """ Return an iterator of all pairs, (v0, v1) from values such that `pred(v0, v1) == True` Parameters ---------- values : iterable pred : function Returns ------- pairs_iterator : generator Generator yielding pairs matching `pred`. Examples -------- >>> from zipline.testing import all_pairs_matching_predicate >>> from operator import eq, lt >>> list(all_pairs_matching_predicate(range(5), eq)) [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] >>> list(all_pairs_matching_predicate("abcd", lt)) [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')] """ return filter(lambda pair: pred(*pair), product(values, repeat=2))
def product_upper_triangle(values, include_diagonal=False): """ Return an iterator over pairs, (v0, v1), drawn from values. If `include_diagonal` is True, returns all pairs such that v0 <= v1. If `include_diagonal` is False, returns all pairs such that v0 < v1. """ return all_pairs_matching_predicate( values, operator.le if include_diagonal else operator.lt, )
def __lt__(a, b): """a < b""" return a._richcmp(b, operator.lt)
def __lt__(self, other): return self._op(other, operator.lt)
