Python can'；t从列表中删除元素，尽管它存在-Reversi

我正在尝试用Python编写一个简单的Reversi游戏

在我的代码中，有两个主要列表：

takenred-包含红色玩家占据的位置

takenblue-包含蓝色玩家占据的位置

玩家每次移动后，我都会更新这些列表，以包含每个玩家的更新位置

我的问题是：

当我使用输入运行代码时：

R

02

二十三

我收到一条错误消息，说在列表中找不到最后一个索引，因此无法删除

到目前为止，我尝试的是在for循环中使用缩进，因为代码的其余部分对我来说似乎是正确的

我的代码：

import numpy as np
import math


def isfull(board):
    for i in range(0, 4):
        for j in range(0, 4):
            if board[i][j] == 'e':
                return False
    return True


def main():
    board = np.empty([4, 4], dtype=str)
    for t in range(0, 4):
        for n in range(0, 4):
            board[t, n] = 'e'
    board[1, 1] = 'R'
    board[1, 2] = 'B'
    board[2, 1] = 'B'
    board[2, 2] = 'R'
    takenblue = [[1, 2], [2, 1]]
    takenred = [[1, 1], [2, 2]]
    toswitch1=[]
    toswitch2=[]
    print(board)
    player = str(input('input player R or B: '))
    otherplayer = 'e'
    while isfull(board) == False:
        if player == 'R':
            otherplayer = 'B'
        else:
            otherplayer = 'R'
        loc = list(input(player + 'loc '))
        for i in range(0, 2):
            loc[i] = int(loc[i], base=10)
        if player == 'R':
            if board[loc[0], loc[1]]=='e':
                for j in takenred:
                    if (loc[0] == j[0] or loc[1] == j[1] or abs(loc[1] - j[1]) == abs(loc[0] - j[0]) or abs(
                            loc[1] - j[1]) == abs(j[0] - loc[0])):
                        if (board[math.floor((loc[0] + j[0]) // 2), math.floor((loc[1] + j[1]) // 2)] == otherplayer):
                            board[math.floor((loc[0] + j[0]) // 2), math.floor((loc[1] + j[1]) // 2)] = player
                            board[loc[0], loc[1]] = player
                            toswitch1 = [math.floor((loc[0] + j[0]) // 2), math.floor((loc[1] + j[1]) // 2)]
                            print(takenred)
                            print(toswitch1)
                takenblue.remove(toswitch1)
                takenred.append(toswitch1)
                takenred.append(loc)
            print('R: ', takenred)
            print('B: ', takenblue)

        if player == 'B':
            if board[loc[0], loc[1]]=='e':
                for t in takenblue:
                    if (loc[0] == t[0] or loc[1] == t[1] or abs(loc[1] - t[1]) == abs(loc[0] - t[0]) or abs(
                            loc[1] - t[1]) == abs(t[0] - loc[0])):
                        if(board[math.floor((loc[0] + t[0]) // 2), math.floor((loc[1] + t[1]) // 2)] == otherplayer):
                            board[math.floor((loc[0] + t[0]) // 2), math.floor((loc[1] + t[1]) // 2)] = player
                            board[loc[0], loc[1]] = player
                            toswitch2 = [math.floor((loc[0] + t[0]) // 2), math.floor((loc[1] + t[1]) // 2)]
                            print(toswitch2)
                    takenred.remove(toswitch2)
                    takenblue.append(toswitch2)
                    takenblue.append(loc)
            print('B: ', takenblue)
            print('R: ', takenred)
        if player == 'B':
            player = 'R'
            otherplayer = 'B'
        else:
            player = 'B'
            otherplayer = 'R'
        print(board)


if __name__ == '__main__':
    main()

欢迎任何帮助

终端：

[['e' 'e' 'e' 'e']
 ['e' 'R' 'B' 'e']
 ['e' 'B' 'R' 'e']
 ['e' 'e' 'e' 'e']]
input player R or B: R
Rloc 02
[1, 2]
R:  [[1, 1], [2, 2], [1, 2], [0, 2]]
B:  [[2, 1]]
[['e' 'e' 'R' 'e']
 ['e' 'R' 'R' 'e']
 ['e' 'B' 'R' 'e']
 ['e' 'e' 'e' 'e']]
Bloc 23
[2, 2]
Traceback (most recent call last):
  File "x:/xxx/xxx/xxx/xxx.py", line 78, in <module>
    main()
  File "x:/x/xxx/xxx/xxx.py", line 63, in main
    takenred.remove(toswitch2)
ValueError: list.remove(x): x not in list

Process finished with exit code 1

['e'R'B'e']
['e''B''R''e']
['e''e''e''e']
输入播放器R或B:R
Rloc 02
[1, 2]
R:[[1,1]，[2,2]，[1,2]，[0,2]]
B:[[2，1]]
[['e''e''R''e']
['e''R''R''e']
['e''B''R''e']
['e''e''e''e']
集团23
[2, 2]
回溯（最近一次呼叫最后一次）：
文件“x:/xxx/xxx/xxx/xxx.py”，第78行，在
main（）
文件“x:/x/xxx/xxx/xxx.py”，第63行，主
取出。拆下（至开关2）
ValueError:list。删除（x）：x不在列表中
进程已完成，退出代码为1

我发现了几个问题：

• 您尝试修改要迭代的列表

  takenred

  和

  takenblue

  。 这是一个典型的错误，也是你错误的原因。您应该在 如果要删除或添加元素，请单击列表
• 玩家的

  remove

  和

  append

  指令似乎不够缩进。他们 应在每个玩家的最后一个if语句内完成，即当一个位置 应该从一个玩家转到另一个玩家
• 要翻转的位置的检测是错误的。有时你会错过一些位置，例如 当有两个位置要翻转时的实例

下面是脚本的修改版本。我将不同的部分划分为专门的函数，以便更容易理解。要翻转的位置的小车检测在

coords\u to\u flip

功能中。此函数应返回要翻转的坐标列表

将numpy导入为np
输入数学
进口itertools
def已满（电路板）：
对于itertools.product（范围（4）中的（i，j），重复=2：
如果电路板[i][j]=“e”：
返回错误
返回真值
def canflip（播放行、播放列、当前行、当前列）：
返回播放的\u行==当前\u行\
或播放的列==当前列\
或abs（播放的列-当前列）==abs（播放的列-当前列）\
或abs（播放的列-当前列）==abs（当前行-播放的列）
def坐标到翻转（播放行、播放列、当前行、当前列）：
返回math.floor（（播放的行+当前行）//2），math.floor（（播放的列+当前列）//2）
def main（）：
board=np.empty（[4,4]，dtype=str）
对于itertools.product（范围（4）中的（t，n），重复=2：
板[t，n]=“e”
电路板[1,1]=“R”
电路板[1,2]=“B”
电路板[2,1]=“B”
电路板[2,2]=“R”
takenblue=[[1,2]，[2,1]]
takenred=[[1,1]，[2,2]]
toswitch1=[]
toswitch2=[]
玩家=“”
印刷（电路板）
而player.upper（）不在（'R'，'B'）：
player=str（输入（'Starting player R或B:'））
player=player.upper（）
其他玩家='e'
未满时（板）：
如果玩家=='R'：
其他玩家='B'
其他：
其他玩家='R'
loc=[]
而len（loc）！=2:
loc=列表（输入（玩家+loc（2位数字））
loc=[int（val）表示loc中的val]
打印（loc）
行，列=loc
如果板[行，列]！='e'：
打印（'Coord（%d，%d）不可能，已由%s%%（行，列，板[行，列]）执行）
玩家，其他玩家=其他玩家，玩家
持续
打印（'行：'，行）
打印（'列：'，列）
如果玩家=='R'：
对于redrow，takenred[：]中的redcol：
如果可以翻转（行、列、行、列）：
按行，按列=坐标按列翻转（按行，按列，按列，按列，按列，按列）
如果（棋盘[采取行，采取列]==其他玩家）：
棋盘[在行，在行]=玩家
棋盘[行，列]=牌手
toswitch1=[采取行，采取列]
打印（'takenblue:'，takenblue）
打印（'toswitch1:'，toswitch1）
取蓝色。拆下（至开关1）
takenred.append（toswitch 1）
takenred.append（loc）
打印（'R:'，已删除）
打印（'B:'，蓝色）
如果玩家=='B'：
对于bluerow，takenblue[：]中的bluecol：
如果可以翻转（行、列、蓝行、蓝列）：
按行，按列=坐标按列翻转（按行，按列，按列，按列，按列，按列）
如果（棋盘[采取行，采取列]==其他玩家）：
棋盘[在行，在行]=玩家
棋盘[行，列]=牌手
TOSWITCH 2=[TAKED\u row，TAKED\u col]
打印（'takenred:'，takenred）
打印（'toswitch2:'，toswitch2）
取出。拆下（至开关2）
takenblue.append（toswitch 2）
takenblue.追加（loc）
打印（'B:'，蓝色）
打印（'R:'，已删除）
玩家，其他玩家=其他玩家，玩家
印刷（电路板）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
main（）

请提供您的error@Frodon updated@Frodon非常感谢你的帮助@弗罗登，你能提供更多的帮助吗？我发现您对我的代码的修改有一些问题。你有意见分歧或其他什么，我可以直接联系你吗