python四子棋,用python五子棋棋盘的程序

　　本文主要详细介绍了三棋游戏的python实现。本文中的示例代码非常详细，具有一定的参考价值。感兴趣的朋友可以参考一下。

　　00-1010 1.基本流程2。基本步骤1。菜单界面2。初始化棋盘，打印棋盘3，玩家走法4，电脑走法5，输赢判断3。总体代码4。结果显示三棋盘的python实现代码，供大家参考。具体情况如下

目录

　　三棋游戏的逻辑如下：

　　1.创建一个初始化3*3棋盘；

　　2，玩家抱着U子，先动；

　　3.判断结果[赢、输、平]。如果结果不一致，继续如下

　　4.电脑抱着T-box继续前进；

　　5.胜败判断，如果胜败未得分，从步骤2继续。

一、基本流程

二、基本步骤

　　1是开始游戏，2是退出游戏。

　　定义菜单():

　　打印(-*20)

　　打印(“1 -开始”)

　　打印(“双页退出”)

　　打印(“请选择开始或退出”)

　　打印(- * 20)

　　而(1):

　　选择=输入(请输入： )

　　如果选择==1:

　　begin _游戏()

　　及格

　　elif select==2:

　　打印(“退出游戏”)

　　破裂

　　#通过

　　及格

1、菜单界面

　　棋盘是一个3*3的正方形矩阵，用python中的列表存储。

　　chess_board=[[0，0，0]，[0，0，0]，[0，0，0]

　　那么如何把这个存储列表打印出来，变成棋盘呢？

　　DEF _ Cheaa _ Board(chess _ Board)3360 #首先初始化列表。

　　对于范围内的I(MAX _ ROW):

　　对于范围(MAX_COL):内的j

　　chess_board[i][j]=

　　及格

　　Def _ chess _ board(象棋_棋盘): #棋盘印刷

　　打印( * - * 7 * - * 7 * - * 7 * )

　　对于范围内的I(MAX _ ROW):

　　print( * 3 chess _ board[I][0] * 3 * 3 chess _ board[I][1] * 3 * 3 chess _ board[I][2] * 3 )

　　打印( * - * 7 * - * 7 * - * 7 * )

　　及格

　　及格

2、初始化棋盘、打印棋盘

　　玩家在3*3棋盘中选择落子的横坐标和纵坐标。坐标需要满足以下要求：1。点在棋盘上；2.这个点还没有设定。

　　def player_first(象棋_棋盘):

　　而(1):

　　x=int(input(请输入x: ))

　　y=int(输入(请输入y: ))

　　if(chess_board[x][y]！=) 3360 #如果已经设置，重新选择坐标。

　　打印(该位置已经

　　 occupied!)

　　            pass

　　        elif(x >= MAX_ROW or y >= MAX_COL or x < 0 or y < 0): #所选坐标超出棋盘范围，重新选择坐标

　　            print(This position is beyond the chessboard!)

　　            pass

　　        else: #若坐标可以落子，则将该坐标置为玩家的棋子U

　　            chess_board[x][y] = U

　　            print_chess_board(chess_board)

　　            #return x,y

　　            break

　　            pass

　　    pass

4、电脑落子

　　电脑落子算法：

　　4.1、先检查一下棋盘，看电脑已占有棋面中是否已经有两子连成、即将成棋的状态。若已有，则获取可以促成胜利的坐标点，进行落子T；

　　4.2、若4.1不满足，则再去检查一下棋盘，看玩家已占有棋面中是否已经有两子连成、即将成棋的状态。若已有，则获取玩家即将胜利的坐标点，落子T进行拦截；

　　4.3、若4.1、4.2均不满足，则在棋面中选择电脑端有利的点进行落子；

　　A、先判断中心位置[1][1]处是否被占领，若未被占领，则这是最有利点。当占领[1][1]点时，则阻断了玩家的横、纵、正对角线、副对角线四条线路；
B、次有利点则是3*3棋盘的四个角，每占领一个角，则会阻断玩家的三条线路；
C、最后有利的点则是每条边的中心位置，会阻断玩家的两条线路；

def Intercept_player(chess_board,key):
　　    count2 = 0
　　    index2 = []
　　    intercept_index = {x:-1,y:-1}
　　    for i in range(MAX_ROW):
　　        index = []
　　        count = 0
　　        count1 = 0
　　        index1 = []
　　        allindex = [0,1,2]
　　        for j in range(MAX_ROW):
　　            if(chess_board[i][j] == key): #每一行的玩家落子情况
　　                count += 1
　　                index.append(j)
　　            if(chess_board[j][i] == key): #每一列的玩家落子情况
　　                #print(j+str(j)+,i+str(i)+=+chess_board[j][i])
　　                count1 += 1
　　                index1.append(j)
　　            if (i == j and chess_board[j][i] == key):  # 在主对角线中的玩家落子情况
　　                count2 += 1
　　                index2.append(j)
　　        if(count == 2):    #在每一行中  获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index)))
　　            result = result[0]
　　            if(chess_board[i][result] == ): #当这个位置可以进行拦截时，进行坐标返回
　　                #return i,result
　　                intercept_index[x] = i
　　                intercept_index[y] = result
　　                return intercept_index
　　        #print(count1,------->,index1)
　　        if (count1 == 2):  # 在每一列中 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index1)))
　　            result = result[0]
　　            #print(count1==2,result:,result)
　　            if (chess_board[result][i] == ):  # 当这个位置可以进行拦截时，进行坐标返回
　　                intercept_index[x] = result
　　                intercept_index[y] = i
　　                return intercept_index
　　                #return i, result
　　        if (count2 == 2):  # 在主对角线上 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index2)))
　　            result = result[0]
　　            if (chess_board[i][result] == ):  # 当这个位置可以进行拦截时，进行坐标返回
　　                intercept_index[x] = i
　　                intercept_index[y] = result
　　                return intercept_index
　　                #return i, result
　　    count3 = 0
　　    if(chess_board[0][2] == key):
　　        count3 += 1
　　    if (chess_board[1][1] == key):
　　        count3 += 1
　　    if (chess_board[2][0] == key):
　　        count3 += 1
　　    if(count3 == 2):
　　        if(chess_board[0][2] == ):
　　            intercept_index[x] = 0
　　            intercept_index[y] = 2
　　        elif (chess_board[1][1] == ):
　　            intercept_index[x] = 1
　　            intercept_index[y] = 1
　　        elif (chess_board[2][0] == ):
　　            intercept_index[x] = 2
　　            intercept_index[y] = 0
　　    return intercept_index
　　def computer_second(chess_board):  #电脑智能出棋
　　    #1、先检查一下电脑是否两子成棋  若已有，则获取空位置坐标 自己先成棋
　　    intercept_index = Intercept_player(chess_board, T)
　　    if (intercept_index[x] == -1 and intercept_index[y] == -1):
　　        pass
　　    else:  # 电脑可落子
　　        x = intercept_index[x]
　　        y = intercept_index[y]
　　        chess_board[x][y] = T
　　        return
　　    #2、若玩家快成棋   则先进行拦截
　　    intercept_index = Intercept_player(chess_board,U)   #若玩家已经两子成棋  则获取空位置的坐标
　　    #print(intercept_index---:)
　　    #print(intercept_index)
　　    if(intercept_index[x] == -1 and intercept_index[y] == -1):
　　        pass
　　    else:  #电脑可落子
　　        x = intercept_index[x]
　　        y = intercept_index[y]
　　        chess_board[x][y] = T
　　        return
　　    #3、如果没有，则电脑端排棋  以促进成棋
　　    #3.1、 占领中心位置  如若中心位置[1,1]未被占领
　　    if(chess_board[1][1] == ):
　　        chess_board[1][1] = T
　　        return
　　    #3.2、 占领四角位置  若[0,0]  [0,2]  [2,0]  [2,2]未被占领
　　    if (chess_board[0][0] == ):
　　        chess_board[0][0] = T
　　        return
　　    if (chess_board[0][2] == ):
　　        chess_board[0][2] = T
　　        return
　　    if (chess_board[2][0] == ):
　　        chess_board[2][0] = T
　　        return
　　    if (chess_board[2][2] == ):
　　        chess_board[2][2] = T
　　        return
　　    # 3.3、 占领每一边中心位置  若[0,1]  [1,0]  [1,2]  [2,1]未被占领
　　    if (chess_board[0][1] == ):
　　        chess_board[0][1] = T
　　        return
　　    if (chess_board[1][0] == ):
　　        chess_board[1][0] = T
　　        return
　　    if (chess_board[1][2] == ):
　　        chess_board[1][2] = T
　　        return
　　    if (chess_board[2][1] == ):
　　        chess_board[2][1] = T
　　        return

5、输赢判定

　　最终的结果：输、赢、和棋D
判定流程：判断每个横线、纵线、对角线上是否有玩家U或电脑T连成三子的，若有则是该方胜出；当整个棋面都被占满，但玩家和电脑都未成棋时，则说明和棋。

def chess_board_isfull(chess_board):   #判断棋盘是否填充满
　　    for i in range(MAX_ROW):
　　        if ( in chess_board[i]):
　　            return 0
　　    return 1
　　    pass
　　def Win_or_lose(chess_board):
　　    isfull = chess_board_isfull(chess_board)
　　    for i in range(MAX_ROW):  #每一列的判断
　　        if( chess_board[0][i] == chess_board[1][i] == chess_board[2][i]):
　　            return chess_board[0][i]
　　            pass
　　        pass
　　    for i in range(MAX_ROW):  # 每一行的判断
　　        if( chess_board[i][0] == chess_board[i][1] == chess_board[i][2]):
　　            return chess_board[i][0]
　　            pass
　　        pass
　　    if (chess_board[0][0] == chess_board[1][1] == chess_board[2][2]):  # 判断棋盘正对角线
　　        return chess_board[0][0]
　　    if (chess_board[0][2] == chess_board[1][1] == chess_board[2][0]):  # 判断棋盘反对角线
　　        return chess_board[0][2]
　　    if isfull:
　　        return D  # 经过以上的判断，都不满足(既没赢也没输)，但是棋盘也已经填充满，则说明和棋
　　    else:
　　        return 

三、整体代码

# coding=utf-8import random
　　MAX_ROW = 3
　　MAX_COL = 3
　　#array = [0,0,0]
　　chess_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] #[array] * 3
　　def init_cheaa_board(chess_board):
　　    for i in range(MAX_ROW):
　　        for j in range(MAX_COL):
　　            chess_board[i][j] = 
　　    pass
　　def print_chess_board(chess_board):
　　    print(*+-*7+*+-*7+*+-*7+*)
　　    for i in range(MAX_ROW):
　　        print(+ *3+chess_board[i][0]+ *3++ *3+chess_board[i][1]+ *3++ *3+chess_board[i][2]+ *3+)
　　        print(* + - * 7 + * + - * 7 + * + - * 7 + *)
　　        pass
　　    pass
　　def player_first(chess_board):
　　    while(1):
　　        x = int(input(please input x:))
　　        y = int(input(please input y:))
　　        if(chess_board[x][y] != ):
　　            print(This position is already occupied!)
　　            pass
　　        elif(x >= MAX_ROW or y >= MAX_COL or x < 0 or y < 0):
　　            print(This position is beyond the chessboard!)
　　            pass
　　        else:
　　            chess_board[x][y] = U
　　            print_chess_board(chess_board)
　　            #return x,y
　　            break
　　            pass
　　    pass
　　def chess_board_isfull(chess_board):   #判断棋盘是否填充满
　　    for i in range(MAX_ROW):
　　        if ( in chess_board[i]):
　　            return 0
　　    return 1
　　    pass
　　def Win_or_lose(chess_board):
　　    isfull = chess_board_isfull(chess_board)
　　    for i in range(MAX_ROW):  #每一列的判断
　　        if( chess_board[0][i] == chess_board[1][i] == chess_board[2][i]):
　　            return chess_board[0][i]
　　            pass
　　        pass
　　    for i in range(MAX_ROW):  # 每一行的判断
　　        if( chess_board[i][0] == chess_board[i][1] == chess_board[i][2]):
　　            return chess_board[i][0]
　　            pass
　　        pass
　　    if (chess_board[0][0] == chess_board[1][1] == chess_board[2][2]):  # 判断棋盘正对角线
　　        return chess_board[0][0]
　　    if (chess_board[0][2] == chess_board[1][1] == chess_board[2][0]):  # 判断棋盘反对角线
　　        return chess_board[0][2]
　　    if isfull:
　　        return D  # 经过以上的判断，都不满足(既没赢也没输)，但是棋盘也已经填充满，则说明和棋
　　    else:
　　        return 
　　def computer_second_random(chess_board):    #电脑随机出棋
　　    while(1):
　　        x = random.randint(0,2)
　　        y = random.randint(0,2)
　　        if(chess_board[x][y] != ):
　　            continue
　　        else:
　　            chess_board[x][y] = T
　　            break
　　def Intercept_player(chess_board,key):
　　    count2 = 0
　　    index2 = []
　　    intercept_index = {x:-1,y:-1}
　　    for i in range(MAX_ROW):
　　        index = []
　　        count = 0
　　        count1 = 0
　　        index1 = []
　　        allindex = [0,1,2]
　　        for j in range(MAX_ROW):
　　            if(chess_board[i][j] == key): #每一行的玩家落子情况
　　                count += 1
　　                index.append(j)
　　            if(chess_board[j][i] == key): #每一列的玩家落子情况
　　                #print(j+str(j)+,i+str(i)+=+chess_board[j][i])
　　                count1 += 1
　　                index1.append(j)
　　            if (i == j and chess_board[j][i] == key):  # 在主对角线中的玩家落子情况
　　                count2 += 1
　　                index2.append(j)
　　        if(count == 2):    #在每一行中  获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index)))
　　            result = result[0]
　　            if(chess_board[i][result] == ): #当这个位置可以进行拦截时，进行坐标返回
　　                #return i,result
　　                intercept_index[x] = i
　　                intercept_index[y] = result
　　                return intercept_index
　　        #print(count1,------->,index1)
　　        if (count1 == 2):  # 在每一列中 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index1)))
　　            result = result[0]
　　            #print(count1==2,result:,result)
　　            if (chess_board[result][i] == ):  # 当这个位置可以进行拦截时，进行坐标返回
　　                intercept_index[x] = result
　　                intercept_index[y] = i
　　                return intercept_index
　　                #return i, result
　　        if (count2 == 2):  # 在主对角线上 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
　　            result = list(set(allindex).difference(set(index2)))
　　            result = result[0]
　　            if (chess_board[i][result] == ):  # 当这个位置可以进行拦截时，进行坐标返回
　　                intercept_index[x] = i
　　                intercept_index[y] = result
　　                return intercept_index
　　                #return i, result
　　    count3 = 0
　　    if(chess_board[0][2] == key):
　　        count3 += 1
　　    if (chess_board[1][1] == key):
　　        count3 += 1
　　    if (chess_board[2][0] == key):
　　        count3 += 1
　　    if(count3 == 2):
　　        if(chess_board[0][2] == ):
　　            intercept_index[x] = 0
　　            intercept_index[y] = 2
　　        elif (chess_board[1][1] == ):
　　            intercept_index[x] = 1
　　            intercept_index[y] = 1
　　        elif (chess_board[2][0] == ):
　　            intercept_index[x] = 2
　　            intercept_index[y] = 0
　　    return intercept_index
　　def computer_second(chess_board):  #电脑智能出棋
　　    #1、先检查一下电脑是否两子成棋  若已有，则获取空位置坐标 自己先成棋
　　    intercept_index = Intercept_player(chess_board, T)
　　    if (intercept_index[x] == -1 and intercept_index[y] == -1):
　　        pass
　　    else:  # 电脑可落子
　　        x = intercept_index[x]
　　        y = intercept_index[y]
　　        chess_board[x][y] = T
　　        return
　　    #2、若玩家快成棋   则先进行拦截
　　    intercept_index = Intercept_player(chess_board,U)   #若玩家已经两子成棋  则获取空位置的坐标
　　    #print(intercept_index---:)
　　    #print(intercept_index)
　　    if(intercept_index[x] == -1 and intercept_index[y] == -1):
　　        pass
　　    else:  #电脑可落子
　　        x = intercept_index[x]
　　        y = intercept_index[y]
　　        chess_board[x][y] = T
　　        return
　　    #3、如果没有，则电脑端排棋  以促进成棋
　　    #3.1、 占领中心位置  如若中心位置[1,1]未被占领
　　    if(chess_board[1][1] == ):
　　        chess_board[1][1] = T
　　        return
　　    #3.2、 占领四角位置  若[0,0]  [0,2]  [2,0]  [2,2]未被占领
　　    if (chess_board[0][0] == ):
　　        chess_board[0][0] = T
　　        return
　　    if (chess_board[0][2] == ):
　　        chess_board[0][2] = T
　　        return
　　    if (chess_board[2][0] == ):
　　        chess_board[2][0] = T
　　        return
　　    if (chess_board[2][2] == ):
　　        chess_board[2][2] = T
　　        return
　　    # 3.3、 占领每一边中心位置  若[0,1]  [1,0]  [1,2]  [2,1]未被占领
　　    if (chess_board[0][1] == ):
　　        chess_board[0][1] = T
　　        return
　　    if (chess_board[1][0] == ):
　　        chess_board[1][0] = T
　　        return
　　    if (chess_board[1][2] == ):
　　        chess_board[1][2] = T
　　        return
　　    if (chess_board[2][1] == ):
　　        chess_board[2][1] = T
　　        return
　　def begin_games():
　　    global chess_board
　　    init_cheaa_board(chess_board)
　　    result = 
　　    while(1):
　　        print_chess_board(chess_board)
　　        player_first(chess_board)
　　        result = Win_or_lose(chess_board)
　　        if(result != ):
　　            break
　　        else: #棋盘还没满，该电脑出棋
　　            #computer_second_random(chess_board)
　　            computer_second(chess_board)
　　            result = Win_or_lose(chess_board)
　　            if (result != ):
　　                break
　　    print_chess_board(chess_board)
　　    if (result == U):
　　        print(Congratulations on your victory!)
　　    elif (result == T):
　　        print(Unfortunately, you failed to beat the computer.)
　　    elif (result == D):
　　        print(The two sides broke even.)
　　def menu():
　　    print(-*20)
　　    print(1---------------begin)
　　    print(2---------------exit)
　　    print(please select begin or exit)
　　    print(- * 20)
　　    while(1):
　　        select = input(please input:)
　　        if select == 1:
　　            begin_games()
　　            pass
　　        elif select == 2:
　　            print(exit the game)
　　            break
　　            #pass
　　    pass
　　if __name__ == "__main__":
　　    menu()
　　    pass

四、结果展示

　　4.1 在以下截图中，展示了电脑拦截、占据有利位置、并率先成棋的过程

　　以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。