井字棋(Tic-Tac-Toe)

井字棋介绍：https://en.wikipedia.org/wiki/Tic-tac-toe

井字棋简单，但是获胜策略却和直觉不同，四角比中间重要性要高，而且先手有很大的获胜概率获胜（先手胜：91，　后手胜：44，平局：3），所以当你陷入劣势时，怎么选择打平就是一个不那么简单的事情。不过无聊大抵孤单，没有人一起玩就只能和电脑PK，就写了个弱智AI，没事就偷着乐！

AI的获胜策略也很简单，先遍历检测棋盘副本的空格子看下一步能否获胜，如果有机会获胜，返回格子的下标，然后再棋盘上移动，其次，检测对手能否下一步获胜，提前封堵，如果前面两步都没返回的话，就说明双方都没有一步必胜的招式，这时候就得依次抢占四个角落，中间和剩余的位置。

import random

def draw_board(board):
    """board is a 3X3 list containing the moves either ' ' representing
    no moves there or 'x' or 'o' representing actual moves"""
    for i in range(7):
        if i%2 == 0:
            print '+'.join(['---']*3)
        else:
            col = []
            for j in range(11):
                if j%2 == 0:
                    col.append(' ')
                elif j==3 or j==7:
                    col.append('|')
                else:
                    col.append(board[i/2][j/4])
            print ''.join(col)

def who_goes_first():
    if random.randint(0, 1):
        return 'AI'
    else:
        return 'P'

def play_again():
    print "Once Again?(y for Yes, n for No)"
    return raw_input().lower().startswith('y')

def make_move(board, letter, move):
    seq = move-1
    board[2-seq/3][seq%3] = letter

def is_winner(bo, le):
    # Given a board and a player’s letter, this function returns True if that player has won.
    # We use bo instead of board and le instead of letter so we don’t have to type as much.
    return ((bo[0][0] == le and bo[0][1] == le and bo[0][2] == le) or # across the top
    (bo[1][0] == le and bo[1][1] == le and bo[1][2] == le) or # across the middle
    (bo[2][0] == le and bo[2][1] == le and bo[2][2] == le) or # across the bottom
    (bo[0][0] == le and bo[1][0] == le and bo[2][0] == le) or # down the left side
    (bo[0][1] == le and bo[1][1] == le and bo[2][1] == le) or # down the middle
    (bo[0][2] == le and bo[1][2] == le and bo[2][2] == le) or # down the right side
    (bo[0][0] == le and bo[1][1] == le and bo[2][2] == le) or # diagonal
    (bo[0][2] == le and bo[1][1] == le and bo[2][0] == le)) # diagonal

def get_board_copy(board):
    dup = [[' ']*3 for i in range(3)]
    for i in range(3):
        for j in range(3):
            dup[i][j] = board[i][j]
    return dup

def is_move_avail(board, move):
    seq = move-1
    return board[2-seq/3][seq%3] == ' '

def get_P_moves(board):
    move = ''
    while move not in [1, 2, 3, 4, 5, 6, 7, 8, 9] or not is_move_avail(board, move):
        print "Please input your next move('1-9')"
        move = input()
    return move
    
def is_board_full(board):
    for i in range(3):
        for j in range(3):
            if board[i][j] == ' ':
                return False
    return True

def choose_randomly(board, avail):
    possible_moves = []
    for i in avail:
        if is_move_avail(board, i):
            possible_moves.append(i)
    if len(possible_moves) != 0:
        return random.choice(possible_moves)
    else:
        return None

def get_AI_moves(board, AI, P):
    #check if AI can win in the next move
    for i in range(1, 10):
        copy = get_board_copy(board)
        if is_move_avail(board, i):
            make_move(copy, AI, i)
            if is_winner(copy, AI):
                return i
            
    #else check if P can win in the next move and block the first found move
    for i in range(1, 10):
        copy = get_board_copy(board)
        if is_move_avail(board, i):
            make_move(copy, P, i)
            if is_winner(copy, P):
                return i

    #The key to win is to occupy the corners, so move there if available
    move = choose_randomly(board, [1, 3, 7, 9])
    print move
    if move != None:
        return move

    #of second priority is the center element
    if is_move_avail(board, 5):
        return 5

    #Then the rest
    return choose_randomly(board, [2, 4, 6, 8])
    
if __name__ == '__main__':
    
    while True:
        Board = [[' ']*3 for i in range(3)]
        P, AI = 'x', 'o'
        turn = who_goes_first()
        print "{0} will go first".format(turn)
        GameOn = True

        while GameOn:
            if turn == 'P':
                move = get_P_moves(Board)
                make_move(Board, P, move)
                draw_board(Board)

                if is_winner(Board, P):
                    draw_board(Board)
                    print "GameOver You've Won!"
                    GameOn = False
                else:
                    if is_board_full(Board):
                        draw_board(Board)
                        print "Tie"
                        break
                    else:
                        turn = 'AI'

            else:
                move = get_AI_moves(Board, AI, P)
                make_move(Board, AI, move)
                draw_board(Board)

                if is_winner(Board, AI):
                    draw_board(Board)
                    print "GameOver AI has Won!"
                    GameOn = False
                else:
                    if is_board_full(Board):
                        draw_board(Board)
                        print "Tie"
                        break
                    else:
                        turn = 'P'

        if not play_again():
            break

##---+---+---
## x | o | x
##---+---+---
## o | x | o
##---+---+---
## x | o |
##---+---+---

注：

• python 2.7中input和raw_input的区别，python3中合并了
• 数据结构很简单，3X3的list of lists来表示棋盘。井字棋位置和小键盘一致。
• 参考文献: http://www.guokr.com/article/4754/