如何使用一对嵌套的 for 循环来迭代二维数组？

Question

需要从一个数组中取出值，通过一个函数将它们放入另一个数组中。这意味着使用一对嵌套的 for 循环来完成。请帮忙。在这里完成初学者。

编辑：好的，澄清一下，我有一个包含各种值的二维数组。我想对所有这些值应用一个函数，并在它们通过函数后返回一个带有值的二维数组。我在 python 中工作。感谢您的快速回复以及您可以提供的任何帮助！

EDIT3：示例代码：

import numpy as N

def makeGrid(dim):
    ''' Function to return a grid of distances from the centre of an array.
    This version uses loops to fill the array and is thus slow.'''
    tabx = N.arange(dim) - float(dim/2.0) + 0.5
    taby = N.arange(dim) - float(dim/2.0) + 0.5
    grid = N.zeros((dim,dim), dtype='float')
    for y in range(dim):
        for x in range(dim):
            grid[y,x] = N.sqrt(tabx[x]**2 + taby[y]**2)
    return grid

import math

def BigGrid(dim):
    l= float(raw_input('Enter a value for lambda: '))
    p= float(raw_input('Enter a value for phi: '))
    a = makeGrid 
    b= N.zeros ((10,10),dtype=float) #Create an arry to take the returned values
    for i in range(10):
        for j in range (10):
            b[i,j] = a[i][j]*2


if __name__ == "__main__":
    ''' Module test code '''
    size = 10 #Dimension of the array
    newGrid = BigGrid(size)
    newGrid = N.round(newGrid, decimals=2)
    print newGrid

Answer 1

def map_row(row):
    return map(some_function,row)

 map(map_row,my_2d_list)

我可能会这样做......

Answer 2

根据您的问题，您似乎正在使用 Numpy。如果您不太关心速度，您可以简单地使用 numpy 数组调用该函数；该函数将为您对整个数组进行操作。

没有必要明确地编写迭代，但如果你能找到一种方法来利用 numpy 的特殊功能，那将比使用设计为一次操作一个元素的函数更快。不过，除非您使用的是非常大的数据集，否则应该没问题：

import numpy as np
>>> g = np.array( [ [1,2,3], [ 4,5,6] ] )
array([[1, 2, 3],
       [4, 5, 6]])
>>> def myfunc( myarray ):
...     return 2 * myarray
... 
>>> myfunc(g)
array([[ 2,  4,  6],
       [ 8, 10, 12]])

Answer 3

首先，您的代码在以下行中存在错误：

a = makeGrid

您将a 设置为函数，而不是数组。您应该具备以下条件：

a = makeGrid(dim)

这就是为什么您在尝试@abought 的答案时得到TypeError 的原因。

现在，在 numpy 中按元素应用操作有很多可能性。如果要对数组中的每个元素执行相同的操作，最简单的方法是使用数组操作：

b = a * 2

（请注意，您不需要事先声明b。而且您也不需要任何循环。）Numpy 还有许多 C 优化函数，它们对数组的每个元素执行相同的操作。这些被称为ufuncs。您可以结合 ufunc 来获得按元素评估的复杂表达式。例如：

b = N.sin(a**2) + N.log(N.abs(a))

使用数组操作和 numpy 的 mgrid 也可以更有效地创建来自 makeGrid() 的 a 数组：

grid = N.mgrid[-dim//2 + 1:dim//2:0.5, -dim//2 + 1:dim//2:0.5]
grid = N.sqrt(grid[0]**2 + grid[1]**2)

如果您想对每个数组元素执行不同的操作，事情会变得更加复杂，并且可能无法避免循环。对于这些情况，numpy 可以使用ndenumerate 或ndidex 分解nD 数组上的循环。你的例子ndenumerate:

for index, x in N.ndenumerate(a):
    b[index] = x * 2

这比多次循环要快，但应尽可能使用数组操作。

Answer 4

根据我从问题中获得的上下文以及2d-array 通常意味着什么，看起来您正在尝试执行以下操作：

>>>> array2d = [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
>>> def add_two( v ):
...     return v + 2
... 
>>> [ [ add_two( v ) for v in row ] for row in array2d ]
[[2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]

上面使用了一个列表解析，它与使用两个嵌套的 for 循环相同，在这种情况下更具可读性并且涉及较少的 list 方法的直接交互，因为您正在描述 list 是什么而不是构建它。

Answer 5

这里是单线双地图

map(lambda x:map(func, x), l)

例子：

l=[[1,2,3],[4,3,1]]
map(lambda x:map(lambda x:x*10,x),l)

[[10, 20, 30], [40, 30, 10]]

Answer 6

使用嵌套循环很容易做到：

def my_function(n): # n will become y from the next part
   new_num = # do whatever you want with it
   return new_num

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # just an example
new_list, final_list = [], [] # multiple assignment
for x in my_list:
   print x
   new_list = []
   for y in x:
      # y is now the first value of the first value of my_list--- 1.
      my_num = my_function(y)
      new_list.append(my_num)
   final_list.append(new_list)
print final_list

应该可以的。

返回：[[2, 3, 4], [5, 6, 7], [8, 9, 10]]。

Answer 7

for(int i; i < x; i++)
   for(int j; j < y; j++)
       array2[i][j] = func(array2[i][j])

类似的东西？