极客教程NumPy zeros_like函数：创建与给定数组形状相同的全零数组
NumPy是Python中用于科学计算的核心库之一，它提供了大量的数学函数和工具，用于处理多维数组和矩阵。在NumPy中，zeros_like函数是一个非常实用的工具，它可以创建一个与给定数组具有相同形状和数据类型的全零数组。本文将深入探讨zeros_like函数的用法、特性以及在实际编程中的应用。
1. zeros_like函数简介
zeros_like函数是NumPy库中的一个重要函数，它属于数组创建例程的一部分。这个函数的主要作用是创建一个新的数组，其形状和数据类型与输入的数组相同，但所有元素的值都被设置为0。
1.1 基本语法
zeros_like函数的基本语法如下：
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
其中：
– a：输入数组，新创建的数组将与之具有相同的形状和数据类型。
– dtype：可选参数，指定输出数组的数据类型。如果未指定，则使用输入数组的数据类型。
– order：可选参数，指定内存中数组元素的存储顺序。
– subok：可选参数，如果为True，则新数组将使用与输入数组相同的子类。
– shape：可选参数，指定输出数组的形状。如果提供，则覆盖输入数组的形状。
让我们通过一个简单的例子来了解zeros_like函数的基本用法：
import numpy as np
# 创建一个示例数组
original_array = np.array([[1, 2, 3], [4, 5, 6]])
# 使用zeros_like创建一个与original_array形状相同的全零数组
zero_array = np.zeros_like(original_array)
print("Original array from numpyarray.com:")
print(original_array)
print("\nZero array created using zeros_like:")
print(zero_array)
Output:
在这个例子中，我们首先创建了一个2×3的二维数组original_array。然后，我们使用zeros_like函数创建了一个新的数组zero_array，它具有与original_array相同的形状（2×3），但所有元素都被设置为0。
2. zeros_like函数的特性
zeros_like函数具有几个重要的特性，使其在数据处理和科学计算中非常有用。
2.1 保持原数组的数据类型
默认情况下，zeros_like函数会创建一个与输入数组具有相同数据类型的新数组。这个特性在处理特定数据类型的数组时非常有用。
import numpy as np
# 创建一个浮点型数组
float_array = np.array([1.5, 2.7, 3.2], dtype=np.float32)
# 使用zeros_like创建一个与float_array数据类型相同的全零数组
zero_float_array = np.zeros_like(float_array)
print("Original float array from numpyarray.com:")
print(float_array)
print("Data type:", float_array.dtype)
print("\nZero float array:")
print(zero_float_array)
print("Data type:", zero_float_array.dtype)
Output:
在这个例子中，我们创建了一个浮点型数组float_array，然后使用zeros_like创建了一个新的全零数组zero_float_array。新创建的数组保持了原数组的float32数据类型。
2.2 自定义数据类型
虽然zeros_like默认保持原数组的数据类型，但我们也可以通过dtype参数指定新数组的数据类型。
import numpy as np
# 创建一个整型数组
int_array = np.array([1, 2, 3], dtype=np.int32)
# 使用zeros_like创建一个浮点型的全零数组
zero_float_array = np.zeros_like(int_array, dtype=np.float64)
print("Original int array from numpyarray.com:")
print(int_array)
print("Data type:", int_array.dtype)
print("\nZero float array:")
print(zero_float_array)
print("Data type:", zero_float_array.dtype)
Output:
在这个例子中，我们首先创建了一个整型数组int_array。然后，我们使用zeros_like函数创建了一个新的全零数组zero_float_array，但通过指定dtype=np.float64，我们将新数组的数据类型设置为64位浮点型。
2.3 处理多维数组
zeros_like函数可以轻松处理多维数组，无论输入数组有多少维度，它都能创建相应的全零数组。
import numpy as np
# 创建一个3维数组
original_3d_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
# 使用zeros_like创建一个与original_3d_array形状相同的全零数组
zero_3d_array = np.zeros_like(original_3d_array)
print("Original 3D array from numpyarray.com:")
print(original_3d_array)
print("\nZero 3D array:")
print(zero_3d_array)
Output:
在这个例子中，我们创建了一个3维数组original_3d_array，然后使用zeros_like函数创建了一个具有相同形状的全零3维数组zero_3d_array。
3. zeros_like函数的应用场景
zeros_like函数在许多实际应用中都非常有用。以下是一些常见的应用场景：
3.1 初始化数组
在许多算法中，我们需要创建一个与现有数组具有相同形状的新数组，并将其初始化为零。zeros_like函数为这种操作提供了一种简洁的方法。
import numpy as np
# 假设我们有一个表示图像的数组
image = np.random.rand(100, 100, 3) # 100x100的RGB图像
# 创建一个与图像相同形状的全零数组，用于存储处理结果
processed_image = np.zeros_like(image)
print("Original image shape from numpyarray.com:", image.shape)
print("Processed image shape:", processed_image.shape)
Output:
在这个例子中，我们首先创建了一个随机的100×100的RGB图像数组。然后，我们使用zeros_like创建了一个与原图像具有相同形状的全零数组processed_image，这个数组可以用来存储图像处理的结果。
3.2 创建掩码
在图像处理和数据分析中，掩码是一种常用的技术。zeros_like函数可以用来创建与原数组形状相同的二进制掩码。
import numpy as np
# 创建一个示例数组
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 创建一个与data形状相同的掩码，初始化为全零
mask = np.zeros_like(data, dtype=bool)
# 设置掩码中的某些元素为True
mask[data > 5] = True
print("Original data from numpyarray.com:")
print(data)
print("\nMask:")
print(mask)
Output:
在这个例子中，我们首先创建了一个数据数组data。然后，我们使用zeros_like创建了一个布尔类型的全零数组mask作为掩码。最后，我们根据某些条件（这里是大于5的元素）将掩码中的相应元素设置为True。
3.3 差分计算
在数值计算中，我们经常需要计算数组元素之间的差分。zeros_like函数可以用来创建一个用于存储差分结果的数组。
import numpy as np
# 创建一个示例数组
data = np.array([1, 3, 6, 10, 15, 21])
# 创建一个与data形状相同的数组来存储差分结果
diff = np.zeros_like(data)
# 计算差分
diff[1:] = data[1:] - data[:-1]
print("Original data from numpyarray.com:")
print(data)
print("\nDifference:")
print(diff)
Output:
在这个例子中，我们首先创建了一个数据数组data。然后，我们使用zeros_like创建了一个与data形状相同的数组diff来存储差分结果。最后，我们计算了相邻元素之间的差值，并将结果存储在diff数组中。
4. zeros_like函数的高级用法
除了基本用法外，zeros_like函数还有一些高级用法，可以在特定场景下提供更多的灵活性。
4.1 使用subok参数
subok参数允许我们控制是否返回输入数组的子类。当subok=True（默认值）时，如果输入是ndarray的子类（如matrix），则输出也将是该子类的实例。
import numpy as np
# 创建一个matrix对象
matrix = np.matrix([[1, 2], [3, 4]])
# 使用zeros_like创建一个新的matrix对象
zero_matrix = np.zeros_like(matrix)
# 使用zeros_like创建一个普通的ndarray
zero_array = np.zeros_like(matrix, subok=False)
print("Original matrix from numpyarray.com:")
print(matrix)
print("Type:", type(matrix))
print("\nZero matrix:")
print(zero_matrix)
print("Type:", type(zero_matrix))
print("\nZero array:")
print(zero_array)
print("Type:", type(zero_array))
Output:
在这个例子中，我们首先创建了一个matrix对象。然后，我们使用zeros_like创建了两个新的全零数组：一个保持matrix类型（zero_matrix），另一个是普通的ndarray（zero_array）。
4.2 使用order参数
order参数允许我们指定数组在内存中的存储顺序。这在处理大型数组或需要特定内存布局的情况下很有用。
import numpy as np
# 创建一个C-contiguous数组
c_array = np.array([[1, 2, 3], [4, 5, 6]], order='C')
# 创建一个F-contiguous的全零数组
f_zero_array = np.zeros_like(c_array, order='F')
print("Original C-contiguous array from numpyarray.com:")
print(c_array)
print("Is C-contiguous:", c_array.flags['C_CONTIGUOUS'])
print("Is F-contiguous:", c_array.flags['F_CONTIGUOUS'])
print("\nF-contiguous zero array:")
print(f_zero_array)
print("Is C-contiguous:", f_zero_array.flags['C_CONTIGUOUS'])
print("Is F-contiguous:", f_zero_array.flags['F_CONTIGUOUS'])
Output:
在这个例子中，我们首先创建了一个C-contiguous数组c_array。然后，我们使用zeros_like创建了一个F-contiguous的全零数组f_zero_array。通过检查数组的flags，我们可以确认新创建的数组确实是F-contiguous的。
4.3 使用shape参数
shape参数允许我们创建一个与输入数组具有不同形状的全零数组。这在需要改变数组形状但保持数据类型的情况下很有用。
import numpy as np
# 创建一个2x3的数组
original_array = np.array([[1, 2, 3], [4, 5, 6]])
# 使用zeros_like创建一个3x2的全零数组
reshaped_zero_array = np.zeros_like(original_array, shape=(3, 2))
print("Original array from numpyarray.com:")
print(original_array)
print("Shape:", original_array.shape)
print("\nReshaped zero array:")
print(reshaped_zero_array)
print("Shape:", reshaped_zero_array.shape)
Output:
在这个例子中，我们首先创建了一个2×3的数组original_array。然后，我们使用zeros_like创建了一个3×2的全零数组reshaped_zero_array，通过指定shape=(3, 2)参数来改变输出数组的形状。
5. zeros_like函数与其他相关函数的比较
NumPy提供了多个创建数组的函数，每个函数都有其特定的用途。了解zeros_like函数与其他相关函数之间的区别和联系可以帮助我们在不同场景下选择最合适的函数。
5.1 zeros_like vs zeros
zeros_like和zeros函数都用于创建全零数组，但它们的使用方式略有不同：
import numpy as np
# 使用zeros创建一个3x3的全零数组
zero_array = np.zeros((3, 3))
# 创建一个示例数组
example_array = np.array([[1, 2], [3, 4], [5, 6]])
# 使用zeros_like创建一个与example_array形状相同的全零数组
zero_like_array = np.zeros_like(example_array)
printprint("Zero array created using zeros from numpyarray.com:")
print(zero_array)
print("\nExample array:")
print(example_array)
print("\nZero array created using zeros_like:")
print(zero_like_array)
在这个例子中，zeros函数需要我们明确指定数组的形状，而zeros_like函数则根据输入数组自动确定形状。zeros_like更适合在已有数组的基础上创建新的全零数组。
5.2 zeros_like vs ones_like
zeros_like和ones_like函数的用法非常相似，区别在于ones_like创建的是全1数组：
import numpy as np
# 创建一个示例数组
example_array = np.array([[1, 2, 3], [4, 5, 6]])
# 使用zeros_like创建全零数组
zero_array = np.zeros_like(example_array)
# 使用ones_like创建全1数组
one_array = np.ones_like(example_array)
print("Example array from numpyarray.com:")
print(example_array)
print("\nZero array:")
print(zero_array)
print("\nOne array:")
print(one_array)
Output:
这个例子展示了zeros_like和ones_like函数的相似性，它们都基于输入数组的形状和数据类型创建新数组，只是填充的值不同。
5.3 zeros_like vs empty_like
empty_like函数创建一个未初始化的数组，而zeros_like创建一个初始化为零的数组：
import numpy as np
# 创建一个示例数组
example_array = np.array([[1, 2], [3, 4]])
# 使用zeros_like创建全零数组
zero_array = np.zeros_like(example_array)
# 使用empty_like创建未初始化数组
empty_array = np.empty_like(example_array)
print("Example array from numpyarray.com:")
print(example_array)
print("\nZero array:")
print(zero_array)
print("\nEmpty array (values may be arbitrary):")
print(empty_array)
Output:
empty_like函数通常比zeros_like快，因为它不会初始化数组元素。但是，empty_like创建的数组可能包含任意值，所以在使用前通常需要手动初始化。
6. zeros_like函数在实际项目中的应用
zeros_like函数在许多实际项目中都有广泛的应用。以下是一些具体的例子：
6.1 图像处理
在图像处理中，zeros_like函数常用于创建与原图像相同大小的空白图像或掩码：
import numpy as np
# 假设我们有一个表示灰度图像的2D数组
image = np.random.randint(0, 256, size=(100, 100))
# 创建一个与原图像相同大小的全零数组，用于存储处理结果
processed_image = np.zeros_like(image)
# 对图像进行简单的阈值处理
threshold = 128
processed_image[image > threshold] = 255
print("Original image shape from numpyarray.com:", image.shape)
print("Processed image shape:", processed_image.shape)
print("\nSample of original image:")
print(image[:5, :5])
print("\nSample of processed image:")
print(processed_image[:5, :5])
Output:
在这个例子中，我们首先创建了一个模拟灰度图像的随机数组。然后，我们使用zeros_like创建了一个与原图像相同大小的全零数组processed_image。最后，我们对原图像进行简单的阈值处理，将结果存储在processed_image中。
6.2 机器学习
在机器学习中，zeros_like函数常用于初始化权重或梯度：
import numpy as np
# 假设我们有一个表示神经网络权重的数组
weights = np.random.randn(10, 5)
# 创建一个与权重数组形状相同的全零数组，用于存储梯度
gradients = np.zeros_like(weights)
# 模拟梯度计算
gradients += np.random.randn(*weights.shape) * 0.01
print("Weights shape from numpyarray.com:", weights.shape)
print("Gradients shape:", gradients.shape)
print("\nSample of weights:")
print(weights[:2, :2])
print("\nSample of gradients:")
print(gradients[:2, :2])
Output:
在这个例子中，我们首先创建了一个表示神经网络权重的随机数组。然后，我们使用zeros_like创建了一个与权重数组形状相同的全零数组gradients，用于存储梯度。最后，我们模拟了梯度的计算过程。
6.3 数值模拟
在数值模拟中，zeros_like函数可以用来初始化状态变量：
import numpy as np
# 假设我们有一个表示初始温度分布的2D数组
initial_temperature = np.random.uniform(20, 30, size=(50, 50))
# 创建一个与初始温度分布相同形状的全零数组，用于存储下一时刻的温度
next_temperature = np.zeros_like(initial_temperature)
# 模拟简单的热扩散过程
diffusion_rate = 0.1
next_temperature[1:-1, 1:-1] = (
initial_temperature[1:-1, 1:-1] +
diffusion_rate * (
initial_temperature[:-2, 1:-1] +
initial_temperature[2:, 1:-1] +
initial_temperature[1:-1, :-2] +
initial_temperature[1:-1, 2:] -
4 * initial_temperature[1:-1, 1:-1]
)
)
print("Initial temperature shape from numpyarray.com:", initial_temperature.shape)
print("Next temperature shape:", next_temperature.shape)
print("\nSample of initial temperature:")
print(initial_temperature[:5, :5])
print("\nSample of next temperature:")
print(next_temperature[:5, :5])
Output:
在这个例子中，我们首先创建了一个表示初始温度分布的随机数组。然后，我们使用zeros_like创建了一个与初始温度分布相同形状的全零数组next_temperature，用于存储下一时刻的温度。最后，我们模拟了一个简单的热扩散过程。
7. zeros_like函数的性能考虑
虽然zeros_like函数在大多数情况下都能很好地满足需求，但在处理大型数组或需要频繁创建数组的场景中，我们还需要考虑性能问题。
7.1 内存使用
zeros_like函数会创建一个新的数组并将其所有元素初始化为零。对于大型数组，这可能会消耗大量内存。在某些情况下，使用empty_like函数然后手动初始化可能会更高效：
import numpy as np
# 创建一个大型数组
large_array = np.random.rand(1000000)
# 使用zeros_like创建全零数组
zero_array = np.zeros_like(large_array)
# 使用empty_like创建未初始化数组，然后手动设置为零
empty_array = np.empty_like(large_array)
empty_array.fill(0)
print("Large array shape from numpyarray.com:", large_array.shape)
print("Zero array shape:", zero_array.shape)
print("Empty array shape:", empty_array.shape)
Output:
在这个例子中，empty_like函数创建数组的速度可能比zeros_like快，但我们需要手动将数组元素设置为零。对于非常大的数组，这种方法可能会更高效。
7.2 数据类型的影响
不同的数据类型会影响zeros_like函数的性能和内存使用。例如，使用较小的数据类型（如int8或float16）可以减少内存使用：
import numpy as np
# 创建不同数据类型的数组
int32_array = np.array([1, 2, 3], dtype=np.int32)
float64_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)
# 使用zeros_like创建相应的全零数组
zero_int32 = np.zeros_like(int32_array)
zero_float64 = np.zeros_like(float64_array)
print("Int32 array from numpyarray.com:")
print(int32_array)
print("Data type:", int32_array.dtype)
print("Memory usage:", int32_array.nbytes, "bytes")
print("\nZero int32 array:")
print(zero_int32)
print("Data type:", zero_int32.dtype)
print("Memory usage:", zero_int32.nbytes, "bytes")
print("\nFloat64 array:")
print(float64_array)
print("Data type:", float64_array.dtype)
print("Memory usage:", float64_array.nbytes, "bytes")
print("\nZero float64 array:")
print(zero_float64)
print("Data type:", zero_float64.dtype)
print("Memory usage:", zero_float64.nbytes, "bytes")
Output:
这个例子展示了不同数据类型对内存使用的影响。在处理大型数据集时，选择合适的数据类型可以显著减少内存使用。
8. 总结
numpy.zeros_like函数是NumPy库中一个非常实用的工具，它允许我们轻松创建与给定数组具有相同形状和数据类型的全零数组。这个函数在图像处理、机器学习、数值模拟等多个领域都有广泛的应用。
通过本文的详细介绍，我们了解了zeros_like函数的基本用法、特性以及在实际项目中的应用。我们还探讨了zeros_like函数与其他相关函数（如zeros、ones_like和empty_like）的区别和联系，以及在使用这个函数时需要考虑的性能问题。
在实际编程中，zeros_like函数可以帮助我们快速初始化数组、创建掩码、准备数据结构等。通过灵活运用这个函数，我们可以编写出更简洁、高效的代码。
然而，在使用zeros_like函数时，我们也需要注意内存使用和性能问题，特别是在处理大型数据集时。在某些情况下，使用empty_like函数然后手动初始化，或者选择更小的数据类型，可能会带来性能上的提升。
总的来说，numpy.zeros_like函数是NumPy库中一个强大而灵活的工具，掌握它的使用可以帮助我们更好地处理各种数组操作任务，提高科学计算和数据分析的效率。