如何用Python获取二维列表指定坐标横竖及对角线上的所有坐标

现有如下6行8列的二维列表：

grid = [
    [0, 0, 0, 1, 3, 4, 0, 3],
    [0, 2, 0, 0, 2, 0, 0, 5],
    [0, 0, 0, 2, 0, 1, 1, 1],
    [2, 3, 4, 1, 3, 1, 0, 0],
    [0, 1, 5, 1, 6, 0, 2, 0],
    [2, 0, 2, 3, 1, 1, 1, 1]
]

需求为从给定坐标(row, col)出发，获取该位置所在水平方向、垂直方向、两条对角线方向的所有坐标：

• 示例给定坐标为(4,2)（对应位置值为5）
  • 垂直方向坐标：(0,2)、(1,2)、(2,2)、(3,2)、(4,2)、(5,2)
  • 水平方向坐标：(4,0)、(4,1)、(4,2)、(4,3)、(4,4)、(4,5)、(4,6)、(4,7)
  • 左上-右下对角线坐标：(2,0)、(3,1)、(4,2)、(5,3)（提问中提到的(3,1)..(5,3)是该对角线的部分段）
  • 右上-左下对角线坐标：(0,6)、(1,5)、(2,4)、(3,3)、(4,2)、(5,1)

当前已实现水平、垂直方向的坐标获取，但缺少对角线逻辑，原有代码如下：

def connected_values(arr,val,coord):
    #arr->[[2d list]]
    #coord -> given coordinate->(4,2)
    a,b=coord
    list=[]

    # arr=np.array(arr)
    for i in range(len(arr[0])):
        for j in range(len(arr[1])):
            if i==a and j==b:

                for k1 in range (0,i):
                    list.append((k1,b))
                for k2 in range(0,j):
                    list.append ((a,k2))
                for k3 in range(i,len(arr)):
                    list.append((k3,b))
                for k4 in range(j+1,len(arr[0])):
                    list.append((a,k4))

    return list

注：原有代码存在边界计算错误：len(arr)是二维数组的行数，len(arr[0])是列数，原代码混淆了两个值，非方阵场景下会出现索引越界问题，下文代码已修正该问题。

对角线坐标判断不需要遍历全数组，从目标点出发沿四个斜向遍历到边界即可，判断规则非常清晰：

• 左上-右下对角线：线上所有坐标满足行索引 - 列索引 = 目标点行索引 - 列索引，从目标点分别往「左上（行-1、列-1）」「右下（行+1、列+1）」遍历，直到超出数组边界
• 右上-左下对角线：线上所有坐标满足行索引 + 列索引 = 目标点行索引 + 列索引，从目标点分别往「右上（行-1、列+1）」「左下（行+1、列-1）」遍历，直到超出数组边界

def connected_values(arr, val, coord):
    rows = len(arr)
    cols = len(arr[0]) if rows > 0 else 0
    target_r, target_c = coord
    res = []

    #  获取垂直方向所有坐标（列固定，遍历所有行）
    for r in range(rows):
        res.append((r, target_c))
    
    # 获取水平方向所有坐标（行固定，遍历所有列，跳过已加入的目标点避免重复）
    for c in range(cols):
        if c != target_c:
            res.append((target_r, c))
    
    # 获取左上-右下对角线坐标
    # 往左上方向遍历
    r, c = target_r - 1, target_c - 1
    while r >= 0 and c >= 0:
        res.append((r, c))
        r -= 1
        c -= 1
    # 往右下方向遍历
    r, c = target_r + 1, target_c + 1
    while r < rows and c < cols:
        res.append((r, c))
        r += 1
        c += 1
    
    # 获取右上-左下对角线坐标
    # 往右上方向遍历
    r, c = target_r - 1, target_c + 1
    while r >= 0 and c < cols:
        res.append((r, c))
        r -= 1
        c += 1
    # 往左下方向遍历
    r, c = target_r + 1, target_c - 1
    while r < rows and c >= 0:
        res.append((r, c))
        r += 1
        c -= 1

    return res


# 测试验证
grid = [
    [0, 0, 0, 1, 3, 4, 0, 3],
    [0, 2, 0, 0, 2, 0, 0, 5],
    [0, 0, 0, 2, 0, 1, 1, 1],
    [2, 3, 4, 1, 3, 1, 0, 0],
    [0, 1, 5, 1, 6, 0, 2, 0],
    [2, 0, 2, 3, 1, 1, 1, 1]
]
print(connected_values(grid, 5, (4,2)))

传入坐标(4,2)运行后，返回结果包含所有水平、垂直、对角线坐标，和预期完全一致。如果需要按方向分组返回、或者过滤特定值，直接调整返回结构、增加值判断逻辑即可。

内容的提问来源于stack exchange，提问作者AlienwareR