猿创征文｜数据导入与预处理-第2章-numpy

1.numpy介绍

numpy作为高性能科学计算和数据分析的基础包，它是众多数据分析、机器学习等工具的基础架构，掌握numpy的功能及其用法将有助于后续其他数据分析工具的学习。

2 数组对象

numpy中提供了一个重要的数据结构是ndarray（又称为array）对象，该对象是一个N维数组对象，可以存储相同类型、以多种形式组织的数据。
与Python中的数组相比，ndarray对象可以处理结构更复杂的数据。
数组指由相同类型的数据按有序的形式组织而成的一个集合，组成数组的各个数据称为数组的元素。
NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。
NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

NumPy 的数组中比较重要 ndarray 对象属性有：
numpy的常用数据类型

3 创建数组

3.1 根据现有数据类型创建数组

numpy中使用array()函数创建一个数组，该函数需要接收一个列表或元组。
创建一维数组

array_1d = np.array([1, 2, 3])
print(array_1d)

创建二维数组

array_2d = np.array([[1, 2, 3], 
                  [4, 5, 6]])  
print(array_2d)

创建三维数组

list_a = [1, 2, 3]
list_b = [4, 5, 6]
array_3d = np.array([[list_a, 
          list_b], [list_a, list_b]])      
print(array_3d)

3.2 根据指定数值创建数组

numpy中使用zeros()、ones()、empty()函数创建一个基于指定数值的数组，其中zeros()函数用于创建一个元素值都为0的数组；ones()函数用于创建一个元素值都为1的数组；empty()函数用于创建一个元素值都为随机数的数组。

np.zeros(shape, dtype=float, order='C')
np.ones(shape, dtype=None, order='C')
np.empty（shape，dtype=float，order='C' ）

shape：表示数组的形状。
dtype：（可选）表示数组中元素的类型，默认为float（浮点数）。
order：表示按索引顺序读取数组的元素，默认为’C’，说明采用C语言风格，按行排列数组的元素。
还可以使用

np.zeros_like()
np.ones_like()
np.empty_like()

使用zeros()函数创建数组

array_demo = np.zeros((2, 3))
print(array_demo)

输出：
[[0. 0. 0.]
[0. 0. 0.]]
使用ones()函数创建数组

array_demo = np.ones((2, 3)) 
print(array_demo)

输出：
[[1. 1. 1.]
[1. 1. 1.]]
使用empty()函数创建数组

array_demo = np.empty((2, 3))
print(array_demo)

输出
[[7.6e-322 0.0e+000 0.0e+000]
[0.0e+000 0.0e+000 0.0e+000]]

3.3 根据指定数值范围创建数组

numpy中使用arange()函数创建一个基于指定区间均匀分布数值的数组，arange()函数的功能类似于Python中的range()函数，不同的是，arange()函数会返回一维数组而非列表。
创建一个元素位于[1,30)区间、元素值间隔为5的数组:

array_demo = np.arange(1, 30, 5)
print(array_demo)

输出为：
[ 1 6 11 16 21 26]
arange()函数可以搭配reshape()方法使用，以重塑一维数组的形状。reshape()方法用于改变数组的形状，但不会改变数组的元素。

# 重塑数组的形状
new_arr = array_demo.reshape(2, 3) 	
print(new_arr)

输出为：
[[ 1 6 11]
[16 21 26]]

4 访问数组元素

数组支持通过索引和切片访问元素。numpy中提供了多种形式的索引：整数索引、花式索引和布尔索引，通过这些索引可以访问数组的单个、多个或一行元素。此外，还可以使用切片访问数组的元素。

4.1 使用整数索引访问元素

numpy中可以使用整数索引访问数组，以获取该数组中的单个元素或一行元素。

1. 一维数组访问元素的方式与列表访问元素方式相似，它会根据指定的整数索引获取相应位置的元素。

array_1d = np.arange(1, 7)    
print(array_1d)

输出为：
[1 2 3 4 5 6]

# 获取索引为2的元素
print(array_1d[2])

输出为：
3

2. 当使用整数索引访问二维数组时，二维数组会根据索引获取相应位置的一行元素，并将该行元素以一维数组的形式进行返回。
   

import numpy as np
array_2d = np.arange(1, 7).reshape(2, 3)   
print(array_2d)

输出为：
[[1 2 3]
[4 5 6]]

# 获取索引为1的一行元素
print(array_2d[1])

输出为：
[4 5 6]

3. 若想获取二维数组的单个元素，需要通过"二维数组[行索引，列索引]"形式实现。
   

# 获取行索引为1、列索引为2的元素
print(array_2d[1, 2])

输出为：
6

4.2 使用花式索引访问元素

花式索引指以整数组成的数组或列表为索引。当使用花式索引访问一维数组时，会将花式索引对应的数组或列表的元素作为索引，依次根据各个索引获取对应位置的元素，并将这些元素以数组的形式进行返回；当使用花式索引访问二维数组时，会将花式索引对应的数组或列表的元素作为索引，依次根据各个索引获取对应位置的一行元素，并将这些行元素以数组的形式进行返回。

1. 使用花式索引访问一维数组

import numpy as np
array_1d = np.arange(1, 10)    
print(array_1d)

输出为：
[1 2 3 4 5 6 7 8 9]

# 访问索引为[2,5,8]的元素
print(array_1d[[2, 5, 8]])

输出为：
[3 6 9]

2. 使用花式索引访问二维数组

array_2d = np.arange(1, 10).reshape((3, 3))    
print(array_2d)

输出为：
[[1 2 3]
[4 5 6]
[7 8 9]]

# 访问索引为[0, 2]的元素
print(array_2d[[0, 2]])

输出为：
[[1 2 3]
[7 8 9]]

3. 在使用两个花式索引，即通过“二维数组[花式索引，花式索引]”形式访问数组时，会将第一个花式索引对应列表的各元素作为行索引，将第二个花式索引对应列表的各元素作为列索引，再按照“二维数组[行索引，列索引]”的形式获取对应位置的元素。

# 使用两个花式索引访问元素
print(array_2d[[0, 2], [1, 1]])

输出为：
[2 8]

4.3 使用布尔索引访问元素

布尔索引指以布尔值组成的数组或列表为索引。当使用布尔索引访问数组时，会将布尔索引对应的数组或列表的元素作为索引，以获取索引为True时对应位置的元素。

array_2d = np.arange(1, 10).reshape((3, 3))    
print(array_2d)

输出为：

[[1 2 3]
 [4 5 6]
 [7 8 9]]

4.3 使用布尔索引访问数组

# 使用布尔索引访问数组
print(array_2d > 5)

输出为：
[[False False False]
[False False True]
[ True True True]]

print(array_2d[array_2d > 5])

输出为：
[6 7 8 9]

4.4 使用切片访问元素

一维数组的切片操作

array_1d = np.array([10, 20, 30, 40, 50, 60])
print(array_1d[1:3])                   # 访问索引为1、2的元素
print(array_1d[:3])                    # 访问前两个元素
print(array_1d[:-1])                   # 访问除末尾元素之外的元素
print(array_1d[:])                     # 访问全部的元素
print(array_1d[::2])                   # 访问开头到末尾、步长为2的元素

输出为：
[20 30]
[10 20 30]
[10 20 30 40 50]
[10 20 30 40 50 60]
[10 30 50]

二维数组的切片操作
与一维数组相比，二维数组支持更多的切片操作，不仅可以向中括号内传入一个切片，还可以传入两个切片，甚至可以混合传入索引和切片。
创建一个二维数组

arr_2d = np.array([[1, 2, 3], 
              [4, 5, 6], [7, 8, 9]])
print(arr_2d)

输出为：
[[1 2 3]
[4 5 6]
[7 8 9]]

# 使用切片访问前两行的元素
print(arr_2d[:2])

输出为：
[[1 2 3]
[4 5 6]]

# 使用切片访问前两行、第一列的元素
print(arr_2d[:2, 0:1])

输出为：
[[1]
[4]]

# 使用切片访问前两行、第二列的元素
print(arr_2d[:2, 1])

输出为：
[2 5]

5 数组运算

无论是形状相同的数组，还是形状不同的数组，它们之间都可以执行算术运算。与Python列表不同，数组在参与算术运算时无需遍历每个元素，便可以对每个元素执行批量运算，效率更高。

5.1形状相同的数组运算

形状相同的数组在执行算术运算时，会将位置相同的元素做算术运算，并将运算后所得的结果组成一个新数组。

In [1]: import numpy as np

In [2]: a = np.array(10)

In [3]: b = np.linspace(1,10,10) # 一维，长度为10

In [5]: a = np.arange(10)

In [6]: a
Out[6]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [7]: b
Out[7]: array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

In [8]: a + b # 数组加法
Out[8]: array([ 1.,  3.,  5.,  7.,  9., 11., 13., 15., 17., 19.])

In [9]: a - b # 数组减法
Out[9]: array([-1., -1., -1., -1., -1., -1., -1., -1., -1., -1.])

In [10]: a * b
Out[10]: array([ 0.,  2.,  6., 12., 20., 30., 42., 56., 72., 90.])

In [11]: a / b # 数组除法
Out[11]: 
array([0.        , 0.5       , 0.66666667, 0.75      , 0.8       ,
       0.83333333, 0.85714286, 0.875     , 0.88888889, 0.9       ])

In [12]: a % b # 数组取余
Out[12]: array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

In [13]: a ** 2 # 数组元素平方
Out[13]: array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

In [14]: np.multiply(a , b)
Out[14]: array([ 0.,  2.,  6., 12., 20., 30., 42., 56., 72., 90.])

5.2形状不同的数组运算

形状不同的数组之间进行运算会触发广播机制。广播机制指对形状较小的数组进行扩展，以匹配另一个形状较大的数组的形状，进而变成执行形状相同的数组间运算。
广播机制并不适用于任何数组，需要求两个数组满足以下规则：

• 数组形状的某一维度为1。
• 数组的某一维度相等。

若两个数组的形状在任一维度上都不匹配，且没有任一维度等于1，则会导致程序引发异常。
符合广播机制的拓展

A      (2d array):   5 x 4                         
B      (1d array):        1                      
Result (2d array):  5 x 4
A      (4d array):  8 x 1 x 6 x 1
B      (3d array):       7 x 1 x 5
Result (4d array): 8 x 7 x 6 x 5

不符合广播机制的拓展

A      (2d array):      2 x 1
# 倒数第二个维度不匹配
B      (3d array):  8 x 4 x 3

现有两个形状分别为(3,1)和(3,0)的数组arr_one和arr_two，这两个数组相加后得到一个形状为(3,3)的新数组result。

5.3 矩阵相乘

在 numpy 中，点乘使用 np.dot 计算：

In [25]: a = np.arange(9).reshape(3,3)

In [26]: a
Out[26]: 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

In [27]: b = np.ones(shape=(3,2))

In [28]: b
Out[28]: 
array([[1., 1.],
       [1., 1.],
       [1., 1.]])

In [29]: np.dot(a,b)
Out[29]: 
array([[ 3.,  3.],
       [12., 12.],
       [21., 21.]])

In [30]: 

np也支持将数组转换为矩阵的形式:

In [30]: a = np.mat(np.arange(9).reshape(3,3))

In [31]: a
Out[31]: 
matrix([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

In [32]: b = np.mat(np.ones(shape = (3,2)))

In [33]: b
Out[33]: 
matrix([[1., 1.],
        [1., 1.],
        [1., 1.]])

In [34]: a * b
Out[34]: 
matrix([[ 3.,  3.],
        [12., 12.],
        [21., 21.]])

In [35]: 

如果将数组转换为矩阵类型，a*b就表示为矩阵乘法，而非数组的按位乘法。
同时maxtrix类，提供了几个常用函数：

In [37]: a = np.mat(np.random.random((3,3)))

In [38]: a
Out[38]: 
matrix([[0.23559988, 0.16587754, 0.1944262 ],
        [0.11905442, 0.22523777, 0.53797625],
        [0.77548962, 0.37045583, 0.85015392]])

In [39]: a.I # 返回矩阵a的逆矩阵
Out[39]: 
matrix([[-0.3100451 , -2.73911773,  1.80421584],
        [12.54447562,  1.96597866, -4.1129312 ],
        [-5.18345835,  1.64187812,  1.32271189]])

In [40]: a.T # 返回矩阵a的转置矩阵
Out[40]: 
matrix([[0.23559988, 0.11905442, 0.77548962],
        [0.16587754, 0.22523777, 0.37045583],
        [0.1944262 , 0.53797625, 0.85015392]])

In [41]: a.A # 返回矩阵a对应的二维数组
Out[41]: 
array([[0.23559988, 0.16587754, 0.1944262 ],
       [0.11905442, 0.22523777, 0.53797625],
       [0.77548962, 0.37045583, 0.85015392]])

5.4 数组与常量的运算

形状相同的数组之间的任何算术运算都会应用到各元素，同样地，数组与标量执行算术运算时也会将标量应用到各元素，以方便各元素与标量直接进行相加、相减、相乘、相除等基础操作。

import numpy as np
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
num = 10
print(arr_2d + num)        # 数组与标量相加

输出为：
[[11 12 13]
[14 15 16]]

print(arr_2d - num)        # 数组与标量相减

输出为：
[[-9 -8 -7]
[-6 -5 -4]]

print(arr_2d * num)        # 数组与标量相乘

输出为：
[[10 20 30]
[40 50 60]]

print(arr_2d / num)        # 数组与标量相除

输出为：
[[0.1 0.2 0.3]
[0.4 0.5 0.6]]

6 Numpy的约减即操作

约减：表示将众多数据按照某种规则合并成一个或几个数据。
约减之后，数据的个数在总量上是减少的。
在这里，“约减”的“减”并非减法之意，而是元素的减少。比如说，数组的加法操作就是一种“约减”操作，因为它对众多元素按照加法指令实施操作，最后合并为少数的一个或几个值。

axis=0表示按照垂直方向约减
axis=1表示按照水平方向约减

6.1 约减计算

In [43]: a = np.ones((2, 3))
In [45]: 

In [45]: a.sum(axis=0)
Out[45]: array([2., 2., 2.])

In [46]: a.sum(axis=1)
Out[46]: array([3., 3.])

In [47]: a.sum()
Out[47]: 6.0

对于大于3的维度，难以找到直观理解的方向。可以采用括号层次理解，括号由外到内，对应从小到大的维数，比如，对于一个三维数组
[[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]]]
有三层括号，其维度由外之内分别为[0,1,2]。张量的阶rank和张量的轴axis是对应的，可以用ndim属性表示。
当sum()函数的axis=0时们就是第0个维度元素之间进行求和，即拆掉最外层括号后对应的两个元素[[1,1,1],[2,2,2]] 和 [[3,3,3],[4,4,4]] ，然后对同一个括号层次下的两个张量实施逐元素“约减”操作，其结果为[[4, 4, 4],[6, 6, 6]]。没有被“约减”的维度，其括号层次保持不变。

In [48]: a = np.array([[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]]])

In [49]: a
Out[49]: 
array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

In [50]: a.sum(axis = 0)
Out[50]: 
array([[4, 4, 4],
       [6, 6, 6]])

类似的，当sum()函数的axis=1时们就是第1个维度元素之间进行求和，即拆掉中间层括号后对应的元素[[1,1,1],[2,2,2]和 [3,3,3],[4,4,4]]。需要注意的是，约减操作的对象为原来统一括号层次内的对象，即[1,1,1],[2,2,2]相加，[3,3,3],[4,4,4]相加，没有被约减的维度，其括号保持不变，结果得到
[[3, 3, 3], [7, 7, 7]]

In [51]: a.sum(axis = 1)
Out[51]: 
array([[3, 3, 3],
       [7, 7, 7]])

类似的，当sum()函数的axis=2时，就是第2个维度元素之间进行求和，即拆掉最内层括号元素实施求和操作，即1+1+1 = 3，2+2+2 = 6，3+3+3=9，4+4+4=12。实施约减操作后，该层括号消失，其他维度的括号保留。结果得到[[3,6],[9,12]]

In [52]: a.sum(axis = 2)
Out[52]: 
array([[ 3,  6],
       [ 9, 12]])

这里对每个维度约减后，都是一种降维打击，比如axis为0时，就是把第0维干掉，即在第0维上执行求和操作。其他max(),min(),mean()邓函数的轴方向约减也类似。

6.2 数组排序操作

numpy中使用sort()方法实现数组排序功能，数组的每行元素默认会按照从小到大的顺序排列，返回排序后的数组。

sort(axis=-1, kind=None, order=None)

axis：表示排序的轴编号，默认为-1，代表沿着末尾的轴排序。
kind：表示排序的算法，默认为’quicksort’（快速排序）。
order：表示按哪个字段排序。

In [68]: a = np.array([[1,2,3],[4,5,6],[9,8,7],[5,3,1]])

In [69]: a
Out[69]: 
array([[1, 2, 3],
       [4, 5, 6],
       [9, 8, 7],
       [5, 3, 1]])

In [70]: a.sort(axis = 1)

In [71]: a
Out[71]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9],
       [1, 3, 5]])

In [72]: a = np.array([[1,2,3],[4,5,6],[9,8,7],[5,3,1]])

In [73]: a.sort(axis = 0)

In [74]: a
Out[74]: 
array([[1, 2, 1],
       [4, 3, 3],
       [5, 5, 6],
       [9, 8, 7]])

In [75]: 

numpy中提供了all()和any()函数检索数组的元素。
all()函数用于判断数组的所有元素是否全部满足条件，满足条件则返回True，否则返回False。
any()函数用于判断数组的元素是否有一个满足条件，满足条件则返回True，否则就返回False。

In [4]: import numpy as np
In [5]: arr = np.array([[1, -2, 5], [7, 6, 2], [-5, 9, 2]])
In [6]: print(np.all(arr > 0)) # 检测arr的元素是否全大于0

输出为：
False

print(np.any(arr > 0)) # 检测arr的元素是否至少有1个大于0

输出为：
True

6.3 检索数组元素

元素唯一化操作是数组中比较常见的操作，它主要查找数组的唯一元素。numpy中使用uniuqe()函数实现元素唯一化功能，将查找的唯一元素进行排序后返回。

import numpy as np
arr = np.array([12, 11, 34, 23, 12, 8, 11])
print(np.unique(arr)) # 查找数组的唯一元素

输出为：
[ 8 11 12 23 34]

6.3数组转置

熟悉数组的转置，可以通过T属性、transpose()方法、swapaxes()方法实现数组转置操作。
数组的转置指数组中各元素按照一定的规则变换位置。numpy中提供了三种实现数组转置的方式，分别为T属性、transpose()方法、swapaxes()方法。
numpy中数组通过访问T属性可实现简单的转置操作，即互换两个轴方向的元素，并返回一个互换后的新数组。

In [9]: import numpy as np
   ...: arr = np.arange(10).reshape(2,5)
   ...: print(f"arr形状：{arr.shape}")
   ...: print(arr)
   ...: 

输出为：
arr形状：(2, 5)
[[0 1 2 3 4]
[5 6 7 8 9]]

In [10]: # 使用T属性进行转置
    ...: new_arr = arr.T
    ...: print(f"new_arr形状：{new_arr.shape}")
    ...: print(new_arr)
    ...: 

输出为：
new_arr形状：(5, 2)
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]

与T属性的作用相似，swapaxes()方法也用于交换两个轴的元素，但该方法可以交换任意两个轴的元素。

In [11]: import numpy as np
    ...: arr = np.arange(24).reshape(2, 3, 4)
    ...: print(f"arr形状：{arr.shape}")
    ...: print(arr)
    ...: 

输出为：
arr形状：(2, 3, 4)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]

In [12]: # 使用swapaxes()方法进行数组转置，互换1号轴和2号轴的元素
    ...: new_arr = arr.swapaxes(2, 1)
    ...: print(f"new_arr形状：{new_arr.shape}")
    ...: print(new_arr)
    ...: 

输出为：
new_arr形状：(2, 4, 3)
[[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]

[[12 16 20]
[13 17 21]
[14 18 22]
[15 19 23]]]

transpose()方法不仅可以交换两个轴方向的元素，还可以交换多个轴方向的元素。transpose()方法需要接收一个由轴编号构成的元组，返回一个按轴编号互换后的新数组。

In [13]: import numpy as np
    ...: arr = np.arange(24).reshape(2,3,4)
    ...: print(f"arr形状：{arr.shape}")
    ...: print(arr)
    ...: 

输出为：
arr形状：(2, 3, 4)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]

In [14]: 
    ...: 
    ...: # 使用transpose()方法进行转置
    ...: new_arr = arr.transpose((1,2,0))
    ...: print(f"new_arr形状：{new_arr.shape}")
    ...: print(new_arr)
    ...: 

输出为：
new_arr形状：(3, 4, 2)
[[[ 0 12]
[ 1 13]
[ 2 14]
[ 3 15]]

[[ 4 16]
[ 5 17]
[ 6 18]
[ 7 19]]

[[ 8 20]
[ 9 21]
[10 22]
[11 23]]]

7 随机数生成

7.1 numpy的random库

python里随机数生成主要有两种方式，一种是random库，另一种是numpy.random。我目前后一种用的比较多，因此就先介绍后一种中一些(我)可能常用的，第一种等有时间了再整理。

1. 用numpy.random生成随机数
    1.1 生成服从均匀分布的随机数
    1.2 生成服从正态分布的随机数
    1.3 生成服从指数分布的随机数
    1.4 生成服从二项分布的随机数
    1.5 从指定一维数据集中随机选择数据：（可用于bootstrap抽样）
    1.6 将数据打乱（可用于Permutation Test）

返回数据在[0,1)之间，具有均匀分布
语法：rand(d0,d1,d2…)

In [23]: np.random.rand(3,4)
Out[23]: 
array([[0.58496659, 0.10987918, 0.73306144, 0.84831449],
       [0.17575706, 0.03498951, 0.17905576, 0.58961677],
       [0.66099259, 0.26250776, 0.2900706 , 0.16465037]])

返回具有标准正态分布，均值为0，方差为1
语法：randn(d0,d1,d2…)

In [24]: np.random.randn(3,4)
Out[24]: 
array([[ 1.65273029,  0.73261963,  0.83941063, -0.52498145],
       [-2.06807352,  0.20780148,  1.57492915,  0.98535171],
       [ 0.76163315,  0.29797001,  0.79840516,  1.81377089]])

生成随机整数，包含low，不包含high
语法：randint(low[,high,size,dtype])

In [25]: np.random.randint(1,10)
Out[25]: 4

返回[0.0,1.0)之间的随机小数
语法：random([size])

In [26]: np.random.random(size=(2,3))
Out[26]: 
array([[0.93927203, 0.99155484, 0.69772799],
       [0.80344563, 0.47586053, 0.43938675]])

生成服从均匀分布的随机数：
语法：np.random.uniform(low, high, size)

In [18]: import numpy as np
    ...: #通过low=0, high=1, size=10000，我们可以得到10000个0-1之间的随机数
    ...: data1 = np.random.uniform(low=0, high=1, size=10000)
    ...: data1
    ...: 
Out[18]: 
array([0.13849647, 0.15558525, 0.22337992, ..., 0.19242624, 0.84803791,
       0.69032494])

生成服从正态分布的随机数：
语法：np.random.normal(loc, scale, size)
说明：其中scale为标准差

#得到10000个服从均值为2，方差为1的正态分布的随机数
data2 = np.random.normal(2, 1, 10000)
data2

Out[19]: 
array([2.51079434, 0.55556988, 2.90165398, ..., 2.77380212, 3.41591164,
       1.85772448])

生成服从指数分布的随机数

语法：np.random.exponential(scale, size)

说明：scale即为$f(x)=e^{-\lambda }$中的$\lambda$

In [20]: data_e = np.random.exponential(1, 10000)

In [21]: data_e
Out[21]: 
array([1.91002501, 0.38237735, 0.68948747, ..., 1.13515155, 0.12209743,
       0.13518789])

生成服从二项分布的随机数
语法：np.random.binomial(n, p, size)
说明：参数n表示一次实验的样本数，p为每个样本发生的概率

#比如说，抛size=10次硬币，正面朝上的概率为p=0.5
data3 = np.random.binomial(1, p=0.5, size=10)
print(data3)

输出为：
[1 1 0 1 0 0 0 1 1 1]