NumPy: 绝对初学者的基础知识
欢迎来到 NumPy 的绝对初学者指南！如果你有评论或建议，请不要犹豫联系我们！
欢迎来到 NumPy！
NumPy（Numerical Python）是一个开源的 Python 库，几乎在每个科学和工程领域中都被使用。它是 Python 中处理数值数据的通用标准，在科学 Python 和 PyData 生态系统的核心地位不可撼动。NumPy 的用户包括从初学者程序员到经验丰富的从事最前沿的科学和工业研究与开发的研究人员。NumPy API 在 Pandas、SciPy、Matplotlib、scikit-learn、scikit-image 和大多数其他数据科学和科学 Python 软件包中得到广泛应用。
NumPy 库包含多维数组和矩阵数据结构（你会在后面的章节中找到更多关于这个的信息）。它提供ndarray，一个同构的 n 维数组对象，并提供了一些有效操作的方法。NumPy 可以用来对数组执行各种数学运算。它为 Python 提供了强大的数据结构，保证了对数组和矩阵的高效计算，并提供了一个庞大的高级数学函数库，可用于这些数组和矩阵的操作。
了解更多关于 NumPy 的信息！
安装 NumPy
为了安装 NumPy，我们强烈建议使用科学 Python 发行版。如果你正在寻找在你的操作系统上安装 NumPy 的完整说明，请参阅安装 NumPy。
如果你已经安装了 Python，可以使用以下命令安装 NumPy：
conda install numpy
或者
pip install numpy
如果你还没有安装 Python，你可能想考虑使用Anaconda。这是最简单的入门方式。获取这个发行版的好处是你不需要太担心单独安装 NumPy 或者你将用于数据分析的其他主要软件包，比如 pandas, Scikit-Learn 等等。
如何导入 NumPy
要访问 NumPy 及其函数，请在你的 Python 代码中这样导入：
import numpy as np
我们将导入名称缩短为np，以提高使用 NumPy 的代码的可读性。这是一个被广泛采用的惯例，可以使你的代码对每个人在上面工作时更容易阅读。我们建议始终使用import numpy as np导入。
阅读示例代码
如果你还不习惯阅读包含大量代码的教程，你可能不知道如何解释如下的代码块：
>>> a = np.arange(6) >>> a2 = a[np.newaxis, :] >>> a2.shape (1, 6)
如果您不熟悉这种风格，那么这很容易理解。如果您看到>>>，那么这是 输入，或者您要输入的代码。没有 >>> 的一切都是 输出，或者您代码运行的结果。这是在命令行上运行python时看到的风格，但如果您使用 IPython，可能会看到不同的风格。请注意，它不是代码的一部分，如果键入或粘贴到 Python shell 中会导致错误。可以安全地键入或粘贴到 IPython shell; >>> 会被忽略。
Python 列表和 NumPy 数组之间有什么区别？
NumPy 为您提供了大量快速有效的方式来创建数组并在其中操作数值数据。虽然 Python 列表可以在单个列表内包含不同的数据类型，但 NumPy 数组中的所有元素应该是同类元素。如果数组不同类的话，那么这些数组上执行的数学运算将非常低效。
为什么要使用 NumPy？
NumPy 数组比 Python 列表更快、更紧凑。数组占用更少的内存，使用起来更加方便。NumPy 使用更少的内存存储数据，并提供了一种指定数据类型的机制。这允许进一步优化代码。
什么是数组？
数组是 NumPy 库的核心数据结构。数组是一组值的网格，它包含关于原始数据、如何定位元素以及如何解释元素的信息。它有一组可以用各种方式进行索引的元素。这些元素都是相同类型的，称为数组的 dtype。
数组可以通过非负整数的元组、布尔值、另一个数组或整数进行索引。数组的rank是维度的数量。数组的shape是包含沿每个维度的数组大小的整数元组。
我们初始化 NumPy 数组的一种方法是使用 Python 列表，对于二维或更高维数据，使用嵌套列表。
例如：
>>> a = np.array([1, 2, 3, 4, 5, 6])
或者：
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
我们可以使用方括号访问数组中的元素。访问元素时，请记住 NumPy 中的索引从 0 开始。这意味着如果您要访问数组中的第一个元素，您将访问元素“0”。
>>> print(a[0]) [1 2 3 4]
关于数组的更多信息
本节涵盖 1D 数组，2D 数组，ndarray，向量，矩阵
你可能偶尔会听到将数组称为ndarray，这是“N 维数组”的缩写。一个 N 维数组就是一个具有任意数量维度的数组。您还可能听到1-D，或一维数组，2-D，或二维数组，等等。NumPy 的 ndarray 类用于表示矩阵和向量。向量是一个具有单一维度的数组（行向量和列向量之间没有区别），而矩阵指的是具有两个维度的数组。对于3-D或更高维度的数组，术语张量也经常使用。
数组的属性是什么？
数组通常是相同类型和大小的项目的固定大小容器。数组的维度和项目的数量由其形状定义。数组的形状是一组非负整数的元组，指定了每个维度的大小。
在 NumPy 中，维度被称为轴。这意味着如果你有一个看起来像这样的 2D 数组：
[[0., 0., 0.], [1., 1., 1.]]
您的数组有 2 个轴。第一个轴的长度为 2，第二个轴的长度为 3。
就像在其他 Python 容器对象中一样，可以通过对数组进行索引或切片来访问和修改数组的内容。与典型的容器对象不同，不同的数组可以共享相同的数据，因此对一个数组的更改可能会在另一个数组中可见。
数组的属性反映了数组本身的内在信息。如果需要获取甚至设置数组的属性而不创建新数组，通常可以通过其属性访问数组。
在这里阅读更多关于数组属性的信息 并了解这里的数组对象。
如何创建一个基本数组
本节涵盖 np.array()、np.zeros()、np.ones()、np.empty()、np.arange()、np.linspace()、dtype
要创建一个 NumPy 数组，可以使用函数np.array()。
要创建一个简单的数组，您只需向其传递一个列表。如果愿意，还可以指定列表中的数据类型。您可以在这里找到有关数据类型的更多信息。
>>> import numpy as np >>> a = np.array([1, 2, 3])
您可以通过这种方式将数组可视化：
请注意，这些可视化旨在简化概念并为您提供对 NumPy 概念和机制的基本理解。数组和数组操作比这里呈现的要复杂得多！
除了从一系列元素创建数组之外，您还可以轻松地创建一个填充有0的数组：
>>> np.zeros(2) array([0., 0.])
或者一个由1填充的数组：
>>> np.ones(2) array([1., 1.])
或者甚至一个空数组！函数empty创建一个数组，其初始内容是随机的，并取决于内存的状态。使用empty而不是zeros（或类似物）的原因是速度—只需确保稍后填充每个元素！
>>> # Create an empty array with 2 elements >>> np.empty(2) array([3.14, 42\. ]) # may vary
您可以创建一个具有元素范围的数组：
>>> np.arange(4) array([0, 1, 2, 3])
甚至可以创建一个包含一系列均匀间隔的区间的数组。为此，您需要指定第一个数字、最后一个数字和步长。
>>> np.arange(2, 9, 2) array([2, 4, 6, 8])
您也可以使用np.linspace()在指定的间隔中创建一系列线性间隔的值的数组：
>>> np.linspace(0, 10, num=5) array([ 0\. , 2.5, 5\. , 7.5, 10\. ])
指定您的数据类型
虽然默认数据类型是浮点数（np.float64），您可以明确指定想要的数据类型，使用dtype关键字。
>>> x = np.ones(2, dtype=np.int64) >>> x array([1, 1])
在这里了解更多关于创建数组的信息
添加、删除和排序元素
这个部分涵盖 np.sort()，np.concatenate()
使用np.sort()简单地对元素进行排序。在调用函数时，您可以指定轴、种类和顺序。
如果你从这个数组开始：
>>> arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])
您可以快速将数字按升序排序：
>>> np.sort(arr) array([1, 2, 3, 4, 5, 6, 7, 8])
除了返回数组的排序副本的sort之外，您还可以使用：
argsort，是沿着指定轴的间接排序，lexsort，是多个键的间接稳定排序，searchsorted，用于在排序的数组中查找元素，以及partition是一个部分排序。
要了解更多关于数组排序的内容，请参阅：sort。
如果你从这些数组开始：
>>> a = np.array([1, 2, 3, 4]) >>> b = np.array([5, 6, 7, 8])
你可以使用np.concatenate()将它们连接起来。
>>> np.concatenate((a, b)) array([1, 2, 3, 4, 5, 6, 7, 8])
或者，如果你从这些数组开始：
>>> x = np.array([[1, 2], [3, 4]]) >>> y = np.array([[5, 6]])
你可以用以下方法将它们连接起来：
>>> np.concatenate((x, y), axis=0) array([[1, 2], [3, 4], [5, 6]])
要从数组中删除元素，可以简单地使用索引选择要保留的元素。
要了解更多关于连接的信息，请参阅：concatenate。
如何知道数组的形状和大小？
这个部分涵盖 ndarray.ndim，ndarray.size，ndarray.shape
ndarray.ndim会告诉您数组的轴数，或者维度数。
ndarray.size会告诉您数组中元素的总数。这是数组形状各元素的乘积。
ndarray.shape将显示一个整数元组，表示数组沿每个维度存储的元素数。例如，如果您有一个有 2 行 3 列的二维数组，则数组形状是(2, 3)。
举例来说，如果您创建了这个数组：
>>> array_example = np.array([[[0, 1, 2, 3], ... [4, 5, 6, 7]], ... ... [[0, 1, 2, 3], ... [4, 5, 6, 7]], ... ... [[0 ,1 ,2, 3], ... [4, 5, 6, 7]]])
要找到数组的维度数，请运行：
>>> array_example.ndim 3
要找到数组中元素的总数，请运行：
>>> array_example.size 24
要找到数组的形状，请运行：
>>> array_example.shape (3, 2, 4)
你能调整数组的形状吗？
这一部分涵盖 arr.reshape()
可以！
使用 arr.reshape() 将为数组赋予一个新的形状，而不改变数据。只需记住，当使用 reshape 方法时，你想要生成的数组需要与原始数组具有相同数量的元素。如果你从一个具有 12 个元素的数组开始，你需要确保你的新数组也有总共 12 个元素。
如果你从这个数组开始：
>>> a = np.arange(6) >>> print(a) [0 1 2 3 4 5]
你可以使用 reshape() 来重新塑造你的数组。举个例子，你可以将这个数组重塑成一个具有三行两列的数组：
>>> b = a.reshape(3, 2) >>> print(b) [[0 1] [2 3] [4 5]]
通过 np.reshape，你可以指定一些可选的参数：
>>> np.reshape(a, newshape=(1, 6), order='C') array([[0, 1, 2, 3, 4, 5]])
a 是待重塑的数组。
newshape 是你想要的新形状。你可以指定一个整数或一个整数元组。如果你指定一个整数，结果将是一个具有该长度的数组。新形状应该与原始形状兼容。
order: C 表示使用类 C 索引顺序读取/写入元素，F 表示使用类 Fortran 索引顺序读取/写入元素，A 表示如果 a 在内存中是 Fortran 连续的，则使用类 Fortran 索引顺序读取/写入元素，否则使用类 C 顺序。（这是一个可选参数，不需要指定。）
如果你想了解关于 C 和 Fortran 顺序的更多信息，你可以在这里读更多关于 NumPy 数组内部组织的信息。基本上，C 和 Fortran 顺序与索引如何对应到数组在内存中的存储顺序有关。在 Fortran 中，移动二维数组元素时，第一个索引是变化最快的索引。当第一个索引改变时，矩阵按列存储在内存中一列一列地变化。这就是为什么 Fortran 被认为是一种基于列的语言。而在 C 中，最后一个索引最快变化。矩阵按行存储，使之成为基于行的语言。你使用 C 或 Fortran 取决于是否更重要地保持索引约定或者不重新排序数据。
在这里了解更多有关形状操作的信息。
如何将一个一维数组转换为二维数组（如何给数组添加一个新的轴）
这一节介绍了 np.newaxis，np.expand_dims
你可以使用 np.newaxis 和 np.expand_dims 来增加现有数组的维度。
使用 np.newaxis 会在使用一次后将数组的维度增加一维。这意味着1D 数组将成为2D 数组，2D 数组将成为3D 数组，依此类推。
举个例子，如果你从这个数组开始：
>>> a = np.array([1, 2, 3, 4, 5, 6]) >>> a.shape (6,)
你可以使用 np.newaxis 来添加一个新的轴：
>>> a2 = a[np.newaxis, :] >>> a2.shape (1, 6)
你可以使用 np.newaxis 明确地将一维数组转换为行向量或列向量。例如，你可以通过在第一维度插入一个轴将一维数组转换为行向量：
>>> row_vector = a[np.newaxis, :] >>> row_vector.shape (1, 6)
或者，对于列向量，你可以在第二维度插入一个轴：
>>> col_vector = a[:, np.newaxis] >>> col_vector.shape (6, 1)
你也可以使用np.expand_dims在指定位置插入一个新轴。
例如，如果你从这个数组开始：
>>> a = np.array([1, 2, 3, 4, 5, 6]) >>> a.shape (6,)
你可以使用np.expand_dims在索引位置 1 处添加一个轴：
>>> b = np.expand_dims(a, axis=1) >>> b.shape (6, 1)
你可以在索引位置 0 处添加一个轴：
>>> c = np.expand_dims(a, axis=0) >>> c.shape (1, 6)
在这里找到关于 newaxis 的更多信息和关于expand_dims的expand_dims。
索引和切片
你可以使用与 Python 列表切片相同的方式对 NumPy 数组进行索引和切片。
>>> data = np.array([1, 2, 3]) >>> data[1] 2 >>> data[0:2] array([1, 2]) >>> data[1:] array([2, 3]) >>> data[-2:] array([2, 3])
你可以这样可视化它：
你可能想取数组的一部分或特定的数组元素，用于进一步分析或其他操作。为此，您需要对数组进行子集、切片和/或索引。
如果你想要选择符合特定条件的数组中的值，使用 NumPy 是很直接的。
例如，如果你从这个数组开始：
>>> a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
你可以轻松地打印数组中所有小于 5 的值。
>>> print(a[a < 5]) [1 2 3 4]
你还可以选择等于或大于 5 的数字，并用该条件对数组进行索引。
>>> five_up = (a >= 5) >>> print(a[five_up]) [ 5 6 7 8 9 10 11 12]
你可以选择可被 2 整除的元素：
>>> divisible_by_2 = a[a%2==0] >>> print(divisible_by_2) [ 2 4 6 8 10 12]
或者你可以使用&和|运算符选择满足两个条件的元素：
>>> c = a[(a > 2) & (a < 11)] >>> print(c) [ 3 4 5 6 7 8 9 10]
你还可以使用逻辑运算符**&和|**来返回布尔值，指定数组中的值是否满足某个条件。这对于包含名称或其他分类值的数组非常有用。
>>> five_up = (a > 5) | (a == 5) >>> print(five_up) [[False False False False] [ True True True True] [ True True True True]]
你还可以使用np.nonzero()从数组中选择元素或索引。
从这个数组开始：
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
你可以使用np.nonzero()打印小于 5 的元素的索引：
>>> b = np.nonzero(a < 5) >>> print(b) (array([0, 0, 0, 0]), array([0, 1, 2, 3]))
在这个例子中，返回了一个数组的元组：每个维度一个数组。第一个数组表示这些值所在的行索引，第二个数组表示这些值所在的列索引。
如果你想要生成一个元素存在的坐标列表，你可以将数组进行组合，遍历坐标列表，并打印它们。例如：
>>> list_of_coordinates= list(zip(b[0], b[1])) >>> for coord in list_of_coordinates: ... print(coord) (0, 0) (0, 1) (0, 2) (0, 3)
你也可以使用np.nonzero()打印数组中小于 5 的元素：
>>> print(a[b]) [1 2 3 4]
如果你要查找的元素在数组中不存在，则返回的索引数组将为空。例如：
>>> not_there = np.nonzero(a == 42) >>> print(not_there) (array([], dtype=int64), array([], dtype=int64))
在这里了解更多关于索引和切片的信息和这里。
在这里阅读有关使用 nonzero 函数的更多信息：nonzero。
如何从现有数据创建数组
这部分涵盖切片和索引、np.vstack()、np.hstack()、np.hsplit()、.view()、copy()
你可以轻松地从现有数组的一部分创建一个新数组。
假设你有这个数组：
>>> a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
你可以随时通过指定想要切片的位置来从数组的一个部分创建新数组。
>>> arr1 = a[3:8] >>> arr1 array([4, 5, 6, 7, 8])
在这里，你从索引位置 3 到索引位置 8 取出了数组的一个部分。
你还可以垂直和水平堆叠两个已经存在的数组。假设你有两个数组，a1和a2：
>>> a1 = np.array([[1, 1], ... [2, 2]]) >>> a2 = np.array([[3, 3], ... [4, 4]])
你可以使用vstack将它们垂直堆叠：
>>> np.vstack((a1, a2)) array([[1, 1], [2, 2], [3, 3], [4, 4]])
或者使用hstack将它们水平堆叠：
>>> np.hstack((a1, a2)) array([[1, 1, 3, 3], [2, 2, 4, 4]])
你可以使用hsplit将数组分割成几个更小的数组。你可以指定要返回的形状相同的数组的数量，也可以指定分割应发生的列的位置。
假设你有这个数组：
>>> x = np.arange(1, 25).reshape(2, 12) >>> x array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])
如果你想将这个数组等分成三个形状相同的数组，你需要运行：
>>> np.hsplit(x, 3) [array([[ 1, 2, 3, 4], [13, 14, 15, 16]]), array([[ 5, 6, 7, 8], [17, 18, 19, 20]]), array([[ 9, 10, 11, 12], [21, 22, 23, 24]])]
如果你想在第三和第四列后分割你的数组，你需要运行：
>>> np.hsplit(x, (3, 4)) [array([[ 1, 2, 3], [13, 14, 15]]), array([[ 4], [16]]), array([[ 5, 6, 7, 8, 9, 10, 11, 12], [17, 18, 19, 20, 21, 22, 23, 24]])]
在这里了解更多有关堆叠和分割数组。
你可以使用view方法创建一个查看原始数组相同数据的新数组对象（浅复制）。
视图是 NumPy 中的重要概念！ 在可能的情况下，NumPy 函数以及诸如索引和切片之类的操作都会返回视图。这样可以节省内存并提高速度（数据不需要复制）。然而，了解这一点很重要 - 在视图中修改数据也会修改原始数组！
假设你创建了这个数组：
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
现在我们通过切片a创建一个数组b1，并修改b1的第一个元素。这将同时修改a中对应的元素！
>>> b1 = a[0, :] >>> b1 array([1, 2, 3, 4]) >>> b1[0] = 99 >>> b1 array([99, 2, 3, 4]) >>> a array([[99, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]])
使用copy方法将创建数组的完整副本和数据（深复制）。你可以运行以下命令来使用它在数组上：
>>> b2 = a.copy()
在这里了解有关复制和视图的更多内容。
基本数组操作
本节涵盖了加法、减法、乘法、除法等内容
创建数组后，你可以开始使用它们。例如，你创建了两个名为“data”和“ones”的数组
你可以用加号将数组相加。
>>> data = np.array([1, 2]) >>> ones = np.ones(2, dtype=int) >>> data + ones array([2, 3])
当然，你当然还可以进行更多操作！
>>> data - ones array([0, 1]) >>> data * data array([1, 4]) >>> data / data array([1., 1.])
在 NumPy 中，基本操作非常简单。如果你想要找到数组中元素的总和，你可以使用sum()。这适用于 1D 数组、2D 数组以及更高维度的数组。
>>> a = np.array([1, 2, 3, 4]) >>> a.sum() 10
要对 2D 数组的行或列进行加法，你需要指定轴。
如果你从这个数组开始：
>>> b = np.array([[1, 1], [2, 2]])
你可以通过以下方式对行轴求和：
>>> b.sum(axis=0) array([3, 3])
你可以通过以下方式对列轴求和：
>>> b.sum(axis=1) array([2, 4])
在这里了解更多有关基本操作的内容。
广播
有时你可能想要在数组和单个数字之间进行操作（也称为向量和标量之间的操作）或者在两个不同大小的数组之间进行操作。例如，你的数组（我们称之为“数据”）可能包含了以英里为单位的距离信息，但你想要将信息转换为公里。你可以通过以下操作来实现：
>>> data = np.array([1.0, 2.0]) >>> data * 1.6 array([1.6, 3.2])
NumPy 理解乘法应该发生在每个单元格上。这个概念被称为广播。广播是一种机制，允许 NumPy 对不同形状的数组执行操作。你的数组的维度必须兼容，例如，当两个数组的维度相等时，或者其中一个维度是 1 时。如果维度不兼容，你将得到一个ValueError。
在这里了解更多关于广播的信息。
更有用的数组操作
本节涵盖最大值、最小值、和、平均值、乘积、标准差等内容
NumPy 还执行聚合函数。除了min、max和sum之外，你还可以轻松地运行mean得到平均值，prod得到乘积的结果，std得到标准差等。
>>> data.max() 2.0 >>> data.min() 1.0 >>> data.sum() 3.0
让我们从这个名为“a”的数组开始
>>> a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652], ... [0.54627315, 0.05093587, 0.40067661, 0.55645993], ... [0.12697628, 0.82485143, 0.26590556, 0.56917101]])
想要沿着行或列进行聚合通常很常见。默认情况下，每个 NumPy 聚合函数将返回整个数组的聚合结果。要找到数组中元素的和或最小值，运行：
>>> a.sum() 4.8595784
或者：
>>> a.min() 0.05093587
你可以指定要计算聚合函数的轴。例如，你可以通过指定axis=0来找到每列中的最小值。
>>> a.min(axis=0) array([0.12697628, 0.05093587, 0.26590556, 0.5510652 ])
上述四个值对应于数组中列的数量。对于一个有四列的数组，你将得到四个值作为你的结果。
阅读更多关于 数组方法的内容。
创建矩阵
你可以传递 Python 的列表列表来创建一个 2-D 数组（或“矩阵”）以在 NumPy 中表示它们。
>>> data = np.array([[1, 2], [3, 4], [5, 6]]) >>> data array([[1, 2], [3, 4], [5, 6]])
当你操作矩阵时，索引和切片操作非常有用：
>>> data[0, 1] 2 >>> data[1:3] array([[3, 4], [5, 6]]) >>> data[0:2, 0] array([1, 3])
你可以像聚合向量那样聚合矩阵：
>>> data.max() 6 >>> data.min() 1 >>> data.sum() 21
你可以聚合矩阵中的所有值，你还可以使用axis参数沿行或列进行聚合。为了说明这一点，让我们看一个稍微修改过的数据集：
>>> data = np.array([[1, 2], [5, 3], [4, 6]]) >>> data array([[1, 2], [5, 3], [4, 6]]) >>> data.max(axis=0) array([5, 6]) >>> data.max(axis=1) array([2, 5, 6])
一旦你创建了你的矩阵，如果你有两个大小相同的矩阵，你可以使用算术运算符对它们进行加法和乘法运算。
>>> data = np.array([[1, 2], [3, 4]]) >>> ones = np.array([[1, 1], [1, 1]]) >>> data + ones array([[2, 3], [4, 5]])
你可以对不同大小的矩阵进行这些算术运算，但前提是一个矩阵只有一列或一行。在这种情况下，NumPy 将使用其操作的广播规则。
>>> data = np.array([[1, 2], [3, 4], [5, 6]]) >>> ones_row = np.array([[1, 1]]) >>> data + ones_row array([[2, 3], [4, 5], [6, 7]])
请注意，当 NumPy 打印 N 维数组时，最后一个轴最快地循环，而第一个轴最慢。例如：
>>> np.ones((4, 3, 2)) array([[[1., 1.], [1., 1.], [1., 1.]], [[1., 1.], [1., 1.], [1., 1.]], [[1., 1.], [1., 1.], [1., 1.]], [[1., 1.], [1., 1.], [1., 1.]]])
常常有这样的情况，我们希望 NumPy 初始化数组的值。NumPy 提供了ones()、zeros()和random.Generator类来生成随机数，你只需传递你想要生成的元素数量即可：
>>> np.ones(3) array([1., 1., 1.]) >>> np.zeros(3) array([0., 0., 0.]) >>> rng = np.random.default_rng() # the simplest way to generate random numbers >>> rng.random(3) array([0.63696169, 0.26978671, 0.04097352])
你还可以使用ones()、zeros()和random()来创建 2D 数组，只要给它们一个描述矩阵维度的元组。
>>> np.ones((3, 2)) array([[1., 1.], [1., 1.], [1., 1.]]) >>> np.zeros((3, 2)) array([[0., 0.], [0., 0.], [0., 0.]]) >>> rng.random((3, 2)) array([[0.01652764, 0.81327024], [0.91275558, 0.60663578], [0.72949656, 0.54362499]]) # may vary
阅读更多关于创建数组，填充为0、1、其他值或未初始化的信息，参见数组创建例程。
产生随机数
随机数生成的使用是许多数值和机器学习算法配置和评估的重要部分。不管你需要在人工神经网络中随机初始化权重，将数据拆分为随机集，还是随机洗牌你的数据集，能够生成随机数（实际上是可重复的伪随机数）是必不可少的。
使用Generator.integers，你可以从低值（请记住这在 NumPy 中是包含在内的）生成随机整数到高值（不包括）。你可以设置endpoint=True使得高值包括在内。
你可以生成一个 2 x 4 的随机整数数组，范围在 0 到 4 之间：
>>> rng.integers(5, size=(2, 4)) array([[2, 1, 1, 0], [0, 0, 0, 4]]) # may vary
在此处阅读更多关于随机数生成的信息。
NumPy 1.26 中文官方指南（二）（2）https://developer.aliyun.com/article/1510606
