numpy学习笔记3——常用函数2

import numpy as np

矩阵相关函数

#字符串创建矩阵
a = np.mat('1 2 3;4 5 6; 7 8 9')
print('a')
print(a)

#数组创建矩阵
b = np.mat(np.arange(9).reshape(3,3))
print('b')
print(b)

#矩阵的转置
print('转置')
print(a.T)

#求逆矩阵 由于a的行列式为0 所有不存在逆矩阵
c  = np.mat('1 2;1 -2')
c1 = c.I 
print('逆矩阵')
print(c1)

#分块矩阵拼成大矩阵
d = np.eye(2)
e = d*2
print(d)
print(e)
print('拼接矩阵')
f = np.bmat('d e;e d')
print(f)

a
[[1 2 3]
 [4 5 6]
 [7 8 9]]
b
[[0 1 2]
 [3 4 5]
 [6 7 8]]
转置
[[1 4 7]
 [2 5 8]
 [3 6 9]]
逆矩阵
[[ 0.5   0.5 ]
 [ 0.25 -0.25]]
[[1. 0.]
 [0. 1.]]
[[2. 0.]
 [0. 2.]]
拼接矩阵
[[1. 0. 2. 0.]
 [0. 1. 0. 2.]
 [2. 0. 1. 0.]
 [0. 2. 0. 1.]]

g = np.array([[1,2],[3,4]])
h = np.array([[5,8],[7,9]])
#协方差矩阵
print('协方差矩阵')
print(np.cov(g,h))

#查看对角线元素
print('对角线元素')
print(g.diagonal())

#计算矩阵的迹（对角线的和）
print('迹')
print(g.trace())

#相关系数
print('相关系数')
print(np.corrcoef(g,h))

相关性
[[0.5 0.5 1.5 1. ]
 [0.5 0.5 1.5 1. ]
 [1.5 1.5 4.5 3. ]
 [1.  1.  3.  2. ]]
对角线元素
[1 4]
迹
5
相关系数
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

相关系数的计算公式为：$corr(a,b)=\frac{cov(a,b)}{{\sigma }_a{\sigma }_b}$ 其中conv为协方差矩阵,$\sigma$为方差

多项式相关函数

#多项式拟合
c = np.array([0,1,2,3,4,5,6,7,8])
d = np.array([0,0.83,0.9,0.142,-0.76,-0.96,-0.29,0.66,0.99])
poly = np.polyfit(c,d,2) #二次多项式拟合 返回多项式系数
print('多项式拟合')
print(poly)

#利用拟合推测下一个值(也就是9对应的y值)
print('推测下一个值')
print(np.polyval(poly,c[-1]+1))

#求多项式的零点
print('零点')
print(np.roots(poly)) #输入多项式系数
#验证一下
print(np.polyval(poly,6.04797391))
print(np.polyval(poly,1.95992656))

#多项式导数
der = np.polyder(poly) #返回多项式系数
print('导数')
print(der) 

#利用导数零点求极值点
e = np.roots(der)
print('极值点')
print(e)
#极值点带入原函数得到极值
print('极值')
print(np.polyval(poly,e[0]))

多项式拟合
[ 0.06750649 -0.54058528  0.80019394]
推测下一个值
1.4029523809523852
零点
[6.04797391 1.95992656]
-1.0662040139663986e-09
1.8710943905375643e-10
导数
[ 0.13501299 -0.54058528]
极值点
[4.00395024]
极值
-0.2820443434398944

sign和piecewise函数

#sign 返回每个元素正负符号 0 保持不变
f = np.array([1,2,8,5,6,4,0,3,3])
f1 = np.diff(f)
print(f1)
print(np.sign(f1))

#piecewise
print(np.piecewise(f1,[f1<0,f1>0],[-1,1])) #后面两个参数相对应

[ 1  6 -3  1 -2 -4  3  0]
[ 1  1 -1  1 -1 -1  1  0]
[ 1  1 -1  1 -1 -1  1 0]

函数向量化

# vectorize函数
def g(a,b):
    if a>b:
        return a-b
    else:
        return a+b
#此时若有一组元素，比如[1,2,3,4],要作为a与b进行计算，则需要使用循环实现
a = [1,2,3,4] #列表
b = 2
for a1 in a:
    print(g(a1,b))
    
#vectorize函数可以将函数向量化，避免循环
g1 = np.vectorize(g) #参数为函数g 同时返回的也是函数

#此时可以对函数g1输入列表
print(g1([1,2,3,4],2))

#同样的道理
print(g1(2,[1,2,3,4]))

3
4
1
2
[3 4 1 2]
[1 4 5 6]
[1, 2, 3, 4, 1, 2, 3, 4]

平滑处理

#平滑处理
N = 8 #平滑窗口长度
h = np.hanning(N) #生成平滑权重
print(h)

h2 =  np.array([0,0.83,0.9,0.142,-0.76,-0.96,-0.29,0.66,0.99]) #待平滑数据
h3 = np.convolve(h/h.sum(),h2) #卷积得到平滑结果
print(h3)

#画图可视化
import matplotlib.pyplot as plt
#嵌入到python concsole
%matplotlib inline       
x1 = np.arange(len(h2))
x2 = np.arange(len(h3))
plt.plot(x1,h2,'r')
plt.plot(x2,h3,'b')
plt.legend(['before smooth','after smooth'])

[0.         0.1882551  0.61126047 0.95048443 0.95048443 0.61126047
 0.1882551  0.        ]
[ 0.          0.          0.04464335  0.19336451  0.39021964  0.45373234
  0.24356232 -0.14926207 -0.40903481 -0.29603623  0.06484091  0.34580254
  0.36851929  0.20839892  0.0532493   0.        ]

其他函数

# 计算多项式的差
i1 = np.array([1.22,0.36,6])
i2 = np.array([2.56,-1.5,3])
print(np.polysub(i1,i2))

#判断是否为实数
j = np.array([27.1+0.j, 5.6, 3.2, 1+2j, 2.87+3.68j])
j1 = np.isreal(j)
print(j1)

#select根据条件挑选元素(选择True的函数)
k = np.arange(len(j))
k1 = np.select([j1],[k]) #未选中的用0填充
print(k)
print(k1)

#trim_zeros去掉数组首尾的多个0
print(np.trim_zeros(k1))

[-1.34  1.86  3.  ]
[ True  True  True False False]
[0 1 2 3 4]
[0 1 2 0 0]
[1 2]