目录
Numpy是Python的一种开源的数值计算扩展库,它提供了两种基本的对象:
ndarray:是存储单一数据类型的多维数组。
ufunc:是一种能够对数组进行处理的函数。
Numpy常用的导入格式:
import numpy as np
1.Numpy数组
1.1创建数组
(1)array函数
data1=[1,3,5,7]
sz1=np.array(data1)
print(sz1)
#---------
[1 3 5 7]
(2)arange函数
w1=np.arange(10)
print(w1)
#---------------
[0 1 2 3 4 5 6 7 8 9]
(3)linspace函数
linspace函数通过指定起始值、终值、元素个数创建一维数组,默认包括终值。
w2=np.linspace(0,2,5)
print(w2)
#--------------------
[0. 0.5 1. 1.5 2. ]
(4)logspace函数
logspace函数的参数中,起始位和终止位代表的是10的幂。
w3=np.logspace(0,2,4)
print(w3)
#-------------------
[ 1. 4.64158883 21.5443469 100. ]
(5)zeros函数
zeros函数可以创建指定长度或形状的全0数组。
w4=np.zeros([3,3])
print(w4)
#------------------
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
(6)ones函数
ones函数可以创建指定长度或形状的全1数组。
w5=np.ones([2,3])
print(w5.astype(np.int32))
#-------------------------
[[1 1 1]
[1 1 1]]
(7)diag函数
diag函数可以创建对角矩阵,即对角线元素为0或指定值,其他元素为0。
w6=np.diag([1,2,3])
print(w6)
#--------------------
[[1 0 0]
[0 2 0]
[0 0 3]]
(8)eye函数
eye函数可创建一条对角线位置为1、其他位置全为0的矩阵。
w7=np.eye(3)
print(w7.astype(np.int32))
#-------------------------
[[1 0 0]
[0 1 0]
[0 0 1]]
(9)生成随机数
w8=np.random.randint(10,50,size=(2,4))
print(w8)
#-------------------------------------
[[15 29 37 13]
[18 48 49 33]]
2.数组变换
2.1数组重塑
可以通过reshape方法改变其数组维度,其中的一个参数可以设置为-1,表示数组的维度可以通过数据本身来推断。
ar1=np.arange(12)
print('ar1:',ar1)
ar2=ar1.reshape(3,-1)
print('ar2:',ar2)
#--------------------
ar1: [ 0 1 2 3 4 5 6 7 8 9 10 11]
ar2: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
数据散开(ravel)和数据扁平化(flatten)
ar3=ar2.ravel()
print('ar3:',ar3)
ar4=ar2.flatten()
print('ar4:',ar4)
#------------------
ar3: [ 0 1 2 3 4 5 6 7 8 9 10 11]
ar4: [ 0 1 2 3 4 5 6 7 8 9 10 11]
2.2数组合并
hstack:数组横向合并
vstack:数组纵向合并
concatenate函数可以实现数组的横向合并和纵向合并,当axis=1时进行横向合并,当axis=0时,进行纵向合并。
ar5=np.arange(6).reshape(3,2)
ar6=ar5*3
ar7=np.hstack((ar5,ar6))
print(ar7)
ar8=np.vstack((ar5,ar6))
print(ar8)
print('横向合并:\n',np.concatenate((ar5,ar6),axis=1))
print('纵向合并:\n',np.concatenate((ar5,ar6),axis=0))
#-----------------------------------------------------
[[ 0 1 0 3]
[ 2 3 6 9]
[ 4 5 12 15]]
[[ 0 1]
[ 2 3]
[ 4 5]
[ 0 3]
[ 6 9]
[12 15]]
横向合并:
[[ 0 1 0 3]
[ 2 3 6 9]
[ 4 5 12 15]]
纵向合并:
[[ 0 1]
[ 2 3]
[ 4 5]
[ 0 3]
[ 6 9]
[12 15]]
2.3数组分割
hsplit:实现数组的横向分割
vsplit:实现数组的纵向分割
split在参数axis=1时实现数组的横向分割,axis=0时实现数组的纵向分割
sz=np.arange(16).reshape(4,4)
print('横向分割:\n',np.hsplit(sz,2))
print('纵向分割:\n',np.vsplit(sz,4))
print('横向分割:\n',np.split(sz,1,axis=1))
print('纵向分割:\n',np.split(sz,2,axis=0))
#-----------------------------------------
横向分割:
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]),
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
纵向分割:
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
横向分割:
[array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
纵向分割:
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]),
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
3.数组的运算
3.1常用的ufunc函数运算
(1)四则运算:加(+)、减(-)、乘(*)、除(/)、幂(**)。数组间的四则运算是对每个数组中的元素分别进行四则运算,所以形状必须相同。
(2)比较运算:>,<,==,>=,<=,!=。比较运算返回的结果是一个布尔数组,每个元素为每个数组对应元素的比较结果。
(3)逻辑运算:np.any函数表示逻辑“or”,np.all函数表示逻辑“and”,运算结果返回布尔值。
(4)ufunc函数的广播机制
广播是指不同形状的数组之间执行算术运算的方式。
aa1=np.array([[1,1,1],[2,2,2],[3,3,3]])
bb1=np.array([1,2,3])
print('aa1+bb1:\n',aa1+bb1)
#---------------------------------------
aa1+bb1:
[[2 3 4]
[3 4 5]
[4 5 6]]
4.排序
numpy的排序方式有直接排序和间接排序,直接排序经常用sort函数,间接排序经常用argsort函数和lexsort函数。
直接排序:
sss=np.array([[3,6,8,2],[1,7,4,9],[6,4,8,3]])
sss.sort(axis=1)
print('横向排序:\n',sss)
sss.sort(axis=0)
print('纵向排序:\n',sss)
#-------------------------------------
横向排序:
[[2 3 6 8]
[1 4 7 9]
[3 4 6 8]]
纵向排序:
[[1 3 6 8]
[2 4 6 8]
[3 4 7 9]]
argsort函数间接排序:
arr=np.array([7,8,6,2,9,4,3,1,5,3])
print('原数组:\n',arr)
print('排序后:\n',arr.argsort())#返回值为数组排序后的下标序列
#----------------------------------------------------------
原数组:
[7 8 6 2 9 4 3 1 5 3]
排序后:
[7 3 6 9 5 8 2 0 1 4]
lexsort间接排序:
a=[1,5,7,4,3,0,2]
b=[9,5,2,0,6,8,7]
ind=np.lexsort((b,a))
print('数组a排序后的下标:\n',ind)
tmp=[(a[i],b[i])for i in ind]
print('数组a和b排序后的结果:\n',tmp)
#------------------------------------
数组a排序后的下标:
[5 0 6 4 3 1 2]
数组a和b排序后的结果:
[(0, 8), (1, 9), (2, 7), (3, 6), (4, 0), (5, 5), (7, 2)]
5.数据去重与重复
5.1数据去重
在numpy中,可以使用unique函数找到数组中的唯一值并返回已排序的结果,实现数据去重,当其中的参数return_counts设置为True时,即可返回每个取值出现的次数。
names=np.array(['a','b','b','a','c','b','c','a'])
print('原数组:',names)
print('去重后的数组:',np.unique(names))
print('字母出现次数:',np.unique(names,return_counts=True))
#-------------------------------------------------------
原数组: ['a' 'b' 'b' 'a' 'c' 'b' 'c' 'a']
去重后的数组: ['a' 'b' 'c']
字母出现次数: (array(['a', 'b', 'c'], dtype='<U1'), array([3, 3, 2], dtype=int64))
5.2数据重复
在numpy 中主要使用tile和repeat函数实现数据重复。
tile函数实现数据重复
sz=np.arange(3)
print('原数组:',sz)
sz1=np.tile(sz,3)
print('重复后的数组:',sz1)
#--------------------------
原数组: [0 1 2]
重复后的数组: [0 1 2 0 1 2 0 1 2]
repeat函数实现数据重复:axis=0表示按行进行元素重复,axis=1表示按列进行元素重复。
arr=np.diag([1,2,3])
print('原数组:\n',arr)
arr1=np.repeat(arr,2,axis=0)
print('按行重复:\n',arr1)
arr2=np.repeat(arr,2,axis=1)
print('按列重复:\n',arr2)
#---------------------------
原数组:
[[1 0 0]
[0 2 0]
[0 0 3]]
按行重复:
[[1 0 0]
[1 0 0]
[0 2 0]
[0 2 0]
[0 0 3]
[0 0 3]]
按列重复:
[[1 1 0 0 0 0]
[0 0 2 2 0 0]
[0 0 0 0 3 3]]
6.读写数组
6.1读写二进制文件
numpy中读/写二进制文件的方法有以下两种:
(1)numpy.load("文件名.npy"):从二进制的文件中读取数据。
(2)numpy.save("文件名[.npy]",arr):以二进制的格式保存数据。
a=np.arange(12).reshape(3,-1)
print('a:',a)
np.save('arr.npy',a)
b=np.load('arr.npy')
print('b:',b)
#------------------------
a: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
6.2读/写文本文件
numpy中读写文本文件的方法主要有以下三种:
(1)numpy.loadtxt("arr.txt",delimiter=","):把文件加载到一个二维数组中。
(2)numpy.savetxt("arr.txt",arr,fmt="%d",delimiter=","):将数组写到某种分隔符隔开的文本文件中。
(3)numpy.genfromtxt("arr.txt",delimiter=","):结构化数组和缺失数据。
a=np.arange(12).reshape(4,-1)
np.savetxt("szout.txt",a,fmt="%d",delimiter=",")
np.loadtxt("szout.txt",delimiter=",")
#------------------------------------------
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.]])
码字不易,大家的阅读就是我创作的动力^_^ ^_^