python——numpy（一）

一、查看与指定数值类型

import numpy as np  # 导入 NumPy 模块

#TODO 1 指定数值类型，修改数值类型，查看数值类型
a = np.array([1.1, 2.2, 3.3], dtype=np.float64)  # 指定 1 维数组的数值类型为 float64
print(a, a.dtype)  # 查看 a 及 dtype 类型
print(a.astype(int).dtype)  # 将 a 的数值类型从 float64 转换为 int，并查看 dtype 类型


'''运行结果
[1.1 2.2 3.3] float64
int32
'''

数值类型：

'''数值类型
类型            解释
bool        布尔类型，1 个字节，值为 True 或 False。
int            整数类型，通常为 int64 或 int32 。
intc        与 C 里的 int 相同，通常为 int32 或 int64。
intp        用于索引，通常为 int32 或 int64。
int8        字节（从 -128 到 127）
int16        整数（从 -32768 到 32767）
int32        整数（从 -2147483648 到 2147483647）
int64        整数（从 -9223372036854775808 到 9223372036854775807）
uint8        无符号整数（从 0 到 255）
uint16        无符号整数（从 0 到 65535）
uint32        无符号整数（从 0 到 4294967295）
uint64        无符号整数（从 0 到 18446744073709551615）
float        float64 的简写。
float16        半精度浮点，5 位指数，10 位尾数
float32        单精度浮点，8 位指数，23 位尾数
float64        双精度浮点，11 位指数，52 位尾数
complex        complex128 的简写。
complex64    复数，由两个 32 位浮点表示。
complex128    复数，由两个 64 位浮点表示。
'''

二、numpy常见参数

'''
NumPy 中，ndarray 类具有六个参数，它们分别为：
shape：数组的形状。
dtype：数据类型。
buffer：对象暴露缓冲区接口。
offset：数组数据的偏移量。
strides：数据步长。
order：{'C'，'F'}，以行或列为主排列顺序。'''

三、列表或元组转换

'''
在 NumPy 中，我们使用 numpy.array 将列表或元组转换为 ndarray 数组。
其方法为：
numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
其中，参数：
object：列表、元组等。
dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
copy：布尔类型，默认 True，表示复制对象。
order：顺序。
subok：布尔类型，表示子类是否被传递。
ndmin：生成的数组应具有的最小维数。
'''

import numpy as np
#列表转换
data = np.array([[1, 2, 3], [4, 5, 6]])
print(data)
'''
[[1 2 3]
 [4 5 6]]
'''
#元组转换
data1 = np.array([(1, 2), (3, 4), (5, 6)])
print(data1)
'''
[[1 2]
 [3 4]
 [5 6]]
'''

四、numpy函数创建数组

1.arange函数

'''arange函数
作用：在给定区间内创建一系列均匀间隔的值
numpy.arange(start, stop, step, dtype=None)
'''


import numpy as np
# 在区间 [3, 7) 中以 0.5 为步长新建数组,数值类型为浮点数
data=np.arange(3, 7, 0.5, dtype='float32')
print(data)
'''
[3.  3.5 4.  4.5 5.  5.5 6.  6.5]
'''

2.linspace函数

'''linspace函数
作用：linspace方法也可以像arange方法一样，创建数值有规律的数组。
linspace 用于在指定的区间内返回间隔均匀的值
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start：序列的起始值。
stop：序列的结束值。
num：生成的样本数。默认值为50。
endpoint：布尔值，如果为真，则最后一个样本包含在序列内。
retstep：布尔值，如果为真，返回间距。
dtype：数组的类型。
'''


import numpy as np
#np.linspace(起始值, 结束值, 生成样本数, 是否包含结束值,是否返回间隔,数值类型指定)
data1=np.linspace(0, 1, 100, endpoint=False,retstep=False,dtype=None)
print(data1)
'''
[0.   0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1  0.11 0.12 0.13
 0.14 0.15 0.16 0.17 0.18 0.19 0.2  0.21 0.22 0.23 0.24 0.25 0.26 0.27
 0.28 0.29 0.3  0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4  0.41
 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5  0.51 0.52 0.53 0.54 0.55
 0.56 0.57 0.58 0.59 0.6  0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69
 0.7  0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8  0.81 0.82 0.83
 0.84 0.85 0.86 0.87 0.88 0.89 0.9  0.91 0.92 0.93 0.94 0.95 0.96 0.97
 0.98 0.99]
'''
#将 endpoint 参数改成 True 看看区别：（endpoint：布尔值为真，则最后一个样本包含在序列内）
'''
[0.         0.01010101 0.02020202 0.03030303 0.04040404 0.05050505
 0.06060606 0.07070707 0.08080808 0.09090909 0.1010101  0.11111111
 0.12121212 0.13131313 0.14141414 0.15151515 0.16161616 0.17171717
 0.18181818 0.19191919 0.2020202  0.21212121 0.22222222 0.23232323
 0.24242424 0.25252525 0.26262626 0.27272727 0.28282828 0.29292929
 0.3030303  0.31313131 0.32323232 0.33333333 0.34343434 0.35353535
 0.36363636 0.37373737 0.38383838 0.39393939 0.4040404  0.41414141
 0.42424242 0.43434343 0.44444444 0.45454545 0.46464646 0.47474747
 0.48484848 0.49494949 0.50505051 0.51515152 0.52525253 0.53535354
 0.54545455 0.55555556 0.56565657 0.57575758 0.58585859 0.5959596
 0.60606061 0.61616162 0.62626263 0.63636364 0.64646465 0.65656566
 0.66666667 0.67676768 0.68686869 0.6969697  0.70707071 0.71717172
 0.72727273 0.73737374 0.74747475 0.75757576 0.76767677 0.77777778
 0.78787879 0.7979798  0.80808081 0.81818182 0.82828283 0.83838384
 0.84848485 0.85858586 0.86868687 0.87878788 0.88888889 0.8989899
 0.90909091 0.91919192 0.92929293 0.93939394 0.94949495 0.95959596
 0.96969697 0.97979798 0.98989899 1.        ]
'''

3.ones函数

'''numpy.ones函数与zeros函数，两者使用相同，区别在于填充值不同
作用：快速创建数值全部为 1 的多维数组
numpy.ones(shape, dtype=None, order='C')
shape：用于指定数组形状，例如（1， 2）或 3。
dtype：数据类型。
order：{'C'，'F'}，按行或列方式储存数组。
'''


import numpy as np
#生成三行4列为1的多维数组
print(np.ones((3, 4)))
'''
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
'''
#生成三行4列为1的多维数组，指定数组类型为整数
print(np.ones((3, 4),dtype=int))
'''
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]
'''
#生成三行4列的多维数组，分别为行列指定类型
print(np.ones((3,4),dtype=[('x','int'),('y','float')]))
'''
[[(1, 1.) (1, 1.) (1, 1.) (1, 1.)]
 [(1, 1.) (1, 1.) (1, 1.) (1, 1.)]
 [(1, 1.) (1, 1.) (1, 1.) (1, 1.)]]
'''

4.eye函数

'''numpy.eye 
作用：创建一个二维数组，其特点是k 对角线上的值为 1，其余值全部为0。方法如下：
numpy.eye(N, M=None, k=0, dtype=<type 'float'>)
N：输出数组的行数。
M：输出数组的列数。
k：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线。
'''


import numpy as np
print(np.eye(4,4,0,dtype=int)) #生成4行4列，主对角线为1
'''
[[1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]
'''
print(np.eye(4,4,1,dtype=int)) #生成4行4列，主对角线向上偏移一行为1
'''
[[0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]
 [0 0 0 0]]
'''
print(np.eye(4,4,-1,dtype=int))#生成4行4列，主对角线向下偏移一行为1
'''
[[0 0 0 0]
 [1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]]
'''

五、从已知数据创建

'''
函数中创建 ndarray。NumPy 提供了下面 5 个方法：

frombuffer（buffer）：将缓冲区转换为 1 维数组。
fromfile（file，dtype，count，sep）：从文本或二进制文件中构建多维数组。
fromfunction（function，shape）：通过函数返回值来创建多维数组。
fromiter（iterable，dtype，count）：从可迭代对象创建 1 维数组。
fromstring（string，dtype，count，sep）：从字符串中创建 1 维数组。
'''



import numpy as np

#创建一个5行4列
data = np.fromfunction(lambda a, b: a + b, (5, 4))
print(data)
'''
[[0. 1. 2. 3.]
 [1. 2. 3. 4.]
 [2. 3. 4. 5.]
 [3. 4. 5. 6.]
 [4. 5. 6. 7.]]
'''

数组属性：

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# TODO 1 查看a的值
print(a)  
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''
#TODO  2 查看a的转置
print(a.T)  
'''
[[1 4 7]
 [2 5 8]
 [3 6 9]]
'''
#TODO 3 # 查看a的数据类型
print(a.dtype)  
'''int32'''
#TODO 4 # 用来输出数组包含元素的实部。
print(a.real)  
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''
#TODO 5 # 用来输出数组包含元素的虚部。
print(a.imag)  
'''
[[0 0 0]
 [0 0 0]
 [0 0 0]]
'''
#TODO 6 # 用来输出数组中的总包含元素数。 
print(a.size)  
'''9'''
#TODO 7 # itemsize输出一个数组元素的字节数。
print(a.itemsize)  
'''4  '''
#TODO 8 # nbytes用来输出数组的元素总字节数。
print(a.nbytes)  
'''36'''
#TODO 9 strides用来遍历数组时，输出每个维度中步进的字节数组。
print(a.strides)  
'''(12, 4)'''
#TODO 10 用来输出数组维度
print(a.ndim)  
'''2'''
#TODO 11 shape用来输出数组形状(行数，列数)
print(a.shape)  
'''(3, 3)'''

六、数组操作

改变形状

import numpy as np

'''reshape 可以在不改变数组数据的同时，改变数组的形状,numpy.reshape(a, newshape)'''

print(np.arange(10).reshape((5, 2)))# 对生成的一维数组改变形状为5行2列

注意：

1.reshape 在改变形状时，不会影响原数组，相当于对原数组做了一份拷贝。

2.resize 则是对原数组执行操作。

数组展开

import numpy as np
# TODO 1 
'''扁平化
ravel 的目的是将任意形状的数组扁平化，变为 1 维数组，
numpy.ravel(a, order='C')
'''

a = np.arange(10).reshape((2, 5))
print(a)
'''
[[0 1 2 3 4]
 [5 6 7 8 9]]
'''
#TODO 2 order 表示变换时的读取顺序，默认是按照行依次读取，当 order='F' 时，可以按列依次读取排序。
# 默认按行读取，转换为一维数组
print(np.ravel(a))
'''[0 1 2 3 4 5 6 7 8 9]'''
#指定按列读取，转换为一维数组
print(np.ravel(a,order='F'))
'''[0 5 1 6 2 7 3 8 4 9]'''

轴移动

轴移动，moveaxis 可以将数组的轴移动到新的位置。
其方法如下：numpy.moveaxis(a, source, destination)
a：数组。
source：要移动的轴的原始位置。
destination：要移动的轴的目标位置。



import numpy as np
a = np.arange(10).reshape((1,2, 5))
print(a.shape, np.moveaxis(a, 0, -1).shape)
'''(1, 2, 5) (2, 5, 1)'''
#将0列对应的1，迁移到最后一位，其他默认向前移动一位，这就是轴移动

轴交换

轴交换，swapaxes 可以用来交换数组的轴。
其方法如下：numpy.swapaxes(a, axis1, axis2)
a：数组。
axis1：需要交换的轴 1 位置。
axis2：需要与轴 1 交换位置的轴 1 位置。


import numpy as np
a = np.arange(10).reshape((1,2, 5))
print(a.shape, np.swapaxes(a, 0, 2).shape)  
'''(1, 2, 5) (5, 2, 1)'''
#将0对应的1，与2对应的5，进行轴交换

数组转置

transpose 类似于矩阵的转置，它可以将 2 维数组的横轴和纵轴交换。
numpy.transpose(a, axes=None)
a：数组。
axis：该值默认为 none，表示转置。如果有值，那么则按照值替换轴。


import numpy as np
a = np.arange(4).reshape(2, 2)
print(a)
'''
[[0 1]
 [2 3]]
'''
print(np.transpose(a)) #转置
'''
[[0 2]
 [1 3]]
'''
print(a.T) #转置，作用等同上面
'''
[[0 2]
 [1 3]]
'''

维度改变

import numpy as np
'''
维度改变，atleast_xd 支持将输入数据直接视为 x维。
这里的 x 可以表示：1，2，3。方法分别为：
numpy.atleast_1d()
numpy.atleast_2d()
numpy.atleast_3d()
'''
print(np.atleast_1d([1, 2, 3])) #数据直接视为1维度
'''[1 2 3]'''
print(np.atleast_2d([4, 5, 6])) #数据直接视为2维度
'''[[4 5 6]]'''
print(np.atleast_3d([7, 8, 9])) #数据直接视为3维度
'''[[[7]
  [8]
  [9]]]'''

类型转换

'''
在 NumPy 中，还有一系列以 as 开头的方法，它们可以将特定输入转换为数组，
亦可将数组转换为矩阵、标量，ndarray 等。如下：
asarray(a，dtype，order)：将特定输入转换为数组。
asanyarray(a，dtype，order)：将特定输入转换为 ndarray。
asmatrix(data，dtype)：将特定输入转换为矩阵。
asfarray(a，dtype)：将特定输入转换为 float 类型的数组。
asarray_chkfinite(a，dtype，order)：将特定输入转换为数组，检查 NaN 或 infs。
asscalar(a)：将大小为 1 的数组转换为标量。
'''

import numpy as np

a = np.arange(6).reshape(2, 3)

print(np.asarray(a))  # 将特定输入转换为数组
'''
[[0 1 2]
 [3 4 5]]'''
print(np.asanyarray(a)) # 将特定输入转换为 ndarray。
'''
[[0 1 2]
 [3 4 5]]
'''
print(np.asmatrix(a))  # 将二维数组转化为矩阵类型
'''
[[0 1 2]
 [3 4 5]]
'''
print(np.asfarray(a))#：将特定输入转换为 float 类型的数组。
'''
[[0. 1. 2.]
 [3. 4. 5.]]'''
print(np.asarray_chkfinite(a)) #将特定输入转换为数组，检查 NaN 或 infs。
'''
[[0 1 2]
 [3 4 5]]'''

数组连接

concatenate 可以将多个数组沿指定轴连接在一起。其方法为：
numpy.concatenate((a1, a2, ...), axis=0)
其中：
(a1, a2, ...)：需要连接的数组。
axis：指定连接轴。

注意：按行连接，行数必须相同，按列连接，列数必须相同

数组堆叠

'''
stack(arrays，axis)：按水平方向堆叠数组。
column_stack()：将 1 维数组作为列堆叠到 2 维数组中。
hstack()：按水平方向堆叠数组。
vstack()：按垂直方向堆叠数组。
dstack()：按深度方向堆叠数组。
'''

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print(np.stack((a, b)))#按水平方向堆叠数组
'''
[[1 2 3]
 [4 5 6]]
'''
print(np.stack((a, b), axis=-1))#横着堆叠
'''
[[1 4]
 [2 5]
 [3 6]]
'''
print(np.vstack((a, b)))#按垂直方向堆叠数组。
'''
[[1 2 3]
 [4 5 6]]'''
print(np.hstack((a, b)))#按水平方向堆叠数组
'''[1 2 3 4 5 6]'''
print(np.dstack((a, b))) #按深度方向堆叠数组。
'''
[[[1 4]
  [2 5]
  [3 6]]]'''
print(np.column_stack((a,b)))#将 1 维数组作为列堆叠到 2 维数组中
'''
[[1 4]
 [2 5]
 [3 6]]
'''

数组拆分

'''
split 及与之相似的一系列方法主要是用于数组的拆分，列举如下：
split(ary，indices_or_sections，axis)：将数组拆分为多个子数组。
dsplit(ary，indices_or_sections)：按深度方向将数组拆分成多个子数组。
hsplit(ary，indices_or_sections)：按水平方向将数组拆分成多个子数组。
vsplit(ary，indices_or_sections)：按垂直方向将数组拆分成多个子数组。
'''

import numpy as np

a = np.arange(10).reshape(5,2)
print(a)
'''
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]'''
print(np.split(a, 5))#按行拆分为5个
'''[array([[0, 1]]), array([[2, 3]]), array([[4, 5]]), array([[6, 7]]), array([[8, 9]])]'''
print(np.split(a, 2,axis=1))#按列拆分为2个
'''
[array([[0],
       [2],
       [4],
       [6],
       [8]]), array([[1],
       [3],
       [5],
       [7],
       [9]])]
'''

数组删除

'delete(arr，obj，axis)：沿特定轴删除数组中的子数组。'
arr:数组
obj：轴
axis:0行1列

import numpy as np
a = np.arange(12).reshape(3, 4)
print(a)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
print(np.delete(a, 2, 1))#删除第二列的数据
'''
[[ 0  1  3]
 [ 4  5  7]
 [ 8  9 11]]
'''
print(np.delete(a, 2, 0)) #删除第二行的数据
'''
[[0 1 2 3]
 [4 5 6 7]]
'''

数组插入

'insert(arr，obj，values，axis)：依据索引在特定轴之前插入值'

import numpy as np
a = np.arange(12).reshape(3, 4)
b = np.arange(4)
c= np.arange(3)
print(np.insert(a, 2, b, 0)) #将b按行插入到a索引为2的地方
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 0  1  2  3]
 [ 8  9 10 11]]
'''
print(np.insert(a, 2, c, 1)) #将c按列插入到a索引为2的地方
'''
[[ 0  1  0  2  3]
 [ 4  5  1  6  7]
 [ 8  9  2 10 11]]
'''

数组追加

'''append(arr，values，axis)：将值附加到数组的末尾，并返回 1 维数组。'''

import numpy as np
a = np.arange(6).reshape(2, 3)
b = np.arange(3)
#注意比较两者的区别
print(np.append(a, b))#注意：返回的是一维数据，a是二维，b是一维，但是返回的是一维
'''[0 1 2 3 4 5 0 1 2]'''
print(np.insert(a, 2, b, 0)) #将b按行插入到a索引为2的地方，即最后一行插入数据，追加到数组的末尾，不改变维度
'''
[[0 1 2]
 [3 4 5]
 [0 1 2]]
'''

数组翻转

'''
fliplr(m)：左右翻转数组。
flipud(m)：上下翻转数组。
'''

import numpy as np
a = np.arange(16).reshape(4, 4)
print(a) #原来的数组
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
'''
print(np.fliplr(a))#左右翻转的数组
'''
[[ 3  2  1  0]
 [ 7  6  5  4]
 [11 10  9  8]
 [15 14 13 12]]
'''
print(np.flipud(a))#上下翻转的数组
'''
[[12 13 14 15]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [ 0  1  2  3]]
'''

随机数据

随机数据

'''
numpy.random.rand(d0, d1, ..., dn) 方法的作用为：
指定一个数组，并使用 [0, 1) 区间随机数据填充，这些数据均匀分布'''

import numpy as np

#TODO 1 [0, 1) 区间随机生成一个指定维度数组

a=np.random.rand(2, 5) #生成一个2行5列的二维数组，值随机在[0, 1) 区间.值类型float64
print(a)
'''
[[0.69972014 0.75348206 0.83342597 0.30635227 0.5588981 ]
 [0.28818975 0.61550448 0.96397808 0.42668209 0.38289549]]
'''

'''numpy.random.randn(d0, d1, ..., dn),与上面作用相同，
区别在于randn是从标准正态分布中返回一个或多个样本值'''

import numpy as np
a=np.random.randn(1, 10)
print(a)
'''
[[-2.46704604e-01 -4.37358303e-01 -3.20202210e-01  6.49797726e-01
   2.28593375e-02 -8.74794120e-01 -1.71152455e+00 -3.50333458e-01
   9.52973951e-04 -5.16972677e-01]]
'''

随机整数

'''randint(low, high, size, dtype) 方法将会生成 [low, high) 的随机整数。
注意这是一个半开半闭区间。
特点：随机整数，指定区间，指定个数，一维数组
'''

随机浮点数
'''random_sample(size) 方法将会在 [0, 1) 区间内生成指定 size 的随机浮点数。
特点：随机浮点数，限定区间[0, 1)，指定个数，一维数组
'''
与 numpy.random.random_sample 类似的方法还有：
numpy.random.random([size])
numpy.random.ranf([size])
numpy.random.sample([size])
'''

随机取样
'''choice(a, size, replace, p) 方法将会给定的数组里随机抽取几个值，该方法类似于随机抽样
a:数组矩阵，单个数字时,比如k，则为【x for x in range(k)】
size：输出数组中的个数，默认1
replace：布尔类型，输出的元素是否可重复，默认True
p:每个数字输出的概率，加起来必须等于1，默认None
'''

import numpy as np
print(np.random.choice(10, 8)) #区间【0,10）中随机返回8个元素，可重复。一维数组.
'''[5 5 9 8 3 6 2 3]'''
print(np.random.choice(10, 8,replace=False)) #区间【0,10）中随机返回5个不重复的元素，一维数组
'''[6 3 2 0 9 4 7 8]'''
aa_milne_arr=[1,2,3,4,]
#从指定数组，返回指定个数的元素，注意出现频率需要与指定数组一一对应，频率加起来必须为1
print(np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3]))
'''[1 4 1 1 2]'''

概率密度分布：

'''
NumPy 还提供了大量的满足特定概率密度分布的样本生成方法。它们的使用方法和上面非常相似，这里就
numpy.random.beta(a，b，size)：从 Beta 分布中生成随机数。
numpy.random.binomial(n, p, size)：从二项分布中生成随机数。
numpy.random.chisquare(df，size)：从卡方分布中生成随机数。
numpy.random.dirichlet(alpha，size)：从 Dirichlet 分布中生成随机数。
numpy.random.exponential(scale，size)：从指数分布中生成随机数。
numpy.random.f(dfnum，dfden，size)：从 F 分布中生成随机数。
numpy.random.gamma(shape，scale，size)：从 Gamma 分布中生成随机数。
numpy.random.geometric(p，size)：从几何分布中生成随机数。
numpy.random.gumbel(loc，scale，size)：从 Gumbel 分布中生成随机数。
numpy.random.hypergeometric(ngood, nbad, nsample, size)：从超几何分布中生成随机数。
numpy.random.laplace(loc，scale，size)：从拉普拉斯双指数分布中生成随机数。
numpy.random.logistic(loc，scale，size)：从逻辑分布中生成随机数。
numpy.random.lognormal(mean，sigma，size)：从对数正态分布中生成随机数。
numpy.random.logseries(p，size)：从对数系列分布中生成随机数。
numpy.random.multinomial(n，pvals，size)：从多项分布中生成随机数。
numpy.random.multivariate_normal(mean, cov, size)：从多变量正态分布绘制随机样本。
numpy.random.negative_binomial(n, p, size)：从负二项分布中生成随机数。
numpy.random.noncentral_chisquare(df，nonc，size)：从非中心卡方分布中生成随机数。
numpy.random.noncentral_f(dfnum, dfden, nonc, size)：从非中心 F 分布中抽取样本。
numpy.random.normal(loc，scale，size)：从正态分布绘制随机样本。
numpy.random.pareto(a，size)：从具有指定形状的 Pareto II 或 Lomax 分布中生成随机数。
numpy.random.poisson(lam，size)：从泊松分布中生成随机数。
numpy.random.power(a，size)：从具有正指数 a-1 的功率分布中在 0，1 中生成随机数。
numpy.random.rayleigh(scale，size)：从瑞利分布中生成随机数。
numpy.random.standard_cauchy(size)：从标准 Cauchy 分布中生成随机数。
numpy.random.standard_exponential(size)：从标准指数分布中生成随机数。
numpy.random.standard_gamma(shape，size)：从标准 Gamma 分布中生成随机数。
numpy.random.standard_normal(size)：从标准正态分布中生成随机数。
numpy.random.standard_t(df，size)：从具有 df 自由度的标准学生 t 分布中生成随机数。
numpy.random.triangular(left，mode，right，size)：从三角分布中生成随机数。
numpy.random.uniform(low，high，size)：从均匀分布中生成随机数。
numpy.random.vonmises(mu，kappa，size)：从 von Mises 分布中生成随机数。
numpy.random.wald(mean，scale，size)：从 Wald 或反高斯分布中生成随机数。
numpy.random.weibull(a，size)：从威布尔分布中生成随机数。
numpy.random.zipf(a，size)：从 Zipf 分布中生成随机数。
'''