numpy基础学习笔记

numpy基础

array数组

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

array = ([1,2,3,4,'5'])
print(array) 
# array(['1','2','3','4','5'],dtype = '<U11')

常用：

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)