python 2D列表，包含原始2D列表中周围单元格的平均值

我需要编写一个函数blur（l），用它的邻域和自身的平均值替换2D矩阵（即，一个矩形的2D列表）中的每个单元格。每个单元最多有8个相邻单元，因此计算的平均值最多为9个单元。关于给定的列表，您可以假定它是矩形的，并且它只包含整数

！这必须在没有numpy的情况下完成

我尝试使用以下代码：

def blur(l):
    result = []
    for x in range(len(l) - 1):
        tussen = []
        for y in range(len(l) - 1):
            t = get_neighbor_sum(l, x, y)
            tussen.append(t)
        result.append(tussen)
    return result

def get_value(list, i, j):
    new_i = len(list) - 1
    new_j = len(list[new_i]) - 1
    print(i, j, new_i, new_j)
    return list[new_i][new_j]


def get_neighbor_sum(list, i, j):
    sum = 0
    for offset_i in [-1, 0, 1]:
        for offset_j in [-1, 0, 1]:
            sum += get_value(list, i + offset_i, j + offset_j)
    return sum

但出于某种原因，它只返回原始列表，有人能解释一下为什么以及如何修复它吗

import itertools

def get_neighbors(lst, point):
    x,y = point
    neighbors = []
    for offset_x, offset_y in itertools.product([-1, 0, 1], repeat=2):
        new_x, new_y = x + offset_x, y + offset_y
        try:
            neighbors.append(lst[new_y][new_x])
        except IndexError:
            continue
    return neighbors

这将为您提供

lst

中与点

相关的相邻单元格的所有值（该点应为
（列，行）
）形式的元组）。从那里，您应该能够遍历列表并将该元素替换为
sum（result）/len（result）

您甚至可以通过更改
get_neights
函数来接受一个参数，该参数表示要搜索的偏移量有多宽，以及每个偏移量的权重有多大

import itertools

def get_neighbors(lst, point, n=1, weights=None):
    if weights is None:
        weights = dict()
    x, y = point
    neighbors = []
    offsets = range(-n, n+1)
    for offset_x, offset_y in itertools.product(offsets, repeat=2)):
        new_x, new_y = x + offset_x, y + offset_y
        weight = weights.get(new_y, {}).get(new_x, 1)
        # defaults to 1.
        # Same as try: weights[new_y][new_x] except KeyError: 1
        try:
            neighbors.append(lst[new_y][new_x] * weight)
        except IndexError:
            continue
    return neighbors

这期望权重是一个dict的dict，它定义了应该给偏移量x和y多少权重，例如：

{-1: {-1: 0.5,
       0: 1,
       1: 0.5},
  1: {-1: 0.5,
       0: 1,
       1: 0.5}}

任何缺少的关键点都被假定为具有完整的权重，因此这将为下面标记为
X
的方块提供一半的权重

X O X
O O O
X O X

可能有更好的实现，但我不能马上想到一个：）

这将为您提供
lst
中与点
相关的相邻单元格的所有值（该点应为
（列，行）
）形式的元组）。从那里，您应该能够遍历列表并将该元素替换为
sum（result）/len（result）

您甚至可以通过更改
get_neights
函数来接受一个参数，该参数表示要搜索的偏移量有多宽，以及每个偏移量的权重有多大

import itertools

def get_neighbors(lst, point, n=1, weights=None):
    if weights is None:
        weights = dict()
    x, y = point
    neighbors = []
    offsets = range(-n, n+1)
    for offset_x, offset_y in itertools.product(offsets, repeat=2)):
        new_x, new_y = x + offset_x, y + offset_y
        weight = weights.get(new_y, {}).get(new_x, 1)
        # defaults to 1.
        # Same as try: weights[new_y][new_x] except KeyError: 1
        try:
            neighbors.append(lst[new_y][new_x] * weight)
        except IndexError:
            continue
    return neighbors

这期望权重是一个dict的dict，它定义了应该给偏移量x和y多少权重，例如：

{-1: {-1: 0.5,
       0: 1,
       1: 0.5},
  1: {-1: 0.5,
       0: 1,
       1: 0.5}}

任何缺少的关键点都被假定为具有完整的权重，因此这将为下面标记为
X
的方块提供一半的权重

X O X
O O O
X O X

可能有一个更好的实现，但我不能马上想到一个：）
get\u value（）应该检查您为函数提供的索引是否对列表有效。如果它们的索引无效，则get_neighbor_sum（）不应将它们相加，在角点处，平均值只能在四个值之间。这很难用两个函数来实现，因为我们必须为get_value（）返回一个无效的值（可能是浮点值），让get_neighbor_sum（）注意到这一点，而不是添加它

我认为您根本不需要函数get_value（），可以通过创建一个get_neighbor_average函数来简化它：

def get_neighbor_average(list, i, j):
    sum = 0
    div = 0
    for offset_i in [-1, 0, 1]:
        for offset_j in [-1, 0, 1]:
            new_i = i + offset_i
            new_j = j + offset_j
            if (new_i >= 0 and new_j >= 0 and new_i < len(list) and new_j < len(list)):
                sum += list[new_i][new_j]
                div += 1
    avg = sum / div
    return avg

def get_neighbor_average（列表，i，j）：
总和=0
div=0
对于[-1,0,1]中的偏移量_i：
对于[-1,0,1]中的偏移量_j：
新的_i=i+偏移量_i
新_j=j+偏移量_j
如果（new_i>=0和new_j>=0和new_i

这将为您提供所有邻居的平均值，但这是安全的，因为它检查我们尝试访问的列表元素是否有效。
get\u value（）应该检查您为函数提供的索引是否对列表有效。如果它们的索引无效，则get_neighbor_sum（）不应将它们相加，在角点处，平均值只能在四个值之间。这很难用两个函数来实现，因为我们必须为get_value（）返回一个无效的值（可能是浮点值），让get_neighbor_sum（）注意到这一点，而不是添加它

我认为您根本不需要函数get_value（），可以通过创建一个get_neighbor_average函数来简化它：

def get_neighbor_average(list, i, j):
    sum = 0
    div = 0
    for offset_i in [-1, 0, 1]:
        for offset_j in [-1, 0, 1]:
            new_i = i + offset_i
            new_j = j + offset_j
            if (new_i >= 0 and new_j >= 0 and new_i < len(list) and new_j < len(list)):
                sum += list[new_i][new_j]
                div += 1
    avg = sum / div
    return avg

def get_neighbor_average（列表，i，j）：
总和=0
div=0
对于[-1,0,1]中的偏移量_i：
对于[-1,0,1]中的偏移量_j：
新的_i=i+偏移量_i
新_j=j+偏移量_j
如果（new_i>=0和new_j>=0和new_i

这将为您提供所有邻居的平均值，但这是安全的，因为它会检查我们试图访问的列表元素是否有效。
请澄清一个问题：get\u value有什么用？如果你已经有了这个列表，为什么不直接从get_Neighbor_sum中获取值呢？
get_value
似乎有问题。它没有注意传递给它的
i
和
j
，斯巴达英雄，这个问题问得很好，很清楚，远不像我们在StackOverflow上看到的“给我密码”问题。完全值得回答，一句话也不抄袭，因为它来自拼写检查。只需澄清一个问题：get_value有什么用？如果你已经有了这个列表，为什么不直接从get_Neighbor_sum中获取值呢？
get_value
似乎有问题。它没有注意传递给它的
i
和
j
，斯巴达英雄，这个问题问得很好，很清楚，远不像我们在StackOverflow上看到的“给我密码”问题。完全值得回答，一句话也不抄袭，因为它来自拼写检查。谢谢，打字错误，我想使用列表索引。唯一的其他评论是小心索引。因为你有
i，j
作为
哪行，哪列
，而不是更常见的
（x，y）
符号（
哪列，哪行
）。这是没有打破，但需要仔细记录，因为它很容易出错