Python Numpy where（），使用随数组中项目位置变化的条件

我正在尝试使用numpy构建一个网格世界

网格为4*4，呈正方形布置。
第一个和最后一个方块（即1和16）是终端方块。
在每个时间步中，您可以向任意方向移动一步：向上、向下、向左或向右。 一旦你进入一个终端方块，就不可能再移动了，游戏就结束了

第一列和最后一列是正方形的左边缘和右边缘，而第一行和最后一行表示顶部和底部边缘。 如果你在一条边上，例如左边的边，并试图向左移动，而不是向左移动，你会停留在你开始的正方形中。同样，如果你尝试穿过任何其他边，你将保持在同一个正方形中

虽然网格是正方形，但我已经将其实现为数组

状态\u r计算右移后状态的位置。1和16保持在原来的位置，因为它们是终端状态（注意，代码使用基于零的计数，因此1和16在代码中分别为0和15）。
其余的方块增加1。州代码可以工作，但是右边的正方形（4、8、12）也应该保持在原来的位置，但州代码不能这样做

State_l是我尝试包含正方形左边缘的边缘条件。逻辑是相同的，终端状态（1，16）不应该移动，左边的方块（5，9，13）也不应该移动。我认为一般的逻辑是正确的，但它产生了一个错误

states = np.arange(16)
states_r = states[np.where((states + 1 <= 15) & (states != 0), states + 1, states)]
states_l = states[np.where((max(1, (states // 4) * 4) <= states - 1) & (states != 15), states - 1, states)]

states=np.arange（16）
states_r=states[np.where（（states+1如果我理解正确，您需要根据移动（右、左、上、下）为每个状态指示下一个状态的数组）。
如果是这样的话，我想你的
state\u r
实现是不对的。我建议你切换到网格的2D表示，因为如果你直接使用x和y（至少对我来说），你描述的很多事情都更容易、更直观地处理

将numpy导入为np
n=4
状态=np.arange（n*n）.重塑（n，n）
states\u r，states\u l，states\u，states\u d=（states.copy（），states.copy（），
states.copy（），states.copy（））
状态_r[：，：n-1]=状态[：，1:]
状态l[：，1::=状态[：，：n-1]
状态_u[1:，：]=状态[：n-1，：]
状态d[：n-1，：]=状态[1:，：]
#向上[[0,1,2,3]，
#左状态右[0,1,2,3]，
#向下[4,5,6,7]，
#                        [ 8,  9, 10, 11]]
#
#  [[ 0,  0,  1,  2],   [[ 0,  1,  2,  3],   [[ 1,  2,  3,  3],
#   [ 4,  4,  5,  6],    [ 4,  5,  6,  7],    [ 5,  6,  7,  7],
#   [ 8,  8,  9, 10],    [ 8,  9, 10, 11],    [ 9, 10, 11, 11],
#   [12, 12, 13, 14]]    [12, 13, 14, 15]]    [13, 14, 15, 15]]
#
#                       [[ 4,  5,  6,  7],
#                        [ 8,  9, 10, 11],
#                        [12, 13, 14, 15],
#                        [12, 13, 14, 15]]

如果要排除端子状态，可以执行以下操作：

terminal_states=np.zeros（（n，n），dtype=bool）
终端状态[0，0]=真
终端状态[-1，-1]=真
状态[终端状态]=状态[终端状态]
状态[终端状态]=状态[终端状态]
状态[终端状态]=状态[终端状态]
状态d[终端状态]=状态[终端状态]

如果您更喜欢1D方法：

将numpy导入为np
n=4
状态=np.arange（n*n）
有效的（n*n，dtype=bool）
有效的\u s[0]=错误
有效的\u s[-1]=错误
状态r=np.其中（np.逻辑状态和（有效状态，状态%n0），状态-1，状态）
states\u=np.where（np.logical\u和（valid\u s，states>n-1），states-n，states）
状态d=np.其中（np.逻辑和（有效状态
不预先分配数组的另一种方法：

states = np.arange(16).reshape(4,4)

states_l = np.hstack((states[:,0][:,None],states[:,:-1],))
states_r = np.hstack((states[:,1:],states[:,-1][:,None]))
states_d = np.vstack((states[1:,:],states[-1,:]))
states_u = np.vstack((states[0,:],states[:-1,:]))

要将它们全部放在1-D中，您可以始终
flant（）/ravel（）/reforme（-1）
2-D数组

                  [[ 0  1  2  3]
                   [ 0  1  2  3]
                   [ 4  5  6  7]
                   [ 8  9 10 11]]

[[ 0  0  1  2]    [[ 0  1  2  3]    [[ 1  2  3  3]
 [ 4  4  5  6]     [ 4  5  6  7]     [ 5  6  7  7]
 [ 8  8  9 10]     [ 8  9 10 11]     [ 9 10 11 11]
 [12 12 13 14]]    [12 13 14 15]]    [13 14 15 15]]
                  
                  [[ 4  5  6  7]
                   [ 8  9 10 11]
                   [12 13 14 15]
                   [12 13 14 15]]

对于拐角处，您可以执行以下操作：

states_u[-1,-1] = 15
states_l[-1,-1] = 15

你解释了游戏，但是你想在
state\u l
和
state\u r
中存储什么？值得注意的是，第一个和最后一个方块的索引分别为
0
和
15
，正如你所说的“即1和16”。