Numpy 中多维数组的切片操作与 Python

numpy在处理数据的时候，经常会有切片操作，如提取指定几行的数据或者几列的数据，本文记录一些典型的切片方法以备日后查看。

一维数组的切片：

数组[start🔚step]
从start到end，以step为步长的元素
且：start < end.

>>> b=np.random.randint(1,10,[10])
>>> b
array([6, 5, 2, 3, 9, 9, 3, 8, 5, 8])

正向第i个元素到第j个元素：

>>> i=1
>>> j=8
>>> b[i:j]
array([5, 2, 3, 9, 9, 3, 8])

返回b[i],b[i+1],···，b[j-1]的元素

>>> i=1
>>> j=2
>>> b[i:j]
array([5])

我们发现是左闭右开，第j个元素不返回。

>>> b[::2]
array([6, 2, 9, 3, 5])

以2位步长，取下标为2的倍数的元素。

反向 倒数几个元素：
start和end为负数则是反向取元素，
取b[start+1] ，b[start+2],···,b[end]的元素

>>> b[-3:-1]
array([8, 5])

二维数组的切片

>>> a=np.random.randint(0,10,size=[4,5])
>>> a
array([[1, 8, 4, 9, 8],
       [4, 1, 6, 4, 2],
       [6, 4, 1, 2, 7],
       [4, 9, 3, 5, 9]])

第i列到第j列：

>>> a[:,2:4]
array([[4, 9],
       [6, 4],
       [1, 2],
       [3, 5]])

我们可以发现，多维的切片是在中括号中用逗号运算符, 将不同维上的操作分开，分割开后每个维度上单独维护即可。

另外

另外 numpy中对切片元素的操作是会影响到原数组本身的！
例如沿用上例的a矩阵：

>>> a[:1,:1]=[[100]]
>>> a
array([[100,   8,   4,   9,   8],
       [  4,   1,   6,   4,   2],
       [  6,   4,   1,   2,   7],
       [  4,   9,   3,   5,   9]])

切片(slicing)操作

Numpy 中多维数组的切片操作与 Python 中 list 的切片操作一样，同样由 start, stop, step 三个部分组成

import numpy as np
 
arr = np.arange(12)
print 'array is:', arr
 
slice_one = arr[:4]
print 'slice begins at 0 and ends at 4 is:', slice_one
 
slice_two = arr[7:10]
print 'slice begins at 7 and ends at 10 is:', slice_two
 
slice_three = arr[0:12:4]
print 'slice begins at 0 and ends at 12 with step 4 is:', slice_three

上述例子是一维数组的例子，如果是多维数组，将不同维度上的切片操作用 逗号 分开就好了

# coding: utf-8
import numpy as np
 
arr = np.arange(12).reshape((3, 4))
print 'array is:'
print arr
 
# 取第一维的索引 1 到索引 2 之间的元素，也就是第二行
# 取第二维的索引 1 到索引 3 之间的元素，也就是第二列和第三列
slice_one = arr[1:2, 1:3]
print 'first slice is:'
print slice_one
 
# 取第一维的全部
# 按步长为 2 取第二维的索引 0 到末尾 之间的元素，也就是第一列和第三列
slice_two = arr[:, ::2]
print 'second slice is:'
print slice_two

对于 slice_two，如果 arr 是用 Python 的 list 表示的，那么要得到相同的结果得像下面这样，相对来说就麻烦多了:

import numpy as np
 
arr = np.arange(12).reshape((3, 4)).tolist()
 
slice_two = [
    row[::2] for row in arr
]
print slice_two

对于维数超过 3 的多维数组，还可以通过 ‘…’ 来简化操作

# coding: utf-8
import numpy as np
 
arr = np.arange(24).reshape((2, 3, 4))
 
print arr[1, ...]               # 等价于 arr[1, :, :]
print arr[..., 1]               # 等价于 arr[:, :, 1]

索引(indexing) 操作

最简单的情况

对于一个多维数组来说，最简单的情况就是访问其中一个特定位置的元素了，如下所示:

# coding: utf-8
import numpy as np
 
arr = np.array([
    [1, 2, 3, 4],
    [2, 4, 6, 8],
    [3, 6, 9, 12],
    [4, 8, 12, 16]
])
print '第二行第二列的值:', arr[1, 1]

第二行第二列的值: 4
相比之下，如果用 Python 的 list 来表示上述二维数组，获取同一个位置的元素的方法为:

# coding: utf-8
arr = [
    [1, 2, 3, 4],
    [2, 4, 6, 8],
    [3, 6, 9, 12],
    [4, 8, 12, 16]
]
print '第二行第二列的值:', arr[1][1]
try:
    print '第二行第二列的值(尝试用 Numpy 的方式获取):', arr[1, 1]
except Exception as e:
    print str(e)

第二行第二列的值: 4
第二行第二列的值(尝试用 Numpy 的方式获取): list indices must be integers, not tuple
如果只是二维数组，这种差别可能看起来并不大，但想象一下假如有一个 10 维的数组，用 Python 的标准做法需要写 10 对中括号，而用 Numpy 依然只需要一对。

获取多个元素

事实上，在 Numpy 的索引操作方式 x = arr[obj] 中， obj 不仅仅可以是一个用逗号分隔开的数字序列，还可以是更复杂的内容。

1.用逗号分隔的数组序列
序列的长度和多维数组的维数要一致
序列中每个数组的长度要一致

import numpy as np
 
arr = np.array([
    [1, 2, 3, 4],
    [2, 4, 6, 8],
    [3, 6, 9, 12],
    [4, 8, 12, 16]
])
 
print arr[[0, 2], [3, 1]]

以上面这个例子来说，其含义是: 选择第一行和第三行，然后对第一行选择第四列，对第三行选择第二列。

2.boolean/mask index

这个不太好翻译，所以就用原来的英语表达。

所谓 boolean index，就是用一个由 boolean 类型值组成的数组来选择元素的方法。比如说对下面这样多维数组

array([[1, 2, 3, 4],
[2, 4, 6, 8],
[3, 6, 9, 12],
[4, 8, 12, 16]])
如果要取其中 值大于 5 的元素，就可以用上 boolean index 了，如下所示:

import numpy as np
 
arr = np.array([[1, 2, 3, 4],
                [2, 4, 6, 8],
                [3, 6, 9, 12],
                [4, 8, 12, 16]])
mask = arr > 5
 
print 'boolean mask is:'
print mask
 
print arr[mask]

除了比较运算能产生 boolean mask 数组以外， Numpy 本身也提供了一些工具方法:

numpy.iscomplex
numpy.isreal
numpy.isfinite
numpy.isinf
numpy.isnan

切片和索引的同异

切片和索引都是访问多维数组中元素的方法，这是两者的共同点，不同之处有:
1.切片得到的是原多维数组的一个 视图(view) ，修改切片中的内容会导致原多维数组的内容也发生变化
2.切片得到在多维数组中连续(或按特定步长连续)排列的值，而索引可以得到任意位置的值，自由度更大一些
不考虑第一点的话，切片的操作是可以用索引操作来实现的，不过这没有必要就是了。

对于第一点，见下面的实验:

import numpy as np
 
arr = np.arange(12).reshape(2, 6)
print 'array is:'
print arr
 
slc = arr[:, 2:5]
print 'slice is:'
print slc
 
slc[1, 2] = 10000
print 'modified slice is:'
print slc
print 'array is now:'
print arr