NumPy：Python中的强大数学工具

NumPy：Python中的强大数学工具

一、NumPy简介

当谈到数据科学和数值计算时，NumPy是Python编程语言中最重要的软件库之一。NumPy提供了强大的多维数组对象和一系列高效的函数和操作，以便在Python中进行数值计算和科学计算。

NumPy的核心是ndarray，即n-dimensional array，一种用于存储和处理多维数组的数据结构。NumPy中的数组可以包含不同类型的数据，包括整数、浮点数、布尔值和字符串等，这使得NumPy数组非常灵活。

NumPy的另一个关键功能是它提供了许多用于数组操作和计算的函数。例如，可以使用NumPy中的函数进行向量化操作，即对整个数组进行操作，而不是对数组中的每个元素进行单独的操作。这种向量化操作可以大大提高计算速度。

除了基本的数组操作和函数之外，NumPy还提供了许多其他的功能。例如，NumPy中有用于线性代数、随机数生成、傅里叶变换、信号处理和图像处理等领域的函数和类。此外，NumPy还可以与其他Python库和工具集（如Pandas和Matplotlib）集成使用，以便进行更复杂的数据分析和可视化。

总之，NumPy是Python编程语言中最重要的软件库之一，提供了强大的多维数组对象和一系列高效的函数和操作，使得Python成为一种优秀的数值计算和科学计算的工具。

二、创建数组

在NumPy中，有几种方法可以创建数组。以下是其中几种常见的方法：

1. 使用numpy.array()函数创建数组：这是一种最基本的创建数组的方法，它接受一个序列（例如Python列表或元组）作为输入，并将其转换为NumPy数组。例如，下面的代码将Python列表转换为NumPy数组：

   import numpy as np
   
   a = np.array([1, 2, 3, 4, 5])
   print(a)
   

   [1 2 3 4 5]
   

2. 使用numpy.zeros()函数创建数组：这个函数创建一个由0组成的数组，并指定数组的形状。例如，下面的代码创建一个形状为（3, 4）的二维数组：

   import numpy as np
   
   a = np.zeros((3, 4))
   print(a)
   

   [[0. 0. 0. 0.]
    [0. 0. 0. 0.]
    [0. 0. 0. 0.]]
   

3. 使用numpy.ones()函数创建数组：这个函数创建一个由1组成的数组，并指定数组的形状。例如，下面的代码创建一个形状为（2, 3）的二维数组：

   import numpy as np
   
   a = np.ones((2, 3))
   print(a)
   

   [[1. 1. 1.]
    [1. 1. 1.]]
   

4. 使用numpy.arange()函数创建数组：这个函数创建一个等差数列，并将其转换为NumPy数组。例如，下面的代码创建一个由1到9的整数组成的数组：

   import numpy as np
   
   a = np.arange(1, 10)
   print(a)
   

   [1 2 3 4 5 6 7 8 9]
   

5. 使用numpy.linspace()函数创建数组：这个函数创建一个在指定范围内均匀分布的数组。例如，下面的代码创建一个由0到1之间的5个数字组成的数组：

   import numpy as np
   
   a = np.linspace(0, 1, 5)
   print(a)
   

   [0.   0.25 0.5  0.75 1.  ]
   

这些是一些在NumPy中创建数组的常用方法和示例。这些函数提供了许多选项，可以进一步自定义数组的形状、数据类型和其他特性。

三、数组尺寸

在NumPy中，可以使用shape属性获取数组的尺寸，它返回一个表示数组形状的元组，其中元组中的每个值表示该维度的大小。以下是一些示例：

import numpy as np

# 创建一个二维数组
a = np.array([[1, 2, 3], [4, 5, 6]])

# 获取数组的形状
print(a.shape)  # 输出 (2, 3)

# 创建一个三维数组
b = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

# 获取数组的形状
print(b.shape)  # 输出 (2, 2, 2)

# 创建一个一维数组
c = np.array([1, 2, 3, 4, 5])

# 获取数组的形状
print(c.shape)  # 输出 (5,)

在第一个示例中，我们创建了一个2x3的二维数组，并使用shape属性获取其形状，它返回一个元组(2, 3)。在第二个示例中，我们创建了一个2x2x2的三维数组，并使用shape属性获取其形状，它返回一个元组(2, 2, 2)。在第三个示例中，我们创建了一个包含5个元素的一维数组，并使用shape属性获取其形状，它返回一个元组(5,)，这里使用的逗号表示这是一个元组，而不是单个整数。

除了shape属性之外，NumPy还提供了许多其他的属性和方法，用于获取和操作数组的尺寸和形状，例如ndim属性、size属性、reshape()方法等。这些方法可以帮助您更好地了解和操作数组的结构和形状。

四、数组运算

NumPy中的数组运算可以使用各种数学运算符和NumPy中提供的函数完成。以下是一些示例：

import numpy as np

# 创建两个数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 加法
c = a + b
print(c)  # 输出 [5 7 9]

# 减法
d = a - b
print(d)  # 输出 [-3 -3 -3]

# 乘法
e = a * b
print(e)  # 输出 [ 4 10 18]

# 除法
f = a / b
print(f)  # 输出 [0.25 0.4  0.5 ]

# 按位求幂
g = a ** b
print(g)  # 输出 [  1  32 729]

# 按位取余
h = a % b
print(h)  # 输出 [1 2 3]

# 求平方根
i = np.sqrt(a)
print(i)  # 输出 [1.         1.41421356 1.73205081]

在上面的示例中，我们创建了两个NumPy数组a和b，然后使用加法、减法、乘法、除法、按位求幂、按位取余和求平方根等运算符对它们进行了各种运算。对于所有这些运算，NumPy会对数组的每个元素进行相应的运算。

此外，NumPy还提供了许多其他函数，用于对数组进行各种操作，例如sum()、mean()、std()、min()、max()等，这些函数可以对数组进行聚合操作，或者对数组中的元素进行排序、比较等操作。这些函数可以帮助您更好地了解和操作NumPy数组。

五、数组切片

在NumPy中，可以使用切片操作从数组中获取子数组或部分元素。切片操作使用[start:stop:step]的语法，其中start表示子数组的起始索引，stop表示子数组的结束索引（不包括该索引对应的元素），step表示切片步长。以下是一些示例：

import numpy as np

# 创建一个一维数组
a = np.array([1, 2, 3, 4, 5])

# 获取前三个元素
b = a[:3]
print(b)  # 输出 [1 2 3]

# 获取第二个到第四个元素
c = a[1:4]
print(c)  # 输出 [2 3 4]

# 获取每隔一个元素的子数组
d = a[::2]
print(d)  # 输出 [1 3 5]

# 反转数组
e = a[::-1]
print(e)  # 输出 [5 4 3 2 1]

# 创建一个二维数组
f = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 获取第一行
g = f[0, :]
print(g)  # 输出 [1 2 3]

# 获取第二列
h = f[:, 1]
print(h)  # 输出 [2 5 8]

# 获取前两行和前两列的子数组
i = f[:2, :2]
print(i)  # 输出 [[1 2] [4 5]]

在上面的示例中，我们首先创建了一个一维数组a和一个二维数组f，然后使用切片操作从这些数组中获取子数组或部分元素。我们可以使用索引和切片操作来访问一维和多维数组的不同部分，这些操作可以让我们更方便地操作和处理数组中的数据。

六、数组连接

在NumPy中，可以使用各种函数将两个或多个数组连接在一起，以形成更大的数组。以下是一些示例：

import numpy as np

# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 水平连接两个数组
c = np.hstack((a, b))
print(c)  # 输出 [1 2 3 4 5 6]

# 垂直连接两个数组
d = np.vstack((a, b))
print(d)
# 输出 [[1 2 3]
#        [4 5 6]]

# 深度连接两个数组
e = np.dstack((a, b))
print(e)
# 输出 [[[1 4]
#         [2 5]
#         [3 6]]]

# 创建两个二维数组
f = np.array([[1, 2], [3, 4]])
g = np.array([[5, 6], [7, 8]])

# 水平连接两个数组
h = np.hstack((f, g))
print(h)
# 输出 [[1 2 5 6]
#        [3 4 7 8]]

# 垂直连接两个数组
i = np.vstack((f, g))
print(i)
# 输出 [[1 2]
#        [3 4]
#        [5 6]
#        [7 8]]

# 深度连接两个数组
j = np.dstack((f, g))
print(j)
# 输出 [[[1 5]
#         [2 6]]
#        [[3 7]
#         [4 8]]]

在上面的示例中，我们创建了一些数组，并使用hstack()、vstack()和dstack()函数将它们连接在一起。这些函数可以将两个或多个数组沿着不同的维度连接起来，例如在一维数组中进行水平连接，在二维数组中进行水平、垂直和深度连接。这些函数可以帮助我们更方便地将不同的数组组合在一起，并进行一些更复杂的操作和分析。

七、数据存取

NumPy提供了两个函数np.save()和np.load()，用于将数组存储到磁盘文件中以及从磁盘文件中加载数组。

• np.save(file, arr, allow_pickle=True, fix_imports=True)：将数组存储到磁盘文件中。
  • file：文件名，字符串类型。
  • arr：要保存的数组。
  • allow_pickle：是否允许pickle序列化。默认为True。
  • fix_imports：如果为True，则为Python 2和Python 3兼容性而导入pickle模块。默认为True。
• np.load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')：从磁盘文件中加载数组。
  • file：文件名，字符串类型。
  • mmap_mode：如果给定，使用内存映射来加速读取大文件。默认为None。
  • allow_pickle：是否允许pickle序列化。默认为True。
  • fix_imports：如果为True，则为Python 2和Python 3兼容性而导入pickle模块。默认为True。
  • encoding：如果数据文件是文本文件，则指定文件的编码格式。默认为’ASCII’。

以下是一个简单的示例，演示了如何使用np.save()和np.load()函数来保存和加载数组：

import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])

# 保存数组到文件
np.save('my_array.npy', arr)

# 加载文件中的数组
loaded_array = np.load('my_array.npy')

# 打印加载的数组
print(loaded_array)

在上面的示例中，我们首先创建一个数组arr，然后使用np.save()函数将它保存到文件my_array.npy中。接着，我们使用np.load()函数从文件中加载数组，并将其存储在loaded_array变量中。最后，我们打印loaded_array，以确认我们已经成功地加载了数组。注意，文件名包含文件扩展名.npy。保存和加载多维数组的方法与此类似，只是需要将数组作为参数传递给相应的函数。

八、数组形态变换

NumPy提供了一些方法，可以用于改变数组的形状或者大小。下面是几个常用的方法，并给出相应的示例：

1. reshape()方法：改变数组的形状，不改变元素个数

   import numpy as np
   
   # 创建一个3x4的数组
   arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
   
   # 将数组形状变为4x3
   new_arr = arr.reshape(4, 3)
   
   print(new_arr)
   

   array([[ 1,  2,  3],
          [ 4,  5,  6],
          [ 7,  8,  9],
          [10, 11, 12]])
   

2. resize()方法：改变数组的形状和大小

   import numpy as np
   
   # 创建一个3x4的数组
   arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
   
   # 改变数组的形状和大小为4x5
   arr.resize(4, 5)
   
   print(arr)
   

   array([[ 1,  2,  3,  4,  5],
          [ 6,  7,  8,  9, 10],
          [11, 12,  0,  0,  0],
          [ 0,  0,  0,  0,  0]])
   

3. transpose()方法：交换数组的维度

   import numpy as np
   
   # 创建一个3x4的数组
   arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
   
   # 交换数组的维度
   new_arr = arr.transpose()
   
   print(new_arr)
   

   array([[ 1,  5,  9],
          [ 2,  6, 10],
          [ 3,  7, 11],
          [ 4,  8, 12]])
   

4. flatten()方法：将数组展开为一维数组

   import numpy as np
   
   # 创建一个3x4的数组
   arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
   
   # 将数组展开为一维数组
   new_arr = arr.flatten()
   
   print(new_arr)
   

   array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])
   

这些方法可以方便地对数组进行形态变换，但需要注意的是，有些方法会直接修改原始数组的形状，而有些方法则会返回一个新的数组。在使用这些方法时，需要根据具体的需求来选择合适的方法来实现。

九、数组排序与搜索

NumPy提供了一些方法，可以对数组进行排序和搜索。下面是几个常用的方法，并给出相应的示例：

1. sort()方法：对数组进行排序

   import numpy as np
   
   # 创建一个随机数组
   arr = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
   
   # 对数组进行排序
   arr.sort()
   
   print(arr)
   

   array([1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9])
   

2. argsort()方法：返回数组排序后的索引值

   import numpy as np
   
   # 创建一个随机数组
   arr = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
   
   # 返回数组排序后的索引值
   idx = arr.argsort()
   
   print(idx)
   

   array([ 1,  3,  6,  0,  9,  2,  4,  8, 10,  7,  5])
   

3. searchsorted()方法：返回要插入元素的索引值

   import numpy as np
   
   # 创建一个有序数组
   arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
   
   # 返回要插入元素的索引值
   idx = np.searchsorted(arr, 5)
   
   print(idx)
   

   4
   

4. max()方法和min()方法：返回数组中的最大值和最小值

   import numpy as np
   
   # 创建一个随机数组
   arr = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
   
   # 返回数组中的最大值和最小值
   max_value = arr.max()
   min_value = arr.min()
   
   print(max_value, min_value)
   

   9 1
   

这些方法可以方便地对数组进行排序和搜索，但需要注意的是，排序方法会直接修改原始数组，而搜索方法不会修改数组。在使用这些方法时，需要根据具体的需求来选择合适的方法。

十、矩阵与线性代数运算

NumPy提供了强大的矩阵和线性代数运算功能，下面介绍一些常用的运算方法，并举例说明：

1. 创建矩阵

   使用numpy.array()函数可以创建矩阵。

   import numpy as np
   
   # 创建一个2x2的矩阵
   matrix = np.array([[1, 2], [3, 4]])
   
   print(matrix)
   

   array([[1, 2],
          [3, 4]])
   

2. 矩阵乘法

   使用numpy.dot()函数可以进行矩阵乘法运算。

   import numpy as np
   
   # 创建两个矩阵
   matrix1 = np.array([[1, 2], [3, 4]])
   matrix2 = np.array([[5, 6], [7, 8]])
   
   # 矩阵乘法
   result = np.dot(matrix1, matrix2)
   
   print(result)
   

   array([[19, 22],
          [43, 50]])
   

3. 矩阵的逆

   使用numpy.linalg.inv()函数可以求矩阵的逆。

   import numpy as np
   
   # 创建一个2x2的矩阵
   matrix = np.array([[1, 2], [3, 4]])
   
   # 求矩阵的逆
   inv_matrix = np.linalg.inv(matrix)
   
   print(inv_matrix)
   

   array([[-2. ,  1. ],
          [ 1.5, -0.5]])
   

4. 矩阵的转置

   使用numpy.transpose()函数可以求矩阵的转置。

   import numpy as np
   
   # 创建一个2x3的矩阵
   matrix = np.array([[1, 2, 3], [4, 5, 6]])
   
   # 求矩阵的转置
   transpose_matrix = np.transpose(matrix)
   
   print(transpose_matrix)
   

   array([[1, 4],
          [2, 5],
          [3, 6]])
   

5. 矩阵的行列式

   使用numpy.linalg.det()函数可以求矩阵的行列式。

   import numpy as np
   
   # 创建一个2x2的矩阵
   matrix = np.array([[1, 2], [3, 4]])
   
   # 求矩阵的行列式
   det_matrix = np.linalg.det(matrix)
   
   print(det_matrix)
   

   -2.0
   

6. 求特征值和特征向量

   使用numpy.linalg.eig()函数可以求解矩阵的特征值和特征向量。特征向量是在相应特征值下的非零向量。

   import numpy as np
   
   # 创建一个3x3的矩阵
   matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
   
   # 求解特征值和特征向量
   eigenvalues, eigenvectors = np.linalg.eig(matrix)
   
   print("特征值：", eigenvalues)
   print("特征向量：", eigenvectors)
   

   特征值： [ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
   特征向量： [[-0.23197069 -0.78583024  0.40824829]
    [ 0.52532209 -0.08675134 -0.81649658]
    [-0.81867387  0.61232755  0.40824829]]
   

7. 奇异值分解

   奇异值分解（Singular Value Decomposition，SVD）是一种用于矩阵分解的方法。它将矩阵分解成三个矩阵的乘积，即$A=U\Sigma V^T$，其中$U$和$V$是正交矩阵，$\Sigma$是一个对角矩阵，对角线上的元素称为奇异值。

   使用numpy.linalg.svd()函数可以进行奇异值分解。

   import numpy as np
   
   # 创建一个3x2的矩阵
   matrix = np.array([[1, 2], [3, 4], [5, 6]])
   
   # 进行奇异值分解
   U, S, VT = np.linalg.svd(matrix)
   
   print("U：", U)
   print("奇异值：", S)
   print("V转置：", VT)
   

   U： [[-0.2298477  -0.88346102 -0.40824829]
    [-0.52474482 -0.24078249  0.81649658]
    [-0.81964194  0.40189604 -0.40824829]]
   奇异值： [9.52551809 0.51430058]
   V转置： [[-0.61962948 -0.78489445]
    [ 0.78489445 -0.61962948]]
   

这些函数是NumPy中用于进行线性代数计算的一小部分。NumPy还提供了许多其他有用的线性代数函数，例如求解线性方程组、计算矩阵的行列式和求逆等。这些函数使得使用NumPy可以更加方便地进行线性代数计算。