NumPy 数据类型

1.常用 NumPy 基本类型

（1）bool_：布尔型数据类型（True 或者 False）

（2）int_：默认的整数类型（类似C 语言long，int32 或 int64）

（3）intc：与 C 语言的 int 类型相似，一般是 int32 或 int 64

（4）intp：用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）

（5）int8：字节（-128 to 127）

（6）int16：整数（-32768 to 32767）

（7）int32：整数（-2147483648 to 2147483647）

（8）int64：整数（-9223372036854775808 to 9223372036854775807）

（9）uint8：无符号整数（0 to 255）

（10）uint16：无符号整数（0 to 65535）

（11）uint32：无符号整数（0 to 4294967295）

（12）uint64：无符号整数（0 to 18446744073709551615）

（13）float_：float64 类型的简写

（14）float16：半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位

（15）float32     ：单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位

（16）float64：双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位

（17）complex_：complex128 类型，即 128 位复数

（18）complex64：复数，双 32 位浮点数（实数部分和虚数部分）

（19）complex128：复数，双 64 位浮点数（实数部分和虚数部分）

（20）numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

2数据类型对象 (dtype) 描述与数组对应的内存区域使用

字节顺序通过对数据类型预先设定 < 或 > 决定。 < 小端法(最小值存储在最小的地址，低位组放在最前面)。> 大端法(最重要的字节存储在最小的地址，高位组放在最前面)。

（1）数据的类型（整数，浮点数或者 Python 对象）

（2）数据的大小（例如， 整数使用多少个字节存储）

（3）数据的字节顺序（小端法或大端法）

（4）在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分

（5）如果数据类型是子数组，那么它的形状和数据类型是什么。

numpy.dtype(object, align, copy)

（1）object：要转换为的数据类型对象

（2）align：如果为 true，填充字段使其类似 C 的结构体。

（3）copy：复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

3.定义并查看 int32 类型的描述信息

import numpy as np
# 使用标量类型
dt = np.dtype(np.int32)
print(dt)

（1）导入 numpy 库：import numpy as np 将 numpy 库导入并简写为 np，方便后续使用。

（2）定义数据类型：np.dtype(np.int32) 创建了数据类型对象 dt，表示 32 位整型。np.int32 是 numpy 定义的 32 位整数类型，可以存储从 -2,147,483,648 到 2,147,483,647 之间的整数。

（3）输出数据类型：print(dt) 会输出 int32，显示定义的数据类型。

4.用缩写符号 'i4' 表示 int32 数据类型，并输出描述信息

import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)

（1）导入 numpy 库：import numpy as np 导入 numpy 库并简写为 np，便于后续代码调用。

（2）使用缩写表示数据类型：np.dtype('i4') 创建了数据类型对象 dt，表示 32 位整数类型（int32）， 'i4' 是 int32 的缩写形式。'i1' 表示 int8 类型，8 位整数。'i2' 表示 int16 类型，16 位整数。'i4' 表示 int32 类型，32 位整数。'i8' 表示 int64 类型，64 位整数。

（3）输出数据类型：print(dt) 会输出 int32，显示定义的数据类型。

5.定义小端字节序的 int32 数据类型并输出描述信息

import numpy as np
# 字节顺序标注
dt = np.dtype('<i4')
print(dt)

（1）导入 numpy 库：import numpy as np 导入 numpy 并重命名为 np，便于后续调用。

（2）使用字节顺序和数据类型缩写：np.dtype('<i4') 创建数据类型对象 dt，表示小端字节序的 32 位整数（int32）。'<i4' 中的符号解释：< 表示小端字节序（little-endian），即低字节位存储在低地址处。i4 表示 int32 类型，即 4 字节的整数。在字节顺序标注中，'<' 表示小端字节序，'>' 表示大端字节序（big-endian）。

（3）输出数据类型：print(dt) 会输出 int32，显示该数据类型。

6.创建包含单个字段的结构化数据类型

# 首先创建结构化数据类型
import numpy as np
dt = np.dtype([('age',np.int8)])
print(dt)

（1）导入 numpy 库：import numpy as np 导入 numpy 并重命名为 np。

（2）定义结构化数据类型：np.dtype([('age', np.int8)]) 定义了一个结构化数据类型 dt，其中包含一个字段。[('age', np.int8)] 是一个包含字段定义的列表，每个字段由名称和数据类型组成。'age' 是字段的名称。np.int8 是字段的数据类型，表示 8 位的整数（范围是 -128 到 127）。这使得 dt 成为一种结构，可以用于存储包含 age 字段的数据。

（3）输出数据类型：print(dt) 输出 dt 的描述信息，显示结构化数据类型的定义。

7.通过 dtype 参数将结构化数据类型 dt 应用于 ndarray 对象

# 将数据类型应用于 ndarray 对象
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a)

（1）导入 numpy 库：import numpy as np 导入 numpy 并重命名为 np。

（2）定义结构化数据类型：dt = np.dtype([('age', np.int8)]) 创建结构化数据类型 dt，包含一个字段 'age'，类型为 int8。

（3）创建结构化数组：np.array([(10,), (20,), (30,)], dtype=dt) 使用定义的数据类型 dt 创建一个 ndarray 数组 a。数组 a 的每个元素都是一个包含单一字段的元组，其中 'age' 字段的值分别是 10, 20 和 30。dtype=dt 指定数组的每个元素应当符合 dt 定义的结构，即每个元素包含一个 int8 类型的 age 字段。

（4）输出数组：print(a) 打印数组内容，输出结果将显示 [(10,) (20,) (30,)]，其中每个元素的值对应 age 字段。

8.通过字段名称来访问结构化数组中的具体列

# 类型字段名可以用于存取实际的 age 列
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a['age'])

（1）导入 numpy 库：import numpy as np 导入 numpy 并简写为 np。

（2）定义结构化数据类型：dt = np.dtype([('age', np.int8)]) 定义了结构化数据类型 dt，包含一个字段 'age'，数据类型为 int8。

（3）创建结构化数组：a = np.array([(10,), (20,), (30,)], dtype=dt) 用定义的结构化数据类型 dt 创建一个 ndarray 数组 a，每个元素包含一个 age 字段。每个元组对应一个元素，10、20 和 30 分别为 age 字段的值。

（4）通过字段名访问数据：a['age'] 使用字段名 'age' 来获取数组 a 中所有元素的 age 数据。这个操作返回一个数组，包含了 age 字段的所有值 [10, 20, 30]。

（5）输出结果：print(a['age']) 输出 [10 20 30]，age 字段的所有值。

9.创建适用于学生数据的结构化数据类型 student

import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)

（1）导入 numpy 库：import numpy as np 导入 numpy 并重命名为 np。

（2）定义结构化数据类型：student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')]) 定义了一个结构化数据类型 student，包含三个字段：'name'：数据类型为 'S20'，表示一个长度为 20 的字符串。S 表示字节字符串类型，20 是最大字符长度。'age'：数据类型为 'i1'，表示一个 8 位的整数（即 int8），范围是 -128 到 127。'marks'：数据类型为 'f4'，表示一个 32 位的浮点数（即 float32）。这个结构化数据类型适合表示学生的 name（名字），age（年龄），和 marks（分数）。

（3）输出结构化数据类型描述：print(student) 打印 student 类型的描述信息。输出显示：[('name', 'S20'), ('age', 'i1'), ('marks', 'f4')]，每个字段及其对应的数据类型。

10.创建包含多个学生信息的结构化数组 a

import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print(a)

（1）导入 numpy 库：import numpy as np 导入 numpy 并简写为 np。

（2）定义结构化数据类型：student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')]) 定义了名为 student 的结构化数据类型。'name' 字段为 S20，长度为 20 的字节字符串，用于存储学生名字。'age' 字段为 i1，8 位整数（即 int8），用于存储学生年龄。'marks' 字段为 f4，表示 32 位浮点数（即 float32），用于存储学生分数。

（3）创建结构化数组：a = np.array([('abc', 21, 50), ('xyz', 18, 75)], dtype=student) 创建了一个数组 a，包含两个学生的记录：第一条记录：('abc', 21, 50)，其中 'abc' 是学生的名字，21 是年龄，50 是分数。第二条记录：('xyz', 18, 75)，其中 'xyz' 是学生的名字，18 是年龄，75 是分数。dtype=student 指定了数组 a 的数据类型为之前定义的结构化数据类型 student。

（4）输出数组：print(a) 打印数组 a 的内容，结果为[(b'abc', 21, 50.) (b'xyz', 18, 75.)]输出显示了每个学生的详细信息，其中 b'abc' 和 b'xyz' 表示字节字符串格式的名字，21 和 18 是年龄，50. 和 75. 是分数（浮点数格式）。

11.常用数据类型代码（字符）及对应实际数据类型

（1）b：布尔型，表示布尔值 (True/False)

（2）i ：(有符号) 整型，表示有符号整数，允许负数，例如 -128 到 127（具体范围根据字节数不同而不同）

（3）u：无符号整型，表示无符号整数，只允许正数，例如 0 到 255（具体范围根据字节数不同而不同）

（4）f ：浮点型：表示浮点数，即带小数的数值，例如 3.14

（5）c ：复数浮点型，表示复数，由两个浮点数表示实部和虚部，如 3 + 2j

（6）m：timedelta，表示时间间隔，用于日期和时间的差值

（7）M：datetime，表示日期时间类型，用于存储具体的日期和时间

（8）O：对象，表示 Python 对象，一般用于存储任意 Python 对象

（9）S, a：(byte-)字符串，表示字节字符串，例如 b'hello'。S 和 a 的后面可以指定长度，例如 S10 表示长度为 10 的字节字符串

（10）U：Unicode，表示 Unicode 字符串，可用于存储多语言字符

（11）V：原始数据类型 (void)     ，表示原始数据，用于定义结构化数据类型或指定占位空间