数据导入与预处理-numpy
- 1.numpy介绍
- 2 数组对象
- 3 创建数组
- 3.1 根据现有数据类型创建数组
- 3.2 根据指定数值创建数组
- 3.3 根据指定数值范围创建数组
- 4 访问数组元素
- 4.1 使用整数索引访问元素
- 4.2 使用花式索引访问元素
- 4.3 使用布尔索引访问数组
- 4.4 使用切片访问元素
- 5 数组运算
- 5.1形状相同的数组运算
- 5.2形状不同的数组运算
- 5.3 矩阵相乘
- 5.4 数组与常量的运算
- 6 Numpy的约减即操作
- 6.1 约减计算
- 6.2 数组排序操作
- 6.3 检索数组元素
- 6.3数组转置
- 7 随机数生成
- 7.1 numpy的random库
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()函数创建一个数组，该函数需要接收一个列表或元组。 创建一维数组
代码语言：javascript复制array_1d = np.array([1, 2, 3])
print(array_1d)创建二维数组
代码语言：javascript复制array_2d = np.array([[1, 2, 3],
[4, 5, 6]])
print(array_2d)创建三维数组
代码语言：javascript复制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()函数用于创建一个元素值都为随机数的数组。
代码语言：javascript复制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语言风格，按行排列数组的元素。 还可以使用
代码语言：javascript复制np.zeros_like()
np.ones_like()
np.empty_like()使用zeros()函数创建数组
代码语言：javascript复制array_demo = np.zeros((2, 3))
print(array_demo)输出： [[0. 0. 0.] [0. 0. 0.]] 使用ones()函数创建数组
代码语言：javascript复制array_demo = np.ones((2, 3))
print(array_demo)输出： [[1. 1. 1.] [1. 1. 1.]] 使用empty()函数创建数组
代码语言：javascript复制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的数组:
代码语言：javascript复制array_demo = np.arange(1, 30, 5)
print(array_demo)输出为： [ 1 6 11 16 21 26] arange()函数可以搭配reshape()方法使用，以重塑一维数组的形状。reshape()方法用于改变数组的形状，但不会改变数组的元素。
代码语言：javascript复制# 重塑数组的形状
new_arr = array_demo.reshape(2, 3)
print(new_arr)输出为： [[ 1 6 11] [16 21 26]]
4 访问数组元素
数组支持通过索引和切片访问元素。numpy中提供了多种形式的索引：整数索引、花式索引和布尔索引，通过这些索引可以访问数组的单个、多个或一行元素。此外，还可以使用切片访问数组的元素。
4.1 使用整数索引访问元素
numpy中可以使用整数索引访问数组，以获取该数组中的单个元素或一行元素。
- 一维数组访问元素的方式与列表访问元素方式相似，它会根据指定的整数索引获取相应位置的元素。
array_1d = np.arange(1, 7)
print(array_1d)输出为： [1 2 3 4 5 6]
代码语言：javascript复制# 获取索引为2的元素
print(array_1d[2])输出为： 3
- 当使用整数索引访问二维数组时，二维数组会根据索引获取相应位置的一行元素，并将该行元素以一维数组的形式进行返回。
import numpy as np
array_2d = np.arange(1, 7).reshape(2, 3)
print(array_2d)输出为： [[1 2 3] [4 5 6]]
代码语言：javascript复制# 获取索引为1的一行元素
print(array_2d[1])输出为： [4 5 6]
- 若想获取二维数组的单个元素，需要通过"二维数组[行索引，列索引]"形式实现。
# 获取行索引为1、列索引为2的元素
print(array_2d[1, 2])输出为： 6
4.2 使用花式索引访问元素
花式索引指以整数组成的数组或列表为索引。当使用花式索引访问一维数组时，会将花式索引对应的数组或列表的元素作为索引，依次根据各个索引获取对应位置的元素，并将这些元素以数组的形式进行返回；当使用花式索引访问二维数组时，会将花式索引对应的数组或列表的元素作为索引，依次根据各个索引获取对应位置的一行元素，并将这些行元素以数组的形式进行返回。
- 使用花式索引访问一维数组
import numpy as np
array_1d = np.arange(1, 10)
print(array_1d)输出为： [1 2 3 4 5 6 7 8 9]
代码语言：javascript复制# 访问索引为[2,5,8]的元素
print(array_1d[[2, 5, 8]])输出为： [3 6 9]
- 使用花式索引访问二维数组
array_2d = np.arange(1, 10).reshape((3, 3))
print(array_2d)输出为： [[1 2 3] [4 5 6] [7 8 9]]
代码语言：javascript复制# 访问索引为[0, 2]的元素
print(array_2d[[0, 2]])输出为： [[1 2 3] [7 8 9]]
- 在使用两个花式索引，即通过“二维数组[花式索引，花式索引]”形式访问数组时，会将第一个花式索引对应列表的各元素作为行索引，将第二个花式索引对应列表的各元素作为列索引，再按照“二维数组[行索引，列索引]”的形式获取对应位置的元素。
# 使用两个花式索引访问元素
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 使用布尔索引访问数组
代码语言：javascript复制# 使用布尔索引访问数组
print(array_2d > 5)输出为： [[False False False] [False False True] [ True True True]]
代码语言：javascript复制print(array_2d[array_2d > 5])输出为： [6 7 8 9]
4.4 使用切片访问元素
一维数组的切片操作
代码语言：javascript复制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]
二维数组的切片操作 与一维数组相比，二维数组支持更多的切片操作，不仅可以向中括号内传入一个切片，还可以传入两个切片，甚至可以混合传入索引和切片。 创建一个二维数组
代码语言：javascript复制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]]
代码语言：javascript复制# 使用切片访问前两行的元素
print(arr_2d[:2])输出为： [[1 2 3] [4 5 6]]
代码语言：javascript复制# 使用切片访问前两行、第一列的元素
print(arr_2d[:2, 0:1])输出为： [[1] [4]]
代码语言：javascript复制# 使用切片访问前两行、第二列的元素
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，则会导致程序引发异常。 符合广播机制的拓展
代码语言：javascript复制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不符合广播机制的拓展
代码语言：javascript复制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 计算：
代码语言：javascript复制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也支持将数组转换为矩阵的形式:
代码语言：javascript复制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类，提供了几个常用函数：
代码语言：javascript复制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 数组与常量的运算
形状相同的数组之间的任何算术运算都会应用到各元素，同样地，数组与标量执行算术运算时也会将标量应用到各元素，以方便各元素与标量直接进行相加、相减、相乘、相除等基础操作。
代码语言：javascript复制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]]
代码语言：javascript复制print(arr_2d - num) # 数组与标量相减输出为： [[-9 -8 -7] [-6 -5 -4]]
代码语言：javascript复制print(arr_2d * num) # 数组与标量相乘输出为： [[10 20 30] [40 50 60]]
代码语言：javascript复制print(arr_2d / num) # 数组与标量相除输出为： [[0.1 0.2 0.3] [0.4 0.5 0.6]]
6 Numpy的约减即操作
约减：表示将众多数据按照某种规则合并成一个或几个数据。 约减之后，数据的个数在总量上是减少的。 在这里，“约减”的“减”并非减法之意，而是元素的减少。比如说，数组的加法操作就是一种“约减”操作，因为它对众多元素按照加法指令实施操作，最后合并为少数的一个或几个值。
axis=0表示按照垂直方向约减 axis=1表示按照水平方向约减
6.1 约减计算
代码语言：javascript复制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]]。没有被“约减”的维度，其括号层次保持不变。
代码语言：javascript复制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]]
代码语言：javascript复制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]]
代码语言：javascript复制In [52]: a.sum(axis = 2)
Out[52]:
array([[ 3, 6],
[ 9, 12]])这里对每个维度约减后，都是一种降维打击，比如axis为0时，就是把第0维干掉，即在第0维上执行求和操作。其他max(),min(),mean()邓函数的轴方向约减也类似。
6.2 数组排序操作
numpy中使用sort()方法实现数组排序功能，数组的每行元素默认会按照从小到大的顺序排列，返回排序后的数组。
代码语言：javascript复制sort(axis=-1, kind=None, order=None)axis：表示排序的轴编号，默认为-1，代表沿着末尾的轴排序。 kind：表示排序的算法，默认为’quicksort’（快速排序）。 order：表示按哪个字段排序。
代码语言：javascript复制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。
代码语言：javascript复制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
代码语言：javascript复制print(np.any(arr > 0)) # 检测arr的元素是否至少有1个大于0输出为： True
6.3 检索数组元素
元素唯一化操作是数组中比较常见的操作，它主要查找数组的唯一元素。numpy中使用uniuqe()函数实现元素唯一化功能，将查找的唯一元素进行排序后返回。
代码语言：javascript复制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]]
代码语言：javascript复制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]]]
代码语言：javascript复制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()方法需要接收一个由轴编号构成的元组，返回一个按轴编号互换后的新数组。
代码语言：javascript复制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]]]
代码语言：javascript复制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。我目前后一种用的比较多，因此就先介绍后一种中一些(我)可能常用的，第一种等有时间了再整理。
- 用numpy.random生成随机数 1.1 生成服从均匀分布的随机数 1.2 生成服从正态分布的随机数 1.3 生成服从指数分布的随机数 1.4 生成服从二项分布的随机数 1.5 从指定一维数据集中随机选择数据：（可用于bootstrap抽样） 1.6 将数据打乱（可用于Permutation Test）
返回数据在[0,1)之间，具有均匀分布 语法：rand(d0,d1,d2…)
代码语言：javascript复制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…)
代码语言：javascript复制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])
代码语言：javascript复制In [25]: np.random.randint(1,10)
Out[25]: 4返回[0.0,1.0)之间的随机小数 语法：random([size])
代码语言：javascript复制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)
代码语言：javascript复制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为标准差
代码语言：javascript复制#得到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即为
中的
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为每个样本发生的概率
代码语言：javascript复制#比如说，抛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]
