NumPy 数据类型 (dtype) 详解

NumPy 是 Python 中用于科学计算的核心库，它提供了高性能的多维数组对象以及处理这些数组的工具。NumPy 数组与 Python 内建的列表（list）最大的区别在于，NumPy 数组是同质的（homogeneous），即数组中所有元素的类型必须相同。这种同质性是 NumPy 实现高性能的关键，因为它允许数据以紧凑、连续的内存块存储，并且可以通过优化的、底层的代码（通常是 C 或 Fortran）进行高效处理。

而 数据类型 (dtype) 正是 NumPy 用来描述数组中元素内存布局和解释方式的对象。理解 dtype 是高效使用 NumPy 的基石。它决定了：

内存占用： 每种数据类型都有固定的大小（例如，一个 32 位整数占用 4 字节）。
数值范围和精度： 不同类型能表示的数值范围（例如，有符号整数 vs 无符号整数）和浮点数的精度不同。
操作方式： NumPy 知道如何对特定 dtype 的数据执行算术运算、比较等操作。
与其他库/系统的交互： 数据类型映射到底层的 C 类型或文件格式中常见的类型，方便数据的导入导出。

本文将详细探讨 NumPy 中的 dtype，包括其基本概念、常用类型、指定和检查 dtype 的方法、类型转换以及一些高级主题，如结构化数组和字节序。

1. 什么是 dtype？

在 NumPy 中，dtype 是一个特殊的 Python 对象，它描述了数组中每个元素的类型。它不仅仅是 Python 的内置类型（如 int 或 float），而是一个更底层、更精确的描述，包括：

数据类型种类： 整数、浮点数、复数、布尔值、字符串、日期时间、对象等。
数据大小： 占用多少字节（例如，8 位、16 位、32 位、64 位）。
字节序 (Endianness)： 数据在内存中的字节顺序（对于多字节类型）。
结构化类型字段（如果适用）： 对于结构化数组，dtype 描述了每个字段的名称、类型和偏移量。

当你创建一个 NumPy 数组时，NumPy 会尝试根据输入的数据自动推断 dtype。但通常情况下，为了确保正确性或优化性能，你会需要显式地指定或检查数组的 dtype。

2. NumPy 的核心数据类型

NumPy 支持比 Python 内建类型更广泛的数值类型。这些类型通常是平台独立的，但它们的大小会根据类型定义严格确定。以下是一些最常用的 NumPy 数据类型类别：

2.1 布尔类型 (Boolean)

bool_ 或 '?'：存储布尔值 (True 或 False)。每个元素通常占用 1 字节。

2.2 整数类型 (Integer)

NumPy 提供了多种大小的有符号和无符号整数类型。

有符号整数： 可以表示正数、负数和零。
- int8 或 'i1'：8 位有符号整数 (-128 到 127)
- int16 或 'i2'：16 位有符号整数 (-32768 到 32767)
- int32 或 'i4'：32 位有符号整数 (~-20 亿到 ~20 亿)
- int64 或 'i8'：64 位有符号整数 (~-9e18 到 ~9e18)
- int_：平台相关的默认整数类型，通常是 int32 或 int64。
无符号整数： 只能表示非负数（零和正数）。范围是 0 到 2^n – 1。
- uint8 或 'u1'：8 位无符号整数 (0 到 255)
- uint16 或 'u2'：16 位无符号整数 (0 到 65535)
- uint32 或 'u4'：32 位无符号整数 (0 到 ~40 亿)
- uint64 或 'u8'：64 位无符号整数 (0 到 ~1.8e19)
- uint_：平台相关的默认无符号整数类型。

选择合适的整数类型很重要。例如，如果你知道数据都在 0 到 255 之间，使用 uint8 可以节省大量内存，特别是对于大型图像或字节数据。但要注意，如果执行可能产生超出类型范围结果的运算，会发生溢出（wrap around）。

2.3 浮点类型 (Floating-point)

用于表示带有小数部分的数值。

float16 或 'f2'：16 位半精度浮点数。范围有限，精度较低，但在深度学习等领域常用作内存优化。
float32 或 'f4'：32 位单精度浮点数（通常对应 C 的 float）。
float64 或 'f8'：64 位双精度浮点数（通常对应 C 的 double）。这是 NumPy 的默认浮点类型，提供了较高的范围和精度。
float_：平台相关的默认浮点类型，通常是 float64。
float128 或 'f16'：128 位扩展精度浮点数（可用性取决于平台）。

选择浮点类型主要权衡精度和内存。大多数科学计算推荐使用 float64 以保证精度。

2.4 复数类型 (Complex)

用于表示复数，由两个浮点数（实部和虚部）组成。

complex64 或 'c8'：由两个 32 位浮点数组成。
complex128 或 'c16'：由两个 64 位浮点数组成。这是 NumPy 的默认复数类型。
complex_：平台相关的默认复数类型，通常是 complex128。
complex256 或 'c32'：由两个 128 位浮点数组成（可用性取决于平台）。

2.5 字符串类型 (String)

NumPy 支持固定长度的字符串。这里的关键是“固定长度”，这一点与 Python 的可变长度字符串有很大不同。

string_ 或 'S'：固定长度的字节字符串 (byte string)。例如 'S10' 表示长度为 10 的字节字符串。
unicode_ 或 'U'：固定长度的 Unicode 字符串。例如 'U20' 表示长度为 20 的 Unicode 字符串。

重要提示： NumPy 的字符串类型是固定长度的。如果你尝试将一个较长的字符串存入一个固定长度较小的 dtype 数组中，字符串会被截断。这与 Python 的字符串行为截然不同，因此在处理变长文本时，NumPy 数组通常不是最佳选择，或者需要小心管理最大长度。处理复杂的文本数据通常还是使用 Python 的列表或专门的库（如 Pandas 的 object dtype 或 string dtype）。

2.6 日期和时间类型 (Datetime and Timedelta)

NumPy 提供了用于表示时间点和时间间隔的类型，方便进行时间序列分析。

datetime64 或 'M'：表示特定时间点，精度可以从年份到飞秒。例如 'M8[D]' 表示以天为单位的 datetime。
timedelta64 或 'm'：表示两个时间点之间的时间间隔，精度与 datetime64 类似。例如 'm8[s]' 表示以秒为单位的 timedelta。

这些类型支持方便的日期时间计算，例如两个日期相减得到时间间隔，或者一个日期加上一个时间间隔得到新的日期。

2.7 对象类型 (Object)

object_ 或 'O'：NumPy 数组的元素可以是 Python 对象。在这种情况下，数组存储的是 Python 对象的引用。

重要提示： 使用 object dtype 会失去 NumPy 的许多优势。数组不再存储同质的、固定大小的数据块，而是存储指向任意 Python 对象的指针。这意味着 NumPy 无法直接对这些元素执行矢量化、底层的操作，很多操作会回退到 Python 级别的循环，效率大大降低。内存占用也会增加（存储指针本身加上对象数据）。除非必要（例如，数组中确实包含混合类型的 Python 对象），应尽量避免使用 object dtype。

2.8 Void 类型 (Void)

void 或 'V'：表示一个固定大小的内存块，但不指定如何解释其中的内容。通常用于低级操作或作为结构化数组的基础。

3. 指定和检查 dtype

创建 NumPy 数组时，可以通过 dtype 参数显式指定数据类型。如果不指定，NumPy 会尝试从输入数据中推断出最合适的类型。

3.1 自动推断

“`python
import numpy as np

arr1 = np.array([1, 2, 3]) # 整数，通常推断为 int64 或 int32
print(arr1.dtype)

arr2 = np.array([1.0, 2.5, 3.1]) # 浮点数，通常推断为 float64
print(arr2.dtype)

arr3 = np.array([True, False, True]) # 布尔值，推断为 bool
print(arr3.dtype)

arr4 = np.array([‘hello’, ‘world’]) # 字符串，推断为 U5 (Unicode 长度为 5)
print(arr4.dtype)

arr5 = np.array([1, 2.5]) # 混合类型，推断为能容纳所有元素的更广泛类型 (float64)
print(arr5.dtype)

arr6 = np.array([1, ‘hello’]) # 混合类型，包含字符串和整数，可能推断为 object
print(arr6.dtype)
“`
自动推断通常很方便，但在某些情况下可能不是最优或期望的结果，尤其是在处理混合类型数据或需要精细控制内存时。

3.2 显式指定 dtype

使用 dtype 参数可以精确控制数组的数据类型。指定 dtype 有多种方式：

使用 NumPy 类型对象： np.int32, np.float64, np.bool_, np.unicode_ 等。

python arr = np.array([1, 2, 3], dtype=np.int16) print(arr.dtype) # int16

使用 Python 内建类型： int, float, bool, complex, str。NumPy 会将其映射到相应的默认 NumPy 类型（通常是平台相关的或 64 位）。

“`python
arr = np.array([1, 2, 3], dtype=float)
print(arr.dtype) # float64 (在大多数平台上)

arr = np.array([1+2j, 3+4j], dtype=complex)
print(arr.dtype) # complex128 (在大多数平台上)
“`

使用字符串代码： 这是最灵活（也可能看起来最复杂）的方式，因为它允许指定精确的大小和字节序。字符串代码的格式通常是 [endianness][type_code][size]。
- endianness：> (大端), < (小端), = (本地字节序), | (忽略/不适用，如单字节类型)。对于大多数用户，使用 = 或省略通常是安全的，除非你在处理特定的二进制文件格式。
- type_code：i (有符号整数), u (无符号整数), f (浮点数), c (复数), b (布尔), S (字节字符串), U (Unicode 字符串), M (datetime), m (timedelta), O (对象), V (void)。
- size：类型占用的字节数。例如，4 表示 4 字节，8 表示 8 字节。对于字符串，表示字符/字节的数量（例如，U10 表示 10 个 Unicode 字符）。

“`python
arr = np.array([1, 2, 3], dtype=’i4′) # 32位有符号整数
print(arr.dtype) # int32

arr = np.array([1.0, 2.0], dtype=’f8′) # 64位浮点数
print(arr.dtype) # float64

arr = np.array([‘apple’, ‘banana’], dtype=’U5′) # 5个字符的Unicode字符串
print(arr.dtype) # <U5 (注意可能带有字节序前缀)

指定字节序 (这里使用本机字节序)

arr = np.array([1000], dtype=’=i2′) # 本机字节序的16位有符号整数
print(arr.dtype) # int16 或 i2 取决于平台
“`

使用 dtype 对象本身： 可以先创建一个 dtype 对象，再用它来创建数组。

python my_dtype = np.dtype('float32') arr = np.array([1.0, 2.0, 3.0], dtype=my_dtype) print(arr.dtype) # float32

3.3 检查现有数组的 dtype

NumPy 数组有一个 .dtype 属性，可以用来查看其数据类型。

“`python
arr = np.array([1, 2, 3], dtype=np.int16)
print(arr.dtype) # int16

arr2 = np.array([1.0, 2.0])
print(arr2.dtype) # float64
“`

4. 类型转换 (Type Casting)

你可以使用数组的 .astype() 方法将数组的数据类型转换为另一种类型。这个方法会返回一个新的数组，原始数组不会被修改。

“`python
arr = np.array([1.5, 2.6, 3.1], dtype=np.float64)
print(arr.dtype) # float64
print(arr) # [1.5 2.6 3.1]

转换为整数类型

arr_int = arr.astype(np.int32)
print(arr_int.dtype) # int32
print(arr_int) # [1 2 3] (小数部分被截断)

转换为布尔类型

arr_bool = arr.astype(np.bool_)
print(arr_bool.dtype) # bool
print(arr_bool) # [ True True True] (非零数值转换为 True)

arr_zero = np.array([0, 1.5])
print(arr_zero.astype(np.bool_)) # [False True]

转换为字符串类型

arr_str = arr_int.astype(np.unicode_).astype(‘U10’) # 先转Unicode对象，再指定长度
print(arr_str.dtype) # <U10
print(arr_str) # [‘1’ ‘2’ ‘3’]

从字符串转换为数值 (如果字符串内容合法)

arr_from_str = np.array([‘1’, ‘2’, ‘3.5’], dtype=’U’)
print(arr_from_str.astype(np.float64)) # [1. 2. 3.5]

注意溢出和截断

large_arr = np.array([300], dtype=np.int16) # 16位整数最大32767
print(large_arr)

转换为 8位无符号整数 (最大255) 会发生溢出/截断

small_int_arr = large_arr.astype(np.uint8)
print(small_int_arr.dtype) # uint8
print(small_int_arr) # [44] (300 % 256 = 44)
“`

类型转换是一个常见的操作，但在进行时务必注意可能的数据丢失（如浮点数转整数的截断、数值转小范围整数的溢出）或解释方式的变化（如数值转布尔值）。

5. 字节序 (Endianness)

字节序是指多字节数据（如 16 位整数、32 位浮点数等）在内存中存储时，其字节的顺序。主要有两种：

大端序 (Big-endian)： 最高有效字节存储在最低内存地址。
小端序 (Little-endian)： 最低有效字节存储在最低内存地址。

不同的计算机架构可能使用不同的字节序。在大多数现代计算机（如 Intel x86/x64 架构）上使用小端序。网络传输通常使用大端序。

NumPy 的 dtype 字符串可以通过前缀指定字节序：

<：强制使用小端序。
>：强制使用大端序。
=：使用本机字节序（平台默认）。
|：不关心或不适用（如 1 字节类型）。

“`python
arr = np.array([1000], dtype=’>i2′) # 大端序的16位整数
print(arr.dtype) # >i2

arr2 = np.array([1000], dtype='<i2′) # 小端序的16位整数
print(arr2.dtype) # <i2

你可以使用 .byteswap() 方法改变数组的字节序（会创建一个新的数组）

arr_swapped = arr.byteswap()
print(arr_swapped.dtype) # <i2 (字节序互换)
print(arr_swapped)
“`

对于绝大多数日常计算，你可能不需要关心字节序，因为 NumPy 默认使用本机字节序 (=)，并且在同一台机器上进行计算时不会遇到问题。但当你需要读写特定格式的二进制文件，或者在不同架构的机器之间交换二进制数据时，字节序就变得至关重要。

6. 结构化数组 (Structured Arrays)

这是 NumPy dtype 中一个更高级但非常强大的特性，允许你在同一个数组中存储不同数据类型的“记录”或“结构”。它类似于 C 语言中的结构体或数据库中的一行记录。

结构化数组的 dtype 不是一个单一类型，而是一个包含字段（field）列表的描述。每个字段都有一个名称和一个数据类型。

创建结构化数组时，dtype 可以指定为一个列表，其中每个元素是一个元组 (field_name, field_dtype)，或者更详细的 (field_name, field_dtype, shape)（shape 用于定义多维字段）。

“`python

定义一个 dtype，包含 ‘name’ (字符串), ‘age’ (整数), ‘weight’ (浮点数) 字段

person_dtype = np.dtype([(‘name’, ‘U10’), (‘age’, ‘i4’), (‘weight’, ‘f8’)])

使用这个 dtype 创建数组

people = np.array([
(‘Alice’, 30, 65.5),
(‘Bob’, 25, 72.0),
(‘Charlie’, 35, 80.2)
], dtype=person_dtype)

print(people)
print(people.dtype)

访问字段 (返回一个普通NumPy数组，包含该字段的所有值)

print(“Names:”, people[‘name’])
print(“Ages:”, people[‘age’])
print(“Weights:”, people[‘weight’])

访问单条记录 (返回一个NumPy标量，其类型是结构化dtype)

first_person = people[0]
print(“\nFirst person:”, first_person)
print(“Type of first person:”, type(first_person)) # – 虽然是标量，但类型是结构化的void

访问单条记录的特定字段

print(“First person’s age:”, first_person[‘age’])

结构化数组非常适合处理表格数据或二进制文件格式中具有固定结构的记录。

它们允许你在一个NumPy数组中维护相关联但类型不同的数据，同时仍然保留NumPy的高性能处理能力。

“`

结构化 dtype 还可以嵌套，一个字段本身可以是另一个结构化 dtype，这使得表示复杂的数据结构成为可能。

7. dtype 的属性

NumPy dtype 对象有很多有用的属性，可以提供关于类型的信息：

.name: 类型名称的字符串表示 (e.g., ‘int32’, ‘float64’).
.kind: 类型类别的单字符代码 (e.g., ‘i’, ‘f’, ‘U’, ‘b’, ‘V’).
.char: 类型字符码 (e.g., ‘i4’, ‘f8’, ‘U10’).
.type: 底层 Python 或 NumPy 类型对象 (e.g., numpy.int32, numpy.float64).
.byteorder: 字节序 (‘<‘, ‘>’, ‘=’, ‘|’).
.itemsize: 每个元素占用的字节数。
.isalignedstruct: 是否是字节对齐的结构体（对于结构化 dtype）。
.fields: 对于结构化 dtype，一个字典，描述每个字段的信息。

“`python
dt = np.dtype(‘i4’)
print(dt.name) # int32
print(dt.kind) # i
print(dt.char) # i4
print(dt.type) #
print(dt.itemsize) # 4 (4 bytes)

dt_struct = np.dtype([(‘x’, ‘f8’), (‘y’, ‘i4’)])
print(dt_struct.name) # |V12 (Void type with size 12)
print(dt_struct.kind) # V
print(dt_struct.itemsize) # 12 (8 bytes for float + 4 bytes for int)
print(dt_struct.fields) # OrderedDict([(‘x’, (dtype(‘float64’), 0)), (‘y’, (dtype(‘int32’), 8))])
# (显示字段名称、dtype 和在结构中的字节偏移量)
“`

8. 选择合适的 dtype

选择正确的 dtype 对于优化内存使用和计算性能至关重要。

数值数据： 选择能容纳你的数据范围和所需精度的最小类型。例如，0-255 的整数用 uint8 足矣；需要高精度计算时用 float64；内存受限且对精度要求不高时考虑 float32 或 float16。
布尔数据： 使用 bool_。
字符串数据： 仔细确定所需的最大字符串长度，并使用 'S' 或 'U' 指定。如果字符串长度变化大且没有合理的上限，或者需要复杂的文本处理，NumPy 数组可能不是最佳工具。
日期时间： 使用 datetime64 和 timedelta64，并根据需要选择合适的单位精度（秒、毫秒、天、年等）。
混合类型/结构化数据： 使用结构化数组 dtype。
任意 Python 对象： 仅在无法使用其他 dtype 时考虑 object dtype，并意识到性能会显著下降。

9. dtype 与性能和内存

NumPy 高性能的核心在于它能够处理存储在连续内存块中的同质数据。dtype 定义了这个块中每个元素的精确大小和结构。

内存： 较小的 dtype 意味着数组占用更少的内存。对于大型数据集，这可以防止内存溢出，减少缓存未命中，从而提高性能。例如，存储一百万个 32 位整数比一百万个 64 位整数节省一半内存。
性能： NumPy 的许多底层函数（如数学运算、聚合、排序等）都针对特定的 dtype 进行了高度优化（通常通过向量化指令集如 SSE/AVX）。使用标准、简单（非结构化、非对象）的 dtype 可以最大化利用这些优化。结构化数组也可以受益于矢量化，但对象数组则不能。

10. 总结

NumPy 的数据类型 (dtype) 是其数组对象的核心组成部分，它详细描述了数组元素的内存布局和解释方式。理解并正确使用 dtype 对于高效地进行科学计算至关重要。

本文详细介绍了 NumPy 中的各种内置数据类型，包括整数、浮点数、复数、布尔值、字符串、日期时间、对象以及结构化类型。我们探讨了如何通过自动推断、NumPy 类型对象、Python 类型或字符串代码来指定数组的 dtype，以及如何使用 .dtype 属性检查现有数组的类型。此外，还介绍了使用 .astype() 进行类型转换以及需要注意的潜在问题，简要解释了字节序的概念，并重点阐述了结构化数组这一强大的特性。

选择合适的 dtype 能够显著影响程序的内存使用和执行速度。在处理大规模数据时，精确控制数据类型是优化性能的关键手段之一。通过掌握 NumPy dtype 的知识，你将能更自信、更高效地使用 NumPy 进行各种数据处理和数值计算任务。

NumPy 数据类型 (dtype) 详解 – wiki基地

NumPy 数据类型 (dtype) 详解

1. 什么是 dtype？

2. NumPy 的核心数据类型

2.1 布尔类型 (Boolean)

2.2 整数类型 (Integer)

2.3 浮点类型 (Floating-point)

2.4 复数类型 (Complex)

2.5 字符串类型 (String)

2.6 日期和时间类型 (Datetime and Timedelta)

2.7 对象类型 (Object)

2.8 Void 类型 (Void)

3. 指定和检查 dtype

3.1 自动推断

3.2 显式指定 dtype

指定字节序 (这里使用本机字节序)

3.3 检查现有数组的 dtype

4. 类型转换 (Type Casting)

转换为整数类型

转换为布尔类型

转换为字符串类型

从字符串转换为数值 (如果字符串内容合法)

注意溢出和截断

转换为 8位无符号整数 (最大255) 会发生溢出/截断

5. 字节序 (Endianness)

你可以使用 .byteswap() 方法改变数组的字节序（会创建一个新的数组）

6. 结构化数组 (Structured Arrays)

定义一个 dtype，包含 ‘name’ (字符串), ‘age’ (整数), ‘weight’ (浮点数) 字段

使用这个 dtype 创建数组

访问字段 (返回一个普通NumPy数组，包含该字段的所有值)

访问单条记录 (返回一个NumPy标量，其类型是结构化dtype)

访问单条记录的特定字段

结构化数组非常适合处理表格数据或二进制文件格式中具有固定结构的记录。

它们允许你在一个NumPy数组中维护相关联但类型不同的数据，同时仍然保留NumPy的高性能处理能力。

7. dtype 的属性

8. 选择合适的 dtype

9. dtype 与性能和内存

10. 总结

发表评论取消回复

NumPy 数据类型 (dtype) 详解

1. 什么是 dtype？

2. NumPy 的核心数据类型

2.1 布尔类型 (Boolean)

2.2 整数类型 (Integer)

2.3 浮点类型 (Floating-point)

2.4 复数类型 (Complex)

2.5 字符串类型 (String)

2.6 日期和时间类型 (Datetime and Timedelta)

2.7 对象类型 (Object)

2.8 Void 类型 (Void)

3. 指定和检查 dtype

3.1 自动推断

3.2 显式指定 dtype

指定字节序 (这里使用本机字节序)

3.3 检查现有数组的 dtype

4. 类型转换 (Type Casting)

转换为整数类型

转换为布尔类型

转换为字符串类型

从字符串转换为数值 (如果字符串内容合法)

注意溢出和截断

转换为 8位无符号整数 (最大255) 会发生溢出/截断

5. 字节序 (Endianness)

你可以使用 .byteswap() 方法改变数组的字节序（会创建一个新的数组）

6. 结构化数组 (Structured Arrays)

定义一个 dtype，包含 ‘name’ (字符串), ‘age’ (整数), ‘weight’ (浮点数) 字段

使用这个 dtype 创建数组

访问字段 (返回一个普通NumPy数组，包含该字段的所有值)

访问单条记录 (返回一个NumPy标量，其类型是结构化dtype)

访问单条记录的特定字段

结构化数组非常适合处理表格数据或二进制文件格式中具有固定结构的记录。

它们允许你在一个NumPy数组中维护相关联但类型不同的数据，同时仍然保留NumPy的高性能处理能力。

7. dtype 的属性

8. 选择合适的 dtype

9. dtype 与性能和内存

10. 总结

发表评论 取消回复

发表评论取消回复