掌握 NumPy zeros()：初始化全零数组的必备函数
在数据科学、机器学习、科学计算以及工程领域的 Python 应用中，NumPy 几乎是不可或缺的基础库。它提供了强大的多维数组对象（ndarray）和一系列用于处理这些数组的快速操作。在构建复杂的数值算法或数据结构时，我们经常需要一个“干净”的起点——一个所有元素都初始化为特定值的数组。其中最常见的需求之一就是创建一个所有元素都是零的数组。这时，NumPy 提供的 zeros() 函数就成为了我们的得力助手。
本文将带你深入探索 numpy.zeros() 函数的方方面面，从基础用法到高级技巧，从参数详解到实际应用，让你彻底掌握这个初始化全零数组的必备工具。
1. 引言：为什么需要全零数组？
在许多计算任务中，初始化一个包含全零值的数组是至关重要的第一步。例如：
- 预分配内存： 在执行迭代计算、累加结果或填充数据的过程中，提前创建一个确定大小的全零数组可以避免在循环中动态地创建或扩展数组，从而提高效率和性能。
- 初始化计数器或累加器： 当你需要统计某些事件的发生次数或者对一系列数值进行求和时，一个全零数组是初始化这些计数器或累加器的自然选择。
- 创建掩码或模板： 在图像处理、信号处理或逻辑操作中，全零数组常被用作掩码的初始状态或特定模式的模板。
- 机器学习模型初始化： 在某些机器学习模型（如神经网络）中，权重或偏置可能需要初始化为零或接近零的小值，尽管更常见的是随机初始化，但全零初始化在特定层或特定目的下（如偏置项）仍有其用途。
- 作为其他计算的起点： 很多数值算法的中间结果或最终结果都需要在一个数组中累积，全零数组提供了一个干净的起始状态。
手动通过 Python 列表创建并填充零（例如 [[0] * width for _ in range(height)]）对于小型任务尚可接受，但对于大型多维数组，这种方式不仅效率低下，而且难以处理高维数据。NumPy 的 ndarray 是针对数值计算高度优化的，其操作通常在底层以 C 或 Fortran 实现，速度远超纯 Python 列表操作。numpy.zeros() 函数正是利用了 NumPy 的这一优势，以高效且直观的方式创建全零 ndarray。
2. numpy.zeros() 的基本用法
numpy.zeros() 函数的基本语法如下：
python
numpy.zeros(shape, dtype=float, order='C', *, like=None)
它接受以下几个主要参数：
shape: 必需参数，用于指定创建数组的形状（dimensions）。dtype: 可选参数，用于指定数组中元素的 数据类型（data type）。默认为float。order: 可选参数，用于指定数组元素的存储顺序，可以是 ‘C’ (行主序，C-style) 或 ‘F’ (列主序，Fortran-style)。默认为 ‘C’。like: 可选参数 (NumPy 1.20+ 新增)，用于参考另一个数组来确定shape和dtype。如果提供了此参数，shape和dtype参数将被忽略。
函数返回一个指定形状和类型的 ndarray，其所有元素都初始化为零。
让我们从最简单的例子开始：创建一个一维全零数组。
“`python
import numpy as np
创建一个包含 5 个元素的零数组
arr_1d = np.zeros(5)
print(“一维零数组:”)
print(arr_1d)
print(“数据类型:”, arr_1d.dtype)
print(“形状:”, arr_1d.shape)
“`
输出：
一维零数组:
[0. 0. 0. 0. 0.]
数据类型: float64
形状: (5,)
可以看到，默认情况下，zeros() 创建的数组元素类型是浮点型 (float64)。形状 (5,) 表示这是一个长度为 5 的一维数组。
接下来，创建二维和多维全零数组。shape 参数可以是一个表示每个维度大小的元组（tuple）。
“`python
创建一个 2×3 的二维零数组
arr_2d = np.zeros((2, 3))
print(“\n二维零数组:”)
print(arr_2d)
print(“数据类型:”, arr_2d.dtype)
print(“形状:”, arr_2d.shape)
创建一个 2x3x4 的三维零数组
arr_3d = np.zeros((2, 3, 4))
print(“\n三维零数组:”)
print(arr_3d)
print(“数据类型:”, arr_3d.dtype)
print(“形状:”, arr_3d.shape)
“`
输出：
“`
二维零数组:
[[0. 0. 0.]
[0. 0. 0.]]
数据类型: float64
形状: (2, 3)
三维零数组:
[[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]]
数据类型: float64
形状: (2, 3, 4)
“`
这些例子展示了如何使用元组来定义任意维度的数组形状。只要将每个维度的大小按顺序放入元组中，zeros() 就能创建相应形状的全零数组。
3. 深入理解 shape 参数
shape 参数是 zeros() 函数的核心，它决定了创建数组的维度和大小。它可以是一个整数，表示一维数组的长度；也可以是一个由整数组成的元组，表示多维数组在每个维度上的大小。
-
单个整数：
np.zeros(n)创建一个长度为n的一维数组。等价于np.zeros((n,))。python
arr_int_shape = np.zeros(10)
print("\n形状为单个整数的数组:")
print(arr_int_shape.shape) # Output: (10,) -
整数元组：
np.zeros((d1, d2, ..., dn))创建一个 n 维数组，其中第一个维度有d1个元素，第二个维度有d2个元素，依此类推。python
arr_tuple_shape = np.zeros((2, 5))
print("\n形状为整数元组的数组:")
print(arr_tuple_shape.shape) # Output: (2, 5) -
空元组：
np.zeros(())创建一个标量数组（scalar array），也称为零维数组。这种数组只有一个元素。python
arr_scalar = np.zeros(())
print("\n形状为空元组的标量数组:")
print(arr_scalar)
print("数据类型:", arr_scalar.dtype)
print("形状:", arr_scalar.shape)
print("元素个数:", arr_scalar.size)输出：
形状为空元组的标量数组:
0.0
数据类型: float64
形状: ()
元素个数: 1零维数组虽然看起来像一个单独的数值，但在 NumPy 中它仍然是一个
ndarray对象，拥有dtype和shape等属性，这使得NumPy的通用函数（ufunc）能够以统一的方式处理标量和数组。
正确指定 shape 是使用 zeros() 的第一步，也是最关键的一步。错误地指定 shape（例如，传递一个非整数或包含非整数的元组）会导致 TypeError。
4. 控制元素类型：dtype 参数
dtype 参数决定了数组中元素的 数据类型。NumPy 支持非常丰富的数据类型，包括：
- 整数类型：
np.int8,np.int16,np.int32,np.int64等。 - 无符号整数类型：
np.uint8,np.uint16,np.uint32,np.uint64等。 - 浮点类型：
np.float16,np.float32,np.float64(等同于np.double) 等。 - 复数类型：
np.complex64,np.complex128等。 - 布尔类型：
np.bool_。 - 对象类型：
np.object_(慎用，性能较低)。 - 字符串类型：
np.string_,np.unicode_(固定长度)。
选择合适的 dtype 至关重要，因为它影响着：
- 内存占用： 不同类型占用不同字节数。例如，
int64占用 8 字节，而int32占用 4 字节。创建大型数组时，选择合适的类型可以显著节省内存。 - 精度和数值范围： 浮点类型决定了数值的精度，整数类型决定了可表示的整数范围。
- 计算性能： 某些操作在特定
dtype上可能更快或更慢，尤其是在利用特定的硬件指令集时。
默认的 dtype 是 float64，这是一个双精度浮点数类型，通常提供足够的精度，但也占用较多内存。如果你确定数组只需要存储整数，或者需要更小的内存占用，应该明确指定 dtype。
“`python
创建一个包含整数的零数组
arr_int = np.zeros((2, 3), dtype=int)
print(“\n整数类型的零数组:”)
print(arr_int)
print(“数据类型:”, arr_int.dtype)
创建一个包含 8 位无符号整数的零数组
arr_uint8 = np.zeros((3, 3), dtype=np.uint8)
print(“\n无符号 8 位整数类型的零数组:”)
print(arr_uint8)
print(“数据类型:”, arr_uint8.dtype)
创建一个包含复数的零数组
arr_complex = np.zeros(4, dtype=complex)
print(“\n复数类型的零数组:”)
print(arr_complex)
print(“数据类型:”, arr_complex.dtype)
创建一个布尔类型的零数组 (布尔零即 False)
arr_bool = np.zeros(3, dtype=bool)
print(“\n布尔类型的零数组:”)
print(arr_bool)
print(“数据类型:”, arr_bool.dtype)
“`
输出：
“`
整数类型的零数组:
[[0 0 0]
[0 0 0]]
数据类型: int64
无符号 8 位整数类型的零数组:
[[0 0 0]
[0 0 0]]
数据类型: uint8
复数类型的零数组:
[0.+0.j 0.+0.j 0.+0.j 0.+0.j]
数据类型: complex128
布尔类型的零数组:
[False False False]
数据类型: bool
“`
请注意，当你指定 dtype=int 时，NumPy 会根据你的操作系统和架构选择一个默认的整数类型，通常是 int64。如果需要特定的整数位数，最好使用 np.int32 或 np.int64 等更精确的类型名称。同样，dtype=float 通常对应 np.float64。
5. 内存布局：order 参数
order 参数控制数组元素在内存中的存储顺序。这对于与使用不同内存布局的外部库（如某些 Fortran 库）进行交互或在编写性能敏感的代码时可能很重要。主要有两种顺序：
'C'(C-order / row-major): 元素按行存储。对于二维数组，同一行的元素在内存中是连续的。这是 NumPy 的默认顺序，也是 C 和 Python 的列表的默认顺序。'F'(Fortran-order / column-major): 元素按列存储。对于二维数组，同一列的元素在内存中是连续的。这是 Fortran 和 MATLAB 的默认顺序。
对于大多数标准的 NumPy 操作，order 参数的影响可能不那么明显，因为 NumPy 的内部函数通常能够高效地处理这两种布局。然而，如果你正在进行大量的切片、转置操作，或者与期望特定内存布局的外部函数接口，了解并正确使用 order 参数就变得重要。
使用 order 参数：
“`python
创建一个 2×3 的 C-order 零数组
arr_c = np.zeros((2, 3), order=’C’)
print(“\nC-order 零数组:”)
print(arr_c)
print(“形状:”, arr_c.shape)
可以通过 .flags 属性查看内存布局信息
print(“Flags (C-order):”, arr_c.flags)
创建一个 2×3 的 F-order 零数组
arr_f = np.zeros((2, 3), order=’F’)
print(“\nF-order 零数组:”)
print(arr_f)
print(“形状:”, arr_f.shape)
print(“Flags (F-order):”, arr_f.flags)
“`
输出（flags 输出可能因环境而异，但应显示 C_CONTIGUOUS 或 F_CONTIGUOUS）：
“`
C-order 零数组:
[[0. 0. 0.]
[0. 0. 0.]]
形状: (2, 3)
Flags (C-order): C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
F-order 零数组:
[[0. 0. 0.]
[0. 0. 0.]]
形状: (2, 3)
Flags (F-order): C_CONTIGUOUS : False
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
“`
通过 flags 属性，我们可以确认数组是否按照 C 或 F 顺序在内存中连续存储。对于许多操作，访问内存中连续存储的元素比跳跃访问更快。因此，如果你的算法是逐行访问数据，C-order 更优；如果逐列访问数据，F-order 更优。
6. 参考其他数组：like 参数 (NumPy 1.20+)
like 参数是一个相对较新的特性，它提供了一种方便的方式来创建一个与现有数组具有相同形状和数据类型的全零数组。如果你已经有一个 NumPy 数组 a，并且想创建一个与 a 大小和类型都相同但全为零的新数组，你可以使用 np.zeros(shape, like=a)。
“`python
假设有一个现有数组
existing_array = np.array([[1, 2, 3],
[4, 5, 6]], dtype=np.int32)
print(“现有数组:”)
print(existing_array)
print(“现有数组数据类型:”, existing_array.dtype)
print(“现有数组形状:”, existing_array.shape)
使用 like 参数创建一个与现有数组相同形状和数据类型的零数组
注意：shape 参数仍需要指定，但 like 会覆盖 dtype 和 shape（取决于 NumPy 版本和具体实现）
在 NumPy 1.20+ 中，如果提供了 like，shape 和 dtype 通常会被忽略，直接使用 like 数组的属性
zero_like_array = np.zeros(existing_array.shape, like=existing_array) # 显式提供 shape 更保险，但 like 会主导
或者更简洁地使用 numpy.zeros_like 函数（更常见和推荐的方式）
zero_like_array_zeros_like = np.zeros_like(existing_array) # 这是等价且更常见的做法
print(“\n使用 like 参数创建的零数组:”)
print(zero_like_array)
print(“数据类型:”, zero_like_array.dtype)
print(“形状:”, zero_like_array.shape)
验证是否与原数组属性一致
print(“数据类型一致:”, zero_like_array.dtype == existing_array.dtype)
print(“形状一致:”, zero_like_array.shape == existing_array.shape)
“`
输出：
“`
现有数组:
[[1 2 3]
[4 5 6]]
现有数组数据类型: int32
形状: (2, 3)
使用 like 参数创建的零数组:
[[0 0 0]
[0 0 0]]
数据类型: int32
形状: (2, 3)
数据类型一致: True
形状一致: True
“`
尽管 zeros() 函数提供了 like 参数，但在实践中，更常用且语义更清晰的方式是使用专门的函数 numpy.zeros_like()。
7. 与 numpy.zeros_like() 的比较
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None) 函数专门用于创建一个与输入数组 a 具有相同形状和数据类型（除非指定了 dtype）的全零数组。它是 np.zeros(a.shape, a.dtype) 的一个便捷版本，通常也考虑了输入数组 a 的内存布局和子类信息。
“`python
import numpy as np
假设有一个现有数组
existing_array = np.array([[1.5, 2.3],
[4.1, 5.9]], dtype=np.float32)
使用 zeros_like 创建一个零数组
zero_like_array = np.zeros_like(existing_array)
print(“现有数组:”)
print(existing_array)
print(“数据类型:”, existing_array.dtype)
print(“形状:”, existing_array.shape)
print(“\n使用 zeros_like 创建的零数组:”)
print(zero_like_array)
print(“数据类型:”, zero_like_array.dtype)
print(“形状:”, zero_like_array.shape)
验证是否与原数组属性一致
print(“数据类型一致:”, zero_like_array.dtype == existing_array.dtype)
print(“形状一致:”, zero_like_array.shape == existing_array.shape)
“`
输出：
“`
现有数组:
[[1.5 2.3]
[4.1 5.9]]
数据类型: float32
形状: (2, 2)
使用 zeros_like 创建的零数组:
[[0. 0.]
[0. 0.]]
数据类型: float32
形状: (2, 2)
数据类型一致: True
形状一致: True
“`
zeros_like() 的主要优点在于其简洁性和表达力。当你需要一个与另一个数组结构相同的零数组时，zeros_like(a) 比 zeros(a.shape, dtype=a.dtype) 更直接、更易读。在 NumPy 1.20 之前，zeros_like() 是实现此目的的标准方法。即使在引入了 like 参数之后，zeros_like() 依然是推荐的惯用法。
8. zeros() 与 empty(), ones(), full() 的对比
NumPy 提供了多种函数来创建具有特定初始值的数组，了解 zeros() 与它们之间的区别有助于在不同场景下做出正确的选择。
-
numpy.empty(shape, dtype=float, order='C', *, like=None): 创建一个指定形状和类型的数组，但不初始化其元素。这意味着数组中的值是内存中当前存在的任意值（“垃圾值”）。empty()函数比zeros()或ones()稍快，因为它跳过了将内存区域写入零或一的步骤。当你确定会在创建数组后立即用其他值完全覆盖所有元素时，可以使用empty()来获得轻微的性能提升。“`python
创建一个空的 2×2 数组
arr_empty = np.empty((2, 2), dtype=int)
print(“\nEmpty 数组 (值不确定):”)
print(arr_empty) # 输出将是随机的整数值
print(“数据类型:”, arr_empty.dtype)
print(“形状:”, arr_empty.shape)
“`重要提示： 不要依赖
empty()创建的数组中的初始值。它们是未定义的。 -
numpy.ones(shape, dtype=None, order='C', *, like=None): 与zeros()类似，但创建一个所有元素都初始化为一的数组。“`python
创建一个 2×3 的全一数组
arr_ones = np.ones((2, 3))
print(“\nOnes 数组:”)
print(arr_ones)
print(“数据类型:”, arr_ones.dtype) # 默认 float64
print(“形状:”, arr_ones.shape)
“` -
numpy.full(shape, fill_value, dtype=None, order='C', *, like=None): 这是最通用的初始化函数，可以创建一个所有元素都初始化为fill_value指定的任意值的数组。zeros()实际上等价于full(shape, 0, dtype=...)，而ones()等价于full(shape, 1, dtype=...)。“`python
创建一个 2×2 的全 5 数组
arr_full = np.full((2, 2), 5)
print(“\nFull 数组 (填充值为 5):”)
print(arr_full)
print(“数据类型:”, arr_full.dtype) # 默认根据 fill_value 推断，这里是 int64
print(“形状:”, arr_full.shape)使用 full 创建一个全零数组 (等价于 zeros)
arr_full_zero = np.full((1, 4), 0.0, dtype=float)
print(“\nFull 数组 (填充值为 0.0):”)
print(arr_full_zero)
print(“数据类型:”, arr_full_zero.dtype)
print(“形状:”, arr_full_zero.shape)
“`
总结：
- 当你需要一个所有元素都为零的数组时，使用
zeros()。 - 当你需要一个所有元素都为一的数组时，使用
ones()。 - 当你需要一个所有元素都为任意特定值时，使用
full()。 - 当你只需要一个特定形状和类型的数组，并且确定会立即覆盖所有元素，不需要初始化值时，使用
empty()(注意其潜在的未定义值)。 - 当你需要一个与现有数组形状和类型相同的零数组时，使用
zeros_like()。
9. zeros() 的实际应用场景举例
9.1 矩阵初始化（例如，在实现线性代数算法时）
在实现矩阵运算或迭代算法时，经常需要初始化结果矩阵为零。
“`python
例如，初始化一个 3×3 的零矩阵作为累加器
sum_matrix = np.zeros((3, 3))
print(“初始化累加矩阵:”)
print(sum_matrix)
模拟一些计算并累加到矩阵中
matrix_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix_b = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
假设我们想计算 A + B 并存储在 sum_matrix 中
sum_matrix = matrix_a + matrix_b
print(“\n累加后的矩阵:”)
print(sum_matrix)
或者，更经典的累加用法 (虽然这里直接相加更简单，但演示了累加思想)
sum_matrix_iter = np.zeros((3, 3))
sum_matrix_iter += matrix_a
sum_matrix_iter += matrix_b
print(“\n迭代累加后的矩阵:”)
print(sum_matrix_iter)
“`
9.2 初始化图像数据
图像在计算机中通常表示为多维数组（例如，灰度图像是二维，彩色图像是三维）。创建一个黑色（所有像素值为零）的空白图像作为画布是很常见的操作。
“`python
创建一个 100×150 像素的灰度黑色图像
通常灰度图像像素值范围是 0-255，使用 uint8 类型
black_image_gray = np.zeros((100, 150), dtype=np.uint8)
print(“\n黑色灰度图像数组 (部分显示):”)
print(black_image_gray)
print(“形状:”, black_image_gray.shape)
print(“数据类型:”, black_image_gray.dtype)
创建一个 50×80 像素的彩色黑色图像 (RGB格式，3通道)
black_image_rgb = np.zeros((50, 80, 3), dtype=np.uint8)
print(“\n黑色彩色图像数组 (部分显示):”)
print(black_image_rgb)
print(“形状:”, black_image_rgb.shape)
print(“数据类型:”, black_image_rgb.dtype)
可以通过一些简单的操作在上面“画”东西
例如，将左上角 10×10 的区域变成白色 (像素值为 255)
black_image_gray[0:10, 0:10] = 255
print(“\n在黑色灰度图像上“画”白色区域 (部分显示):”)
print(black_image_gray)
“`
9.3 动态规划或网格计算的初始化
在动态规划问题或基于网格的模拟中，通常需要初始化一个网格（通常表示为二维或多维数组）来存储中间结果或状态。
“`python
例如，初始化一个 10×10 的网格，用于存储某个算法的计算结果，初始值为零
dp_grid = np.zeros((10, 10), dtype=float)
print(“\n动态规划网格初始化:”)
print(dp_grid)
在计算过程中填充网格
… (这里省略具体的动态规划算法)
dp_grid[i, j] = calculate_value(…)
“`
9.4 初始化统计频率计数器
当需要统计一系列数据的频率时，可以使用全零数组作为计数器。
“`python
假设我们有一系列值，范围在 0 到 9 之间
data = np.array([1, 5, 2, 1, 8, 5, 2, 9, 1, 5, 3])
初始化一个长度为 10 的零数组，用于统计 0-9 的频率
frequency_counts = np.zeros(10, dtype=int)
print(“\n初始化频率计数器:”)
print(frequency_counts)
遍历数据，增加对应索引的计数
for value in data:
if 0 <= value < 10: # 确保值在有效范围内
frequency_counts[value] += 1
print(“\n统计后的频率计数器:”)
print(frequency_counts)
结果: [0 3 2 1 0 3 0 0 1 1] 表示 0出现0次, 1出现3次, …, 9出现1次
“`
10. 性能和内存考虑
创建大型数组时，dtype 和数组的大小直接决定了所需的内存。例如，创建一个 10000×10000 的 float64 零数组需要 10000 * 10000 * 8 字节 ≈ 800 MB。如果使用 float32，则只需约 400 MB。
“`python
import sys
创建一个较小的数组示例
small_array = np.zeros((100, 100), dtype=np.float64)
print(“\n小型 float64 数组内存占用 (近似):”, small_array.nbytes, ” bytes”) # nbytes 给出数组元素占用的总字节数
创建一个使用更少内存类型的数组示例
small_array_int8 = np.zeros((100, 100), dtype=np.int8)
print(“小型 int8 数组内存占用 (近似):”, small_array_int8.nbytes, ” bytes”)
尝试创建一个更大的数组 (注意内存限制)
large_array = np.zeros((10000, 10000), dtype=np.float64) # 小心运行，可能耗尽内存
print(“大型 float64 数组内存占用 (近似):”, large_array.nbytes, ” bytes”)
“`
nbytes 属性提供了数组元素所占用的总字节数，不包含 NumPy 数组对象的开销，但这是一个很好的内存占用近似值。
创建数组本身的操作通常非常快，但对于极大的数组，分配内存本身也需要时间，并且如果可用内存不足，可能会导致 MemoryError。
11. 潜在问题与注意事项
- 指定形状时使用元组： 对于多维数组，务必使用元组来指定形状，例如
np.zeros((rows, cols))，而不是np.zeros(rows, cols)(这将导致错误)。 - 注意
dtype的默认值： 记住默认dtype是float64。如果需要整数或其他类型，请务必明确指定。否则，你可能会得到浮点零0.而不是整数零0，这在某些比较或操作中可能导致意外行为。 - 内存溢出： 创建非常大的数组时，注意系统的内存限制，避免
MemoryError。 empty()的风险： 如果不希望数组包含未定义的值，请不要使用empty()，而应该使用zeros()或full()进行初始化。
12. 总结
numpy.zeros() 是 NumPy 库中一个基础且功能强大的函数，用于创建指定形状和数据类型的全零数组。通过灵活使用 shape 和 dtype 参数，我们可以创建满足各种需求的初始化数组，无论是简单的一维数组、复杂的多维张量，还是特定数值类型的数组。了解 order 参数则有助于在性能敏感场景下优化内存访问模式。
与 zeros_like()、empty()、ones() 和 full() 等相关函数进行对比，可以帮助我们更清晰地理解 zeros() 的适用场景和优势。在预分配内存、初始化计数器、创建模板或作为复杂计算的起点时，zeros() 都是一个高效且不可或缺的工具。
掌握 numpy.zeros() 及其参数，是高效使用 NumPy 进行数值计算的第一步。通过本文的详细介绍和示例，希望你已经对这个必备函数有了全面的认识，并能在今后的实践中得心应手地运用它。多加练习，尝试在不同的场景下创建和使用全零数组，你将更深刻地体会到 NumPy 带来的便利和强大。