帮我用python设计一款五子棋游戏，可以和与电脑对战。

好的，我可以为您提供一个简单的五子棋游戏代码。我们可以使用Python中的Pygame库来实现游戏界面，使用Minimax算法和Alpha-Beta剪枝算法来实现人机对战。

首先，我们需要安装Pygame库，可以使用以下命令：

pip install pygame

然后，我们可以开始编写代码：

import pygame
import sys
import math
import random

# 初始化游戏
pygame.init()

# 设置游戏窗口大小
WINDOW_WIDTH = 640
WINDOW_HEIGHT = 640
WINDOW_SIZE = (WINDOW_WIDTH, WINDOW_HEIGHT)

# 设置棋盘大小
BOARD_SIZE = 15

# 设置棋子大小
PIECE_SIZE = 40

# 设置颜色
BLACK_COLOR = (0, 0, 0)
WHITE_COLOR = (255, 255, 255)
GRAY_COLOR = (192, 192, 192)

# 设置字体
FONT = pygame.font.SysFont('Arial', 20)

# 创建游戏窗口
screen = pygame.display.set_mode(WINDOW_SIZE)
pygame.display.set_caption('五子棋')

# 创建棋盘
board = [[0] * BOARD_SIZE for i in range(BOARD_SIZE)]

# 绘制棋盘
def draw_board():
    for i in range(BOARD_SIZE):
        pygame.draw.line(screen, BLACK_COLOR, (20, 20 + i * PIECE_SIZE), (620, 20 + i * PIECE_SIZE), 1)
        pygame.draw.line(screen, BLACK_COLOR, (20 + i * PIECE_SIZE, 20), (20 + i * PIECE_SIZE, 620), 1)

# 绘制棋子
def draw_piece(row, col, color):
    pygame.draw.circle(screen, color, (20 + col * PIECE_SIZE, 20 + row * PIECE_SIZE), PIECE_SIZE // 2, 0)

# 判断是否胜利
def is_win(row, col):
    directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
    for d in directions:
        count = 1
        r, c = row + d[0], col + d[1]
        while r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] == board[row][col]:
            count += 1
            r += d[0]
            c += d[1]
        r, c = row - d[0], col - d[1]
        while r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] == board[row][col]:
            count += 1
            r -= d[0]
            c -= d[1]
        if count >= 5:
            return True
    return False

# 评估函数
def evaluate():
    score = 0
    directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col] == 0:
                continue
            for d in directions:
                count = 1
                r, c = row + d[0], col + d[1]
                while r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] == board[row][col]:
                    count += 1
                    r += d[0]
                    c += d[1]
                r, c = row - d[0], col - d[1]
                while r >= 0 and r < BOARD_SIZE and c >= 0 and c < BOARD_SIZE and board[r][c] == board[row][col]:
                    count += 1
                    r -= d[0]
                    c -= d[1]
                if count >= 5:
                    if board[row][col] == 1:
                        score += 10000
                    else:
                        score -= 10000
                elif count == 4:
                    if board[row][col] == 1:
                        score += 100
                    else:
                        score -= 100
                elif count == 3:
                    if board[row][col] == 1:
                        score += 10
                    else:
                        score -= 10
                elif count == 2:
                    if board[row][col] == 1:
                        score += 1
                    else:
                        score -= 1
    return score

# 极大极小值算法
def minimax(depth, alpha, beta, is_max):
    if depth == 0:
        return evaluate()
    if is_max:
        max_score = -math.inf
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if board[row][col] == 0:
                    board[row][col] = 1
                    score = minimax(depth - 1, alpha, beta, False)
                    board[row][col] = 0
                    max_score = max(max_score, score)
                    alpha = max(alpha, score)
                    if beta <= alpha:
                        break
        return max_score
    else:
        min_score = math.inf
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if board[row][col] == 0:
                    board[row][col] = 2
                    score = minimax(depth - 1, alpha, beta, True)
                    board[row][col] = 0
                    min_score = min(min_score, score)
                    beta = min(beta, score)
                    if beta <= alpha:
                        break
        return min_score

# Alpha-Beta剪枝算法
def alpha_beta(depth, alpha, beta, is_max):
    if depth == 0:
        return evaluate()
    if is_max:
        max_score = -math.inf
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if board[row][col] == 0:
                    board[row][col] = 1
                    score = alpha_beta(depth - 1, alpha, beta, False)
                    board[row][col] = 0
                    max_score = max(max_score, score)
                    alpha = max(alpha, score)
                    if beta <= alpha:
                        break
        return max_score
    else:
        min_score = math.inf
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if board[row][col] == 0:
                    board[row][col] = 2
                    score = alpha_beta(depth - 1, alpha, beta, True)
                    board[row][col] = 0
                    min_score = min(min_score, score)
                    beta = min(beta, score)
                    if beta <= alpha:
                        break
        return min_score

# 电脑下棋
def computer_move():
    best_score = -math.inf
    best_row, best_col = 0, 0
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col] == 0:
                board[row][col] = 1
                score = alpha_beta(4, -math.inf, math.inf, False)
                board[row][col] = 0
                if score > best_score:
                    best_score = score
                    best_row, best_col = row, col
    board[best_row][best_col] = 1
    return (best_row, best_col)

# 主函数
def main():
    # 设置玩家颜色和电脑颜色
    player_color = BLACK_COLOR
    computer_color = WHITE_COLOR

    # 设置先手和后手
    turn = random.randint(1, 2)

    # 游戏循环
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.MOUSEBUTTONUP:
                if turn == 1:
                    pos = pygame.mouse.get_pos()
                    col = (pos[0] - 20) // PIECE_SIZE
                    row = (pos[1] - 20) // PIECE_SIZE
                    if row >= 0 and row < BOARD_SIZE and col >= 0 and col < BOARD_SIZE and board[row][col] == 0:
                        board[row][col] = 2
                        turn = 2
                        if is_win(row, col):
                            text = FONT.render('You win!', True, BLACK_COLOR)
                            screen.blit(text, (260, 620))
                            pygame.display.update()
                            pygame.time.wait(3000)
                            pygame.quit()
                            sys.exit()
                if turn == 2:
                    row, col = computer_move()
                    turn = 1
                    if is_win(row, col):
                        text = FONT.render('You lose!', True, BLACK_COLOR)
                        screen.blit(text, (260, 620))
                        pygame.display.update()
                        pygame.time.wait(3000)
                        pygame.quit()
                        sys.exit()

        # 绘制游戏界面
        screen.fill(GRAY_COLOR)
        draw_board()
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                if board[row][col] == 2:
                    draw_piece(row, col, player_color)
                elif board[row][col] == 1:
                    draw_piece(row, col, computer_color)
        pygame.display.update()

if __name__ == '__main__':
    main()

这是一个比较基础的代码，您可以根据自己的需求对其进行修改和优化。希望能帮到您！