移动 Numpy 数组中的元素答案

【问题标题】：Shifting Elements in a Numpy Array移动 Numpy 数组中的元素
【发布时间】：2018-03-19 18:16:04
【问题描述】：

我正在尝试实现一个函数，它将 numpy 二维数组中的特定元素在给定方向上移动所需数量的空格。空格应该用 0 填充。该函数将输入一个 numpy 数组、x 和 y 坐标、所需方向以及要移动的空格数。

例如，其中 shift 是假设函数：

arr = np.array([1, 1, 1], [1, 1, 1], [1, 1, 1])
arr out: [[1, 1, 1],
          [1, 1, 1],
          [1, 1, 0]]

shift(arr, 0, 0, 'right', 2)
arr out: [[0, 0, 1],
          [1, 1, 1],
          [1, 1, 0]]

shift(arr, 0, 2, 'down', 1)
arr out: [[0, 0, 0],
          [1, 1, 1],
          [1, 1, 1]]

我发现我可以使用 numpy 的 roll 函数实现行或列的所有元素沿该行或列的所需移动。但是，这种方法只是将元素循环回到同一行或列的开头，并且不会用 0 填充空白空间。例如：

arr[:, 0] = np.roll(arr[:, 0], 1)
arr out: [[1, 0, 0],
          [0, 1, 1],
          [1, 1, 1]]

非常感谢任何帮助。

edit：x 和 y 坐标是要在 2d 数组中移动的元素的坐标。然后，同一行或列中的其余元素相对于该元素在所需方向上移动。例如 shift(arr, 2, 2, 'down', 1) 将列中的元素相对于 (2, 2) 处的元素向下移动 1。可以假定所有输入值始终有效。

edit：此问题与链接问题的不同之处在于元素相对于提供的坐标处的元素进行了移动，并且这种移动发生在嵌套数组中。此外，此解决方案不允许在同一列中向上或向下移动元素。

【问题讨论】：

Shift elements in a numpy array的可能重复
x,y坐标是什么意思？
班次数大于维数怎么办？
@J...S 我用更多信息更新了这个问题。
@AryaMcCarthy 我的问题与这个问题的不同之处在于元素相对于提供的坐标处的元素进行了移动，并且这种移动发生在嵌套数组中。

标签： python numpy

【解决方案1】：

这里有一个或多或少的综合函数来解决它：

def shift(a, i, j, dir, n, fill=0, inplace=False):
    out = a
    if not inplace:
        out = a.copy()
    if dir == 'down':
        if n < 0:
            return shift(out, i, j, 'up', -n, fill=fill, inplace=True)
        n = min(n, a.shape[0] - i)
        out[i+n:, j] = a[i:a.shape[0] - n, j]
        out[i:i+n, j] = fill
    elif dir == 'up':
        if n < 0:
            return shift(out, i, j, 'down', -n, fill=fill, inplace=True)
        n = min(n, i+1)
        out[:i+1-n, j] = a[n:i+1, j]
        out[i+1-n:i+1, j] = fill
    elif dir == 'right':
        if n < 0:
            return shift(out, i, j, 'left', -n, fill=fill, inplace=True)
        n = min(n, a.shape[1] - j)
        out[i, j+n:] = a[i, j:a.shape[1] - n]
        out[i, j:j+n] = fill
    elif dir == 'left':
        if n < 0:
            return shift(out, i, j, 'right', -n, fill=fill, inplace=True)
        n = min(n, j+1)
        out[i, :j+1-n] = a[i, n:j+1]
        out[i, j+1-n:j+1] = fill
    else:
        raise ValueError('Unknown direction "{}".'.format(dir))
    return out

一些测试：

import numpy as np

arr = np.arange(25).reshape((5, 5))
print(arr)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]
print(shift(arr, 2, 1, 'up', 2))
# [[ 0 11  2  3  4]
#  [ 5  0  7  8  9]
#  [10  0 12 13 14]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]
print(shift(arr, 2, 1, 'left', -2))
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10  0  0 11 12]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]
print(shift(arr, 2, 1, 'down', 1, fill=100))
# [[  0   1   2   3   4]
#  [  5   6   7   8   9]
#  [ 10 100  12  13  14]
#  [ 15  11  17  18  19]
#  [ 20  16  22  23  24]]
shift(arr, 2, 1, 'right', 3, inplace=True)
print(arr)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10  0  0  0 11]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]

编辑

根据 cmets 中的讨论，我添加了另一个函数来解决“滑动瓷砖”移动的问题：

import numpy as np

def shift_vector(v, i, n, empty=0):
    if n < 0:
        return shift_vector(v[::-1], len(v) - i - 1, -n)[::-1]
    if n < len(v) - i:
        # Find n empty places after i
        idx = np.where(np.cumsum(v[i + 1:] == empty) == n)[0]
        last_zero_idx = idx[0] if len(idx) > 0 else len(v) - i - 1
        # Get non-empty values
        v_slice = v[i + 1:i + last_zero_idx + 1]
        values = v_slice[np.where(v_slice != empty)[0]]
        # Copy to vector
        v[i + n] = v[i]
        r = range(i + n + 1, min(i + last_zero_idx + 2, len(v)))
        v[r] = values[:len(r)]
    v[i:i + n] = empty
    return v

def shift(a, i, j, dir, n, empty=0, inplace=False):
    out = a
    if not inplace:
        out = a.copy()
    if dir == 'down':
        out[:, j] = shift_vector(out[:, j], i, n, empty=empty)
    elif dir == 'up':
        out[:, j] = shift_vector(out[:, j], i, -n, empty=empty)
    elif dir == 'right':
        out[i, :] = shift_vector(out[i, :], j, n, empty=empty)
    elif dir == 'left':
        out[i, :] = shift_vector(out[i, :], j, -n, empty=empty)
    else:
        raise ValueError('Unknown direction "{}".'.format(dir))
    return out


m = np.array([[1, 0, 0, 2],
              [3, 4, 0, 0],
              [5, 0, 6, 7],
              [0, 8, 9, 0]])
print("m")
print(m)
print("shift(m, 1, 0, 'right', 2)")
print(shift(m, 1, 0, 'right', 2))
print("shift(m, 3, 1, 'down', -2)")
print(shift(m, 3, 1, 'down', -2))
print("shift(m, 0, 3, 'left', 3)")
print(shift(m, 0, 3, 'left', 3))
print("shift(m, 2, 2, 'up', 1)")
print(shift(m, 2, 2, 'up', 1))

输出：

m
[[1 0 0 2]
 [3 4 0 0]
 [5 0 6 7]
 [0 8 9 0]]
shift(m, 1, 0, 'right', 2)
[[1 0 0 2]
 [0 0 3 4]
 [5 0 6 7]
 [0 8 9 0]]
shift(m, 3, 1, 'down', -2)
[[1 4 0 2]
 [3 8 0 0]
 [5 0 6 7]
 [0 0 9 0]]
shift(m, 0, 3, 'left', 3)
[[2 0 0 0]
 [3 4 0 0]
 [5 0 6 7]
 [0 8 9 0]]
shift(m, 2, 2, 'up', 1)
[[1 0 0 2]
 [3 4 6 0]
 [5 0 0 7]
 [0 8 9 0]]

【讨论】：

如何修改这样的实现以允许将元素转移到数组中的空位置？
@martinsarif 不知道你的意思，也许你可以举个例子。
为简单起见，我将使用一维数组来演示正在执行移位操作的行或列的元素。考虑 [1, 0, 1, 0, 0]。假设我要将这一行或列 2 中的第一个元素移向末尾。这将导致以下新行或列 [0, 0, 1, 1, 0]。请注意，算法现在如何将这些元素视为数组中的空位置，而不是移动 0 元素。此外，每个元素都充当一种滑动块。这是否澄清了我的要求？
@martinsarif 不完全确定...所以如果我有一行[1, 1, 0, 1, 0] 并决定我想将第一个元素向右移动两个位置，结果应该是[0, 0, 1, 1, 1]？如果是这样的话，这似乎是一个相当不同（而且更难）的问题......另外，你的数组是否总是只由 1 和 0 组成？
您在那种情况下应该是什么解决方案是正确的。为了简单起见，我只使用了 1 和 0，它们可以是任何整数值。但是，0 被视为数组中的空位置。

【解决方案2】：

只需滚动然后将旋转的数据归零：

# Let direction = "down" and col = 0, n = 2
In [1]: i
Out[1]:
array([[1., 0., 0.],
       [1., 1., 1.],
       [0., 0., 1.]])

In [2]: i[:, col] = np.roll(i[:, col], n)

In [3]: i[:n, col] = 0

In [4]: i
Out[4]:
array([[0., 0., 0.],
       [0., 1., 1.],
       [1., 0., 1.]])

您需要为其他三个方向实现等效版本，但这只是这两行的变体。

【讨论】：