初识数据分析之NumPy 笔记二 数组的基本的索引和切片

来源：《利用Python进行数据分析·第2版》

NumPy数组的索引是一个内容丰富的主题，因为选取数据子集或单个元素的方式有很多。一维数组很简单。从表面上看，它们跟Python列表的功能差不多：

In [1]: import numpy as np

In [2]: arr = np.arange(10)

In [3]: arr
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [4]: arr[5]
Out[4]: 5

In [5]: arr[5:8]
Out[5]: array([5, 6, 7])

In [6]: arr[5:8] = 12

In [7]: arr
Out[7]: array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])

如上所示，当你将一个标量值赋值给一个切片时（如arr[5:8]=12），该值会自动传播（也就说后面将会讲到的“广播”）到整个选区。跟列表最重要的区别在于，数组切片是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数组上。

作为例子，先创建一个arr的切片：

In [8]: temp_arr = arr[5:8]

In [9]: temp_arr
Out[9]: array([12, 12, 12])

现在，当我修改temp_arr中的值，变动也会体现在原始数组arr中：

In [10]: temp_arr[1] = 123456

In [11]: arr
Out[11]:
array([     0,      1,      2,      3,      4,     12, 123456,     12,
            8,      9])

如果你刚开始接触NumPy，可能会对此感到惊讶（尤其是当你曾经用过其他热衷于复制数组数据的编程语言）。由于NumPy的设计目的是处理大数据，所以你可以想象一下，假如NumPy坚持要将数据复制来复制去的话会产生何等的性能和内存问题。

注意：如果你想要得到的是ndarray切片的一份副本而非视图，就需要明确地进行复制操作，例如arr[5:8].copy()。

 对于高维度数组，能做的事情更多。在一个二维数组中，各索引位置上的元素不再是标量而是一维数组：

In [12]: arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

In [13]: arr2d[2]
Out[13]: array([7, 8, 9])

因此，可以对各个元素进行递归访问，但这样需要做的事情有点多。你可以传入一个以逗号隔开的索引列表来选取单个元素。也就是说，下面两种方式是等价的：

In [14]: arr2d[0][2]
Out[14]: 3

In [15]: arr2d[0, 2]
Out[15]: 3

图4-1说明了二维数组的索引方式。轴0作为行，轴1作为列。

标量值和数组都可以被赋值给arr3d[0]：

In [16]: arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

In [18]: arr3d
Out[18]:
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [19]: old_values = arr3d[0].copy()

In [20]: arr3d[0] = 42

In [21]: arr3d
Out[21]:
array([[[42, 42, 42],
        [42, 42, 42]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

In [22]: arr3d[0] = old_values

In [23]: arr3d
Out[23]:
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]])

切片索引

ndarray的切片语法跟Python列表这样的一维对象差不多：

In [24]: arr
Out[24]:
array([     0,      1,      2,      3,      4,     12, 123456,     12,
            8,      9])

In [25]: arr[1:6]
Out[25]: array([ 1,  2,  3,  4, 12])

对于之前的二维数组arr2d，其切片方式稍显不同

In [26]: arr2d
Out[26]:
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

In [27]: arr2d[:2]
Out[27]:
array([[1, 2, 3],
       [4, 5, 6]])

可以看出，它是沿着第0轴（即第一个轴）切片的。也就是说，切片是沿着一个轴向选取元素的。表达式arr2d[:2]可以被认为是“选取arr2d的前两行”。

你可以一次传入多个切片，就像传入多个索引那样：

In [28]: arr2d[:2, 1:]
Out[28]:
array([[2, 3],
       [5, 6]])

像这样进行切片时，只能得到相同维数的数组视图。通过将整数索引和切片混合，可以得到低维度的切片。

例如，我可以选取第二行的前两列：

In [29]: arr2d[1, :2]
Out[29]: array([4, 5])

相似的，还可以选择第三列的前两行：

In [31]: arr2d[2, :2]
Out[31]: array([7, 8])

图4-2对此进行了说明。注意，“只有冒号”表示选取整个轴，因此你可以像下面这样只对高维轴进行切片

In [34]: arr = np.array([[1,2,3],[4,5,6],[7,8,9]])

In [41]: arr[1:, :2]
Out[41]:
array([[4, 5],
       [7, 8]])

In [42]: arr[1:2, :2]
Out[42]: array([[4, 5]])

自然，对切片表达式的赋值操作也会被扩散到整个选区：

In [44]: arr2d[:2, 1:] = 0

In [45]: arr2d
Out[45]:
array([[1, 0, 0],
       [4, 0, 0],
       [7, 8, 9]])

布尔型索引

来看这样一个例子，假设我们有一个用于存储数据的数组以及一个存储姓名的数组（含有重复项）。在这里，我将使用numpy.random中的randn函数生成一些正态分布的随机数据：

In [46]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

In [47]: names
Out[47]: array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='

假设每个名字都对应data数组中的一行，而我们想要选出对应于名字"Bob"的所有行。跟算术运算一样，数组的比较运算（如==）也是矢量化的。因此，对names和字符串"Bob"的比较运算将会产生一个布尔型数组：

In [50]: names == "Bob"
Out[50]: array([ True, False, False,  True, False, False, False])

这个布尔型数组可用于数组索引：

In [52]: data[names=="Bob"]
Out[52]:
array([[ 0.44563136,  1.16668659,  2.98215472,  0.02914175],
       [ 0.53097898,  0.59327164, -0.8837376 ,  0.8334125 ]])

布尔型数组的长度必须跟被索引的轴长度一致。此外，还可以将布尔型数组跟切片、整数（或整数序列，稍后将对此进行详细讲解）混合使用：

选取names == 'Bob'的行，并索引了列：

In [53]: data[names=="Bob", 2:]
Out[53]:
array([[ 2.98215472,  0.02914175],
       [-0.8837376 ,  0.8334125 ]])

In [54]: data[names=="Bob", 3]
Out[54]: array([0.02914175, 0.8334125 ])

要选择除"Bob"以外的其他值，既可以使用不等于符号（!=），也可以通过~对条件进行否定：

In [55]: data[names!="Bob"]
Out[55]:
array([[ 0.18628937,  1.88104933,  0.12924571, -0.51758933],
       [ 1.07128893,  0.50035911, -0.03291711, -0.72732549],
       [ 1.00182986, -0.56374139, -1.62964244,  0.73499296],
       [ 0.72855653, -0.2428242 , -1.32900097, -1.55934853],
       [-0.22572668,  0.93512949, -0.13112029,  1.38163118]])

In [56]: data[~(names=="Bob")]
Out[56]:
array([[ 0.18628937,  1.88104933,  0.12924571, -0.51758933],
       [ 1.07128893,  0.50035911, -0.03291711, -0.72732549],
       [ 1.00182986, -0.56374139, -1.62964244,  0.73499296],
       [ 0.72855653, -0.2428242 , -1.32900097, -1.55934853],
       [-0.22572668,  0.93512949, -0.13112029,  1.38163118]])

选取这三个名字中的两个需要组合应用多个布尔条件，使用&（和）、|（或）之类的布尔算术运算符即可：

In [60]: (names == "Bob") | (names == "Will")
Out[60]: array([ True, False,  True,  True,  True, False, False])

In [61]: flag = (names == "Bob") | (names == "Will")

In [62]: data[flag]
Out[62]:
array([[ 0.44563136,  1.16668659,  2.98215472,  0.02914175],
       [ 1.07128893,  0.50035911, -0.03291711, -0.72732549],
       [ 0.53097898,  0.59327164, -0.8837376 ,  0.8334125 ],
       [ 1.00182986, -0.56374139, -1.62964244,  0.73499296]])

通过布尔型索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样的数组也是如此。

注意：Python关键字and和or在布尔型数组中无效。要使用&与|。

通过布尔型数组设置值是一种经常用到的手段。为了将data中的所有负值都设置为0，我们只需：

In [63]: data[data < 0] = 0

In [64]: data
Out[64]:
array([[0.44563136, 1.16668659, 2.98215472, 0.02914175],
       [0.18628937, 1.88104933, 0.12924571, 0.        ],
       [1.07128893, 0.50035911, 0.        , 0.        ],
       [0.53097898, 0.59327164, 0.        , 0.8334125 ],
       [1.00182986, 0.        , 0.        , 0.73499296],
       [0.72855653, 0.        , 0.        , 0.        ],
       [0.        , 0.93512949, 0.        , 1.38163118]])

 花式索引

花式索引（Fancy indexing）是一个NumPy术语，它指的是利用整数数组进行索引。假设我们有一个8×4数组：

In [65]: arr = np.empty((8, 4))

In [67]: for i in range(8):
    ...:     arr[i] = i
    ...:

In [68]: arr
Out[68]:
array([[0., 0., 0., 0.],
       [1., 1., 1., 1.],
       [2., 2., 2., 2.],
       [3., 3., 3., 3.],
       [4., 4., 4., 4.],
       [5., 5., 5., 5.],
       [6., 6., 6., 6.],
       [7., 7., 7., 7.]])

为了以特定顺序选取行子集，只需传入一个用于指定顺序的整数列表或ndarray即可：

In [70]: arr[[5,2,7,0]]
Out[70]:
array([[5., 5., 5., 5.],
       [2., 2., 2., 2.],
       [7., 7., 7., 7.],
       [0., 0., 0., 0.]])

这段代码确实达到我们的要求了！使用负数索引将会从末尾开始选取行：

In [71]: arr[[-5,-2,-7,]]
Out[71]:
array([[3., 3., 3., 3.],
       [6., 6., 6., 6.],
       [1., 1., 1., 1.]])

一次传入多个索引数组会有一点特别。它返回的是一个一维数组，其中的元素对应各个索引元组：

In [72]: arr = np.arange(32).reshape(8, 4)

In [73]: arr
Out[73]:
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, 30, 31]])

In [74]: arr[[1, 5, 7, 2], [0, 3, 1, 2]]
Out[74]: array([ 4, 23, 29, 10])

最终选出的是元素(1,0)、(5,3)、(7,1)和(2,2)。无论数组是多少维的，花式索引总是一维的。

记住，花式索引跟切片不一样，它总是将数据复制到新数组中。

数组转置和轴对换

转置是重塑的一种特殊形式，它返回的是源数据的视图（不会进行任何复制操作）。数组不仅有transpose方法，还有一个特殊的T属性：

In [75]: arr = np.arange(15).reshape((3, 5))

In [76]: arr
Out[76]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [77]: arr.T
Out[77]:
array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

在进行矩阵计算时，经常需要用到该操作，比如利用np.dot计算矩阵内积：

In [80]: arr = np.random.randn(6, 3)

In [81]: arr
Out[81]:
array([[-0.27155944,  0.17883244,  1.67811323],
       [ 0.6014445 ,  0.88050065,  0.28260649],
       [-0.34991222, -0.02636702,  0.62255874],
       [-1.6028363 , -1.5057255 ,  0.96742156],
       [-1.8206886 , -0.96700445,  0.19953161],
       [ 0.52152672,  0.66470608, -0.94795859]])

In [82]: np.dot(arr.T, arr)
Out[82]:
array([[ 6.71389988,  5.01094222, -2.91186533],
       [ 5.01094222,  4.45209872, -1.74721185],
       [-2.91186533, -1.74721185,  5.15785264]])