数据类型对象（dtype）

数据类型对象（numpy.dtype类的一个实例）描述了应如何解释与数组项对应的固定大小内存块中的字节。它描述了数据的以下方面：

1. 数据的类型（整数，浮点数，Python对象等）
2. 数据大小（例如， 整数使用多少个字节存储）
3. 数据的字节顺序（little-endian或big-endian））
4. 如果数据类型是structured，则其他数据类型（，例如，描述由整数和浮点数组成的数组项）的集合
   1. 该结构的“字段”的名称是什么，它们可以被accessed，
   2. 每个字段的数据类型是什么，以及
   3. 每个字段占用哪部分内存块。
5. 如果数据类型是子数组，它的形状和数据类型是什么。

为了描述标量数据的类型，在NumPy中有多个built-in scalar types，用于各种整数精度，浮点数，等。通过索引从数组中提取的项目，例如将是一个Python对象，其类型是与数组的数据类型关联的标量类型。

请注意，标量类型不是dtype对象，即使在NumPy中需要数据类型规范时，它们也可以用来代替它。

结构化数据类型是通过创建其字段包含其他数据类型的数据类型形成的。每个字段都有一个可以被accessed的名称。父数据类型应该具有足够的大小以包含其所有字段；父类几乎总是基于允许任意大小的void类型。结构化数据类型也可以在其字段中包含嵌套的结构化子数组数据类型。

最后，数据类型可以描述其本身是另一种数据类型的项目数组的项目。但是，这些子阵列必须具有固定的大小。

如果使用描述子数组的数据类型创建数组，则在创建数组时，子数组的维将附加到数组的形状中。结构化类型字段中的子数组的行为有所不同，请参阅Field Access。

子数组总是有一个C连续的内存布局。

例

一个简单的数据类型，包含一个32位的big-endian整数：（关于构造细节，请参阅Specifying and constructing data types）

>>> dt = np.dtype('>i4')
>>> dt.byteorder
'>'
>>> dt.itemsize
4
>>> dt.name
'int32'
>>> dt.type is np.int32
True

相应的数组标量类型是int32。

例

包含16个字符的字符串（在字段'name'中）和一个由两个64位浮点数（字段'等级'）组成的子数组的结构化数据类型：

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt['name']
dtype('|S16')
>>> dt['grades']
dtype(('float64',(2,)))

此数据类型的数组项包装在一个array scalar类型中，该类型也有两个字段：

>>> x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
>>> x[1]
('John', [6.0, 7.0])
>>> x[1]['grades']
array([ 6.,  7.])
>>> type(x[1])
<type 'numpy.void'>
>>> type(x[1]['grades'])
<type 'numpy.ndarray'>

指定和构造数据类型

只要NumPy函数或方法需要数据类型，就可以提供dtype对象或可以转换为一个对象的东西。这种转换由dtype构造函数完成：

dtype

创建一个数据类型对象。

下面介绍可以转换为数据类型对象的内容：

dtype对象

原样使用。

None

默认数据类型：float_。

数组标量类型

24个内置的array scalar type objects全部转换为关联的数据类型对象。对于他们的子类也是如此。

请注意，并非所有数据类型信息都可以提供一个类型对象：例如，flexible数据类型的默认itemsize为0，并且需要明确给定大小是有用的。

例

>>> dt = np.dtype(np.int32)      # 32-bit integer
>>> dt = np.dtype(np.complex128) # 128-bit complex floating-point number

泛型类型

通用分层类型对象根据关联转换为相应的类型对​​象：

number，inexact，floating	float
complexfloating	cfloat
integer，signedinteger	int_
unsignedinteger	uint
character	string
generic，flexible	void

内置的Python类型

当用于生成dtype对象时，多个python类型相当于相应的数组标量：

int	int_
bool	bool_
float	float_
complex	cfloat
str	string
unicode	unicode_
buffer	void
（所有其他对象）	object_

例

>>> dt = np.dtype(float)   # Python-compatible floating-point number
>>> dt = np.dtype(int)     # Python-compatible integer
>>> dt = np.dtype(object)  # Python object

使用.dtype的类型

任何具有dtype属性的类型对象：该属性将被直接访问和使用。该属性必须返回可转换为dtype对象的内容。

几种字符串可以被转换。Recognized strings can be prepended with '>' (big-endian), '<' (little-endian), or '=' (hardware-native, the default), to specify the byte order.

一个字符的字符串

每个内置数据类型都有一个字符代码（更新后的数字类型代码），用于唯一标识它。

例

>>> dt = np.dtype('b')  # byte, native byte order
>>> dt = np.dtype('>H') # big-endian unsigned short
>>> dt = np.dtype('<f') # little-endian single-precision float
>>> dt = np.dtype('d')  # double-precision floating-point number

数组协议类型字符串（请参阅The Array Interface）

第一个字符指定数据类型，其余字符指定每个项目的字节数，Unicode除外，其中它被解释为字符数。项目大小必须与现有类型相对应，否则会引发错误。支持的种类是

'b'	布尔
'i'	（带符号）整数
'u'	无符号整数
'f'	浮点
'c'	复杂浮点
'm'	timedelta
'm'	datetime
'O'	（Python）对象
'S', 'a'	（字节级）字符串
'u'	统一
'V'	原始数据（void）

例

>>> dt = np.dtype('i4')   # 32-bit signed integer
>>> dt = np.dtype('f8')   # 64-bit floating-point number
>>> dt = np.dtype('c16')  # 128-bit complex floating-point number
>>> dt = np.dtype('a25')  # 25-character string

带逗号分隔字段的字符串

用于指定结构化数据类型格式的简写符号是逗号分隔的基本格式字符串。

此上下文中的基本格式是一个可选的形式说明符，后跟一个数组协议类型字符串。如果该形状具有多个维度，则需要在该形状上使用括号。NumPy允许对格式进行修改，因为任何可唯一标识类型的字符串都可用于指定字段中的数据类型。The generated data-type fields are named 'f0', 'f1', ..., 'f<N-1>' where N (>1) is the number of comma-separated basic formats in the string. 如果提供了可选的形状说明符，则相应字段的数据类型将描述一个子数组。

例

• 包含32位整数的名为f0的字段
• 字段名为f1，其中包含一个由64位浮点数组成的2 x 3子数组
• 包含一个32位浮点数的名为f2的字段

>>> dt = np.dtype("i4, (2,3)f8, f4")

• 名为f0的字段包含一个3个字符的字符串
• 名为f1的字段包含形状为（3，）的子数组，其中包含64位无符号整数
• 名为f2的字段包含一个包含10个字符的字符串的3 x 4子数组

>>> dt = np.dtype("a3, 3u8, (3,4)a10")

键入字符串

numpy.sctypeDict .keys()中的任何字符串：

例

>>> dt = np.dtype('uint32')   # 32-bit unsigned integer
>>> dt = np.dtype('Float64')  # 64-bit floating-point number

（flexible_dtype， itemsize）

第一个参数必须是转换为零大小的灵活数据类型对象的对象，第二个参数是提供所需项目大小的整数。

例

>>> dt = np.dtype((void, 10))  # 10-byte wide data block
>>> dt = np.dtype((str, 35))   # 35-character string
>>> dt = np.dtype(('U', 10))   # 10-character unicode string

（fixed_dtype， shape）

第一个参数是可以转换为固定大小的数据类型对象的任何对象。第二个参数是这种类型的所需形状。如果形状参数是1，那么数据类型对象相当于固定的dtype。如果shape是一个元组，则新的dtype定义给定形状的子数组。

例

>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('S10', 1))                 # 10-character string
>>> dt = np.dtype(('i4, (2,3)f8, f4', (2,3))) # 2 x 3 structured sub-array

[(field_name, field_dtype, field_shape), ...]

obj应该是一个字段列表，其中每个字段由长度为2或3的元组描述。（相当于__array_interface__属性中的descr项）。

第一个元素field_name是字段名称（如果这是''，则分配标准字段名称'f#'） 。字段名称也可以是字符串的2元组，其中第一个字符串是可以是任何对象的“标题”（可以是任何字符串或unicode字符串）或字段的元数据，第二个字符串是“名称”必须是有效的Python标识符。

第二个元素field_dtype可以是任何可以解释为数据类型的东西。

如果此字段表示第二个元素中的数据类型的数组，则可选的第三个元素field_shape包含形状。请注意，第三个参数等于1的三元组相当于一个2元组。

此样式不接受dtype构造函数中的align，因为假定所有内存都由数组接口描述考虑。

例

具有字段big（大端32位整数）和little（小端32位整数）的数据类型：

>>> dt = np.dtype([('big', '>i4'), ('little', '<i4')])

Data-type with fields R, G, B, A, each being an unsigned 8-bit integer:

>>> dt = np.dtype([('R','u1'), ('G','u1'), ('B','u1'), ('A','u1')])

{'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., 'itemsize': ...}

这种风格有两个必需和三个可选键。名称和格式键是必需的。它们各自的值是具有字段名称和字段格式的等长列表。字段名称必须是字符串，而字段格式可以是由dtype构造函数接受的任何对象。

当提供可选键offset和标题时，它们的值必须与名称和格式< / t3>列表。偏移量值是每个字段的字节偏移量（整数）列表，而titles值是每个字段的标题列表（None标题可以是任何string或unicode对象，并将添加另一个条目到标题所键入的字段字典中，并引用相同的字段元组将包含标题作为额外的元组成员。

itemsize键允许设置dtype的总大小，并且必须是足够大的整数，以便所有字段都在dtype内。如果构造的dtype是对齐的，则itemsize也必须可以被结构对齐整除。

例

数据类型包含字段r，g，b，a，每个都是8位无符号整数：

>>> dt = np.dtype({'names': ['r','g','b','a'],
...                'formats': [uint8, uint8, uint8, uint8]})

带有r和b（带给定标题）的数据类型，它们都是8位无符号整数，第一个位于字段开始的字节位置0处，第二位：

>>> dt = np.dtype({'names': ['r','b'], 'formats': ['u1', 'u1'],
...                'offsets': [0, 2],
...                'titles': ['Red pixel', 'Blue pixel']})

{'field1'： ...， 'field2'： ...， ...} T5> T0>

这种用法令人沮丧，因为它与其他基于字典的构造方法不一致。如果您有一个名为“名称”的字段和一个名为“格式”的字段，则会有冲突。

该样式允许传入数据类型对象的fields属性。

obj should contain string or unicode keys that refer to (data-type, offset) or (data-type, offset, title) tuples.

例

包含字段col1（字节位置0的10个字符的字符串），col2（字节位置10的32位浮点数据）和col3

>>> dt = np.dtype({'col1': ('S10', 0), 'col2': (float32, 10),
    'col3': (int, 14)})

（base_dtype， new_dtype）

在NumPy 1.7及更高版本中，该表单允许将base_dtype解释为结构化dtype。使用此dtype创建的数组将具有基础dtype base_dtype，但将具有来自new_dtype的字段和标志。这对于创建自定义结构化dtypes很有用，正如record arrays中所做的那样。

这种形式还可以指定带有重叠字段的struct dtypes，其功能类似于C中的'union'类型。然而，这种用法是不鼓励的，并且联合机制是优选的。

这两个参数必须可转换为具有相同总大小的数据类型对象。.. admonition ::例子

32位整数，前两个字节通过字段real解释为整数，以及后续两个字节通过字段imag解释。

>>> dt = np.dtype((np.int32,{'real':(np.int16, 0),'imag':(np.int16, 2)})

32位整数，它被解释为由包含8位整数的形状(4,)的子数组组成：

>>> dt = np.dtype((np.int32, (np.int8, 4)))

32位整数，包含解释整数中4个字节的字段r，g，b，a

>>> dt = np.dtype(('i4', [('r','u1'),('g','u1'),('b','u1'),('a','u1')]))

dtype

NumPy数据类型描述是dtype类的实例。

属性

数据类型由以下dtype属性描述：

dtype.type	用于实例化此数据类型的标量的类型对象。
dtype.kind	识别一般数据类型的字符代码（'biufcmMOSUV'之一）。
dtype.char	21种不同内置类型中的每一种的唯一字符代码。
dtype.num	21种不同内置类型中的每一种的唯一编号。
dtype.str	此数据类型对象的数组协议类型字符串。

数据的大小依次描述如下：

dtype.name	此数据类型的位宽名称。
dtype.itemsize	此数据类型对象的元素大小。

此数据的字节顺序：

dtype.byteorder

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

有关结构化数据类型中子数据类型的信息：

dtype.fields	为此数据类型定义的命名字段字典，或None。
dtype.names	有序的字段名称列表，如果没有字段，则None。

对于描述子数组的数据类型：

dtype.subdtype	Tuple (item_dtype, shape) if this dtype describes a sub-array, and None otherwise.
dtype.shape	如果此数据类型描述子数组，则为子数组的形状元组，否则为()。

提供附加信息的属性：

dtype.hasobject	布尔值，指示此dtype是否包含任何字段或子dtype中的引用计数对象。
dtype.flags	描述这种数据类型如何解释的位标志。
dtype.isbuiltin	整数指示这个dtype与内置dtypes的关系。
dtype.isnative	布尔值，指示此dtype的字节顺序是否是平台的本地顺序。
dtype.descr	数组接口符合数据类型的完整描述。
dtype.alignment	根据编译器所需的这种数据类型的对齐（字节）。

方法

数据类型具有以下用于更改字节顺序的方法：

dtype.newbyteorder

用不同的字节顺序返回一个新的dtype。

以下方法实现pickle协议：

dtype.__reduce__
dtype.__setstate__