这更多是关于优雅和性能的问题，而不是“根本如何做”，因此我将仅显示代码：

def iterate_adjacencies(gen, fill=0, size=2, do_fill_left=True,

do_fill_right=False):

""" Iterates over a 'window' of `size` adjacent elements in the supploed

`gen` generator, using `fill` to fill edge if `do_fill_left` is True

(default), and fill the right edge (i.e. last element and `size-1` of

`fill` elements as the last item) if `do_fill_right` is True. """

fill_size = size - 1

prev = [fill] * fill_size

i = 1

for item in gen: # iterate over the supplied `whatever`.

if not do_fill_left and i < size:

i += 1

else:

yield prev + [item]

prev = prev[1:] + [item]

if do_fill_right:

for i in range(fill_size):

yield prev + [fill]

prev = prev[1:] + [fill]

然后问：该功能已经存在吗？而且，如果没有，您能否以更好的方式(例如，更简洁和/或更快速)来做相同的事情？

编辑：

从@ agf，@ FogleBird，@ senderle的答案中得到的想法，最终的代码看起来很整洁：

def window(seq, size=2, fill=0, fill_left=True, fill_right=False):

""" Returns a sliding window (of width n) over data from the iterable:

s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...

"""

ssize = size - 1

it = chain(

repeat(fill, ssize * fill_left),

iter(seq),

repeat(fill, ssize * fill_right))

result = tuple(islice(it, size))

if len(result) == size: # `<=` if okay to return seq if len(seq) < size

yield result

for elem in it:

result = result[1:] + (elem,)

yield result

假设我们有一个数字nums的列表，可以说两个数字nums [i]≤nums [j]在没有数字的情况下是相邻的(nums [i]，nums [j])。我们必须找到可能的最小值| j-i | 这样nums [j]和nums [i]是相邻的。

因此，如果输入类似于nums = [1，-9，6，-6，2]，则输出将为2，因为我们可以看到2和6相邻，并且它们彼此相距2个索引。

范例(Python)

让我们看下面的实现以更好地理解-

from collections import defaultdict

class Solution:

def solve(self, A):

indexes = defaultdict(list)

for i, x in enumerate(A):

indexes[x].append(i)

ans = len(A)

for row in indexes.values():

for i in range(len(row) - 1):

ans = min(ans, row[i + 1] - row[i])

vals = sorted(indexes)

for k in range(len(vals) - 1):

r1 = indexes[vals[k]]

r2 = indexes[vals[k + 1]]

i = j = 0

while i 

ans = min(ans, abs(r1[i] - r2[j]))

if r1[i] 

i += 1

else:

j += 1

return ans

ob = Solution()

nums = [1, -9, 6, -6, 2]

print(ob.solve(nums))

输入值

[1, -9, 6, -6, 2]输出结果2

我有一个矩阵

例如.

[[4,5,0,0,0],

[5,1,2,1,0],

[0,2,3,2,0],

[0,1,2,1,0],

[0,0,0,0,0]]

对于矩阵中的每个元素,我试图获取其相邻对角元素的总和及其相邻水平和垂直元素的总和.

以矩阵中间的3为例,我试图计算对角相邻元素(1)与水平和垂直相邻元素(2)的总和.

对于拐角和边缘情况,我想忽略没有元素的区域,例如(对于左上角的4,我想获得对角线相邻的1的总和以及水平和垂直相邻的总和5的.

在python中最有效的方法是什么？

到目前为止,我已经提出了

diagonals = lambda x,y:[(x-1, y-1), (x-1,y+1), (x+1,y-1), (x+1,y+1)]

horiz_vert= lambda x,y:[(x,y+1), (x,y-1), (x+1,y), (x-1,y)]

以获得索引,但是这些没有考虑边缘和拐角情况.

解决方法:

解决此任务的正确工具似乎是convolution.您只需定义将在每个位置应用的过滤器(“对角线邻居的总和”或“垂直/水平邻居的总和”)就可以了.

import numpy as np

import scipy.signal

D = np.array([[4,5,0,0,0],

[5,1,2,1,0],

[0,2,3,2,0],

[0,1,2,1,0],

[0,0,0,0,0]])

h_diag = np.array([[1,0,1], [0,0,0], [1,0,1]])

h_hv = np.array([[0,1,0], [1,0,1], [0,1,0]])

过滤器的外观如下：

>>> h_diag

array([[1, 0, 1],

[0, 0, 0],

[1, 0, 1]])

>>> h_hv

array([[0, 1, 0],

[1, 0, 1],

[0, 1, 0]])

您可以将2D卷积视为在矩阵上移动滤波器并在每个位置计算逐元素相乘之和.严格来说,过滤器需要镜像,但是在您的情况下,它们还是对称的.这是网上的原理的随机说明：

您的情况的唯一区别是我们希望将过滤器放置在任何地方,包括“边界”或“角”位置.这可以通过对原始矩阵D进行零填充来实现,从而可以将滤波器的中心放置在例如在位置(0,0).

好消息！它已经在Numpy / Scipy中实现,并且是非常有效的实现！现在,您只需将D与滤波器h卷积即可构造矩阵.

>>> scipy.signal.convolve2d(D, h_diag, mode='same')

array([[1, 7, 2, 2, 1],

[7, 7, 9, 3, 2],

[2, 9, 4, 4, 2],

[2, 3, 4, 3, 2],

[1, 2, 2, 2, 1]])

>>> scipy.signal.convolve2d(D, h_hv, mode='same')

array([[10, 5, 7, 1, 0],

[ 5, 14, 5, 4, 1],

[ 7, 5, 8, 5, 2],

[ 1, 4, 5, 4, 1],

[ 0, 1, 2, 1, 0]])

从这些矩阵中,您可以读取每个位置所需的总和.例如.原始矩阵D中的中心元素,即D [2,2]在对角线上被4包围,在水平/垂直邻接上被4包围.因此,卷积输出中在位置(2,2)上的条目是4和8.位置D [0,0]仅具有一个对角邻居(1)和两个水平/垂直邻居(5和5).卷积输出矩阵中的条目与预期的1和10.

标签：matrix,python