处理python中2D列表边界检查的最佳方法？

Question

I have one 2D list like following, I want to change cell value from 1 to 0 if the cell surrounding cell is 0 like

from
[
  [1, 0, 1, 0, 1],
  [0, 0, 1, 0, 0],
  [0, 0, 0, 0, 0],
  [1, 0, 1, 0, 1],
  [0, 0, 0, 0, 0],
  [1, 0, 1, 0, 1],
]
To
[
  [0, 0, 1, 0, 0],
  [0, 0, 1, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
]

I think I can use 8 if/else logic to check but wondering if there is a better or clean way to do it?

Answer 1

I will make use of python generator to get the valid neighbors, and use the all to check if all the neighbors are zero.

def update_cell(grid):
    if not grid or not grid[0]:
        return
    m, n = len(grid), len(grid[0])

    def is_valid(i, j):
        return 0 <= i < m and 0 <= j < n

    def neighbors(i, j):
        for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0), (-1, 1), (-1, -1), (1, -1), (1, 1)]:
            ni, nj = i+di, j+dj
            if is_valid(ni, nj):
                yield ni, nj

    for i in range(m):
        for j in range(n):
            if grid[i][j] and all(not grid[ni][nj] for ni, nj in neighbors(i, j)):
                grid[i][j] = 0


if __name__ == "__main__":

    grid = [
        [1, 0, 1, 0, 1],
        [0, 0, 1, 0, 0],
        [0, 0, 0, 0, 0],
        [1, 0, 1, 0, 1],
        [0, 0, 0, 0, 0],
        [1, 0, 1, 0, 1],
    ]

    update_cell(grid)

    print(grid)

   # prints
   #[[0, 0, 1, 0, 0], 
   # [0, 0, 1, 0, 0], 
   # [0, 0, 0, 0, 0], 
   # [0, 0, 0, 0, 0], 
   # [0, 0, 0, 0, 0], 
   # [0, 0, 0, 0, 0]]

Answer 2

Sum the 3x3 list-list around the point in question. Iff the sum is 1 (value of the center cell), you set it to 0 .

To pick out the 3x3 segment, you can

• Iterate over the 3x3 slices you want.
• Use slices of slices to make a new 3x3 segment for each check.
• Convert your list-list to a NumPy 2D array; NumPy has nice slicing capabilities.

Answer 3

I'd write the if's, but generating neighbors as in the other answer is elegant.

If you can alter the data structure and need speed then you can use ghost cells.

Surround your grid with zeros like this :

       0 0 0 0
1 2    0 1 2 0
4 5    0 4 5 0
       0 0 0 0

Then you can iterate from 1..n-1 and always have all neighbours

Answer 4

One way would be:

def neighbors(m,r,c):
    return sum((
        sum(m[r-1][max(0,c-1):c+2]) if 0 <= r-1 < len(m) else 0,
        sum(m[r  ][max(0,c-1):c+2]) if 0 <= r   < len(m) else 0,
        sum(m[r+1][max(0,c-1):c+2]) if 0 <= r+1 < len(m) else 0,
    )) - m[r][c]

It takes the sum of the 3x3 square around the (r,c) element, then subtracts the value at (r,c) .

There are innumerable ways to clean this up based on preference, for example:

def neighbors(m,r,c):
    return sum(
        sum(m[x][max(0,c-1):c+2]) for x in [r-1,r,r+1] if 0 <= x < len(m)
    ) - m[r][c]

The only real somewhat clever thing here is that you can sort of side-step out of bounds errors by using slicing. So x = [1,2,3]; print(x[100:200]) x = [1,2,3]; print(x[100:200]) will just print an empty list, no IndexError .

Do I think you should use this code instead of a simple nested for loop? Almost definitely not.