NumPy 超详细教程（3）：ndarray 的内部机理及高级迭代

深碍√TFBOYSˉ_ 2022-01-20 04:35 342阅读 0赞

## 系列文章地址 ##

*  [NumPy 最详细教程（1）：NumPy 数组][NumPy _1_NumPy]
 *  [NumPy 超详细教程（2）：数据类型][NumPy _2]
 *  [NumPy 超详细教程（3）：ndarray 的内部机理及高级迭代][NumPy _3_ndarray]

## ndarray 对象的内部机理 ##

在前面的内容中，我们已经详细讲述了 `ndarray` 的使用，在本章的开始部分，我们来聊一聊 `ndarray` 的内部机理，以便更好的理解后续的内容。

### 1、ndarray 的组成 ###

*ndarray* 与数组不同，它不仅仅包含数据信息，还包括其他描述信息。*ndarray* 内部由以下内容组成：

*  数据指针：一个指向实际数据的指针。
 *  数据类型（dtype）：描述了每个元素所占字节数。
 *  维度（shape）：一个表示数组形状的元组。
 *  跨度（strides）：一个表示从当前维度前进道下一维度的当前位置所需要“跨过”的字节数。

*NumPy* 中，数据存储在一个**均匀连续的内存块**中，可以这么理解，*NumPy* 将多维数组在内部以一维数组的方式存储，我们只要知道了每个元素所占的字节数（dtype）以及每个维度中元素的个数（shape），就可以快速定位到任意维度的任意一个元素。

*dtype* 及 *shape* 前文中已经有详细描述，这里我们来讲下 *strides*。

**示例**

ls = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], 
          [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]
    a = np.array(ls, dtype=int)
    print(a)
    print(a.strides)
    复制代码

**输出：**

[[[ 1  2  3  4]
      [ 5  6  7  8]
      [ 9 10 11 12]]
    
     [[13 14 15 16]
      [17 18 19 20]
      [21 22 23 24]]]
    (48, 16, 4)
    复制代码

上例中，我们定义了一个三维数组，*dtype* 为 *int*，*int* 占 4个字节。 第一维度，从元素 1 到元素 13，间隔 12 个元素，总字节数为 48； 第二维度，从元素 1 到元素 5，间隔 4 个元素，总字节数为 16； 第三维度，从元素 1 到元素 2，间隔 1 个元素，总字节数为 4。 所以跨度为(48, 16, 4)。

## 普通迭代 ##

*ndarray* 的普通迭代跟 *Python* 及其他语言中的迭代方式无异，**N** 维数组，就要用 **N** 层的 `for` 循环。

**示例：**

import numpy as np
    
    ls = [[1, 2], [3, 4], [5, 6]]
    a = np.array(ls, dtype=int)
    for row in a:
        for cell in row:
            print(cell)
    复制代码

**输出：**

1
    2
    3
    4
    5
    6
    复制代码

上例中，`row` 的数据类型依然是 `numpy.ndarray`，而 `cell` 的数据类型是 `numpy.int32`。

## nditer 多维迭代器 ##

*NumPy* 提供了一个高效的**多维迭代器**对象：*nditer* 用于迭代数组。在普通方式的迭代中，**N** 维数组，就要用 **N** 层的 `for` 循环。但是使用 `nditer` 迭代器，一个 `for` 循环就能遍历整个数组。（因为 *ndarray* 在内存中是连续的，连续内存不就相当于是一维数组吗？遍历一维数组当然只需要一个 `for` 循环就行了。）

### 1、基本示例 ###

**例一：**

ls = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
          [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]
    a = np.array(ls, dtype=int)
    for x in np.nditer(a):
        print(x, end=", ")
    复制代码

**输出：**

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 
    复制代码

### 2、order 参数：指定访问元素的顺序 ###

创建 *ndarray* 数组时，可以通过 *order* 参数指定元素的顺序，按行还是按列，这是什么意思呢？来看下面的示例：

**例二：**

ls = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
          [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]
    a = np.array(ls, dtype=int, order='F')
    for x in np.nditer(a):
        print(x, end=", ")
    复制代码

**输出：**

1, 13, 5, 17, 9, 21, 2, 14, 6, 18, 10, 22, 3, 15, 7, 19, 11, 23, 4, 16, 8, 20, 12, 24, 
    复制代码

> `nditer` 默认以内存中元素的顺序（order='K'）访问元素，对比**例一**可见，创建 *ndarray* 时，指定不同的顺序将影响元素在内存中的位置。

**例三：** `nditer` 也可以指定使用某种顺序遍历。

ls = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
          [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]
    a = np.array(ls, dtype=int, order='F')
    for x in np.nditer(a, order='C'):
        print(x, end=", ")
    复制代码

**输出：**

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 
    复制代码

> 行主顺序（`order='C'`）和列主顺序（`order='F'`），参看 [en.wikipedia.org/wiki/Row-\_a…][en.wikipedia.org_wiki_Row-_a]。例一是行主顺序，例二是列主顺序，如果将 *ndarray* 数组想象成一棵树，那么会发现，行主顺序就是深度优先，而列主顺序就是广度优先。NumPy 中之所以要分行主顺序和列主顺序，主要是为了在矩阵运算中提高性能，顺序访问比非顺序访问快几个数量级。（矩阵运算将会在后面的章节中讲到）

### 3、op\_flags 参数：迭代时修改元素的值 ###

默认情况下，*nditer* 将视待迭代遍历的数组为只读对象（**readonly**），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 `op_flags` 参数为 **readwrite** 或者 **writeonly** 的模式。

**例四：**

import numpy as np
    
    a = np.arange(5)
    for x in np.nditer(a, op_flags=['readwrite']):
        x[...] = 2 * x
    print(a)
    复制代码

**输出：**

[0 1 2 3 4]
    复制代码

### 4、flags 参数 ###

`flags` 参数需要传入一个数组或元组，既然参数类型是数组，我原本以为可以传入多个值的，但是，就下面介绍的 4 种常用选项，我试了，不能传多个，例如 `flags=['f_index', 'external_loop']`，运行**报错**。

#### （1）使用外部循环：external\_loop ####

**将一维的最内层的循环转移到外部循环迭代器，使得 *NumPy* 的矢量化操作在处理更大规模数据时变得更有效率。**

简单来说，当指定 `flags=['external_loop']` 时，将返回一维数组而并非单个元素。具体来说，当 *ndarray* 的顺序和遍历的顺序一致时，将所有元素组成一个一维数组返回；当 *ndarray* 的顺序和遍历的顺序不一致时，返回每次遍历的一维数组（这句话特别不好描述，看例子就清楚了）。

**例五：**

import numpy as np
    
    ls = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
          [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]
    a = np.array(ls, dtype=int, order='C')
    for x in np.nditer(a, flags=['external_loop'], order='C'):
        print(x,)
    复制代码

**输出：**

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
    复制代码

**例六：**

b = np.array(ls, dtype=int, order='F')
    for x in np.nditer(b, flags=['external_loop'], order='C'):
        print(x,)
    复制代码

**输出：**

[1 2 3 4]
    [5 6 7 8]
    [ 9 10 11 12]
    [13 14 15 16]
    [17 18 19 20]
    [21 22 23 24]
    复制代码

#### （2）追踪索引：c\_index、f\_index、multi\_index ####

**例七：**

import numpy as np
    
    a = np.arange(6).reshape(2, 3)
    it = np.nditer(a, flags=['f_index'])
    
    while not it.finished:
        print("%d <%d>" % (it[0], it.index))
        it.iternext()
    复制代码

**输出：**

0 <0>
    1 <2>
    2 <4>
    3 <1>
    4 <3>
    5 <5>
    复制代码

这里索引之所以是这样的顺序，因为我们选择的是列索引（f\_index）。直观的感受看下图：

> 遍历元素的顺序是由 `order` 参数决定的，而行索引（c\_index）和列索引（f\_index）不论如何指定，并不会影响元素返回的顺序。它们仅表示在当前内存顺序下，如果按行/列顺序返回，各个元素的下标应该是多少。

**例八：**

import numpy as np
    
    a = np.arange(6).reshape(2, 3)
    it = np.nditer(a, flags=['multi_index'])
    
    while not it.finished:
        print("%d <%s>" % (it[0], it.multi_index))
        it.iternext()
    复制代码

**输出：**

0 <(0, 0)>
    1 <(0, 1)>
    2 <(0, 2)>
    3 <(1, 0)>
    4 <(1, 1)>
    5 <(1, 2)>
    复制代码

### 5、同时迭代多个数组 ###

说到同时遍历多个数组，第一反应会想到 *zip* 函数，而在 *nditer* 中不需要。

**例九：**

a = np.array([1, 2, 3], dtype=int, order='C')
    b = np.array([11, 12, 13], dtype=int, order='C')
    for x, y in np.nditer([a, b]):
        print(x, y)
    复制代码

**输出：**

1 11
    2 12
    3 13
    复制代码

## 其他函数 ##

### 1、flatten函数 ###

`flatten` 函数将多维 *ndarray* 展开成一维 *ndarray* 返回。 **语法：**

flatten(order='C')
    复制代码

**示例：**

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]], dtype=int, order='C')
    b = a.flatten()
    print(b)
    print(type(b))
    复制代码

**输出：**

[1 2 3 4 5 6]
    <class 'numpy.ndarray'>
    复制代码

### 2、flat ###

`flat` 返回一个迭代器，可以遍历数组中的每一个元素。

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]], dtype=int, order='C')
    for b in a.flat:
        print(b)
    print(type(a.flat))
    复制代码

**输出：**

1
    2
    3
    4
    5
    6
    <class 'numpy.flatiter'>
    复制代码

--------------------

欢迎关注我的公众号

**大龄码农的Python之路**

[NumPy _1_NumPy]: https://juejin.im/post/5c8b09b2f265da2dc13cc871
[NumPy _2]: https://juejin.im/post/5c8ee28ef265da67ff3000e8
[NumPy _3_ndarray]: https://juejin.im/post/5ca17073f265da30b2476570
[en.wikipedia.org_wiki_Row-_a]: https://link.juejin.im?target=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FRow-_and_column-major_order