NumPy索引切片

Posted 2021-02-15 pythonyeyu

索引，切片和迭代

一维数组可以被索引，切片和迭代，就像 列表 和其他Python序列一样。

 

代码实例解析数组中的索引切片

>>> import numpy as np   #导入numpy  别名为np
>>> a = np.arange(10)**3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
>>> a[2]                                  #数组的索引从下标0开始
8
>>> a[2:5]                               #数组的索引包含首不包含尾
array([ 8, 27, 64])
>>> a[:6:2] = -1000    # 指索引[0:6]步长为2的值都赋值为1000
>>> a
array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
>>> a[ : :-1]                                   # 将 a  逆序
array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
>>> for i in a:
...     print(i**(1/3.))
...
nan
1.0
nan 
3.0
nan
5.0
6.0
7.0
8.0
9.0

多维数组每个轴可以有一个索引。这些索引以逗号分隔的元组给出：

 

>>> def f(x,y):
...     return 10*x+y                     #这里定义了一个生成方法
...
>>> b = np.fromfunction(f,(5,4),dtype=int) #fromfunction（函数名，shape,dtype）生成一个数组
>>> b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
>>> b[2,3]           #索引第二行第三列的值，数组的索引从下标0开始
23
>>> b[0:5, 1]                        # ‘,‘前面是行维度，后是列维度
array([ 1, 11, 21, 31, 41])          #这里表示所有行的第一类
>>> b[ : ,1]                        # 同上
array([ 1, 11, 21, 31, 41])
>>> b[1:3, : ]                      # 一行和二行的所有列
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])
#当提供的索引少于轴的数量时，缺失的索引被认为是完整的切片:
>>> b[-1]                                  # 等价于b[-1,:]
array([40, 41, 42, 43])
?

括号内的表达式b[i]被视为一个i 后跟尽可能多的实例:来表示剩余的轴。NumPy还允许你用点来写这个 b[i,...]。

的点（...根据需要，以产生一个完整的索引元组）表示为许多冒号。例如，if x是一个包含5个轴的数组，那么

• x[1,2,...]相当于x[1,2,:,:,:]，

• x[...,3]去x[:,:,:,:,3]和

• x[4,...,5,:]到x[4,:,:,5,:]。

• ps：省略号自然是省略的意思，所以是省略一坨咯

  可以看看下面的代码实例

>>> c = np.array( [[[  0,  1,  2],               #生成一个三维数组
...                 [ 10, 12, 13]],
...                [[100,101,102],
...                 [110,112,113]]])
>>> c.shape     #返回该数组的形状
(2, 2, 3)
>>> c[1,...]                                   #横的第1坨 剩下的省略不要 
array([[100, 101, 102],
       [110, 112, 113]])
>>> c[...,2]                                   # 竖的第二列全部，省略的一坨对不起，俺们不要
array([[  2,  13],
       [102, 113]])
对多维数组进行迭代是针对第一个轴完成的：
    （就是按行开始便利么）
>>>
>>> for row in b:
...     print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
#但是，如果想要对数组中的每个元素执行操作，可以使用flat属性 作为数组的所有元素的 迭代器：
#当便利的元素有时候特别特别小时可以通过指定dtype属性为complex来解决
>>>
>>> for element in b.flat:   #（b这个矩阵的flat属性，可以当作是化身为一维数组的形式内包含所有的元素的一个列表就ok了，记住仅仅是当作）
...     print(element)
...
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43 

形状操纵

改变数组的形状

#这里给出一个数组三行四列的二维数组
#floor:小于这个元素的最大整数值
?
>>> a = np.floor(10*np.random.random((3,4)))
>>> a
array([[ 2.,  8.,  0.,  6.],
       [ 4.,  5.,  1.,  1.],
       [ 8.,  9.,  3.,  6.]])
>>> a.shape
(3, 4)

可以使用各种命令更改阵列的形状。请注意，以下三个命令都返回已修改的数组，但不更改原始数组：

>>> a.ravel()  # 返回一个数组列表相当于奥特曼变身和flat差不多
array([ 2.,  8.,  0.,  6.,  4.,  5.,  1.,  1.,  8.,  9.,  3.,  6.])
>>> a.reshape(6,2)  #不改变数组元素，返回一个shape形状的数组，原数组不变
#哦我的天，快看出现一个6行2列的二维数组
array([[ 2.,  8.],
       [ 0.,  6.],
       [ 4.,  5.],
       [ 1.,  1.],
       [ 8.,  9.],
       [ 3.,  6.]])
>>> a.T  # 卡布达变身 行列交换 
array([[ 2.,  4.,  8.],  #原来的0列变成0行 以此类推
       [ 8.,  5.,  9.],
       [ 0.,  1.,  3.],
       [ 6.,  1.,  6.]])
>>> a.T.shape # (3，4) 变(4,3)这里指返回变身后的形状 
(4, 3)
>>> a.shape
(3, 4)

由ravel（）产生的数组中元素的顺序通常是“C风格”，也就是说，最右边的索引“变化最快”，因此[0,0]之后的元素是[0,1] 。如果将数组重新整形为其他形状，则该数组将被视为“C风格”。NumPy通常创建按此顺序存储的数组，因此ravel（）通常不需要复制其参数，但如果数组是通过获取另一个数组的切片或使用不常见的选项创建的，则可能需要复制它。还可以使用可选参数指示函数ravel（）和reshape（），以使用FORTRAN样式的数组，其中最左边的索引变化最快。

flat只是一个可跌带的玩意 可以通过便利来查看 ravel则是真的返回一个一维数组

总结：

ps:
1.选取一个维度用‘ : ‘
2.每个维度切片方法与一维数组相同
3.每个维度可以使用步长跳跃切片