用 Python 跟自己下棋

crossin先生

用 Python 跟自己下棋

我有一壶酒，足以慰风尘。

自己写 AI，对弈不求人。

（附 Python 版 AlphaGo 开源项目地址）

今天，李世乭终于在与 AlphaGo 的人机大战中扳回一局。但计算机 AI 可以在围棋上战胜人类顶尖棋手的时代已经到来。可以预见，人工智能和机器人将会在更多领域做到比人力更高效、准确、安全。所以未来，掌握编程技能将会显得更加重要。与其现在感叹所谓的机器威胁论，还不如现在动起手来，磨练自己的技能。

再厉害的程序员，也是从“hello world”程序开始写起。再“聪明”的机器，也是从零样本开始“训练”出来的。所以今天就来写一个最简单棋类游戏：Tic Tac Toe，又叫井字棋。

0本篇将实现游戏框架，让你可以和电脑对战，但提升电脑的“智能”会在下一篇中细说。另外，文末会介绍一个 Github 上的 Python 版 AlphaGo 项目。

大致说下井字棋的规则：

棋盘为 3*3 共 9 格，类似汉字“井”；

一方为 o，一方为 x，轮流落子；

任一方先有连成一条线的 3 个棋子（横、竖、斜皆可）则为胜利；

棋盘摆满仍没有一方胜利，则为平局。

我打算在控制台下实现这个游戏，所以我需要用一个格式把棋盘的状态输出出来，设想是这样：

    a   b   c

  |---|---|---|

1 |   | o |   |

  |---|---|---|

2 |   | o | x |

  |---|---|---|

3 | x | o |   |

  |---|---|---|

每走一步，就再次输出新的状态。

而棋盘本身的数据，我用一个 2 维数组来存储：

board = [

  [0, 0, 0],

  [0, 0, 0],

  [0, 0, 0],

0 表示没有子，落子之后，o 为 1，x 为 2。

现在，我需要一个函数，按照设想的格式，把棋盘数据输出到屏幕上。以下是我的实现：

CHESS = [' ', 'o', 'x']

def showBoard():

  print '    a   b   c  '

  for i in range(3):

    print '  |---|---|---|'

    print i+1, '|',

    for j in range(3):

      print '%s |' % CHESS[board[j]],

    print

  print '  |---|---|---|'

为了对应 0、1、2 和空格、o、x 的关系，我用了一个 CHESS 数组。中间的 print 较多，有些乱，但仔细对照前面的设计图看一下应不难理解。

之后考虑游戏的主体玩法部分。大体的思路是：人走一步、显示棋盘、判断是否结束、AI 走一步、显示棋盘、判断是否结束，如此循环。所以大的框架是：

yourturn = True

showBoard()

while not isFinished():

  if yourturn:

    moveMan()

  else:

    moveAI()

  showBoard()

  yourturn = not yourturn;

这里，我用一个变量 yourturn 来记录该哪一方落子，每次走完一步就交换。

isFinished 是一个判断游戏是否结束的函数，如果结束了，就返回 True，游戏主循环退出。最终结果输出，我也打算放在这个函数里。

moveMan 和 moveAI 分别是人和 AI 落子，一个是等待控制台的输入，一个是计算出位置。

接下来要做的，就是完成这 3 个函数。

先来看 moveMan：

ROW = {'1': 0, '2': 1, '3': 2}

COL = {'a': 0, 'b': 1, 'c': 2}

def moveMan():

  print 'Your turn...'

  while True:

    try:

      move = raw_input('choose a position (e.g. a1/c2/b3...):\n')

      pos_row = ROW[move[1]]

      pos_col = COL[move[0]]

      if board[pos_row][pos_col] == 0:

        board[pos_row][pos_col] = 1

        return

    except:

      pass

用 raw_input 等待用户输入。为了方便表示，我们之前的设计就在棋盘上标记了 abc 和 123。ROW 和 COL 两个 dict 是用来将用户输入对应到具体的棋盘坐标上。当判断 board 数组里，用户输入的位置没有棋子时，则指定为 1，并结束函数。while 循环和 try-except 块是为了保证用户的输入是有效的，否则就会重复提示用户输入。

再来看 moveAI：

def moveAI():

  print 'AI\'s turn...'

  while True:

    r = random.randint(0, 2)

    c = random.randint(0, 2)

    if board[r][c] == 0:

      board[r][c] = 2

      return

这个函数的目的是为了将 board 一个位置设置为 2。选取这个位置的过程，则是此游戏 AI 的算法的核心部分。今天先偷个懒，随机生成一个位置，如果为空，就作为落子的位置，并结束函数。下一篇，我们再来完善这个核心。

最后，就是判断胜负的 isFinished：

def isFinished():

  # check row

  if [1, 1, 1] in board:

    print 'You win!'

    return True

  if [2, 2, 2] in board:

    print 'AI wins!'

    return True

  # check col

  for i in range(3):

    if board[0] == board[1] == board[2] == 1:

      print 'You win!'

      return True

    if board[0] == board[1] == board[2] == 2:

      print 'AI wins!'

      return True

  # check diagonal

  if (board[0][0] == board[1][1] == board[2][2] == 1) or (

    board[2][0] == board[1][1] == board[0][2] == 1):

    print 'You win!'

    return True

  if (board[0][0] == board[1][1] == board[2][2] == 2) or (

    board[2][0] == board[1][1] == board[0][2] == 2):

    print 'AI wins!'

    return True

  # check draw game

  draw = True

  for i in range(3):

    if 0 in board:

      draw = False

  if draw:

    print 'Draw game.'

    return True

  return False

稍有点长，主要分为 4 部分：分别是判断横、竖、斜、平局。

横竖斜的胜利部分，就是遍历棋盘去寻找是否有符合条件的情况，有则输出游戏结果，并返回 True。如果都没有，就去判断是否是平局。

判断平局的逻辑是这样：先设定 draw 为 True，如果遇到棋盘上有 0 的位置，则设为 False。否则遍历结束，draw 仍然为 True，就说明已没有空位，游戏以平局结束。

一个井字棋游戏已完成，截取一小段输出结果：

Your turn...

choose a position (e.g. a1/c2/b3...):

b2

  a   b   c

  |---|---|---|

1 | o |   |   |

  |---|---|---|

2 | o | o |   |

  |---|---|---|

3 | x |   | x |

  |---|---|---|

AI's turn...

  a   b   c

  |---|---|---|

1 | o |   |   |

  |---|---|---|

2 | o | o |   |

  |---|---|---|

3 | x | x | x |

  |---|---|---|

AI wins!

当然，现在的这根本还算不上 AI。下一次，我们会让它更“机智”一点。

如果手机上看代码不方便，可移步论坛，在电脑上查看，我也会将完整代码上传。（论坛上的附件需要登录才可下载）

另外，关于前面提到的开源版 AlphaGo 项目。

项目地址：

https://github.com/Rochester-NRT/AlphaGo

有人传是 AlphaGo 开源了，但这其实只是 University of Rochester 根据 AlphaGo 的论文做的实现，用了 Python。与真正使用的程序相去甚远。可以去围观，看看代码。对机器学习、神经网络有兴趣的可以深入研究一下，甚至参与项目开发。不过如果你真想在自己的机器上运行项目，那我要提醒你几点：

首先，项目里面用到了 SciPy，而 SciPy 的安装是需要根据不同操作系统编译的，这里面坑不少，至少我是在两个系统上折腾了几小时才安装成功。

另外，项目目前只完成了一个基本框架，和算法中一小部分，完成度很低。虽然也可以训练 AI 走棋，但效果肯定远不如 AlphaGo。

项目里虽然附带了一个 HTML5 的网页围棋接口，但应该还没有对接，所以想跟电脑对战的要失望了。

完整代码：

1. 
   
2. import random
   
3. 
   
4. board = [
   
5.     [0, 0, 0],
   
6.     [0, 0, 0],
   
7.     [0, 0, 0],
   
8. ]
   
9. 
   
10. ROW = {'1': 0, '2': 1, '3': 2}
    
11. COL = {'a': 0, 'b': 1, 'c': 2}
    
12. 
    
13. CHESS = [' ', 'o', 'x']
    
14. 
    
15. def isFinished():
    
16.     # check row
    
17.     if [1, 1, 1] in board:
    
18.         print 'You win!'
    
19.         return True
    
20.     if [2, 2, 2] in board:
    
21.         print 'AI wins!'
    
22.         return True
    
23.     # check col
    
24.     for i in range(3):
    
25.         if board[0][i] == board[1][i] == board[2][i] == 1:
    
26.             print 'You win!'
    
27.             return True
    
28.         if board[0][i] == board[1][i] == board[2][i] == 2:
    
29.             print 'AI wins!'
    
30.             return True
    
31.     # check diagonal
    
32.     if (board[0][0] == board[1][1] == board[2][2] == 1) or (
    
33.         board[2][0] == board[1][1] == board[0][2] == 1):
    
34.         print 'You win!'
    
35.         return True
    
36.     if (board[0][0] == board[1][1] == board[2][2] == 2) or (
    
37.         board[2][0] == board[1][1] == board[0][2] == 2):
    
38.         print 'AI wins!'
    
39.         return True
    
40.     # check draw game
    
41.     draw = True
    
42.     for i in range(3):
    
43.         if 0 in board[i]:
    
44.             draw = False
    
45.     if draw:
    
46.         print 'Draw game.'
    
47.         return True
    
48.     return False
    
49. 
    
50. def moveAI():
    
51.     print 'AI\'s turn...'
    
52.     while True:
    
53.         r = random.randint(0, 2)
    
54.         c = random.randint(0, 2)
    
55.         if board[r][c] == 0:
    
56.             board[r][c] = 2
    
57.             return
    
58. 
    
59. def moveMan():
    
60.     print 'Your turn...'
    
61.     while True:
    
62.         try:
    
63.             move = raw_input('choose a position (e.g. a1/c2/b3...):\n')
    
64.             pos_row = ROW[move[1]]
    
65.             pos_col = COL[move[0]]
    
66.             if board[pos_row][pos_col] == 0:
    
67.                 board[pos_row][pos_col] = 1
    
68.                 return
    
69.         except:
    
70.             pass
    
71. 
    
72. def showBoard():
    
73.     print '    a   b   c  '
    
74.     for i in range(3):
    
75.         print '  |---|---|---|'
    
76.         print i+1, '|',
    
77.         for j in range(3):
    
78.             print '%s |' % CHESS[board[i][j]],
    
79.         print
    
80.     print '  |---|---|---|'
    
81. 
    
82. yourturn = True
    
83. showBoard()
    
84. while not isFinished():
    
85.     if yourturn:
    
86.         moveMan()
    
87.     else:
    
88.         moveAI()
    
89.     showBoard()
    
90.     yourturn = not yourturn;
    
91. 
    
92. 
    

复制代码

代码文件下载：

mike90326

哇哦，终于赶上进度了

请教crossin老师一个coding的细节：

比如要在给一大段代码前加上if判断语句，我通常的做法是先写上if语句，然后把后面的所有代码逐行缩退4格。但是这样在代码很长的时候太痛苦了，不知道有没有能整体缩退的办法？

crossin先生

mike90326 发表于 2016-3-16 10:07
哇哦，终于赶上进度了

请教crossin老师一个coding的细节：

一般编辑器都会有支持类似的功能吧。大多数是全部选中了按tab键，但要注意有的tab是制表符，有的tab是4个空格，不能混用。这个要看编辑器设置了。退回来很多是shift+tab

mike90326

crossin先生 发表于 2016-3-16 10:40
一般编辑器都会有支持类似的功能吧。大多数是全部选中了按tab键，但要注意有的tab是制表符，有的tab是4个 ...

我用的是pycharm,试了一下tab，果然好用！感谢！

hogcen