处理2D列表Python的周围环境

Question

I want to go through a 2D list of numbers and I want to do some calculations with each element and its surrounding elements. Whenever a number is at a "wall" it should calculate with itself. eg.

list1 =[[1,2,3],
        [4,5,6],
        [7,8,9]]

list1[1][1] = 5 + 4 + 2 + 6 + 8 #element in the middle will be replaced by the 
number itself + its surrounding numbers

list1[0][0] = 1 + 1 + 1 + 2 + 4 
#element in the left top corner will be replace by the 
number itself + its surrounding 
(as there is no element above or left from it, it will be + the number itself (here 1))

I thought about doing some if-statements in a double for loop to deal with the numbers in the corners and at the walls:

for i in range(len(list1)):
    for j in range(len(list1[i])):

      if j == 0 : #elements at the left wall
        #do something
      elif i == 0 and j == 0: #element in the top left corner

      ...

my first question is:

is there a smarter way to deal with the surrounding of a 2D list? is there a function that can do something like:

if Index out of range:
  do something (not throwing and error message but calculate like above)

my second question is:

i want to first calculate all values and then update the values of the matrix at once. I though about putting the new values in a copy of the first list

list2 = list1[:] #copy using slice method

but it seems like list2 is always the same as list1 and when the for loop reaches the second element, it has already replaced the first one by the new value

Thanks for any help!

Answer 1

UPDATE:

Although the operation is a convolution, in this case it can be computed way faster with simple vectorized additions, as explained in my other answer .

---

What you are describing is a convolution operation in 2 dimensions, and is an operation that appears very frequently in signal processing. A typical application is image filtering. Here is a good explanation, but it basically boils down to what you want to do.

There is a NumPy implementation of the operation in SciPy, convolve2d . A smart implementation of convolution will be way, way faster than a straightforward loop-based approach, so it's usually worth using an existing one. For your case, you could do something like:

import numpy as np
from scipy import signal

data = np.array([[1,2,3],
                 [4,5,6],
                 [7,8,9]])
kernel = np.array([[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]])
result = signal.convolve2d(data, kernel, boundary='symm', mode='same')
print(result)

>>> array([[ 9, 13, 17],
           [21, 25, 29],
           [33, 37, 41]])

Answer 2

I have realised that, for your case, which is rather simple (a small kernel with weights 1 or 0), you can also do the operation manually, only in a vectorized way:

import numpy as np

data = np.array([[1,2,3],
                 [4,5,6],
                 [7,8,9]])
result = np.zeros_like(data)
result += data
result[1:] += data[:-1]
result[:-1] += data[1:]
result[:, 1:] += data[:, :-1]
result[:, :-1] += data[:, 1:]
result[0] += data[0]
result[-1] += data[-1]
result[:, 0] += data[:, 0]
result[:, -1] += data[:, -1]
print(result)

>>> array([[ 9, 13, 17],
           [21, 25, 29],
           [33, 37, 41]])

I think this should in theory be faster, because you are just doing additions, although it has more Python-C trips (maybe some could be saved), so it may depend on the size of the matrix in the end.

UPDATE:

After a couple of quick tests, this method is indeed faster with an input of size 30x30 or bigger in my machine, so unless your input is really small (in which case performance won't matter anyway) you should prefer this method.