numpy 使用汇总

1. numpy简单介绍

numpy 是采用c语言编写，相对python自带的list数组,好处是采用的矩阵运算，速度快了好多。

原理：python中List数据存放在不连续的内存中，只是通过内存地址来获取每个值。numpy是寻找内存中一连串区域来存放。

2. numpy 创建ndarray数组函数

ndarray：N维数组对象（矩阵），所有元素必须是相同类型。
numpy创建ndarray的函数有

• array() 将输入数据(列表，元祖，数组或其他序列类型)转换为ndarray。要么推断出dtype, 要么显式指定dtype。默认直接复制数据

import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6]])
print('array')
# 输出结果
[[1 2 3]
 [4 5 6]]

• asarray() 将输入转换为ndarray，如果输入本身就是一个ndarray就不进行复制。

array = np.asarray([[1, 2, 3], [4, 5, 6]])
array1 = np.asarray(array)
print(array) 
print(array1)
# 输出结果都是
[[1 2 3]
 [4 5 6]]

• arange() 类似于内置的range， 但返回的是一个ndarray而不是列表。

print numpy.arange(6) # [0,1,2,3,4,5,] 开区间
print numpy.arange(0,6,2)  # [0, 2，4]

• ones()，ones_like() 根据指定的形状和dtype创建一个全1的数组。ones_like以另个一个数组为参数，并根据其形状和dtype创建一个全1数组

x = numpy.ones((2,3)) #创建一维长度为2，二维长度为3的二维1数组
a = np.array([[0, 1, 2], [1, 0, -1]])
y = np.ones_like(a)   #只是引用了a的shape, 再全部赋值成1
print(x) 
print(y)  
# 返回结果
[[1 1 1]
 [1 1 1]]

• zeros()，zeros_like() # 类似于ones和ones_like，只不过产生的全部是0的数组

• empty()，empty_like() # 创建新数组，只分配内存空间，但不填充任何值

x = np.empty((2, 3))
a = np.array([[0, 1, 2], [1, 0, -1]])
y = np.empty_like(a)
print(x)
print(y)
# 返回结果，因为只分配内存空间，里面的值是以前内存地址中的值
[[-2.31584178e+077 -1.29073997e-231 -2.31584178e+077]
 [ 1.73059936e-077  2.23626159e-314  4.17203585e-309]]

[[-3458764513820540928 -9223363261248861942                    3]
 [                   0                    0      844424930131968]]

• eye()， identity() 创建一个正方的N × N单位矩阵(对角线为1，其余为0)。也称为单位矩阵，是对角矩阵的一种。

a = np.eye(3)
print(a)
# 输出结果
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

b = np.identity(3)
print(b)
# 输出结果
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

其区别参考np.identity()/np.eye()区别

• linspace() linspace的功能最初是从MATLAB中学来的，用此来创建等差数列

a = np.linspace(1, 10)
b = np.linspace(1, 10, 10)
print(a)
print(b)
# 输出结果
[ 1.          1.18367347  1.36734694  1.55102041  1.73469388  1.91836735
  2.10204082  2.28571429  2.46938776  2.65306122  2.83673469  3.02040816
  3.20408163  3.3877551   3.57142857  3.75510204  3.93877551  4.12244898
  4.30612245  4.48979592  4.67346939  4.85714286  5.04081633  5.2244898
  5.40816327  5.59183673  5.7755102   5.95918367  6.14285714  6.32653061
  6.51020408  6.69387755  6.87755102  7.06122449  7.24489796  7.42857143
  7.6122449   7.79591837  7.97959184  8.16326531  8.34693878  8.53061224
  8.71428571  8.89795918  9.08163265  9.26530612  9.44897959  9.63265306
  9.81632653 10.        ]   # 50个
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

3. numpy ndarray 数组元素的类型

数据类型

print '生成指定元素类型的数组:设置dtype属性'
x = numpy.array([1,2.6,3],dtype = numpy.int64)
print x # 元素类型为int64
print x.dtype
x = numpy.array([1,2,3],dtype = numpy.float64)
print x # 元素类型为float64
print x.dtype

print '使用astype复制数组，并转换类型'
x = numpy.array([1,2.6,3],dtype = numpy.float64)
y = x.astype(numpy.int32)
print y # [1 2 3]
print x # [ 1.   2.6  3. ]
z = y.astype(numpy.float64)
print z # [ 1.  2.  3.]

print '将字符串元素转换为数值元素'
x = numpy.array(['1','2','3'],dtype = numpy.string_)
y = x.astype(numpy.int32)
print x # ['1' '2' '3']
print y # [1 2 3] 若转换失败会抛出异常

print '使用其他数组的数据类型作为参数'
x = numpy.array([ 1., 2.6,3. ],dtype = numpy.float32);
y = numpy.arange(3,dtype=numpy.int32);
print y # [0 1 2]
print y.astype(x.dtype) # [ 0.  1.  2.]

4. numpy ndarray 的属性

• ndmin 维度
• shape 行数和列数
• size 元素个数

print('number of dim:',array.ndim)  # 维度
# number of dim: 2

print('shape :',array.shape)    # 行数和列数
# shape : (2, 3)

print('size:',array.size)   # 元素个数
# size: 6

5. numpy ndarray 矢量化计算

矢量运算：相同大小的数组键间的运算应用在元素上
矢量和标量运算：“广播”— 将标量“广播”到各个元素

print 'ndarray数组与标量/数组的运算'
x = numpy.array([1,2,3]) 
print x*2 # [2 4 6]
print x>2 # [False False  True]
y = numpy.array([3,4,5])
print x+y # [4 6 8]
print x>y # [False False False]

6. numpy ndarray 数组的基本索引和切片

一维数组的索引：与Python的列表索引功能相似
多维数组的索引：

• arr[r1:r2, c1:c2]
• arr[1,1] 等价 arr[1][1]
• [:] 代表某个维度的数据

print 'ndarray的基本索引'
x = numpy.array([[1,2],[3,4],[5,6]])
print x[0] # [1,2]
print x[0][1] # 2,普通python数组的索引
print x[0,1] # 同x[0][1]，ndarray数组的索引

x = numpy.array([[[1, 2], [3,4]], [[5, 6], [7,8]]])
print x[0] # [[1 2],[3 4]]
y = x[0].copy() # 生成一个副本
z = x[0] # 未生成一个副本
print y #  [[1 2],[3 4]]
print y[0,0] # 1
y[0,0] = 0 
z[0,0] = -1
print y # [[0 2],[3 4]]
print x[0] # [[-1 2],[3 4]]
print z # [[-1 2],[3 4]]

print 'ndarray的切片'
x = numpy.array([1,2,3,4,5])
print x[1:3] # [2,3] 右边开区间
print x[:3] # [1,2,3] 左边默认为 0
print x[1:] # [2,3,4,5] 右边默认为元素个数
print x[0:4:2] # [1,3] 下标递增2

x = numpy.array([[1,2],[3,4],[5,6]])
print x[:2] # [[1 2],[3 4]]
print x[:2,:1] # [[1],[3]]
x[:2,:1] = 0 # 用标量赋值
print x # [[0,2],[0,4],[5,6]]
x[:2,:1] = [[8],[6]] # 用数组赋值
print x # [[8,2],[6,4],[5,6]]

7. ndarray 数组的布尔索引和花式索引

布尔索引：使用布尔数组作为索引。arr[condition]，condition为一个条件/多个条件组成的布尔数组。

print 'ndarray的布尔型索引'
x = numpy.array([3,2,3,1,3,0])
# 布尔型数组的长度必须跟被索引的轴长度一致
y = numpy.array([True,False,True,False,True,False]) 
print x[y] # [3,3,3] 
print x[y==False] # [2,1,0]
print x>=3 # [ True False  True False  True  False]
print x[~(x>=3)] # [2,1,0]
print (x==2)|(x==1) # [False  True False  True False False]
print x[(x==2)|(x==1)] # [2 1]
x[(x==2)|(x==1)] = 0
print x # [3 0 3 0 3 0]

花式索引：使用整型数组作为索引。

print 'ndarray的花式索引:使用整型数组作为索引'
x = numpy.array([1,2,3,4,5,6])
print x[[0,1,2]] # [1 2 3]
print x[[-1,-2,-3]] # [6,5,4]

x = numpy.array([[1,2],[3,4],[5,6]])
print x[[0,1]] # [[1,2],[3,4]]
print x[[0,1],[0,1]] # [1,4] 打印x[0][0]和x[1][1]
print x[[0,1]][:,[0,1]] # 打印01行的01列 [[1,2],[3,4]]

# 使用numpy.ix_()函数增强可读性
print x[numpy.ix_([0,1],[0,1])] #同上 打印01行的01列 [[1,2],[3,4]]
x[[0,1],[0,1]] = [0,0]
print x # [[0,2],[3,0],[5,6]]

8. ndarray 数组的转换和轴兑换

数组的转置/轴对换只会返回源数据的一个视图，不会对源数据进行修改。

print 'ndarray数组的转置和轴对换'
k = numpy.arange(9) #[0,1,....8]
m = k.reshape((3,3)) # 改变数组的shape复制生成2维的，每个维度长度为3的数组
print k # [0 1 2 3 4 5 6 7 8]
print m # [[0 1 2] [3 4 5] [6 7 8]]
# 转置(矩阵)数组：T属性 : mT[x][y] = m[y][x]
print m.T # [[0 3 6] [1 4 7] [2 5 8]]
# 计算矩阵的内积 xTx
print numpy.dot(m,m.T) # numpy.dot点乘
# 高维数组的轴对象
k = numpy.arange(8).reshape(2,2,2)
print k # [[[0 1],[2 3]],[[4 5],[6 7]]]
print k[1][0][0]
# 轴变换 transpose 参数:由轴编号组成的元组
m = k.transpose((1,0,2)) # m[y][x][z] = k[x][y][z]
print m # [[[0 1],[4 5]],[[2 3],[6 7]]]
print m[0][1][0]
# 轴交换 swapaxes (axes：轴)，参数:一对轴编号
m = k.swapaxes(0,1) # 将第一个轴和第二个轴交换 m[y][x][z] = k[x][y][z]
print m # [[[0 1],[4 5]],[[2 3],[6 7]]]
print m[0][1][0]
# 使用轴交换进行数组矩阵转置
m = numpy.arange(9).reshape((3,3))
print m # [[0 1 2] [3 4 5] [6 7 8]]
print m.swapaxes(1,0) # [[0 3 6] [1 4 7] [2 5 8]]

9. 通用函数

一元函数

• abs, fabs
  计算整数，浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs

• sqrt
  计算各元素的平方根。相当于arr**0.5

• square
  计算各元素的平方。相当于arr**2

• exp
  计算各元素的指数e**x

• log, log10, log2, log1p
  分别为自然对数(底数为e), 底数为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

print '一元ufunc示例'
x = numpy.arange(6)
print x # [0 1 2 3 4 5]
print numpy.square(x) # [ 0  1  4  9 16 25]
x = numpy.array([1.5,1.6,1.7,1.8])
y,z = numpy.modf(x)
print y # [ 0.5  0.6  0.7  0.8]
print z # [ 1.  1.  1.  1.]

二元数组函数

• 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
  执行元素级的真值逻辑运算。相当于运算符 & ，|，^

print '二元ufunc示例'
x = numpy.array([[1,4],[6,7]])
y = numpy.array([[2,3],[5,8]])
print numpy.maximum(x,y) # [[2,4],[6,8]]
print numpy.minimum(x,y) # [[1,3],[5,7]]

10. ndarray 数组的合并

• concatenate
  最一般化的连接，沿一条轴连接一组数组

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
C = np.concatenate((A,B,B,A),axis=0)

print(C)
"""
array([[1],
       [1],
       [1],
       [2],
       [2],
       [2],
       [2],
       [2],
       [2],
       [1],
       [1],
       [1]])
"""

D = np.concatenate((A,B,B,A),axis=1)

print(D)
"""
array([[1, 2, 2, 1],
       [1, 2, 2, 1],
       [1, 2, 2, 1]])
"""

• vstack, row_stack
  以面向行的方式对数组进行堆叠（沿轴0）

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
         
print(np.vstack((A,B)))    # vertical stack
"""
[[1,1,1]
 [2,2,2]]
"""

• hstack
  以面向行的方式对数组进行堆叠（沿轴1）

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
D = np.hstack((A,B))       # horizontal stack

print(D)
# [1,1,1,2,2,2]

print(A.shape,D.shape)
# (3,) (6,)

• column_stack
  类似于hstack,但是会先将一维数组转换为二维列向量

• dstack
  以面向“深度”的方式对数组进行堆叠（沿轴2）

• np.newaxis()
  说完了array的合并，我们稍稍提及一下前一节中转置操作，如果面对如同前文所述的A序列， 转置操作便很有可能无法对其进行转置（因为A并不是矩阵的属性），此时就需要我们借助其他的函数操作进行转置：

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
print(A[np.newaxis,:])
# [[1 1 1]]

print(A[np.newaxis,:].shape)
# (1,3)

print(A[:,np.newaxis])
"""
[[1]
[1]
[1]]
"""

print(A[:,np.newaxis].shape)
# (3,1)

此时我们便将具有3个元素的array转换为了1行3列以及3行1列的矩阵了。

import numpy as np
A = np.array([1,1,1])[:,np.newaxis]
B = np.array([2,2,2])[:,np.newaxis]
         
C = np.vstack((A,B))   # vertical stack
D = np.hstack((A,B))   # horizontal stack

print(D)
"""
[[1 2]
[1 2]
[1 2]]
"""

print(A.shape,D.shape)
# (3,1) (3,2)

11. ndarray 数组的分割

• split
  沿指定轴在指定的位置拆分数组

A = np.arange(12).reshape((3, 4))
print(A)
"""
array([[ 0,  1,  2,  3],
    [ 4,  5,  6,  7],
    [ 8,  9, 10, 11]])
"""

# 纵向分割
print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
        [4, 5],
        [8, 9]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11]])]
"""

#横向分割
print(np.split(A, 3, axis=0))

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

• hsplit, vsplit, dsplit
  split的便捷化函数，分别沿着轴0，轴1和轴2进行拆分

A = np.arange(12).reshape((3, 4))
print(A)
"""
array([[ 0,  1,  2,  3],
    [ 4,  5,  6,  7],
    [ 8,  9, 10, 11]])
"""
print(np.vsplit(A, 3)) #等于 print(np.split(A, 3, axis=0))

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


print(np.hsplit(A, 2)) #等于 print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11]])]
"""

12. numpy的where函数使用

np.where(condition, x, y)，第一个参数为一个布尔数组，第二个参数和第三个参数可以是标量也可以是数组。

print 'where函数的使用'
cond = numpy.array([True,False,True,False])
x = numpy.where(cond,-2,2)
print x # [-2  2 -2  2]
cond = numpy.array([1,2,3,4])
x = numpy.where(cond>2,-2,2)
print x # [ 2  2 -2 -2]
y1 = numpy.array([-1,-2,-3,-4])
y2 = numpy.array([1,2,3,4])
x = numpy.where(cond>2,y1,y2) # 长度须匹配
print x # [1,2,-3,-4]

print 'where函数的嵌套使用'
y1 = numpy.array([-1,-2,-3,-4,-5,-6])
y2 = numpy.array([1,2,3,4,5,6])
y3 = numpy.zeros(6)
cond = numpy.array([1,2,3,4,5,6])
x = numpy.where(cond>5,y3,numpy.where(cond>2,y1,y2))
print x # [ 1.  2. -3. -4. -5.  0.]

13. ndarray常用的统计方法

可以通过这些基本统计方法对整个数组/某个轴的数据进行统计计算

• sum
  对数组中全部或某轴向的元素求和。零长度的数组的sum为0

• mean
  算术平均数。零长度的数组的mean为NaN

• std, var
  分别是标准差和方差，自由度可调（默认为n）

• min, max
  最大值和最小值

• argmin, argmax
  分别为最大和最小元素的索引

• cumsum
  所有元素的累计和

• cumprod
  所有元素的累计积

print 'numpy的基本统计方法'
x = numpy.array([[1,2],[3,3],[1,2]]) #同一维度上的数组长度须一致
print x.mean() # 2
print x.mean(axis=1) # 对每一行的元素求平均
print x.mean(axis=0) # 对每一列的元素求平均
print x.sum() #同理 12
print x.sum(axis=1) # [3 6 3]
print x.max() # 3
print x.max(axis=1) # [2 3 2]
print x.cumsum() # [ 1  3  6  9 10 12]
print x.cumprod() # [ 1  2  6 18 18 36]

用于布尔数组的统计方法：

• sum : 统计数组/数组某一维度中的True的个数
• any： 统计数组/数组某一维度中是否存在一个/多个True
• all： 统计数组/数组某一维度中是否都是True

print '用于布尔数组的统计方法'
x = numpy.array([[True,False],[True,False]])
print x.sum() # 2
print x.sum(axis=1) # [1,1]
print x.any(axis=0) # [True,False]
print x.all(axis=1) # [False,False]

使用sort对数组/数组某一维度进行就地排序（会修改数组本身）

print '.sort的就地排序'
x = numpy.array([[1,6,2],[6,1,3],[1,5,2]])
x.sort(axis=1) 
print x # [[1 2 6] [1 3 6] [1 2 5]]
#非就地排序：numpy.sort()可产生数组的副本

14. ndarray数组的去重以及集合运算

• 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)
  集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素

print 'ndarray的唯一化和集合运算'
x = numpy.array([[1,6,2],[6,1,3],[1,5,2]])
print numpy.unique(x) # [1,2,3,5,6]
y = numpy.array([1,6,5])
print numpy.in1d(x,y) # [ True  True False  True  True False  True  True False]
print numpy.setdiff1d(x,y) # [2 3]
print numpy.intersect1d(x,y) # [1 5 6]

15. numpy中的线性代数

import numpy.linalg 模块。线性代数（linear algebra）

常用的numpy.linalg模块函数：

• diag
  以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线方阵元素为0）

• dot
  矩阵乘法

• trace
  计算对角线元素的和

• det
  计算矩阵行列式

• eig
  计算方阵的本征值和本征向量

• inv
  计算方阵的逆

• pinv
  计算矩阵的Moore-Penrose违逆

• qr
  计算QR分解

• svd
  计算奇异值分解

• solve
  解线性方程组Ax = b,其中A为一个方阵

• lstsq
  计算Ax=b 的最小二乘解

print '线性代数'
import numpy.linalg as nla
print '矩阵点乘'
x = numpy.array([[1,2],[3,4]])
y = numpy.array([[1,3],[2,4]])
print x.dot(y) # [[ 5 11][11 25]]
print numpy.dot(x,y) # # [[ 5 11][11 25]]
print '矩阵求逆'
x = numpy.array([[1,1],[1,2]])
y = nla.inv(x) # 矩阵求逆（若矩阵的逆存在）
print x.dot(y) # 单位矩阵 [[ 1.  0.][ 0.  1.]]
print nla.det(x) # 求行列式

16. numpy中的随机数生成

import numpy.random模块。

常用的numpy.random模块函数：

• seed
  确定随机数生成器的种子

• permutation
  返回一个序列的随机排列或返回一个随机排列的范围

• shuffle
  对一个序列就地随机排列

• rand
  产生均匀分布的样本值

• randint
  从给定的上下限范围内随机选取的整数

• randn
  产生正态分布（平均值为0， 标准差为1）的样本值，类似于MATLAB接口

• binomial
  产生二项分布的样本值

• normal
  产生正态（高斯）分布的样本值

• beta
  产生Beta分布的样本值

• chisquare
  产生卡方分布的样本值

• gamma
  产生gamma分布的样本值

• uniform
  产生在（0，1）中均匀分布的样本值

print 'numpy.random随机数生成'
import numpy.random as npr

x = npr.randint(0,2,size=100000) #抛硬币
print (x>0).sum() # 正面的结果
print npr.normal(size=(2,2)) #正态分布随机数数组 shape = (2,2)

17. ndarray数组重塑

print 'ndarray数组重塑'
x = numpy.arange(0,6) #[0 1 2 3 4]
print x #[0 1 2 3 4]
print x.reshape((2,3)) # [[0 1 2][3 4 5]]
print x #[0 1 2 3 4]
print x.reshape((2,3)).reshape((3,2)) # [[0 1][2 3][4 5]]

y = numpy.array([[1,1,1],[1,1,1]])
x = x.reshape(y.shape)
print x # [[0 1 2][3 4 5]]
print x.flatten() # [0 1 2 3 4 5]   # 从高维向低维铺开
x.flatten()[0] = -1 # flatten返回的是拷贝
print x # [[0 1 2][3 4 5]]

print x.ravel() # [0 1 2 3 4 5]
x.ravel()[0] = -1 # ravel返回的是视图（引用） 
print x # [[-1 1 2][3 4 5]]
print "维度大小自动推导"
arr = numpy.arange(15)
print arr.reshape((5, -1)) # 15 / 5 = 3

18. 数组的元素重复操作

print '数组的元素重复操作'
x = numpy.array([[1,2],[3,4]])
print x.repeat(2) # 按元素重复 [1 1 2 2 3 3 4 4]
print x.repeat(2,axis=0) # 按行重复 [[1 2][1 2][3 4][3 4]]
print x.repeat(2,axis=1) # 按列重复 [[1 1 2 2][3 3 4 4]]
x = numpy.array([1,2])
print numpy.tile(x,2) # tile瓦片：[1 2 1 2]
print numpy.tile(x, (2, 2))  # 指定从低维到高维依次复制的次数。 
# [[1 2 1 2][1 2 1 2]]

18. 性能优化

性能优化

参考文章
莫烦PYTHON
python之numpy的基本使用