numpy 的使用

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

扫描二维码关注公众号，回复： 144233 查看本文章

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

array([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14]])

#数据维度，形状和大小的查看

```y.ndim

```

y.shape
```

(9,)

y.size

```

Y.ndim

```

Y.shape

```

(3, 5)

Y.size

```

#numpy中array 数据的访问

```y[0]#访问y中的第一个元素
```

y[-1]#访问y中的最后一个元素

```

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第一行第一列的元素

```

Y[-1,-1]#访问Y中最后一行最后一列的元素

```

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

```
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]])

```
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

```

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的参数必须为列表

A
array([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)]

%%timeit
A = []
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.array
import 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+M
array([[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

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)#向量

x
array([ 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)#矩阵

Y
array([[ 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)

import numpy as np

#数据维度，形状和大小的查看

#numpy中array 数据的访问

#reshape

#数组的拆分 np.split

猜你喜欢