标量#

Python 只定义了特定数据类的一种类型（只有一种整数类型、一种浮点类型等）。这对于不需要关心数据在计算机中表示的所有方式的应用程序来说非常方便。然而，对于科学计算来说，通常需要更多的控制。

在 NumPy 中，有 24 种新的基本 Python 类型来描述不同类型的标量。这些类型描述符主要基于编写 CPython 的 C 语言中可用的类型，还有一些与 Python 类型兼容的附加类型。

数组标量具有与相同的属性和方法ndarrays。[ 1 ]这允许人们在与数组相同的基础上部分地处理数组的项目，从而平滑混合标量和数组操作时产生的粗糙边缘。

数组标量存在于数据类型的层次结构中（参见下图）。可以使用层次结构来检测它们：例如，如果val是数组标量对象，则将返回。或者，可以使用数据类型层次结构的其他成员来确定存在哪种类型的数组标量。因此，例如，如果val是复值类型，则返回 true ，而如果val是灵活的项大小数组类型（、、）之一，则返回 true 。isinstance(val, np.generic)Trueisinstance(val, np.complexfloating)Trueisinstance(val, np.flexible)str_bytes_void

../_images/dtype-hierarchy.png — 图：表示数组数据类型的类型对象的层次结构。未显示的是两种整数类型`intp`， `uintp`它们仅指向保存平台指针的整数类型。所有数字类型也可以使用位宽名称来获取。#

内置标量类型#

内置标量类型如下所示。类似 C 的名称与字符代码相关联，这些代码显示在其描述中。然而，不鼓励使用字符代码。

一些标量类型本质上等同于基本 Python 类型，因此继承自它们以及泛型数组标量类型：

数组标量类型	相关Python类型	继承？
`int_`	`int`	仅限 Python 2
`float_`	`float`	是的
`complex_`	`complex`	是的
`bytes_`	`bytes`	是的
`str_`	`str`	是的
`bool_`	`bool`	不
`datetime64`	`datetime.datetime`	不
`timedelta64`	`datetime.timedelta`	不

该bool_数据类型与 Python 非常相似， bool但不能继承它，因为 Python bool不允许自己继承，并且在 C 级别上，实际 bool 数据的大小与 Python 布尔标量不同。

警告

在Python 3下，该int_类型不再继承自 int内置类型，因为类型int不再是固定宽度的整数类型。

提示

NumPy 中的默认数据类型是float_.

类 numpy.通用[来源] #

numpy 标量类型的基类。

大多数（所有？）numpy 标量类型都派生自该类。为了保持一致性，公开与相同的 API ndarray，尽管许多后续属性要么是“仅获取”，要么完全不相关。强烈建议用户从该类派生自定义标量类型。

类 numpy.数字[来源] #: 所有数值标量类型的抽象基类。

整数类型#

类 numpy.整数[来源] #: 所有整数标量类型的抽象基类。

笔记

numpy 整数类型反映了 C 整数的行为，因此可能会出现溢出错误。

有符号整数类型#

类 numpy.有符号整数[来源] #: 所有有符号整数标量类型的抽象基类。

类 numpy.字节[来源] #

有符号整数类型，与 C 兼容char。

字符代码：: 'b'
该平台上的别名 (Linux x86_64) ：: numpy.int8：8 位有符号整数 (-128到127)。

类 numpy.短[来源] #

有符号整数类型，与 C 兼容short。

字符代码：: 'h'
该平台上的别名 (Linux x86_64) ：: numpy.int16: 16 位有符号整数 (-32_768到32_767)。

类 numpy. intc [来源] #

有符号整数类型，与 C 兼容int。

字符代码：: 'i'
该平台上的别名 (Linux x86_64) ：: numpy.int32: 32 位有符号整数 (-2_147_483_648到2_147_483_647)。

类 numpy. int_ [来源] #

有符号整数类型，兼容 Python int和 C long。

字符代码：: 'l'
该平台上的别名 (Linux x86_64) ：: numpy.int64：64 位有符号整数 (-9_223_372_036_854_775_808到9_223_372_036_854_775_807)。
该平台上的别名 (Linux x86_64) ：: numpy.intp：足够大以容纳指针的有符号整数，与 C 兼容intptr_t。

类 numpy.龙龙[来源] #

有符号整数类型，与 C 兼容。long long

字符代码：: 'q'

无符号整数类型#

类 numpy.无符号整数[来源] #: 所有无符号整数标量类型的抽象基类。

类 numpy. ubyte [来源] #

无符号整数类型，与 C 兼容。unsigned char

字符代码：: 'B'
该平台上的别名 (Linux x86_64) ：: numpy.uint8: 8 位无符号整数 (0到255)。

类 numpy. ushort [来源] #

无符号整数类型，与 C 兼容。unsigned short

字符代码：: 'H'
该平台上的别名 (Linux x86_64) ：: numpy.uint16: 16 位无符号整数 (0到65_535)。

类 numpy. uintc [来源] #

无符号整数类型，与 C 兼容。unsigned int

字符代码：: 'I'
该平台上的别名 (Linux x86_64) ：: numpy.uint32: 32 位无符号整数 (0到4_294_967_295)。

类 numpy. uint [来源] #

无符号整数类型，与 C 兼容。unsigned long

字符代码：: 'L'
该平台上的别名 (Linux x86_64) ：: numpy.uint64：64 位无符号整数 (0至18_446_744_073_709_551_615)。
该平台上的别名 (Linux x86_64) ：: numpy.uintp：无符号整数足以容纳指针，与 C 兼容uintptr_t。

类 numpy.乌龙龙[来源] #

有符号整数类型，与 C 兼容。unsigned long long

字符代码：: 'Q'

不精确的类型#

类 numpy.不精确[来源] #: 所有数值标量类型的抽象基类，具有（可能）不精确表示其范围内的值，例如浮点数。

笔记

通过明智的舍入，使用最少的十进制数字来打印不精确的标量，以将其值与相同数据类型的其他值区分开来。参见和unique的参数。format_float_positionalformat_float_scientific

这意味着具有相同二进制值但数据类型具有不同精度的变量可能显示不同：

>>> f16 = np.float16("0.1")
>>> f32 = np.float32(f16)
>>> f64 = np.float64(f32)
>>> f16 == f32 == f64
True
>>> f16, f32, f64
(0.1, 0.099975586, 0.0999755859375)

请注意，这些浮点数都不包含准确的值\(\frac{1}{10}\); f16打印为0.1因为它尽可能接近该值，而其他类型则不然，因为它们具有更高的精度，因此具有更接近的值。

相反，尽管打印相同，但近似相同十进制值的不同精度的浮点标量可能比较不相等：

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

浮点类型#

类 numpy.浮动[来源] #: 所有浮点标量类型的抽象基类。

类 numpy.一半[来源] #

半精度浮点数类型。

字符代码：: 'e'
该平台上的别名 (Linux x86_64) ：: numpy.float16：16位精度浮点数类型：符号位，5位指数，10位尾数。

类 numpy.单一来源]＃

单精度浮点数类型，与 C 兼容float。

字符代码：: 'f'
该平台上的别名 (Linux x86_64) ：: numpy.float32：32位精度浮点数类型：符号位，8位指数，23位尾数。

类 numpy. double ( x = 0 , / ) [来源] #

双精度浮点数类型，兼容Python float 和 C double。

字符代码：: 'd'
别名：: numpy.float_
该平台上的别名 (Linux x86_64) ：: numpy.float64：64位精度浮点数类型：符号位，11位指数，52位尾数。

类 numpy. longdouble [来源] #

扩展精度浮点数类型，与 C 兼容，但不一定与 IEEE 754 四倍精度兼容。long double

字符代码：: 'g'
别名：: numpy.longfloat
该平台上的别名 (Linux x86_64) ：: numpy.float128：128位扩展精度浮点数类型。

复杂浮点类型#

类 numpy.复杂浮动[来源] #: 所有由浮点数组成的复数标量类型的抽象基类。

类 numpy. csingle [来源] #

由两个单精度浮点数组成的复数类型。

字符代码：: 'F'
别名：: numpy.singlecomplex
该平台上的别名 (Linux x86_64) ：: numpy.complex64：由2个32位精度浮点数组成的复数类型。

类 numpy. cdouble ( real = 0 , imag = 0 ) [来源] #

由两个双精度浮点数组成的复数类型，与Python的complex兼容。

字符代码：: 'D'
别名：: numpy.cfloat
别名：: numpy.complex_
该平台上的别名 (Linux x86_64) ：: numpy.complex128：由2个64位精度浮点数组成的复数类型。

类 numpy. clongdouble [来源] #

由两个扩展精度浮点数组成的复数类型。

字符代码：: 'G'
别名：: numpy.clongfloat
别名：: numpy.longcomplex
该平台上的别名 (Linux x86_64) ：: numpy.complex256：由2个128位扩展精度浮点数组成的复数类型。

其他类型#

类 numpy. bool_ [来源] #

布尔类型（True 或 False），存储为字节。

警告

该bool_类型不是该int_类型的子类（bool_甚至不是数字类型）。这与 Pythonbool作为的子类的默认实现不同int。

字符代码：: '?'

类 numpy. datetime64 [来源] #

如果从 64 位整数创建，则它表示相对于的偏移量 1970-01-01T00:00:00。如果从字符串创建，则该字符串可以采用 ISO 8601 日期或日期时间格式。

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

有关详细信息，请参阅日期时间和时间增量。

字符代码：: 'M'

类 numpy. timedelta64 [来源] #

存储为 64 位整数的时间增量。

有关详细信息，请参阅日期时间和时间增量。

字符代码：: 'm'

类 numpy.对象_ [来源] #

任何 Python 对象。

字符代码：: 'O'

笔记

实际存储在对象数组（即具有 dtype 的数组）中的数据object_是对 Python 对象的引用，而不是对象本身。因此，对象数组的行为更像通常的 Python lists，因为它们的内容不必是相同的 Python 类型。

对象类型也很特殊，因为包含 object_项目的数组在项目访问时不会返回object_对象，而是返回数组项目引用的实际对象。

以下数据类型是灵活的：它们没有预定义的大小，并且它们描述的数据在不同的数组中可以具有不同的长度。（字符代码中#是一个整数，表示该数据类型由多少个元素组成。）

类 numpy.灵活[来源] #: 所有标量类型的抽象基类，没有预定义长度。这些类型的实际大小取决于特定的np.dtype 实例化。

类 numpy.字符[来源] #: 所有字符串标量类型的抽象基类。

类 numpy.字节_ [来源] #

一个字节字符串。

当在数组中使用时，此类型会go除尾随空字节。

字符代码：: 'S'
别名：: numpy.string_

类 numpy. str_ [来源] #

一个 unicode 字符串。

此类型会go除尾随的空代码点。

>>> s = np.str_("abc\x00")
>>> s
'abc'

与内置str不同，它支持Buffer Protocol，将其内容公开为 UCS4：

>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'

字符代码：: 'U'
别名：: numpy.unicode_

类 numpy. void ( length_or_data , / , dtype = None ) [来源] #

创建新的结构化或非结构化空标量。

参数：

length_or_data int、类数组、类字节、对象: 多种含义之一（见注释）。非结构化 void 的长度或字节数据。或者，dtype 提供时要存储在新标量中的数据。这可以是类似数组的，在这种情况下可能会返回一个数组。
数据类型数据类型，可选: 如果提供新标量的数据类型。该数据类型必须是“void”数据类型（即结构化或非结构化空值，另请参阅结构化数据类型）。

..版本添加:: 1.24

笔记

由于历史原因，并且因为 void 标量可以表示任意字节数据和结构化数据类型，所以 void 构造函数具有三种调用约定：

np.void(5)创建一个dtype="V5"充满五个 \0字节的标量。 5 可以是 Python 或 NumPy 整数。
np.void(b"bytes-like")从字节字符串创建一个 void 标量。 dtype itemsize 将与字节字符串长度匹配，此处为"V10"。
当传递 a 时，dtype=调用与数组创建大致相同。但是，返回的是 void 标量而不是数组。

请参阅显示所有三种不同约定的示例。

例子

>>> np.void(5)
void(b'\x00\x00\x00\x00\x00')
>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')
>>> np.void((5, 3.2, "eggs"), dtype="i,d,S5")
(5, 3.2, b'eggs')  # looks like a tuple, but is `np.void`
>>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
(3, 3)  # looks like a tuple, but is `np.void`

字符代码：: 'V'

警告

请参阅有关字符串类型的注释。

数字兼容性：如果您在数字代码中使用了旧的类型代码字符（从未推荐），则需要将其中一些更改为新字符。特别是，所需的更改是、、、、和。这些更改使类型字符约定与其他 Python 模块（例如 module.txt）更加一致。c -> S1b -> B1 -> bs -> hw -> Hu -> Istruct

大小别名#

除了它们（大部分）源自 C 的名称外，还可以使用位宽约定使用整数、浮点和复杂数据类型，以便始终确保数组大小正确。还提供了两个别名（numpy.intp和numpy.uintp），它们指向足够大以容纳 C 指针的整数类型。

麻木的。int8 [来源] #

麻木的。int16 #

麻木的。int32 #

麻木的。int64 #

具有指定位数的有符号整数类型（ numpy.byte、numpy.short、 numpy.intc和之一）的别名numpy.int_。numpy.longlong

分别与 C99 int8_t、int16_t、int32_t和兼容int64_t。

麻木的。uint8 [来源] #

麻木的。uint16 #

麻木的。uint32 #

麻木的。uint64 #

numpy.ubyte具有指定位数的无符号整数类型（、numpy.ushort、 numpy.uintc和之一numpy.uint）numpy.ulonglong的别名。

分别与 C99 uint8_t、uint16_t、uint32_t和兼容uint64_t。

麻木的。intp [来源] #

numpy.byte有符号整数类型（、numpy.short、 numpy.intc和np.longlong之一）的别名，numpy.int_其大小与指针相同。

与 C 兼容intptr_t。

字符代码：: 'p'

麻木的。uintp [来源] #

numpy.ubyte无符号整数类型（、numpy.ushort、 numpy.uintc和np.ulonglong之一）的别名，numpy.uint其大小与指针相同。

与 C 兼容uintptr_t。

字符代码：: 'P'

麻木的。float16 [来源] #: 的别名half

麻木的。float32 [来源] #: 的别名single

麻木的。float64 [来源] #: 的别名double

麻木的。浮动96 #
麻木的。float128 [来源] #: 的别名numpy.longdouble，以其位大小命名。这些别名的存在取决于平台。

麻木的。Complex64 [来源] #: 的别名csingle

麻木的。Complex128 [来源] #: 的别名cdouble

麻木的。复杂192 #
麻木的。Complex256 [来源] #: 的别名numpy.clongdouble，以其位大小命名。这些别名的存在取决于平台。

其他别名#

其中前两个是类似于内置类型名称的便利方法，其风格与bool_, int_, str_, bytes_, 和相同object_：

麻木的。float_ [来源] #: 的别名double

麻木的。复杂_ [来源] #: 的别名cdouble

还有一些使用扩展精度浮点数和复数的替代命名约定：

麻木的。长浮点[来源] #: 的别名longdouble

麻木的。单复合体[来源] #: 的别名csingle

麻木的。cfloat [来源] #: 的别名cdouble

麻木的。长复合体[来源] #: 的别名clongdouble

麻木的。clongfloat [来源] #: 的别名clongdouble

以下别名源自Python 2，建议不要在新代码中使用它们。

麻木的。字符串_ [来源] #: 的别名bytes_

麻木的。unicode_ [来源] #: 的别名str_

属性＃

数组标量对象的值为( -1,000,000.0)。它们还没有属性。否则，它们与数组共享相同的属性：array priorityNPY_SCALAR_PRIORITYctypes

`generic.flags`	标志的整数值。
`generic.shape`	数组维度的元组。
`generic.strides`	每个维度中的字节元组步骤。
`generic.ndim`	数组维数。
`generic.data`	指向数据开始的指针。
`generic.size`	基因型中的元素数量。
`generic.itemsize`	一个元素的长度（以字节为单位）。
`generic.base`	标量属性与相应的数组属性相同。
`generic.dtype`	获取数组数据描述符。
`generic.real`	标量的实部。
`generic.imag`	标量的虚部。
`generic.flat`	标量的一维视图。
`generic.T`	标量属性与相应的数组属性相同。
`generic.__array_interface__`	数组协议：Python端
`generic.__array_struct__`	数组协议：struct
`generic.__array_priority__`	数组优先级。
`generic.__array_wrap__`	sc.__array_wrap__(obj) 从数组返回标量

索引#

也可以看看

索引例程、数据类型对象 (dtype)

数组标量可以像 0 维数组一样进行索引：如果x是数组标量，

x[()]返回数组标量的副本
x[...]返回 0 维ndarray
x['field-name']返回字段field-name中的数组标量。（x可以具有字段，例如，当它对应于结构化数据类型时。）

方法＃

数组标量具有与数组完全相同的方法。这些方法的默认行为是在内部将标量转换为等效的 0 维数组并调用相应的数组方法。此外，定义了数组标量上的数学运算，以便设置相同的硬件标志并用于解释ufunc的结果，以便用于 ufunc 的错误状态也可以转移到数组标量上的数学上。

上述规则的例外情况如下：

`generic.__array__`	sc.__array__(dtype) 从具有指定 dtype 的标量返回 0-dim 数组
`generic.__array_wrap__`	sc.__array_wrap__(obj) 从数组返回标量
`generic.squeeze`	标量方法与相应的数组属性相同。
`generic.byteswap`	标量方法与相应的数组属性相同。
`generic.__reduce__`	泡菜的好帮手。
`generic.__setstate__`
`generic.setflags`	标量方法与相应的数组属性相同。

输入的实用方法：

number.__class_getitem__（物品， /）

返回类型的参数化包装器number。

定义新类型#

有两种方法可以有效地定义新的数组标量类型（除了从内置标量类型组合结构化类型数据类型 ndarray之外）：一种方法是简单地子类化并覆盖感兴趣的方法。这在一定程度上有效，但在内部某些行为是由数组的数据类型固定的。要完全自定义数组的数据类型，您需要定义一个新的数据类型，并将其注册到 NumPy。此类新类型只能使用NumPy C-API在 C 中定义。