# 数据类型对象 (`dtype`)¶

1. 数据类型（整数，浮点数，Python对象等）
2. 数据的大小（例如整数中有多少字节）
3. 数据的字节顺序 (little-endianbig-endian)
4. 如果数据类型是结构化的，则是其他数据类型的集合（如描述由整数和浮点数组成的数组项）,
1. 结构有哪些名称的 字段 可以访问
2. 每个 ‘字段’ 的数据类型是什么
3. 每个字段占用了内存块哪个部分
5. 如果数据类型是子数组，那么它的形状和数据类型是什么

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

```>>> dt = np.dtype([('name', np.unicode_, 16), ('grades', np.float64, (2,))])
>>> dt['name']
dtype('|U16')
dtype(('float64',(2,)))
```

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

## 指定和构造数据类型¶

 `dtype` Create a data type object.

`dtype` object

`None`

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

 `int` `int_` `bool` `bool_` `float` `float_` `complex` `cfloat` `bytes` `bytes_` `str` `bytes_` (Python2) or `unicode_` (Python3) `unicode` `unicode_` `buffer` `void` (all others) `object_`

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

`.dtype` 的类型

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

 `'?'` boolean `'b'` (signed) byte `'B'` unsigned byte `'i'` (signed) integer `'u'` unsigned integer `'f'` floating-point `'c'` complex-floating point `'m'` timedelta `'M'` datetime `'O'` (Python) objects `'S'`, `'a'` zero-terminated bytes (not recommended) `'U'` Unicode string `'V'` raw data (`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-length zero-terminated bytes
>>> dt = np.dtype('U25')  # 25-character string
```

• 名为 `f0` 的字段，包含32位整数
• 名为 `f1` 的字段，包含一个2 x 3的64位浮点数子数组
• 名为 `f2` 的字段，包含32位浮点数
```>>> dt = np.dtype("i4, (2,3)f8, f4")
```
• 名为 `f0` 的字段，包含3个字符的字符串
• 名为 `f1` 的字段，包含一个包含64位无符号整数的shape(3,)子数组
• 名为 `f2` 包含一个 3 x 4 的子数组包含了10个字符串
```>>> 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((np.void, 10))  # 10-byte wide data block
>>> dt = np.dtype(('U', 10))   # 10-character unicode string
```

`(fixed_dtype, shape)`

```>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('U10', 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元组的字符串，其中第一个字符串是 “title” （可以是任何字符串或unicode字符串） 或任何对象字段的元数据，第二个字符串是 “name” 必须是有效的Python标识符。

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

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

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

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

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

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

`{'field1': ..., 'field2': ..., ...}`

obj 应该包含引用``(data-type, offset)`` 或 `(data-type, offset, title)` 元组的字符串或unicode键。

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

`(base_dtype, new_dtype)`

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位整数，包含字段r，g，b，a，将整数中的4个字节解释为四个无符号整数：

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

## `dtype`¶

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

### Attributes¶

 `dtype.type` The type object used to instantiate a scalar of this data-type. `dtype.kind` A character code (one of ‘biufcmMOSUV’) identifying the general kind of data. `dtype.char` A unique character code for each of the 21 different built-in types. `dtype.num` A unique number for each of the 21 different built-in types. `dtype.str` The array-protocol typestring of this data-type object.

 `dtype.name` A bit-width name for this data-type. `dtype.itemsize` The element size of this data-type object.

 `dtype.byteorder` A character indicating the byte-order of this data-type object.

 `dtype.fields` Dictionary of named fields defined for this data type, or `None`. `dtype.names` Ordered list of field names, or `None` if there are no fields.

 `dtype.subdtype` Tuple `(item_dtype, shape)` if this `dtype` describes a sub-array, and None otherwise. `dtype.shape` Shape tuple of the sub-array if this data type describes a sub-array, and `()` otherwise.

 `dtype.hasobject` Boolean indicating whether this dtype contains any reference-counted objects in any fields or sub-dtypes. `dtype.flags` Bit-flags describing how this data type is to be interpreted. `dtype.isbuiltin` Integer indicating how this dtype relates to the built-in dtypes. `dtype.isnative` Boolean indicating whether the byte order of this dtype is native to the platform. `dtype.descr` PEP3118 interface description of the data-type. `dtype.alignment` The required alignment (bytes) of this data-type according to the compiler.

### 方法¶

 `dtype.newbyteorder`([new_order]) Return a new dtype with a different byte order.

The following methods implement the pickle protocol:

 `dtype.__reduce__` helper for pickle `dtype.__setstate__`