Skip to content

NumPy Zeros：使用 np.zeros() 创建零填充数组

Soren Atelier
Name
Soren Atelier

Updated on

用零初始化数组是数值计算中最常见的操作之一。你需要预分配数组来在循环中累积结果，需要零填充矩阵进行图像处理，需要占位张量存放神经网络权重，或者需要空网格存储模拟状态。使用填充零的 Python 列表速度慢，并且缺乏 NumPy 提供的数学运算。

np.zeros() 使用你指定的数据类型创建任意形状的零填充数组。它速度快、内存效率高，是 NumPy 中初始化数组的标准方式。

📚

    基本用法

    一维数组

    import numpy as np
 
# 创建包含 5 个零的一维数组
a = np.zeros(5)
print(a)        # [0. 0. 0. 0. 0.]
print(a.dtype)  # float64 (default)
print(a.shape)  # (5,)

    二维数组（矩阵）

    import numpy as np
 
# 3 行，4 列
matrix = np.zeros((3, 4))
print(matrix)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]
print(matrix.shape)  # (3, 4)

    三维数组

    import numpy as np
 
# 2 层，3 行，4 列
tensor = np.zeros((2, 3, 4))
print(tensor.shape)  # (2, 3, 4)
print(tensor.size)   # 24 elements total

    指定数据类型

    默认 dtype 是 float64。使用 dtype 参数来更改：

    import numpy as np
 
# 整数零
int_zeros = np.zeros(5, dtype=int)
print(int_zeros)       # [0 0 0 0 0]
print(int_zeros.dtype) # int64
 
# 布尔零（False）
bool_zeros = np.zeros(5, dtype=bool)
print(bool_zeros)  # [False False False False False]
 
# 复数零
complex_zeros = np.zeros(3, dtype=complex)
print(complex_zeros)  # [0.+0.j 0.+0.j 0.+0.j]
 
# 32 位浮点数（节省内存）
small_zeros = np.zeros((1000, 1000), dtype=np.float32)
print(f"Memory: {small_zeros.nbytes / 1024 / 1024:.1f} MB")  # ~3.8 MB vs 7.6 MB for float64

    常见数据类型

    dtype描述零的表现每个元素的内存
    float6464 位浮点数（默认）0.8 字节
    float3232 位浮点数0.4 字节
    int6464 位整数08 字节
    int3232 位整数04 字节
    bool布尔False1 字节
    complex128128 位复数0.+0.j16 字节

    np.zeros_like() -- 匹配现有数组

    创建与另一个数组具有相同形状和 dtype 的零数组：

    import numpy as np
 
original = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
 
# 相同形状和 dtype
zeros_copy = np.zeros_like(original)
print(zeros_copy)
# [[0. 0. 0.]
#  [0. 0. 0.]]
print(zeros_copy.dtype)  # float32
print(zeros_copy.shape)  # (2, 3)
 
# 覆盖 dtype
int_copy = np.zeros_like(original, dtype=int)
print(int_copy.dtype)  # int64

    相关初始化函数

    函数创建使用场景
    np.zeros(shape)全零默认初始化
    np.ones(shape)全一乘法单位元、掩码
    np.full(shape, value)全相同值自定义填充值
    np.empty(shape)未初始化性能（立即填充时）
    np.eye(n)单位矩阵线性代数
    np.zeros_like(arr)匹配另一个数组的零匹配输入的结果数组
    import numpy as np
 
# 全一数组
print(np.ones((2, 3)))
# [[1. 1. 1.]
#  [1. 1. 1.]]
 
# Full（自定义值）
print(np.full((2, 3), 7))
# [[7 7 7]
#  [7 7 7]]
 
# Empty（未初始化 -- 更快但包含垃圾数据）
empty = np.empty((2, 3))  # Contents unpredictable
 
# 单位矩阵
print(np.eye(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

    实用案例

    预分配结果数组

    import numpy as np
 
# 为性能预分配（避免重复连接）
n_iterations = 1000
results = np.zeros(n_iterations)
 
for i in range(n_iterations):
    results[i] = np.random.randn() ** 2
 
print(f"Mean: {results.mean():.4f}")
print(f"Std:  {results.std():.4f}")

    混淆矩阵

    import numpy as np
 
def confusion_matrix(y_true, y_pred, n_classes):
    """Build a confusion matrix from predictions."""
    cm = np.zeros((n_classes, n_classes), dtype=int)
    for true, pred in zip(y_true, y_pred):
        cm[true][pred] += 1
    return cm
 
y_true = [0, 1, 2, 0, 1, 2, 0, 0, 1, 2]
y_pred = [0, 1, 1, 0, 2, 2, 0, 1, 1, 0]
 
cm = confusion_matrix(y_true, y_pred, 3)
print(cm)
# [[3 1 0]
#  [0 2 1]
#  [1 0 2]]

    信号处理的零填充

    import numpy as np
 
signal = np.array([1, 2, 3, 4, 5])
 
# 用零填充到长度 16（FFT 的 2 的幂次）
padded = np.zeros(16)
padded[:len(signal)] = signal
print(padded)
# [1. 2. 3. 4. 5. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 
# 使用 np.pad（更灵活）
padded2 = np.pad(signal, (0, 11), mode='constant', constant_values=0)
print(padded2)

    图像处理 -- 零填充

    import numpy as np
 
# 原始 3x3 图像
image = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])
 
# 添加 1 像素零填充
padded = np.zeros((5, 5), dtype=image.dtype)
padded[1:-1, 1:-1] = image
print(padded)
# [[0 0 0 0 0]
#  [0 1 2 3 0]
#  [0 4 5 6 0]
#  [0 7 8 9 0]
#  [0 0 0 0 0]]

    累积模式

    import numpy as np
 
# 在直方图中累积计数
data = np.random.randint(0, 10, size=1000)
bins = np.zeros(10, dtype=int)
 
for value in data:
    bins[value] += 1
 
print("Histogram:")
for i, count in enumerate(bins):
    bar = '#' * (count // 5)
    print(f"  {i}: {bar} ({count})")

    在 Jupyter 中探索零数组

    在构建使用零初始化数组的数值算法时，RunCell (opens in a new tab) 提供了一个 AI 驱动的 Jupyter 环境，你可以在开发过程中交互式地检查数组形状、dtype 和内存使用情况。

    常见问题

    如何在 NumPy 中创建零数组？

    使用 np.zeros(shape)，其中 shape 是一维的整数或多维的元组。例如，np.zeros(5) 创建 [0., 0., 0., 0., 0.]，np.zeros((3, 4)) 创建一个 3x4 的零矩阵。默认 dtype 是 float64。

    np.zeros 和 np.empty 有什么区别？

    np.zeros() 将每个元素初始化为零。np.empty() 分配内存但不初始化，因此它包含该内存位置之前的内容。np.empty() 稍快，但只有在读取之前立即填充每个元素时才安全。

    如何创建整数零而不是浮点零？

    将 dtype=int 传递给 np.zeros()：np.zeros(5, dtype=int) 创建 dtype 为 int64 的 [0, 0, 0, 0, 0]。你还可以使用 np.int32 或 np.int8 等特定类型进行内存控制。

    如何创建与另一个数组相同形状的零数组？

    使用 np.zeros_like(existing_array)。这会复制输入数组的形状和 dtype。你可以用 np.zeros_like(arr, dtype=float) 覆盖 dtype。

    np.zeros() 比 np.full(shape, 0) 更快吗？

    是的，np.zeros() 稍快，因为它使用操作系统级别的优化内存分配（calloc）直接提供零化的内存，而 np.full() 需要先分配再填充。对于大多数实际用途，差异可以忽略不计。

    总结

    np.zeros() 是 NumPy 中创建零填充数组的标准方法。用于预分配、填充、累积模式和初始化。当需要匹配现有数组的形状时选择 np.zeros_like()。指定 dtype 来控制内存使用 -- float32 使用 float64 一半的内存。对于非零初始化，根据需要使用 np.ones()、np.full() 或 np.empty()。

    📚