【技术积累】Python中的NumPy库【一】

来源：cnblogs　　作者：程序员天佑　　时间：2023/6/9 9:16:25　　对本文有异议

NumPy库是什么

NumPy是Python科学计算的核心库之一，用来进行科学计算，数值分析等矩阵运算。主要提供了以下几种功能：

1.多维数组（ndarray）对象，可以进行快速的数值计算和数组操作；

2.广播(Broadcast)功能，可以对不同形状的数组进行算术运算；

3.数学函数库，可以对数组进行各种数学运算；

4.线性代数、傅里叶变换、随机数生成等工具操作；

5.不同数据类型之间的传输功能；

6.数据的输入和输出功能。

在NumPy中，最重要的是它的ndarray对象，多为n维数组，因此它非常适合处理科学计算中的向量、矩阵等数据结构。numpy比列表更加高效，可以大大提高程序运行速度，是数据处理和科学计算的主要工具之一。

如何在NumPy中生成随机数？

在 NumPy 中，我们可以使用 random 模块来生成随机数。

下面是一些常用的随机数生成函数：

np.random.rand()：生成 0 到 1 之间的随机浮点数，可以接收任意个参数作为随机数生成器的形状。
np.random.randn()：生成符合标准正态分布的随机数，可以接收任意个参数作为随机数生成器的形状。
np.random.randint()：生成整数型的随机数，可以接收两个参数：最小值和最大值。
np.random.random()：生成 0 到 1 之间的随机浮点数，可以接收一个参数作为输出的形状。
np.random.shuffle()：随机打乱一个序列，可以接收一个参数作为要打乱的序列。
np.random.choice()：从指定的序列中随机挑选一个元素，可以接收两个参数：序列和挑选出元素的数量。

import numpy as np
# 生成一个形状为 (3, 2) 的随机浮点数数组
arr1 = np.random.rand(3, 2)
# 生成一个形状为 (3, 2) 的符合标准正态分布的随机数数组
arr2 = np.random.randn(3, 2)
# 生成 0 到 9 之间的随机整数
randint = np.random.randint(10)
# 生成一个形状为 (1, 3) 的随机浮点数数组
arr3 = np.random.random((1, 3))
# 打乱一个序列
arr4 = np.arange(10)
np.random.shuffle(arr4)
# 从指定的序列中随机挑选一个元素
choice = np.random.choice([1, 2, 3, 4, 5, 6], 1)

NumPy中NDArray对象有什么特点？

NumPy中NDArray（N-dimensional array）对象有以下特点：

它是多维数组，可以表示任意维度的数据。
所有元素必须是同一类型的数据。
它支持向量化操作，即对整个数组的操作只需要一条语句即可实现。
它快速且高效，因为它是使用C语言实现的，并且在内存使用和计算效率方面进行了优化。
它提供了大量的科学计算函数和方法，包括线性代数、傅里叶变换、统计分析等。
它易于与其他数据处理工具（如Pandas、SciPy等）集成使用，可以提高数据分析处理效率，并且支持大数据量的高效处理。

如何使用NumPy创建对角矩阵？

使用diag函数创建对角矩阵

import numpy as np
# 创建一个3x3的对角矩阵，对角线元素为1
diag_matrix = np.diag([1, 1, 1])
print(diag_matrix)

array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]])

你也可以在diag函数中使用一个数字来创建对应大小的对角矩阵。

# 创建一个5x5的对角矩阵，对角线元素为2
diag_matrix = np.diag(2*np.ones(5))
print(diag_matrix)

array([[2., 0., 0., 0., 0.],
       [0., 2., 0., 0., 0.],
       [0., 0., 2., 0., 0.],
       [0., 0., 0., 2., 0.],
       [0., 0., 0., 0., 2.]])

如何使用NumPy进行数组展平和拉伸操作？

NumPy提供了两个方法flatten()和ravel()都可用于将多维数组展平为一维数组，不同之处在于ravel()返回的是原数组的视图，而flatten()返回的是原数组的副本。下面是使用flatten()和ravel()方法展示多维数组的方法：

1.使用flatten()方法

import numpy as np
# 创建一个2x3的二维数组
a = np.array([[1, 2, 3], [4, 5, 6]])
# 展平数组
b = a.flatten()
print('原数组：')
print(a)
print('展平后的数组：')
print(b)

原数组：
[[1 2 3]
 [4 5 6]]
展平后的数组：
[1 2 3 4 5 6]

2.使用ravel()方法

import numpy as np
# 创建一个2x3的二维数组
a = np.array([[1, 2, 3], [4, 5, 6]])
# 拉伸数组
b = a.ravel()
print('原数组：')
print(a)
print('拉伸后的数组：')
print(b)

原数组：
[[1 2 3]
 [4 5 6]]
拉伸后的数组：
[1 2 3 4 5 6]

如何在NumPy中进行数组广播操作？

NumPy的数组广播操作可以在不同形状的数组之间进行数学运算，简化了数组的操作和计算。数组广播主要遵循以下规则：

数组维度不同，可以将维度较小的数组延伸为维度较大的数组，使它们的维度相等。
如果两个数组在某个维度上的形状相同，或者其中一个数组在该维度上的形状为1，则称它们在该维度上是兼容的，可以进行数学运算。
在任何维度上，如果一个数组形状为1，则可以沿着该维度扩展为另一个数组的对应维度。

以下是一个示例，演示如何使用numpy进行数组广播：

import numpy as np
#创建两个形状不同的数组
a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
#打印两个数组的形状
print("a.shape = ", a.shape)
print("b.shape = ", b.shape)
#使用数组广播计算a和b的和
c = a + b
print("a + b = \n", c)

a.shape = (3,)
b.shape = (3, 1)
a + b =
 [[2 3 4]
 [3 4 5]
 [4 5 6]]

在这个示例中，我们创建了两个数组a和b，它们的形状不同。然后，我们使用数组广播计算a和b的和。由于a和b的形状不同，我们可以将维度较小的数组b延伸为维度相等的数组，以兼容它们之间的加法运算。最后，我们将结果存储在新数组c中。

如何使用NumPy进行数组的切片和子集选择？

NumPy可以使用切片和布尔索引来选择数组的子集。、

使用切片可以选择数组的某一部分，例如：

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = a[1:4]  # 选择a[1]到a[3]的元素
print(b)  # 输出 [2 3 4]

也可以对多维数组进行切片，例如：

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
b = a[0:2, 1:3]  # 选择a中第1列到第2列、第2行到第3行的元素
print(b)  # 输出 [[2 3]
          #     [5 6]]

使用布尔索引可以根据某种条件选择数组中的元素，例如：

a = np.array([1, 2, 3, 4, 5])
b = a[a > 2]  # 选择a中大于2的元素
print(b)  # 输出 [3 4 5]

也可以对多维数组使用布尔索引，例如：

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
b = a[a > 2]  # 选择a中大于2的元素
print(b)  # 输出 [3 4 5 6 7 8 9]

注意，布尔索引返回的是一维数组，需要使用reshape方法将其转换为多维数组。可以使用np.where来进行更复杂的条件选择。

如何使用NumPy进行矩阵运算和线性代数计算？

NumPy是Python语言的一个扩展库，专门处理大型多维数组与矩阵运算。NumPy提供了许多线性代数和矩阵操作函数。下面是使用NumPy进行矩阵运算的一些例子：

创建矩阵

要使用NumPy创建一个矩阵，可以使用numpy.array()函数，并将二维数组传递给它。

import numpy as np
# 创建一个3x3的矩阵
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

矩阵转置

要使用NumPy将矩阵转置，可以使用numpy.transpose()函数。

import numpy as np
# 创建一个3x3的矩阵
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)
# 转置矩阵
matrix_transpose = np.transpose(matrix)
print(matrix_transpose)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]

矩阵相加和矩阵相减

要使用NumPy对矩阵进行加法和减法操作，可以使用numpy.add()和numpy.subtract()函数。

import numpy as np
# 创建两个矩阵
matrix_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix_b = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
# 矩阵相加
matrix_sum = np.add(matrix_a, matrix_b)
print(matrix_sum)
# 矩阵相减
matrix_diff = np.subtract(matrix_a, matrix_b)
print(matrix_diff)
# 输出:
# [[10 10 10]
#  [10 10 10]
#  [10 10 10]]
# [[-8 -6 -4]
#  [-2  0  2]
#  [ 4  6  8]]

矩阵乘法

要使用NumPy进行矩阵乘法，可以使用numpy.dot()函数。

import numpy as np
# 创建两个矩阵
matrix_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix_b = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
# 矩阵乘法
matrix_prod = np.dot(matrix_a, matrix_b)
print(matrix_prod)
# 输出:
# [[ 30  24  18]
#  [ 84  69  54]
#  [138 114  90]]

行列式和逆矩阵

要使用NumPy计算行列式和逆矩阵，可以使用numpy.linalg.det()和numpy.linalg.inv()函数。

import numpy as np
# 创建一个3x3的矩阵
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 计算矩阵的行列式
matrix_det = np.linalg.det(matrix)
print(matrix_det)
# 计算矩阵的逆矩阵
matrix_inv = np.linalg.inv(matrix)
print(matrix_inv)
# 输出:
# 0.0
# [[-3.00000000e+00  6.00000000e+00 -3.00000000e+00]
#  [ 6.00000000e+00 -1.20000000e+01  6.00000000e+00]
#  [-3.00000000e+00  6.00000000e+00 -3.00000000e+00]]

这些只是NumPy中可用的许多矩阵运算之一。NumPy库还提供了其他矩阵运算，如解线性方程组等等逆矩阵可以计算其它方面的线性代数问题，如解线性方程组，这是数据科学中不可或缺的。

如何使用NumPy进行数据的离散化和分组操作？

使用NumPy进行数据的离散化和分组操作可以使用numpy.digitize和numpy.bincount函数。

numpy.digitize函数可以将一组数据划分为不同的区间，返回每个数据所属的区间编号；numpy.bincount函数可以统计每个区间内数据的数量。这两个函数的联合使用可以实现数据的离散化和分组操作。

例如，对数据进行10个区间的离散化，并统计每个区间内数据的数量可以使用以下代码：

import numpy as np
data = np.array([1, 4, 8, 3, 6, 9, 2, 5, 7, 10])
bins = np.linspace(0, 10, 11) # 划分为10个区间
indices = np.digitize(data, bins) # 划分数据所属区间
counts = np.bincount(indices)

上述代码执行完毕后，counts数组中即为每个区间内数据的数量。可以在此基础上进行更多操作，例如计算每个区间内数据的平均值等。

NumPy如何进行数组的输入和输出？

NumPy可以通过多种方式进行数组的输入和输出，包括文本文件、二进制文件、内存缓冲等。

下面是一些常见的数组输入和输出的方法和示例：

从文本文件读取数组：
将数组保存到文本文件中：
从二进制文件读取数组：
将数组保存到二进制文件中：
从内存缓冲读取数组：
将数组保存到内存缓冲中：

import numpy as np
import io
# 从文本文件读取数组
data = np.loadtxt('data.txt')
print(data)
# 将数组保存到文本文件中
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
np.savetxt('data.txt', data)
# 从二进制文件读取数组
data = np.load('data.npy')
print(data)
# 将数组保存到二进制文件中
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
np.save('data.npy', data)
# 从内存缓冲读取数组
str_data = '1 2 3\n4 5 6\n7 8 9'
data = np.genfromtxt(str_data.splitlines(), delimiter=' ')
print(data)
# 将数组保存到内存缓冲中
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
output = io.StringIO()
np.savetxt(output, data, delimiter=',')
str_data = output.getvalue()
print(str_data)