本文主要是介绍Python数据分析入门（二）——从NumPy数组说起前言什么是NumPy？多维数组对象ndarray聊聊dtypeNumPy数组算数基础索引与切片特殊的索引数组转置与换轴小节，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

前言

第一篇中说好了这个系列要勤更，但是这一篇还是拖得有点久，毕竟是工作之余的学习，各种事情都在耽误吧。上一篇有说到《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）的相关基础知识，之前嫌转置和换轴这个总结起来描述麻烦懒得写，现在也补上了。其实大家看完这章会发现数据分析会涉及到很多数学知识，对于理工科出身的朋友来说基本都学过几何与线性代数，这方面的知识都不会有什么大问题，如果是半路出家的程序员的话，我还是建议大家了解一些高等数学的相关概念，这样在学习和应用中会少很多压力。


![在这里插入图片描述](https://www.www.zyiz.net/i/ll/?i=20210608151750993.gif)

这篇关于Python数据分析入门（二）——从NumPy数组说起前言什么是NumPy？多维数组对象ndarray聊聊dtypeNumPy数组算数基础索引与切片特殊的索引数组转置与换轴小节的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！