第四篇，数据分析之Numpy的使用方法其一

什么是numpy

numpy是python语言的一个第三方的库，应用于数据分析，实现多维数组与矩阵的高校运算，提供大量的数学函数，也是进入机器学习与人工智能等方面必不可少的需要掌握的技术。

安装numpy

本地安装：pip install numpy。
也可以网上安装具体就自己百度不多说。

numpy的使用方法

首先导入在python中导入模块：import numpy as np（这里的as表示的是重命名的意思）

创建一个数组

arrts = np.array([1,2,3],dtype=np.int)#定义他是一个整数类型,int64,int32,也可以定义float类型
print(arrts)

输出就是：[1 2 3]，这个输出的数字称为数组的元素。
输出的类型为：numpy.ndarray类型。

创建一个多维数组

arrts = np.array([[1,2,3],
                  [4,5,6]]) #这就是一个矩阵，外面用一个列表括起来
print(arrts.shape)#输出的第一个参数表示几行，第二个表示几列

输出结果：(2, 3),shape表示有几行几列

创建一个对角数组

a = np.eye(4,dtype=int)
print(a)

输出结果：

[[1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]

这里就简单介绍一下np.exe()不仅能够创建对角线元素为1的nxn的二维数组，还可以设置任何一个斜线方向为等效对角线。

a = np.eye(4,dtype=int,k=1)
print(a)

输出结果为:

[[0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]
 [0 0 0 0]]

创建一个等差或等比的数组

np.arange()是一个类似于python中的range()的函数，数组元素符合等差数列，就是后一个元素值与前一个元素值的差等于指定的步长值。

arrts = np.arange(10,20,2)#表示输出一个10-20之间取偶数
print(arrts)

输出结果为：[10 12 14 16 18]

arrts = np.linspace(10,20,5)#表示开始值是10结束值是20共有有5个数
print(arrts)

输出结果为：[10. 12.5 15. 17.5 20. ]
区别在于，arange方法原则为“前包括，后不包括”，而linspace是这个数列总共有的长度。

创建一个自定义数组

a_type = np.dtype([('book','S40'),('version',np.int)])
a = np.array(([(b"learn python",2),(b'learn Django',1)]),dtype=a_type)
print(a)

输出结果：

[(b'learn python', 2) (b'learn Django', 1)]

S40表示字符串长度为40，np.int就是整数类型，可以参照numpy内置数组元素类型。

数组的索引

通过索引来获取到数组的元素

arrts = np.array([[1,2,3],
                  [4,5,6]])
print(arrts)
print(arrts[1])#获取索引为1的行
print(arrts[1][1])#获取第一行第一列的值

运行结果为：

[[1 2 3]
 [4 5 6]]
[4 5 6]
5

也可以通过下标更改数组的元素：

arrts = np.array([[1,2,3],
                  [4,5,6]])
arrts[0][1] = 9
print(arrts) 

运行结果为：

[[1 9 3]
 [4 5 6]]

数组的切片

根据下标获取到数组中的一个或几个的元素：
一维数组的切片

arrts = np.arange(1,20)
print(arrts)
print(arrts[3:6]) #表示输出下标大于等于3小于6的元素
print(arrts[3:]) #表示输出下标大于等于3之后的所有元素
print(arrts[:3]) #表示输出下标小于3之前的所有元素

输出结果为：

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[4 5 6]
[ 4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[1 2 3]

多维数组的切片：

arrts = np.arange(2,14).reshape(3,4)
print(arrts)
print(arrts[1:3]) #表示在行上输出大于等于索引为1的行与小于索引为3的行之间的元素
print(arrts[1:3,1:3]) #表示先在行上切出一片,之后按照列的[1:3]的要求再次切分出来
print(arrts[:,2]) #表示获取第二列的元素
print(arrts[::2,::2]) #先根据行进行切片再通过列进行切片
print(arrts[:3,[0,3]]) #先根据行进行切片再通过列进行切片

运行结果：

[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]
[[ 6  7  8  9]
 [10 11 12 13]]
[[ 7  8]
 [11 12]]
 [ 4  8 12]
 [[ 2  4]
 [10 12]]
[[ 2  5]
 [ 6  9]
 [10 13]]

这里就可以总结出切片大致的两种方式：
一种是：先根据行进行切片得到的结果再通过列进行切片
二种是：对数组按照行跟列要求进行切片，将两者的交集作为最后的结果

数组的变换

将已有的数组按照要求改变形状不改变他的元素之后形成一个新的数组

一维数组转换为二维数组

arrts = np.arange(1,21)
print(arrts) 
arrts1 = np.arange(1,21).reshape((4,5))#按照4行5列的输出，不足或者少于则报错
print(arrts1)

输出结果：

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]

可以使用reshape的方法对原数组进行修改

arrts = np.arange(1,21)
print(arrts)
arrts2 = np.reshape(arrts,(4,5))
print(arrts2)

输出结果：

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]

将多维数组转换为一维数组：

arrts = np.arange(1,21)
arrts2 = np.reshape(arrts,(4,5))
print(arrts2)
arrts3 = np.ravel(arrts2)
print(arrts3)

输出结果为：

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]

数组的组合

水平组合

a = np.arange(9).reshape(3,3)
b = np.arange(12).reshape(3,4)
c = np.arange(15).reshape(3,5)
print(np.hstack((a,b)))

运行结果：

[[ 0  1  2  0  1  2  3]
 [ 3  4  5  4  5  6  7]
 [ 6  7  8  8  9 10 11]]

垂直组合

a = np.arange(9).reshape(3,3)
b = np.arange(12).reshape(3,4)
c = np.arange(15).reshape(3,5)
print(np.hstack((a,b)))
b2 = b.T #这个表示他之前的行变为列，列变为行
print(np.vstack((a,b2)))

运行结果：

[[ 0  1  2  0  1  2  3]
 [ 3  4  5  4  5  6  7]
 [ 6  7  8  8  9 10 11]]
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

其他组合

列组合与行组合

a = np.arange(5)
b = np.arange(5,10)
print(np.row_stack((a,b))) #
print(np.column_stack((a,b)))

运行结果：

[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]

上下合并与左右合并

a = np.array([1,1,1])
b = np.array([2,2,2])
c = np.vstack((a,b)) #表示两个矩阵上下合并
d = np.hstack((a,b))# 表示两个矩阵左右合并
print(c)
print(d)

运行结果：

[[1 1 1]
 [2 2 2]]
[1 1 1 2 2 2]

数组的分割

a = np.arange(12).reshape(3,4) #0-12，3行4列
print(a)
print(np.vsplit(a,3)) #切割三行
print(np.hsplit(a,2)) #切割两列

运行结果：

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

元素的加减乘除

元素加法

a = np.array([10,20,30,40])
b = np.arange(4)
c = a+b   #相加
d = a-b   #相减
e = a*b   #相乘
f = a/10  #相除
print(c)
print(d)
print(e)
print(f)

运行结果：

[10 21 32 43]
[10 19 28 37]
[  0  20  60 120]
[1. 2. 3. 4.]

元素的增删改

添加元素

a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9]])
c = np.append(a,b,axis=0) #按照行的方式进行添加
print(c)

运行结果:

[[1 2 3]
 [4 5 6]
 [7 8 9]]

修改元素：

d = np.append(a,b) #合并成一个一维数组
e = np.insert(d,1,100)
print(e)

运行结果：

[  1 100   2   3   4   5   6   7   8   9]

删除元素：

f = np.delete(a,1,axis=0) #按照行的方式进行删除
print(f)

运行结果：

[[1 2 3]]

额外：

如果两个数组的形状不同，则会报错，但有的情况除外，有的情况就是numpy将某个数组通过“广播”的方式进行临时转换，使得两个数组的形状符合。

a = np.array([[1,2,3],[4,5,6]])
n = np.arange(1,3).reshape((-1,1))
print(a+n)

比如上面这代码里面的n单独输出的话运行结果：

[[1]
 [2]]

但要是他们的行数相同，numpy会自动进行“广播”，使得a与n数组的形状一样再相加，相加后的结果如下：

[[2 3 4]
 [6 7 8]]