Python数据分析入门（二）——从NumPy数组说起

梦里梦外; 2022-05-16 08:09 203阅读 0赞

# 前言 #

第一篇中说好了这个系列要勤更，但是这一篇还是拖得有点久，毕竟是工作之余的学习，各种事情都在耽误吧。上一篇有说到《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. ])

可以看到调用array函数后产生的ndarray对象中的值都变成float类型了，这是因为ndarray是一个通用的多维同类数据容器，也就是说它包含的每一个元素均为相同类型，我们可以通过shape属性和dtype属性来分别查看ndarray对象的每一维度数量以及其数据类型：

In [6]: arr1.shape
    Out[6]: (5,)
    
    In [7]: arr1.dtype
    Out[7]: dtype('float64')

可以看到arr1为一个一维数组，数据类型为float64。

array同样可以将嵌套的序列转换为ndarray：

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')

data2中有两个等长的列表，在经过array函数转换后即可生成多维数组。除非我们显示地指定了生成数组的数据类型，否则array函数将会自动推断生成数据的类型。

In [13]: arr3 = np.array(data1, 'int64')
    
    In [14]: arr3
    Out[14]: array([6, 7, 8, 0, 1])

这样生成的ndarray中的数据类型就成了我们指定的int64了。

当然，你可能还有点好奇如果上面代码中的data2中的元素是两个不等长的列表的话，array函数的执行结果会是什么样子：

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')

可以看到，arr3会被赋值为一个一维数组，它有两个list类型的元素，这也很好理解。

除了array函数以外，我们还有很多别的方法创建ndarray对象。直接看代码吧：

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])

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对象的数据类型：

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')

# NumPy数组算数 #

ndarray有一个有趣的特性，我们可以称其为向量化，即无需遍历数组即可对数组进行各种算数操作。

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]])

当然，这里我们讲到的只是对于相同尺寸的数组间的计算，至于不同尺寸的数组以后再聊（感兴趣的朋友可以自己去了解一下广播特性）。

# 基础索引与切片 #

一维数组索引和Python的列表类似，都可以通过索引和切片获得所需的元素，不过还是有些许差别：

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])

看到这段代码是不是有点惊讶？我们可以来对比一下Python的列表：

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]

我们可以看到，在Python的内建列表中，切片是对于原列表的一段复制，对其值进行改变的话并不会影响到原列表；而在NumPy中，一个数组的切片相当于这个数组的一段视图，修改这段切片的值也会导致原数组的这一段值被修改——这意味着原数组并不是被复制了。

对于这一点，如果你熟悉其他的编程语言的话可能会有所疑惑，在其他语言的使用场景中，切片操作都是希望尽量不影响到原数组的，可是在NumPy中不一样，因为NumPy被设计出来的初衷便是处理非常大的数组，想想看，对于庞大的数组持续复制将会引起多少内存问题。当然了，如果你一定想要一段切片的拷贝的话，可以通过copy函数。

对于多维数组的索引也很好理解，其中的元素需要一级一级地去取，我们以一个2\*2\*3的数组为例：array(\[\[\[1, 2, 3\], \[4, 5, 6\]\], \[\[7, 8, 9\], \[10 ,11, 12\]\]\])，如果我想取出“2”这个值该怎么办？

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

很简单吧？只需要用逗号分隔每一级的索引就OK了。对于多维数组还有一点挺有趣的：

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]]])

无论是传入标量或者数组，都可以为arr3d\[0\]赋值。

多维数组的切片或许会有点绕，我们还是看arr3d吧：

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]]])

其实也很容易理解，对多维数组的切片也是一级一级地进行的，以逗号分开即可。

# 特殊的索引 #

接下来我们来看看NumPy中两种比较特殊的索引，分别是布尔索引和神奇索引，它们和其他语言中的列表索引操作可能有很大的区别，但是对于数据分析相当有用。

## 布尔索引 ##

我来改编一下书中的例子，可能更容易理解。我们先假设现在有一组人名names，同时还有一组每个人名对应的信息data，这两个数组中的元素是一一对应的：

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')

把两个数组对应起来，Tall和Shy是对Tom的描述，Handsome和Kind是对Jack的描述……同时对于Jack的描述还有Erudite和Smart，我们有没有什么办法可以迅速地找到某一个人对应的描述呢？直接上代码：

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')

很简单地，我们得到了所有对于Jack的描述。传入data的索引names == 'Jack'比较特殊，它会生成一个布尔类型的数组，names中与'Jack'相等的元素对应的位置的值会为True，否则为False，将这个布尔数组作为索引传入data，即可以筛选出布尔数组中为True的元素的位置在data数组中所对应的值……这个描述挺绕的，其实看看代码就能懂了。

以布尔数组作为索引，这样的索引自然就叫布尔索引。当然，布尔索引还有很多其他的妙用，比如我们现在想找出除了Jack以外其他人的描述：

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')

无论是直接使用names != 'Jack'还是对names == 'Jack'取反，都是OK的。同时，其他的条件运算符如|（Or）和&（And）也是可以使用的，大家可以自己敲敲试试。

与切片不同，通过布尔索引产生的数组都是对原数组的一个拷贝，当我们改变它的值时并不会对原数组产生什么影响，这一点注意一下：

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')

布尔索引的使用相当广泛，相信在后面的章节会有更详细的使用。

## 神奇索引 ##

这个索引的命名挺中二的，解释起来有点困难，我们直接上代码：

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])

结合代码来看，对于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，可以获取到其转置后的数组：

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]])

换轴，正如字面的意思，对于二维数组来说，转置就是一次换轴，调换x轴与y轴的过程，接下来我们拓展到三维数组。ndarray还有两个针对换轴操作的方法，分别是transpose方法和swapaxes方法。

先说transpose方法，我们可以向其传入一个轴编号的元组，它将根据这个轴编号去改变元素在数组中的位置。我们可以把三维数组最外层的一维看做轴0，往内层的维度则依次加1，因此一个三维数组的正常维度序列是(0, 1, 2)，可以对应(x, y, z)，如果我们往transpose方法中传入(1, 0, 2)，则是将原数组中的元素位置变为了(y, x, z)。来看看例子：

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]]])

在搞懂了transpose方法之后，理解swapaxes方法也就很容易了。swapaxes方法接收一对轴编号，将传入的这对轴编号位置互换，例如还是这个三维数组arr3d，原本其中每个元素位置都是正常的(x, y, z)，如果向swapaxes方法中传入(0, 1)，则是意味着将x轴和y轴进行互换，这样一来其中的元素位置就变成了(y, x, z)，运行结果跟上面使用transpose方法的代码应该是一样的，我们来验证一下：

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]]])

喏，毫无问题。对于更高维度的数组也可以按这样的思想推导，到这里，数组的转置和换轴应该不会有什么不理解的了吧？

# 小节 #

这篇文章就先写到这里。这次主要是总结了NumPy中的多维数组（ndarray）的相关基础知识，之前嫌转置和换轴这个总结起来描述麻烦懒得写，现在也补上了。其实大家看完这章会发现数据分析会涉及到很多数学知识，对于理工科出身的朋友来说基本都学过几何与线性代数，这方面的知识都不会有什么大问题，如果是半路出家的程序员的话，我还是建议大家了解一些高等数学的相关概念，这样在学习和应用中会少很多压力。