Numpy矩阵的创建与运算

编程语言 2018-06-05 05:15:00 阅读次数: 0

Numpy矩阵的创建与运算

标签（空格分隔）： 未分类

'''--------------------numpy矩阵的创建-----------------------'''
import numpy as np
#numpy矩阵创建的方法

# 1.直接使用分号隔开的字符串
mat1 = np.mat("1 2 3;4 5 6;7 8 9")
print(mat1)  #<class 'numpy.matrixlib.defmatrix.matrix'>
print(type(mat1))

# 2.使用numpy数组创建矩阵
arr = np.arange(1,10).reshape(3,3)
# print(type(arr))  #<class 'numpy.ndarray'>
# print(arr)
mat2 = np.mat(arr)
print(mat2)
# print(type(mat2))  #<class 'numpy.matrixlib.defmatrix.matrix'>

# 3.从已有的矩阵中通过bmat函数复合创建矩阵
A = np.eye(2)
B = A*2

mat3 = np.bmat("A B;B A;A B")
print(mat3)
print(mat3.shape)  #(6, 4)
'''--------------------numpy随机矩阵的创建-----------------------'''
import numpy as np
from matplotlib import pyplot as plt

#创建一个服从正太分布的随机矩阵
normal = np.random.normal(size=100)
print(normal)
#打印直方图
# plt.hist(normal)
# plt.show()

#创建一个服从beta分布的随机样本
beta = np.random.beta(a=.5,b=.5,size=100)
# plt.hist(beta)
# plt.show()

#产生均匀分布的随机数
rand = np.random.rand(3,2,4)  #三层两行四列
print(rand)

#产生4x4随机正太分布样本
normal2 = np.random.normal(size=(100,100))
print("normal2-100x100:\n",normal2)
plt.hist(normal2)
plt.show()

#产生在某个范围内的随机整数矩阵
numbers = np.mat(np.random.randint(1,50,[5,5]))
# print(numbers)

#产生0-1之间随机浮点数
floatNum = np.mat(np.random.random(10))  #产生10个0-1的浮点数
print(floatNum)

#在某个范围内的所有数中随机抽取一个
num = np.random.choice(10)  #[0,10)内随机选一个数
print(num)
num1 = np.random.choice(5,10)  #[0,5)内随机选10个数
print(num1)
'''--------------------numpy矩阵的运算add/multiply/*-----------------------'''
import numpy as np

mat1 = np.mat(np.array([2,6,5]))
mat2 = np.mat(np.array([1,4,7]))

#矩阵的加法
addResult = np.add(mat1,mat2)
print(type(addResult))  #<class 'numpy.matrixlib.defmatrix.matrix'>
print(addResult)  #[[ 3 10 12]]

#数组的乘法
multiResult = np.multiply(mat1,mat2)
print(multiResult)  #[[ 2 24 35]]

#矩阵相乘 mxp矩阵乘以pxn矩阵，相乘后得mxn矩阵
mat3 = np.mat(np.arange(6).reshape(2,3))
mat4 = np.mat(np.arange(6).reshape(3,2))
print("矩阵相乘mat3*mat4=\n",mat3*mat4)

'''-------------numpy矩阵的运算divide/floor_divide/mod/remainder/fmod-------------'''
import numpy as np

a = np.mat(np.array([4,5,8]))
b = np.mat(np.array([2,3,5]))

#数组的除法
result = np.divide(a,b)
print("数组相除：",result)
print("直接数组相除：",a/b)
#数组除法并将结果向下取整
result2 = np.floor_divide(a,b)
print("相除向下取整：",result2)
print("相除向下取整：",a//b)

#矩阵取模运算/求余数
result3 = np.remainder(a,b)
print("remainder结果：",result3)
result4 = np.mod(a,b)
print("mod结果：",result4)
print("取模运算:",a%b)
result5 = np.fmod(a,b)  #所得余数的正负由被除数决定，与除数的正负无关
print("fmod结果：",result5)


#矩阵相除,python2.7和3的结果还不一致，python3里true_divide与divide结果一样
floatResult = np.true_divide(a,b)
print("true_divide:",floatResult)

'''----------------numpy一元通用函数-----------------'''
import numpy as np

mat = np.mat(np.array([-4,3,0,12]))
print("abs:",np.abs(mat))      #[[ 4  3  0 12]]
print("fabs:",np.fabs(mat))   #[[ 4.  3.  0. 12.]]

#获取mat矩阵中各元素的正负号
sign = np.sign(mat)
print("sign:",sign)     #[[-1  1  0  1]]

#将数组中元素的小数和整数部分抽取出来
arr = np.mat(np.array([[1.2,3.14],
               [-2.5,6.8]]))
arr1,arr2 = np.modf(arr)
print("小数部分：",arr1)    #[[ 0.2   0.14]  [-0.5   0.8 ]]
print("整数部分：",arr2)    #[[ 1.  3.]  [-2.  6.]]

#求平方根
C = np.mat(np.arange(1,6))
print("平方根：",np.sqrt(C))

#求平方
D = np.mat(np.arange(-3,2))
print("平方：",np.square(D))

#取整
E = np.mat(np.array([[2.3,4.6],[1.2,1.9]]))
print("ceil:",np.ceil(E))
print("floor:",np.floor(E))
print("rint:",np.rint(E))
'''----------------numpy创建通用函数-----------------'''
import numpy as np

a = np.arange(4).reshape(2,2)
print("a",a)  #[[0 1] [2 3]]

like_a = np.zeros_like(a)
print("like_a-1",like_a)  #[[0 0] [0 0]]

like_a.flat = 42
print("like_a-2:",like_a)  #[[42 42]  [42 42]]

#创建一个numpy通用函数
def like(ndarray):
    result = np.zeros_like(ndarray)
    result = 42   #result.flat = 42
    return result

#调用numpy创建通用函数的方法
myfunc = np.frompyfunc(like,1,1)  #1 个输入， 1 个输出
test = myfunc(np.arange(9).reshape(3,3))
print("test:",test)  #[[42 42 42] [42 42 42] [42 42 42]]
'''-------------------二元通用函数-------------------'''
import numpy as np
#power
mat = np.mat(np.array([1,2,3,4,5]))
I = np.mat(np.array([2,3,2,1,3]))
print("mat power I:",np.power(mat,I))   #power: [[  1   8   9   4 125]]
print("I power mat:",np.power(I,mat))    #power: [[  2   9   8   1 243]]

#获取两个数组对应元素的最大值和最小值，返回到至一个新的数组中
d2 = np.array([[22,15],
              [5.4,6.6]])
d3 = np.array([[15,28],
               [7.9,4.0]])
# maximum = np.maximum(d2,d3)
# print("maxinum:",maximum)   #[[22.  28. ],[ 7.9  6.6]]
# minimum = np.minimum(d2,d3)
# print("minimum:",minimum)   #[[15.  15. ],[ 5.4  4. ]]

#数组比较函数
result = np.greater(d2,d3)
print("greater:",result)   #[[ True False], [False  True]]

result1 = np.greater_equal(d2,d3)
print("greater_equal:",result1)  #[[ True False], [False  True]]

#python转换为bool为False:0 None ""  {}  []  ()   False
bool1 = np.array([[1,0],[3,5]])
bool2 = np.array([[0,1],[12,0]])
bool3 = np.logical_and(bool1,bool2)
print("逻辑与：",bool3)   #[[False False] [ True False]]
bool4 = np.logical_xor(bool1,bool2)
print("逻辑异或：",bool4)   #[[ True  True] [False  True]]
bool5 = np.logical_or(bool1,bool2)
print("逻辑或：",bool5)   # [[ True  True] [ True  True]]

'''-------------------np.add模块下的通用函数-------------------'''
import numpy as np

#np.add模块下面的通用函数
a = np.arange(9)
print("a=",a)

#reduce求和
print("reduce(a)=",np.add.reduce(a))
print("sum(a)=",np.sum(a))

#accumulate 依次将数组元素相加的每一步结果保存到一个新数组
print("accumulate(a)=",np.add.accumulate(a))

#reduceat,根据给定区间分段进行reduce求和操作
print("reduceat=",np.add.reduceat(a,[0,5,2,7]))  #reduceat= [10  5 20 15]
#上面求的应该是[0,5)之间的和，因为5>2,就去5，再求[2,7)之间和，再求[7:)后面的求和

#outer，将第一个数组中额每个元素分别和第二个数组中的所有元素求和
print("outer=",np.add.outer(np.arange(1,4),a))

'''-------------------矩阵求逆np.linalg.inv()-------------------'''
import numpy as np

A = np.mat(np.array([[0,1,2],
                     [1,0,3],
                     [4,-3,8]]))
print("A:\n",A)

#求A矩阵的逆矩阵
A_ = np.linalg.inv(A)
print("A的逆矩阵：\n",A_)

#验证A*A_的结果是否是一个单位矩阵
print("A*A_:\n",A*A_)
'''----------------矩阵求解方程组np.linalg.solve()-------------------'''
import  numpy as np

'''
x − 2y + z = 0
2y - 8z = 8
−4�� + 5�� + 9�� = −9
'''
#numpy求解三元一次方程组
A = np.mat("1 -2 1;0 2 -8;-4 5 9")
print("方程组的系数：\n",A)
b = np.array([0,8,-9])   #不能用矩阵表示
print("方程组的常数：\n",b)
#调用numpy的solve方法求解
C = np.linalg.solve(A,b)
print("x={},y={},z={}".format(C[0],C[1],C[2]))

'''-------------------矩阵求特征值和特征向量np.linalg.eigvals()/np.linalg.eig()-------------------'''
import numpy as np

vector = np.mat("3 -2;1 0")
print(vector)
#求向量的特征值
eigenvalues = np.linalg.eigvals(vector)
print("向量的特征值：",eigenvalues)
#同时求向量的特征值和特征向量
eigenvalues,eigvector = np.linalg.eig(vector)
print("特征值：",eigenvalues)
print("特征向量：",eigvector)

'''-------------------矩阵奇异值分解np.linalg.svd()-------------------'''
import numpy as np

vector = np.mat("4 11 14;8 7 -2")
print("vector\n",vector)
#调用numpy中的svd方法对矩阵进行奇异值分解
U,sigma,V = np.linalg.svd(vector,full_matrices=False)

print("U:\n",U)
print("sigma:\n",sigma)
print("V:\n",V)

#将svd分解出的值相乘
print("vector:\n",U*np.diag(sigma)*V)
'''-------------------矩阵的行列式np.linalg.det()-------------------'''
import numpy as np

vector = np.mat("3 4;5 6")

print(vector)
#求矩阵的行列式
value = np.linalg.det(vector)
print("矩阵的行列式的值：",value)
'''-------------------数组的排序函数np.argsort()/sort()-------------------'''
#二维数组排序
d2 = np.array([[12,8,35],
               [22,45,9]])
d2.sort(axis=0)  #按列排序
print("当axis=0时排序：",d2)
d2.sort(axis=1)  #按行排序
print("当axis=1时排序：",d2)

# 2.返回排序后数组元素的索引
argsort = np.argsort(arr)
print("argsort:",argsort)
#将多维数组按列排序后返回列索引
print(np.argsort(d2,axis=0))

#将多维数组按行降序排序后返回行索引
print(np.argsort(-d2,axis=1))
'''-------------------搜索函数np.searchsorted()-------------------'''
import numpy as np

a = np.array([[12,56,-34],
              [18,200,6]])
b = np.array([34,22,34,67,11,90,20])
#获取数组中元素最大值的下标，如果是多维数组，则展平后输出最大值的下标
argmax = np.argmax(a)
print(argmax)  #4  将二维数组展平后输出最大值的索引
print(np.argmax(b))  #5

#根据条件在数组中搜索非零元素，并分组返回对应的下标
print("argwhere:\n",np.argwhere(b>20))   #[[0][1][2][3][5]]
print("argwhere:\n",np.argwhere(a>40))  # [[0 1] [1 1]]

#searchsort为需要添加到数组中的元素寻找合适的下标，
#使得原数组的排序顺序不变
sorted =np.arange(5)
print("添加新元素之前：",sorted)  #[0 1 2 3 4]
indices = np.searchsorted(sorted,[-2,7])
print("寻找到的插入位置下标：",indices)  #[0 5]
#根据寻找到的下标，将元素添加到数组中，返回新的数组
result = np.insert(sorted,indices,[-2,7])
print("新数组：",result)  #[-2  0  1  2  3  4  7]

'''-----------------专有函数np.nonzero/np.extract----------------'''
import numpy as np

#提取数组中的非零元素索引np.nonzero()
arr = np.array([[0,1,2],
                [0,3,4],
                [0,5,6]])
rows,cols = np.nonzero(arr)
print("数组中的非零元素的行索引:",rows)
print("数组中的非零元素的列索引:",cols)
#利用深度组合将行列索引合并
indices = np.dstack((rows,cols))
print("数组中的非零元素的索引:",indices)
----------------------------------------
import numpy as np

a = np.arange(10)
#生成一个抽取数组元素花式索引
condition = a%2 ==0 #赋值运算符，算术运算符，逻辑运算符优先级
print("花式索引",condition)  #[ True False  True False  True False  True False  True False]

#np.extract()根据给定条件提取数组元素
even = np.extract(condition,a)
print("数组中的偶数项：",even)   #[0 2 4 6 8]

#用数组的compress方法提取元素
even2 = a.compress(condition)
print("even2:",even2)     #[0 2 4 6 8]

#用np.take函数结合np.where实现提取偶数项
indices = np.where(a%2 ==0)
print("偶数项元素的索引：",indices)  #(array([0, 2, 4, 6, 8], dtype=int64),)
print("even3:",np.take(a,indices))   #[[0 2 4 6 8]]
'''-------------------------金融函数-------------------------'''
import numpy as np

#fv函数
'''
np.fv(rate,nper,pmt,pv)
rate:存款/贷款每期的利率
nper:存款/贷款期数
pmt:存款/贷款每期支付的金额
pv:存款/贷款金额,如果是贷款，pv为正，如果是存款，pv为负；
01举例：某用户去银行存款，假设年利率3%、每季度续存金额 10元、
存5年以及存款1000，则计算5年后可领取多少金额
'''
#该用户5年能够得到的本息和为：
print("Future vlue",np.fv(0.03/12,5*12,-10/3,-1000))   #按每月计算
print("Future vlue",np.fv(0.03/4,5*4,-10,-1000))    #按每季度计算
#计算每一年过后能得到的本息和
fvals = []
for year in range(1,6):
    fvals.append(np.fv(0.03/12,year*12,-10/3,-1000))
    print("第{}年后本息和为:{}".format(year,fvals))

'''
np.pv(rate,nper,pmt,fv)
rate:存款/贷款每期的利率
nper:存款/贷款期数
pmt:存款/贷款每期支付的金额
fv:存款/贷款终值，如何是贷款，终值为0，如果是存款终值为本息和
02举例：：某用户去银行存款，假设年利率3%、每季度续存金额10 元、
存5年后可领1376.0963320，则计算5年前存取的本金是多少金额。
'''
pv = np.pv(0.03/12,5*12,-10/3,1376.09)
print("第一次存款金额为：",-pv)
'''
np.npv(rate,values)
rate:折现率
values:现金流,正数代表‘收入’或‘取款’，负数代表‘投资’或‘存款’。 
       第一个值必须是初始的投资，也就是必须是负数
03举例：投资100，收入39、59、55、20。折现率为28.1%，则净现值为多少？
'''
#现金流：0-100，39-0，59-0，55-0，20-0
npv = np.npv(0.281,[-100,39,59,55,20])
print("净现值为:",npv)

'''
np.pmt(rate,nper,pv)
rate:存款/贷款每期的利率
nper:存款/贷款期数
pmt:存款/贷款每期支付的金额
pv:存款/贷款金额,如果是贷款，pv为正，如果是存款，pv为负；
04举例：某同学房贷20万，准备15年还清，年利率为7.5%，则每 月需还贷多少金额？
'''
pmt = np.pmt(0.075/12,15*12,200000)
print("每期需要还款：{}元".format(pmt))

'''
np.nper(rate,pmt,pv)
rate:存款/贷款每期的利率
nper:存款/贷款期数
pmt:存款/贷款每期支付的金额
pv:存款/贷款金额,如果是贷款，pv为正，如果是存款，pv为负；
05举例：某同学房贷20万，年利率为7.5%，每月能还贷2000，则 需要还多少期？
'''
months = np.ceil(np.nper(0.075/12,-2000,200000))
print("需要还款{}月".format(months))

#月转化为年
years = np.ceil(months/12)
print("需要还款{}年".format(years))

'''
np.rate(nper,pmt,pv,fv)
rate:存款/贷款每期的利率
nper:存款/贷款期数
pmt:存款/贷款每期支付的金额
pv:存款/贷款金额,如果是贷款，pv为正，如果是存款，pv为负；
fv:终值
06举例：某同学房贷20万，需还14年，每月能还贷2000，则年利率为多少？
'''
rate = 12* np.rate(14*12,-2000,200000,0)
print("年利率为：",rate)

'''
作业:小明房贷70万，年利率4%，准备还20年， 则每月月供多少

'''
rate=0.04/12
nper=20*12
pv=700000
pmt=np.pmt(rate,nper,pv)
print(pmt)
pmt2=np.pmt(0.04/12,20*12,700000)
print(pmt2)

猜你喜欢

转载自blog.csdn.net/qq_42379006/article/details/80563560
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
周排行
购置笔记本常识
从源码看Spring Security之采坑笔记（Spring Boot篇）
大数据学习——高可用配置案例
如何避免选择不专业的建站公司?
Euclid's Game HDU - 1525（博弈）
面试笔记（六）---Js实现eventHandler
Windows 实例搭建的 FTP 在外网无法连接和访问
设计模式 : 桥接模式
USB 设备驱动开发之几个重要结构体分析
14-p14_sqrt求平方根
每日归档
更多
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022