# Python numpy.issubdtype() Examples

The following are 30 code examples for showing how to use numpy.issubdtype(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
```def SetDistribution(self, distinct_values):
"""This is all the values this column will ever see."""
assert self.all_distinct_values is None
# pd.isnull returns true for both np.nan and np.datetime64('NaT').
is_nan = pd.isnull(distinct_values)
contains_nan = np.any(is_nan)
dv_no_nan = distinct_values[~is_nan]
# NOTE: np.sort puts NaT values at beginning, and NaN values at end.
# For our purposes we always add any null value to the beginning.
vs = np.sort(np.unique(dv_no_nan))
if contains_nan and np.issubdtype(distinct_values.dtype, np.datetime64):
vs = np.insert(vs, 0, np.datetime64('NaT'))
elif contains_nan:
vs = np.insert(vs, 0, np.nan)
if self.distribution_size is not None:
assert len(vs) == self.distribution_size
self.all_distinct_values = vs
self.distribution_size = len(vs)
return self ```
Example 2
```def test_basic_property(self):
# Check A = L L^H
shapes = [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
dtypes = (np.float32, np.float64, np.complex64, np.complex128)

for shape, dtype in itertools.product(shapes, dtypes):
np.random.seed(1)
a = np.random.randn(*shape)
if np.issubdtype(dtype, np.complexfloating):
a = a + 1j*np.random.randn(*shape)

t = list(range(len(shape)))
t[-2:] = -1, -2

a = np.matmul(a.transpose(t).conj(), a)
a = np.asarray(a, dtype=dtype)

c = np.linalg.cholesky(a)

b = np.matmul(c, c.transpose(t).conj())
assert_allclose(b, a,
err_msg="{} {}\n{}\n{}".format(shape, dtype, a, c),
atol=500 * a.shape[0] * np.finfo(dtype).eps) ```
Example 3
```def _name_get(dtype):
# provides dtype.name.__get__

if dtype.isbuiltin == 2:
# user dtypes don't promise to do anything special
return dtype.type.__name__

# Builtin classes are documented as returning a "bit name"
name = dtype.type.__name__

# handle bool_, str_, etc
if name[-1] == '_':
name = name[:-1]

# append bit counts to str, unicode, and void
if np.issubdtype(dtype, np.flexible) and not _isunsized(dtype):
name += "{}".format(dtype.itemsize * 8)

elif dtype.type in (np.datetime64, np.timedelta64):

return name ```
Example 4
```def _checksum(fname, buffer_size=512 * 1024, dtype='uint64'):
# https://github.com/airware/buzzard/pull/39/#discussion_r239071556
dtype = np.dtype(dtype)
dtypesize = dtype.itemsize
assert buffer_size % dtypesize == 0
assert np.issubdtype(dtype, np.unsignedinteger)

acc = dtype.type(0)
with open(fname, "rb") as f:
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore', r'overflow encountered')

for chunk in iter(lambda: f.read(buffer_size), b""):
head = np.frombuffer(chunk, dtype, count=len(chunk) // dtypesize)

tailsize = len(chunk) % dtypesize
if tailsize > 0:
# This should only be needed for file's tail
tail = chunk[-tailsize:] + b'\0' * (dtypesize - tailsize)
tail = np.frombuffer(tail, dtype)
acc += tail
return '{:016x}'.format(acc.item()) ```
Example 5
```def _checksum(fname, buffer_size=512 * 1024, dtype='uint64'):
# https://github.com/airware/buzzard/pull/39/#discussion_r239071556
dtype = np.dtype(dtype)
dtypesize = dtype.itemsize
assert buffer_size % dtypesize == 0
assert np.issubdtype(dtype, np.unsignedinteger)

acc = dtype.type(0)
with open(fname, "rb") as f:
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore', r'overflow encountered')

for chunk in iter(lambda: f.read(buffer_size), b""):
head = np.frombuffer(chunk, dtype, count=len(chunk) // dtypesize)

tailsize = len(chunk) % dtypesize
if tailsize > 0:
# This should only be needed for file's tail
tail = chunk[-tailsize:] + b'\0' * (dtypesize - tailsize)
tail = np.frombuffer(tail, dtype)
acc += tail
return '{:016x}'.format(acc.item()) ```
Example 6
```def normalize_channels_parameter(channels, channel_count):
if channels is None:
if channel_count == 1:
return [0], True
else:
return list(range(channel_count)), False

indices = np.arange(channel_count)
indices = indices[channels]
indices = np.atleast_1d(indices)

if isinstance(channels, slice):
return indices.tolist(), False

channels = np.asarray(channels)
if not np.issubdtype(channels.dtype, np.number):
raise TypeError('`channels` should be None or int or slice or list of int')
if channels.ndim == 0:
assert len(indices) == 1
return indices.tolist(), True
return indices.tolist(), False ```
Example 7
```def __call__(self, df_or_series):
if isinstance(df_or_series, SERIES_TYPE):
if not np.issubdtype(df_or_series.dtype, np.number):
raise NotImplementedError('non-numeric type is not supported for now')
test_series = pd.Series([], dtype=df_or_series.dtype).describe(
percentiles=self._percentiles, include=self._include, exclude=self._exclude)
return self.new_series([df_or_series], shape=(len(test_series),),
dtype=test_series.dtype,
index_value=parse_index(test_series.index, store_data=True))
else:
test_inp_df = build_empty_df(df_or_series.dtypes)
test_df = test_inp_df.describe(
percentiles=self._percentiles, include=self._include, exclude=self._exclude)
for dtype in test_df.dtypes:
if not np.issubdtype(dtype, np.number):
raise NotImplementedError('non-numeric type is not supported for now')
return self.new_dataframe([df_or_series], shape=test_df.shape, dtypes=test_df.dtypes,
index_value=parse_index(test_df.index, store_data=True),
columns_value=parse_index(test_df.columns, store_data=True)) ```
Example 8
```def testAstype(self):
arr = ones((10, 20, 30), chunk_size=3)

arr2 = arr.astype(np.int32)
arr2 = arr2.tiles()

self.assertEqual(arr2.shape, (10, 20, 30))
self.assertTrue(np.issubdtype(arr2.dtype, np.int32))
self.assertEqual(arr2.op.casting, 'unsafe')

with self.assertRaises(TypeError):
arr.astype(np.int32, casting='safe')

arr3 = arr.astype(arr.dtype, order='F')
self.assertTrue(arr3.flags['F_CONTIGUOUS'])
self.assertFalse(arr3.flags['C_CONTIGUOUS'])

arr3 = arr3.tiles()

self.assertEqual(arr3.chunks[0].order.value, 'F') ```
Example 9
```def _AccumulateHistogram(self, statistics=None, labels=None):
"""Accumulate histogram of binned statistic by label.

Args:
statistics: int32 np.array of shape [K, 1] of binned statistic
labels: int32 np.array of shape [K, 1] of labels

Returns:
nothing
"""
assert np.issubdtype(statistics.dtype, int)
if not statistics.size:
return
p = self.params
assert np.max(statistics) < self._histogram.shape[0], (
'Histogram shape too small %d vs %d' %
(np.max(statistics), self._histogram.shape[0]))
indices = np.where(labels == l)[0]
for s in statistics[indices]:
self._histogram[s, l] += 1 ```
Example 10
```def __init__(self, arr=None, metadata=None, missing_id='<missing>',
groupings=None, substitute=True, weights=None, name=None):
super(self.__class__, self).__init__(arr, metadata, missing_id=missing_id, weights=weights, name=name)
self._nan = np.array([np.nan]).astype(int)[0]

if substitute and metadata is None:
self.arr, self.orig_type = self.substitute_values(self.arr)
elif substitute and metadata and not np.issubdtype(self.arr.dtype, np.integer):
# custom metadata has been passed in from external source, and must be converted to int
self.arr = self.arr.astype(int)

self._groupings = {}
if groupings is None:
for x in np.unique(self.arr):
self._groupings[x] = [x, x + 1, False]
else:
for x in np.unique(self.arr):
self._groupings[x] = list(groupings[x])
self._possible_groups = None ```
Example 11
```def to_java_array(m):
'''
to_java_array(m) yields to_java_ints(m) if m is an array of integers and to_java_doubles(m) if
m is anything else. The numpy array m is tested via numpy.issubdtype(m.dtype, numpy.int64).
'''
if not hasattr(m, '__iter__'): return m
m = np.asarray(m)
if np.issubdtype(m.dtype, np.dtype(int).type) or all(isinstance(x, num.Integral) for x in m):
else:
Example 12
```def parse_type(self, hdat, dataobj=None):
dtype = super(MGHImageType, self).parse_type(hdat, dataobj=dataobj)
if   np.issubdtype(dtype, np.floating): dtype = np.float32
elif np.issubdtype(dtype, np.int8):     dtype = np.int8
elif np.issubdtype(dtype, np.int16):    dtype = np.int16
elif np.issubdtype(dtype, np.integer):  dtype = np.int32
else: raise ValueError('Could not deduce appropriate MGH type for dtype %s' % dtype)
return dtype ```
Example 13
```def output_indices(ii):
ii = flattest(ii)
if (np.issubdtype(ii.dtype, np.dtype('bool').type)): ii = np.where(ii)[0]
return pimms.imm_array(ii) ```
Example 14
```def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
dt = cls._dtype
if dt is int or np.issubdtype(dt, np.integer):
items = {"type": "number", "multipleOf": 1.0}
elif dt is float or np.issubdtype(dt, np.floating):
items = {"type": "number"}
elif dt is str or np.issubdtype(dt, np.string_):
items = {"type": "string"}
elif dt is bool or np.issubdtype(dt, np.bool_):
items = {"type": "boolean"}
field_schema.update(type="array", items=items) ```
Example 15
```def test_simple():
tree_data, tree_clusters = phate.tree.gen_dla(n_branch=3)
phate_operator = phate.PHATE(knn=15, t=100, verbose=False)
tree_phate = phate_operator.fit_transform(tree_data)
assert tree_phate.shape == (tree_data.shape[0], 2)
clusters = phate.cluster.kmeans(phate_operator, n_clusters='auto')
assert np.issubdtype(clusters.dtype, np.signedinteger)
assert len(np.unique(clusters)) >= 2
assert len(clusters.shape) == 1
assert len(clusters) == tree_data.shape[0]
clusters = phate.cluster.kmeans(phate_operator, n_clusters=3)
assert np.issubdtype(clusters.dtype, np.signedinteger)
assert len(np.unique(clusters)) == 3
assert len(clusters.shape) == 1
assert len(clusters) == tree_data.shape[0]
phate_operator.fit(phate_operator.graph)
G = graphtools.Graph(
phate_operator.graph.kernel,
precomputed="affinity",
use_pygsp=True,
verbose=False,
)
phate_operator.fit(G)
G = pygsp.graphs.Graph(G.W)
phate_operator.fit(G)
phate_operator.fit(anndata.AnnData(tree_data))
with assert_raises_message(TypeError, "Expected phate_op to be of type PHATE. Got 1"):
phate.cluster.kmeans(1) ```
Example 16
```def _name_arms(self, pred):
if self.choice_names is None:
return pred
else:
if not np.issubdtype(pred.dtype, np.integer):
pred = pred.astype(int)
return self.choice_names[pred] ```
Example 17
```def append_alpha(imtmp):
alpha = np.ones_like(imtmp[:, :, 0]).astype(imtmp.dtype)
if np.issubdtype(imtmp.dtype, np.uint8):
alpha = alpha * 255
b_channel, g_channel, r_channel = cv2.split(imtmp)
im_RGBA = cv2.merge((b_channel, g_channel, r_channel, alpha))
return im_RGBA ```
Example 18
```def test_uncompute_time_var(dset, time_coord_name='time'):
esm = dset.esmlab.set_time(time_coord_name=time_coord_name)
xr.testing._assert_internal_invariants(esm._ds_time_computed)
ds = esm.compute_time_var()
assert ds[time_coord_name].dtype == np.dtype('O')
dset_with_uncomputed_time = esm.uncompute_time_var()
assert np.issubdtype(dset_with_uncomputed_time[time_coord_name].dtype, np.number)

# For some strange reason, this case fails when using pytest parametrization ```
Example 19
```def validate_coords(coords):
assert coords.ndim == 2, coords.ndim
assert coords.shape[1] == 2, coords.shape
assert np.issubdtype(coords.dtype, np.float), coords.dtype ```
Example 20
```def main():
args = parseArguments(sys.argv[1:])
raise IOError('Could not find file: {0}'.format(args.fn_mask))
if not os.path.isfile(args.fn_mesh):
raise IOError('Could not find file: {0}'.format(args.fn_mesh))
vol = image.dataobj
if not np.issubdtype(vol.dtype, np.integer):
logger.warn('Volume is not an integer type, masking may fail')

affine = image.affine

ed = mesh_io.ElementData.from_data_grid(
mesh, vol, affine, 'from_volume'
)
# Re-label tetrahedra
mesh.elm.tag1[(ed.value > 0) * mesh.elm.elm_type == 4] = args.tag
mesh.elm.tag2[(ed.value > 0) * mesh.elm.elm_type == 4] = args.tag
# Remove triangles
mesh.elm.tag1[(ed.value > 0) * mesh.elm.elm_type == 2] = 99999
mesh.elm.tag2[(ed.value > 0) * mesh.elm.elm_type == 2] = 99999
mesh = mesh.remove_from_mesh(99999)

logger.info(f'Writing {args.fn_out}')
mesh_io.write_msh(mesh, args.fn_out) ```
Example 21
```def repeat(self, ntimes, expand="default"):
if expand == "default": expand = Circuit.default_expand_subcircuits
assert((_compat.isint(ntimes) or _np.issubdtype(ntimes, int)) and ntimes >= 0)
mystr, mylines = self._labels_lines_str()
if ntimes > 1: s = "(%s)^%d" % (mystr, ntimes)
elif ntimes == 1: s = "(%s)" % mystr
else: s = "{}"
if mylines is not None:
s += "@" + mylines  # add line labels
if ntimes > 1 and expand is False:
reppedCircuitLbl = self.as_label(nreps=ntimes)
return Circuit((reppedCircuitLbl,), self.line_labels, None, not self._static, s, check=False)
else:
# just adds parens to string rep & copies
return Circuit(self.layertup * ntimes, self.line_labels, None, not self._static, s, check=False) ```
Example 22
```def encode_categorical_features(cls, df):
cat_feature_map = OrderedDict()
for pos, f in enumerate(df):
if not np.issubdtype(df[f].dtype, np.number):
encoder = LabelEncoder()
df[f] = encoder.fit_transform(df[f])
#TODO: must ensure the mapping is consistent
cat_feature_map[pos] = encoder.classes_.tolist()

return cat_feature_map ```
Example 23
```def _set_or_promote_dtype(self, column_dtypes, c, dtype):
existing_dtype = column_dtypes.get(c)
if existing_dtype is None or existing_dtype != dtype:
# Promote ints to floats - as we can't easily represent NaNs
if np.issubdtype(dtype, int):
dtype = np.dtype('f8')
column_dtypes[c] = np.promote_types(column_dtypes.get(c, dtype), dtype) ```
Example 24
```def _round_ifneeded(arr, dtype):
"""
Rounds arr inplace if destination dtype is integer.

Parameters
----------
arr : ndarray
Input array.
dtype : dtype
The dtype of the destination array.

"""
if np.issubdtype(dtype, np.integer):
arr.round(out=arr) ```
Example 25
```def test_shape_and_dtype(self):
sizes = (4, 5, 3, 2)
# Test both lists and arrays
for func in (range, np.arange):
arrays = np.ix_(*[func(sz) for sz in sizes])
for k, (a, sz) in enumerate(zip(arrays, sizes)):
assert_equal(a.shape[k], sz)
assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
assert_(np.issubdtype(a.dtype, np.integer)) ```
Example 26
```def test_objects(self):
from decimal import Decimal
p = np.poly1d([Decimal('4.0'), Decimal('3.0'), Decimal('2.0')])
p2 = p * Decimal('1.333333333333333')
assert_(p2[1] == Decimal("3.9999999999999990"))
p2 = p.deriv()
assert_(p2[1] == Decimal('8.0'))
p2 = p.integ()
assert_(p2[3] == Decimal("1.333333333333333333333333333"))
assert_(p2[2] == Decimal('1.5'))
assert_(np.issubdtype(p2.coeffs.dtype, np.object_))
p = np.poly([Decimal(1), Decimal(2)])
assert_equal(np.poly([Decimal(1), Decimal(2)]),
[1, Decimal(-3), Decimal(2)]) ```
Example 27
```def test_asfarray(self):
a = asfarray(np.array([1, 2, 3]))
assert_equal(a.__class__, np.ndarray)
assert_(np.issubdtype(a.dtype, np.floating))

# previously this would infer dtypes from arrays, unlike every single
# other numpy function
assert_raises(TypeError,
asfarray, np.array([1, 2, 3]), dtype=np.array(1.0)) ```
Example 28
```def test_type(self):
# Check the type of the returned histogram
a = np.arange(10) + .5
h, b = histogram(a)
assert_(np.issubdtype(h.dtype, np.integer))

h, b = histogram(a, density=True)
assert_(np.issubdtype(h.dtype, np.floating))

h, b = histogram(a, weights=np.ones(10, int))
assert_(np.issubdtype(h.dtype, np.integer))

h, b = histogram(a, weights=np.ones(10, float))
assert_(np.issubdtype(h.dtype, np.floating)) ```
Example 29
```def do(self, a, b, tags):
arr = np.asarray(a)
m, n = arr.shape
u, s, vt = linalg.svd(a, 0)
x, residuals, rank, sv = linalg.lstsq(a, b, rcond=-1)
if m == 0:
assert_((x == 0).all())
if m <= n:
assert_almost_equal(b, dot(a, x))
assert_equal(rank, m)
else:
assert_equal(rank, n)
assert_almost_equal(sv, sv.__array_wrap__(s))
if rank == n and m > n:
expect_resids = (
np.asarray(abs(np.dot(a, x) - b)) ** 2).sum(axis=0)
expect_resids = np.asarray(expect_resids)
if np.asarray(b).ndim == 1:
expect_resids.shape = (1,)
assert_equal(residuals.shape, expect_resids.shape)
else:
expect_resids = np.array([]).view(type(x))
assert_almost_equal(residuals, expect_resids)
assert_(np.issubdtype(residuals.dtype, np.floating))
assert_(consistent_subclass(x, b))
assert_(consistent_subclass(residuals, b)) ```
Example 30
```def test_both_abstract(self):