1. ndarray数组合并
| 方法 | 用途 |
|---|---|
| row_stack(tup) | 多个一维array当作行，合并成2维（行拼接）== vstack（效果一样） |
| column_stack(tup) | 多个一维array当作列，合并成2维（列拼接）==hstack（效果一样） |
| vstack(tup) | 沿第一个维度合并（行拼接） |
| hstack(tup) | 沿第二个维度合并（列拼接） |
| 通用公式 | concatenate(tup,axis=0/1) 沿着指定维度合并 |
2.ndarray数组拆分
| 方法 | 用途 |
|---|---|
| hsplit(arr,indices) | 拆分多列 |
| vsplit(arr,indices) | 拆成多行 |
| split(arr,indices,axis=0) 通用公式 | 沿着指定方向拆分 |
ndarray 数组运算
1.算数运算
+，-，/，*，//(floor division整除),**(幂)，%(取模)
算数运算都是针对相同位置的元素进行的。
更新运算符：+=，-=，*=，/=，**=2.比较运算
同算术运算，返回bool值
还可以通过通用函数：算术函数 来进行计算3.判断
np.all(alltrue) 判断array 是否所有元素都为True
np.any(sometrue) 判断array 是否至少有一个True4.聚合计算：沿着一个指定维度计算汇总
np.average 加权平均值（arr1 , weights = arr2）
np.mean 算术平均值（arr1）
np.median 计算中位数
np.sum 求和
np.prod 求乘积（阶乘）
np.cumprod 数组的累积乘积
np.min 求最小
np.max 求最大
np.bincount 计算每个元素出现的次数
5 查找和排列
np.argmin 沿指定维度查找最小值下标
np.argmax 沿指定维度查找最大值下标
np.nonzero 查找非零元素的下标
np.where（condition） 根据条件查找或替换
np.take(column,index) #根据索引获取值
np.argsort 沿着指定维度计算下标，按这个下标元素是递增的
np.sort 沿指定维度 元素按递增顺序排序
np.lexsort 根据多个array进行排序
6 数组的修剪
clip()函数计算：将所有比给定最大值num1还大的元素全部设为num1，
而所有比给定最小值num2还小的元素全部设为给定的最小值num2
arr1. clip(num1,num2)
arr1= [0 1 2 3 4]
Clipped [1 1 2 2 2] 7 数组的压缩
利用compres ()函数计算：返回一个根据给定条件筛选后的数组。线性代数
1矩阵的创建 np.mat( ) / np.bmat( )
mat1 = np.mat('1 2 3 4;5 6 7 8;9 11 12 13') #创建矩阵,方法1
mat2 = np.mat(np.arange(9)).reshape(3,3) #创建矩阵，方法2
print(mat1)
print(mat2)
>>> #输出mat1
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 11 12 13]]
>>> #输出mat2
[[0 1 2]
[3 4 5]
[6 7 8]]
----------------------------------------------------
A = np.eye(3,3)
B = A*2
mat3 = np.bmat("A B;B A")
print(A,"\n")
print(B,"\n")
print(mat3)
>>> #输出 A 矩阵
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
>>> 输出 B 矩阵
[[2. 0. 0.]
[0. 2. 0.]
[0. 0. 2.]]
>>> 输出 mat3 矩阵
[[1. 0. 0. 2. 0. 0.]
[0. 1. 0. 0. 2. 0.]
[0. 0. 1. 0. 0. 2.]
[2. 0. 0. 1. 0. 0.]
[0. 2. 0. 0. 1. 0.]
[0. 0. 2. 0. 0. 1.]]
2 创建随机数矩阵函数
3 矩阵统计函数
np.random.normal(loc,scale,size): # loc:均值；scale标准差；size 数据量
loc：float
此概率分布的均值（对应着整个分布的中心centre）
scale：float
此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
4 一元通用函数
| 函数 | 说明 |
|---|---|
| add | 将数组中对应的元素相加 |
| subtract | 从第一个数组中减去第二个数组中的元素 |
| multiply | 数组元索相乘 |
| divide、floor_divide | 数组元索相乘 |
| power | 对第一个救组中的元素，根据第二个数组中的相应元索B ，计算AB. |
| max、fmax | 元素级的最大值计算。 fmax 将忽峪 NaN |
| min、fmix | 元素级的最小值计林。 fmin 将忽略 NaN |
| mod | 元素级的求模计算（除法的余数） |
| copysign | 将第二个数组中的值的符号复制给第一个数组中的值 |
| greater、greater_equal、less、less_equal、equal Not_qual | 执行元素级的比较运算，最终产生布尔型数组。相当于中缀运算符 >，>=，<，<=，==．!= |
| logical_add、logical_or、 Logical_xor | 执行元素级的直值逻辑运算。相当于中缀运算符＆、 |
6 自定义函数 zero_like:
a = np.array(np.arange(9)).reshape(3,3)
def ultimate_answer(a):
result = np.zeros_like(a)
result.flat = 42
return result
function_like = np.frompyfunc(ultimate_answer,1,1)
text=function_like(a)
print(text)
7 四种自定义求和函数
a = np.arange(9)
print("Reduce", np.add.reduce(a))
>>>36
print("Accumulate", np.add.accumulate(a))
>>>[ 0 1 3 6 10 15 21 28 36]
print("Reduceat", np.add.reduceat(a, [0, 5, 2, 7]))
>>>[10 5 20 15]
#第一步用到索引值列表中的0和5，对数组中索引值在0到5之间的元素进行reduce操作 得到10
#第二步用到索引值5和2。由于2比5小，所以直接返回索引值为5的元素 得到5
#第三步用到索引值2和7。对索引值在2到7之间的数组元素进行reduce操作 得到20
#第四步用到索引值7。对索引值从7开始直到数组末端的元素进行reduce操作 得到15
print("Outer", np.add.outer(np.arange(1,3), a))
>>>[[ 1 2 3 4 5 6 7 8 9]
>>>[ 2 3 4 5 6 7 8 9 10]]
#返回1+a数组的每个元素；
#返回2+a数组的每个元素。
8 numpy.linalg 模块主要函数
| 函数及描述 | 演示代码 |
|---|---|
| dot 两个数组的点积 | a = np.array([[1,2],[3,4]]), b = np.array([[11,12],[13,14]]); np.dot(a,b)：[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]] |
| vdot 两个向量的点积 | a = np.array([[1,2],[3,4]]) , b = np.array([[11,12],[13,14]]) ; np.vdot(a,b)：1*11 + 2*12 + 3*13 + 4*14 = 130 |
| inner 两个数组的内积 | np.inner(np.array([1,2,3]),np.array([0,1,0]));输出： 1*0+2*1+3*0 |
| matmul 两个数组的矩阵积 | 矩阵乘法 |
| determinant 数组的行列式 | 行列式的det |
| solve 求解线性矩阵方程 | |
| inv 寻找矩阵的乘法逆矩阵 |
print('------------逆矩阵与单位矩阵---------------')
import numpy as np
A = np.mat("0 1 2;1 0 3;4 -3 8")
print("A=",A)
inverse = np.linalg.inv(A)
print(u"A的逆矩阵：","\n",inverse)
I = A*inverse
print('单位矩阵:I = A*inverse：',"\n",I)
>>>
A= [[ 0 1 2]
[ 1 0 3]
[ 4 -3 8]]
A的逆矩阵：
[[-4.5 7. -1.5]
[-2. 4. -1. ]
[ 1.5 -2. 0.5]]
单位矩阵:I = A*inverse：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
使用 np.linalg.solve(A, b) 求解线性方程组
A= np.mat("1 -2 1;0 2 -8;-4 5 9")
B= np.array([0,8,-9])
C = np.linalg.solve(A,B)
print("X=",C[0],"Y=", C[1],"Z=", C[2])
>>>
X= 29.0
Y= 16.0
Z= 3.0
9 特征值、特征向量
Arr =np.mat("3 -2;1 0")
print("单独求特征值：",np.linalg.eigvals(Arr))
print("特征值，特征向量：",np.linalg.eig(Arr))
>>>
单独求特征值： [2. 1.]
特征值，特征向量： (array([2., 1.]),
matrix([[0.89442719, 0.70710678],
[0.4472136 , 0.70710678]]))
10奇异值分解
print('----------------SVD奇异值分解---------------')
Arr2 = np.mat("4 11 14;8 7 -2")
U,Sigma,V = np.linalg.svd(Arr2,full_matrices=False)
print("U",U)
print("Sigma",Sigma)
print("V",V)
>>>
U [[-0.9486833 -0.31622777]
[-0.31622777 0.9486833 ]]
Sigma [18.97366596 9.48683298]
V [[-0.33333333 -0.66666667 -0.66666667]
[ 0.66666667 0.33333333 -0.66666667]]
11 计算矩阵的行列式
print('----------矩阵行列式的计算-----------')
Arr3 = np.mat("3 4;5 6")
print("矩阵行列式的计算：",np.linalg.det(Arr3))
>>>
矩阵行列式的计算： -2.0000000000000013排序函数
ndarray类的sort方法——可对数组进行原地排序； np.sort(-arr , axis=1)降序排序
argsort函数——返回输入数组排序后的下标； np.argsort(-arr,axis=1)降序排序
sort函数——返回排序后的数组
print('----------------ndarray排序-----------------')
list1 = [[3,1,2],[5,7,0]]
array1 = np.array(list1)
array1.sort(axis=1)
print(array1)
>>>
[[1 2 3]
[0 5 7]]
print("------------返回排序后的索引值----------------")
list1 = [[3,1,2],[5,7,0]]
array1 = np.array(list1)
array2 = np.argsort(array1,axis=0) #返回列索引
array3 = np.argsort(array1,axis=1) #返回行索引
print("array2:",array2)
print("array3:",array3)
>>>
array2:[[0 0 1]
[1 1 0]]
array3:[[1 2 0]
[2 0 1]]
---------------------
作者：SongpingWang
来源：CSDN
原文：https://blog.csdn.net/wsp_1138886114/article/details/80527863
版权声明：本文为博主原创文章，转载请附上博文链接！搜索函数
◆ argmax函数： 返回数组中最大值对应的下标
◆ nanargmax函数： 与argmax提供相同的功能，但忽略NaN值
◆ argmin函数： 返回数组中最小值对应的下标
◆ nanargmin函数： 与argmin的功能类似， 但忽略NaN值
◆ argwhere函数： 根据条件搜索非零的元素，并分组返回对应的下标
◆ searchsorted函数：为指定的插入值寻找维持数组排序的索引位置。该函数使用二分
print('----------返回最大值的索引----------')
arr_a = np.array([[3,1,2],[5,7,0]])
print(np.argmax(arr_a)) #先将多维数组展平，再返回最大值的索引
print("------argwhere返回对应的下标-----")
arr_a = np.array([[3,1,2],[5,7,0]])
print(np.argwhere(arr_a>3))
>>>
[[1 0] #第二行第一列
[1 1]] #第二行第二列
print('-----searchsorted()为指定的插入值寻找维持数组排序的索引位置----')
arr_b = np.arange(5)
arr_insert = np.searchsorted(arr_b,[-1,7])
print("插入后：",np.insert(arr_b,arr_insert,[-1,7]))
>>>
插入后： [-1 0 1 2 3 4 7]
数组元素抽取
extract函数——根据某个条件从数组中抽取元素
nonzero函数——专门用来抽取非零的数组元素print('-----------元素抽取-------------')
arr_ele = np.arange(8)
condition =(arr_ele%2) ==0
print("抽取能被2整除的元素：",np.extract(condition,arr_ele))
print("非零值：",np.nonzero(arr_ele))
>>
抽取能被2整除的元素： [0 2 4 6]
非零值： (array([1, 2, 3, 4, 5, 6, 7], dtype=int64),)
print('-----------元素抽取(condition)-------------')
arr_ele = np.arange(8)
arr_fa = arr_ele.compress(condition=(arr_ele%2) ==0)
print("抽取能被2整除的元素",arr_fa)
print('-----------元素抽取(where)-------------')
arr_ele = np.arange(8)
arr_fa = np.where((arr_ele%2) ==0)
print("抽取能被2整除的元素",arr_fa)
print('---------非零元素索引提取----------')
arr = np.array([[0,1,3],
[0,4,7],
[7,0,9]])
row,col = np.nonzero(arr)
print("非零元素行索引row_index",row)
print("非零元素列索引col_index",col)
ndarray的文件IO
1.保存为二进制文件
保存单个 array( .npy文件)
np.save(file,arr,allow_pickle=True,fix_imports=True)
allow_pickle:允许使用pickle的方式保存对象。出于安全性和兼容性考虑，会禁用pickle
安全性：加载一个pickle的数据时，会执行任何代码
兼容性：pickle对象对版本有要求，不同版本python不兼容
保存多个 array(.npz文件)
np.savez(file,*args,**kwargs)
*args:以列表参数的方式指定要保存的array，无法保存array变量名，加载时通过arr_0,arr_1这种方式获取。
**kwargs:以命名参数的方式指定array，加载时可以通过名称获取array
保存多个array并压缩( .npz文件)
np.savez_compressed(file,*args,**kwargs)
2 加载二进制文件
np.load(file,mmap_mode=None,allow_pickle=True,fix_imports=True,encoding='ASCII')
mmap_mode:可选值(None,'r+','r','w+','c')。如果不是None，则会用指定的模式把内存块映射为一个file对象。
可以实现访问array中的一部分而不用把整个array导入内存
fix_imports：只在python3中读取python2 生成含pickle对象的文件时有用
encoding： 只在python3中读取python2 生成含pickle对象的文件时有用
可选值有('latin1','ASCII',bytes)
np.load 可以支持。npy和,npz文件的读取
读取.npy文件 直接返回array
读取.npz文件，返回一个NpzFile对象（用完close），可以通过.key()方法查看包含的array
3 保存为文本文件
np.savetxt(filename,array,fmt= '%.18e',delimiter='',
newline='\n',header='',footer='',comments='#')
-filename: 文件名，若以.gz结尾则自动以gzip压缩
-fmt: 保存格式
-delimiter：分隔符
-newline： 换行符
-header： 首行输出内容
-footer： 末行输出内容
-comments: 在header和footer前插入的字符，表示注释
4 加载文本文件
np.loadtxt(fname,dtype=<type 'float'>,comments= '#',delimiter=None,
concerters=None,skiprows=0,usecols=None,skiprows=0,uppack=False,ndmin=0)
comments : 在header和footer前插入的字符，表示注释
concerters : 转换函数字典，通过下标key,为每列定义一个转换函数
skiprows : 跳过开头的若干行
usecols : 使用指定列，下标0开始
uppack : 若为 True,可以用变量捕获每一列
ndmin : 最小的维度数
import numpy as np
■ 无参数写读
arr1 = np.random.normal(size=20).reshape(4,5) #创建随机数矩阵
np.savetxt('arr1_file.txt',arr1) #默认分隔符：空格
arr_data1 = np.loadtxt('arr_file.txt')
■ 带参数写读
arr2 = np.random.normal(size=20).reshape(4,5) # 创建随机数矩阵
np.savetxt('arr1_file.txt',arr2,fmt="%d",delimiter=",") # %d: 保存为整数，
# 分隔符：逗号
arr_data2 = np.loadtxt('arr2_file.txt',delimiter=",")
■ 读取文件：
arr3_file.csv文件内容如下：
"姓名","年龄","年级","体重","身高"
"李光",30,12,100,188
"司马光",42,9,120,178
"董卓",56,8,155,184
"项羽",45,9,142,186
arr3_data = np.loadtxt('arr3_file.csv',dtype = np.str,delimiter=",")
arr3_num = arr3_data[1:,1:].astype(np.float)
print(arr3_num)
>>>
[[ 30. 12. 100. 188.]
[ 42. 9. 120. 178.]
[ 56. 8. 155. 184.]
[ 45. 9. 142. 186.]
[ 65. 6. 152. 189.]]
金融函数
fv 函数——计算所谓的终值（future value），某个金融资产在未来某一时间点的价值。
pv 函数——计算现值（present value），即金融资产当前的价值。
npv 函数——计算净现值（net present value），即按折现率计算的净现金流之和。
pmt 函数——根据本金和利率计算每期需支付的金额。(payment)
nper函数——计算定期付款的期数。
rate函数——计算利率（rate of interest）。
1. 某用户去银行存款，假设年利率3%、每季度续存金额 -------------计算fv
10元、存5年以及存款1000，则计算5年后可领取多少金额
分析：
rate : 0.03/4
nper : 5*4
pmt : -10
pv : -1000
fv : 存款终值是本息和 贷款终值是0
import numpy as np
print("Future value",np.fv(0.03/4,5*4,-10,-1000))
fvals = []
for i in range(1,6):
fvals.append(np.fv(.03/4,i*4,-10,-1000))
print('第{}年的本息和是{}'.format(i,fvals[i-1]))
>>>
Future value 1376.0963320407982
第1年的本息和是1070.7914448828128
第2年的本息和是1143.7306449093103
第3年的本息和是1218.8827612322955
第4年的本息和是1296.3149319412119
第5年的本息和是1376.0963320407982
2.某用户去银行存款，假设年利率3%、每季度续存金额10--------------计算pv
元、存5年后可领1376.0963320，则计算5年前存取的本金是多少金额
pv = np.pv(0.03/4,5*4,-10,1376.096)
print("当初存钱：",np.round(pv)) --np.round()四舍五入
>>>
当初存钱： -1000.0
3.投资100，支出39、 59、 55、 20。 折现率为28.1%，则净现值为多少？---计算npv
1
print("npv:",np.npv(0.281,[-100,39,59,55,20]))----rate:折现率；values:现金流
>>>
npv: -0.00847859163845488
4.某同学房贷20万，准备15年还清，年利率为7.5%，则每月需还贷多少金额 ----计算pmt
print("每月需还贷金额为:",np.pmt(0.075/12,12*15,200000))
>>>
每月需还贷金额为: -1854.0247200054619
5.某同学房贷20万，年利率为7.5%，每月能还贷2000，则需要还多少期?-------计算nper
year = np.ceil(np.nper(0.075/12,-2000,200000)/12)------np.ceil：向上取整
print("需要还贷{}年。".format(year))
>>>
需要还贷14.0年。
广播
让两个不同维度的 array进行元素运算
若维数较小的array增加1的维度，直到两者维数相等
x = np.arange(6).reshape((2,3))
y = np.arange(9).reshape((3,3))
x[:,np.newaxis,:]+y
array([
[[0,2,4],
[3,5,7],
[6,8,10]]
[[3,5,7],
[6,8,10],
[9,11,13]]
])
转载自：https://blog.csdn.net/wsp_1138886114/article/details/80527863#t7
扫一扫
91
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
