import numpy as np
1.查看numpy的版本
np.__version__
2.list, array 与np.array的区别
(1)L = [i for i in range(10)] (list 中的每个元素类型是任意的,可以不相同)
(2)import array
arr = array.array('i', [i for i in range(10)]) (第一个参数‘i’表示本数组的数据类型为整型,也就是说arr中的数据全部为整型)
执行 arr[3] = 3.14
报错:TypeError: integer argument expected, got float
(3)import numpy as np
nparr = np.array([i for i in range(10)])
nparr.dtype
out: dtype('int64') (即 其默认类型为‘int64’)
nparr[3] = 3.14 nparr[3]
out: 3 (由于 nparr.dtype 为 'int64’,则其会将3.14自动的转化为‘int64’)
nparr2 = np.array([1,2,3.0]) nparr2.dtype
out: dtype('float64') (np.array 的数据类型的设定会根据自身数据去设定,且可以自动进行数据类型的转换,故使用起来比较方便)
3.创建 np.array
(1)np.zeros(shape= ,detype = )
np.ones(shape= ,detype = )
np.full(shape = , full_value = ) (同理,数据的类型根据full_value的类型来确定)
注意,size 可以是一维的,也可以是二维等多维的。eg:size=10,size = (3,5)
shape 同size 一样
(2)np.arange 与 arange 的不同
L = [i for i in range(10,20,2)] (前闭后开,最后一个参数为步长,默认步长为1,注意,在这里,步长不能为小数)
np.arange(10,20,2) (前闭后开)
np.arange(10,20,0.5) (此时步长可以为小数)
(3) np.linspace
np.linspace(0,20,10) (前闭后闭,等间隔的生成10个数)
(4)随机数的生成
np.random.randint(0,10,size = ) (前闭后开,随机生成整数(在0-10之间))
np.random.seed(10) (让随机种子不变(即参数不变),则每次生成的随机数就是一样的了,为方便调试程序)
np.random.uniform(low=0.0, high=1.0, size=10) (生成0-1之间均匀分布的数)
np.random.uniform(0, 1, size=10) (生成正态分布的随机数,均值为0,方差为1)
4.numpy的一维和二维数组(y表示1维,Y表示2维)
import numpy as np
y = np.arange(1,10)Y = np.arange(15).reshape(3,5)
y
```
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Y
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],[10, 11, 12, 13, 14]])
#数据维度,形状和大小的查看
```y.ndim```
1
y.shape```
(9,)
y.size
```9
Y.ndim
```2
Y.shape
```(3, 5)
Y.size
```15
#numpy中array 数据的访问
```y[0]#访问y中的第一个元素```
1
y[-1]#访问y中的最后一个元素
```9
y[0:5]#切片
```array([1, 2, 3, 4, 5])
y[:5]
```array([1, 2, 3, 4, 5])
y[5:]
```array([6, 7, 8, 9])
y[::2]#以2为步长,访问y中的元素
```array([1, 3, 5, 7, 9])
y[::-1]#到序访问y中的元素
```array([9, 8, 7, 6, 5, 4, 3, 2, 1])
Y[0,0]#访问Y第一行第一列的元素
```0
Y[-1,-1]#访问Y中最后一行最后一列的元素
```14
Y[:2,:3]#访问Y中前两行前三列的元素
```array([[0, 1, 2],
[5, 6, 7]])
Y[:2,::2]#访问Y中前两行,以2为步长访问列元素
```array([[0, 2, 4],
[5, 7, 9]])
Y[::-1,::-1]#倒序访问行,倒序访问列
```array([[14, 13, 12, 11, 10],
[ 9, 8, 7, 6, 5],
[ 4, 3, 2, 1, 0]])Y[0]#访问Y的第1行
```
array([0, 1, 2, 3, 4])Y[0,:]#访问Y的第1行== Y[0]
```
array([0, 1, 2, 3, 4])
Y[:,0]# 访问Y的第一列
```array([ 0, 5, 10])#创建数据的子集
```subY = Y[:2,:3]#注意,此时subY和Y是连体的
```subY[0,0]=100
```subY
```
array([[100, 1, 2],
[ 5, 6, 7]])
Y
```array([[100, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]])
Y[0,0]=66
```Y```
array([[66, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
subY
```array([[66, 1, 2],
[ 5, 6, 7]])
sub1Y = Y[:2,:3].copy() #此时sub1Y与Y解除连体
```sub1Y[0,0]=101```sub1Y
```
array([[101, 1, 2],
[ 5, 6, 7]])
Y
```array([[66, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
Y[0,0] = 0
```Y```
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
sub1Y
```array([[101, 1, 2],
[ 5, 6, 7]])
#reshape
```y.reshape(3,3) #只是将y输出为shape=(3,3)的形式,而y本身的shape没变```
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])y
```
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
A = y.reshape(3,3)
```A```
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
B= y.reshape(1,9)#y为1维的数组,可向上查看y.ndim,y.shape,而B为2维的
```B```
array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
B.ndim
```2
B.shape
```(1, 9)
y.reshape(3,-1)#保证y输出形状为3行
```array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
y.reshape(-1,3)#保证y输出的列数为3
```array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
5.np.array 的 concatenate 和 split
x=np.array([1,2,3])
y=np.array([3,2,1])
x
array([1, 2, 3])
y
array([3, 2, 1])
A = np.concatenate([x,y]) #将x,横向链接,注意:concatenate的参数必须为列表
Aarray([1, 2, 3, 3, 2, 1])
z =np.array([4,5,6])
np.concatenate([x,y,z])
array([1, 2, 3, 3, 2, 1, 4, 5, 6])
Y=np.array([[1,2,3],
[4,5,6]])
Y
array([[1, 2, 3],
[4, 5, 6]])
B = np.concatenate([Y,Y]) #注意,传入的参数必须是列表
B
array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
np.concatenate([Y,Y],axis = 1)
array([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6]])
np.concatenate([Y,z])#由于Y.dnim 为2,z.dnim 为1,故不能直接拼接
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-69-a85dfdafd37d> in <module>()
----> 1 np.concatenate([Y,z])#由于Y.dnim 为2,z.dnim 为1,故不能直接拼接
ValueError: all the input arrays must have same number of dimensions
np.concatenate([Y,z.reshape(1,-1)])
array([[1, 2, 3],[4, 5, 6],
[4, 5, 6]])
np.vstack([Y,z]) #此时 Y与z就可以直接拼接 = np.concatenate([Y,z.reshape(1,-1)])
array([[1, 2, 3],
[4, 5, 6],
[4, 5, 6]])
Y1 = np.array([[1,2],
[3,4]])
np.hstack([Y,Y1]) #== np.concatenate([Y,Y1],axis = 1)
array([[1, 2, 3, 1, 2],
[4, 5, 6, 3, 4]])
#数组的拆分 np.split
s = np.arange(1,10)
s
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
np.split(s,[3,7])#将s以3,7为分界点分成三段(两个数可以将其分成3段)
[array([1, 2, 3]), array([4, 5, 6, 7]), array([8, 9])]
np.split(s,[5])#将s以5为分界点分成两段(一个数可以将其分成两段)
[array([1, 2, 3, 4, 5]), array([6, 7, 8, 9])]
E = np.arange(16).reshape(4,4)
E
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
E1,E2 = np.split(E,[2]
E1
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
E2
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
E11,E21 = np.split(E,[3],axis=1)
E11
array([[ 0, 1, 2],
[ 4, 5, 6],
[ 8, 9, 10],
[12, 13, 14]])
E21
array([[ 3],
[ 7],
[11],
[15]])
Ev1,Ev2 = np.vsplit(E,[2])
Ev1
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
Ev2
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Eh1,Eh2 = np.hsplit(E,[3])#按列分
Eh1
array([[ 0, 1, 2],
[ 4, 5, 6],
[ 8, 9, 10],
[12, 13, 14]])
Eh2
array([[ 3],
[ 7],
[11],
[15]])
Eh11,Eh21 = np.hsplit(E,[-1])# 取出最后一列放在Eh21中,前边的全部放入Eh1中
Eh11
array([[ 0, 1, 2],
[ 4, 5, 6],
[ 8, 9, 10],
[12, 13, 14]])
Eh21
array([[ 3],
[ 7],
[11],
[15]])
h = Eh21[:,0]#将Eh2 变为1维度的行向量
h
array([ 3, 7, 11, 15])
6.numpy 中的矩阵运算
6.1
#要实现
#a=(0,1,2)
#a*2 = (0,2,4)
(1)#list的实现方法
n = 10
L = [i for i in range(n)]
2*L #这样执行的结果是 重复2遍L中的元素
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#将L中的每个元素乘以2 方法一
A = []
for i in L:
A.append(2*i)
A
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#将L中的每个元素乘以2 方法二
A = [i*2 for i in L]
A
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#假设n=100000,看一下两种方法的运行时间
n = 100000
L = [i for i in range(n)]
%%timeitA = []
for i in L:
A.append(2*i)
20.3 ms ± 315 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit A = [i*2 for i in L]
9.18 ms ± 9.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
#显然,列表生成式比for循环更快
(2)#下边,我们再看一下np.arrayimport numpy as np
n = 10
Ln = np.arange(n)
Ln
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Ln*2 #在np 的array 表示的是将Ln中的元素都乘以2
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
np.array([2*i for i in Ln]) # =Ln*2
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
#让n等于100000,看一下其执行速度
n = 100000
Ln = np.arange(n)
%timeit Ln*2 #这种执行方式最快
365 µs ± 17.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit np.array([2*i for i in Ln])
48.9 ms ± 398 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
6.2#universal Functions #对矩阵中的每个元素做运算
X = np.arange(1,16).reshape(3,5)
X+1 #将X矩阵的每个元素都加1
X-1
X*2
X/2
X//2
X**2
X%2
np.abs(X)
np.sin(X)
np.cos(X)
np.tan(X)
np.exp(X)
np.power(X,3)# = X**3
np.power(3,X)# =3**X
np.log(X)#默认的是以e为底
np.log2(X)#以2为底,X的对数
6.3#两个矩阵之间的运算(在这里举的例子矩阵 ndim 都为 2)
A = np.arange(4).reshape(2,-1)
A
array([[0, 1],
[2, 3]])
B = np.full((2,2),10)
B
array([[10, 10],
[10, 10]])
(1)#z矩阵之间对应的元素相 +,-,*,/
A+B
A-B
A*B
A/B
(2)#矩阵以及矩阵间的运算
A.dot(B)#矩阵相乘
A.T#矩阵A的转置
invA = np.linalg.inv(A)#矩阵A的逆,此时矩阵A必须为方针
invA.dot(A)
array([[1., 0.],
[0., 1.]])
A.dot(invA)
array([[1., 0.],
[0., 1.]])
#当矩阵不是方阵时,可以求其伪逆
S = np.arange(6).reshape(2,-1)
pinvS = np.linalg.pinv(S)
S.dot(pinvS) # 由于S不是方阵,这个满足对角线的元素的值为1,pinvS.dot(S) 不满足
array([[ 1.00000000e+00, -1.38777878e-16],
[ 3.10862447e-15, 1.00000000e+00]])
6.4#向量和矩阵的运算
v = np.array([2,2,2])
M = np.array([[1,2,3],
[5,6,7]])
v+M #将向量加到矩阵的每一行
#注意,若v也是二维的矩阵,即v.shape为(1,3)(此时v.shape为(3,)),则不能直接相加,维度不一致
array([[3, 4, 5],
[7, 8, 9]])
np.vstack([v]*M.shape[0])+M # = v+Marray([[3, 4, 5],
[7, 8, 9]])
np.tile(v,(2,1))#指将横向堆叠两次,列向堆叠1次
array([[2, 2, 2],
[2, 2, 2]])
np.tile(v,(2,1))+M # v+M
array([[3, 4, 5],
[7, 8, 9]])
v*M # = M*v 对应的元素相乘
array([[ 2, 4, 6],
[10, 12, 14]])
M.dot(v) # 根据需要,自动的将v转换成列向量
array([12, 36])
v.dot(M) #不管是转换为行向量,还是转换为列向量,均不能满足要求,报错
7.numpy中的统计功能
import numpy as np
7.1#对向量
L = np.random.random(10) #在半开间隔[0.0,1.0)中返回随机浮点数。L = np.random.randn(1000000) #从“标准正态”分布中返回一个抽样(或多个)。
sum(L)
min(L)
max(L)
np.sum(L) #一般np运算速度更快np.min(L)
np.max(L)
np.median(L)
np.percentile(L,q=50) #L中 位于50%的数 =np.median(L) 中位数
np.percentile(L,q=100) # L中我位于100%的数 = np.max(L)
np.mean(L) #均值
np.var(L) #方差
np.std(L) #标准差
7.2#矩阵
X = np.arange(16).reshape(4,-1)X
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
np.sum(X)
120
np.sum(X,axis = 0) #沿着行的方向进行运算,即对行进行压缩,压缩到1行
array([24, 28, 32, 36])
np.sum(X, axis = 1) #沿着列的方向进行运算,即对列进行压缩,压缩到1列
array([ 6, 22, 38, 54])
np.prod(X)# 对X中所有的元素相乘,由于其第一个元素为0,所以乘积为0
0
np.prod(X+1) #将矩阵X中的每个元素+1,然后相乘
20922789888000
np.mean(X)# X所有元素的均值
np.mean(X,axis = 0) #沿着行的方向进行运算,即每次运算,每行都可以遍历到np.mean(X,axis = 1) #沿着列的方向进行运算,即每次运算,每列都可以遍历到
np.median(X)#X中所有元素的中位数
np.median(X,axis=0)
np.median(X,axis = 1)
np.percentile(X,q=50) # = np.median(X)
np.percentile(X,q=50,axis = 0)
np.percentile(X,q=50,axis = 1)
np.var(X)#标准差
np.var(X,axis = 0)
np.var(X,axis = 1)
np.std(X)#方差
np.std(X,axis = 0)
np.std(X, axis = 1)
8.# numpy中的索引arg
import numpy as np
8.1#对于向量x = np.arange(10)
np.random.shuffle(x) # 将x中的顺序打乱
array([0, 2, 4, 3, 9, 7, 5, 6, 8, 1])
np.argmin(x) # x中最小值的索引
np.argmax(x) # x中最大值的索引
np.sort(x) # 输出排好序array,但x中的顺序是不变的
x.sort() # 此时x中的顺序改变
np.random.shuffle(x)
x
array([8, 6, 9, 2, 0, 7, 1, 5, 4, 3])
np.argsort(x) # 输出排好序的array 的在x中的索引值
np.partition(x,3)#类似与快排中的将<3的数放在3的左边,将>3的数放在3额右边
array([2, 0, 1, 3, 6, 7, 9, 5, 4, 8])
np.argpartition(x,3)#输出对应的索引
8.2#对于矩阵Y = np.random.randint(10,size=(4,4)) #randint(low[, high, size, dtype]) 返回从low(包括)到high(不包括)的随机整数。
Y
array([[4, 7, 8, 6],
[1, 6, 7, 6],
[3, 4, 1, 1],
[2, 2, 3, 8]])
np.sort(Y) #默认axis= 1
array([[4, 6, 7, 8],
[1, 6, 6, 7],
[1, 1, 3, 4],
[2, 2, 3, 8]])
np.sort(Y,axis=0)
array([[1, 2, 1, 1],
[2, 4, 3, 6],
[3, 6, 7, 6],
[4, 7, 8, 8]])
np.argsort(Y) # 输出排序索引
np.argsort(Y,axis = 0)
array([[0, 3, 1, 2],
[0, 1, 3, 2],
[2, 3, 0, 1],
[0, 1, 2, 3]])
Y
array([[4, 7, 8, 6],
[1, 6, 7, 6],
[3, 4, 1, 1],
[2, 2, 3, 8]])
np.partition(Y,3) #默认axis=1
np.partition(Y,3,axis=0)
array([[1, 4, 1, 1],
[2, 2, 3, 6],
[3, 6, 7, 6],
[4, 7, 8, 8]])
#求相应元素的索引
np.argpartition(Y,3) #默认axis=1
np.argpartition(Y,3,axis=0)
#这里边出现了一个bug,现在还没搞明白
b = np.array([7,6,4,2])
np.partition(b,3)
array([4, 2, 6, 7])
b = np.array([7,6,4,2,1])
np.partition(b,3)
array([2, 1, 4, 6, 7])
9.#Fancy Indexing
import numpy as np
1.(1)#对于向量
x = np.arange(16)x[3] #取x的第4个元素
x[3:9]#切片操作
x[3:9:2]#以2为步长的切片操作
#若要想访问第3,5,9个元素怎么办,这些元素不能用切片设置确定的步长来获得
ind = [2,4,8]
x[ind]
#ind 也可以为二维的ind = np.array([[1,3],
[6,9]])
x[ind]
array([[1, 3],
[6, 9]])
(2)#对于矩阵
Y = x.reshape(4,-1)Y
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
#取出下标为 (0,1)(1,2)(2,3)的元素
row = np.array([0,1,2])
col = np.array([1,2,3])
Y[row,col]
#取出第0行,下标为col的元素
Y[0,col]
#取出0,1行,下标为col的元素
Y[:2,col]
#下标用bool值来表示,取出0,1行,0,2,3列的数据
col = [True,False,True,True]
Y[:2,col]
array([[0, 2, 3],
[4, 6, 7]])
2.#numpy.array 中的比较
(1)#向量
xarray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
x<3 #注意输出的是bool值
x>3
x<=3
x>=3
x==3
#同样,也可以写成表达式的形式
2*x == 24-4*x
#将符合条件的数值打印出来
x[x<3]
x[x%2==0]
x[2*x == 24-4*x]
np.sum(x<=3)#输出x中 <=3 的个数
#还可以加入逻辑运算,与,或,非
np.sum((x>3)&(x<10)) #与
np.sum((x%2==0)|(x>10)) #或
np.sum(~(x%2==0)) #非
np.count_nonzero(x<=3) # = np.sum(x<=3),注:True=1,False=0
np.count_nonzero((x%2==0)|(x>10))
np.any(x==0) # x中 有一个数为0,即返回True
np.all(x==0) #x 中所有的数都为0,才返回True,否则返回False
(2)#矩阵
Yarray([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Y<6 #同理 输出的也是bool值Y>6
Y<=6
Y>=6
Y==3
#同样,也可以写成表达式的形式
2*Y == 24-4*Y
#将符合条件的数值打印出来
Y[Y<6]Y[Y%2==0]
Y[2*Y == 24-4*Y]
Y[Y[:,3]%3==0,:]
np.sum(Y<=6)#输出Y中 <=6 的个数
np.sum(Y<=6,axis=0)
np.sum(Y<=6,axis=1)
#还可以加入逻辑运算与,或,非,也可以分 axis=0,axis=1
np.sum((Y>3)&(Y<10)) #与
np.sum((Y%2==0)|(Y>10)) #或
np.sum(~(Y%2==0)) #非
np.count_nonzero(Y<=6) # = np.sum(Y<=6),注:True=1,False=0
np.count_nonzero(Y<=6,axis=0)
np.count_nonzero(Y<=6,axis=1)
np.any(Y==0) # Y中 有一个数为0,即返回True
np.any(Y==0,axis=0)
np.any(Y==0,axis=1)
np.all(Y==0) # Y中所有的数都为0,才返回True,否则返回False
np.all(Y==0,axis=0)
np.all(Y>0,axis=1)