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

宇宙之至尊魔皇

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()：从指定的序列中随机挑选一个元素，可以接收两个参数：序列和挑选出元素的数量。
  

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

复制代码

NumPy中NDArray对象有什么特点？

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

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

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

使用diag函数创建对角矩阵

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

复制代码

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

复制代码

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

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

复制代码

1. array([[2., 0., 0., 0., 0.],
2.        [0., 2., 0., 0., 0.],
3.        [0., 0., 2., 0., 0.],
4.        [0., 0., 0., 2., 0.],
5.        [0., 0., 0., 0., 2.]])

复制代码

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

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

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

复制代码

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

复制代码

2.使用ravel()方法

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

复制代码

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

复制代码

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

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

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

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

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

复制代码

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

复制代码

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

NumPy可以使用切片和布尔索引来选择数组的子集。、
使用切片可以选择数组的某一部分，例如：

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

注意，布尔索引返回的是一维数组，需要使用reshape方法将其转换为多维数组。可以使用np.where来进行更复杂的条件选择。
如何使用NumPy进行矩阵运算和线性代数计算？

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

• 创建矩阵
  

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

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

复制代码

• 矩阵转置
  

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

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

复制代码

• 矩阵相加和矩阵相减
  

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

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

复制代码

• 矩阵乘法
  

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

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

复制代码

• 行列式和逆矩阵
  

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

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

复制代码

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

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

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

复制代码

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

NumPy可以通过多种方式进行数组的输入和输出，包括文本文件、二进制文件、内存缓冲等。
下面是一些常见的数组输入和输出的方法和示例：

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

1. import numpy as np
2. import io
4. # 从文本文件读取数组
5. data = np.loadtxt('data.txt')
6. print(data)
8. # 将数组保存到文本文件中
9. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
10. np.savetxt('data.txt', data)
12. # 从二进制文件读取数组
13. data = np.load('data.npy')
14. print(data)
16. # 将数组保存到二进制文件中
17. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
18. np.save('data.npy', data)
20. # 从内存缓冲读取数组
21. str_data = '1 2 3\n4 5 6\n7 8 9'
22. data = np.genfromtxt(str_data.splitlines(), delimiter=' ')
23. print(data)
25. # 将数组保存到内存缓冲中
26. data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
27. output = io.StringIO()
28. np.savetxt(output, data, delimiter=',')
29. str_data = output.getvalue()
30. print(str_data)

复制代码

除此之外，NumPy还提供了很多其他的输入和输出方式，如Pandas DataFrame、HDF5等。具体可以查阅官方文档。

来源:https://www.cnblogs.com/yyyyfly1/p/17465313.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！