推荐：使用NSDT场景编辑器快速搭建3D应用场景

什么是 Numpy？

Numpy、Scipy 和 Matplotlib 是数据科学项目中使用的 Python 库，它们提供类似 MATLAB 的功能。

图片来自维基百科

主要是，Numpy具有以下功能：

1. 类型化多维数组（矩阵）
2. 快速数值计算（矩阵数学）
3. 高级数学函数

Numpy代表Numerical Python，是高性能计算和数据分析所需的基本软件包。NumPy对于Python中的数值计算是必需的，因为它是为大型数据数组的效率而设计的。

创建 numpy 数组的不同方法

在开始对 numpy 数组进行操作之前，我们的第一个目标是熟练地根据问题陈述根据我们的要求创建 numpy 数组。

有多种方法可以创建 numpy 数组。下面提到了一些标准和实用的方法：

案例 1：使用 np.ones 方法创建数组：

如果我们必须创建一个只有“一”的数组，你可以利用这种方法。

np.ones((3,5), dtype=np.float32)
#Output
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]

案例 2：使用 np.zeros 方法创建零数组：

如果我们必须创建一个只有“零”的数组，你可以使用这种方法。

np.zeros((6,2), dtype=np.int8)
# Output
[[0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]]

案例 3：使用 np.arange 方法：

如果必须按照序列创建元素数组，则可以使用此方法。

np.arange(1334,1338)
#Output
[1334 1335 1336 1337]

案例 4：使用 np.concatenate 方法：

当您所需的数组组合一个或多个数组时，此方法是正确的。

A = np.ones((2,3))
B = np.zeros((4,3))
C = np.concatenate([A, B])
#Output
[[1. 1. 1.]
 [1. 1. 1.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

案例 5：使用 np.random.random 方法：

在创建具有随机值的数组时，它很有用。

np.random.random((2,3))
#Output
[[0.30512345 0.10055724 0.89505387]
 [0.36219316 0.593805   0.7643694 ]]

Numpy 数组操作

让我们通过一个例子来讨论 numpy 数组的基本属性：

法典：

a = numpy.array([[1,2,3],[4,5,6]],dtype=numpy.float32)
# Array dimensions, shape, and data types
print (a.ndim, a.shape, a.dtype)
Output:
2 (2, 3) float32

基于上面的代码，我们有以下几点要记住作为结论：

1. 数组可以将任何维度作为正整数，包括零（对应于标量值）。
2. 数组是类型化的，可以具有数据类型，例如 np.uint8、np.int64、np.float32、np.float64
3. 数组是密集的。数组的每个元素都存在并具有相同的类型。

法典：

# Arrays reshaping
a = numpy.array([1,2,3,4,5,6])
a = a.reshape(3,2)              
#Output: 
[[1 2]                 
[3 4]                           
[5 6]]

a = a.reshape(2,-1)
#Output: 
[[1 2 3]
 [4 5 6]]

a = a.ravel()
#Output:  
[1 2 3 4 5 6]

要记住的要点：

1. 整形操作后，数组中的元素总数无法更改。
2. 要推断轴形状，请使用 -1。
3. 默认情况下，它以行主格式存储元素，而另一方面，在 MATLAB 中，它是列主格式。

数字阵列广播

广播允许对不同形状的数组执行操作，只要它们兼容。数组的较小维度实际上会扩展以匹配较大数组的维度。

图片来自Javatpoint

法典：

# arrays broadcasting
a = numpy.array([[1, 2], [3, 4], [5, 6]])
b = numpy.array([10, 20])
c = a + b  # Broadcasting the 'b' array to match the dimensions of 'a'

该示例涉及维度为 （2， 3） 的 2D NumPy 数组“a”和形状为 （1） 的一维数组“b”。广播允许操作“a + b”虚拟扩展“b”以匹配二维中的“a”，从而在“a”和扩展的“b”之间逐元素加法。

数组索引和切片

1. 切片是视图。写入切片会覆盖原始数组。
2. 列表或布尔数组也可以为其编制索引。
3. Python 索引语法：

start_index ： stop_index： step_size

法典：

a = list(range(10)) 

 # first 3 elements
a[:3] # indices 0, 1, 2 

# last 3 elements
a[-3:] # indices 7, 8, 9 

# indices 3, 5, 7 
a[3:8:2] 

# indices 4, 3, 2 (this one is tricky)
a[4:1:-1] 

如您所知，图像也可以可视化为多维数组。因此，切片也有助于对图像执行一些数学运算。下面提到了一些重要和高级示例，以增加您的理解：

# Select all but one-pixel border 
pixel_matrix[1:-1,1:-1] 		

# swap channel order 
pixel_matrix = pixel_matrix[:,:,::-1]

# Set dark pixels to black 	
pixel_matrix[pixel_matrix<10] = 0

# select 2nd and 4th-row		
pixel_matrix[[1,3], :]	

阵列聚合和缩减

现在，我们将从 numpy 数组上的聚合操作开始。通常，您可以执行的操作如下：

1. 查找数组中所有元素的总和和乘积。
2. 查找数组中的最大值和最小值元素
3. 查找数组中特定元素的计数
4. 我们还可以使用线性代数模块找到其他参数，包括矩阵行列式、矩阵迹线、矩阵特征值和特征向量等。

让我们通过示例开始讨论每个功能：

案例 1：数组中存在的所有元素的代数和

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.sum())
#Output: 
21

案例 2：数组中的最大元素

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.max())
#Output: 
6

案例 3：数组中的最小元素

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.min())
#Output: 
1

案例 4：数组中最大元素所在的元素的位置/索引

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmax())
#Output: 
5

案例 5：数组中最小元素所在的元素的位置/索引

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmin())
#Output: 
0

在查找位置时，您可以观察到它将任何多维数组视为一维数组，然后对其进行计算。

案例 6：数组中所有元素的平均值/平均值

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.mean())
#Output: 
3.5

案例7：二维数组的点积/标量积

array_1 = numpy.array([[1,2], [4,5]])
array_2 = numpy.array([[1,-1,2], [3,7,-2]])
t = array_1.dot(array_2)
print(t)
#Output: 
[[ 7 13 -2]
 [19 31 -2]]

数字数组中的矢量化

矢量化允许对整个数组执行操作，而不是遍历单个元素。它利用优化的低级例程，从而产生更快、更简洁的代码。

法典：

a = numpy.array([1, 2, 3, 4, 5])
b = numpy.array([10, 20, 30, 40, 50])
c = a + b  # Element-wise addition without explicit loops

根据上面的示例，您可以看到创建了两个名为“a”和“b”的 NumPy 数组。在执行操作 'a + b' 时，我们使用矢量化概念在数组之间执行逐元素加法，从而生成一个新的数组 'c'，其中包含来自 'a' 和 'b' 的相应元素之和。因此，由于元素操作，程序避免运行显式循环，并利用优化的例程进行高效计算。

数组串联

情况 1：假设您有两个或多个数组要使用 concatenate 函数进行连接，您必须在其中连接数组的元组。

法典：

# concatenate 2 or more arrays using concatenate function row-wise
numpy_array_1 = numpy.array([1,2,3])
numpy_array_2 = numpy.array([4,5,6])
numpy_array_3 = numpy.array([7,8,9])
array_concatenate = numpy.concatenate((numpy_array_1, numpy_array_2, numpy_array_3))
print(array_concatenate)
#Output:
[1 2 3 4 5 6 7 8 9]

情况 2：假设您有一个具有多个维度的数组;然后，要连接数组，您必须提及必须连接这些数组的轴。否则，它将沿第一个维度执行。

法典：

# concatenate 2 or more arrays using concatenate function column-wise
array_1 = numpy.array([[1,2,3], [4,5,6]])
array_2 = numpy.array([[7,8,9], [10, 11, 12]])
array_concatenate = numpy.concatenate((array_1, array_2), axis=1)
print(array_concatenate)
#Output:
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

数学函数和通用函数

这些通用函数也称为 ufuncs。在这些函数中执行元素操作。例如：

1. NP.exp
2. NP.sqrt
3. 新冼
4. NP.cos
5. np.isnan

法典：

A = np.array([1,4,9,16,25])
B = np.sqrt(A)
#Output
[1. 2. 3. 4. 5.]

性能比较

在执行数值计算时，如果我们有大量的计算，Python 需要很多时间。如果我们取一个形状为 1000 x 1000 的矩阵并进行矩阵乘法，那么 Python 和 numpy 所需的时间是：

1. Python 三重循环需要 > 10 分钟
2. 数字需要 ~0.03 秒

因此，从上面的例子中，我们可以看到numpy需要的时间比标准python少得多，因此在与数据科学相关的现实生活中，我们的延迟减少了，数据科学有大量数据需要处理。

包起来

在本文中，我们讨论了 numpy 数组。因此，为了结束我们的会议，让我们总结一下numpy相对于Python的优势：

1. Numpy具有面向阵列的计算。
2. Numpy有效地实现了多维数组。
3. Numpy主要是为科学计算而设计的。
4. Numpy 包含标准的数学函数，可以在没有循环的数组上更快地计算。
5. Numpy 具有内置的线性代数和随机数生成模块，可以使用傅里叶变换功能。
6. Numpy还包含用于读取和写入数组到磁盘以及处理内存映射文件的工具。

原文链接：提升数学效率：导航 Numpy 数组操作 (mvrlink.com)