我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用operator.isNumberType()。
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 __add__(self, other): # Order of testing is important! if isinstance(other, numpy.ndarray): # If adding sparse and dense, result is dense # rv = SparseVector(max(self.n, other.shape[0]), {}) rv = numpy.zeros(max(self.n, other.shape[0]), 'd') for k in range(other.shape[0]): rv[k] = other[k] for k in self.values.keys(): rv[k] += self[k] return rv elif isSparseVector(other): rv = SparseVector(max(self.n, other.n), {}) for k in self.values.keys(): rv[k] += self[k] for k in other.values.keys(): rv[k] += other[k] return rv elif operator.isNumberType(other): rv = SparseVector(self.n, {}) for k in self.values.keys(): rv[k] = self[k] + other return rv else: raise TypeError("Cannot add with SparseVector")
def __iadd__(self, other): # Order of testing is important! if isinstance(other, numpy.ndarray): self.n = max(self.n, other.shape[0]) for k in range(other.shape[0]): self[k] += other[k] return self elif isSparseVector(other): self.n = max(self.n, other.n) inter = filter(self.values.has_key, other.values.keys()) other_only = filter(lambda x: not self.values.has_key, other.values.keys()) for k in inter + other_only: self[k] += other[k] return self elif operator.isNumberType(other): for k in self.values.keys(): self[k] += other return self else: raise TypeError("Cannot add to SparseVector")
def __imul__(self, other): """Element by element multiplication. For dot product, see the helper function dot(). """ if isinstance(other, numpy.ndarray): self.n = max(self.n, other.shape[0]) for k in range(other.shape[0]): self.values[k] *= other[k] return self elif isSparseVector(other): self.n = max(self.n, other.n) inter = filter(self.values.has_key, other.values.keys()) other_only = filter(lambda x: not self.values.has_key, other.values.keys()) for k in inter + other_only: self.values[k] *= other.values[k] return self elif operator.isNumberType(other): for k in self.values.keys(): self.values[k] *= other return self else: raise TypeError("Cannot multiply with SparseVector")
def __idiv__(self, other): """Element by element division.""" if isinstance(other, numpy.ndarray): self.n = max(self.n, other.shape[0]) for k in range(other.shape[0]): self[k] /= other[k] return self elif isSparseVector(other): self.n = max(self.n, other.n) inter = filter(self.values.has_key, other.values.keys()) other_only = filter(lambda x: not self.values.has_key, other.values.keys()) for k in inter + other_only: self[k] /= other.values[k] return self elif operator.isNumberType(other): for k in self.values.keys(): self[k] /= other return self else: raise TypeError("Cannot multiply with SparseVector")
def __div__(self, other): """Element by element division.""" if isinstance(other, numpy.ndarray): rv = SparseVector(max(self.n, other.shape[0]), {}) for k in self.values.keys(): rv[k] = self[k] / other[k] return rv elif isSparseVector(other): rv = SparseVector(max(self.n, other.n), {}) for k in filter(self.values.has_key, other.values.keys()): rv[k] = self[k] / other[k] return rv elif operator.isNumberType(other): rv = SparseVector(self.n, {}) for k in self.values.keys(): rv[k] = self[k] / other return rv else: raise TypeError("Cannot multiply with SparseVector")
def Set(cls, value): log.step_normal("Element [%s]: Set [%s]." % (cls.__name__, value)) if isNumberType(value): value = str(value) cls.__wait() elements = env.threadlocal.BROWSER.find_elements(cls.by, cls.value) if elements[cls.index].tag_name == "select" or elements[cls.index].tag_name == "ul": cls.Select(value) else: elements[cls.index].clear() action = webdriver.ActionChains(env.threadlocal.BROWSER) action.send_keys_to_element(elements[cls.index], value) #???????? action.perform() cls.__clearup()
def __init__(self, stream, cols=None, number_fmt='%8.4f', col_width=8, col_sep=' ', output_block=False, **pars): DataRecorder.__init__(self, **pars) self._stream = stream if not number_fmt.startswith('%'): number_fmt = '%%s' % number_fmt self._number_fmt = number_fmt self._col_sep = col_sep self._col_width = col_width if operator.isSequenceType(cols) and \ not isinstance(cols, (str, unicode)): cols = CaselessList(cols) elif operator.isNumberType(cols): cols = cols else: cols = None self._columns = cols self._output_block = output_block
def is_number(obj): """ Helper function to determine numbers across Python 2.x and 3.x """ try: from numbers import Number except ImportError: from operator import isNumberType return isNumberType(obj) else: return isinstance(obj, Number)
def test_isNumberType(self): self.assertRaises(TypeError, operator.isNumberType) self.assertTrue(operator.isNumberType(8)) self.assertTrue(operator.isNumberType(8j)) self.assertTrue(operator.isNumberType(8L)) self.assertTrue(operator.isNumberType(8.3)) self.assertFalse(operator.isNumberType(dir()))
def __setitem__(self, index, item): if not isinstance(index, types.IntType): raise KeyError("Index must be integer") if index > self.n: self.n = index if not operator.isNumberType(item): raise TypeError("Value must be numeric") if float(item) != 0.0: dict.__setitem__(self.values, index, item) # Fetch item from sparse vector
def _getscaleoffset(expr): stub = ["stub"] data = expr(_E(stub)).data try: (a, b, c) = data # simplified syntax if (a is stub and b == "__mul__" and isNumberType(c)): return c, 0.0 if (a is stub and b == "__add__" and isNumberType(c)): return 1.0, c except TypeError: pass try: ((a, b, c), d, e) = data # full syntax if (a is stub and b == "__mul__" and isNumberType(c) and d == "__add__" and isNumberType(e)): return c, e except TypeError: pass raise ValueError("illegal expression") # -------------------------------------------------------------------- # Implementation wrapper ## # This class represents an image object. To create Image objects, use # the appropriate factory functions. There's hardly ever any reason # to call the Image constructor directly. # # @see #open # @see #new # @see #fromstring
def exec_(self): """**Internal method**. Execute macro as an iterator""" self._macro_thread = threading.current_thread() macro_status = self.getMacroStatus() # make sure a 0.0 progress is sent yield macro_status # allow any macro to be paused at the beginning of its execution self.pausePoint() # Run the macro or obtain a generator res = self.run(*self._in_pars) # If macro returns a generator then running the macro means go through # the generator steps, otherwise the macro has already ran if isinstance(res, types.GeneratorType): it = iter(res) for i in it: if operator.isMappingType(i): new_range = i.get('range') if new_range is not None: macro_status['range'] = new_range new_step = i.get('step') if new_step is not None: macro_status['step'] = new_step elif operator.isNumberType(i): macro_status['step'] = i macro_status['state'] = 'step' yield macro_status # make sure a 'stop' progress is sent in case an exception occurs macro_status['state'] = 'stop' else: self._out_pars = res macro_status['step'] = 100.0 macro_status['state'] = 'finish' yield macro_status
def _writeRecord(self, record): if not self.isInitialized(): return vals = [] for colname in self.labels: val = record.data.get(colname) if (not val is None) and (operator.isNumberType(val) and (type(val) in [int, float, long])): vals.append(val) elif (not val is None) and (operator.isNumberType(val)): valsmca = [] for i in range(0, len(val)): valsmca.append(val[i]) sufix = "1D" if self.array.endswith(sufix): valsmca = numpy.array(valsmca) self.sps.putdatarow( self.program, self.array, record.recordno, valsmca) sufix = "0D" if self.array.endswith(sufix): vals = numpy.array(vals) self.sps.putdatarow(self.program, self.array, record.recordno, vals) self.nopts += 1 env = {'nopts': self.nopts, 'peak': 111, 'peakpos': 34, 'fwhm': 12.3, 'fwhmpos': 45, 'com': 23} self.putAllEnv(env)
