numpy基础学习笔记

numpy默认要求矩阵里面都是相同类型：

array = ([1,2,3,4,'5'])
print(array) 
# array(['1','2','3','4','5'],dtype = ' 
常用：
 
array.itemsize() # 查看每个元素占了多少个字节
array.size() # 查看里面有多少个元素
array.ndim() # 查看有多少个维度
array.fill(n) # 用n填充矩阵

array = ([1,2,3,4,5])
array2 = array
array2[1] = 10
print(array2) # ([1,10,3,4,5])
print(array) # ([1,10,3,4,5])
 
array2 = array并不是创建一个新的地址存储array2，只是让array2指向和array相同的地址，因此修改array2的值，也会修改array的值，此时的解决办法为：array2 = array.copy()
 
np.random.rand(n)会随机返回n个0-1之间的值，可以根据随机数组random_array返回一个bool类型的矩阵
 
random_array = np.random.rand(5) 
# array([0.56372953,0.13857392,0.48362758,0.84739275,0.937582716])
mask = random_array > 0.5 
# array([True,False,False,True,True],dtype = bool)
 
使用np.where()来找到想要的值的索引，可以利用该索引来提取想要的值
 
np.where(array > 3) # array([3,4],dtype = int64)
array[np.where(array >30)] # array([4,5])
 
常用：
 
array = ([1,2,3,4,5],dtype = np.float32)
print(array.nbytes()) # 20
# 返回的总共占多少字节 一个float32占4个字节，5个元素一共占20个字节

array = ([1,2,3.5,'str'])
print(array) # array(['1','2','3.5','str']) 会全部返回字符串类型
array = ([1,2,3.5,'str'],dtype = object)
print(array) # array([1,2,3.5,'str']) # object会保持元素原有类型
 
重新定义矩阵类型：
 
array = ([1,2,3,4,5])
array2 = np.asarray(array,dtype = np.float32)
print(array2) # array([1.,2.,3.,4.,5.],dtype = float32)
print(array) # array([1,2,3,4,5],dtype = float32)
# 重新定义array类型，并存到一个新的内存array2中，即不会修改原有array的类型
# astype()也可以做到
array.astype(dtype = np.float32)
 
numpy的数值计算 
array.clip(2,4) # ([2,2,3,4,4,4])
#clip(n,m)函数，将小于n的值全部改为n，将大于m的值全部改为m
array = ([1.2,3.4,5.67])
array.round() # [1,3,6] 四舍五入
array.round(decimal = 1) #[1.2,3.4,5.7] 参数decimal决定保留几位小数

array = ([[1,2,3],[4,5,6]])
np.sum(array) # 21
# 或者可以写array.sum()
np.sum(array,axis = 0) # ([5,7,9])
# array(sum,axis = 0)
np.sum(array,axis = 1) # ([6,15])
 
可以利用axis 指定轴进行计算，对于多维的矩阵，想指定最后一个轴时，可用axis = -1，除了加法运算，还有一下运算，均可以使用轴来进行运算：
 
乘法prod()最小值min()最大值max()找到最小值的索引argmin()找到最大值的索引argmax()均值mean()标准差std()方差var() 
numpy排序 
array = ([[1.5,1.3,7.5],[5.6,7.8,1.2]])
np.sort(array) # ([[1.3,1.5,7.5],[5.6,[7.8],[7.5]])
np.sort(array,axis = 0) # ([[1.5,1.3,1.2],[5.6,7.8,7.5]]) 按轴排序
 
排序索引
 
np.argsort(array) # ([[1,0,2],[2,0,1]])

array = np.linspace(0,10,10)
 # ([0.,1.11111111,2.22222222,3.33333333,4.44444444,5.55555556,6.66666667,7.77777778,8.88888889,10.])
values = np.array([2.5,6.5,9.5])
np.searchsorted(array,values)
# [3,6,9] 按大小顺序返回插入的位置
 
多条件排序
 
array = np.array([[1,0,6],[1.7.6],[2.3.1],[2.4.0]])
index = np.lexsort([-1*array[:,0],array[:,2]]) 
# 在第三列降序的情况下，第一列升序 返回[0,1,3,2]
array[index] = index
# ([[2,4,0],[1,7,0],[2,3,1],[1,0,6]])
 
数组形状操作 
array = np.arange(10) # ([0,1,2,3,4,5,6,7,8,9])
print(array,shape) # (10,)
array.shape = 2,5 # ([[0,1,2,3,4],[5,6,7,8,9]])
array.reshape(1,10) #  ([[0,1,2,3,4,5,6,7,8,9]])
 
新增一个维度newaxis
 
array = np.arange(10) # ([0,1,2,3,4,5,6,7,8,9])
print(array.shape) # (10,)
array = array[:,np.newaxis] # ([[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]])
print(array.shape) # (10,1)
array = array[:,np.newaxis,np.newaxis]
print(array.shape) # (10,1,1,1)
 
压缩squeeze()
 
array = array.squeeze() #去掉空轴
print(array.shape) # (10,)
 
转置transpose()或T
 
array.shape = 2,5
array.transpose() #([[0,5],[1,6],[2,7],[3,8],[4,9]])
# 或者array.T ，但此时array的值不会改变，所以要使用转置，必须重新赋值
 
数组的连接concatenate()
 
a = np.array([[12,34,23],[32,43,45]])
b = np.array([[35,37,68],[56,58,34]])
c = np.concatenate((a,b)) 
# 注意两个括号，第一个括号传参数，第二个括号代表元组
# ([[12,34,23],[32,43,45],[35,37,68],[56,58,34]])
c = np.concatenate((a,b),axis = 1)
#([[12,34,23,35,37,68],[32,43,45,56,58,34]])

np.vstack((a,b))# ([[12,34,23],[32,43,45],[35,37,68],[56,58,34]])
np.hstack((a,b))#([[12,34,23,35,37,68],[32,43,45,56,58,34]])
 
拉平flatten()或ravel()
 
a.flatten() #([12,34,23,32,43,45]) 
a.ravel() #([12,34,23,32,43,45]) 
 
数组生成 
arange() 左闭右开
 
np.arange(10)
np.arange(2,20,2)
 
linspace()左开左闭
 
np.linspace(0,10,50) # 在0-10中随机50个数
 
logspace() 默认以10为底
 
np.logspace(0,1,5)
 
生成x,y的网格meshgrid()
 
x = linspace(-10,10,5) # ([-10,-5,0,5,10])
y = linspace(-10,10,5) # ([-10,-5,0,5,10])
x, y = meshgrid(x,y)
print(x) #([[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10]])
print(y) #([[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10],[-10,-5,0,5,10]])
 
构造行向量、列向量
 
np.r_[0:10:1] # 行向量([0,1,2,3,4,5,6,7,8,9])
np.c_[0:10:1] # 列向量([[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]])
 
更常用的zeros()、ones()、empty()
 
np.zeros(3) # ([0.,0.,0.])
np.zeros((3,3)) # ([[0.,0.,0.],[0.,0.,0.],[0.,0.,0.]])
np.ones((3,3)) # ([[1.,1.,1.],[1.,1.,1.],[1.,1.,1.]])
a = np.empty(5) # 随机
a.fill(1) #([1.,1.,1.,1.,1.])

a = np.array([1,2,3,4])
b = np.zeros_like(a) # ([0,0,0,0]) 只复制shape

np.identity(3) #构造单位函数 ([1,0,0],[0,1,0],[0,0,1])
 
运算 
运算必须保证维度相同
 
x = np.array([5,5])
y = np.array([2,2])
np.multiply(x,y) #([10,10]) 对应位置进行相乘
np.dot(x,y) # 20 = 2*5+2*5 内积

x.shape = 2,1
y.shape = 1,2
np.dot(x,y) #([[10,10],[10,10]])
np.dot(y,x) #([[20]])
 
逻辑运算
 
x = np,array([1,1,1,4]) 
y = np,array([1,1,1])
x == y # 维度不一样报错

y = np,array([1,1,1,2])
x == y #([True,True,Ture,False])
np.logical_and(x,y) #([True,True,Ture,True]) 返回逻辑and
np.logical_or(x,y) #([True,True,Ture,True]) 返回逻辑or
np.logical_not(x,y) #([0,0,0,0]) 返回逻辑not
 
随机模块 
np.random.rand(3,2) #构造从0-1的shape为3,2的矩阵
np.random.randint(10,size=(5,4)) #构造5，4的0-10的随机矩阵 左闭右开
np.random.random_sample()
np.random.randint(0,10,3) # 在0-10中随机选择3个数
mu, sigma = 0,0.1
np.random.normal(mu,sigma,10) # 高斯分布随机10个数
np.set_printoptions(precision = 3) # 设置浮点的精度，即输出3为小数
 
洗牌shuffle()
 
array = np.arange(10)
np.random.shuffle(array) # 打乱array的顺序
 
随机种子seed()
 
np.random.seed(0)
mu, sigma = 0,0.1
np.random.normal(mu,sigma,10) 
# 指定随机的种子后，无论执行多少次np.random.normal(mu,sigma,10) 值都不会变，只有当修改seed里面的参数时，才会改变
 
文件读写 
#首先写个文件
%%writefile tang.txt
1 2 3 4 5 6
2 3 5 8 7 9

data = []
with open('tang.txt') as f:
	for line in f.readlines():
		fileds = line.split()
		cur_data = [float(x) for x in fileds]
		data.append(cur_data)
data = np.array(data) #([[1.,2.,3.,4.,5.,6.],[2.,3.,5.,8.,7.,9.]])

data = np.loadtxt('tang.txt') #([[1.,2.,3.,4.,5.,6.],[2.,3.,5.,8.,7.,9.]]) 若数据比较规整，可以直接使用loadtxt

%%writefile tang2.txt
1,2,3,4,5,6
2,3,5,8,7,9
data = np.loadtxt('tang2.txt') #报错，无法转为浮点型，需要指定分隔符
data = np.loadtxt('tang2.txt',delimiter = ',') #默认为空格

%%writefile tang2.txt
	x,y,z,w,d,s
	1,2,3,4,5,6
	2,3,5,8,7,9
data = np.loadtxt('tang2.txt',delimiter = ',',skiprows = 1) #skiprows去掉第一行
 
 
 
skiprows:去掉几行
 delimiter = ‘,’ :以,为分隔符
 usecols = (0,1,4) :指定使用哪几列
 
 
array = np.array([[1,2,3],[4,5,6]])
np.savetxt 'tang4.txt',array.fmt = '%d',delimiter = ','#fmt为指定数据类型fmt = '%.2f'
 
读写array结构
 
array = np.array([[1,2,3],[4,5,6]])
np.save('tang5.npy',array)

tang = np.load('tang5.npy')
print(tang) # ([[1,2,3],[4,5,6]])

#保存多个array,会保存成一个压缩文件npz,里面有多个npy
array1 = np.arange(10)
np.savez('tang.npz',a = array,b = array1)
data = np.load('tang.npz')
data.keys() # ['b','a']
data['a'] #([[1,2,3],[4,5,6]])
 
练习题 
1、打印当前numpy版本
 
print(np.__version__)
 
2、打印3，3零矩阵，并输出其占用的内存
 
arr2 = np.zeros((3,3))
print(arr2,arr2.nbytes)
print('%d bytes'% (arr2.size * arr2.itemsize))
 
3、np的帮助文档
 
print(help(np.info(np.add)))
 
4、返回数组10-49，且为降序
 
arr4 = np.arange(10,50,1)
arr4 = arr4[::-1]
print(arr4)
 
5、找到一个数组中不为0的索引
 
arr5 = np.nonzero([1,34,654,8,0,467,0,579,0,50,0,0])
print(arr5)
 
6、3*3矩阵 打印最大值、最小值
 
arr6 = np.array([[235,3674,345,457],[34,57,3,647]])
print(arr6)
print(arr6.max(),arr6.min())
 
7、5,5矩阵，外圈加一圈0,pad()函数
 
arr7 = np.ones((5,5))
arr7 = np.pad(arr7,pad_width = 1,mode = 'constant',constant_values = 0)
print(arr7)
 
8、shape=6,7,8的矩阵，返回第100个元素的索引
 
print(np.unravel_index(100,(6,7,8)))
 
9、5,5矩阵归一化
 
arr8 = np.random.random((5,5))
arr8 = (arr8-arr8.min())/(arr8.max()-arr8.min()) #归一化
print(arr8)
 
10、找到两个数组中相同的值
 
arr9 = np.random.randint(0,10,10)
arr10 = np.random.randint(0,10,10)
print(arr9)
print(arr10)
print(np.intersect1d(arr10,arr9))
 
11、得到昨天、今天、明天
 
yesterday = np.datetime64('today','D') - np.timedelta64(1,'D')
today = np.datetime64('today','D')
tommorow = np.datetime64('today','D') + np.timedelta64(1,'D')
print(yesterday,today,tommorow)
 
12、得到一个月所有的天
 
arr11 = np.arange('2022-03','2022-04',dtype = 'datetime64[D]')
print(arr11)
 
13、得到一个数的整数部分
 
arr12 = np.random.uniform(0,10,10)# 0-10选10个数
print(arr12)
arr12 = np.floor(arr12)# round()四舍五入，floor()向下取整
print(arr12)
 
14、构造一个不能背改变的数组
 
arr13 = np.zeros(5)
arr13.flags.writeable = False
 
15、打印一个很大的数据的部分值，全部值
 
np.set_printoptions(threshold=np.nan)# 打印全部
arr14 = np.zeros((15,15))
print(arr14)
np.set_printoptions(threshold=5)# 只打印5行
arr14 = np.zeros((15,15))
print(arr14)
 
16、在数组中，找到最接近数的索引
 
arr15 = np.arange(100)
v = np.random.uniform(0,100)
print(v)
index = (np.abs(arr15-v)).argmin()
print(index)
'''
93.2285873444004
93
'''
 
17、float32和int32的转换
 
arr16 = np.arange(10,dtype = np.int32)
arr16 = arr16.astype(np.float32)
print(arr16.dtype)
 
18、打印数组元素位置坐标与数值
 
arr17 = np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(arr17):
    print(index,value)
'''
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 3
(1, 1) 4
(1, 2) 5
(2, 0) 6
(2, 1) 7
(2, 2) 8
'''
 
19、按某一列排序
 
arr18 = np.random.randint(0,10,(3,3))
print(arr18)
print(arr18[arr18[:,1].argsort()])
'''
[[6 7 7]
 [6 8 5]
 [6 4 0]]
[[6 4 0]
 [6 7 7]
 [6 8 5]]
'''
 
20、统计有多少个重复值
 
arr19 = np.random.randint(1,10,10)
print(arr19)
print(np.bincount(arr19)) # 统计arr19里分别有多少个，从0-最大值
# [9 8 3 3 9 4 3 7 7 3]
# [0 0 0 4 1 0 0 2 1 2]
 
21、四维矩阵，以最后两维求和
 
arr20 = np.random.randint(0,20,(4,4,4,4))
print(arr20.sum(axis = (-2,-1)))
 
22、矩阵交换两行顺序
 
a	rr21 = np.arange(25).reshape(5,5)
arr21[[0,1]] = arr21[[1,0]]
 
23、数组中最常出现的数
 
arr22 = np.random.randint(0,10,20)
print(np.bincount(arr22).argmax())
 
24、快速查找TOP K
 
arr23 = np.arange(10000)
np.random.shuffle(arr23)
n = 5
print(arr23[np.argpartition(-arr23,n)[:n]])
# [9999 9998 9996 9997 9995]
 
25、去掉一个数组中，所有元素都相同的数据
 
arr24 = np.random.randint(0,3,(10,3))
print(arr24)
e = np.all(arr24[:,1:] == arr24[:,:-1],axis = 1)# 还有一个any
# all限制所有元素相同，any只要有元素相同
print(e)