Python学习（2）-NumPy矩阵与通用函数-Toy模板网

这篇具有很好参考价值的文章主要介绍了Python学习（2）-NumPy矩阵与通用函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

文章首发于：My Blog 欢迎大佬们前来逛逛

1. NumPy矩阵

1.1 mat函数

mat=asmatrix
asmatrix(data, dtype=None):

data：表示输入的数组或者字符串，使用‘，’分割列，使用‘；’分割行

创建两个普通的矩阵：

print(np.mat([1, 2, 3]))
print(np.mat("1,2,3;4,5,6;7,8,9"))
--------
[[1 2 3]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

需要注意：mat创建的矩阵是不会产生副本的，即共享内存：

a1 = np.array([1, 2, 3, 4, 5])
ma1 = np.mat(a1)
ma1[0, 0] = 100
print(ma1)
print(a1)   # a1[0,0]也会改变
---------
[1 2 3 4 5]
[[100   2   3   4   5]]
[100   2   3   4   5]

1.2 matrix函数

matrix也是创建矩阵的：

 matrix(data, dtype=None, copy=True)

data：数组或者字符串，与mat一样

copy：表示创建的矩阵与原数组data是不是拷贝的，如果是拷贝的，则不共享内存；否则共享内存

注意到：mat默认共享内存，matrix可以选择拷贝，他们的不同仅此而已

print(np.matrix([1, 2, 3, 4, 5]))
print(np.matrix('1,2,3;4,5,6'))
a1 = np.array([1, 2, 3, 4, 5])
ma1 = np.matrix(a1, copy=True)
ma1[0, 0] = 100
print(a1) # 不变
----------
[[1 2 3 4 5]]
[[1 2 3]
 [4 5 6]]
[1 2 3 4 5]

1.3 bmat函数

bmat可以产生一个分块矩阵：

bmat(obj, ldict=None, gdict=None)

obj：数组或者字符串

ldict，gdict：字典

a1 = np.arange(4).reshape(2, 2)
a2 = np.arange(5, 9).reshape(2, 2)
print(a1)
print(a2)
print(np.bmat([a1, a2]))
print(np.bmat('a1,a2;a2,a1')) # 四块 2*2 矩阵合并成一个大的4*4的矩阵
---------
[[0 1]
 [2 3]]
[[5 6]
 [7 8]]
[[0 1 5 6]
 [2 3 7 8]]

[[0 1 5 6]
 [2 3 7 8]
 [5 6 0 1]
 [7 8 2 3]]

1.4 矩阵运算

我们所熟知的运算，NumPy矩阵运算都可以实现：

print(a1 + a2)
print(a1 - a2)
print(a1 * a2) # 注意只能是满足矩阵运算条件 即 m*n 的m的列数要等与n的行数，结果为m的行数*n的列数
print(a1 / a2)
print(a1 ** a2)  
---------
[[ 5  7]
 [ 9 11]]
[[-5 -5]
 [-5 -5]]
[[ 0  6]
 [14 24]]
[[0.         0.16666667]
 [0.28571429 0.375     ]]
[[   0    1]
 [ 128 6561]]

矩阵的特有属性：

T：转置
H：共轭转置
I：逆矩阵
A：转换为二维数组

a2 = np.matrix('1,2,3;4,5,6;7,8,9')
print(a2.T)  # 求转置
print(a2.H)  # 共轭转置
print(a2.I)  # 逆矩阵
print(a2.A)  # 自身的二维数组

2. NumPy通用函数

2.1 ufunc运算函数

注意：ufunc的运算操作是对于数组的运算，而不是矩阵，矩阵的运算是 NumPy 实现的。

ufunc的运算不是矩阵的运算，因此对于不符合矩阵乘法条件的两个数组相乘是合法的。

np.all：对于数组的元素需要全部满足

np.any：对于数组的元素只需要存在即可

创建数组：

a3 = np.array([1, 2, 3])
a4 = np.array([2, 3, 4])
print(a3 + a4)
# ....
print(np.all(a3 > 2))  # a3全部元素大于2
print(np.any(a3 > 2))  # a3任意一个元素大于2
-------
[3 5 7]
False
True

2.2 ufunc广播机制

对于数组的运算，我们会对数组的shape有要求；但是如果shape不一样，我们仍然可以对他们进行运算操作，只需要对他们使用广播机制即可。

广播机制必须满足的前提条件：

两个数组必须具有相同的维数，每个维的长度要么是相同的，要么是1
维数少的数组需要在其形状上加上n个长度为1的维数，以便使得满足条件1.

例子1：

a1数组是 2行4列的，a2数组是 1行4列的。

我们可以发现，a2数组的行数少 1，因此需要在a2的shape上对其行数加1，使得a2数组变为（2，4），那么他们的形状相同，模拟为使得在B的末尾新添加一行与第一行相同的元素，因此可以相加，总结为：

A.shape=(2,4) ；B.shape=(1,4) ----> B.shape=(2,4)

然后再执行A与B相加。

a1 = np.random.randint(0, 8, (2, 4))
a2 = np.random.randint(0, 4, 4)
print(a1)
print(a2)
print(a1 + a2)
-------
[[7 6 3 5]
 [2 7 5 2]]

[1 3 0 2]

[[ 8  9  3  7]
 [ 3 10  5  4]]

例子2：

此时我们的a1的shape是 4行3列，a2的shape是 4行1列，因此需要在a2的shape中对a2的列数加1，直到他们的shape相同，使得a2也变为 4行3列的，模拟在a2的后面新添加两列与第一列相同的元素即可

A,shape=(4,3) B.shape=(4,1) ----> B.shape=(4,3)

然后再执行相加。

a1 = np.random.randint(0, 12, (4, 3))
a2 = np.random.randint(0, 4, (4, 1))
print(a1)
print(a2)
print(a1 + a2)
---------
[[ 0  6  6]
 [11  1  3]
 [ 4 10  6]
 [11  1  4]]
 
[[3]
 [1]
 [2]
 [3]]
 
[[ 3  9  9]
 [12  2  4]
 [ 6 12  8]
 [14  4  7]]

2.3 统计分析函数

2.3.1 排序函数

sort函数直接对对象数组进行升序排序：

a1 = np.random.randint(10, 20, 10)
a1.sort()
print(a1)
-----------
[11 11 12 12 13 15 16 16 18 19]

使用 np.sort() 对数组排序后生成一份拷贝

a1 = np.random.randint(10, 20, 10)
print(np.sort(a1))
print(a1)
--------
[10 10 11 12 13 13 13 15 15 18]
[13 12 15 13 13 11 10 18 15 10]

argsort函数会产生索引数组，其中索引表示的是按照升序排序后，对应位置的元素在原数组中的对应的索引位置

例如新生成的索引数组的：

[0] = 8，表示这个排序后的值[0]位置的值在原数组中是第8个（下标0开始），为10
[1] = 1，表示为第1个，为 11
[2] = 2，表示为第2个，为 11

…

a1 = np.random.randint(10, 20, 10)
print(a1)
print(a1.argsort())
----------
[16 11 11 18 17 15 17 19 10 15]
[8 1 2 5 9 0 4 6 3 7]

lexsort表示对多个键的数组进行间接排序，也是返回一个索引数组。

2.3.2 去重与重复函数

unique函数的作用是去掉重复的元素。

a1 = np.random.randint(10, 20, 10)
print(a1)
print(np.unique(a1))
---------
[15 13 18 14 15 15 12 17 18 16]
[12 13 14 15 16 17 18]

unique可以指定参数：

return_index：是否返回唯一元素的索引
return_inverse：是否返回用索引重建的数组
return_counts：是否返回唯一数组中元素出现的次数

a1 = np.random.randint(10, 20, 10)
print(a1)
print(np.unique(a1, return_index=True))   # 返回唯一元素的索引值
print(np.unique(a1, return_inverse=True))# 使用唯一索引重建数组
print(np.unique(a1, return_counts=True)) # 统计唯一数组的元素出现的次数
----------
[10 13 15 19 10 15 15 14 13 17]
(array([10, 13, 14, 15, 17, 19]), array([0, 1, 7, 2, 9, 3], dtype=int64))
(array([10, 13, 14, 15, 17, 19]), array([0, 1, 3, 5, 0, 3, 3, 2, 1, 4], dtype=int64))
(array([10, 13, 14, 15, 17, 19]), array([2, 2, 1, 3, 1, 1], dtype=int64))

tile用于重复数组的值：

tile(A, reps)

A：表示需要重复的数组

reps：重复的次数

如下，我们把5*2的数组重复了三次，让他变成了 5 * 6的

a1 = np.random.randint(10, 20, (5, 2))
print(np.tile(a1, 3))
--------
[[14 18 14 18 14 18]
 [14 10 14 10 14 10]
 [18 17 18 17 18 17]
 [12 12 12 12 12 12]
 [19 12 19 12 19 12]]

repeat函数也是重复数组的值：

repeat(a, repeats, axis=None)

axis：为0则表示垂直（行数增加），为1表示水平（列数增加）：

print(np.repeat(a1, 3, axis=1))
print(np.repeat(a1, 3, axis=0))
----------
[[16 16 16 18 18 18]
 [13 13 13 11 11 11]
 [11 11 11 13 13 13]
 [13 13 13 10 10 10]
 [11 11 11 15 15 15]]
[[16 18]
 [16 18]
 [16 18]
 [13 11]
 [13 11]
 [13 11]
 [11 13]
 [11 13]
 [11 13]
 [13 10]
 [13 10]
 [13 10]
 [11 15]
 [11 15]
 [11 15]]