Python3.1网格模拟概念问题

Question

目标是将一维阵列视为二维栅格。第二个1D数组给出了需要在网格中更改的值的列表，第三个数组表示更改的程度。在

问题是围绕修改后的值也会发生变化。在

下面的示例保持为1D数组，但对其进行计算时就像它是二维网格一样。它可以工作；但当前它会更改网格中与1D列表（示例）中的值匹配的所有值。我不想只转换1个值及其周围环境，对于列表中的1个值。在

也就是说，如果列表是[2,3]；我只想更改迭代中遇到的第一个2和3值。目前的例子，在网格中每2个改变一次。在

让我困惑的是（可能是因为我构造修改计算的方式），我不能简单地遍历网格并在每次匹配时删除一个列表值。在

提前感谢您抽出时间！！在

守则如下：

import numpy

def grid_range(value):
    if value > 60000:
        value = 60000
        return (value)
    elif value < 100:
        value = 100
        return(value)
    elif value <= 60000 and value >= 100:
        return(value)


def grid(array,samples,details):

    original_length = len(array)
    c = int((original_length)**0.5)

    new_array = []                                                                  #create a new array with the modified values

    for elem in range (len(array)):                                                 #if the value is in samples
        if array[elem] in samples:
            value = array[elem] + (array[elem] * (details[1]/100))
            test_range = grid_range(value)
            new_array.append(test_range)

        elif ((elem + 1) < original_length) and array[elem - 1] in samples:                                          #change the one before the value                                 
            if (len(new_array) % c == 0) and array[elem + 1] not in samples:                             
                new_array.append(array[elem])
            else:
                new_forward_element = array[elem] +(array[elem] * (details[2]/100))   
                test_range1 = grid_range(new_forward_element)
                new_array.append(test_range1)

        elif ((elem + 1) < original_length) and (array[elem + 1]) in samples:       #change the one before and that it doesn't attempt to modify passed the end of the array                                 
            if (len(new_array) + 1) % c == 0:
                new_array.append(array[elem])
            else:
                new_back_element = array[elem] +(array[elem] * (details[2]/100))
                test_range2 = grid_range(new_back_element)    
                new_array.append(test_range2)

        elif ((elem+c) <= (original_length - c))and(array[elem + c]) in samples:    #if based on the 9 numbers on the right of the keyboard with test value numebr 5; this is position '2' 
            extra1 = array[elem] +(array[elem] * (details[2]/100))
            test_range3 = grid_range(extra1)
            new_array.append(test_range3)

        elif (array[abs(elem - c)]) in samples:                                     #position '8'
            extra2 = array[elem] +(array[elem] * (details[2]/100))
            test_range4 = grid_range(extra2)
            new_array.append(test_range4)

        elif (array[abs(elem - (c-1))]) in samples:                                 #position '7' 
            if (elem - (c-1)) % c == 0:
                new_array.append(array[elem])
            else:
                extra3 = array[elem] +(array[elem] * (details[2]/100))
                test_range5 = grid_range(extra3)
                new_array.append(test_range5)

        elif (array[abs(elem - (c+1))]) in samples:                                 #position '9'    
            if (elem - (c+1) + 1) % c == 0:
                new_array.append(array[elem])

            else:
                extra4 = array[elem] +(array[elem] * (details[2]/100))
                test_range6 = grid_range(extra4) 
                new_array.append(test_range6)

        elif ((elem +(c-1)) < original_length) and (array[elem + (c-1)]) in samples:    #position '1', also not passed total array length
            if (elem + (c-1)+ 1) % c == 0:
                new_array.append(array[elem])
            else:            
                extra5 = array[elem] +(array[elem] * (details[2]/100))
                test_range7 = grid_range(extra5)
                new_array.append(test_range7)

        elif (elem + (c+1)) < (len(array)- c) and (array[elem + (c+1)]) in samples:     #position '3', also not passed total array length
            if (elem + (c+1)) % c == 0:
                new_array.append(array[elem])
            else:
                extra6 = array[elem] +(array[elem] * (details[2]/100))
                test_range8 = grid_range(extra6)
                new_array.append(test_range8)

        else:
            new_array.append(array[elem])

    return(new_array)


a = [16,2,20,4,14,6,70,8,9,100,32,15,7,14,50,20,17,10,9,20,7,17,50,2,19,20]
samples = [2]
grid_details = [10,50,100]

result = grid(a,samples,grid_details)

编辑：

根据你的回答，Joe，我创建了一个版本，它将主值（中心）修改为特定的%并将周围的元素修改为另一个。但是，如何确保在下一次样本迭代期间不会再次转换更改的值。在

感谢您抽出时间！在

示例代码：

^{pr2}$

PS：我不想避免修改网格中的任何值，这些值之前已经被修改过，无论是主值还是周围的值。在

Answer 1

你没有说明你必须以任何具体的方式来做，所以我假设你愿意接受建议。 一种完全不同（而且更简单）的方法是制作数组：

grid = [[0,0,0,0,0],
        [0,0,0,2,0],
        [1,0,0,0,0],
        [0,0,0,0,0],
        [0,0,3,0,0]]

要访问网格上的某个位置，只需提供列表（行）的索引，然后提供该网格上位置的索引（列）。例如：

^{pr2}$

要创建非硬编码网格（例如可变大小）：

def gridder(width,height):
    list = []
    sublist = []
    for i in range(0,width):
        sublist.append(1)
    for i in range(0,height):
        list.append(sublist)
    return list

要修改网格的一部分：

def modifier(x,y,value):
    grid[y][x] = value

*如果这是家庭作业，你应该按照答案中指定的方式来做，那么你可能不能使用这个答案。在

Answer 2

首先，我不太清楚你在问什么，所以如果我完全误解了你的问题，请原谅我。。。在

你说你只想修改第一个等于给定值的项，而不是全部。如果是这样，您将需要在找到第一个值之后添加一个break，否则您将继续循环并修改所有其他值。在

然而，有更好的方法去做你想做的事。在

另外，你在顶部导入numpy，然后再也不会（？）使用它。。。在

这正是你想用numpy来做的事情，所以我将给出一个使用它的例子。在

看起来你只是将一个函数应用到一个2D数组的3x3移动窗口中，其中数组的值与某个给定值匹配。在

如果我们想将给定索引周围的3x3区域设置为某个值，我们可以这样做：

x[i-1:i+1, j-1:j+1] = value 

…其中x是数组，i和{}是行和列，value是要设置它们的值。（类似地，x[i-1:i+1, j-1:j+1]返回<i,j>周围的3x3数组）

此外，如果我们想知道<i,j>表示数组中某个特定值的位置，我们可以使用^{}，它将为给定条件为真的每个位置返回一个<i,j>表示的列表。在

（在numpy数组上使用条件会导致一个布尔数组，显示条件的真或假。因此，x >= 10将生成与x形状相同的布尔数组，而不是只是True或{}。这让您可以做一些很好的事情，比如x[x>100] = 10来设置x中所有大于100到10的值。）

综上所述，我相信这段代码可以实现您想要的效果：

^{pr2}$

这就产生了：

Original Data:
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 50 87 88 89]
 [90 91 92 93 94 95 96 97 98  2]]

Modified Data:
[[  0 200 200 200   4   5   6   7   8   9]
 [ 10 200 200 200  14  15  16  17  18  19]
 [ 20  21  22  23  24  25  26  27  28  29]
 [ 30  31  32  33  34  35  36  37  38  39]
 [ 40  41 500 500 500  45  46  47  48  49]
 [ 50  51 500 500 500  55  56  57 100 100]
 [ 60  61 500 500 500  65  66  67 100 100]
 [ 70  71  72  73  74  75  76  77 100 100]
 [ 80  81  82  83  84  85  50  87  88  89]
 [ 90  91  92  93  94  95  96  97  98   2]]

最后，您提到您希望“同时以N维数组和“平面”列表的形式查看某些内容”。从某种意义上说，这就是numpy数组已经存在的。在

例如：

import numpy as np

x = np.arange(9)
y = x.reshape(3,3)

print x
print y

y[2,2] = 10000

print x
print y

这里，y是x的“视图”。如果我们改变y的元素，我们就会改变x的相应元素，反之亦然。在

类似地，如果我们有一个2D数组（或者3D，4D等等），我们想把它看作一个“平面”1D数组，你可以调用flat_array = y.ravel()，其中y是你的2D数组。在

希望这能有所帮助，无论如何！在