Python 玩转数据 3 - NumPy ndarray Array Indexing, Slicing, Striding, View Subarray,Copy Subarray

引言

主要介绍 NumPy 数组索引 Index，切片 Slicing，子数组，更多 Python 进阶系列文章，请参考 Python 进阶学习 玩转数据系列

内容提要：

1. 索引，切片，子数组概要
2. 索引 Indexing
3. 连续切片和跨步切片 Slicing and striding
4. 子数组 Subarray: View vs. Copy

索引，切片，子数组概要:

索引 Indexing:

1. Index 是一个整型数
2. Index 从 0 开始
3. 负数的 index 也是可以的
4. Index 引用用中括号 [ ]
5. 某个维度 index 的范围值：
   正数: np.size (a, axis = axis_value) - 1
   负数: -np.size (a, axis = axis_value)
6. 多维数组: 用逗号分开每个维度的 index

Slicing and Striding:

1. [ start : stop : step ]: 用方括号 [ ] 表示
2. start, stop and step 切片访问某个特定维度的数组
3. 负数值也是可以的
4. 取值范围和 index 一样
5. [ start, stop ): 注意 stop 是不包含的
6. 多维数组的分片: 用逗号分开每个维度的 index

Subarray: View vs. Copy:
view subarray 会改变主 array
copy subarray 不会改变主 array

索引 Indexing

Indexing 索引主要提供随机访问数组的单个元素

index的重点：

1. index: 从 0 开始
2. 0 ≤ index ≤ np.size (a) - 1
3. 负数 index is ok
   –index ≡ np.size (a) — index

index 范围：

举例：

import numpy as np

array_1_d = np.arange(1, 5)
array_2_d = np.random.randint (0, 100, (3, 4))
# Right-most element of the 2-d array
row = np.size (array_2_d, axis=0) - 1 
col = np.size (array_2_d, axis=1) - 1 

right_most = array_2_d[row, col]

print("array_1_d: {}\nfirst element array_1_d[0]: {}\nlast element array_1_d[-1]: {} ".format(array_1_d, array_1_d[0], array_1_d[-1]))
print("array_2_d:\n{} \nfirst element array_2_d[0][0]: {}\nlast element array_2_d[-1][-1]: {} ".format(array_2_d, array_2_d[0][0], array_2_d[-1][-1]))
print("last element array_2_d[row, col]: {}".format(right_most))

输出：

array_1_d: [1 2 3 4]
first element array_1_d[0]: 1
last element array_1_d[-1]: 4
array_2_d:
[[15 53 42 77]
 [48 38 67 53]
 [12 84 98 17]]
first element array_2_d[0][0]: 15
last element array_2_d[-1][-1]: 17
last element array_2_d[row, col]: 17

连续切片和跨步切片 Slicing and striding

分片访问数组的元素

Slicing 连续切片
注意：end_index是不包含的
subarray = array [ start_index : end_index ]
np.size (subarray) = end_index – start_index


连续切片举例：

import numpy as np

array_1 = np.arange(0,5)
array_2 = np.arange(5, 12)
array_join = np.concatenate([array_1, array_2])
subarray_1 = array_join[1:5]

array_2_d = np.reshape (array_join, (3,4))
subarray_2 = array_2_d[:2, :3]
first_column = array_2_d[:, 0]
thrid_row = array_2_d[2, :]

print("array_1:{}\n".format(array_1))
print("array_2:{}\n".format(array_2))
print("array_join:{}\n".format(array_join))
print("sub array of array_join array_join[1:5]:{}\n".format(subarray_1))

print("array_2_d:{}\n".format(array_2_d))
print("sub array of array_2_d array_2_d[:2, :3]:{}\n".format(subarray_2))
print("the first column of array_2_d array_2_d[:, 0]{}\n".format(first_column))
print("the third row of array_2_d array_2_d[2, :]:{}\n".format(thrid_row))

输出：

array_1:[0 1 2 3 4]

array_2:[ 5  6  7  8  9 10 11]

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

sub array of array_join array_join[1:5]:[1 2 3 4]

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

sub array of array_2_d array_2_d[:2, :3]:[[0 1 2]
 [4 5 6]]

the first column of array_2_d array_2_d[:, 0][0 4 8]

the third row of array_2_d array_2_d[2, :]:[ 8  9 10 11]

一维数组跨步不连续切片：
subarray = array [ start_index : end_index : stride ]

多维数组跨步不连续切片：
subarray = m [ start_0 : end_0 : stride_0, start_1 : end_1 : stride_1 ]

跨步不连续切片举例：

import numpy as np

array_1 = np.arange(0,12)
array_2_d = np.reshape (array_1, (3,4))

# every other element
subarray_1_every_other = array_1[::2]
# every other element, starting at index 1
subarray_1_every_other_start_from_1 = array_1[1::2]
# reversed array
subarray_1_reversed = array_1[::-1]

# reversing all dimensions
subarray_2_d_reversed = array_2_d[::-1, ::-1]

print("array_1:{}\n".format(array_1))
print("subarray_1_every_other -> array_1[::2]:{}\n".format(subarray_1_every_other))
print("subarray_1_every_other_start_from_1 -> array_1[1::2]:{}\n".format(subarray_1_every_other_start_from_1))
print("subarray_1_reversed -> array_1[::-1]:{}\n".format(subarray_1_reversed))

print("array_2_d:{}\n".format(array_2_d))
print("subarray_2_d_reversed -> array_2_d[::-1, ::-1]:\n{}".format(subarray_2_d_reversed)) 

输出：

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

subarray_1_every_other -> array_1[::2]:[ 0  2  4  6  8 10]

subarray_1_every_other_start_from_1 -> array_1[1::2]:[ 1  3  5  7  9 11]

subarray_1_reversed -> array_1[::-1]:[11 10  9  8  7  6  5  4  3  2  1  0]

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

subarray_2_d_reversed -> array_2_d[::-1, ::-1]:
[[11 10  9  8]
 [ 7  6  5  4]
 [ 3  2  1  0]]

子数组 Subarray: View vs. Copy

1. Subarray 是一个视图不是拷贝
2. 改变 subarray, 将会影响到 主 array
3. 用 np.copy() 方法创建一个主 array 的拷贝，这样改变subarray 的值就不会影响到主 array

举例：

import numpy as np

a = np.arange (12)
ma = np.reshape (a, (3,4))
print("main array:\n{}\n".format(ma))

# a view not a copy
sma = ma [ : 2, : 2]
print("sub view array -> ma [ : 2, : 2]:\n{}\n".format(sma))
# changing the view, changes the original array
sma [0, 0] = 100
print("the changed sub view array -> sma [0, 0] = 100:\n{}\n".format(sma))
print("the changed main array:\n{}\n".format(ma))

# create a copy of the subarray
cma = np.copy (sma)
print("sub copy array -> np.copy (sma):\n{}\n".format(cma))
# changing the copy, do not change the original array
cma [1, 1] = 1000
print("the changed sub copy array:\n{}\n".format(cma))
print("main array not changed:\n{}\n".format(ma))

输出：

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

sub view array -> ma [ : 2, : 2]:
[[0 1]
 [4 5]]

the changed sub view array -> sma [0, 0] = 100:
[[100   1]
 [  4   5]]

the changed main array:
[[100   1   2   3]
 [  4   5   6   7]
 [  8   9  10  11]]

sub copy array -> np.copy (sma):
[[100   1]
 [  4   5]]

the changed sub copy array:
[[ 100    1]
 [   4 1000]]

main array not changed:
[[100   1   2   3]
 [  4   5   6   7]
 [  8   9  10  11]]