展开全部#!usr/bin/env python
'''tic tac toe in python,minimax with alpha-beta pruning.'''
import sys
import random
import getopt
board:array of 9 int,positionally numbered like th**:
0 1 2
3 4 5
6 7 8
well-known board positions
winning_triads=((0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),
(2,5,8),(0,4,8),(2,4,6))
printing_triads=((0,1,2),(3,4,5),(6,7,8))
the order in which slots get checked for absence of a player's token:
slots=(0,1,2,3,4,5,6,7,8)
internal-use values.chosen so that the"winner"of a fin**hed
game has an appropriate value,as x minimizes and o maximizes
the board's value(function board_valuation()defines"value")
internally,the computer always plays os,even though the markers[]
array can change based on-r command line flag.
x_token=-1
open_token=0
o_token=1
strings for output:player's markers,phrase for end-of-game
markers=['_','o','x']
end_phrase=('draw','win','loss')
human=1
computer=0
def board_valuation(board,player,next_player,alpha,beta):
'''dynamic and static evaluation of board position.'''
static evaluation-value for next_player
wnnr=winner(board)
if wnnr!open_token:
not a draw or a move left:someone won
return wnnr
elif not legal_move_left(board):
draw-no moves left
return 0#cat
if flow-of-control gets here,no winner yet,not a draw.
check all legal moves for"player
for move in slots:
if board[move]=open_token:
board[move]=player
val=board_valuation(board,next_player,player,alpha,beta)
board[move]=open_token
if player=o_token:#maximizing player
if val>alpha:
alpha=val
if alpha>=beta:
return beta
else:#x_token player,minimizing
if val
beta=val
if beta
return alpha
if player=o_token:
retval=alpha
else:
retval=beta
return retval
def print_board(board):
'''print the board in human-readable format.
called with current board(array of 9 ints).
'''
for row in printing_triads:
for hole in row:
print markers[board[hole]],
print
def legal_move_left(board):
''' returns true if a legal move remains,false if not.'''
for slot in slots:
if board[slot]=open_token:
return true
return false
def winner(board):
''' returns-1 if x wins,1 if o wins,0 for a cat game,
0 for an unfin**hed game.
returns the first"win"it finds,so check after each move.
note that clever choices of x_token,o_token,open_token
make th** work better.
'''
for triad in winning_triads:
triad_sum=board[triad[0]]+board[triad[1]]+board[triad[2]]
if triad_sum=3 or triad_sum=-3:
return board[triad[0]]#take advantage of"_token"values
return 0
def determine_move(board):
''' determine os next move.check that a legal move remains before calling.
randomly picks a single move from any group of moves with the same value.
'''
best_val=-2#1 less than min of o_token,x_token
my_moves=[]
for move in slots:
if board[move]=open_token:
board[move]=o_token
val=board_valuation(board,x_token,o_token,-2,2)
board[move]=open_token
print"my move",move,"causes a",end_phrase[val]
if val>best_val:
best_val=val
my_moves=[move]
if val=best_val:
my_moves.append(move)
return random.choice(my_moves)
def recv_human_move(board):
''' encapsulate human's input reception and validation.
call with current board configuration.returns
an int of value 0.8,the human's move.
'''
looping=true
while looping:
try:
inp=input("your move:")
yrmv=int(inp)
if 0
if board[yrmv]=open_token:
looping=false
else:
print"spot already filled.
else:
print"bad move,no donut.
except eoferror:
print
sys.exit(0)
except nameerror:
print"not 0-9,try again.
except syntaxerror:
print"not 0-9,try again.
if looping:
print_board(board)
return yrmv
def usage(progname):
'''call with name of program,to explain its usage.'''
print progname+":tic tac toe in python
print"usage:",progname,"[-h][-c][-r][-x][-x]
print"flags:
print"-x,-x:print th** usage **,then exit.
print"-h:human goes first(default)
print"-c:computer goes first
print"-r:computer ** x,human ** o
print"the computer o and the human plays x by default.
def main():
'''call without arguments from_main_context.'''
try:
opts,args=getopt.getopt(sys.argv[1:],"chrxx",
["human","computer","help"])
except getopt.getopterror:
print help **rmation and exit:
usage(sys.argv[0])
sys.exit(2)
next_move=human#human goes first by default
for opt,arg in opts:
if opt="-h":
next_move=human
if opt="-c":
next_move=computer
if opt="-r":
markers[-1]='o'
markers[1]='x'
if opt in("-x","-x","-help"):
usage(sys.argv[0])
sys.exit(1)
initial state of board:all open spots.
board=[open_token,open_token,open_token,open_token,open_token,
open_token,open_token,open_token,open_token]
state machine to decide who goes next,and when the game ends.
th** allows letting computer or human go first.
while legal_move_left(board)and winner(board)=open_token:
print
print_board(board)
if next_move=human and legal_move_left(board):
humanmv=recv_human_move(board)
board[humanmv]=x_token
next_move=computer
if next_move=computer and legal_move_left(board):
mymv=determine_move(board)
print"i choose",mymv
board[mymv]=o_token
next_move=human
print_board(board)
final board state/winner and congratulatory output.
try:
you won"should never appear on output:the program
should always at least draw.
print["cat got the game","i won","you won"][winner(board)]
except indexerror:
print"really bad error,winner **",winner(board)
sys.exit(0)
if_name_='_main_':
try:
main()
except keyboardinterrupt:
print
sys.exit(1)