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

array is: [ 0  1  2  3  4  5  6  7  8  9 10 11]

slice begins at 0 and ends at 4 is: [0 1 2 3]

slice begins at 7 and ends at 10 is: [7 8 9]

slice begins at 0 and ends at 12 with step 4 is: [0 4 8]

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

# 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

array is:

[[ 0  1  2  3]

 [ 4  5  6  7]

 [ 8  9 10 11]]

first slice is:

[[5 6]]

second slice is:

[[ 0  2]

 [ 4  6]

 [ 8 10]]

对于 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

[[0, 2], [4, 6], [8, 10]]

对于维数超过 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]

[[12 13 14 15]

 [16 17 18 19]

 [20 21 22 23]]

[[ 1  5  9]

 [13 17 21]]

索引(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 不仅仅可以是一个用逗号分隔开的数字序列，还可以是更复杂的内容。

用逗号分隔的数组序列
- 序列的长度和多维数组的维数要一致
- 序列中每个数组的长度要一致
```
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]]

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

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 is:

[[False False False False]

 [False False  True  True]

 [False  True  True  True]

 [False  True  True  True]]

[ 6  8  6  9 12  8 12 16]

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

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

切片和索引的同异

切片和索引都是访问多维数组中元素的方法，这是两者的共同点，不同之处有:

切片得到的是原多维数组的一个 视图(view) ，修改切片中的内容会导致原多维数组的内容也发生变化
切片得到在多维数组中连续(或按特定步长连续)排列的值，而索引可以得到任意位置的值，自由度更大一些

不考虑第一点的话，切片的操作是可以用索引操作来实现的，不过这没有必要就是了。

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

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

array is:

[[ 0  1  2  3  4  5]

 [ 6  7  8  9 10 11]]

slice is:

[[ 2  3  4]

 [ 8  9 10]]

modified slice is:

[[    2     3     4]

 [    8     9 10000]]

array is now:

[[    0     1     2     3     4     5]

 [    6     7     8     9 10000    11]]

转自http://www.zmonster.me/2016/03/09/numpy-slicing-and-indexing.html