NumPy 1.26 中文文档（二十二）

最新推荐文章于 2024-10-17 13:41:35 发布

绝不原创的飞龙

最新推荐文章于 2024-10-17 13:41:35 发布

阅读量804

点赞数 16

文章标签： numpy

License CC BY-NC-SA 4.0 / 自豪地采用谷歌翻译

本文链接：https://blog.csdn.net/wizardforcel/article/details/140007632

版权

原文：numpy.org/doc/

数据类型例程

原文：numpy.org/doc/1.26/reference/routines.dtype.html

`can_cast`(from_, to[, casting])	根据转换规则，如果可以在数据类型之间进行转换，则返回 True。
`promote_types`(type1, type2)	返回可安全转换为`type1`和`type2`的最小大小和最小标量种类的数据类型。
`min_scalar_type`(a, /)	对于标量`a`，返回可以容纳其值的大小和最小标量种类的数据类型。
`result_type`(*arrays_and_dtypes)	返回应用 NumPy 类型提升规则到参数时得到的类型。
`common_type`(*arrays)	返回输入数组通用的标量类型。
`obj2sctype`(rep[, default])	返回对象的标量 dtype 或 Python 类型的 NumPy 等效类型。

创建数据类型

`dtype`(dtype[, align, copy])	创建数据类型对象。
`format_parser`(formats, names, titles[, …])	将格式、名称、标题描述转换为数据类型的类。

数据类型信息

`finfo`(dtype)	浮点类型的机器限制。
`iinfo`(type)	整数类型的机器限制。

数据类型测试

`issctype`(rep)	确定给定对象是否表示标量数据类型。
`issubdtype`(arg1, arg2)	如果第一个参数在类型层次结构中的类型码较低/相等，则返回 True。
`issubsctype`(arg1, arg2)	判断第一个参数是否是第二个参数的子类。
`issubclass_`(arg1, arg2)	判断一个类是否是第二个类的子类。
`find_common_type`(array_types, scalar_types)	遵循标准强制规则确定常见类型。

杂项

`typename`(char)	返回给定数据类型代码的描述。
`sctype2char`(sctype)	返回标量数据类型的字符串表示。
`mintypecode`(typechars[, typeset, default])	返回给定类型可以安全转换的最小尺寸类型的字符。
`maximum_sctype`(t)	返回与输入相同种类的最高精度标量类型。

创建数据类型

`dtype`(dtype[, align, copy])	创建一个数据类型对象。
`format_parser`(formats, names, titles[, …])	将格式、名称、标题描述转换为数据类型的类。

数据类型信息

`finfo`(dtype)	浮点数类型的机器限制。
`iinfo`(type)	整数类型的机器限制。

数据类型测试

`issctype`(rep)	确定给定对象是否表示标量数据类型。
`issubdtype`(arg1, arg2)	如果第一个参数在类型层次结构中低于/等于类型代码，则返回 True。
`issubsctype`(arg1, arg2)	判断第一个参数是否是第二个参数的子类。
`issubclass_`(arg1, arg2)	判断一个类是否是第二个类的子类。
`find_common_type`(array_types, scalar_types)	根据标准强制规则确定通用类型。

杂项

`typename`(char)	返回给定数据类型代码的描述。
`sctype2char`(sctype)	返回标量数据类型的字符串表示。
`mintypecode`(typechars[, typeset, default])	返回给定类型可以安全转换的最小尺寸类型的字符。
`maximum_sctype`(t)	返回与输入相同种类的最高精度标量类型。

`numpy.can_cast`

原文：numpy.org/doc/1.26/reference/generated/numpy.can_cast.html

numpy.can_cast(from_, to, casting='safe')

如果根据转换规则可以进行数据类型之间的转换，则返回 True。如果 from 是标量或数组标量，则如果标量值可以在不溢出或截断的情况下转换为整数，则还返回 True。

参数:

从数据类型或数据类型说明符、标量或数组

要转换数据类型的数据类型、标量或数组。

至数据类型或数据类型说明符

要转换为的数据类型。

转换{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, 可选

控制进行何种类型的数据转换。

‘no’表示根本不应进行数据类型的转换。
‘equiv’表示只允许进行字节顺序的更改。
‘safe’表示只允许可以保留值的转换。
‘same_kind’表示只允许安全转换或类似类型之间的转换，如从 float64 到 float32。
‘unsafe’表示可能进行任何数据转换。

输出布尔

如果根据转换规则可以进行转换，则返回 True。

另请参阅

dtype，result_type

注意

在 1.17.0 版本中更改：简单数据类型与结构化数据类型之间的转换仅在“不安全”转换的情况下才可行。允许向多个字段进行转换，但不允许从多个字段进行转换。

在 1.9.0 版本中更改：在“安全”转换模式下，从数值到字符串类型的转换要求字符串数据类型的长度足够长，以存储转换后的最大整数/浮点数值。

示例

基本示例

>>> np.can_cast(np.int32, np.int64)
True
>>> np.can_cast(np.float64, complex)
True
>>> np.can_cast(complex, float)
False

>>> np.can_cast('i8', 'f8')
True
>>> np.can_cast('i8', 'f4')
False
>>> np.can_cast('i4', 'S4')
False

转换标量

>>> np.can_cast(100, 'i1')
True
>>> np.can_cast(150, 'i1')
False
>>> np.can_cast(150, 'u1')
True

>>> np.can_cast(3.5e100, np.float32)
False
>>> np.can_cast(1000.0, np.float32)
True

数组标量检查值，数组不检查

>>> np.can_cast(np.array(1000.0), np.float32)
True
>>> np.can_cast(np.array([1000.0]), np.float32)
False

使用转换规则

>>> np.can_cast('i8', 'i8', 'no')
True
>>> np.can_cast('<i8', '>i8', 'no')
False

>>> np.can_cast('<i8', '>i8', 'equiv')
True
>>> np.can_cast('<i4', '>i8', 'equiv')
False

>>> np.can_cast('<i4', '>i8', 'safe')
True
>>> np.can_cast('<i8', '>i4', 'safe')
False

>>> np.can_cast('<i8', '>i4', 'same_kind')
True
>>> np.can_cast('<i8', '>u4', 'same_kind')
False

>>> np.can_cast('<i8', '>u4', 'unsafe')
True

`numpy.promote_types`

numpy.org/doc/1.26/reference/generated/numpy.promote_types.html

numpy.promote_types(type1, type2)

返回最小大小和最小标量类型的数据类型，可以安全地将type1和type2都转换为该类型。返回的数据类型始终被认为是“规范的”，这主要意味着提升的数据类型总是处于本机字节顺序中。

此函数是对称的，但很少是结合性的。

参数：

type1 数据类型或数据类型指示符

第一个数据类型。

type2 数据类型或数据类型指示符

第二个数据类型。

out 数据类型

提升的数据类型。

参见

result_type，dtype，can_cast

注意事项

有关提升的更多信息，请参见numpy.result_type。

新版本：1.6.0。

从 NumPy 1.9 开始，当一个参数是整数或浮点数数据类型，另一个参数是字符串数据类型时，则 promote_types 函数现在会返回一个有效的字符串长度。以前，它始终返回输入的字符串数据类型，即使不足以存储转换为字符串的最大整数/浮点数值。

修改版本：1.23.0。

NumPy 现在支持更多结构化数据类型的提升。它现在会从结构数据类型中删除不必要的填充，并逐个提升包含的字段。

示例

>>> np.promote_types('f4', 'f8')
dtype('float64')

>>> np.promote_types('i8', 'f4')
dtype('float64')

>>> np.promote_types('>i8', '<c8')
dtype('complex128')

>>> np.promote_types('i4', 'S8')
dtype('S11')

一个非结合性案例的例子：

>>> p = np.promote_types
>>> p('S', p('i1', 'u1'))
dtype('S6')
>>> p(p('S', 'i1'), 'u1')
dtype('S4')

`numpy.min_scalar_type`

原文：numpy.org/doc/1.26/reference/generated/numpy.min_scalar_type.html

numpy.min_scalar_type(a, /)

对于标量 a，返回能够容纳其值的大小和标量种类最小的数据类型。对于非标量数组 a，返回未修改的向量数据类型。

浮点值不会降级为整数，复数值也不会降级为浮点数。

参数：

a标量或类似数组

要找到其最小数据类型的值。

返回值：

out数据类型

最小数据类型。

另请参阅

result_type, promote_types, dtype, can_cast

注意事项

新版本 1.6.0 中的新增内容。

示例

>>> np.min_scalar_type(10)
dtype('uint8')

>>> np.min_scalar_type(-260)
dtype('int16')

>>> np.min_scalar_type(3.1)
dtype('float16')

>>> np.min_scalar_type(1e50)
dtype('float64')

>>> np.min_scalar_type(np.arange(4,dtype='f8'))
dtype('float64')

`numpy.result_type`

原文：numpy.org/doc/1.26/reference/generated/numpy.result_type.html

numpy.result_type(*arrays_and_dtypes)

返回应用 NumPy 类型提升规则到参数时的结果类型。

NumPy 中的类型提升与诸如 C ++之类的语言中的规则类似，但略有不同。当同时使用标量和数组时，数组的类型优先，实际标量的值也会被考虑在内。

例如，计算 3*a，其中 a 是 32 位浮点数数组，直觉上应该会得到一个 32 位浮点数输出。如果 3 是 32 位整数，则 NumPy 规则表明它无法无损地转换为 32 位浮点数，因此结果类型应为 64 位浮点数。通过检查常量‘3’的值，我们可以看到它适合 8 位整数，可以无损地转换为 32 位浮点数。

参数：

arrays_and_dtypes数组和数据类型列表

需要结果类型的某些操作的操作数。

out数据类型

结果类型。

另请参见

dtype, promote_types, min_scalar_type, can_cast

注

在版本 1.6.0 中新增。

使用的特定算法如下。

类别通过首先检查所有数组和标量的所有数组和标量中的最大类别是布尔值、整数（int/uint）还是浮点数（float/complex）来确定。

如果只有标量或标量的最大类别高于数组的最大类别，则使用promote_types将数据类型组合以生成返回值。

否则，对每个标量调用min_scalar_type，并使用promote_types组合所有结果数据类型以生成返回值。

对于具有相同位数的类型，整数值的集合不是无符号整数值的子集，min_scalar_type中没有反映这一点，但在result_type中作为特殊情况处理。

示例

>>> np.result_type(3, np.arange(7, dtype='i1'))
dtype('int8')

>>> np.result_type('i4', 'c8')
dtype('complex128')

>>> np.result_type(3.0, -2)
dtype('float64')

`numpy.common_type`

原文：numpy.org/doc/1.26/reference/generated/numpy.common_type.html

numpy.common_type(*arrays)

返回一个与输入数组共同的标量类型。

返回类型始终为非精确的（即浮点）标量类型，即使所有数组都是整数数组。如果输入的其中一个是整数数组，则返回的最小精度类型是 64 位浮点 dtype。

所有输入数组，除了 int64 和 uint64，都可以安全地转换为返回的 dtype，而不会丢失信息。

参数:

**array1, array2, …**多维数组

输入数组。

输出数据类型代码

数据类型代码。

参见

dtype, mintypecode

例子

>>> np.common_type(np.arange(2, dtype=np.float32))
<class 'numpy.float32'>
>>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
<class 'numpy.float64'>
>>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
<class 'numpy.complex128'>

`numpy.obj2sctype`

原文：numpy.org/doc/1.26/reference/generated/numpy.obj2sctype.html

numpy.obj2sctype(rep, default=None)

返回对象的标量 dtype 或 Python 类型的 NumPy 等效类型。

参数：

rep任意

要返回其类型的对象。

default任意，可选

如果给定，将返回给定对象类型无法确定的对象。如果未给定，则对于这些对象返回 None。

dtypedtype 或 Python 类型

rep的数据类型。

另请参阅

sctype2char, issctype, issubsctype, issubdtype, maximum_sctype

示例

>>> np.obj2sctype(np.int32)
<class 'numpy.int32'>
>>> np.obj2sctype(np.array([1., 2.]))
<class 'numpy.float64'>
>>> np.obj2sctype(np.array([1.j]))
<class 'numpy.complex128'>

>>> np.obj2sctype(dict)
<class 'numpy.object_'>
>>> np.obj2sctype('string')

>>> np.obj2sctype(1, default=list)
<class 'list'>

numpy 数据类型

numpy.org/doc/1.26/reference/generated/numpy.dtype.html的原文链接。

class numpy.dtype(dtype, align=False, copy=False[, metadata])

创建数据类型对象。

一个 numpy 数组是同质的，包含由数据类型对象描述的元素。数据类型对象可以由不同基本数值类型的不同组合构建。

参数：

dtype

要转换为数据类型对象的对象。

align布尔值，可选

添加填充以匹配类似 C 结构的 C 编译器输出的字段。只有当obj是字典或逗号分隔的字符串时才可能为True。如果正在创建结构数据类型，则还会设置一个粘性对齐标志isalignedstruct。

copy布尔值，可选

制作此数据类型对象的新副本。如果False，则结果可能仅是对内置数据类型对象的引用。

metadata字典，可选

一个可选的带有数据类型元数据的字典。

参见

result_type

示例

使用数组标量类型：

>>> np.dtype(np.int16)
dtype('int16')

结构化类型，一个名为‘f1’的字段，包含 int16：

>>> np.dtype([('f1', np.int16)])
dtype([('f1', '<i2')])

结构化类型，一个名为‘f1’的字段，其内部包含一个带有一个字段的结构化类型：

>>> np.dtype([('f1', [('f1', np.int16)])])
dtype([('f1', [('f1', '<i2')])])

结构化类型，两个字段：第一个字段包含一个无符号整数，第二个包含一个 int32：

>>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
dtype([('f1', '<u8'), ('f2', '<i4')])

使用数组协议类型字符串：

>>> np.dtype([('a','f8'),('b','S10')])
dtype([('a', '<f8'), ('b', 'S10')])

使用逗号分隔的字段格式。形状为（2,3）：

>>> np.dtype("i4, (2,3)f8")
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])

使用元组。int是一个固定类型，3 是字段的形状。void是一个灵活类型，在这个例子中大小为 10：

>>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
dtype([('hello', '<i8', (3,)), ('world', 'V10')])

将int16细分为 2 个int8，称为 x 和 y。0 和 1 是字节偏移量：

>>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))

使用字典。两个名为“gender”和“age”的字段：

>>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
dtype([('gender', 'S1'), ('age', 'u1')])

字节偏移量，这里为 0 和 25：

>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', 'S25'), ('age', 'u1')])

属性：

alignment

根据编译器，此数据类型的数据对齐（字节）要求。

base

返回子数组的基本元素的数据类型，而不考虑它们的维度或形状。

byteorder

表示此数据类型对象字节顺序的字符。

char

21 种不同的内置类型的每种的唯一字符代码。

descr

*array_interface*描述数据类型的接口。

fields

用于此数据类型定义的命名字段的字典，或为None。

flags

描述如何解释此数据类型的位标志。

hasobject

布尔值，指示此数据类型是否在任何字段或子数据类型中包含任何引用计数对象。

isalignedstruct

布尔值，指示该数据类型是否为保持字段对齐的结构体。

isbuiltin

表示此数据类型与内置数据类型的关系的整数。

isnative

布尔值，指示此数据类型的字节顺序是否为平台本地的。

itemsize

此数据类型对象的元素大小。

kind

一个字符代码（biufcmMOSUV之一），用于标识数据的一般类型。

metadata

None 或一个只读的元数据字典（mappingproxy）。

name

此数据类型的位宽名称。

names

字段名称的有序列表，如果没有字段则为None。

ndim

如果此数据类型描述一个子数组，则为其子数组的维度数，否则为0。

num

21 种不同内置类型中的每一种的唯一编号。

shape

如果此数据类型描述一个子数组，则为其子数组的形状元组，否则为()。

str

此数据类型对象的数组协议类型字符串。

subdtype

如果这个dtype描述一个子数组，则为元组(item_dtype, shape)，否则为None。

类型

方法

`newbyteorder`([new_order])	返回具有不同字节顺序的新数据类型。

`numpy.format_parser`

原文：numpy.org/doc/1.26/reference/generated/numpy.format_parser.html

class numpy.format_parser(formats, names, titles, aligned=False, byteorder=None)

将格式、名称和标题说明转换为 dtype 的类。

构造 format_parser 对象之后，dtype 属性就是转换后的数据类型：dtype = format_parser(formats, names, titles).dtype

参数：

formatsstr 或 str 列表

格式描述，可以指定为以逗号分隔的格式描述字符串，格式为'f8, i4, a5'，或者以格式描述字符串的列表形式为['f8', 'i4', 'a5']。

namesstr 或 str 列表/元组

字段名可以指定为逗号分隔的字符串，格式为'col1, col2, col3'，或者以字符串的列表或元组形式为['col1', 'col2', 'col3']。可以使用空列表，在这种情况下将使用默认字段名称（‘f0’, ‘f1’, …）。

titles序列

标题字符串的序列。可以使用空列表来排除标题。

alignedbool，可选

如果为 True，则通过填充，使字段对齐，就像 C 编译器一样。默认为 False。

byteorderstr，可选

如果指定，则所有字段都会更改为所提供的字节顺序。否则，将使用默认的字节顺序。有关所有可用的字符串说明符，请参见dtype.newbyteorder。

参见

dtype, typename, sctype2char

示例

>>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
...                  ['T1', 'T2', 'T3']).dtype
dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])

names和/或titles可以是空列表。如果titles是一个空列表，标题将不会显示。如果names是空的，将使用默认字段名称。

>>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
...                  []).dtype
dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
>>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])

属性：

dtypedtype

转换后的数据类型。

`numpy.finfo`

原文：numpy.org/doc/1.26/reference/generated/numpy.finfo.html

class numpy.finfo(dtype)

浮点类型的机器限制。

参数：

dtypefloat、dtype 或实例

要获取有关的浮点或复杂浮点数据类型的信息。

参见

iinfo

整数数据类型的等效值。

spacing

值与最近的相邻数之间的距离

nextafter

从 x1 开始到 x2 的下一个浮点值

注意

对于 NumPy 的开发者：不要在模块级别实例化此参数。这些参数的初始计算是昂贵的，并且会对导入时间产生负面影响。这些对象已缓存，因此在函数内多次调用 finfo() 不是问题。

注意，smallest_normal 实际上不是 NumPy 浮点类型中可表示的最小正值。与 IEEE-754 标准相同[1]，NumPy 浮点类型利用子正规数来填补 0 和 smallest_normal 之间的差距。但是，子正规数可能具有显著降低的精度[2]。

此函数也可用于复杂数据类型。如果使用，则输出将与相应的实数浮点类型相同（例如 numpy.finfo(numpy.csingle) 与 numpy.finfo(numpy.single)相同）。然而，输出对于实部和虚部是真实的。

参考

[1]

浮点数算术的 IEEE 标准，IEEE Std 754-2008，第 1-70 页，2008 年，www.doi.org/10.1109/IEEESTD.2008.4610935

[2]

维基百科，“非规格化数”，en.wikipedia.org/wiki/Denormal_number

示例

>>> np.finfo(np.float64).dtype
dtype('float64')
>>> np.finfo(np.complex64).dtype
dtype('float32')

属性：

bitsint

类型所占的位数。

dtypedtype

返回 finfo 返回信息的 dtype。对于复数输入，返回的 dtype 是与其实部和复数部分对应的 float* dtype。

epsfloat

1.0 和大于 1.0 的下一个最小的可表示浮点数之间的差异。例如，对于 IEEE-754 标准中的 64 位二进制浮点数，eps = 2**-52，大约为 2.22e-16。

epsnegfloat

1.0 和小于 1.0 的下一个最小可表示浮点数之间的差异。例如，对于 IEEE-754 标准中的 64 位二进制浮点数，epsneg = 2**-53，大约为 1.11e-16。

iexpint

浮点表示的指数部分的位数。

machepint

产生 eps 的指数。

最大的适当类型浮点数

可表示的最大数。

maxexpint

导致溢出的基数(2)的最小正幂。

最小的适当类型浮点数

可表示的最小数值，通常为 -max。

minexp整型

基数 (2) 的最小负幂次，其尾数中没有前导 0 的情况下。

negep整型

产生 epsneg 的指数。

nexp整型

指数中包括其符号和偏置的位数。

nmant整型

尾数中的位数。

precision整型

此种浮点数精确的十进制位数的近似值。

分辨率适当类型的浮点数

此类型的近似十进制分辨率，即，10**-precision。

最小值浮点数

返回 tiny 的值，作为 smallest_normal 的别名。

最小正常值浮点数

返回最小正常值的值。

最小下正常值浮点数

在 IEEE-754 中，尾数中以 0 开头的最小正浮点数。

`numpy.iinfo`

原文：numpy.org/doc/1.26/reference/generated/numpy.iinfo.html

class numpy.iinfo(type)

整数类型的机器限制。

参数：

int_type整数类型，dtype 或实例

要获取信息的整数数据类型的种类。

另请参阅

finfo

浮点数数据类型的等价物。

示例

对类型：

>>> ii16 = np.iinfo(np.int16)
>>> ii16.min
-32768
>>> ii16.max
32767
>>> ii32 = np.iinfo(np.int32)
>>> ii32.min
-2147483648
>>> ii32.max
2147483647

对实例：

>>> ii32 = np.iinfo(np.int32(10))
>>> ii32.min
-2147483648
>>> ii32.max
2147483647

属性：

bitsint

类型所占的位数。

dtypedtype

返回iinfo返回信息的 dtype。

minint

给定 dtype 的最小值。

maxint

给定 dtype 的最大值。

`numpy.issctype`

原文：numpy.org/doc/1.26/reference/generated/numpy.issctype.html

numpy.issctype(rep)

确定给定对象是否表示标量数据类型。

参数：

repany

如果 rep 是标量 dtype 的实例，则返回 True。如果不是，则返回 False。

outbool

检查 rep 是否是标量 dtype 的布尔结果。

参见

issubsctype, issubdtype, obj2sctype, sctype2char

示例

>>> np.issctype(np.int32)
True
>>> np.issctype(list)
False
>>> np.issctype(1.1)
False

字符串也是标量类型：

>>> np.issctype(np.dtype('str'))
True

`numpy.issubdtype`

原文：numpy.org/doc/1.26/reference/generated/numpy.issubdtype.html

numpy.issubdtype(arg1, arg2)

如果第一个参数是类型码，且在类型层次结构中较低/相等，则返回 True。

这类似于内置的 issubclass, 但适用于 dtype.

参数:

arg1, arg2dtype_like

dtype 或可转换为其的对象

outbool

另请参阅

标量

numpy 类型层次结构概览。

issubsctype, issubclass_

例子

issubdtype 可以用来检查数组的类型：

>>> ints = np.array([1, 2, 3], dtype=np.int32)
>>> np.issubdtype(ints.dtype, np.integer)
True
>>> np.issubdtype(ints.dtype, np.floating)
False

>>> floats = np.array([1, 2, 3], dtype=np.float32)
>>> np.issubdtype(floats.dtype, np.integer)
False
>>> np.issubdtype(floats.dtype, np.floating)
True

不同大小的类似类型不是彼此的子类型：

>>> np.issubdtype(np.float64, np.float32)
False
>>> np.issubdtype(np.float32, np.float64)
False

但两者都是 floating 的子类型：

>>> np.issubdtype(np.float64, np.floating)
True
>>> np.issubdtype(np.float32, np.floating)
True

为方便起见，也允许使用类似 dtype 的对象：

>>> np.issubdtype('S1', np.string_)
True
>>> np.issubdtype('i4', np.signedinteger)
True

`numpy.issubsctype`

原文：numpy.org/doc/1.26/reference/generated/numpy.issubsctype.html

numpy.issubsctype(arg1, arg2)

确定第一个参数是否是第二个参数的子类。

参数：

arg1, arg2数据类型或数据类型说明符

数据类型。

outbool

结果。

另请参见

issctype, issubdtype, obj2sctype

示例

>>> np.issubsctype('S8', str)
False
>>> np.issubsctype(np.array([1]), int)
True
>>> np.issubsctype(np.array([1]), float)
False

`numpy.issubclass_`

原文：numpy.org/doc/1.26/reference/generated/numpy.issubclass_.html

numpy.issubclass_(arg1, arg2)

判断一个类是否是第二个类的子类。

issubclass_ 等同于 Python 内置的issubclass，不同之处在于如果其中一个参数不是类，则返回 False 而不是引发 TypeError。

参数：

arg1类

输入类。如果arg1是arg2的子类，则返回 True。

arg2类或类元组。

输入类。如果是类元组，则如果arg1是元组元素之一的子类，则返回 True。

返回值：

out布尔值

arg1是否是arg2的子类。

另请参见

issubsctype, issubdtype, issctype

示例

>>> np.issubclass_(np.int32, int)
False
>>> np.issubclass_(np.int32, float)
False
>>> np.issubclass_(np.float64, float)
True

`numpy.find_common_type`

原文：numpy.org/doc/1.26/reference/generated/numpy.find_common_type.html

numpy.find_common_type(array_types, scalar_types)

遵循标准强制规则确定共同类型。

自 NumPy 版本 1.25 起已弃用：

此函数已被弃用，请使用numpy.promote_types或numpy.result_type。要为scalar_types参数实现语义，请使用numpy.result_type并传递 Python 值 0, 0.0，或 0j。在几乎所有情况下，这将得到相同的结果。有关更多信息和罕见的例外，请参阅NumPy 1.25 发行说明。

参数：

array_types序列

由表示数组的 dtypes 或可转换为 dtype 的对象组成的列表。

scalar_types序列

由表示标量的 dtypes 或可转换为 dtype 的对象组成的列表。

datatypedtype

共同的数据类型，即array_types中的最大值，忽略scalar_types，除非scalar_types的最大值属于不同种类（dtype.kind）。如果该种类不被理解，则返回 None。

另请参考

dtype, common_type, can_cast, mintypecode

示例

>>> np.find_common_type([], [np.int64, np.float32, complex])
dtype('complex128')
>>> np.find_common_type([np.int64, np.float32], [])
dtype('float64')

标准的类型转换规则确保了标量不会将数组向上转型，除非标量属于一种完全不同类型的数据（即在数据类型层次结构中处于不同的层级）：

>>> np.find_common_type([np.float32], [np.int64, np.float64])
dtype('float32')

复数是一种不同类型，因此它会将array_types参数中的浮点数向上转型：

>>> np.find_common_type([np.float32], [complex])
dtype('complex128')

类型说明字符串可转换为 dtypes，因此可以用于替代 dtypes：

>>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
dtype('complex128')

`numpy.typename`

原文：numpy.org/doc/1.26/reference/generated/numpy.typename.html

numpy.typename(char)

返回给定数据类型代码的描述。

参数：

charstr

数据类型代码。

outstr

输入数据类型代码的描述。

另请参阅

dtype, typecodes

示例

>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
>>> for typechar in typechars:
...     print(typechar, ' : ', np.typename(typechar))
...
S1  :  character
?  :  bool
B  :  unsigned char
D  :  complex double precision
G  :  complex long double precision
F  :  complex single precision
I  :  unsigned integer
H  :  unsigned short
L  :  unsigned long integer
O  :  object
Q  :  unsigned long long integer
S  :  string
U  :  unicode
V  :  void
b  :  signed char
d  :  double precision
g  :  long precision
f  :  single precision
i  :  integer
h  :  short
l  :  long integer
q  :  long long integer

`numpy.sctype2char`

译文：numpy.org/doc/1.26/reference/generated/numpy.sctype2char.html

numpy.sctype2char(sctype)

返回标量 dtype 的字符串表示形式。

参数:

sctype标量 dtype 或对象

如果是标量 dtype，则返回相应的字符串字符。如果是对象，sctype2char试图推断其标量类型，然后返回相应的字符串字符。

typecharstr

与标量类型对应的字符串字符。

异常：

ValueError

如果sctype是一个无法推断类型的对象。

另请参阅

obj2sctype, issctype, issubsctype, mintypecode

示例

>>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
...     print(np.sctype2char(sctype))
l # may vary
d
D
S
O

>>> x = np.array([1., 2-1.j])
>>> np.sctype2char(x)
'D'
>>> np.sctype2char(list)
'O'

`numpy.mintypecode`

原文：numpy.org/doc/1.26/reference/generated/numpy.mintypecode.html

numpy.mintypecode(typechars, typeset='GDFgdf', default='d')

返回给定类型可以安全转换的最小大小类型的字符。

返回的类型字符必须代表最小大小的 dtype，以便返回类型的数组可以处理typechars中所有类型的数组的数据（或者如果typechars是一个数组，则其 dtype.char）。

参数：

typecharsstr 列表或 array_like

如果是字符串列表，则每个字符串应代表一个 dtype。如果是 array_like，则使用数组 dtype 的字符表示。

typesetstr 或 str 列表，可选

返回字符的字符集。默认字符集为‘GDFgdf’。

defaultstr，可选

默认字符，如果typechars中的字符没有匹配typeset中的字符，则返回默认字符。

typecharstr

代表找到的最小大小类型的字符。

另请参阅

dtype, sctype2char, maximum_sctype

示例

>>> np.mintypecode(['d', 'f', 'S'])
'd'
>>> x = np.array([1.1, 2-3.j])
>>> np.mintypecode(x)
'D'

>>> np.mintypecode('abceh', default='G')
'G'

`numpy.maximum_sctype`

原文：numpy.org/doc/1.26/reference/generated/numpy.maximum_sctype.html

numpy.maximum_sctype(t)

返回输入的与之最高精度相同类型的标量类型。

参数：

tdtype 或 dtype 指示符

输入的数据类型。可以是一个dtype 对象或可转换为dtype 的对象。

outdtype

与 t 相同类型的最高精度数据类型(dtype.kind )。

另请参阅

obj2sctype， mintypecode， sctype2char

dtype

示例：

>>> np.maximum_sctype(int)
<class 'numpy.int64'>
>>> np.maximum_sctype(np.uint8)
<class 'numpy.uint64'>
>>> np.maximum_sctype(complex)
<class 'numpy.complex256'> # may vary

>>> np.maximum_sctype(str)
<class 'numpy.str_'>

>>> np.maximum_sctype('i2')
<class 'numpy.int64'>
>>> np.maximum_sctype('f4')
<class 'numpy.float128'> # may vary

具有自动定义域的数学函数

原文：numpy.org/doc/1.26/reference/routines.emath.html

注释

numpy.emath 是 numpy.lib.scimath 的一个首选别名，在导入 numpy 后可用。

包装函数以更用户友好的方式调用某些数学函数，其输出数据类型在输入的某些域中与输入数据类型不同。

例如，对于像log这样具有分支切割的函数，该模块中的版本在复平面上提供数学上有效的答案：

>>> import math
>>> np.emath.log(-math.exp(1)) == (1+1j*math.pi)
True

类似地，sqrt，其他基数对数，power 和三角函数都得到了正确处理。请参阅各自的文档字符串以获取特定的示例。

函数

`sqrt`(x)	计算x的平方根。
`log`(x)	计算x的自然对数。
`log2`(x)	计算x的对数，以 2 为底。
`logn`(n, x)	计算以 n 为底的 x 的对数。
`log10`(x)	计算x的对数，以 10 为底。
`power`(x, p)	x 的 p 次方，(x**p)。
`arccos`(x)	计算x的反余弦值。
`arcsin`(x)	计算x的反正弦值。
`arctanh`(x)	计算x的反双曲正切值。

函数

`sqrt`(x)	计算x的平方根。
`log`(x)	计算x的自然对数。
`log2`(x)	计算x的对数，以 2 为底。
`logn`(n, x)	计算以 n 为底的 x 的对数。
`log10`(x)	计算x的对数，以 10 为底。
`power`(x, p)	返回 x 的 p 次方，(x**p)。
`arccos`(x)	计算 x 的反余弦值。
`arcsin`(x)	计算 x 的反正弦值。
`arctanh`(x)	计算 x 的反双曲正切值。

`numpy.emath.sqrt`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.sqrt.html

emath.sqrt(x)

计算 x 的平方根。

对于负输入元素，会返回一个复数（与numpy.sqrt不同，它会返回 NaN）。

参数：

x类似数组

输入值。

outndarray 或标量

x的平方根。如果x是标量，out也是如此，否则将返回一个数组。

另请参阅

numpy.sqrt

示例

对于真实且非负的输入，这就像使用numpy.sqrt一样：

>>> np.emath.sqrt(1)
1.0
>>> np.emath.sqrt([1, 4])
array([1.,  2.])

但它自动处理负输入：

>>> np.emath.sqrt(-1)
1j
>>> np.emath.sqrt([-1,4])
array([0.+1.j, 2.+0.j])

由于：浮点数 0.0 和-0.0 是不同的，所以会有不同的结果。

要更加灵活地控制，可显式地使用complex()如下所示：

>>> np.emath.sqrt(complex(-4.0, 0.0))
2j
>>> np.emath.sqrt(complex(-4.0, -0.0))
-2j

`numpy.emath.log`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.log.html

emath.log(x)

计算 x 的自然对数。

返回 (log_e(x)) 的“主值”（有关此内容的描述，请参见numpy.log）。对于实数 x > 0，这是一个实数（log(0)返回-inf，log(np.inf)返回inf）。否则，返回复数的主值。

参数：

x类似数组

需要其对数的值。

out 数组或标量

x 值的对数。如果 x 是标量，则 out 也是标量，否则返回数组。

另请参阅

numpy.log

注意

对于在实数 x < 0 时返回NAN的 log()，请使用numpy.log（注意，然而，否则numpy.log和这个log是相同的，即返回-inf，返回inf，并且如果x.imag != 0则返回复数的主值）。

示例

>>> np.emath.log(np.exp(1))
1.0

负参数被处理“正确”（请注意exp(log(x)) == x不适用于实数x < 0）：

>>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)
True

`numpy.emath.log2`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.log2.html

emath.log2(x)

计算以 2 为底的 x 的对数。

返回 (log_2(x)) 的“主值”（有关此的描述，请参见numpy.log2）。对于实 x > 0，这是一个实数（log2(0) 返回 -inf，log2(np.inf) 返回 inf）。否则，返回复数主值。

参数：

x：array_like

需要取对数的数值（们）。

out：ndarray 或标量

x 值的以 2 为底的对数。如果 x 是标量，则 out 也是标量，否则返回一个数组。

另请参见

numpy.log2

注释

要求实 x < 0 时返回 NAN 的 log2()，请使用 numpy.log2（但请注意，否则 numpy.log2 和此 log2 相同，即对于 x = 0 两者都返回 -inf，对于 x = inf 都返回 inf，并且特别地，如果 x.imag != 0 则返回复数的主值）。

示例

我们设置打印精度，以便可以自动测试示例：

>>> np.set_printoptions(precision=4)

>>> np.emath.log2(8)
3.0
>>> np.emath.log2([-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])

`numpy.emath.logn`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.logn.html

emath.logn(n, x)

对x取以n为底的对数。

如果x包含负数输入，则结果在复数域中计算并返回。

参数：

n：类似于数组

计算对数的整数底数。

x：类似于数组

需要计算其底为n的对数值（或者值）的数值（或者值）。

返回值：

out：ndarray 或标量

x的底为n的对数值（或者值）。如果x是一个标量，则out也是标量，否则返回一个数组。

示例：

>>> np.set_printoptions(precision=4)

>>> np.emath.logn(2, [4, 8])
array([2., 3.])
>>> np.emath.logn(2, [-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])

`numpy.emath.log10`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.log10.html

emath.log10(x)

计算x的以 10 为底的对数。

返回log_{10}(x)的“主值”（有关此内容的描述，请参阅numpy.log10）。对于实数x > 0，这是一个实数（log10(0)返回-inf，log10(np.inf)返回inf）。否则，返回复数主值。

参数：

xarray_like 或标量

需要其以 10 为底的对数的值。

返回值：

outndarray 或标量

x值的以 10 为底的对数。如果x是标量，则out也是标量，否则返回一个数组对象。

另请参阅

numpy.log10

注意事项

对于 log10()在真实x < 0时返回NAN的情况，请使用numpy.log10（不过，请注意，否则numpy.log10和这个log10是相同的，即对于x = 0，两者都返回-inf，对于x = inf，都返回inf，特别地，如果x.imag != 0，则返回复数主值）。

示例

（我们设置了打印精度，以便自动测试示例）

>>> np.set_printoptions(precision=4)

>>> np.emath.log10(10**1)
1.0

>>> np.emath.log10([-10**1, -10**2, 10**2])
array([1.+1.3644j, 2.+1.3644j, 2.+0.j    ])

`numpy.emath.power`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.power.html

emath.power(x, p)

将 x 提高到幂 p，(x**p)。

如果x包含负值，则输出将转换为复数域。

参数：

x数组样式

输入值。

p int 的数组样式

将x提高到的幂。如果x包含多个值，则p必须是标量，或者包含与x相同数量的值。在后一种情况下，结果是x[0]**p[0], x[1]**p[1], ...。

out ndarray 或标量

x**p的结果。如果x和p是标量，则out也是标量，否则返回数组。

另请参阅

numpy.power

示例

>>> np.set_printoptions(precision=4)

>>> np.emath.power([2, 4], 2)
array([ 4, 16])
>>> np.emath.power([2, 4], -2)
array([0.25  ,  0.0625])
>>> np.emath.power([-2, 4], 2)
array([ 4.-0.j, 16.+0.j])

`numpy.emath.arccos`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.arccos.html

emath.arccos(x)

计算x的反余弦。

返回x的反余弦的“主值”（关于此的描述，请参见numpy.arccos）。对于实数x，使得abs(x) <= 1，这是一个闭区间([0, \pi])中的实数。否则，返回复数的主值。

参数：

x 类似数组或标量

需要其 arccos 的值。

返回值：

out ndarray 或标量

x值的反余弦。如果x是标量，则out也是如此，否则将返回一个数组对象。

另请参阅

numpy.arccos

注意事项

对于一个返回NAN的 arccos()，当实数x不在区间[-1,1]时，请使用numpy.arccos。

示例

>>> np.set_printoptions(precision=4)

>>> np.emath.arccos(1) # a scalar is returned
0.0

>>> np.emath.arccos([1,2])
array([0.-0.j   , 0.-1.317j])

`numpy.emath.arcsin`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.arcsin.html

emath.arcsin(x)

计算 x 的反正弦。

返回 x 的反正弦的“主值”（有关此主值的描述，请参见 numpy.arcsin）。对于实数 x 使得 abs(x) <= 1，这是一个闭区间内的实数 ([-\pi/2, \pi/2])。否则，返回复数的主值。

参数：

x，array_like 或标量

需要计算反正弦的值。

返回值：

out，ndarray 或标量

x 值的反正弦。如果 x 是标量，则 out 也是标量，否则将返回数组对象。

另请参见

numpy.arcsin

注意事项

对于一个 arcsin() 当实数 x 不在区间[-1,1]时返回 NAN，请使用 numpy.arcsin。

示例

>>> np.set_printoptions(precision=4)

>>> np.emath.arcsin(0)
0.0

>>> np.emath.arcsin([0,1])
array([0\.    , 1.5708])

`numpy.emath.arctanh`

原文：numpy.org/doc/1.26/reference/generated/numpy.emath.arctanh.html

emath.arctanh(x)

计算 x 的反双曲正切值。

返回arctanh(x)的“主值”（关于此的描述，请参见numpy.arctanh）。对于实数 x，使得 abs(x) < 1，这将是一个实数。如果 abs(x) > 1，或者 x 为复数，则结果为复数。最后，x = 1返回inf，x=-1返回-inf。

参数：

x类数组

需要求其反双曲正切值的值（们）。

out数组或标量

x 值的反双曲正切值。如果 x 是标量，则 out 也是标量，否则返回一个数组。

也见

numpy.arctanh

注释

对于 NAN 返回的反双曲正切值在实际 x 不在区间 (-1,1)时，请使用numpy.arctanh(然而，对于 x = +/-1，此后者返回 +/-inf)。

示例

>>> np.set_printoptions(precision=4)

>>> from numpy.testing import suppress_warnings
>>> with suppress_warnings() as sup:
...     sup.filter(RuntimeWarning)
...     np.emath.arctanh(np.eye(2))
array([[inf,  0.],
 [ 0., inf]])
>>> np.emath.arctanh([1j])
array([0.+0.7854j])

浮点错误处理

原文：numpy.org/doc/1.26/reference/routines.err.html

设置和获取错误处理

`seterr`([all, divide, over, under, invalid])	设置处理浮点错误的方式。
`geterr`()	获取当前处理浮点错误的方式。
`seterrcall`(func)	设置浮点错误回调函数或日志对象。
`geterrcall`()	返回当前用于浮点错误的回调函数。
`errstate`(**kwargs)	用于处理浮点错误的上下文管理器。

内部函数

`seterrobj`(errobj, /)	设置定义浮点错误处理的对象。
`geterrobj`()	返回定义浮点错误处理的当前对象。

设置和获取错误处理

`seterr`([all, divide, over, under, invalid])	设置处理浮点错误的方式。
`geterr`()	获取当前处理浮点错误的方式。
`seterrcall`(func)	设置浮点错误回调函数或日志对象。
`geterrcall`()	返回当前用于浮点错误的回调函数。
`errstate`(**kwargs)	用于处理浮点错误的上下文管理器。

内部函数

`seterrobj`(errobj, /)	设置定义浮点错误处理的对象。
`geterrobj`()	返回定义浮点错误处理的当前对象。

`numpy.seterr`

原文：numpy.org/doc/1.26/reference/generated/numpy.seterr.html

numpy.seterr(all=None, divide=None, over=None, under=None, invalid=None)

设置浮点错误的处理方式。

注意，对整数标量类型（例如int16）的操作与浮点数类型相同，并且受到这些设置的影响。

参数：

all{‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}，可选

一次性设置所有类型的浮点错误处理方式：

ignore：当异常发生时不采取任何操作。
warn：通过 Python warnings模块打印RuntimeWarning。
raise：引发FloatingPointError。
调用：使用seterrcall函数指定调用一个函数。
print：直接在stdout上打印警告。
log：记录由seterrcall指定的 Log 对象中的错误。

默认情况下不更改当前行为。

divide{‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}，可选

除零处理方式。

over{‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}，可选

浮点溢出的处理方式。

under{‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}，可选

浮点下溢处理方式。

invalid{‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}，可选

无效浮点操作的处理方式。

old_settingsdict

包含旧设置的字典。

另请参见

seterrcall

设置“call”模式的回调函数。

geterr，geterrcall，errstate

注意事项

浮点异常在 IEEE 754 标准[1]中定义：

除零：从有限数得到无限结果。
溢出：结果太大无法表示。
下溢：结果接近零，导致丢失了一些精度。
无效操作：结果不是可表示的数字，通常表示产生了 NaN。

[1]

en.wikipedia.org/wiki/IEEE_754

示例

>>> old_settings = np.seterr(all='ignore')  #seterr to known value
>>> np.seterr(over='raise')
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
>>> np.seterr(**old_settings)  # reset to default
{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}

>>> np.int16(32000) * np.int16(3)
30464
>>> old_settings = np.seterr(all='warn', over='raise')
>>> np.int16(32000) * np.int16(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FloatingPointError: overflow encountered in scalar multiply

>>> old_settings = np.seterr(all='print')
>>> np.geterr()
{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
>>> np.int16(32000) * np.int16(3)
30464