第五节：numpy

　　Numpy是高性能科学计算和数据分析的基础包。Numpy本身并没有提供多么高级的数据分析功能，理解 Numpuy 数组以及面向数组的计算将有助于你提高处理数据能力。本节内容介绍ndarray数组和矩阵。

一、ndarray数组基础

　　使用 ndarray 数组，需要导入 Numpy 函数库。
　　导入方法1：直接导入该函数库：

In [2]:
from numpy import *

　　导入方法2：指定导入库的别名（在引入多个库的时候，推荐使用这个方法）。

In [3]:
import numpy as np

　　下面正式进入Numpy的数组世界。如果没有说明，所称数组均为 Numpy 数组对象，与 Python 的列表和 array模块无关。

1.1 创建数组

　　创建数组是进行数组计算的第一步，可以通过numpy库包内的array()函数定义数组实例对象，其参数为Python 的序列对象，如果想定义多维数组，则传递多层嵌套的序列。
　　例如下面这条语句定义了一个二维数组，其大小为（2,3），即有2行，3列。

In [3]:
a = np.array([[1,2,3.0],[2,3,4.0]])
print(a)

[[ 1.  2.  3.]
 [ 2.  3.  4.]]

　　以下三种操作，可以帮助我们查看数组的一些属性：
　　查看行数使用 ndim

In [4]:
a.ndim
Out[4]:
2

　　查看数组的维数使用shape，返回(n,m)， 其中 n 为行数，m 为列数。

In [5]:
a.shape
Out[5]:
(2, 3)

　　查看元素的类型使用dtype，比如 numpy.int32、numpy.float64

In [7]:
a.dtype
Out[7]:
dtype('float64')

1.2 特殊数组

　　Numpy的特殊数组主要有以下三种：

　　　zeros数组：全零数组，元素全为0；
　　　ones数组：全1数组，元素全为1;
　　　empty数组：空数组，元素全近似为0；

　　创建方法分别为：
　　zeros数组

In [8]:
np.zeros((2,5))
Out[8]:
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

　　ones数组

In [9]:
np.ones((6,7))
Out[9]:
array([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.]])

　　empty数组

In [10]:
np.empty((3,3))
Out[10]:
array([[  6.93055009e-310,   6.93055009e-310,   6.93055008e-310],
       [  6.93055008e-310,   6.93055008e-310,   6.93055009e-310],
       [  6.93055008e-310,   6.93055009e-310,   6.93055008e-310]])

1.3 序列数组

　　arange函数：属于Numpy 库，其参数依次为：开始值、结束值、步长。

In [11]:
np.arange(1,100,5)
Out[11]:
array([ 1,  6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81,
       86, 91, 96])

　　linspace 函数创建等差序列数组，其参数依次为：开始值、结束值、元素数量。

In [12]:
np.linspace(1,100,5)
Out[12]:
array([   1.  ,   25.75,   50.5 ,   75.25,  100.  ])

1.4 数组索引

　　Numpy 数组的每个元素、每行元素、每列元素都可以用索引访问。注意：索引是从 0 开始的。
　　其操作与列表基本相同，以下是三种操作方式。

In [14]:
a = np.array([[1,2,4.0],[3,6,9]])

　　1.取 a 的第一行元素

In [15]:
a[0]
Out[15]:
array([ 1.,  2.,  4.])

　　2.取 a 的第二列元素

In [16]:
a[:,1]
Out[16]:
array([ 2.,  6.])

　　3.取 a 的第一行的第三个元素

In [17]:
a[0,2]
Out[17]:
4.0

　　1.5 数组运算，以下介绍10种常用运算

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

　　1.加法运算

In [19]:
a + b
Out[19]:
array([ 5.,  7.,  9.])

　　2.减法运算

In [20]:
a - b
Out[20]:
array([-3., -3., -3.])

　　3.乘法运算

In [21]:
a * b
Out[21]:
array([  4.,  10.,  18.])

　　4.乘方运算：a的2次方

In [22]:
a ** 2
Out[22]:
array([1, 4, 9])

　　5.除法运算

In [23]:
a/b
Out[23]:
array([ 0.25,  0.4 ,  0.5 ])

　　6.数组点乘

In [24]:
np.dot(a,b)
Out[24]:
32.0

　　7.判断大小，返回 bool 值

In [25]:
a >= 2
Out[25]:
array([False,  True,  True], dtype=bool)

　　8.a中最大的元素

In [26]:
a.max()
Out[26]:
3

　　9.a中最小的元素

In [27]:
a.min()
Out[27]:
1

　　10.a的和

In [28]:
a.sum()
Out[28]:
6

1.6 数组拷贝

　　数组的拷贝分为浅拷贝和深拷贝两种，浅拷贝通过数组变量的复制完成，深拷贝使用数组对象的copy方法完成。
　　浅拷贝只拷贝数组的引用，如果对拷贝对象修改。原数组也将修改。
　　以下是浅拷贝的演示：

In [29]:
a = np.ones((2,3))
print(a)

[[ 1.  1.  1.]
 [ 1.  1.  1.]]

　　b 为 a 的浅拷贝

In [30]:
b = a
print(b)

[[ 1.  1.  1.]
 [ 1.  1.  1.]]

　　对 b 进行修改，a 也会被修改

In [31]:
b[1,2] = 9
print(a)

[[ 1.  1.  1.]
 [ 1.  1.  9.]]

　　以下是深拷贝的演示：
　　深拷贝会复制一份和原数组一样的数组，但他们在内存中是分开存放的，所以改变拷贝数组，原数组不会改变。

In [32]:
a = np.ones((2,3))
print(a)

[[ 1.  1.  1.]
 [ 1.  1.  1.]]
In [33]:
b = a.copy()
b[1,2] = 9
print(b)

[[ 1.  1.  1.]
 [ 1.  1.  9.]]
In [34]:
print(a)

[[ 1.  1.  1.]
 [ 1.  1.  1.]]

1.7 数组重塑、合并与拆分

　　1.一维数组转变成二维数组
　　通过reshape( )函数即可实现

In [6]:
data=np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [7]:
data.reshape((2,5))
Out[7]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

　　作为参数的形状的其中一维可以是-1，它表示该维度的大小由数据本身推断而来，因此上面代码等价于：

In [8]:
data.reshape((2,-1))
Out[8]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
In [9]:
data.reshape((-1,2))
Out[9]:
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

　　2.二维数组转换成一维数组
　　将多维数组转换成一维数组的运算通常称为扁平化（flattening）或散开（raveling）,因此有两个函数可供选择。两者功能是一致的。
　　ravel函数返回的是源数据的视图而不是副本，对其修改会影响源数组
　　flatte函数返回的是源数据的副本，对其修改不会影响源数组

In [35]:
data=np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
data=data.reshape((2,-1))
data
Out[35]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
In [36]:
data2=data.ravel()
data2[0]=10
data2
Out[36]:
array([10,  1,  2,  3,  4,  5,  6,  7,  8,  9])
In [37]:
data
Out[37]:
array([[10,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9]])
In [38]:
data=np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
data=data.reshape((2,-1))
data
Out[38]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
In [39]:
data2=data.flatten()
data2[0]=10
data2
Out[39]:
array([10,  1,  2,  3,  4,  5,  6,  7,  8,  9])
In [40]:
data
Out[40]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

　　3.数组的合并
　　numpy提供许多数组合并的方法，这里只介绍最为常用的一种，即concatenate方法

In [42]:
arr1 = np.array([[1,2,3], [4,5,6]])
print(arr1)
arr2 = np.array([[7,8,9], [10,11,12]])
print(arr2)
data = np.concatenate([arr1, arr2], axis=0) # axis参数指明合并的轴向，0表示按行，1表示按列
data

[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]
Out[42]:
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
In [43]:
arr1 = np.array([[1,2,3], [4,5,6]])
print(arr1)
arr2 = np.array([[7,8,9], [10,11,12]])
print(arr2)
data = np.concatenate([arr1, arr2], axis=1) # axis参数指明合并的轴向，0表示按行，1表示按列
data

[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]
Out[43]:
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])

　　4.数组的拆分
　　这里只介绍split函数

In [56]:
np.split(data, [1], axis=0)#data为拆分的数组，[1]为拆分的行号或列号，axis表明按列或者行进行拆分（默认为0，即按行拆分）
Out[56]:
[array([[1, 2, 3, 7, 8, 9]]), array([[ 4,  5,  6, 10, 11, 12]])]
In [57]:
np.split(data, [2], axis=1)#data为拆分的数组，[1]为拆分的行号或列号，axis表明按列或者行进行拆分（默认为0，即按行拆分）
Out[57]:
[array([[1, 2],
        [4, 5]]), array([[ 3,  7,  8,  9],
        [ 6, 10, 11, 12]])]
In [58]:
np.split(data, [2,4], axis=1)#data为拆分的数组，[1]为拆分的行号或列号，axis表明按列或者行进行拆分（默认为0，即按行拆分）
Out[58]:
[array([[1, 2],
        [4, 5]]), array([[ 3,  7],
        [ 6, 10]]), array([[ 8,  9],
        [11, 12]])]

二、矩阵

2.1 创建矩阵

　　Numpy的矩阵对象与数组对象相似，主要不同之处在于，矩阵对象的计算遵循矩阵数学运算规律。
　　矩阵使用 matrix 函数创建，以（2,2）大小的矩阵为例（2行2列），定义方法如下：

In [35]:
a = np.matrix([[1.0,2.0],[3.0,4.0]])
print(a)

[[ 1.  2.]
 [ 3.  4.]]

　　type函数可以查看a的类型

In [36]:
type(a)
Out[36]:
numpy.matrixlib.defmatrix.matrix

2.2 矩阵运算

　　矩阵的常用数学运算有转置、乘法、求逆等。分别一一实例讲述。
　　创建一个矩阵

In [37]:
b=np.matrix([[4.0,6.0],[2.0,8.0]])
print(b)

[[ 4.  6.]
 [ 2.  8.]]

　　1.转置操作

In [38]:
b.T
Out[38]:
matrix([[ 4.,  2.],
        [ 6.,  8.]])

　　2.矩阵乘法

In [39]:
c=np.matrix([[2.0,2.0],[2.0,2.0]])
b*c
Out[39]:
matrix([[ 20.,  20.],
        [ 20.,  20.]])

　　3.逆矩阵

In [40]:
b.I
Out[40]:
matrix([[ 0.4, -0.3],
        [-0.1,  0.2]])