【Numpy基础（01）NumPy数组的构造】

基础数组生成：

import numpy as np
np.array([1,2,3])

>>>
array([1,2,3])
1
2
3
4
5

1.等差数列

生成数值均匀间隔的数组的函数：

1） np.linspace(start,end(incloud),count)

np.linspace(1,5,5)

>>>
array([1,2,3,4,5])

1
2
3
4
5

2）np.arange(start,end(NOT incolud),step)

np.arange(1,5,1)

>>>
array([1,2,3,4])
1
2
3
4

2.特殊矩阵

Numpy提供了丰富的特殊数组生成函数。

学习4祌更加常用的函数：np.zeros()、np.ones()、np.eye()、np.full() 。

其中，np.zeros() 和np.ones() 传入的参数为元组，其含义是数组每一个维度的大小。

需要注意的是，NumPy很多函数含有dim 参数，指代这个函数操作的作用于数组哪一个维度。

1）全零数组：

np.zeros((2,3,4))

>>>
array([[[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
2
3
4
5
6
7
8
9
10

2）全一数组：

np.ones((2,2,2))

>>>
array([[[1., 1.],
        [1., 1.]],

       [[1., 1.],
        [1., 1.]]])

1
2
3
4
5
6
7
8
9

3）填充函数：

实际上，np.zeros() 是填充函数np.full() 的特例：

# 传入元组表示各维度大小，10代表填充数值。
np.full((2,3),10)

>>>
array([[10, 10, 10],
       [10, 10, 10]])

1
2
3
4
5
6
7

指定函数填充：

除了用具体数值做填充参数外，np.full() 也可以用相关数组作填充。

np_input = [[1,2],[2,3],[3,4]]
np.full((3,2),np_input)

>>>
array([[1, 2],
       [2, 3],
       [3, 4]])

1
2
3
4
5
6
7
8

4）相似数组：

给定一个数组，希望生成一个大小相同的全零矩阵、全一矩阵、填充矩阵的时候，

可以通过np.zeros_like() 、np.ones_like() 、np.full_like() 来完成。

arr =  [[1,2],[3,4]]
np.zeros_like(arr)
np.ones_like(arr)
np.full_like(arr,[100,200])

>>>
array([[0, 0],
       [0, 0]])

array([[1, 1],
       [1, 1]])

array([[100, 200],
       [100, 200]])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5）单位矩阵（one-hot)数组：

np.eye(n) ,其中包含参数n，表示返回n*n的单位矩阵；其中参数k表示对角线的偏移距离，当k ≥ 1 时，主对角线的元素1向上移动k个单位。

np.eye(3)

>>>
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])、

np.eye(3,k=1)

>>>
array([[0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])

1
2
3
4
5
6
7
8
9
10
11
12
13
14

6）随机数组：

• 均匀分布的随机数组np.random.uniform() :

  使用uniform(a,b,size) 生成服从Union[a,b]且数组维度为size的均匀分布的数组。

  np.random.uniform(-1,2,3) # 一维
  >>>
  array([1.78858473, 1.10174551, 0.94010394])
   
  np.random.uniform(-1,2,(3,3)) # 二维
  >>>
  array([[-0.56628198,  1.83583593, -0.37143635],
         [-0.81564169, -0.7184707 ,  1.15597808],
         [ 0.9893065 ,  0.14192388,  0.63407046]])
  1
  2
  3
  4
  5
  6
  7
  8
  9

  特别地，使用rank(d1,d2,...,di)可生成服从Union[0,1] 的均匀分布的数组。

  np.random.rand(3) # 一维
  >>>
  array([0.17224068, 0.08768655, 0.21122689])
  
  np.random.rand(3,3) # 二维
  >>>
  array([[0.43080002, 0.77445509, 0.64440975],
         [0.94128853, 0.08567484, 0.58384549],
         [0.82629929, 0.87821442, 0.92663952]])
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 正态分布的随机数组np.random.normal() :

  numpy.random.normal(loc=0,scale=1e-2,size=shape)

  生成服从N[μ,σ] 的正态分布数组；

  参数loc(float)：正态分布的均值μ（mu），对应着这个分布的中心；loc=0说明这一个以Y轴为对称轴的正态分布;
  参数scale(float)：正态分布的标准差σ（sigma），对应分布的宽度，scale越大，正态分布的曲线越矮胖，scale越小，曲线越高瘦。
  参数size(int 或者整数元组)：输出的值赋在shape里，默认为None。

  mu,sigma = 3 ,2.5
  np.random.normal(mu,sigma,3) # 一维
  >>>
  array([ 4.29499138,  0.98655863, -1.56466144])
  
  np.random.normal(mu,sigma,(3,3)) # 二维
  >>>
  array([[0.41735476, 0.99672494, 0.37768128],
         [3.13139722, 0.33436774, 4.93461669],
         [3.98845975, 1.12911117, 2.96952763]])
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  特别地，使用randn(d1,d2,...,di) 来生成N[0,1]的标准正态分布数组。

  np.random.randn(3) # 一维
  >>>
  array([-0.47404843,  1.17751787, -0.39836191])
  
  np.random.randn(3,3) # 二维
  >>>
  array([[-0.96746354,  1.11524261,  0.44647443],
         [-0.42288963,  0.34874541,  0.32548492],
         [-0.15397721,  1.32918807,  0.09952371]])
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 满足离散均匀分布的随机整数数组np.random.randint() ：

  ​(low, high=None, size=None, dtype=‘l’)

  生成在给定整数范围内的呈离散均匀分布的整数数组，其中参数high对应的整数值不包含在内.

  返回low(包括)到high(不包括)之间的随机整数，即[low, high)。从半开区间[low, high)中返回满足离散均匀分布的随机整数，这些数据需符合函数指定的数据类型。如果未指定high（即采用默认值None），那么结果将落到区间[0, low)。

  low,high,size = 5,15,(3,3)
  np.random.randint(low,high,size)
  >>>
  array([[ 9,  8,  9],
         [11,  7,  9],
         [12, 14, 14]])
  
  1
  2
  3
  4
  5
  6
  7

• 抽样生成数组np.random.choice() :

  使用choice() 可以从给定的列表中，以一定的概率和方式抽取元素，当不指定概率时默认等概率抽样、默认抽样方式为有放回抽样，此时，replace = True ,即同一个元素可能被重复抽取：

  my_list = [ "a","b","c","d"]
  np.random.choice(
      my_list,
      3,
      replace = False,
      p = [0.1,0.7,0.1,0.1]
  
  >>>
  array(['b', 'a', 'd'], dtype=')
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

  numpy.random.choice(a, size=None, replace=True, p=None)

  参数a：必须是一维的。

  参数size：形成指定大小的数组。

  参数replace：是否有放回抽样。true代表放回抽样。
  数组p：与数组a相对应，表示取数组a中每个元素的概率，默认为选取每个元素的概率相同。

  特别地，当返回的列表个数与原列表元素个数相同，且是不放回抽样时候就等价于打散原列表：

  等价于使用permutation() 函数：

  np.random.permutation(my_list)
  >>>
  array(['b', 'c', 'a', 'd'], dtype=')
  
  1
  2
  3
  4

• 随机种子np.random.seed() :

  np.random.seed(n)函数用于生成指定随机数。

  seed()中的参数被设置了之后，np.random.seed()可以按顺序产生一组固定的数组，如果使用相同的seed()值，则每次生成的随机数都相同。如果不设置这个值，那么每次生成的随机数不同。但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同。

  例1（只调用一次seed()，两次的产生随机数不同）

  import numpy as np
  np.random.seed(1)
  L1 = np.random.randn(3, 3)
  L2 = np.random.randn(3, 3)
  print(L1)
  print(L2)
  
  >>>
  [[ 1.62434536 -0.61175641 -0.52817175]
    [-1.07296862  0.86540763 -2.3015387 ]
    [ 1.74481176 -0.7612069   0.3190391 ]]
  
  [[-0.24937038  1.46210794 -2.06014071]
    [-0.3224172  -0.38405435  1.13376944]
    [-1.09989127 -0.17242821 -0.87785842]]
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

  例2（调用两次seed()，两次产生的随机数相同）

  import numpy as np
  np.random.seed(1)
  L1 = np.random.randn(3, 3)
  np.random.seed(1)
  L2 = np.random.randn(3, 3)
  print(L1)
  print(L2)
  
  >>>
  [[ 1.62434536 -0.61175641 -0.52817175]
    [-1.07296862  0.86540763 -2.3015387 ]
    [ 1.74481176 -0.7612069   0.3190391 ]]
  
  [[ 1.62434536 -0.61175641 -0.52817175]
    [-1.07296862  0.86540763 -2.3015387 ]
    [ 1.74481176 -0.7612069   0.3190391 ]]
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16