numpy详解

暂时写这么多，之后有时间进行补充！

1.初步

一般使用np（numpy）

import numpy as np

2.zeros函数，ones函数

顾名思义zeros函数就是创建用0填充的矩阵，而ones函数则是创建用1填充的矩阵

Z = np.zeros(10)
print(Z)

result:
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]


Z = np.zeros((5,5))
print(Z)

result:
[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]

Z = np.ones((3,3,3))
print(Z)

result:
[[[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]

 [[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]

 [[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]]

3.arange函数

arange函数根据start（包含）与stop（不包含）指定的范围以及step（默认是1）设定的步长，生成一个 ndarray
arange(start,stop,step)

Z = np.arange(10,50)
print(Z)
result:
[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]

Z = np.arange(50)
Z = Z[::-1] #切片知识，倒置
print(Z)
result:
[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26
 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2
  1  0]

Z = np.arange(10,20,0.2) #步长为小数也可以
print(Z)
result:
[10.  10.2 10.4 10.6 10.8 11.  11.2 11.4 11.6 11.8 12.  12.2 12.4 12.6
 12.8 13.  13.2 13.4 13.6 13.8 14.  14.2 14.4 14.6 14.8 15.  15.2 15.4
 15.6 15.8 16.  16.2 16.4 16.6 16.8 17.  17.2 17.4 17.6 17.8 18.  18.2
 18.4 18.6 18.8 19.  19.2 19.4 19.6 19.8]

4.reshape函数

Z = np.arange(12).reshape(3,4)
print(Z)
result:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Z = np.arange(12).reshape(3,-1)# 注意-1表示自动计算列数，数组或者矩阵里面所有的元素个数/3, 该数必须是整数，不然报错
print(Z)
result:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Z = np.arange(12).reshape(-1,2)
print(Z)
result:
[[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 6  7]
 [ 8  9]
 [10 11]]

5.nonzero函数

nonzero函数用来寻找非0数字的位置

nz = np.nonzero([1,2,0,0,4,0])
print(nz)
result:
(array([0, 1, 4], dtype=int64),)

nz = np.nonzero([[1,2,0,0,4,0],[1,0,0,0,2,0]])
print(nz)
result:
(array([0, 0, 0, 1, 1], dtype=int64), array([0, 1, 4, 0, 4], dtype=int64))

6.eye函数

创建单位矩阵

Z = np.eye(3)
print(Z)
result:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Z = np.eye(3,4)
print(Z)
result:
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]

Z = np.eye(3,4,1)# 1表示向右移动一位
print(Z)
result:
[[0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

7.random函数

random函数是一个大集体

# 在0.0-1.0之内随机采样，生成3*3*3的矩阵，同random_sample
Z = np.random.random((3,3,3))
print(Z)
result:
[[[7.10814455e-01 1.56377352e-01 4.89797888e-01]
  [7.19437082e-04 9.52608478e-01 4.80563696e-01]
  [4.20960506e-01 4.94450677e-01 3.81385335e-01]]

 [[2.13768284e-02 3.04147484e-01 2.72083015e-01]
  [5.83624949e-01 5.05400898e-01 6.90514241e-01]
  [6.67028364e-01 8.64926031e-01 8.91323908e-01]]

 [[6.10570358e-01 7.66965389e-01 9.02382794e-01]
  [7.15163408e-01 3.19030084e-01 5.29582037e-01]
  [9.66168104e-01 4.81311435e-01 1.01713279e-01]]]

# 生成1（闭区间）-10（开区间）之内的3*2随机数
Z = np.random.randint(1,10,(3,2))
print(Z)
result:
[[6 4]
 [8 3]
 [2 5]]

# 生成1（闭区间）-5（闭区间）之内的3*2随机数
Z = np.random.random_integers(1,5,(3,2))
print(Z)
result:
[[1 5]
 [1 3]
 [1 1]]

# uniform(low=0, high=1, size),从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high 
Z = np.random.uniform(1,5,(3,2))
print(Z)
result:
[[2.14046721 4.77548873]
 [1.49745706 1.69981635]
 [3.8691427  3.71096113]]

#np.random.normal(loc, scale, size)
#loc：float类型,此概率分布的均值（对应着整个分布的中心centre）
#scale：float类型此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
#输出的shape，默认为None，只输出一个值
#另np.random.randn(size)所谓标准正态分布（μ=0,σ=1），对应于np.random.normal(loc=0, scale=1, size)
Z = np.random.normal(0,1,(3,1))
print(Z)
result:
[[ 0.91673935]
 [-0.29160901]
 [-0.02777222]]

#RandomState() 之后补充

8.pad函数

pad(array, pad_width, mode, constant_values) 返回值：数组

array——表示需要填充的数组；
pad_width——表示每个轴（axis）边缘需要填充的数值数目。
参数输入方式为：（(before_1, after_1), … (before_N, after_N)），其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值。取值为：{sequence, array_like, int}
mode——表示填充的方式

填充方式
‘constant’——表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0
‘edge’——表示用边缘值填充
‘linear_ramp’——表示用边缘递减的方式填充
‘maximum’——表示最大值填充
‘mean’——表示均值填充
‘median’——表示中位数填充
‘minimum’——表示最小值填充
‘reflect’——表示对称填充
‘symmetric’——表示对称填充
‘wrap’——表示用原数组后面的值填充前面，前面的值填充后面

Z = np.ones((5,5))
Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0)
print(Z)
result:
[[0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 1. 1. 1. 1. 1. 0.]
 [0. 0. 0. 0. 0. 0. 0.]]

Z = np.ones((5,5))
#（3,2）表示在A的第[1]轴填充（二维数组中，1轴表示行！），即在0轴前面（上面）填充3个宽度的0，在后面（下面）填充2个0
#（2,3）表示在A的第[0]轴填充（二维数组中，0轴表示列！），即在1轴前面填充3个宽度的0，后面填充2个宽度的0
Z = np.pad(Z,((3,2),(3,2)), mode='constant',constant_values=0)
print(Z)
result:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 1. 1. 1. 1. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

Z = np.zeros((3,3))
# 分别用1,2来填充前面和后面的。可以这么理解
#先将上面2行用1填充，任何将下面1行用2填充，接着用1填充前面一列（注意这里有覆盖），最后用2填充后面两列（同样有覆盖）。
Z = np.pad(Z, ((2,1),(1,2)), mode='constant',constant_values=(1,2))
print(Z)
result:
[[1. 1. 1. 1. 2. 2.]
 [1. 1. 1. 1. 2. 2.]
 [1. 0. 0. 0. 2. 2.]
 [1. 0. 0. 0. 2. 2.]
 [1. 0. 0. 0. 2. 2.]
 [1. 2. 2. 2. 2. 2.]]

Z = np.zeros((3,3))
# 注意上下前后四个填充的值均可不一样，如下面用1填充上面两行。
Z = np.pad(Z, ((2,1),(1,2)), mode='constant',constant_values=((1,2),(3,4)))
print(Z)
result:
[[3. 1. 1. 1. 4. 4.]
 [3. 1. 1. 1. 4. 4.]
 [3. 0. 0. 0. 4. 4.]
 [3. 0. 0. 0. 4. 4.]
 [3. 0. 0. 0. 4. 4.]
 [3. 2. 2. 2. 4. 4.]]

9.nan函数

nan为空值，先看一组测试

print(0 * np.nan)
print(np.nan == np.nan)
print(np.inf > np.nan)
print(np.nan - np.nan)
print(np.nan in set([np.nan]))# set为集合
print(0.3 == 3 * 0.1)
x = np.array([1, 1, 8, np.nan, 10])
print(np.nan in x)
print(np.isnan(x))
result:
nan
False
False
nan
True
False
False
[False False False  True False]

注意nan为浮点型，而在Python中浮点数是不对等的，不能用==，在np中nan需要用isnan这个函数来识别。

10 diag函数

Z = np.diag(1+np.arange(4))
print(Z)
result:
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]

Z = np.diag(1+np.arange(4),k=2)
print(Z)
result:
[[0 0 1 0 0 0]
 [0 0 0 2 0 0]
 [0 0 0 0 3 0]
 [0 0 0 0 0 4]
 [0 0 0 0 0 0]
 [0 0 0 0 0 0]]

Z = np.diag(1+np.arange(4),k=-2)
print(Z)
result:
[[0 0 0 0 0 0]
 [0 0 0 0 0 0]
 [1 0 0 0 0 0]
 [0 2 0 0 0 0]
 [0 0 3 0 0 0]
 [0 0 0 4 0 0]]

11.unravel_index函数

numpy.unravel_index(indices, dims)
返回indices中的元素在维度为dims的数组中的索引值，默认按元组的形式返回。

# 寻找(6,7,8)的第一百个元素的位置
print(np.unravel_index(99,(6,7,8)))
result:
(1, 5, 3)

12.tile函数

以前面的数/数组为整体，第二个为划分为x行y列的矩阵

Z = np.tile( np.array([[0,1],[1,0]]), (3,3))
print(Z)
result:
[[0 1 0 1 0 1]
 [1 0 1 0 1 0]
 [0 1 0 1 0 1]
 [1 0 1 0 1 0]
 [0 1 0 1 0 1]
 [1 0 1 0 1 0]]

13.intersect1d函数

寻找两个数组的交集

Z1 = np.random.randint(1,10,10)
Z2 = np.random.randint(1,10,10)
print(Z1)
print(Z2)
print(np.intersect1d(Z1,Z2))
result:
[2 5 7 5 9 5 8 9 4 3]
[7 9 2 5 5 3 8 2 4 9]
[2 3 4 5 7 8 9]

14.datetime64函数

时间函数

yesterday = np.datetime64('today') - np.timedelta64(1)
today     = np.datetime64('today')
tomorrow  = np.datetime64('today') + np.timedelta64(1)
print(yesterday)
print(today)
print(tomorrow)
result:
2021-08-02
2021-08-03
2021-08-04

Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')
print(Z)
result:
['2016-07-01' '2016-07-02' '2016-07-03' '2016-07-04' '2016-07-05'
 '2016-07-06' '2016-07-07' '2016-07-08' '2016-07-09' '2016-07-10'
 '2016-07-11' '2016-07-12' '2016-07-13' '2016-07-14' '2016-07-15'
 '2016-07-16' '2016-07-17' '2016-07-18' '2016-07-19' '2016-07-20'
 '2016-07-21' '2016-07-22' '2016-07-23' '2016-07-24' '2016-07-25'
 '2016-07-26' '2016-07-27' '2016-07-28' '2016-07-29' '2016-07-30'
 '2016-07-31']

15.矩阵运算

如计算((A+B)*(-A/2))

A = np.ones(3)*1
B = np.ones(3)*2
np.add(A,B,out=B)
np.divide(A,2,out=A)
np.negative(A,out=A) #取负号
np.multiply(A,B,out=A)
print(A)
result:
[-1.5 -1.5 -1.5]

16.fromiter函数

fromiter(iterable, dtype, count = -1) 从一个循环对象中提取数字，产生新的数组
Iterable: 为生成数组提供数据的对象
dtype: 生成的数组內数据类型

def generate():
    for x in range(10):
        yield x
Z = np.fromiter(generate(),dtype=float,count=-1)
print(Z)
result:
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

generate = (x for x in range(0,10))
Z = np.fromiter(generate,dtype=float,count=-1)
print(Z)
result:
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

17.allclose函数、array_equal函数

A = np.random.randint(0,2,5)
B = np.random.randint(0,2,5)
# Assuming identical shape of the arrays and a tolerance for the comparison of values
equal = np.allclose(A,B)
print(equal)
# Checking both the shape and the element values, no tolerance (values have to be exactly equal)
equal = np.array_equal(A,B)
print(equal)
result:
False
False

18.meshgrid函数

从坐标向量中返回坐标矩阵

Z = np.meshgrid(np.linspace(0,1,5))
print(Z)
result:
[array([0.  , 0.25, 0.5 , 0.75, 1.  ])]

Z = np.zeros((5,5), [('x',float),('y',float)])
Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),
                             np.linspace(0,1,5))
print(Z)
result:
[[(0.  , 0.  ) (0.25, 0.  ) (0.5 , 0.  ) (0.75, 0.  ) (1.  , 0.  )]
 [(0.  , 0.25) (0.25, 0.25) (0.5 , 0.25) (0.75, 0.25) (1.  , 0.25)]
 [(0.  , 0.5 ) (0.25, 0.5 ) (0.5 , 0.5 ) (0.75, 0.5 ) (1.  , 0.5 )]
 [(0.  , 0.75) (0.25, 0.75) (0.5 , 0.75) (0.75, 0.75) (1.  , 0.75)]
 [(0.  , 1.  ) (0.25, 1.  ) (0.5 , 1.  ) (0.75, 1.  ) (1.  , 1.  )]]