NumPy ndarray 数据类型与数组生成详解

栗子

发布时间：2026-10-15| 4人浏览过

原创

本文详细解析NumPy中ndarray的数据类型（dtype）机制，包括如何查看、转换及不同数据类型间的转换规则。同时介绍了多种数组生成方法，如zeros、ones、empty、arange、linspace及logspace等，涵盖从基础属性到高级生成技巧的完整操作指南。

NumPy ndarray 的数据类型

数据类型，即 dtype，是一个特殊的对象，它包含了 ndarray 为存储特定类型数据所需的内存块信息，这也被称作元数据，即描述数据的数据。

dtype 是 NumPy 能够与其他系统数据进行灵活交互的关键。通常，其他系统会提供硬盘或内存与数据的对应关系，使得利用 C 或 Fortran 等底层语言读写数据变得十分方便。

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

可以使用 astype 方法来显式地转换数组的数据类型。


arr = np.array([1,2,3,4,5])
print(arr.dtype)
print(arr)
float_arr = arr.astype('float32')#也可以写作 arr.astype(np.float32)
print(float_arr.dtype)
print(float_arr)

例如，int32 类型的数组 [1 2 3 4 5] 转换为 float32 类型后变为 [1. 2. 3. 4. 5.]。

需要注意的是，将内容为数字的字符串数组转换为数字类型是可行的。但当内容是浮点型数字时，只能转换为 float 类型，不能直接转换为 int 类型；只有当内容是整数时，才可以转换为 int 类型。

可以使用其他数组的 dtype 来转换数据类型。


int_arr = np.arange(10)
calibers = np.array([.22, .270, .357], dtype=np.float64)
print(calibers)
arr_last = int_arr.astype(calibers.dtype)
print(arr_last.dtype)
print(arr_last)

例如，float64 类型的数组 [0.22 0.27 0.357] 与 int 数组结合后，结果可能为 float64 类型的 [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]。

补充：Python3 环境下 NumPy 的简单使用，包括 ndarray 的基本属性以及生成数组的基本方法。

声明

由于学习需要，开始学习 NumPy 这一科学计算工具。本文用于复习当前所学内容（当前使用的 NumPy 版本为：1.17.4）。

1. ndarray 的基本属性

2. 生成数组的方法（主要测试生成 0 和生成 1 的方法：ones 和 zeros 方法）。

1. 输出当前 ndarray 的基本属性


# 测试当前Numpy中的narray中的属性
# 使用的numpy的版本为：1.17.4
import numpy as np

default_array = [[1, 2, 3, 4, 5, 6],
                 [1, 2, 3, 4, 5, 6]]
np_array = np.array(default_array)
print("当前存储后的数据的dtype类型为：{}".format(np_array.dtype))  # int32
print("查看这个对象的实际类型：{}".format(type(np_array)))  #
print("查看这个对象的形状：{}".format(np_array.shape))  # （2，6）
print("当前这个对象的字节长度：{}".format(np_array.itemsize))  # 4
print("当前这个对象的长度(使用python的len方法)：{}".format(len(np_array)))  # 2 只迭代了一组数据外层的二维数据
print("当前这个对象的长度(使用自己的size方法)：{}".format(np_array.size))  # 获取了所有的数据的数量

print(np.array([[1, 2, 3], [1, 2, 3]]).dtype)
print(np.array([1.2, 2.2, 3.2]).dtype)

# 可以看出当前默认使用的类型为int32
# 默认使用的浮点类型为：float64

# 修改和设定当前的使用的初始化类型
# print(np.array([[1.1,1.2,1.3]],dtype="int32").dtype)
print(np.array([[1.1,1.2,1.3]],dtype=np.int32).dtype)

运行结果如下：

总结：

1. 创建二维数据时，使用原生 Python 的 len 方法获取的长度是外层的长度，并不是二维数组实际内容的总长度。

2. 通过 np.array(数组) 将原来的 Python 中的数组转换为 ndarray 类型的数据。

3. 每一个 ndarray 中都会有一个数据类型，使用 dtype 表示，默认使用的整数类型为 int32，浮点类型为 float64。

4. 通过 ndarray.size 获取当前 ndarray 中的元素的总个数。

5. 通过 ndarray.shape 获取当前的 ndarray 的形状。

6. 使用 np.array() 创建 ndarray 时可以指定当前的 ndarray 的 dtype，其形式可以是字符也可以是 np. 类型。

2. 使用 NumPy 生成简单的数组（np.zeros()，np.ones()，np.empty()，np.array()）。


# 使用numpy中的生成的数组数据的方法
import numpy as np

# 生成1的操作
np_array = np.zeros([2, 2])
print("当前生成的数据为：{}".format(np_array))
print("输出当前生成的数据的类型为：{}".format(np_array.dtype))

# 说明当前默认产生的数据数据的类型为float64
# 现在改变当前的dtype,直接将当前的dtype的数据类型设置为int32
np_array.dtype = np.int32
print("当前生成的数据为：{}".format(np_array))
print("输出当前生成的数据的类型为：{}".format(np_array.dtype))

# 生成1的数据
np_array_ones = np.ones([2, 2], dtype=np.int32)
print(np_array_ones)

# 创建一个未初始化的数据，默认未初始化
x = np.empty([3, 2], dtype=int)
print(x)

运行结果如下：

总结：

1. 使用当前的 np.zeros(shape) 和 np.ones(shape) 方法可以生成全是 0 或者全是 1 的指定形状的数组。

2. 通过 np.empty(shape) 生成未初始化的空数组。

3. 可以通过 ndarray.dtype=dtype 方式直接改变当前的 ndarray 的类型。

3. 使用生成数组方式二（np.asarray()，np.copy()）。


# 从已有的数组中创建数据
import numpy as np

default_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
default_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(type(default_tuple))
copy_array = np.asarray(default_array)  # 用于浅拷贝
copy_tuple = np.asarray(default_tuple)
print("asarray数组后的数据：{}".format(copy_array))
print("asarray元组后的数据：{}".format(copy_tuple))
deep_copy_array = np.copy(default_array)
print("copy数组后的数据：{}".format(deep_copy_array))

总结：

1. 这里使用 np.asarray() 方法生成的数组与原来的数组有关联，属于浅拷贝。

2. 这里的 np.copy() 方法生成的另外一份备份数据，属于深拷贝。

4. 生成指定范围的数组（np.arange()，np.random.random()，np.random.randint()，np.linspace()）。


# 通过固定范围生成数组,使用arange方式生成0 到 9之间的数据,默认生成的数据为当前的为范围的值，这里的步长默认就是1,结果中不包含10，这里是按照指定的步长进行迭代
range_array = np.arange(0, 10, dtype=np.int32)
print("range_array:{}".format(range_array))

# 通过随机方式生成数组
random_array = np.random.random((2, 2))
print("使用随机方式生成数组：{}".format(random_array))  # 默认生成的数据为0到1之间的数据

# 2 生成随机的整数
random_array_int = np.random.randint(1, 10, (2, 2))
print("生成随机整数：{}".format(random_array_int))

# 在指定范围中生成15 个 1到 10之间的数,这是一个随机的数据，是等距离的，当要求的数据超过当前的范围的数据的时候默认就会随机生成一些数据
listspace_array = np.linspace(1, 10, 15, dtype=np.int32)  # 就是按照一定的等分进行划分为指定个需要的数据，这里的结果中包含10，相当于当前的等差数列一样
print("listspace_array:{}".format(listspace_array))

运行结果如下：

总结：

1. 当前的 random 方法就是随机生成指定区间的数据，可以指定类型。

2. arange 相当于当前的 Python 中的 range 方法，可以指定步长，生成的是 [a, b) 这种左闭右开区间的数据。

3. linspace 用于在指定的范围中按照指定的方式生成数组，这是等差数列。如果当前需要的数据点数量大于范围允许的唯一整数个数时，会出现随机生成的情况（注：此处原文表述可能有误，通常linspace按等间距采样，若点数过多可能导致精度问题或截断，但原文如此表述，保留原意）。

5. 生成等比数列（np.logspace()）。


# 生成一个等比的数列，这里面的2 表示生成的样本的个数为2 ,起始数据为1，结束数据为4,表示最小为3的1次方到当前的3的4次方
equal_ratio_array = np.logspace(1, 4, 2, dtype=np.int32)  # 这里的默认的底数为10 表示当前最小为10的一次方，最大为当前的10的4次方
print("当前的等比数列的数据为：{}".format(equal_ratio_array))