python tic tac toe but

import random

def drawBoard$($board$)$:

# This function prints out the board that it was passed.

# "board" is a list of $10$ strings representing the board $($ignore index $0$

print$($board$[7]+\text{'}|\text{'}+$ board$[8]+\text{'}|\text{'}+$ board$[9])$

print$(\text{'}-+-+-\text{'})$

print$($board$[4]+\text{'}|\text{'}+$ board$[5]+\text{'}|\text{'}+$ board$[6])$

print$(\text{'}-+-+-\text{'})$

print$($board$[1]+\text{'}|\text{'}+$ board$[2]+\text{'}|\text{'}+$ board$[3])$

def inputPlayerLetter$()$:

#Lets the player type which letter they want to be$.$

#Returns a list with the player's letter as the first item and the computer's letter as the second.

letter $=\text{'}\text{'}$

while not $($letter $==\text{'}$X$\text{'}$ or letter $==\text{'}$O$\text{'})$:

print$(\text{'}$Do you want to be X or O$?\text{'})$

letter $=$ input$().$upper$()$

# The first element in the list is the player's letter; the second is the computer's letter,

if letter $==\text{'}$X$\text{'}$:

return $[\text{'}$X$\text{'},\text{'}$O$\text{'}]$

else:

return $[\text{'}$O$\text{'},\text{'}$X$\text{'}]$

def whoGoesFirst$()$:

# Randomly choose which player goes first.

if random.randint$(0,1)==0$:

return 'computer'

else:

return 'player'

def makeMove$($board$,$ letter, move$)$:

board$[$move$]=$ letter

def isWinner$($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$[7]==$ le and bo$[8]==$ le and bo$[9]==$ le$)$ or # Across the

top

$($bo$[4]==$ le and bo$[5]==$ le and bo$[6]==$ le$)$ or # Across the middle

$($bo$[1]==$ le and bo$[2]==$ le and bo$[3]==$ le$)$ or # Across the bottom

$($bo$[7]==$ le and bo$[4]==$ le and bo$[1]==$ le$)$ or # Down the left side

$($bo$[8]==$ le and bo$[5]==$ le and bo$[2]==$ le$)$ or # Down the middle

$($bo$[9]==$ le and bo$[6]==$ le and bo$[3]==$ le$)$ or # Down the right

side

$($bo$[7]==$ le and bo$[5]==$ le and bo$[3]==$ le$)$ or # Diagonal

$($bo$[9]==$ le and bo$[5]==$ le and bo$[1]==$ le$))$ # Diagonal

def getBoardCopy$($board$)$:

# Make a copy of the board list and return it$.$

# boardCopy $=[]$

for i in board:

boardCopy.append$($i$)$

return boardCopy

def isSpaceFree$($board$,$ move$)$:

# Return True if the passed move is free on the passed board.

return board$[$move$]==\text{'}\text{'}$

def getPlayerMove$($board$)$:

# Let the player enter their move.

move $=\text{'}\text{'}$

while move not in $\text{'}123456789\text{'}.$split$()$:

isSpaceFree$($board$,$ int$($move$))$

print$(\text{'}$What is your next move? $(1-9)\text{'})$

move $=$ input$()$

input $=$ int$($move$)$

def chooseRandomMoveFromList$($board$,$ movesList$)$:

# Returns a valid move from the passed list on the passed board.

# Returns None if there is no valid move.

possibleMoves $=[]$

for i in movesList:

if isSpaceFree$($board$,$ i$)$:

possibleMoves.append$($i$)$

if len$($possibleMoves$)!=0$:

return random.choice$($possibleMoves$)$

else:

return None

def getComputerMove$($board$,$ computerLetter$)$:

# Given a board and the computer's letter, determine where to move and return that move.

if computerLetter $==\text{'}$X$\text{'}$:

playerLetter $=\text{'}$O$\text{'}$

else:

playerLetter $=\text{'}$X$\text{'}$

# Here is the algorithm for our Tic$-$Tac$-$Toe AI:

# First, check if we can win in the next move.

for i in range$(1,10)$:

boardCopy $=$ getBoardCopy$($board$)$

if isSpaceFree$($boardCopy$,$ i$)$:

makeMove$($boardCopy$,$ computerLetter, i$)$

if isWinner$($boardCopy$,$ computerLetter$)$:

return i

# Check if the player could win on their next move and block them.

for i in range$(1,10)$:

boardCopy $=$ getBoardCopy$($board$)$

if isSpaceFree$($boardCopy$,$ i$)$:

makeMove$($boardCopy$,$ playerLetter, i$)$

if isWinner$($boardCopy$,$ playerLetter$)$:

return i

# Try to take one of the corners, if they are free.

move $=$ chooseRandomMoveFromList$($board$,[1,3,7,9])$

if move $!=$ None:

return move

# Try to take the center, if it is free.

if isSpaceFree$($board$,5)$:

return $5$

# Move on one of the sides.

return chooseRandomMoveFromList$($board$,[2,4,6,8])$

def isBoardFull$($board$)$:

# Return True if every space on the board has been taken. Otherwise, return False.

for i in range$(1,10)$:

if isSpaceFree$($board$,$ i$)$:

return False

return True

print$(\text{'}$Welcome to Tic$-$Tac$-$Toe!$\text{'})$

while True:

# Reset the board.

theBoard $=[\text{'}\text{'}]*10$

playerLetter, computerLetter $=$ inputPlayerLetter$()$

turn $=$ whoGoesFirst$()$

print$(\text{'}$The $\text{'}+$ turn $+\text{'}$ will go first.$\text{'})$

gameIsPlaying $=$ True

while gameIsPlaying:

if turn $==$ 'player':

# Player's turn

drawBoard$($theBoard$)$

move $=$ getPlayerMove$($theBoard$)$

this way why is it failing to run