NumPy - 数组迭代



NumPy 中的数组迭代

在 NumPy 中迭代数组是指以系统的方式逐个访问数组中每个元素的过程。这通常使用循环来完成。迭代用于对每个元素执行操作,例如计算、修改或检查。

NumPy 提供了几种迭代数组的方法:

  • 使用 for 循环
  • 使用 'nditer()' 迭代器对象
  • 扁平迭代
  • 迭代顺序
  • 控制迭代顺序
  • 广播迭代
  • 使用矢量化操作
  • 外部循环
  • 修改数组值

使用 for 循环

在 NumPy 中,您可以使用基本的 Python **for 循环**来迭代数组。for 循环是一种控制流语句,用于迭代序列(例如列表、元组、字典、集合或字符串)。它允许您为序列中的每个元素重复执行一段代码。

迭代一维数组

一维数组基本上是元素的列表。迭代它很简单,类似于迭代常规 Python 列表。

示例

在下面的示例中,我们从元素列表创建一个 NumPy 数组,并使用 for 循环迭代每个元素:

import numpy as np

# Create a 1-dimensional NumPy array
arr = np.array([1, 2, 3, 4, 5])

# Iterate over the array
for element in arr:
   print(element)

以下是获得的输出:

1
2
3
4
5

迭代多维数组

NumPy 数组可以具有任意数量的维度,通常称为轴。例如:

  • 一维数组是元素的列表。
  • 二维数组类似于具有行和列的矩阵。
  • 三维数组可以可视化为二维矩阵的集合。

示例:迭代二维数组

当迭代二维数组时,每次迭代都访问数组的一整行,如下面的示例所示:

import numpy as np

# Create a 2D NumPy array (3x3 matrix)
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Iterate over the array
for row in arr_2d:
   print(row)

这将产生以下结果:

[1 2 3]
[4 5 6]
[7 8 9]

示例:迭代三维数组

当迭代三维数组时,每次迭代都访问一个完整的二维子数组(矩阵),如下面的示例所示:

import numpy as np

# Create a 3D NumPy array (2x2x3)
arr_3d = np.array([[[1, 2, 3],
                    [4, 5, 6]],
                   [[7, 8, 9],
                    [10, 11, 12]]])

# Iterate over the array
for matrix in arr_3d:
   print(matrix)

以下是上述代码的输出:

[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]

迭代多维数组中的元素

迭代 NumPy 中多维数组中的元素是一种访问每个单独元素的方式,而不管数组的维度如何。此过程需要嵌套循环来遍历数组结构的每个维度。

示例

在此示例中,我们使用嵌套循环来迭代每一行 (i) 和每一列 (j),使用索引访问和打印每个元素:

import numpy as np

# Create a 2-dimensional NumPy array
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Iterating over elements in the 2D array
# Iterate over rows
for i in range(arr_2d.shape[0]):   
   # Iterate over columns
   for j in range(arr_2d.shape[1]):  
      print(arr_2d[i, j])

获得的输出如下所示:

1
2
3
4
5
6
7
8
9

使用索引迭代

使用索引迭代 NumPy 数组用于通过数组每个维度内的特定位置访问数组元素。

在 NumPy 中,数组的索引从每个维度的 **0** 开始。使用索引迭代涉及使用嵌套循环遍历数组的每个维度,并使用其特定索引访问元素。

与简单的元素迭代相比,这种方法允许更精确地控制元素访问和操作。

示例

在下面的示例中,我们使用嵌套循环迭代二维数组的每个元素。我们访问并打印每个元素的值及其索引:

import numpy as np

# Create a 2-dimensional NumPy array
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Get the dimensions of the array
rows, cols = arr_2d.shape

# Iterate over the array using indices
for i in range(rows):
   for j in range(cols):
      print(f"Element at ({i}, {j}): {arr_2d[i, j]}")

执行上述代码后,我们得到以下输出:

Element at (0, 0): 1
Element at (0, 1): 2
Element at (0, 2): 3
Element at (1, 0): 4
Element at (1, 1): 5
Element at (1, 2): 6
Element at (2, 0): 7
Element at (2, 1): 8
Element at (2, 2): 9

使用 'nditer' 迭代器对象

NumPy 中的 **nditer()** 函数提供了一个高效的多维迭代器对象,可用于迭代数组的元素。它使用 Python 的标准迭代器接口访问数组的每个元素。

示例

在此示例中,nditer() 函数用于以扁平化的顺序迭代数组“arr”的所有元素,依次打印每个元素:

import numpy as np

# Example array
arr = np.array([[1, 2], [3, 4]])

# Iterate using nditer
for x in np.nditer(arr):
   print(x)

产生的结果如下:

1234

扁平迭代

扁平迭代是指迭代多维数组的所有元素,就好像它是一维数组一样。当您需要处理或操作数组中的每个元素而无需显式考虑其原始形状或维度时,此方法很有用。

示例

在此示例中,我们正在创建一个二维 NumPy 数组。然后,我们使用带有“buffered”标志的 np.nditer 以扁平化的顺序迭代此数组,依次打印每个元素:

import numpy as np

# Create a 2D array
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# Flat iteration using nditer with 'buffered' flag
print("Iterating over the array:")
for x in np.nditer(arr, flags=['buffered']):
   print(x, end=' ')

我们得到如下所示的输出:

Iterating over the array:
1 2 3 4 5 6 

迭代顺序

NumPy 中的迭代顺序是指在迭代期间访问数组元素的顺序。默认情况下,NumPy 数组以 **行优先** 顺序迭代,也称为 **C 风格** 顺序。

这意味着对于多维数组,迭代从第一个维度(行)开始,沿着最后一个维度(列)迭代所有元素。

示例

在此示例中,我们使用 numpy.nditer() 函数迭代数组,以默认的行优先顺序(C 风格)访问每个元素,并依次打印它们:

import numpy as np

# Create a 2D array
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# Iterate over the array
print("Default Iteration Order (C-style, row-major):")
for x in np.nditer(arr):
   print(x, end=' ')

以下是获得的输出:

Default Iteration Order (C-style, row-major):
1 2 3 4 5 6 

控制迭代顺序

控制 NumPy 中的迭代顺序允许您指定在迭代期间访问数组元素的方式。NumPy 提供了根据内存布局和性能考虑因素控制迭代顺序的选项:

  • **Fortran 风格顺序 -** 按列迭代元素(列优先顺序)。

  • for x in np.nditer(arr, order='F'):
        ...
    
  • **外部循环 -** 在迭代外部维度时保持内部维度完整。

  • for row in np.nditer(arr, flags=['external_loop']):
        ...
    

示例

在此示例中,我们使用 numpy.nditer() 函数迭代数组,以 Fortran 风格顺序(F 风格)访问每个元素:

import numpy as np

# array
arr = np.array([[1, 2], [3, 4]])

# Iterate in specified order (F-style)
for x in np.nditer(arr, order='F'):
   print(x)

这将产生以下结果:

1
3
2
4

广播迭代

NumPy 中的广播迭代是指同时迭代多个数组,其中数组被广播以具有兼容的形状。

这允许元素级运算在数组之间高效地应用,而无需显式对齐其维度。

示例

在下面的示例中,我们通过同时迭代两个数组 arr1 和 arr2 来演示 NumPy 中的广播迭代。

使用 nditer() 函数对“arr1”和“arr2”中每个对应元素求和,显示元素级运算,无需显式对齐数组维度:

import numpy as np

# arrays
arr1 = np.array([1, 2, 3])
arr2 = np.array([10, 20, 30])

# Broadcasting addition operation
print("Broadcasting Iteration:")
for x, y in np.nditer([arr1, arr2]):
   print(x + y, end=' ')

以下是上述代码的输出:

Broadcasting Iteration:
11 22 33 

使用矢量化操作

NumPy 中的矢量化运算是指一次对整个数组执行运算,而不是迭代单个元素。

示例

在下面的示例中,我们通过对两个数组 arr1 和 arr2 执行元素级加法来演示 NumPy 中的矢量化运算。这只需在数组之间使用 **+** 运算符即可实现:

import numpy as np

# Example arrays
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([10, 20, 30, 40])

# Vectorized addition operation
result = arr1 + arr2

print("Vectorized Operations:")
print("Result of addition:", result)

获得的输出如下所示:

Vectorized Operations:Result of addition: [11 22 33 44]

外部循环

在 NumPy 中,“外部循环”的概念是指在迭代数组时保持某些维度完整。这允许您迭代具有嵌套结构的数组,而无需将内部维度折叠成单个序列。

**numpy.nditer()** 函数在与 **external_loop** 标志一起使用时,允许在保留数组行结构的同时迭代数组元素。这确保每行都被单独处理,演示了整个迭代过程中维度的完整性是如何保持的。

示例

在下面的示例中,我们通过迭代二维数组来说明 NumPy 中的外部循环迭代:

import numpy as np

# array with multiple dimensions
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# External loop iteration
print("External Loop:")
for row in np.nditer(arr, flags=['external_loop']):
   print(row)

执行上述代码后,我们得到以下输出:

External Loop:[1 2 3 4 5 6]

修改数组值

修改 NumPy 中的数组值用于直接为数组内的特定元素或切片分配新值。这有助于就地更新数据,而无需重新创建整个数组。

**nditer** 对象还有另一个可选参数称为 **op_flags**。它的默认值为只读,但可以设置为读写或只写模式。这将启用使用此迭代器修改数组元素。

示例

在下面的示例中,我们使用 nditer() 函数修改 NumPy 中的数组值。通过将“op_flags”参数设置为“readwrite”,迭代器将数组 arr 的每个元素乘以 2:

import numpy as np

# Create a 1D array
arr = np.array([1, 2, 3, 4, 5])

# Modify array elements
with np.nditer(arr, flags=['buffered'], op_flags=['readwrite']) as it:
   for x in it:
      # Multiply each element by 2
      x[...] = x * 2  

print("Modified Array Example:",arr)

产生的结果如下:

Modified Array Example: [ 2  4  6  8 10]
广告