数据分析与数据科学必备技能之——Numpy使用

Numpy基本用法汇总

近期对Python的常用数据局处理模块一些常用用法进项总结，方面以后工作学习查阅使用。

import numpy as np
from tqdm import tqdm_notebook
import math

1. Numpy常用函数

1.1 生成函数

生成函数	作用
np.array( x) np.array( x, dtype)	将输入数据转化为一个ndarray 将输入数据转化为一个类型为type的ndarray
np.asarray( array )	将输入数据转化为一个新的（copy）ndarray
np.ones( N ) np.ones( N, dtype) np.ones_like( ndarray )	生成一个N长度的一维全一ndarray 生成一个N长度类型是dtype的一维全一ndarray 生成一个形状与参数相同的全一ndarray
np.zeros( N) np.zeros( N, dtype) np.zeros_like(ndarray)	生成一个N长度的一维全零ndarray 生成一个N长度类型位dtype的一维全零ndarray 类似np.ones_like( ndarray )
np.empty( N ) np.empty( N, dtype) np.empty_like(ndarray)	生成一个N长度的未初始化一维ndarray 生成一个N长度类型是dtype的未初始化一维ndarray 类似np.ones_like( ndarray )
np.eye( N ) np.identity( N )	创建一个N * N的单位矩阵（对角线为1，其余为0）
np.arange( num) np.arange( begin, end) np.arange( begin, end, step)	生成一个从0到num-1步数为1的一维ndarray 生成一个从begin到end-1步数为1的一维ndarray 生成一个从begin到end-step的步数为step的一维ndarray
np.mershgrid(ndarray, ndarray,…)	生成一个ndarray * ndarray * …的多维ndarray
np.where(cond, ndarray1, ndarray2)	根据条件cond，选取ndarray1或者ndarray2，返回一个新的ndarray
np.in1d(ndarray, [x,y,…])	检查ndarray中的元素是否等于[x,y,…]中的一个，返回bool数组

# 生成函数例子
data=[1,7.5,3,54,5]
arr1=np.array([1,7.5,3,54,5])
arr2=np.array(data,dtype=np.int32)
np.asarray(data)
'1------------------------------------------------------------------------------------'
np.ones(10)
np.zeros((2,3))
np.empty((2,3),dtype=np.int32)
np.empty_like(arr2)
'2------------------------------------------------------------------------------------'
np.eye(2)
np.identity(3)
'3------------------------------------------------------------------------------------'
np.arange(10)
np.arange(2,10)
np.arange(1,10,2)
'4------------------------------------------------------------------------------------'
xarr=np.array([1.1,1.2,1.3,1.4,1.5])
yarr=np.array([2.1,2.2,2.3,2.4,2.5])
cond1=np.array([True,False,True,True,False])
cond2=np.array([True,False,True,False,True])
np.where(cond,xarr,yarr) # cond为true选择xarr否则选择yarr
np.where(cond1 & cond2,0,np.where(cond1,1,np.where(cond2,2,3))) # 简单实现for循环
'--------------------------------------------------------------'
arr3=np.random.randn(3,3)
np.where(arr3>0,2,-2) # 快速替换数组中不符合要求的元素
'5------------------------------------------------------------------------------------'
arr4=np.array([6,0,0,3,2,5,6])
np.in1d(arr4,[2,3,6])

array([ 1. ,  7.5,  3. , 54. ,  5. ])
'1------------------------------------------------------------------------------------'
array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

array([[0., 0., 0.],
       [0., 0., 0.]])
       
array([[ 539820088, 1819242592, 1836016761],
       [1617848673,  539831584, 2037149520]])
       
array([ 1,  7,  3, 54,  5])
'2------------------------------------------------------------------------------------'
array([[1., 0.],
       [0., 1.]])
       
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
'3------------------------------------------------------------------------------------'
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
array([2, 3, 4, 5, 6, 7, 8, 9])
array([1, 3, 5, 7, 9])
'4------------------------------------------------------------------------------------'
array([1.1, 2.2, 1.3, 1.4, 2.5])
array([0, 3, 0, 1, 2])
'--------------------------------------------------------------'
array([[-2,  2, -2],
       [-2, -2, -2],
       [-2,  2,  2]])
'5------------------------------------------------------------------------------------'
array([ True, False, False,  True,  True, False,  True])

1.2 矩阵函数

矩阵函数	说明
np.diag( ndarray)	以一维数组的形式返回方阵的对角线（或非对角线）元素
np.diag( [x,y,…])	将一维数组转化为方阵（非对角线元素为0）
np.dot(ndarray, ndarray)	矩阵乘法
np.trace( ndarray)	计算对角线元素的和

# 矩阵函数例子
arr5=np.ones((4,4))
np.diag(arr5)
np.diag(arr5[0])
np.dot(arr5[0],arr5[1]) # x.dot(y)
np.trace(arr5) # 对角线元素和

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

1.3 排序函数

排序函数	说明
np.sort( ndarray)	排序，返回副本
np.unique(ndarray)	返回ndarray中的元素，排除重复元素之后，并进行排序
np.intersect1d( ndarray1, ndarray2)	返回二者的交集并排序。
np.union1d( ndarray1, ndarray2)	返回二者的并集并排序。
np.setdiff1d( ndarray1, ndarray2)	返回二者的差。
np.setxor1d( ndarray1, ndarray2)	返回二者的对称差

# 排序函数例子
arr6=np.random.randn(4,4)
arr6[1]
arr6.sort(1) # 按第一行排序
large_arr=arr6[1]
large_arr
large_arr[int(0.25*len(large_arr))] #25%分位数
'------------------------------------------------------------------------------------'
name1=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
name2=np.array(['Bob','jou','rewq','thk','ghjk','cdse','Joe'])
np.unique(name1) 
np.intersect1d(name1,name2) # 交
np.union1d(name1,name2) # 并
np.setdiff1d(name1,name2) # 差
np.setxor1d(name1,name2)

array([ 2.07292296, -1.07581669, -1.18633297, -1.17428201])
array([-1.18633297, -1.17428201, -1.07581669,  2.07292296])
-1.1742820094251654
'------------------------------------------------------------------------------------'
array(['Bob', 'Joe', 'Will'], dtype='<U4')
array(['Bob', 'Joe'], dtype='<U4')
array(['Bob', 'Joe', 'Will', 'cdse', 'ghjk', 'jou', 'rewq', 'thk'],dtype='<U4')
array(['Will'], dtype='<U4')
array(['Will', 'cdse', 'ghjk', 'jou', 'rewq', 'thk'], dtype='<U4')

1.4 一元计算函数

一元计算函数	说明
np.abs(ndarray) np.fabs(ndarray)	计算绝对值 计算绝对值（非复数）
np.mean(ndarray)	求平均值
np.sqrt(ndarray)	计算x^0.5
np.square(ndarray)	计算x^2
np.exp(ndarray)	计算e^x
log、log10、log2、log1p	计算自然对数、底为10的log、底为2的log、底为(1+x)的log
np.sign(ndarray)	计算正负号：1（正）、0（0）、-1（负）
np.ceil(ndarray) np.floor(ndarray) np.rint(ndarray)	计算大于等于该值的最小整数 计算小于等于该值的最大整数 四舍五入到最近的整数，保留dtype
np.modf(ndarray)	将数组的小数和整数部分以两个独立的数组方式返回
np.isnan(ndarray)	返回一个判断是否是NaN的bool型数组
np.isfinite(ndarray) np.isinf(ndarray)	返回一个判断是否是有穷（非inf，非NaN）的bool型数组 返回一个判断是否是无穷的bool型数组
cos、cosh、sin、sinh、tan、tanh	普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函数和双曲型反三角函数
np.logical_not(ndarray)	计算各元素not x的真值，相当于-ndarray

1.5 多元计算函数

多元计算函数	说明
np.add(ndarray, ndarray) np.subtract(ndarray, ndarray) np.multiply(ndarray, ndarray) np.divide(ndarray, ndarray) np.floor_divide(ndarray, ndarray) np.power(ndarray, ndarray) np.mod(ndarray, ndarray)	相加 相减 乘法 除法 圆整除法（丢弃余数） 次方 求模
np.maximum(ndarray, ndarray) np.fmax(ndarray, ndarray) np.minimun(ndarray, ndarray) np.fmin(ndarray, ndarray)	求最大值 求最大值（忽略NaN） 求最小值 求最小值（忽略NaN）
np.copysign(ndarray, ndarray)	将参数2中的符号赋予参数1
np.greater(ndarray, ndarray) np.greater_equal(ndarray, ndarray) np.less(ndarray, ndarray) np.less_equal(ndarray, ndarray) np.equal(ndarray, ndarray) np.not_equal(ndarray, ndarray)	> >= < <= == !=
logical_and(ndarray, ndarray) logical_or(ndarray, ndarray) logical_xor(ndarray, ndarray)	& | ^
np.dot( ndarray, ndarray)	计算两个ndarray的矩阵内积
np.ix_([x,y,m,n],…)	生成一个索引器，用于Fancy indexing(花式索引)

1.6 文件读写

文件读写	说明
np.save(string, ndarray)	将ndarray保存到文件名为 [string].npy 的文件中（无压缩）
np.savez(string, a1=ndarray1, a2=ndarray2, …)	将所有的ndarray(数组以关键字参数传入)压缩保存到文件名为[string].npy的文件中
np.savetxt(sring, ndarray, fmt, newline=’\n’)	将ndarray写入文件，格式为fmt
np.load(string)	读取文件名string的文件内容并转化为ndarray对象（或字典对象）
np.loadtxt(string, delimiter)	读取文件名string的文件内容，以delimiter为分隔符转化为ndarray

# 文件的读写
np.save('some_array',arr)
np.load("some_array.npy")
np.savez('some_array.npz',a=arr1,b=arr2)\
np.savetxt('arrray_test.txt', ndarray, fmt, newline='\n')
np.loadtxt('arrray_test.txt', delimiter=',')

  File "<ipython-input-1-3be4bf726ff8>", line 4
    np.savez('some_array.npz',a=arr1,b=arr2)np.savetxt('arrray_test.txt', ndarray, fmt, newline='\n')
                                             ^
SyntaxError: invalid syntax

2. NumPy.ndarray函数和属性

2.1 ndarray基本属性

ndarray属性	说明
ndarray.ndim	获取ndarray的维数
ndarray.shape	获取ndarray各个维度的长度
ndarray.dtype	获取ndarray中元素的数据类型
ndarray.T	简单转置矩阵ndarray

# ndarray属性
arr_01=np.array([6,7.5,8.0,5])
arr_02=np.array([[1,2,3],[4,5,6]])
arr_01.shape
arr_02.ndim
arr_01.dtype
arr_02.dtype
arr_02.T

(4,)
2
dtype('float64')
dtype('int32')
array([[1, 4],
       [2, 5],
       [3, 6]])

2.2 ndarray函数

ndarray函数	说明
ndarray.astype(dtype)	转换类型，若转换失败则会出现TypeError
ndarray.copy()	复制一份ndarray(新的内存空间)
ndarray.reshape((N,M,…))	将ndarray转化为NM…的多维ndarray（非copy）
ndarray.transpose((xIndex,yIndex,…))	根据维索引xIndex,yIndex…进行矩阵转置，依赖于shape，不能用于一维矩阵（非copy）
ndarray.swapaxes(xIndex,yIndex)	交换维度（非copy）

# ndarray函数
int_array=np.arange(10)
float_arr=np.array([.22,.27,.357,.44],dtype=np.float)
int_array.astype(float_arr.dtype) # 等价于i nt_array.astype(np.float16)
'------------------------------------------------------------------------------------'
int_array[7:10].copy()
arr7=np.arange(15).reshape((3,5))
arr7
'------------------------------------------------------------------------------------'
arr8=np.arange(16).reshape((2,2,4))
arr8.transpose((1,0,2))
arr8.swapaxes(1,2)

array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

array([7, 8, 9])

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
       
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],
       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],
       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

2.3 ndarray计算函数

ndarray计算函数	说明
ndarray.mean( axis=0 )	求平均值
ndarray.sum( axis= 0)	求和
ndarray.cumsum( axis=0)	累加
ndarray.cumprod( axis=0)	累乘
ndarray.std()	方差
ndarray.var()	标准差
ndarray.max()	最大值
ndarray.min()	最小值
ndarray.argmax()	最大值索引
ndarray.argmin()	最小值索引
ndarray.any()	是否至少有一个True
ndarray.all()	是否全部为True
ndarray.dot( ndarray)	计算矩阵内积
排序函数	说明
ndarray.sort(axis=0)	排序，返回源数据

# ndarray计算函数
arr9=np.random.randn(10)
(arr9>0).sum(0)
bools=np.array([False,True,False,False])
bools.any()
bools.all()
(arr9>0).all()

8
True
False
False

2.4 ndarray索引/切片方式

ndarray索引/切片方式	说明
ndarray[n]	选取第n+1个元素
ndarray[n:m]	选取第n+1到第m个元素
ndarray[:]	选取全部元素
ndarray[n:]	选取第n+1到最后一个元素
ndarray[:n]	选取第0到第n个元素
ndarray[ bool_ndarray ] 注：bool_ndarray表示bool类型的ndarray	选取为true的元素
ndarray[[x,y,m,n]]…	选取顺序和序列为x、y、m、n的ndarray
ndarray[n,m] ndarray[n][m]	选取第n+1行第m+1个元素
ndarray[n,m,…] ndarray[n][m]…	选取n+1行m+1列…的元素
ndarray[:n,m:]	选取前n行第m+1个元素
ndarray[n,:m]	选取前n+1行第m个元素

# ndarray索引/切片方式
# 一维数组索引切片
arr_1=np.arange(10)
arr_1[5]
arr_1[5:8]
arr_1[6:]
arr_1[:6]
# 数组的切片是原始数组的视图，修改切片时会直接反映到原数组上
arr_1[5:8]=1234
arr_1

5
array([5, 6, 7])
array([6, 7, 8, 9])
array([0, 1, 2, 3, 4, 5])
array([   0,    1,    2,    3,    4, 1234, 1234, 1234,    8,    9])

# 高维数组索引/切片
arr3d=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
arr3d
arr3d[0] #一维
arr3d[0,1] #二维 （等价于 arr3d[0][1])
arr3d[0,1,0] #三维 (等价于 arr3d[0][1][0])
'------------------------------------------------------------------------------'
arr2d=np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d
arr2d[:0] #创建一个形状相同的空数组
arr2d[:2]
arr2d[2:]
arr2d[:2,1:]
arr2d[1,:2]
arr2d[2,:1]
arr2d[:,:1]

array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

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

4
'------------------------------------------------------------------------------'
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
       
array([], shape=(0, 3), dtype=int32)

array([[1, 2, 3],
       [4, 5, 6]])
       
array([[7, 8, 9]])

array([[2, 3],
       [5, 6]])
       
array([4, 5])

array([7])

array([[1],
       [4],
       [7]])

# 布尔型索引
names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
data=np.random.random((7,4))
data
data[names=='Bob']
data[names=='Bob',2:]
data[names=='Bob',3]
data[(names=='Bob')|(names=='Will')]
data[names!='Joe']=7
data

array([[0.33941649, 0.65116192, 0.93824344, 0.29002249],
       [0.50000329, 0.77587939, 0.21230807, 0.67183365],
       [0.77376553, 0.13012356, 0.87731599, 0.29837325],
       [0.45061448, 0.04886051, 0.47766973, 0.15143359],
       [0.89001235, 0.80974726, 0.83793562, 0.3681108 ],
       [0.07796115, 0.67935599, 0.47303493, 0.29083483],
       [0.5727589 , 0.99951767, 0.38358243, 0.17562358]])

array([[0.33941649, 0.65116192, 0.93824344, 0.29002249],
       [0.45061448, 0.04886051, 0.47766973, 0.15143359]])
       
array([[0.93824344, 0.29002249],
       [0.47766973, 0.15143359]])

array([0.29002249, 0.15143359])

array([[0.33941649, 0.65116192, 0.93824344, 0.29002249],
       [0.77376553, 0.13012356, 0.87731599, 0.29837325],
       [0.45061448, 0.04886051, 0.47766973, 0.15143359],
       [0.89001235, 0.80974726, 0.83793562, 0.3681108 ]])
       
array([[7.        , 7.        , 7.        , 7.        ],
       [0.50000329, 0.77587939, 0.21230807, 0.67183365],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [0.07796115, 0.67935599, 0.47303493, 0.29083483],
       [0.5727589 , 0.99951767, 0.38358243, 0.17562358]])

# 花式索引:利用整数数组进行索引,注意花式索引主要将数据复制到新数组中
arr_rand=np.arange(32).reshape((8,4))
arr_rand
arr_rand[[4,3,0,6]]
arr_rand[[-3,-2,-1]]
arr_rand[[1,5,7,2],[0,3,1,2]]
arr_rand[[1,5,7,2]][:,[0,3,1,2]]

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23],
       [24, 25, 26, 27],
       [28, 29, 30, 31]])
       
array([[16, 17, 18, 19],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3],
       [24, 25, 26, 27]])
       
array([[20, 21, 22, 23],
       [24, 25, 26, 27],
       [28, 29, 30, 31]])

array([ 4, 23, 29, 10])

array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

3. NumPy.linalg函数和属性

linalg常用函数	说明
det(ndarray)	计算矩阵列式
eig(ndarray)	计算方阵的本征值和本征向量
inv(ndarray)	计算方阵的逆
pinv(ndarray)	计算方阵的Moore-Penrose伪逆
qr(ndarray)	计算qr分解
svd(ndarray)	计算奇异值分解svd
solve(ndarray)	解线性方程组Ax = b，其中A为方阵
lstsq(ndarray)	计算Ax=b的最小二乘解

# linalg常用函数
from numpy.linalg import inv,qr
arr_2=np.random.randn(5,5)
mat=arr_2.T.dot(arr_2)
inv(mat)
np.dot(mat,inv(mat))
q,r=qr(mat)
r

array([[ 13.19309849,  15.91381116,  -7.92849995,   0.03240283,
          7.95812703],
       [ 15.91381116,  20.63945645, -10.28471394,   0.6433315 ,
         10.06083667],
       [ -7.92849995, -10.28471394,   5.50083846,  -0.50497575,
         -5.03177011],
       [  0.03240283,   0.6433315 ,  -0.50497575,   0.78857667,
          0.22696533],
       [  7.95812703,  10.06083667,  -5.03177011,   0.22696533,
          5.14118883]])

array([[ 1.00000000e+00, -9.67812736e-16, -1.58521508e-16,
         6.87561379e-17,  6.23597804e-16],
       [ 3.37437347e-15,  1.00000000e+00, -1.63031884e-15,
        -7.48522444e-17, -2.61201735e-15],
       [ 2.74752548e-16,  3.75390640e-16,  1.00000000e+00,
        -1.64732515e-16, -2.40076413e-15],
       [ 4.06258589e-16, -1.10719025e-15, -8.23857309e-16,
         1.00000000e+00,  1.51721137e-17],
       [ 8.36702060e-15,  7.71231580e-15,  1.15368089e-15,
         1.47154595e-16,  1.00000000e+00]])

array([[-2.64753712,  0.28199891, -1.04345279, -2.11285683,  2.70371879],
       [ 0.        , -2.73922778, -1.68841917,  0.17172664,  3.81727246],
       [ 0.        ,  0.        , -2.99587966, -1.39926627, -2.98090485],
       [ 0.        ,  0.        ,  0.        , -1.10278136,  0.05411648],
       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.06798565]])

4. NumPy.random函数

4.1 简单随机数

函数名称	函数功能	参数说明
seed([seed])	确定随机数生成器的种子(用来固定产生的随机数)	参数为整数或者矩阵
rand(d0, d1, …, dn)	产生均匀分布的随机数	dn为第n维数据的维度
randn(d0, d1, …, dn)	产生标准正态分布随机数	dn为第n维数据的维度
randint(low, high,[size], dtype)	产生随机整数	low：最小值；high：最大值；size：随机数个数，可以为元素或元祖或者列表
random_sample([size])	在[0,1）内产生随机数	size：随机数的shape，可以为元祖或者列表，[2,3]表示2维随机数，维度为（2,3）
random([size]) ranf([size]) sample([size]))	同random_sample([size])	同random_sample([size])
choice(a[, size, replace, p])	从a中随机选择指定数据	a：1维数组 size：返回数据形状
bytes(length)	返回随机位	length：位的长度

# 产生简单的随机数
np.random.rand(5) #产生均匀分布随机数
np.random.rand(2,3)
np.random.randn(2,3,3) #产生标准正态分布随机数
'------------------------------------------------------------------------------------'
np.random.randint(0,10,3) #产生随机整数
np.random.randint(0,10,[2,3]) # 等同于np.random.randint(0,10,(2,3))
'------------------------------------------------------------------------------------'
np.random.random(2) #在[0,1内产生随机浮点数  同random.sample([size])
np.random.random([2,3,2]) # np.random.random((2,3,2))
'------------------------------------------------------------------------------------'
np.random.choice(10)

array([0.49300199, 0.28382811, 0.39497916, 0.56358357, 0.82845075])

array([[0.02877944, 0.09308963, 0.07103157],
       [0.82166753, 0.27959221, 0.68625777]])
       
array([[[-0.12347604,  1.64825511,  1.83939757],
        [ 0.10642223,  0.34293218,  0.97889929],
        [-0.99124908, -1.22099218,  0.76242292]],

       [[-1.37767896,  0.65072998,  0.90617696],
        [-0.3083745 ,  0.21535154,  1.55380495],
        [ 0.14490808,  0.52077414,  0.37030239]]])
'------------------------------------------------------------------------------------'
array([6, 5, 3])

array([[7, 3, 7],
       [3, 5, 7]])
'------------------------------------------------------------------------------------'
array([0.59134056, 0.39870651])

array([[[0.34391511, 0.56989914],
        [0.11253822, 0.49433347],
        [0.54224279, 0.45493818]],

       [[0.02335448, 0.62995109],
        [0.92857198, 0.66588853],
        [0.96803092, 0.54617218]]])
'------------------------------------------------------------------------------------'
0

4.2 产生各种分布的随机数函数

函数名称	函数功能
beta(a, b[, size])	贝塔分布样本，在 [0, 1]内。
binomial(n, p[, size])	二项分布的样本。
chisquare(df[, size])	卡方分布样本。
dirichlet(alpha[, size])	狄利克雷分布样本。
exponential([scale, size])	指数分布
f(dfnum, dfden[, size])	F分布样本。
gamma(shape[, scale, size])	伽马分布
geometric(p[, size])	几何分布
gumbel([loc, scale, size])	耿贝尔分布。
hypergeometric(ngood, nbad, nsample[, size])	超几何分布样本。
laplace([loc, scale, size])	拉普拉斯或双指数分布样本
logistic([loc, scale, size])	Logistic分布样本
lognormal([mean, sigma, size])	对数正态分布
logseries(p[, size])	对数级数分布。
multinomial(n, pvals[, size])	多项分布
multivariate_normal(mean, cov[, size])	多元正态分布。
negative_binomial(n, p[, size])	负二项分布
noncentral_chisquare(df, nonc[, size])	非中心卡方分布
noncentral_f(dfnum, dfden, nonc[, size])	非中心F分布
normal([loc, scale, size])	正态(高斯)分布
pareto(a[, size])	帕累托（Lomax）分布
poisson([lam, size])	泊松分布
power(a[, size])	Draws samples in [0, 1] from a power distribution with positive exponent a - 1.
rayleigh([scale, size])	Rayleigh 分布
standard_cauchy([size])	标准柯西分布
standard_exponential([size])	标准的指数分布
standard_gamma(shape[, size])	标准伽马分布
standard_normal([size])	标准正态分布 (mean=0, stdev=1).
standard_t(df[, size])	Standard Student’s t distribution with df degrees of freedom.
triangular(left, mode, right[, size])	三角形分布
uniform([low, high, size])	均匀分布
vonmises(mu, kappa[, size])	von Mises分布
wald(mean, scale[, size])	瓦尔德（逆高斯）分布
weibull(a[, size])	Weibull 分布
zipf(a[, size])	齐普夫分布

4.3 随机排列

函数名称	函数功能	参数说明
permutation(x)	打乱并返回该对象（多维矩阵按照第一维打乱）	整数或者矩阵
shuffle(x)	打乱对象x（多维矩阵按照第一维打乱）	矩阵或者列表

# 随机排列
rand_arr=np.random.randint(1, 10, (3, 4))
rand_arr
rand_data=rand_arr.copy()
np.random.shuffle(rand_data)
rand_data

array([[6, 7, 5, 7],
       [3, 5, 3, 8],
       [8, 8, 3, 8]])
       
array([[8, 8, 3, 8],
       [3, 5, 3, 8],
       [6, 7, 5, 7]])

4.4 随机漫步

# 简单的随机漫步的例子
nsteps=1000
draws=np.random.randint(0,2,size=nsteps)
steps=np.where(draws>0,1,-1)
walk=steps.cumsum()
walk.shape
# walk
# walk.min()
# walk.max()

(1000,)

# 一次模拟多个随机漫步
msteps=5000
nsteps=1000
draws=np.random.randint(0,2,size=(msteps,nsteps))
steps=np.where(draws>0,1,-1)
walk=steps.cumsum(1)
walk.shape
'------------------------------------------------------------------------------'
hits30=(np.abs(walk)>=30).any(1)
hits30.shape
hits30.sum()
'------------------------------------------------------------------------------'
crossing_times=(np.abs(walk[hits30])>=30).argmax(1)
crossing_times.shape
crossing_times.mean()

(5000, 1000)
(5000,)
3370
(3370,)
508.3406528189911

Numpy使用方法介绍到此，后期若有更新及时补充，欢迎批评指正。