Data type objects (dtype)

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

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

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

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

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

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

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

子数组总是具有C连续的存储器布局。

例

包含32位大端整数的简单数据类型：（有关构造的详细信息，请参见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位浮点数（在字段'grade'中）的子数组的结构化数据类型：

>>> 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'>

Specifying and constructing data types

每当在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.

单字符字符串

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

例

>>> 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'	（byte-）字符串
'U'	Unicode
'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允许对格式进行修改，因为任何可以唯一标识该类型的字符串都可以用于指定字段中的数据类型。所生成的数据类型字段被命名为'f0'，'f1'，...，'f<N-1>'如果提供了可选的形状说明符，则相应字段的数据类型描述子阵列。

例

• 包含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）

第一个参数是可以转换为固定大小的数据类型对象的任何对象。第二个参数是这种类型的所需形状。如果shape参数为1，则数据类型对象等效于fixed 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的第三自变量的3元组等价于2元组。

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

例

具有字段big（big-endian 32位整数）和little（小字节32位整数）的数据类型：

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

具有字段R，G，B，A的数据类型，每个都是无符号的8位整数：

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

{'names'： ...， 'formats'： ...， 'offsets'： ...， 'titles'： ...， 'itemsize'： ...}

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

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

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

例

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

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

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

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

{'field1'： ...， 'field2'： ...， ...}

不建议使用这种用法，因为它与其他基于dict的构造方法不明确。如果你有一个名为'names'的字段和一个名为'formats'的字段，则会有冲突。

此样式允许传递数据类型对象的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的字段和标志。这对于创建自定义结构化数据类型非常有用，如record arrays中所做。

这种形式还可以指定具有重叠字段的struct dtypes，其功能类似于C中的“union”类型。但是不建议使用这种用法，并且优选联合机制。

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

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类的实例。

Attributes

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

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

数据的大小又由以下描述：

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.flags	位标志描述如何解释此数据类型。
dtype.isbuiltin	整数指示此dtype如何与内置的dtype相关。
dtype.isnative	布尔值，指示此dtype的字节顺序是否为平台本地的。
dtype.descr	数组类型的数组接口完全描述。
dtype.alignment	根据编译器，此数据类型所需的对齐（字节）。

Methods

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

dtype.newbyteorder（[new_order]）

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

以下方法实现pickle协议：

dtype.__reduce__
dtype.__setstate__