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也可以更有效地创建来自a的{{1}}数组：

makeGrid()

如果要对每个数组元素执行不同的操作，事情会变得更复杂，并且可能无法避免循环。对于这些情况，numpy有一种方法可以使用ndenumerate或ndidex来分解nD数组上的循环。您的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)示例：

ndenumerate

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

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])

那样的东西？

如何使用一对嵌套for循环迭代2-d数组？

7 个答案: