前言
第一篇中说好了这个系列要勤更，但是这一篇还是拖得有点久，毕竟是工作之余的学习，各种事情都在耽误吧。上一篇有说到《Python从入门到实战》这本书，这段时间我已经读完了，里面更多的是Python的一些使用基础，如果这一主题的文章继续围绕这本书就不太合适了，我自己也想加快一下学习的速度，做一些更有价值的总结，所以从这一篇开始主要是围绕《利用Python进行数据分析（第二版）》这本书的笔记总结。
关于开发环境，上一篇中我说到了我是使用的PyCharm，不过在学习的过程中我还是不推荐直接使用IDE，所以这之后我的笔记都是使用的IPython或是Jupyter
notebook，写起来很方便。我是在MacBook Pro下写的，直接下载的Anaconda包，不需要做什么配置，简单便捷。
废话就不多说了，进入正题。
什么是NumPy？
NumPy（Numerical Python）是目前Python数值计算中最为重要的基础包，主要包含以下内容：
·高效多维数组ndarray，提供了基于数组的便捷算数操作以及灵活的广播功能；
·对所有数据进行快速的矩阵计算，而无需编写循环程序；
·对硬盘中数组数据进行读写的工具，并对内存映射文件进行操作；
·线性代数、随机数生成以及傅里叶变换功能；
·用于连接NumPy到C、C++和FORTRAN语言类库的C语言API。
这一大堆概念可能太过抽象，我们一步一步地来看。
多维数组对象ndarray
ndarray是NumPy的核心特征之一，它是Python中一个快速、灵活的大型数据容器。我们的很多计算都是在它的基础上进行的。那要怎么生成一个ndarray对象呢？最简单的方式就是使用array函数：
In [2]: import numpy as np
In [3]: data1 = [6, 7.5, 8, 0, 1]
In [4]: arr1 = np.array(data1)
In [5]: arr1
Out[5]: array([6. , 7.5, 8. , 0. , 1. ])
[/code]
可以看到调用array函数后产生的ndarray对象中的值都变成float类型了，这是因为ndarray是一个通用的多维同类数据容器，也就是说它包含的每一个元素均为相同类型，我们可以通过shape属性和dtype属性来分别查看ndarray对象的每一维度数量以及其数据类型：
```code
In [6]: arr1.shape
Out[6]: (5,)
In [7]: arr1.dtype
Out[7]: dtype('float64')
[/code]
可以看到arr1为一个一维数组，数据类型为float64。
array同样可以将嵌套的序列转换为ndarray：
```code
In [8]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [9]: arr2 = np.array(data2)
In [10]: arr2
Out[10]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [11]: arr2.shape
Out[11]: (2, 4)
In [12]: arr2.dtype
Out[12]: dtype('int64')
[/code]
data2中有两个等长的列表，在经过array函数转换后即可生成多维数组。除非我们显示地指定了生成数组的数据类型，否则array函数将会自动推断生成数据的类型。
```code
In [13]: arr3 = np.array(data1, 'int64')
In [14]: arr3
Out[14]: array([6, 7, 8, 0, 1])
[/code]
这样生成的ndarray中的数据类型就成了我们指定的int64了。
当然，你可能还有点好奇如果上面代码中的data2中的元素是两个不等长的列表的话，array函数的执行结果会是什么样子：
```code
In [2]: data3 = [[1, 2, 3], [4, 5, 6, 7]]
In [3]: arr3 = np.array(data3)
In [4]: arr3
Out[4]: array([list([1, 2, 3]), list([4, 5, 6, 7])], dtype=object)
In [5]: arr3.shape
Out[5]: (2,)
In [6]: arr3.dtype
Out[6]: dtype('O')
[/code]
可以看到，arr3会被赋值为一个一维数组，它有两个list类型的元素，这也很好理解。
除了array函数以外，我们还有很多别的方法创建ndarray对象。直接看代码吧：
```code
In [7]: np.zeros(10)
Out[7]: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [8]: np.zeros(10, 'int64')
Out[8]: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
In [11]: np.zeros((2, 3), 'int64')
Out[11]:
array([[0, 0, 0],
[0, 0, 0]])
In [12]: np.empty((2, 3), 'int64')
Out[12]:
array([[0, 0, 0],
[0, 0, 0]])
In [13]: np.arange(10)
Out[13]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
[/code]
zeros函数将会根据指定的大小和形状创建全0数组，empty函数也能实现，但是在书中特别标注了使用empty函数并不安全，因为有些时候它可能会返回未初始化的垃圾数值（具体是什么现象我也不知道，反正尽量别用这一函数就对了）。zeros函数和empty函数默认生成的数组数据类型都是float64，参数中可以指定数据类型，如以上代码中我指定了数据类型为int64。arange函数是Python内建函数range的数组版，关于range函数上一章我提到过，其返回值是一个可迭代的对象，np.arange其实相当于np.array(range())这样的用法。
当然还有一些其他生成多维数组的函数，在后面实际使用到时我们再聊。
# 聊聊dtype
上文中已经提到了dtype，可以简单地将其理解为ndarray的数据类型。书上有一段很拗口的解释，它是一个特殊的对象，它包含了ndarray需要为某一种数据类型所申明的内存块信息。这个解释虽然拗口但是并不难理解，之前我提到过，ndarray是一个多维同类数组容器，dtype就包含了它的数据类型的信息。
dtype是NumPy能与其他数据系统灵活交互的原因，其中的原理显得有些抽象了，这里就暂时略过。数据的dtype通常都是按照类型名+元素的位数的方式命名，如上文中出现的float64，其含义就是64位双精度浮点型数据。
我们可以使用astype方法来显示地转换ndarray对象的数据类型：
```code
In [4]: arr = np.array([1, 2, 3, 4, 5])
In [5]: arr.dtype
Out[5]: dtype('int64')
In [14]: float_arr = arr.astype(np.float64)
In [15]: float_arr.dtype
Out[15]: dtype('float64')
[/code]
# NumPy数组算数
ndarray有一个有趣的特性，我们可以称其为向量化，即无需遍历数组即可对数组进行各种算数操作。
```code
In [16]: arr = np.array([[1, 2, 3], [4, 5, 6]])
In [17]: arr
Out[17]:
array([[1, 2, 3],
[4, 5, 6]])
In [18]:
In [18]: arr * arr
Out[18]:
array([[ 1, 4, 9],
[16, 25, 36]])
In [19]: arr - arr
Out[19]:
array([[0, 0, 0],
[0, 0, 0]])
In [20]: 1 / arr
Out[20]:
array([[1. , 0.5 , 0.33333333],
[0.25 , 0.2 , 0.16666667]])
In [21]: arr * 0.5
Out[21]:
array([[0.5, 1. , 1.5],
[2. , 2.5, 3. ]])
In [22]: arr2 = np.array([[0, 2, 1], [3, 9, 6]])
In [24]: arr > arr2
Out[24]:
array([[ True, False, True],
[ True, False, False]])
[/code]
当然，这里我们讲到的只是对于相同尺寸的数组间的计算，至于不同尺寸的数组以后再聊（感兴趣的朋友可以自己去了解一下广播特性）。
# 基础索引与切片
一维数组索引和Python的列表类似，都可以通过索引和切片获得所需的元素，不过还是有些许差别：
```code
In [2]: arr = np.arange(10)
In [7]: arr[5:8] = 12
In [8]: arr
Out[8]: array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
[/code]
看到这段代码是不是有点惊讶？我们可以来对比一下Python的列表：
```code
In [9]: py_list = list(range(10))
In [14]: py_slice = py_list[5:8]
In [15]: py_slice
Out[15]: [5, 6, 7]
In [16]: py_slice[1] = 1
In [17]: py_slice
Out[17]: [5, 1, 7]
In [18]: py_list
Out[18]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[/code]
我们可以看到，在Python的内建列表中，切片是对于原列表的一段复制，对其值进行改变的话并不会影响到原列表；而在NumPy中，一个数组的切片相当于这个数组的一段视图，修改这段切片的值也会导致原数组的这一段值被修改——这意味着原数组并不是被复制了。
对于这一点，如果你熟悉其他的编程语言的话可能会有所疑惑，在其他语言的使用场景中，切片操作都是希望尽量不影响到原数组的，可是在NumPy中不一样，因为NumPy被设计出来的初衷便是处理非常大的数组，想想看，对于庞大的数组持续复制将会引起多少内存问题。当然了，如果你一定想要一段切片的拷贝的话，可以通过copy函数。
对于多维数组的索引也很好理解，其中的元素需要一级一级地去取，我们以一个2*2*3的数组为例：array([[[1, 2, 3], [4, 5, 6]],
[[7, 8, 9], [10 ,11, 12]]])，如果我想取出“2”这个值该怎么办？
```code
In [19]: arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10 ,11, 12]]])
In [20]: arr3d
Out[20]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [21]: arr3d[0, 0, 1]
Out[21]: 2
[/code]
很简单吧？只需要用逗号分隔每一级的索引就OK了。对于多维数组还有一点挺有趣的：
```code
In [20]: arr3d
Out[20]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [21]: arr3d[0, 0, 1]
Out[21]: 2
In [22]: arr3d
Out[22]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [23]: old_values = arr3d[0].copy()
In [24]: arr3d[0] = 12
In [25]: arr3d
Out[25]:
array([[[12, 12, 12],
[12, 12, 12]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [26]: arr3d[0] = old_values
In [27]: arr3d
Out[27]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
[/code]
无论是传入标量或者数组，都可以为arr3d[0]赋值。
多维数组的切片或许会有点绕，我们还是看arr3d吧：
```code
In [28]: arr3d
Out[28]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [29]: arr3d[: 1]
Out[29]:
array([[[1, 2, 3],
[4, 5, 6]]])
In [30]: arr3d[:1, 1:3]
Out[30]: array([[[4, 5, 6]]])
In [31]: arr3d[:1, 1:2]
Out[31]: array([[[4, 5, 6]]])
In [32]: arr3d[:1, 1:2, 0:2]
Out[32]: array([[[4, 5]]])
[/code]
其实也很容易理解，对多维数组的切片也是一级一级地进行的，以逗号分开即可。
# 特殊的索引
接下来我们来看看NumPy中两种比较特殊的索引，分别是布尔索引和神奇索引，它们和其他语言中的列表索引操作可能有很大的区别，但是对于数据分析相当有用。
## 布尔索引
我来改编一下书中的例子，可能更容易理解。我们先假设现在有一组人名names，同时还有一组每个人名对应的信息data，这两个数组中的元素是一一对应的：
```code
In [34]: names
Out[34]: array(['Tom', 'Jack', 'Bob', 'Carl', 'Jack'], dtype='<U4')
In [35]: data = np.array([['Tall', 'Shy'], ['Handsome', 'Kind'], ['Popular', 'Cool'], ['Childish', 'Outstanding'], ['Erudite', 'Smart']])
In [36]: data
Out[36]:
array([['Tall', 'Shy'],
['Handsome', 'Kind'],
['Popular', 'Cool'],
['Childish', 'Outstanding'],
['Erudite', 'Smart']], dtype='<U11')
[/code]
把两个数组对应起来，Tall和Shy是对Tom的描述，Handsome和Kind是对Jack的描述……同时对于Jack的描述还有Erudite和Smart，我们有没有什么办法可以迅速地找到某一个人对应的描述呢？直接上代码：
```code
In [37]: names == 'Jack'
Out[37]: array([False, True, False, False, True])
In [38]: data[names == 'Jack']
Out[38]:
array([['Handsome', 'Kind'],
['Erudite', 'Smart']], dtype='<U11')
[/code]
很简单地，我们得到了所有对于Jack的描述。传入data的索引names ==
'Jack'比较特殊，它会生成一个布尔类型的数组，names中与'Jack'相等的元素对应的位置的值会为True，否则为False，将这个布尔数组作为索引传入data，即可以筛选出布尔数组中为True的元素的位置在data数组中所对应的值……这个描述挺绕的，其实看看代码就能懂了。
以布尔数组作为索引，这样的索引自然就叫布尔索引。当然，布尔索引还有很多其他的妙用，比如我们现在想找出除了Jack以外其他人的描述：
```code
In [39]: data[names != 'Jack']
Out[39]:
array([['Tall', 'Shy'],
['Popular', 'Cool'],
['Childish', 'Outstanding']], dtype='<U11')
In [40]: data[~(names == 'Jack')]
Out[40]:
array([['Tall', 'Shy'],
['Popular', 'Cool'],
['Childish', 'Outstanding']], dtype='<U11')
[/code]
无论是直接使用names != 'Jack'还是对names ==
'Jack'取反，都是OK的。同时，其他的条件运算符如|（Or）和&（And）也是可以使用的，大家可以自己敲敲试试。
与切片不同，通过布尔索引产生的数组都是对原数组的一个拷贝，当我们改变它的值时并不会对原数组产生什么影响，这一点注意一下：
```code
In [49]: search_data = data[names != 'Jack']
In [50]: search_data
Out[50]:
array([['Tall', 'Shy'],
['Popular', 'Cool'],
['Childish', 'Outstanding']], dtype='<U11')
In [51]: search_data[:] = 'Handsome'
In [52]: search_data
Out[52]:
array([['Handsome', 'Handsome'],
['Handsome', 'Handsome'],
['Handsome', 'Handsome']], dtype='<U11')
In [53]: data
Out[53]:
array([['Tall', 'Shy'],
['Handsome', 'Kind'],
['Popular', 'Cool'],
['Childish', 'Outstanding'],
['Erudite', 'Smart']], dtype='<U11')
[/code]
布尔索引的使用相当广泛，相信在后面的章节会有更详细的使用。
## 神奇索引
这个索引的命名挺中二的，解释起来有点困难，我们直接上代码：
```code
In [57]: arr = np.arange(12).reshape(3, 4)
In [58]: arr
Out[58]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [59]: arr[[2, 0]]
Out[59]:
array([[ 8, 9, 10, 11],
[ 0, 1, 2, 3]])
In [60]: arr[[2, 0], [3, 1]]
Out[60]: array([11, 1])
[/code]
结合代码来看，对于arr这个3*4的二维数组，将一个一维数组[2, 0]作为它的索引，返回的值则为arr[2]和arr[0]组成的数组，如果将[[2,
0], [3, 1]]作为索引，返回值则为arr[2, 3]和arr[0, 1]组成的数组。喏，这就是神奇索引，其实还是蛮抽象的吧……
对于神奇索引，官方一点的解释是：使用整数数组进行数据索引。将这句话结合上面的代码揣摩一下，就容易理解得多了。
# 数组转置与换轴
只要是学过线代的朋友，对转置都不会陌生，例如有一个矩阵a，矩阵中的元素可以表示为a[x][y]，将a转置之后，其中的元素就变成了a[y][z]，在NumPy中数组的转置与此类似。我们可以将二维数组看成一个矩阵，在二维数组arr2d中，它的元素可以表示为arr2d[x,
y]，而在对其进行转置后，其中的元素就变成了arr2d[y,
x]，和在线代中一样，转置是用字母T表示，ndarray具有一个特殊的属性T，可以获取到其转置后的数组：
```code
In [5]: arr2d = np.arange(10).reshape(2, 5)
In [6]: arr2d
Out[6]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
In [7]: arr2d.T
Out[7]:
array([[0, 5],
[1, 6],
[2, 7],
[3, 8],
[4, 9]])
[/code]
换轴，正如字面的意思，对于二维数组来说，转置就是一次换轴，调换x轴与y轴的过程，接下来我们拓展到三维数组。ndarray还有两个针对换轴操作的方法，分别是transpose方法和swapaxes方法。
先说transpose方法，我们可以向其传入一个轴编号的元组，它将根据这个轴编号去改变元素在数组中的位置。我们可以把三维数组最外层的一维看做轴0，往内层的维度则依次加1，因此一个三维数组的正常维度序列是(0,
1, 2)，可以对应(x, y, z)，如果我们往transpose方法中传入(1, 0, 2)，则是将原数组中的元素位置变为了(y, x,
z)。来看看例子：
```code
In [8]: arr3d = np.arange(30).reshape(2, 3, 5)
In [9]: arr3d
Out[9]:
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]]])
In [10]: arr3d.transpose((1, 0, 2))
Out[10]:
array([[[ 0, 1, 2, 3, 4],
[15, 16, 17, 18, 19]],
[[ 5, 6, 7, 8, 9],
[20, 21, 22, 23, 24]],
[[10, 11, 12, 13, 14],
[25, 26, 27, 28, 29]]])
[/code]
在搞懂了transpose方法之后，理解swapaxes方法也就很容易了。swapaxes方法接收一对轴编号，将传入的这对轴编号位置互换，例如还是这个三维数组arr3d，原本其中每个元素位置都是正常的(x,
y, z)，如果向swapaxes方法中传入(0, 1)，则是意味着将x轴和y轴进行互换，这样一来其中的元素位置就变成了(y, x,
z)，运行结果跟上面使用transpose方法的代码应该是一样的，我们来验证一下：
```code
In [11]: arr3d.swapaxes(0, 1)
Out[11]:
array([[[ 0, 1, 2, 3, 4],
[15, 16, 17, 18, 19]],
[[ 5, 6, 7, 8, 9],
[20, 21, 22, 23, 24]],
[[10, 11, 12, 13, 14],
[25, 26, 27, 28, 29]]])
[/code]
喏，毫无问题。对于更高维度的数组也可以按这样的思想推导，到这里，数组的转置和换轴应该不会有什么不理解的了吧？
# 小节
这篇文章就先写到这里。这次主要是总结了NumPy中的多维数组（ndarray）的相关基础知识，之前嫌转置和换轴这个总结起来描述麻烦懒得写，现在也补上了。其实大家看完这章会发现数据分析会涉及到很多数学知识，对于理工科出身的朋友来说基本都学过几何与线性代数，这方面的知识都不会有什么大问题，如果是半路出家的程序员的话，我还是建议大家了解一些高等数学的相关概念，这样在学习和应用中会少很多压力。
