Как использовать пару вложенных циклов для итерации по 2-мерному массиву?

Question

Необходимо принять значения из одного массива, поместить их через функцию и поместить их в другой массив. Он предназначен для использования пары вложенных циклов. Пожалуйста помоги. Полный новичок здесь.

EDIT: ОК, чтобы уточнить, у меня есть 2-мерный массив с различными значениями в нем. Я хочу применить функцию ко всем этим значениям и вернуть 2-мерный массив со значениями после того, как они пройдут через эту функцию. Я работаю на 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

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

Что-то подобное?

Answer 2

Из того, что я могу получить с точки зрения контекста от вопроса и что 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]] 

Значение выше использует список понимание, которое является тем же самым как использование двух вложенных для циклов и в этом случае более читаемых и включает в себя менее прямое взаимодействие методов list, поскольку вы описываете, что такое list, а не строит его.

Answer 3

Вот одна линия с двойной картой

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 4

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

map(map_row,my_2d_list) 

, вероятно, как бы я это сделать ...

Answer 5

Легко сделать это с вложенным контуром:

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 6

На основании вашего вопроса, похоже, вы используете 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 7

Во-первых, у вас есть ошибка в вашем коде в следующей строке:

a = makeGrid 

Вы устанавливаете a быть функцией, а не массивом. Вы должны иметь следующее:

a = makeGrid(dim) 

Вот почему вы имели TypeError, когда вы пытались ответить на @abought.

Теперь, чтобы применить элемент операции в numpy, есть много возможностей. Если вы хотите выполнить ту же операцию для каждого элемента в массиве, самый простой способ заключается в использовании операции над массивами:

b = a * 2 

(Обратите внимание, что вам не нужно объявлять заранее b И вы надеваете. не нужны никакие циклы.) У Numpy есть также множество оптимизированных по C функций, которые выполняют одну и ту же операцию для каждого элемента массива. Они называются ufuncs. Вы можете комбинировать ufuncs, чтобы получить сложные выражения, оцениваемые по элементам. Например:

Ваш a массив из makeGrid() также может быть гораздо более эффективно созданы с помощью операции над массивами и NumPy-х mgrid:

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 имеет способ разложения петель на массиве nD с использованием ndenumerate или ndidex. Ваш пример с ndenumerate:

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

Это быстрее, чем несколько петель, но работа с массивами следует использовать всякий раз, когда это возможно.