Numpy基础知识

import numpy as np

axis = i 就在 i 这个维度上进行操作
ndim 维度
shape 形状
size 元素个数
dtype 数据类型

#创建连续型数据
a=np.linspace(1,10,5)  #首1，尾10，分成5个数据
print(a)

[ 1. 3.25 5.5 7.75 10. ]

基本操作和运算

A = [[1,2,-5],
     [-2,-7,4],
     [1,-3,6]]
np.exp(A)  #求e^A
np.log(A)  #求log(A)
np.abs(A)  #求绝对值
np.maximum(A, 0)  #求出矩阵A中所有元素和0之间相比的最大值
A**2  #A中每个元素的平方
1/A   #A中每个元素的倒数

np.dot(A,B)  #对应相乘再求和  A.dot(B)  @ 相当于 dot()
np.sum()  #矩阵中数求和
np.sum(A,axis=0) #按列进行求和
np.sum(A,axis=1) #按行进行求和
np.min()  #矩阵中最小的值
np.mean()  #整个矩阵的均值  a.mean()  accuracy = np.mean(y_pred_label == y_true_label)

np.bincount()  #计算索引出现的次数
np.argmin()  #返回最小值元素的索引
np.argmax()  #返回最大值元素的索引
np.argmax(x,axis=0)  #按列操作返回最大元素的索引位置
np.argmax(x,axis=1)  #按行操作返回最大元素的索引位置，对于同为最大值，返回第一个的位置索引即可

np.average()  #平均数
np.median()  #中位数
np.cumsum()  #累加,每个位置的数是前边所有数与当前位置数的和
np.diff()  #累差运算
np.nonzero()  #将非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵

np.sort(A)  #只是对每行进行递增排序
sort()  #函数 sort()用于列表list中元素的排序，list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值
sorted()  #排序，sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作，reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
np.argsort()  #返回的是数组值从小到大的索引值

np.transpose(A)  #矩阵转置  A.T
np.clip(A,5,9)   #对矩阵A中的数，比5小的数变为5，比9大的变为9，其他的不变
#clip(Array,Array_min,Array_max) 
#若Array中的元素在[Array_min,Array_max],则该对应位置为原数
#若Array中的元素在<Array_min,则该对应位置为Array_min
#若Array中的元素在>Array_max,则该对应位置为Array_max

np.flatten()  #多维转一维，返回一份拷贝，对拷贝所做修改不会影响原始矩阵
np.rave() #多维数组降为一维，返回的是视图，修改时会影响原始矩阵 
np.expand_dims()  #在axis位置上增加一个维度
np.squeeze()  # 去掉维度为1的维

zip()  
'''
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，
利用 * 号操作符，可以将元组解压为列表。
在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

'''
map()
'''
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，
返回包含每次 function 函数返回值的新列表。
'''
np.unique()  #对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由小到大返回一个新的无元素重复的元组或者列表
np.reshape(A, (m,n)) # m行n列
np.logical_and()  #逻辑与

#合并
np.stack()
np.vstack((A,B))  #vertical stack上下合并
np.hstack((A,B))  #水平合并
np.dstack((A,B))  #深度合并
np.concatenate((A,B),axis=0)  #纵向合并
np.concatenate((A,B),axis=1)  #横向合并

#拆分
np.split(A,2,axis=1)  #沿横向轴拆分，等价于np.hsplit(A,2)
np.hsplit(A,2)  #沿横向轴拆分（axis=1）
np.split(A,3,axis=0)  #沿纵向轴拆分，等价于np.vsplit(A,3)
np.vsplit(A,3)   #沿纵向轴拆分（axis=0）
np.dsplit()  #深度拆分

np.greater_equal(x1, x2)  #以元素方式返回（x1> = x2）的真值(True / False)
#np.greater_equal(y_pred_numpy, 0.5).astype(np.float32)
np.equal(x1, x2)  #以元素方式返回（x1 == x2）的真值(True / False)

z,s = np.meshgrid(x, y)  #从坐标向量返回坐标矩阵，将 x 变成了矩阵 z 的行向量，y 变成了矩阵 s 的列向量

np.where()  
'''
np.where(condition, x, y)
满足条件(condition)，输出x，不满足输出y。

np.where(condition)
只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。
这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，
分别对应符合条件元素的各维坐标。
'''
np.flatnonzero(x == 3)  #返回某个特定元素的位置

np.round(x)  #返回浮点数x的四舍五入值
np.around()  #近似取整
np.floor()  #向下取整
np.ceil()  #向上取整

np.linalg.inv()  #矩阵求逆  A.I
np.linalg.det()  #矩阵求行列式（标量）
np.linalg.norm()   #求范数
np.tile([0,1,2],(4,1)) #  [0,1,2]   行重复4次，列重复1次
a.tolist()  #数组a 转换成list，使用tolist()
a.astype(float)  #转换成指定类型

# 一维矩阵运算
a=np.array([1,2,3,4])
b=np.arange(4)
print(a,b)

c1=a-b   #对应相减
print(c1)

c2=a*b  #对应相乘
print(c2)

c3=a.dot(b) #对应相乘再求和
#c3=np.dot(a,b)
print(c3)  

c4=b**2 #相应位置平方
print(c4)  

c5=np.sin(a)  #数学函数工具求sin
print(c5)

print(a<2)

#多维矩阵运算
a=np.array([[1,1],[0,1]])
b=np.arange(4).reshape((2,2))
print(a)
print(b)

c1=a.dot(b) #矩阵乘a*b
print(c1)

a=np.random.random((2,4))
print(a)
print(np.sum(a))
print(np.min(a))
print(np.mean(a))

c2=np.sum(a,axis=0) #按列进行求和
c3=np.sum(a,axis=1) #按行进行求和

#矩阵基本计算
A=np.arange(2,14).reshape((3,4))
print(A)

print('最小值元素索引%d'% np.argmin(A))
print('最大值元素索引%d'% np.argmax(A))
print('整个矩阵的均值%f'% np.mean(A))
print(np.average(A))
print(A.mean())

print(np.median(A)) #中位数

print(np.cumsum(A))  #累加,每个位置的数是前边位置的和

print(np.diff(A)) #累差运算

B=np.array([[3,5,9],[4,8,10]])
print(np.nonzero(B))  #将非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵

A=np.arange(14,2,-1).reshape((3,4))
print(A)
print(np.sort(A))#只是对每行进行递增排序

print(np.transpose(A)) #矩阵转置
print(A.T)

print(A)
print(np.clip(A,5,9))   
#clip(Array,Array_min,Array_max) 
#若Array中的元素在[Array_min,Array_max],则该对应位置为原数
#若Array中的元素在<Array_min,则该对应位置为Array_min
#若Array中的元素在>Array_max,则该对应位置为Array_max

数组合并

#数组合并
A=np.array([1,1,1])
print(A)
B=np.array([2,2,2])
print(np.vstack((A,B)))  #vertical stack上下合并

C=np.vstack((A,B))
print(C)

print(A.shape,B.shape,C.shape)

D=np.hstack((A,B))
print(D)

print(A.shape,B.shape,D.shape)

#深度合并
b=np.array([[0,1,20,3,4,5],[6,7,8,9,10,11]])
c=b*2
arr_dstack=np.dstack((b,c))
print(arr_dstack.shape)
arr_dstack

#数组转置为矩阵
print(A[np.newaxis,:])
print(A[np.newaxis,:].shape)
print(A[:,np.newaxis])

#多个矩阵合并p
print(A)
print(B)
A=A[:,np.newaxis]  #数组转置
B=B[:,np.newaxis]  #数组转置
print(A)
print(B)

#纵向合并
C1=np.concatenate((A,B),axis=0)
print(C1)

#横向合并
C2=np.concatenate((A,B),axis=1)
print(C2)

数组拆分

#构造矩阵
A=np.arange(12).reshape((3,4))
print(A)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

#沿横向轴拆分（axis=1）
np.hsplit(A,2)
#np.split(A,2,axis=1)

#沿纵向轴拆分（axis=0）
np.vsplit(A,3)
#np.split(A,3,axis=0)

[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]

#深度拆分
arr_dstack

np.dsplit(arr_dstack,2)

copy 和 =

#=号赋值的关联性
a=np.arange(4)
print(a)

[0 1 2 3]

b=a
c=a
d=b
print(b)
print(c)
print(d)

[0 1 2 3]
[0 1 2 3]
[0 1 2 3]

a[0]=11  #a中元素发生改变，b,c,d中的元素同样变化
print(a)
print(b)
print(c)
print(d)

[11 1 2 3]
[11 1 2 3]
[11 1 2 3]
[11 1 2 3]

d[1:3]=[12,13] #d中元素发生变化，a,b,c中的元素同样变化
print(a)
print(b)
print(c)
print(d)

[11 12 13 3]
[11 12 13 3]
[11 12 13 3]
[11 12 13 3]

#copy()赋值没有关联性
a=np.arange(4)
print(a)
b=a.copy()
print(b)

[0 1 2 3]
[0 1 2 3]

a[3]=44
print(a)
print(b)

[ 0 1 2 44]
[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广播后计算

[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]

#相当于将b重复多次
b=np.tile([0,1,2],(4,1)) #b行重复4次，列重复1次
print(a)
print(b)
print(a+b)

[[ 0 0 0]
[10 10 10]
[20 20 20]
[30 30 30]]
[[0 1 2]
[0 1 2]
[0 1 2]
[0 1 2]]
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]

数组的类型转换

#数组转换成list,使用tolist()
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]
#x中最大数为4，那么bin中统计的索引只能为0-4的5个数字，统计它们在x中出现的次数

[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))

[ 0.3 -0.6 0.5 1.3 1. ]

print(np.bincount(x,weights=w,minlength=7))  #bincount中元素为5个，当设置长度为7时，后边两位设为0

[ 0.3 -0.6 0.5 1.3 1. 0. 0. ]

#argmax
x=[[1,3,3],[7,5,2]]
print(np.argmax(x)) #返回最大元素中的位置
print(np.argmax(x,axis=0))  #按列操作返回最大元素的索引位置
print(np.argmax(x,axis=1))  #按行操作返回最大元素的索引位置，对于同为最大值，返回第一个的位置索引即可

3
[1 1 0]
[1 0]

求取精度

np.around([-0.6,1.2798,2.357,9.67,13],decimals=0)
np.around([1.2798,2.357,9.67,13],decimals=1)
np.around([1.2798,2.357,9.67,13],decimals=2)  #decimals指定保留几位小数

np.around([1,2,5,6,56],decimals=-1)  #-1表示看整数部分最后一位数决定是否进位，大于5进位，小于5省去
np.around([1,2,5,6,56],decimals=-2)  #-2表示看整数部分最后两位数决定是否进位，大于50进位，小于50省去

[ 0 0 0 10 60]
[ 0 0 0 0 100]

import numpy as np
print(np.around([-17.634,123.2798,255.357,950.67123,16],decimals=-1))
print(np.around([-17.634,123.2798,255.357,949.67123,16],decimals=-2))

[-20. 120. 260. 950. 20.]
[ -0. 100. 300. 900. 0.]

取整

#向下取整
np.floor([-0.6,-1.4,-0.1,-1.8,0,1.4,1.7])

array([-1., -2., -1., -2., 0., 1., 1.])

#向上取整
np.ceil([1.2,1.5,1.8,2.1,2.0,-0.5,-0.6,-0.3])

array([ 2., 2., 2., 3., 2., -0., -0., -0.])

#查找
x=np.array([[1,0],[2,-2],[-2,1]])
x

np.where(x>0,x,0)  #大于0的数不变，小于0的值用0填充