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（不包含 10）的数组：

import numpy as np

# Create an array from 0 to 9
arr = np.arange(10)
print("Array using arange():", arr)

获得以下输出：

Array using arange(): [0 1 2 3 4 5 6 7 8 9]

示例：指定起始值、终止值和步长

在这里，我们使用 numpy.arange() 函数生成从 1 到 10（不包含 10），步长为 2 的数组：

import numpy as np

# Create an array from 1 to 9 with a step of 2
arr = np.arange(1, 10, 2)
print("Array with start, stop, and step:", arr)

这将产生以下结果：

Array with start, stop, and step: [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() 函数生成一个从 0 到 1（默认情况下包含 1）的 10 个均匀间隔值的数组：

import numpy as np

# Create an array of 10 evenly spaced values from 0 to 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.        ]

示例：排除端点

在这里，我们使用 numpy.linspace() 函数生成一个从 0 到略小于 1 的 10 个均匀间隔值的数组，不包括端点：

import numpy as np

# Create an array 
arr = np.linspace(0, 1, 10, endpoint=False)
print("Array with endpoint=False:", arr)

获得的输出如下所示：

Array with endpoint=False: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

示例：返回步长

现在，我们生成一个从 0 到 1（默认情况下包含 1）的 10 个均匀间隔值的数组，并返回步长：

import numpy as np

# Create an array 
arr, step = np.linspace(0, 1, 10, retstep=True)
print("Array with step size:", arr)
print("Step size:", step)

执行以上代码后，我们得到以下输出：

Array with step size: [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
Step size: 0.1111111111111111

使用 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() 函数生成一个在对数尺度上从 21 到 210 均匀分布的 10 个值的数组，底数为 2：

import numpy as np

# Create an array 
arr = np.logspace(1, 10, 10, base=2)
print("Array with base 2:", arr)

我们得到以下输出：

Array with base 2: [   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

使用 numpy.meshgrid() 函数

numpy.meshgrid() 函数根据坐标向量生成坐标矩阵。这对于创建用于在 2D 或 3D 空间中评估函数的点网格非常有用。以下是语法：

numpy.meshgrid(*xi, copy=True, sparse=False, indexing='xy')

其中：

  • *xi - 表示网格坐标的 1D 数组。

  • copy (可选) - 如果为 True，则创建输入数组的副本。默认为 True。

  • sparse (可选) - 如果为 True，则返回稀疏网格以节省内存。默认为 False。

  • indexing (可选) - 指定笛卡尔 ('xy'，默认）或矩阵 ('ij') 索引约定。

示例：创建 2D 网格

在下面的示例中，我们使用 numpy.meshgrid() 函数根据 1D 数组 "x" 和 "y" 生成坐标矩阵 "X" 和 "Y"，其中 X 表示 2D 网格的 x 坐标，Y 表示 y 坐标：

import numpy as np

# Create 1D arrays for x and y coordinates
x = np.arange(1, 4)
y = np.arange(1, 3)

# Generate coordinate matrices
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') 为 3D 网格从 1D 数组 x、y 和 z 生成坐标矩阵 X、Y 和 Z：

import numpy as np

# Create 1D arrays for x, y, and z coordinates
x = np.arange(1, 4)
y = np.arange(1, 3)
z = np.arange(1, 3)

# Generate coordinate matrices
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]]]
打印页面
上一页
下一页
广告