Python之numpy模块基础知识及其简单应用案例
文章目录
- Python之numpy模块基础知识及其简单应用案例
- 一、安装numpy
- 二、numpy简介
- 三、如何使用该模块
- 1、数组(Arrays)
- 2、数组的切片
- 3、数组的索引取值
- 4、布尔值也可以作为索引
- 5、数组的数据类型
- 四、numpy的应用举例
- 1、实现矩阵的乘法
- 2、实现矩阵的转置
- 3、求所有的元素的和
- 4、其他的生成数组的方法
- 5、meshgrid方法生成网格
一、安装numpy
pip install numpy
（我记得不太清这个是Python内置的还是外加的，但是反正安装一下肯定不会出错的。）
二、numpy简介
Numpy是Python中科学计算的核心库。它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。
三、如何使用该模块
1、数组(Arrays)
numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。
维数是数组的排名; 数组的形状是一个整数元组，给出了每个维度的数组大小。
举例1:
（定义一个一维数组）
import numpy as np
"""
通常将numpy以别名np的方式使用
"""
# 定义一个一维数组
array_0 = np.array([0, 1, 2, 3, 4])
# 查看类型
print(type(array_0))
# 查看数组
print(array_0)
# 查看数组的“形状”
print(array_0.shape)
# output>
<class 'numpy.ndarray'>
[0 1 2 3 4]
(5,)
举例2：
（定义一个多维数组）
# 此处代码含义与上一个相同
import numpy as np
array_1 = np.array([[0, 1, 2, 3, 4],[5, 6, 7, 8, 9]])
print(type(array_1))
print(array_1)
print(array_1.shape)
# output>
<class 'numpy.ndarray'>
[[0 1 2 3 4]
[5 6 7 8 9]]
(2, 5)
综合以上两个例子，我们可以看出来，如果是一维数组，那么shape返回的元组第一个值表示有几个相同类型的数据，第二个值为空；
如果是多维数组，那么，元组的第一个值表示维数，第二个值表示一个维度里面有几个相同类型的数据。
举例3：
（其他产生数组的方法）
（产生的是浮点数）
import numpy as np
a = np.zeros((2,2))
print(a)
b = np.ones((1,2))
print(b)
c = np.full((2,2), 7)
print(c)
d = np.eye(2)
print(d)
e = np.random.random((2,2))
print(e)
# output>
[[0. 0.]
[0. 0.]]
[[1. 1.]]
[[7 7]
[7 7]]
[[1. 0.]
[0. 1.]]
[[0.69818173 0.09918071]
[0.8520535 0.95435593]]
2、数组的切片
一维数组切片
import numpy as np
array_2 = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(array_2[0:2])
print(array_2[0:6:2])
# 参数为：开始：结束：步长
# output>
array([0, 1])
array([0, 2, 4])
二维数组切片
import numpy as np
array_3 = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
# 打印array_3
print(array_3)
# 行切片
print(array_3[0:2, :])
# 列切片
print(array_3[:, 0:2])
# 行与列的切片
print(array_3[0:2, 0:2])
# 反转行
print(array_3[::-1, :])
# 反转列
print(array_3[:,::-1])
# 行列都反转
print(array_3[::-1,::-1])
# output>
# 打印array_3
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
# 行切片
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
# 列切片
array([[ 0, 1],
[ 5, 6],
[10, 11]])
# 行与列的切片
array([[0, 1],
[5, 6]])
# 反转行
array([[10, 11, 12, 13, 14],
[ 5, 6, 7, 8, 9],
[ 0, 1, 2, 3, 4]])
# 反转列
array([[ 4, 3, 2, 1, 0],
[ 9, 8, 7, 6, 5],
[14, 13, 12, 11, 10]])
# 行列都反转
array([[14, 13, 12, 11, 10],
[ 9, 8, 7, 6, 5],
[ 4, 3, 2, 1, 0]])
3、数组的索引取值
一维数组索引
import numpy as np
# 类似于列表的索引
array_4 = np.array([0, 1, 2, 3, 4, 5, 6, 7])
print(array_4[0])
print(array_4[4])
# output>
0
4
二维数组的索引
import numpy as np
array_5 = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
# 首先先取出一行
# 然后再取出这一行的某一列
print(array_5[0][2])
print(array_5[1][3])
print(array_5[2][3])
# output>
2
8
13
更高维的数组的索引
import numpy as np
array_6 = np.array([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]])
print(array_6[0][1][2])
print(array_6[1][0][0])
print(array_6[3][1][1])
# 与二维数组类似
# 首先取出第一个维度的列表
# 再取出更低维度的列表
# 直至去除最小的一个元素为止
# output>
5
6
22
4、布尔值也可以作为索引
import numpy as np
array_7 = np.array([[2, 1, 4, 5, 9, 11, 13], [0, 14, 8, 7, 20, 23, 123], [77, 6, 34, 22, 102, 56, 64]])
bool_0 = array_7 > 15
print(array_7)
print(bool_0)
print(array_7[bool_0])
# True 则展示数值
# Faulse 则不展示数值
# output>
[[ 2 1 4 5 9 11 13]
[ 0 14 8 7 20 23 123]
[ 77 6 34 22 102 56 64]]
[[False False False False False False False]
[False False False False True True True]
[ True False True True True True True]]
[ 20 23 123 77 34 22 102 56 64]
5、数组的数据类型
每个numpy数组都是相同类型元素的网格。Numpy提供了一组可用于构造数组的大量数值数据类型。Numpy在创建数组时尝试猜测数据类型，但构造数组的函数通常还包含一个可选参数来显式指定数据类型。
例如：
import numpy as np
x1 = np.array([0, 1, 2, 3])
print(x1, x1.dtype)
x2 = np.array([0.0,1.0, 2.0, 3.0])
print(x2, x2.dtype)
x3 = np.array([0,1, 2, 3], dtype=np.int64)
print(x3, x3.dtype)
# output>
[0 1 2 3] int32
[0. 1. 2. 3.] float64
[0 1 2 3]
四、numpy的应用举例
1、实现矩阵的乘法
矩阵乘法注意事项：
1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。
2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。
import numpy as np
array_x = np.array([[1, 2], [5, 6]])
array_y = np.array([[4, 8], [7, 9]])
# x 乘 y
print(array_x.dot(array_y))
# x 乘 y
print(np.dot(array_x, array_y))
# y 乘 x
print(array_y.dot(array_x))
# y 乘 x
print(np.dot(array_y, array_x))
# output>
[[18 26]
[62 94]]
[[18 26]
[62 94]]
[[44 56]
[52 68]]
[[44 56]
[52 68]]
由此我们也可以看出来矩阵的乘法具有不可对易性的
再举一个矩阵乘法的例子：
import numpy as np
X = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
Y = np.array([[4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]])
print(np.dot(X, Y))
print(np.dot(Y, X))
# output>
[[ 66 72 78]
[202 224 246]
[338 376 414]]
[[ 68 83 98 113]
[104 128 152 176]
[140 173 206 239]
[176 218 260 302]]
2、实现矩阵的转置
矩阵的转置必须是一个方阵才可以进行的
import numpy as np
# 设置目标矩阵
X = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
# 设置一个空矩阵
X_t = np.zeros((len(X),len(X)), dtype=X.dtype)
# 实现矩阵的转置：
for i in range(4):
for j in range(4):
X_t[i][j] = X[j][i]
print(X)
print(X_t)
# output>
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[ 0 4 8 12]
[ 1 5 9 13]
[ 2 6 10 14]
[ 3 7 11 15]]
或者：
import numpy as np
# 设置目标矩阵
x = np.array([[1, 2,5,6], [3, 4, 8, 9], [10, 11, 12, 13], [14, 22, 34, 57]])
print(x)
# 实现矩阵的转置：
print(x.T)
v = np.array([1, 2, 3, 4, 5])
print(v)
# 实现矩阵的转置：
print(v.T)
# output>
import numpy as np
# 设置目标矩阵
x = np.array([[1, 2,5,6], [3, 4, 8, 9], [10, 11, 12, 13], [14, 22, 34, 57]])
print(x)
# 实现矩阵的转置：
print(x.T)
v = np.array([1, 2, 3, 4, 5])
print(v)
# 实现矩阵的转置：
print(v.T)
[[ 1 2 5 6]
[ 3 4 8 9]
[10 11 12 13]
[14 22 34 57]]
[[ 1 3 10 14]
[ 2 4 11 22]
[ 5 8 12 34]
[ 6 9 13 57]]
[1 2 3 4 5]
[1 2 3 4 5]
3、求所有的元素的和
import numpy as np
x = np.array([[1, 2, 7, 8],[3, 4, 9, 10], [6, 22, 45, 57]])
print(x.sum())
print(np.sum(x))
# 对每一列都求和，返回一个列表
print(np.sum(x, axis=0))
# 对每一行都求和，返回一个列表
print(np.sum(x, axis=1))
# output>
174
174
[10 28 61 75]
[ 18 26 130]
4、其他的生成数组的方法
方法1：arange方法
import numpy as np
# 从 -10 到 10
# 每隔 0.5 生成一个数
# 为一个等差数列
arr_0 = np.arange(-10, 10, 0.5)
print(arr_0)
# output。
[-10. -9.5 -9. -8.5 -8. -7.5 -7. -6.5 -6. -5.5 -5. -4.5
-4. -3.5 -3. -2.5 -2. -1.5 -1. -0.5 0. 0.5 1. 1.5
2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5
8. 8.5 9. 9.5]
方法2：linspace方法
import numpy as np
# 从 -10 到 10
# 一共生成 40 个数
# 为一个等差数列
arr_1 = np.linspace(-10, 10, 40)
print(arr_1)
# output>
[-10. -9.48717949 -8.97435897 -8.46153846 -7.94871795
-7.43589744 -6.92307692 -6.41025641 -5.8974359 -5.38461538
-4.87179487 -4.35897436 -3.84615385 -3.33333333 -2.82051282
-2.30769231 -1.79487179 -1.28205128 -0.76923077 -0.25641026
0.25641026 0.76923077 1.28205128 1.79487179 2.30769231
2.82051282 3.33333333 3.84615385 4.35897436 4.87179487
5.38461538 5.8974359 6.41025641 6.92307692 7.43589744
7.94871795 8.46153846 8.97435897 9.48717949 10. ]
5、meshgrid方法生成网格
meshgrid方法可以用来生成一个二维的网格：
import numpy as np
# 生成一个一维数组
x = np.arange(0, 3, 0.5)
# 生成一个一维数组
y = np.arange(0, 3, 0.5)
# 调用 meshgrid 方法
X, Y = np.meshgrid(x, y)
print(X)
print(Y)
# output>
[[0. 0.5 1. 1.5 2. 2.5]
[0. 0.5 1. 1.5 2. 2.5]
[0. 0.5 1. 1.5 2. 2.5]
[0. 0.5 1. 1.5 2. 2.5]
[0. 0.5 1. 1.5 2. 2.5]
[0. 0.5 1. 1.5 2. 2.5]]
[[0. 0. 0. 0. 0. 0. ]
[0.5 0.5 0.5 0.5 0.5 0.5]
[1. 1. 1. 1. 1. 1. ]
[1.5 1.5 1.5 1.5 1.5 1.5]
[2. 2. 2. 2. 2. 2. ]
[2.5 2.5 2.5 2.5 2.5 2.5]]
总之，以上内容就是对numpy模块的一个简单介绍以及简单的应用举例，希望对大家有所帮助啦~~
