NoneType 不可订阅 Minimax tic-tac-toe 游戏

Question

我有一个井字游戏，它为计算机“玩家”使用了极小极大算法。 Tkinter 部分有效，真人玩家正常工作。 然而，当计算机应该播放时，它给出了错误：“NoneType is not subscriptable”。 我不确定为什么。 我是否缺少其中一个变量的输入？ 先感谢您。

这是我的代码：

from tkinter import *
import customtkinter
import random
import minimax

customtkinter.set_appearance_mode("Dark")
#creating CTk window for app
root = customtkinter.CTk()

#setting window width and height
root.geometry('500x300')


#Creating label
label = customtkinter.CTkLabel(master=root,
                               text="Tic Tac Toe",
                               width=120,
                               height=50,
                               font=("normal", 20),
                               corner_radius=8)
label.place(relx=0.25, rely=0.8, anchor=CENTER)

#Handling clicks
DEPTH=8
def clickbutton(r, c):
    buttons[r][c]["text"]="X"
    board[r][c]="X"
    buttons[r][c]['state']=DISABLED

    label = customtkinter.CTkLabel(master=root,
                               text=checkwin(board),
                               width=120,
                               height=25,
                               corner_radius=8)
    label.place(relx=0.25, rely=0.9, anchor=CENTER)


    computerplay()
    DEPTH=DEPTH-1
    

#Button matrix
buttons = [
     [0,0,0],
     [0,0,0],
     [0,0,0]]
 
#Matrix identifying whether buttons are active or inactive
board=[[0,0,0],[0,0,0],[0,0,0]]
 
for i in range(3):
    for j in range(3):                                 
        buttons[i][j] = Button(height = 3, width = 6, font = ("Normal", 20),
                        command = lambda r = i, c = j : clickbutton(r,c))
        buttons[i][j].grid(row = i, column = j)



def computerplay():
    bestmove=minimax.minimax(board, DEPTH, 1)
    buttons[bestmove[0]][bestmove[1]]['text']="O"
    buttons[bestmove[0]][bestmove[1]]['state']=DISABLED
    board[bestmove[0]][bestmove[1]]="O"

def checkwin(b):
    score=minimax.evaluate(b)
    if score==10:
        return 'Computer won!'
    elif score==-10:
        return 'You won!'
    else:
        return 'Player vs. Computer'
    

root.mainloop()

我的极小极大代码：

import math

def change_board(board):
    #changes board into -1, 0, and 1s instead of X, O, and 0 (zero).
    new_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

    for i in range(3):
        for j in range(3):
            if board[i][j]=='X':
                new_board[i][j]==-1
            elif board[i][j]=='O':
                new_board[i][j]==1

    return new_board

def empty_cells(board):
    cells=[]
    for i in range(3):
        for j in range(3):
            if board[i][j]==0:
                cells.append([i, j])
                
    return False

def game_over(board):
    #check for wins using evaluate
    if evaluate(board)==10 or evaluate(board)==-10:
        return True
    
    #check for full board
    if (not empty_cells(board)):
        return True

    return False
    

def evaluate(board):
    #check score
    if board[0][0]==board[1][1] and board[1][1]==board[2][2]:
        if board[0][0]==-1:
            return -10
        elif board[0][0]==1:
            return 10
    
    if board[0][2]==board[1][1] and board[1][1]==board[2][0]:
        if board[0][2]==-1:
            return -10
        elif board[0][2]==1:
            return 10
    
    for row in range(3):
        if board[row][0]==board[row][1] and board[row][1]==board[row][2]:
            if board[row][0]==-1:
                return -10
            elif board[row][0]==1:
                return 10

    for col in range(3):
        if board[0][col]==board[1][col] and board[1][col]==board[2][col]:
            if board[0][col]==-1:
                return -10
            elif board[0][col]==1:
                return 10
    



def minimax(board, depth, player):
    if player==1:
        #1 is computer. -1 is human player.
        best=[-1, -1, -math.inf]
    else:
        best=[-1, -1, math.inf]

    if depth==0 or game_over(board):
        score=evaluate(board)
        return score

    #checking scores of valid moves 
    for cell in empty_cells(board):
        x, y = cell[0], cell[1]
        board[x][y] = player
        score = minimax(board, depth - 1, -player)
        board[x][y] = 0
        score[0], score[1] = x, y

        if player == 1:
            if score[2] > best[2]:
                best = score
        else:
            if score[2] < best[2]:
                best = score

    return best

Answer 1

您的 minimax 代码存在以下问题：

• 在change_board中，您没有为new_board单元格分配任何内容，因为您执行的是comparison ，而不是assignment 。 new_board[i][j]==-1更改为new_board[i][j]=-1并且在else子句中类似。

• 在empty_cells中，您不会对cells上完成的工作做任何事情，而只是返回False 。 调用者肯定需要cells列表，因此您应该返回它。

• 在evaluate中，当没有检测到获胜线时，你还应该返回一个数值：调用者需要一个数字来将它与迄今为止的最佳分数进行比较，所以让它只返回None是不好的。 在function的底部添加一个return 0 。

• 在minimax中，你应该总是返回相同的结构，即一个包含三个成员的列表。 在您只返回一个数字的基本情况下不会这样做。 要解决此问题，该基本情况应return [-1, -1, score] 。 与此相关，您应该考虑在分数是数字（如此处）或分数是该列表时使用不同的名称，就像您在代码的其他地方所做的那样。 这令人困惑。

通过这些修复，它将起作用。

尽管如此，您仍然可以改进一些事情，包括：

• 如果您根据 boolean 条件return True或return False ，您可以只返回该条件的评估。 例如， game_over可以return abs(evaluate(board))==10 or not empty_cells(board)

• 您可以链接比较运算符，例如board[0][0]==board[1][1]==board[2][2]

• 避免game_over中的代码重复：将获胜线所在位置的信息放入数据结构中，然后对其进行循环以仅对三格比较编码一次。

• 当不需要改变它时，使用元组而不是列表，比如 x/y 坐标。

• 对于math.inf ，您使用的是浮点数，否则分数将为 integer。最好避免这种类型混合。 在这种情况下，您可以改用值 11。

这是它的样子：

def change_board(board):
    return [
        [(cell == "O") - (cell == "X") for cell in row]
        for row in board
    ]

def empty_cells(board):
    return [(i, j) for i in range(3) for j in range(3) if board[i][j] == 0]

def game_over(board):
    return abs(evaluate(board)) == 10 or not empty_cells(board)
    
lines = (
    (0, 0, 1, 1, 2, 2),
    (0, 2, 1, 1, 2, 0),
    (0, 0, 0, 1, 0, 2),
    (1, 0, 1, 1, 1, 2),
    (2, 0, 2, 1, 2, 2),
    (0, 0, 1, 0, 2, 0),
    (0, 1, 1, 1, 2, 1),
    (0, 2, 1, 2, 2, 2),
)

def evaluate(board):
    def iswin(line):
        arow, acol, brow, bcol, crow, ccol = line
        if board[arow][acol] == board[brow][bcol] == board[crow][ccol]:
            return board[arow][acol]*10

    return next((win for win in map(iswin, lines) if win), 0)


def minimax(board, depth, player):
    best = (-1, -1, -11*player)

    if depth <= 0 or game_over(board):
        return (-1, -1, evaluate(board))  # must return same structure

    for x, y in empty_cells(board):
        board[x][y] = player
        score = minimax(board, depth - 1, -player)[2]  # only get the score
        board[x][y] = 0
        if (player == 1) == (score > best[2]):
            best = (x, y, score)  # only inject x, y when move is best

    return best

当您使用电路板的位表示而不是 2D 矩阵时，可以进行更多优化。