Numpy
开源的Python科学计算库，主要功能之一是用来 操作数组和矩阵
数组创建
Numpy属性：ndim-维度，shape-行数和列数，size-元素个数
import numpy as np
#一维数组的创建
a=np.array([2,3,4],dtype=np.int32)
#多维数组的创建,([[1, 2, 3],[2, 3, 4]])
a=np.array([[1,2,3],[2,3,4]])
#创建全零数组([[ 0., 0., 0., 0.],[ 0., 0., 0., 0.]])
a=np.zeros((2,4))
#创建全1数组,全空数组
a=np.ones((3,4),dtype=np.int)
#创建连续数组。1-10的数据，步长为2 [1, 3, 5, 7, 9]
a=np.arange(1,10,2)
基本操作和运算
#一维矩阵运算
a=np.array([1,2,3,4])
b=np.arange(4)
c1=a-b #对应相减
c2=a*b #对应相乘
c3=a.dot(b) #对应相乘再求和
c4=b**2 #相应位置平方
c5=np.sin(a)
#多维矩阵运算
a=np.array([[1,1],[0,1]])
b=np.arange(4).reshape((2,2))
c1=a.dot(b) #c1=[[2 4] [2 3]]
a=np.random.random((2,4))
c2=np.sum(a,axis=0) #按列进行求和
c3=np.sum(a,axis=1) #按行进行求和
#矩阵基本运算
A=np.arange(2,14).reshape((3,4))
min=np.argmin(A) #返回最小值的索引
max=np.argmax(A) #返回最大值的索引
mean=np.mean(A) #整个矩阵的均值
median=np.median(A) #中位数
add=np.cumsum(A) #累加，每个位置的数是前边位置的和
sub=np.diff(A) #累差运算
B=np.array([[3,5,9],[4,8,10]])
nonzero=np.nonzero(B)#将非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵
A=np.arange(14,2,-1).reshape((3,4))
sort=np.sort(A) #只是对每行进行递增排序
transpose=np.transpose(A) #矩阵转置
clip=np.clip(A,5,9)
print(add,sub,nonzero)
print(A,sort,transpose,clip)#若Array中的元素在[Array_min,Array_max],则该对应位置为原数,若Array中的元素在<Array_min,则该对应位置为Array_min,若Array中的元素>Array_max,则该对应位置为Array_max
add=[ 2 5 9 14 20 27 35 44 54 65 77 90]
sub=[[1 1 1]
[1 1 1]
[1 1 1]]
nonzero=(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))#返回不为0的元素的索引，第一个数组是返回元素所在的行，第二个是返回列
A=[[14 13 12 11] [10 9 8 7] [ 6 5 4 3]]
sort=[[11 12 13 14] [ 7 8 9 10] [ 3 4 5 6]]#只是对每行进行递增排序
transpose=[[14 10 6] [13 9 5] [12 8 4] [11 7 3]]
clip=[[9 9 9 9] [9 9 8 7] [6 5 5 5]]
- 维度，行数和列数，元素个数
array=np.array([[3,5,9],[4,8,10]])
print(array.ndim,array.shape,array.size)#维度，行数和列数，元素个数
索引和切片
A=np.arange(3,15)
b=A.reshape(3,4)
print(b,'\n',b[2],'\n',b[0,2],b[1,1:3])
for row in b: #打印行
print(row)
for columns in b.T: #打印列
print(columns)
print(b.flatten()) #多维转一维
for item in b.flat: #flat是一个迭代器，本身是一个object属性
print(item)
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[11 12 13 14]
5 [8 9]
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
[ 3 4 5 6 7 8 9 10 11 12 13 14]
3
4
5
6
7
8
9
10
11
12
13
14
数组合并
A=np.array([1,1,1])
B=np.array([2,2,2])
c=np.vstack((A,B)) #vertical stack 上下合并
d=np.hstack((A,B)) #横向合并，这两个函数都只需要一个元素，所以把A,B放在一个元组里
e=np.dstack((A,B)) #深度合并，多了一个维度
print(c,d,e)
#数组转置为矩阵
A=A[:,np.newaxis]
B=B[:,np.newaxis]
C1=np.concatenate((A,B),axis=0) #纵向合并
C2=np.concatenate((A,B),axis=1) #横向合并
print(A,B,C1,C2)
c=[[1 1 1] [2 2 2]]
d=[1 1 1 2 2 2]
e=[[[1 2] [1 2] [1 2]]]
A=[[1][1][1]]
B=[[2][2][2]]
C1=[[1][1][1][2][2][2]]
C2=[[1 2][1 2][1 2]]
数组拆分
A=np.arange(12).reshape((3,4))
a=np.hsplit(A,2) #沿横向轴拆分
b=np.split(A,2,axis=1)
c=np.vsplit(A,3) #沿纵向轴拆分
d=np.split(A,3,axis=0)
#e=np.dsplit(A,2)#error,dsplit only works on arrays of 3 or more dimensions\
B=np.array([[[1,2],[3,4],[5,6]]])
e=np.dsplit(B,2)
print(A,a,b,c,d,e)
A=[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
a=[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
b=[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
c=[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])] d=[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])] e=[array([[[1], #三维以上才可以用深度拆分
[3],
[5]]]), array([[[2],
[4],
[6]]])]
copy和=
a=np.arange(4)
b=a
c=a.copy()
a[0]=11#a中元素发生变化，b也变化,c不变
print(a,b,c)
[11 1 2 3 ],
[ 11 1 2 3],
[0 1 2 3]
广播机制
当数组跟一个标量进行计算时，变量需要根据数组的形状进行扩展，然后执行运算，该过程称为“广播”
a=np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
b=np.array([0,1,2])
print(a+b) #a,b的维度不一样，在进行计算的时候会将b广播后计算
b=np.tile([0,1,2],(4,1))
print(b,a+b)
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
[[0 1 2]
[0 1 2]
[0 1 2]
[0 1 2]]
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
数组的类型转换
a=np.array([[0,1,20,3,4,5],[6,7,8,9,10,11]])
print(a.tolist()) #数组转化为列表
#转换成指定类型
print(a.astype(float))
[[0, 1, 20, 3, 4, 5], [6, 7, 8, 9, 10, 11]]
[[ 0. 1. 20. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]]
常用函数
bincount()
计算索引出现次数
x=np.array([1,2,3,3,0,1,4,0])
print(np.bincount(x))
#索引0出现2次，索引1出现2次，索引2出现1次，索引3出现2次，索引4出现1次，所以输出[2,2,1,2,1]
w=np.array([0.3,0.5,0.7,0.6,0.1,-0.9,1,0.2])
print(np.bincount(x,weights=w))#有权值w，则计算输出时，累加x值对应位置的w值，例如0所对应的是0.1加0.2
print(np.bincount(x,weights=w,minlength=7)) #bincount中元素为5个，当设置长度为7时，后边两位设为0
[2 2 1 2 1]
[ 0.3 -0.6 0.5 1.3 1. ]
[ 0.3 -0.6 0.5 1.3 1. 0. 0. ]
around()
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=0))
print(np.around([1.2798,2.357,9.67,13],decimals=2)) #decimals指定保留有效数的位数
print(np.around([1,2,5,6,56],decimals=-1)) #-1表示看最后一位数决定是否进位，大于5进位，小于5省去
print(np.around([1,2,5,6,56],decimals=-2)) #-2表示看最后两位数决定是否进位，大于50进位，小于50省去
[ -1. 1. 2. 10. 13.]
[ 1.28 2.36 9.67 13. ]
[ 0 0 0 10 60]
[ 0 0 0 0 100]
取整
print(np.floor([1.2,4.8]))#向下取整
print(np.ceil([1.2,4.8]))#向上取整
[ 1. 4.]
[ 2. 5.]
x=np.array([[ 1, 0],[ 2, -2],[-2, 1]])
np.where(x>0,x,0) #大于0的数不变，小于0的值用0填充
array([[1, 0],
[2, 0],
[0, 1]])