NumPy - 基于数值范围的数组
NumPy 中的基于数值范围的数组
在 NumPy 中，基于数值范围创建数组是指生成包含指定范围内数字序列的数组。NumPy 提供了几个用于创建此类数组的函数，如下所示:
- 使用 numpy.arange() 函数
- 使用 numpy.linspace() 函数
- 使用 numpy.logspace() 函数
- 使用 numpy.meshgrid() 函数
使用 numpy.arange() 函数
numpy.arange() 函数通过根据指定的起始值、终止值和步长值生成数字序列来创建数组。它类似于 Python 内置的 range() 函数，但返回一个 NumPy 数组。语法如下:-
numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)
其中:
start(可选)- 区间的起始值。默认值为 0。
stop - 区间的结束值(不包含)。
step(可选)- 值之间的间隔。默认值为 1。
dtype(可选)- 数组所需的数据类型。如果未指定，NumPy 会根据输入值解析数据类型。
示例:基本用法
在下面的示例中，我们使用 numpy.arange() 函数生成一个从 0 到(但不包括)10 的数组 -
import numpy as np
# 创建一个从 0 到 9 的数组
arr = np.arange(10)
print("使用 arange() 的数组:", arr)
以下是得到的输出 -
使用 arange() 的数组:[0 1 2 3 4 5 6 7 8 9]
示例:指定起始、终止和终止步长
在这里，我们使用 numpy.arange() 函数生成一个从 1 开始，直到(但不包括)10 的数组，步长为 2 -
import numpy as np
# 创建一个从 1 到 9 的数组，步长为 2
arr = np.arange(1, 10, 2)
print("包含起始值、终止值和步长的数组:", arr)
这将产生以下结果 -
包含起始值、终止值和步长的数组:[1 3 5 7 9]
使用 numpy.linspace() 函数
numpy.linspace() 函数生成一个在指定间隔内具有均匀分布值的数组。当你需要两个值之间指定特定数量的点时，它非常有用。
此函数类似于 arange() 函数。在此函数中，指定的不是步长，而是间隔之间等距值的数量。语法如下:
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
其中:
start − 间隔的起始值。
stop − 间隔的结束值。
num(可选)− 要生成的均匀间隔样本数。默认值为 50。
endpoint(可选)− 如果为 True，则 stop 为最后一个样本。如果为 False，则不包含该样本。默认值为 True。
retstep(可选)− 如果为 True，则返回 (samples, step)，其中 step 为样本之间的间隔。默认值为 False。
dtype(可选)− 数组所需的数据类型。如果未指定，NumPy 会根据输入值解释数据类型。
axis(可选)− 结果中用于存储样本的轴。默认值为 0。
示例:基本用法
在本例中，我们使用 numpy.linspace() 函数生成一个包含 10 个从 0 到 1(默认包含 0 和 1)等距值的数组 -
import numpy as np
# 创建一个包含 10 个从 0 到 1 等距值的数组
arr = np.linspace(0, 1, 10)
print("Array using linspace():", arr)
以下是上述代码的输出 -
Array using linspace(): [0.0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 0.66666667 0.77777778 0.88888889 1. ]
示例:排除端点
在这里，我们生成一个包含 10 个等距值的数组，这些值的范围从 0 到略小于 1，并使用 numpy.linspace() 函数排除端点 -
import numpy as np
# 创建数组
arr = np.linspace(0, 1, 10, end=False)
print("endpoint=False 的数组:", arr)
得到的输出如下所示 −
endpoint=False 的数组:[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
示例:返回步长
现在，我们生成一个包含 10 个等距值的数组，这些值的范围从 0 到 1(默认包含 0 和 1)，并返回步长 -
import numpy as np
# 创建数组
arr, step = np.linspace(0, 1, 10, retstep=True)
print("步长数组:", arr)
print("步长:", step)
执行上述代码后，我们得到以下输出 -
步长数组:[0.0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 0.66666667 0.77777778 0.88888889 1. ] 步长:0.11111111111111111
使用 numpy.logspace() 函数
numpy.logspace() 函数生成一个数组，其值在对数尺度上均匀分布。这对于生成跨越多个数量级的值非常有用。语法如下:
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
其中:
start − 序列的起始值(以基数的幂为单位)。
stop − 序列的终止值(以基数的幂为单位)。
num(可选)− 要生成的样本数。默认为 50。
endpoint(可选)− 如果为 True，则 stop 为最后一个样本。如果为 False，则不包含该样本。默认值为 True。
base(可选)− 对数空间的底数。默认值为 10.0。
dtype(可选)− 数组所需的数据类型。如果未指定，NumPy 会根据输入值解析数据类型。
axis(可选)− 结果中用于存储样本的轴。默认值为 0。
示例
在下面的示例中，我们使用 numpy.logspace() 函数生成一个包含 10 个值的数组，这些值以对数刻度均匀分布，范围从 21 到 210，底数为 2。-
import numpy as np
# 创建数组
arr = np.logspace(1, 10, 10, base=2)
print("以 2 为底的数组:", arr)
输出结果如下 -
以 2 为底的数组:[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
使用 numpy.meshgrid() 函数
numpy.meshgrid() 函数可以根据坐标向量生成坐标矩阵。这对于创建点网格以在二维或三维空间中计算函数非常有用。语法如下:
numpy.meshgrid(*xi, copy=True, sparse=False, indexing='xy')
其中:
*xi - 表示网格坐标的一维数组。
copy(可选)- 如果为 True，则复制输入数组。默认为 True。
sparse(可选)- 如果为 True，则返回稀疏网格以节省内存。默认值为 False。
索引(可选)- 指定笛卡尔坐标("xy"，默认值)或矩阵坐标("ij")的索引约定。
示例:创建二维网格
在下面的示例中，我们使用 numpy.meshgrid() 函数从一维数组"x"和"y"生成坐标矩阵"X"和"Y"，其中 X 表示二维网格的 x 坐标，Y 表示 y 坐标 -
import numpy as np
# 创建 x 和 y 坐标的一维数组
x = np.arange(1, 4)
y = np.arange(1, 3)
# 生成坐标矩阵
X, Y = np.meshgrid(x, y)
print("X grid:")
print(X)
print("Y grid:")
print(Y)
以下是得到的输出 -
X grid: [[1 2 3] [1 2 3]] Y grid: [[1 1 1] [2 2 2]]
示例:创建 3D 网格
现在，我们使用矩阵索引 ('ij')，从一维数组 x、y 和 z 生成 3D 网格的坐标矩阵 X、Y 和 Z -
import numpy as np
# 创建 x、 y 和 z 坐标
x = np.arange(1, 4)
y = np.arange(1, 3)
z = np.arange(1, 3)
# 生成坐标矩阵
X, Y, Z = np.meshgrid(x, y, z, indexing='ij')
print("X grid:")
print(X)
print("Y grid:")
print(Y)
print("Z grid:")
print(Z)
执行上述代码后，我们得到以下输出 -
X grid: [[[1 1] [1 1]] [[2 2] [2 2]] [[3 3] [3 3]]] Y grid: [[[1 1] [2 2]] [[1 1] [2 2]] [[1 1] [2 2]]] Z grid: [[[1 2] [1 2]] [[1 2] [1 2]] [[1 2] [1 2]]]
