我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用operator.ne()。
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 wrap_transition(op, did_change): """Transform operator into a transition operator. That is, an operator that only returns true if the ``did_change`` operator also returns true. Note: E.g. ``wrap_transition(operator.eq, operator.ne)`` returns function with signature ``(new_value, needle, old_value)`` and only returns true if new_value is equal to needle, but old_value was not equal to needle. """ def compare(new_value, needle, old_value): return did_change(old_value, needle) and op(new_value, needle) return compare
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 _rules_pass(obj, rules, compare=operator.eq): for key, expected_value in rules.items(): if isinstance(expected_value, dict): if key.endswith('NotEqual'): nested_compare = operator.ne key = key[:-len('NotEqual')] else: nested_compare = compare nested_rules_passed = _rules_pass( obj=obj.get(key) or {}, rules=expected_value, compare=nested_compare, ) if not nested_rules_passed: return False elif not compare(obj.get(key), expected_value): return False return True
def test_encode(self): self.assertEqual(AP("a").encode(42), ('a___42.0', ['(declare-const a___42.0 Bool)'])) self.assertEqual(AP("a").encode(), ('a___0.0', ['(declare-const a___0.0 Bool)'])) self.assertEqual(AP("a").encode(0.5), ('a___0.5', ['(declare-const a___0.5 Bool)'])) self.assertEqual(AP(None, (1, 2), operator.ge, 42, ('x', 'y')).encode(), ('(>= (+ (* 1.0 x___0.0) (* 2.0 y___0.0)) 42)', ['(declare-const x___0.0 Real)', '(declare-const y___0.0 Real)'])) self.assertEqual(AP(None, (1, 2), operator.ge, 42, ('x', 'y')).encode(42), ('(>= (+ (* 1.0 x___42.0) (* 2.0 y___42.0)) 42)', ['(declare-const x___42.0 Real)', '(declare-const y___42.0 Real)'])) self.assertEqual(AP(None, None, operator.ne, 42, ('x', 'y')).encode(), ('(distinct (+ x___0.0 y___0.0) 42)', ['(declare-const x___0.0 Real)', '(declare-const y___0.0 Real)'])) self.assertEqual(AP(None, None, operator.eq, 42, 'x').encode(), ('(= x___0.0 42)', ['(declare-const x___0.0 Real)'])) self.assertEqual(AP(None, (3,), gt, 42, 'x').encode(), ('(> (* 3.0 x___0.0) 42)', ['(declare-const x___0.0 Real)'])) self.assertEqual(AP(None, (3,), gt, 42, 'x').encode(0.5), ('(and (>= (* 3.0 x___0.0) 42) (and (> (* 3.0 x___0.5) 42) (>= (* 3.0 x___1.0) 42)))', ['(declare-const x___0.0 Real)', '(declare-const x___0.5 Real)', '(declare-const x___1.0 Real)']))
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 __ne__(self, other): """ Construct a Filter returning True for asset/date pairs where the output of ``self`` matches ``other. """ if isinstance(other, Number) != (self.dtype == int64_dtype): raise InvalidClassifierComparison(self, other) if isinstance(other, Number): return NumExprFilter.create( "((x_0 != {other}) & (x_0 != {missing}))".format( other=int(other), missing=self.missing_value, ), binds=(self,), ) else: # Numexpr doesn't know how to use LabelArrays. return ArrayPredicate(term=self, op=operator.ne, opargs=(other,))
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_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_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 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 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 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_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 __ne__(self, trc): return self.apply_op2(trc, operator.ne).binarize()
def __ne__(self, other): return self._op(other, operator.ne)
