操作 numpy 数组的常用函数Word文件下载.docx
《操作 numpy 数组的常用函数Word文件下载.docx》由会员分享，可在线阅读，更多相关《操作 numpy 数组的常用函数Word文件下载.docx（15页珍藏版）》请在冰豆网上搜索。
v1+2
array（[2,3,4,5,6]）
A*2,A+2
（array（[[0,2,4,6,8],
[20,22,24,26,28],
[40,42,44,46,48],
[60,62,64,66,68],
[80,82,84,86,88]]）,
array（[[2,3,4,5,6],
[12,13,14,15,16],
[22,23,24,25,26],
[32,33,34,35,36],
[42,43,44,45,46]]））Element-wise（逐项乘）数组-数组运算
当我们在矩阵间进行加减乘除时，它的默认行为是element-wise（逐项乘）的:
A*A#element-wisemultiplication
array（[[0,1,4,9,16],
[100,121,144,169,196],
[400,441,484,529,576],
[900,961,1024,1089,1156],
[1600,1681,1764,1849,1936]]）
v1*v1
array（[0,1,4,9,16]）
A.shape,v1.shape
（（5,5）,（5,））
A*v1
[0,11,24,39,56],
[0,21,44,69,96],
[0,31,64,99,136],
[0,41,84,129,176]]）矩阵代数
矩阵乘法要怎么办?
有两种方法。
1.使用dot函数进行矩阵－矩阵，矩阵－向量，数量积乘法：
dot（A,A）
array（[[300,310,320,330,340],
[1300,1360,1420,1480,1540],
[2300,2410,2520,2630,2740],
[3300,3460,3620,3780,3940],
[4300,4510,4720,4930,5140]]）
dot（A,v1）
array（[30,130,230,330,430]）
dot（v1,v1）
302.将数组对象映射到matrix类型。
M=matrix（A）
v=matrix（v1）.T#makeitacolumnvector
v
matrix（[[0],
[1],
[2],
[3],
[4]]）
M*M
matrix（[[300,310,320,330,340],
M*v
matrix（[[30],
[130],
[230],
[330],
[430]]）
#innerproduct
v.T*v
matrix（[[30]]）
#withmatrixobjects,standardmatrixalgebraapplies
v+M*v
[131],
[232],
[333],
[434]]）加减乘除不兼容的维度时会报错：
v=matrix（[1,2,3,4,5,6]）.T
shape（M）,shape（v）
（（5,5）,（6,1））
=&
Traceback（mostrecentcalllast）:
File"
&
lt;
ipython-input-9-995fb48ad0cc&
"
line1,in&
module&
M*v
/Applications/Spyder-Py2.app/Contents/Resources/lib/python2.7/numpy/matrixlib/defmatrix.py"
line341,in__mul__
returnN.dot（self,asmatrix（other））
ValueError:
shapes（5,5）and（6,1）notaligned:
5（dim1）!
=6（dim0）查看其它运算函数:
inner,outer,cross,kron,tensordot。
可以使用help（kron）。
数组/矩阵变换
之前我们使用.T对v进行了转置。
我们也可以使用transpose函数完成同样的事情。
让我们看看其它变换函数：
C=matrix（[[1j,2j],[3j,4j]]）
C
matrix（[[0.+1.j,0.+2.j],
[0.+3.j,0.+4.j]]）共轭：
conjugate（C）
matrix（[[0.-1.j,0.-2.j],
[0.-3.j,0.-4.j]]）共轭转置：
C.H
matrix（[[0.-1.j,0.-3.j],
[0.-2.j,0.-4.j]]）real与imag能够分别得到复数的实部与虚部：
real（C）#sameas:
C.real
matrix（[[0.,0.],
[0.,0.]]）
imag（C）#sameas:
C.imag
matrix（[[1.,2.],
[3.,4.]]）angle与abs可以分别得到幅角和绝对值：
angle（C+1）#headsupMATLABUsers,angleisusedinsteadofarg
array（[[0.78539816,1.10714872],
[1.24904577,1.32581766]]）
abs（C）
[3.,4.]]）矩阵计算
矩阵求逆
fromscipy.linalgimport*
inv（C）#equivalenttoC.I
matrix（[[0.+2.j,0.-1.j],
[0.-1.5j,0.+0.5j]]）C.I*C
matrix（[[1.00000000e+00+0.j,4.44089210e-16+0.j],
[0.00000000e+00+0.j,1.00000000e+00+0.j]]）行列式
linalg.det（C）
（2.0000000000000004+0j）
linalg.det（C.I）
（0.50000000000000011+0j）数据处理
将数据集存储在Numpy数组中能很方便地得到统计数据。
为了有个感性地认识，让我们用numpy来处理斯德哥尔摩天气的数据。
#reminder,thetempeaturedatasetisstoredinthedatavariable:
shape（data）
（77431,7）平均值
#thetemperaturedataisincolumn3
mean（data[:
3]）
6.1971096847515925过去200年里斯德哥尔摩的日均温度大约是6.2C。
标准差与方差
std（data[:
3]）,var（data[:
（8.2822716213405663,68.596023209663286）最小值与最大值
#lowestdailyaveragetemperature
data[:
3].min（）
-25.800000000000001
#highestdailyaveragetemperature
3].max（）
28.300000000000001总和,总乘积与对角线和
d=arange（0,10）
d
array（[0,1,2,3,4,5,6,7,8,9]）
#sumupallelements
sum（d）
45
#productofallelements
prod（d+1）
3628800
#cummulativesum
cumsum（d）
array（[0,1,3,6,10,15,21,28,36,45]）
#cummulativeproduct
cumprod（d+1）
array（[1,2,6,24,120,720,5040,
40320,362880,3628800]）
#sameas:
diag（A）.sum（）
trace（A）
110对子数组的操作
我们能够通过在数组中使用索引，高级索引，和其它从数组提取数据的方法来对数据集的子集进行操作。
举个例子，我们会再次用到温度数据集：
!
head-n3stockholm_td_adj.dat
180011-6.1-6.1-6.11
180012-15.4-15.4-15.41
180013-15.0-15.0-15.01该数据集的格式是：
年，月，日，日均温度，最低温度，最高温度，地点。
如果我们只是关注一个特定月份的平均温度，比如说2月份，那么我们可以创建一个索引掩码，只选取出我们需要的数据进行操作：
unique（data[:
1]）#themonthcolumntakesvaluesfrom1to12
array（[1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,
12.]）
mask_feb=data[:
1]==2
mean（data[mask_feb,3]）
-3.2121095707366085拥有了这些工具我们就拥有了非常强大的数据处理能力。
像是计算每个月的平均温度只需要几行代码：
months=arange（1,13）
monthly_mean=[mean（data[data[:
1]==month,3]）formonthinmonths]
fig,ax=subplots（）
ax.bar（months,monthly_mean）
ax.set_xlabel（"
Month"
）
ax.set_ylabel（"
Monthlyavg.temp."
）;
对高维数组的操作
当诸如min,max等函数对高维数组进行操作时，有时我们希望是对整个数组进行该操作，有时则希望是对每一行进行该操作。
使用axis参数我们可以指定函数的行为：
m=rand（3,3）
m
array（[[0.09260423,0.73349712,0.43306604],
[0.65890098,0.4972126,0.83049668],
[0.80428551,0.0817173,0.57833117]]）
#globalmax
m.max（）
0.83049668273782951
#maxineachcolumn
m.max（axis=0）
array（[0.80428551,0.73349712,0.83049668]）
#maxineachrow
m.max（axis=1）
array（[0.73349712,0.83049668,0.80428551]）改变形状与大小
Numpy数组的维度可以在底层数据不用复制的情况下进行修改，所以reshape操作的速度非常快，即使是操作大数组。
A
array（[[0,1,2,3,4],
[10,11,12,13,14],
[20,21,22,23,24],
[30,31,32,33,34],
[40,41,42,43,44]]）
n,m=A.shape
B=A.reshape（（1,n*m））
B
array（[[0,1,2,3,4,10,11,12,13,14,20,21,22,23,24,30,31,
32,33,34,40,41,42,43,44]]）
B[0,0:
5]=5#modifythearray
array（[[5,5,5,5,5,10,11,12,13,14,20,21,22,23,24,30,31,
A#andtheoriginalvariableisalsochanged.Bisonlyadifferentviewofthesamedata
array（[[5,5,5,5,5],
[40,41,42,43,44]]）我们也可以使用flatten函数创建一个高阶数组的向量版本，但是它会将数据做一份拷贝。
B=A.flatten（）
array（[5,5,5,5,5,10,11,12,13,14,20,21,22,23,24,30,31,
32,33,34,40,41,42,43,44]）
B[0:
5]=10
array（[10,10,10,10,10,10,11,12,13,14,20,21,22,23,24,30,31,
A#nowAhasnotchanged,becauseB'
sdataisacopyofA'
s,notreferingtothesamedata
[40,41,42,43,44]]）增加一个新维度:
newaxis
newaxis可以帮助我们为数组增加一个新维度，比如说，将一个向量转换成列矩阵和行矩阵：
v=array（[1,2,3]）
shape（v）
（3,）
#makeacolumnmatrixofthevectorv
v[:
newaxis]
array（[[1],
[3]]）
#columnmatrix
newaxis].shape
（3,1）
#rowmatrix
v[newaxis,:
].shape
（1,3）叠加与重复数组
函数repeat,tile,vstack,hstack,与concatenate能帮助我们以已有的矩阵为基础创建规模更大的矩阵。
tile与repeat
a=array（[[1,2],[3,4]]）
#repeateachelement3times
repeat（a,3）
array（[1,1,1,2,2,2,3,3,3,4,4,4]）
#tilethematrix3times
tile（a,3）
array（[[1,2,1,2,1,2],
[3,4,3,4,3,4]]）concatenate
b=array（[[5,6]]）
concatenate（（a,b）,axis=0）
array（[[1,2],
[3,4],
[5,6]]）
concatenate（（a,b.T）,axis=1）
array（[[1,2,5],
[3,4,6]]）hstack与vstack
vstack（（a,b））
hstack（（a,b.T））
[3,4,6]]）浅拷贝与深拷贝
为了获得高性能，Python中的赋值常常不拷贝底层对象，这被称作浅拷贝。
A=array（[[1,2],[3,4]]）
[3,4]]）
#nowBisreferringtothesamearraydataasA
B=A
#changingBaffectsA
B[0,0]=10
array（[[10,2],
[3,4]]）
[3,4]]）如果我们希望避免改变原数组数据的这种情况，那么我们需要使用copy函数进行深拷贝：
B=copy（A）
#now,ifwemodifyB,Aisnotaffected
B[0,0]=-5
array（[[-5,2],
[3,4]]）遍历数组元素
通常情况下，我们是希望尽可能避免遍历数组元素的。
因为迭代相比向量运算要慢的多。
但是有些时候迭代又是不可避免的，这种情况下用Python的for是最方便的：
v=array（[1,2,3,4]）
forelementinv:
print（element）
1
2
3
4M=array（[[1,2],[3,4]]）
forrowinM:
print（"
row"
row）
forelementinrow:
row[12]
row[34]
4当我们需要遍历数组并且更改元素内容的时候，可以使用enumerate函数同时获取元素与对应的序号：
forrow_idx,rowinenumerate（M）:
row_idx"
row_idx,"
forcol_idx,elementinenumerate（row）:
col_idx"
col_idx,"
element"
element）
#updatethematrixM:
squareeachelement
M[row_idx,col_idx]=element**2
row_idx0row[12]
col_idx0element1
col_idx1element2
row_idx1row[34]
col_idx0element3
col_idx1element4#eachelementinMisnowsquared
Marray（[[1,4],
[9,16]]）矢量化函数
像之前提到的，为了获得更好的性能我们最好尽可能避免遍历我们的向量和矩阵，有时可以用矢量算法代替。
首先要做的就是将标量算法转换为矢量算法：
defTheta（x）:
"
Scalarimplemenationofth
升级会员 