一、Numpy简介

Numpy是python的科学计算库，支持高级大量的维度数组与矩阵运算，此外有针对数组运算提供了大量的数学函数库。基本功能如下：
1、快速高效的多维数组对象ndarray；
2、用于对数组执行元素级计算以及直接对数组执行数学运算的函数；
3、用于读写硬盘上基于数组的数据集的工具；
4、线性代数运算、傅里叶变换，以及随机数生成；
5、用于将c、c++、Fortran代码集成到Python的工具；
6、除了为Python提供快速的数组处理能力，NumPy在数据分析方面还有另外一个主要作用，即作为在算法之间传递数据的容器。

二、Numpy基础

1、创建数组

首先来看一下numpy数组创建函数

类型	说明
array	将输入数据（列表、元组、数组或其他序列类型）转换为ndarray,要么推断出dtype,要么显示指定dtype。默认直接复制输入数据
asarray	将输入转换为darray，如果输入本身就是一个ndarray就不进行复制
arange	类似于内置的range，但返回一个ndarray而不是列表
ones，ones_like	根据指定形状和dtype创建一个全1数组。ones_like以另一个数组为参数，并根据其形状和dtype创建一个全1数组
zeros,zeros_like	类似于ones和ones_like，只不过产生的是全0数组而已
empty，empty_like	创建数组，只分配内容空间但不填充任何值
eye,identity	创建一个正方的N*N单位矩阵

Numpy的ndarray数组和标量之间的运算

1、不用编写循环即可对数据执行批量运算
2、大小相等的数组之间的任何算术运算都会将运算应用到元素级
3、数组与标量的算术运算也会将那个标量值传播到各个元素

一维数组

import numpy as np
arr = np.array([[1,3,4],[5,7,9]])

print (arr * arr)
#输出结果
[[ 1  9 16]
 [25 49 81]]

print(arr - arr)
#输出结果
[[0 0 0]
 [0 0 0]]

print(1/arr)
#输出结果
[[1.         0.33333333 0.25      ]
 [0.2        0.14285714 0.11111111]]

print(arr ** 0.5)
#输出结果
[[1.         1.73205081 2.        ]
 [2.23606798 2.64575131 3.        ]]

二维数组

arr=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])

print(arr[0])
#输出结果
[[1 2 3]
 [4 5 6]]

print(arr[1,0])
#输出结果
[7 8 9]

values=arr[0]
values
#赋值结果
array([[1, 2, 3],
       [4, 5, 6]])
#同上
values=arr[0].copy()
values
array([[1, 2, 3],
       [4, 5, 6]])

arr[0]=1
arr[0]
#将第一行全部赋值为1
#输出结果
array([[1, 1, 1],
       [1, 1, 1]])

arr[0]=values
arr[0]
#再赋值回来
array([[1, 2, 3],
       [4, 5, 6]])

2、数据切片

arr=np.array([1,2,3,4,5,6,7,8,9,10])#一维数组
arr[1:6]#前闭后开，下标为1-5的数据（下标从0开始）
#输出结果
array([2, 3, 4, 5, 6])

arr=np.array([[1,2,3],[4,5,6],[7,8,9]])#二维数组
arr[:2]#前两行
#输出结果
array([[1, 2, 3],
       [4, 5, 6]])

arr[:2,1:]#前两行的2、3两列
#输出结果
array([[2, 3],
       [5, 6]])

arr[:,:1]#打印第一列的所有元素
#输出结果
array([[1],
       [4],
       [7]])

arr[:2,1:]=0#前两行的第2、3列设置为0 
arr
#输出结果
array([[1, 0, 0],
       [4, 0, 0],
       [7, 8, 9]])

3、数据索引

Numpy的ndarray布尔型索引

1、布尔型数组的长度必须跟被索引的轴长度一致
2、可以将布尔型数组跟切片、整数（或整数序列）混合使用
例如

import numpy.random as np_random
name_arr = np.array(['Bob','Joe','Eill','Eill','Joe','Joe','Bob'])
rand_arr=np_random.randn(7,4)#随机7*4的数组
rand_arr
#输出结果
array([[ 0.52900587,  1.70244139, -1.35744235,  1.25015313],
       [ 0.23373258,  1.09742228, -1.00995459, -1.54458745],
       [-0.62998363,  0.11589576,  0.13457285,  0.31126254],
       [-1.01457169, -0.06292203, -0.67612224, -0.74714611],
       [-1.99870067,  1.53986087, -0.38757238, -1.08902317],
       [ 1.09207708, -0.64661848, -0.07324105,  0.32222022],
       [-1.2301582 ,  1.76768207, -1.09098274, -0.47474178]])

name_arr=='Bob'#返回布尔数组，元素等于‘Bob’为True,否则Faluse
#输出结果
array([ True, False, False, False, False, False,  True])

rand_arr[name_arr=='Bob']#利用布尔数组选择行，前提是长度必须等于数组行数
#输出结果（将符合条件的行输出）
array([[ 0.52900587,  1.70244139, -1.35744235,  1.25015313],
       [-1.2301582 ,  1.76768207, -1.09098274, -0.47474178]])

rand_arr[name_arr == 'Bob',:2]#增加限制打印列的范围
#输出结果
array([[ 0.52900587,  1.70244139],
       [-1.2301582 ,  1.76768207]])

rand_arr[~(name_arr == 'Bob')]#对布尔数组的内容取反
#输出结果
array([[ 0.23373258,  1.09742228, -1.00995459, -1.54458745],
       [-0.62998363,  0.11589576,  0.13457285,  0.31126254],
       [-1.01457169, -0.06292203, -0.67612224, -0.74714611],
       [-1.99870067,  1.53986087, -0.38757238, -1.08902317],
       [ 1.09207708, -0.64661848, -0.07324105,  0.32222022]])

mask_arr = (name_arr == 'Bob') | (name_arr == 'Eill')
rand_arr[mask_arr]
#输出结果
array([[ 0.52900587,  1.70244139, -1.35744235,  1.25015313],
       [-0.62998363,  0.11589576,  0.13457285,  0.31126254],
       [-1.01457169, -0.06292203, -0.67612224, -0.74714611],
       [-1.2301582 ,  1.76768207, -1.09098274, -0.47474178]])

rand_arr[name_arr !='Joe']=7
rand_arr
#输出结果
array([[ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 0.23373258,  1.09742228, -1.00995459, -1.54458745],
       [ 7.        ,  7.        ,  7.        ,  7.        ],
       [ 7.        ,  7.        ,  7.        ,  7.        ],
       [-1.99870067,  1.53986087, -0.38757238, -1.08902317],
       [ 1.09207708, -0.64661848, -0.07324105,  0.32222022],
       [ 7.        ,  7.        ,  7.        ,  7.        ]])

Numpy的ndarray花式索引

1、花式索引是一个NumPy术语，它指的是利用整数数组进行索引
2、一次传入多个索引数组会有一点特别。它返回的是一个一维数组，其中的元素对应各个索引元组

import numpy as np
arr=np.empty((8,4))#empty创建的数组中，包含的均是无意义的数值
arr
#输出结果
array([[6.23060065e-307, 8.90104239e-307, 1.89150801e-307,
        1.50202247e-307],
       [3.56043053e-307, 7.56595733e-307, 3.56043054e-307,
        7.56595733e-307],
       [1.00131040e-307, 8.34426464e-308, 6.23038675e-307,
        1.50201822e-307],
       [3.56043053e-307, 1.60219306e-306, 2.44763557e-307,
        1.69119330e-306],
       [4.22805115e-307, 3.22651328e-307, 3.11524091e-307,
        1.60219035e-306],
       [4.45063154e-308, 6.23039354e-307, 2.33422937e-312,
        2.67023123e-307],
       [1.61324985e-307, 3.22649121e-307, 5.34041153e-307,
        2.00264456e-307],
       [8.34427737e-308, 1.50198257e-307, 4.22786442e-307,
        2.00271247e-307]])

for i in range(8):
    arr[i]=i
arr
#输出结果
array([[0., 0., 0., 0.],
       [1., 1., 1., 1.],
       [2., 2., 2., 2.],
       [3., 3., 3., 3.],
       [4., 4., 4., 4.],
       [5., 5., 5., 5.],
       [6., 6., 6., 6.],
       [7., 7., 7., 7.]])

print(arr[[4,3,0,6]])
#输出结果
[[4. 4. 4. 4.]
 [3. 3. 3. 3.]
 [0. 0. 0. 0.]
 [6. 6. 6. 6.]]

print(arr[[-3,-5,-7]])
#输出结果
[[5. 5. 5. 5.]
 [3. 3. 3. 3.]
 [1. 1. 1. 1.]]

arr=np.arange(32).reshape((8,4))#依次生成32个自然数，并且以8行4列的数组形式显示:
arr
#输出结果
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]])

print(arr[[1,5,7,2],[0,3,1,2]])#自动匹配(1,0),(5,3),(7,1),(2,2)
#数据结果
[ 4 23 29 10]

print(arr[[1,5,7,2]][:,[0,3,1,2]])#1、5、7、2行的0、3、1、2列
#输出结果
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

print(arr[np.ix_([1,5,7,2],[0,3,1,2])])#可读性更好的写法
#能把两个一维数组 转换为 一个用于选取方形区域的索引器
#直接往np.ix_()里扔进两个一维数组[1,5,7,2]，[0,3,1,2]，就能先按我们要求选取行，再按顺序将列排序，跟上面得到的结果一样
#输出结果
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

4、NumPy的ndarray数组转置和轴对换

import numpy as np
import numpy.random as np_random
print ('转置矩阵')
arr=np.arange(15).reshape((3,5))#生成顺序数组，后整形为3行5列  
print (arr)
#输出结果
转置矩阵
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

print(arr.T)
#输出结果
[[ 0  5 10]
 [ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]]

print('转置矩阵做点积')
arr = np_random.randn(6,3)
print(arr)
#输出结果
[[ 0.86578763  0.645244   -0.49405087]
 [ 0.27238488 -0.40718433 -0.02145935]
 [-1.96089557 -0.06565915 -0.09322006]
 [ 0.73279045 -0.7511035   0.29078194]
 [ 2.18427138 -0.86903329  0.57696171]
 [-0.67968328  1.25416114 -0.05842028]]

print(np.dot(arr.T,arr))
#输出结果
转置矩阵做点积
[[10.43888587 -2.72455423  1.26223693]
 [-2.72455423  3.4787455  -1.0969994 ]
 [ 1.26223693 -1.0969994   0.67408863]]

print('高维矩阵转换')
arr=np.arange(16).reshape((2,2,4))
arr_copy=arr.copy()
print(arr)
#输出结果
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

print(arr[0])
#输出结果
[[0 1 2 3]
 [4 5 6 7]]

print(arr[0][0])
#输出结果
[0 1 2 3]

print(arr[0][0][1])
#输出结果
1

print(arr.transpose(1,0,2))#transpose的参数为坐标，现在传入为（1,0,2）代表a[x][y][z]=a[y][x][z]
#输出结果
[[[ 0  1  2  3]
  [ 8  9 10 11]]

 [[ 4  5  6  7]
  [12 13 14 15]]]

print(arr_copy)
#输出结果
print(arr_copy)
print(arr_copy)
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

print(arr_copy.transpose(0,2,1))
#输出结果
[[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]

 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]

5、NumPy的ndarray快速的元素级数组函数

一元函数

类型	说明
abs,fabs	计算整数，浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs
sqrt	计算各元素的平方根。相当于arr**0.5
sqare	计算各元素的平方。相当于arr**2
exp	计算各元素的e^x
log,log10,log2,log1p	分别为自然对数、底数为10的log、底数为2的log和log(1+x)
sign	计算各元素的正负号：1（正数）、0（零）、-1（负数）
ceil	计算各元素的ceiling值，即大于等于该值得最小整数
floor	计算各元素的floor值，即小于等于该值得最大整数
rint	将各元素值四舍五入到最接近的整数，保留dtype
modf	将数组的小数部分与整数部分以两个独立数组的形式返还
isnan	返回一个表示“哪些值是NaN(这不是一个数字)”的布尔型数组
isfinite,isinf	分别返回一个表示“哪些元素是有限的（非inf,非NaN）”或“哪些元素是无穷的”的布尔型数组
cos,cosh,sin,sinh,tan,tanh	普通型或双曲型三角函数
arccos,arccosh,arcsin,arcsinh,arctan,arctanh	反三角函数
logical_not	计算各元素not x的真值。相当于-arr

二元函数

类型	说明
add	将数组中对应的元素相加
subtract	从第一个数组中减去第二个数组中的元素
multiply	数组元素相乘
divide,floor_divide	除法或向下取整除法
power	对第一个数组中的元素A和第二个数组中对应位置的元素B，计算A^B
maximum，fmax	元素级的最大值计算。fmax将忽略NaN
minimum,fmin	元素级的最小值计算。fmin将忽略NaN
mod	元素级的求模计算
copysign	将第二个数组中的符号复制给第一个数组中的值
greater，greater_equal,less,less_equal,equal,not_equal	执行元素级的比较，最终产生布尔型数组
logical_and,logical_or,logical_xor	执行元素级的真值逻辑运算，最终产生布尔型数组

举例说明

import numpy as np
import numpy.random as np_random
print('求平方根')
arr=np.arange(10)
print(np.sqrt(arr))
#输出结果
求平方根
[0.         1.         1.41421356 1.73205081 2.        2.23606798   2.44948974   2.64575131   2.82842712   3.        ]

print('数组比较')
x=np_random.randn(8)#标准正态分布中返回一个或多个样本值,numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。
y=np_random.randn(8)
print(x)
print(y)
print (np.maximum(x,y))
#输出结果
数组比较
[ 9.52102078e-01 -5.50715978e-01 -2.88311757e-02 -6.73292894e-01
  1.49144587e+00 -4.29510384e-01 -4.29998122e-01 -1.36136122e-03]
[ 2.13373561  2.06364166  0.61558615 -0.59547026  1.31034061  0.17616641
  0.28403327 -0.26767038]
[ 2.13373561e+00  2.06364166e+00  6.15586151e-01 -5.95470255e-01
  1.49144587e+00  1.76166407e-01  2.84033273e-01 -1.36136122e-03]

print('使用modf函数把浮点数分解成整数和小数部分')
arr=np_random.randn(7) * 5 #统一乘5
print(np.modf(arr))
#输出结果
使用modf函数把浮点数分解成整数和小数部分
(array([-0.82838311, -0.71882546, -0.41527595, -0.21803734, -0.99155683,
        0.75074988, -0.35514585]), array([ -4.,  -1., -11.,  -3.,  -1.,   1.,  -3.]))

6、利用数组进行数据处理

NumPy数组使你可以将许多种数据处理任务表述为简洁的数组表达式（否则需要编写循环）。将数组表达式代替循环的做法，通常被称为矢量化。矢量化数组运算要比等价的纯Python方式快上一两个数量级

print('通过真值表选择元素')
x_arr=np.array([1.1,1.2,1.3,1.4,1.5])
y_arr=np.array([2.1,2.2,2.3,2.4,2.5])
cond=np.array([True,False,True,True,False])
result=[(x if c else y) for x,y,c in zip(x_arr,y_arr,cond)]
print(result)
#输出结果
通过真值表选择元素
[1.1, 2.2, 1.3, 1.4, 2.5]

print(np.where(cond,x_arr,y_arr))
#输出结果
[1.1 2.2 1.3 1.4 2.5]

arr=np_random.randn(4,4)
print(arr)
print(np.where(arr>0,2,-2))
print(np.where(arr >0,2,arr))
#输出结果
[[-1.17689271  1.22467723  0.43345675 -0.72233803]
 [-0.63662559  0.47394752 -0.78281055  0.7745087 ]
 [ 0.34016053  1.2149215  -0.44530653 -2.02560303]
 [ 0.42546874  1.21322415 -0.86223039  0.86367628]]
[[-2  2  2 -2]
 [-2  2 -2  2]
 [ 2  2 -2 -2]
 [ 2  2 -2  2]]
[[-1.17689271  2.          2.         -0.72233803]
 [-0.63662559  2.         -0.78281055  2.        ]
 [ 2.          2.         -0.44530653 -2.02560303]
 [ 2.          2.         -0.86223039  2.        ]]

cond_1=np.array([True,False,True,True,False])
cond_2=np.array([False,True,False,True,False])
# 传统代码
result=[]
for i in range(len(cond)):
    if cond_1[i] and cond_2[i]:  # 如果同时满足，就不在往下走
        result.append(0)
    elif cond_1[i]:
        result.append(1)
    elif cond_2[i]:
        result.append(2)
    else:
        result.append(3)
print(result)
#输出结果
[1, 2, 1, 0, 3]

result = np.where(cond_1 & cond_2,0,np.where(cond_1,1,np.where(cond_2,2,3)))
print(result)
[1 2 1 0 3]

7、利用数组进行数据处理——数学和统计方法

类型	说明
sum	对数组中全部或某轴向的元素求和。零长度的数组的sum为0
mean	算术平均数，零长度的数组的mean为NaN
std,var	分别为标准差和方差，自由度可调（默认为n）
min,max	最大值和最小值
argmin	分别为最大值和最小值的索引
cumsum	所有元素的累计和
cumprod	所有元素的累计积

import numpy as np
import numpy.random as np_random
print('求和，求平均')
arr=np.random.randn(5,4)
print(arr)
print(arr.mean())
print(arr.sum())
print(arr.mean(axis=1))#对每一行的元素求平均值
print(arr.sum(0))#对每一列元素求和，axis可以省略
#输出结果
求和，求平均
[[ 1.1920312   0.59548133 -1.69638354 -0.86765064]
 [ 0.48965205  1.21543697 -0.46861947  0.15786849]
 [ 0.46646589 -1.07657886  0.34960628 -0.64421778]
 [ 0.75182741  0.88173646 -2.1914321   0.53707905]
 [ 0.2316153   1.01686933  1.52000011 -2.31109877]]
0.00748443502551317
0.1496887005102634
[-0.19413041  0.34858451 -0.22618112 -0.0051973   0.11434649]
[ 3.13159185  2.63294523 -2.48682873 -3.12801965]

print('cumsum和cumprod函数演示')
arr=np.array([[0,1,2],[3,4,5],[6,7,8]])
print(arr.cumsum(0))# 按列求和
print(arr.cumprod(1))# 按行求积
print(arr.cumprod(0))# 按列求积
#输出结果
cumsum和cumprod函数演示
[[ 0  1  2]
 [ 3  5  7]
 [ 9 12 15]]
[[  0   0   0]
 [  3  12  60]
 [  6  42 336]]
[[ 0  1  2]
 [ 0  4 10]
 [ 0 28 80]]

print('对正数求和')
arr=np_random.randn(100)
print((arr > 0).sum())
#输出结果
对正数求和
42

print('对数组逻辑操作')
bools=np.array([False,False,True,False])
print(bools.any())# 有一个为True则返回True
print(bools.all())# 有一个为False则返回False
#输出结果
对数组逻辑操作
True
False

8、利用数组进行数据处理——排序

import numpy as np
import numpy.random as np_random
print('一维数组排序')
arr=np_random.randn(8)
arr.sort()
print(arr)
一维数组排序
[-1.93454221 -1.6182566  -0.77200267 -0.688614   -0.63448136 -0.6169222
 -0.18656019  0.26607257]

print('二维数组排序')
arr=np_random.randn(5,3)
arr.sort(1) # 对每一行元素做排序
print(arr)
#输出结果
二维数组排序
[[-0.25145057 -0.01089318  0.19817363]
 [-1.46680866  0.08178992  1.49258159]
 [ 0.65733633  1.59214515  2.81517738]
 [ 0.30385335  0.78703474  1.23996363]
 [-0.82907411 -0.32716698  2.83399797]]

print('找位置在5%的数字')
large_arr=np_random.randn(1000)
large_arr.sort()
print(large_arr[int(0.05 * len(large_arr))])
#输出结果
找位置在5%的数字
-1.6407082885132667

9、利用数组进行数据处理——去重以及其他集合运算

类型	说明
unique(x)	计算x中的唯一元素，并返回有序结果
intersect1d(x,y)	计算x和y的公共元素，并返回有序结果
union1d(x,y)	计算x和y的并集，并返回有序结果
in1d(x,y)	得到一个表述“x的元素是否包含于y”的布尔型数组
setdiff1d(x,y)	集合的差，即元素在x中且不在y中
setxor1d(x,y)	集合的异或，即存在于一个数组中但不同时存在于两个数组中的元素

例如

import numpy as np
import numpy.random as np_random
print('用unique函数去重')
names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
print(sorted(set(names))) #传统python做法
print(np.unique(names))
ints=np.array([3,3,3,2,2,1,1,4,4])
print(np.unique(ints))
#输出结果
用unique函数去重
['Bob', 'Joe', 'Will']
['Bob' 'Joe' 'Will']
[1 2 3 4]

print('查找数组元素是否在另一个数组')
values=np.array([6,0,0,3,2,5,6])
print(np.in1d(values,[2,3,6]))#中间的是数字1
#输出结果
查找数组元素是否在另一个数组
[ True False False  True  True False  True]

10、用于数组的文件的输入输出

NumPy能够读写磁盘上的文本数据或二进制数据
1、将数组以二进制格式保存到磁盘
np.save和np.load是读写磁盘数组数据的两个主要函数。默认情况下，数组使以未压缩的原始二进制格式保存在扩展名为.npy的文件中的。

arr=np.arange(10)
np.save('E:\some_array',arr)#如果文件路径末尾没有扩展名.npy，则该扩展名会被自动加上
np.load('E:\some_array.npy')
#输出结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

通过np.savez可以将多个数组保存到一个压缩文件中，将数组以关键字参数的形式传入即可：

# 数组可以用关键字参数，关键字可以做为加载字典的key，不写的话，key为数组名_索引号
np.savez('some_array_achive.zip',arr,arr)
#加载npz文件时，会得到一个类似字典的对象，该对象会对各个数组进行延迟加载
arch=np.load("some_array_achive.zip.npz")
arch['arr_0']
#输出结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.savez('some_array_archive.npz',a=arr,b=arr)
arch=np.load('some_array_archive.npz')
arch['b']
#输出结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

2、存取文本文件
函数为savetxt和loadtxt，delimiter用于指定分隔符。

arr=np.arange(15).reshape(3,5)
np.savetxt('E:\\number.txt',arr)#默认是以空格存储
np.loadtxt('E:\\number.txt',delimiter=' ')
#输出结果
array([[ 0.,  1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.,  9.],
       [10., 11., 12., 13., 14.]])


arr=np.arange(15).reshape(3,5)
np.savetxt('E:\\number.txt',arr,fmt="%d", delimiter=",")##改为保存为整数，以逗号分隔
np.loadtxt('E:\\number.txt',delimiter=',')#读入时也需要指定逗号分隔
#输出结果
array([[ 0.,  1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.,  9.],
       [10., 11., 12., 13., 14.]])

11、线性代数相关知识

1、常用的numpy.linalg函数

类型	说明
diag	以一维数组的形式返回方阵的对角线（或非对角线元素），或将一维数组转换为方阵（非对角线元素为0）
dot	矩阵乘法
trace	计算对角线元素的和
det	计算矩阵行列式
eig	计算方阵的特征值和特征向量
inv	计算方阵的逆
pinv	计算矩阵的Moore-Penrose伪逆
qr	计算QR分解
svd	计算奇异值分解
solve	解线性方程Ax=b,其中A为一个方阵
lstsq	计算Ax=b的最小二乘法

2、随机数生成

部分numpy.random函数

类型	说明
seed	确定随机数生成器的种子
permutation	返回一个序列的随机排列或返回一个随机排列的返回
shuffle	对一个序列就地随机乱序
rand	产生均匀分布的样本值
randint	从给定的上下限范围内随机选取整数
randn	产生正态分布（平均值为0，标准差为1）
binomial	产生二项分布的样本值
normal	产生正态（高斯）分布的样本值
beta	产生Beta分布的样本值
chisquare	产生卡方分布的样本值
gamma	产生Gamma分布的样本值
uniform	产生在[0,1]中均匀分布的样本值

举例说明一下：

import numpy as np
import numpy.random as np_random
from numpy.linalg import inv,qr #np.linalg.qr() 计算矩阵的QR分解。把矩阵A作为QR，q是正交的，r是上三角形。
print('矩阵乘法')
x=np.array([[1,2,3],[4,5,6]])
y=np.array([[6,23],[-1,7],[8,9]])
print(x.dot(y))
print(np.dot(x,np.ones(3)))
#输出结果
矩阵乘法
[[ 28  64]
 [ 67 181]]
[ 6. 15.]

print('矩阵求逆')
x=np_random.randn(5,5)
mat=x.T.dot(x)
print(mat)
print(inv(mat)) #矩阵求逆
#输出结果
矩阵求逆
[[ 1.98865642  0.87621711  0.50914973 -0.59201157  1.4962339 ]
 [ 0.87621711  3.21679405 -2.71081078 -2.47261804  3.30593938]
 [ 0.50914973 -2.71081078  3.95085603  1.98369356 -3.06847868]
 [-0.59201157 -2.47261804  1.98369356  2.28325811 -1.90019395]
 [ 1.4962339   3.30593938 -3.06847868 -1.90019395  5.32927538]]
[[ 2.51522146  0.5094521  -2.05939265  1.64310943 -1.62208792]
 [ 0.5094521   8.5351535   0.03408685  6.87711283 -2.96597858]
 [-2.05939265  0.03408685  2.30160136 -1.32271445  1.4106317 ]
 [ 1.64310943  6.87711283 -1.32271445  6.95687878 -3.00849462]
 [-1.62208792 -2.96597858  1.4106317  -3.00849462  2.22246694]]

print('矩阵消元')
print(mat)
q,r=qr(mat)
print(q)
print(r)
#输出结果
矩阵消元
[[ 1.98865642  0.87621711  0.50914973 -0.59201157  1.4962339 ]
 [ 0.87621711  3.21679405 -2.71081078 -2.47261804  3.30593938]
 [ 0.50914973 -2.71081078  3.95085603  1.98369356 -3.06847868]
 [-0.59201157 -2.47261804  1.98369356  2.28325811 -1.90019395]
 [ 1.4962339   3.30593938 -3.06847868 -1.90019395  5.32927538]]
[[-0.7227447   0.33998332  0.10879741  0.50419857 -0.30983603]
 [-0.3184468  -0.43592479 -0.4689645  -0.4094794  -0.56653343]
 [-0.18504216  0.69437513 -0.43057462 -0.47498117  0.26944565]
 [ 0.21515694  0.35644137  0.57379943 -0.40888083 -0.57465444]
 [-0.54378178 -0.29184524  0.5035823  -0.43048784  0.4245148 ]]
[[-2.75153372 -3.4857553   1.85957706  2.37275326 -4.8731658 ]
 [ 0.         -4.83286671  5.70077957  3.62243914 -5.29575305]
 [ 0.          0.         -0.78145947  0.59426082  1.52702576]
 [ 0.          0.          0.         -0.3437924  -0.65908086]
 [ 0.          0.          0.          0.          0.19101063]]

三、NumPy高级应用

1、数组重塑

import numpy as np
print('将一位数组转化为二维数组')
arr=np.arange(8)
print(arr)
print(arr.reshape((4,2)))
print(arr.reshape((4,2)).reshape((2,4)))  #支持链式操作
#输出结果
将一位数组转化为二维数组
[0 1 2 3 4 5 6 7]
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
[[0 1 2 3]
 [4 5 6 7]]

print('纬度大小自动推导')
arr=np.arange(15)
print(arr.reshape((5,-1)))
#输出结果
纬度大小自动推导
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]

print('获取维度信息并应用')
other_arr=np.ones((3,5))
print(other_arr.shape)
print(arr.reshape(other_arr.shape))
#输出结果
获取维度信息并应用
(3, 5)
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

print('高维数组拉平')
arr=np.arange(15).reshape((5,3))
print(arr.ravel())
#输出结果
高维数组拉平
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

2、数组的合并和拆分

数组连接函数

类型	说明
concatenate	最一般化的连接，沿一条轴连接一组数组
vstack,row_stack	以面向行的方式对数组进行堆叠（沿轴0）
hstack	以面向行的方式对数组进行堆叠（沿轴1）
column_stack	类似于hstack，但是会先将一维数组转换为二维列向量
dstack	以面向“深度”的方式对数组进行堆叠（沿轴2）
split	沿指定轴在指定的位置拆分数组
hsplit,vsplit,dsplit	split的便捷化函数，分别沿着轴0、轴1和轴2进行拆分