Bool object is not callable in python connect for game ( is in the return line of def isWinner(bo, le):) [closed]

Question

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.

---

This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.

Closed 9 years ago.

Improve this question

Tic Tac Toe

this is the beginning of the code for reference possibly this is the board

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[1]+" | "+board[2]+" | "+board[3]+" | "+board[4]+" | "+board[5]+" |          "+board[6]+" | "+board[7]+" |      "
    print"|___|___|___|___|___|___|___|"
    print"| "+board[8]+" | "+board[9]+" | "+board[10]+" | "+board[11]+" | "+board[12]+" | "+board[13]+" | "+board[14]+" |      "
    print"|___|___|___|___|___|___|___|"
    print"| "+board[15]+" | "+board[16]+" | "+board[17]+" | "+board[18]+" | "+board[19]+" | "+board[20]+" | "+board[21]+" |      "
    print"|___|___|___|___|___|___|___|"
    print"| "+board[22]+" | "+board[23]+" | "+board[24]+" | "+board[25]+" | "+board[26]+" | "+board[27]+" | "+board[28]+" |      "
    print"|___|___|___|___|___|___|___|"
    print"| "+board[29]+" | "+board[30]+" | "+board[31]+" | "+board[32]+" | "+board[33]+" | "+board[34]+" | "+board[35]+" |      "
    print"|___|___|___|___|___|___|___|"
    print"| "+board[36]+" | "+board[37]+" | "+board[38]+" | "+board[39]+" | "+board[40]+" | "+board[41]+" | "+board[42]+" |      "
    print"|___|___|___|___|___|___|___|"

inputs for X or O

def inputPlayerLetter():
# Let's 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 = ''
    while not (letter == 'X' or letter == 'O'):
        print('Do you want to be X or O?')
        letter = input('Do you want to be X or O?').upper()

gives computer other letter

# the first element in the tuple is the player's letter, the second is the computer's letter.
    if letter == 'X':
        return ['X', 'O']
    else:
        return ['O', 'X']

randomly chooses who goes first.

def whoGoesFirst():
# Randomly choose the player who goes first.
    if random.randint(0, 1) == 0:
        return 'computer'
    else:
        return 'player'

play again

def playAgain():
# This function returns True if the player wants to play again, otherwise it returns False.
    print('Do you want to play again? (yes or no)')
    return input('Do you want to play again? (yes or no)').lower().startswith('y')

def makeMove(board, letter, move):
    board[move] = letter

right here is the problem on the return line this is used to match up 4 winning spaces along the board made earlier

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[1] == le and bo[2] == le and bo[3] == le and bo[4] == le) or # top row 1
    (bo[2] == le and bo[3] == le and bo[4] == le and bo[5] == le) or # top row 2
    (bo[3] == le and bo[4] == le and bo[5] == le and bo[6] == le) or # top row 3
    (bo[4] == le and bo[5] == le and bo[6] == le and bo[7] == le) or # top row 4
    (bo[8] == le and bo[9] == le and bo[10] == le and bo[11] == le) or # 2nd row 1
    (bo[9] == le and bo[10] == le and bo[11] == le and bo[12] == le) or # 2nd row 2
    (bo[10] == le and bo[11] == le and bo[12] == le and bo[13] == le) or # 2nd row 3
    (bo[11] == le and bo[12] == le and bo[13] == le and bo[14] == le) # 2nd row 4
    (bo[15] == le and bo[16] == le and bo[17] == le and bo[18] == le) or # 3rd row 1
    (bo[16] == le and bo[17] == le and bo[18] == le and bo[19] == le) or # 3rd row 2
    (bo[17] == le and bo[18] == le and bo[19] == le and bo[20] == le) or # 3rd row 3
    (bo[18] == le and bo[19] == le and bo[20] == le and bo[21] == le) or # 3rd row 4
    (bo[22] == le and bo[23] == le and bo[24] == le and bo[25] == le) or # 4th row 1
    (bo[23] == le and bo[24] == le and bo[25] == le and bo[26] == le) or # 4th row 2
    (bo[24] == le and bo[25] == le and bo[26] == le and bo[27] == le) or # 4th row 3
    (bo[25] == le and bo[26] == le and bo[27] == le and bo[28] == le) or # 4th row 4
    (bo[29] == le and bo[30] == le and bo[31] == le and bo[32] == le) or # 5th row 1
    (bo[30] == le and bo[31] == le and bo[32] == le and bo[33] == le) or # 5th row 2
    (bo[31] == le and bo[32] == le and bo[33] == le and bo[34] == le) or # 5th row 3
    (bo[32] == le and bo[33] == le and bo[34] == le and bo[35] == le) or # 5th row 4
    (bo[36] == le and bo[37] == le and bo[38] == le and bo[39] == le) or # 6th row 1
    (bo[37] == le and bo[38] == le and bo[39] == le and bo[40] == le) or # 6th row 2
    (bo[38] == le and bo[39] == le and bo[40] == le and bo[41] == le) or # 6th row 3
    (bo[39] == le and bo[40] == le and bo[41] == le and bo[42] == le) or # 6th row 4
    (bo[1] == le and bo[8] == le and bo[15] == le and bo[22] == le) or # 1st row 1
    (bo[8] == le and bo[15] == le and bo[22] == le and bo[29] == le) or # 1st row 2
    (bo[15] == le and bo[22] == le and bo[29] == le and bo[36] == le) or # 1st row 3
    (bo[2] == le and bo[9] == le and bo[16] == le and bo[23] == le) or # 2st row 1
    (bo[9] == le and bo[16] == le and bo[23] == le and bo[28] == le) or # 2st row 2
    (bo[16] == le and bo[23] == le and bo[28] == le and bo[35] == le) or # 2st row 3
    (bo[3] == le and bo[10] == le and bo[17] == le and bo[24] == le) or # 3th row 1
    (bo[10] == le and bo[17] == le and bo[24] == le and bo[31] == le) or # 3th row 2
    (bo[17] == le and bo[24] == le and bo[31] == le and bo[38] == le) or # 3th row 3
    (bo[4] == le and bo[11] == le and bo[18] == le and bo[25] == le) or # 4th row 1
    (bo[11] == le and bo[18] == le and bo[25] == le and bo[32] == le) or # 4th row 2
    (bo[18] == le and bo[25] == le and bo[32] == le and bo[39] == le) or # 4th row 3
    (bo[5] == le and bo[12] == le and bo[19] == le and bo[26] == le) or # 5th row 1
    (bo[12] == le and bo[19] == le and bo[26] == le and bo[33] == le) or # 5th row 2
    (bo[19] == le and bo[26] == le and bo[33] == le and bo[40] == le) or # 5th row 3
    (bo[6] == le and bo[13] == le and bo[20] == le and bo[27] == le) or # 6th row 1
    (bo[13] == le and bo[20] == le and bo[27] == le and bo[34] == le) or # 6th row 2
    (bo[20] == le and bo[27] == le and bo[34] == le and bo[41] == le) or # 6th row 3
    (bo[7] == le and bo[14] == le and bo[21] == le and bo[28] == le) or # 7th row 1
    (bo[14] == le and bo[21] == le and bo[28] == le and bo[35] == le) or # 7th row 2
    (bo[21] == le and bo[28] == le and bo[35] == le and bo[42] == le) or # 7th row 3  
    (bo[1] == le and bo[9] == le and bo[17] == le and bo[25] == le) or # diagonal 1 (1)(9)(17)(25)
    (bo[8] == le and bo[16] == le and bo[24] == le and bo[32] == le) or # diagonal 2 (8)(16)(24)(32)
    (bo[15] == le and bo[23] == le and bo[31] == le and bo[39] == le) or # diagonal 3 (15)(23)(31)(39)
    (bo[2] == le and bo[10] == le and bo[18] == le and bo[26] == le) or # diagonal 4 (2)(10)(18)(26)
    (bo[9] == le and bo[17] == le and bo[25] == le and bo[33] == le) or # diagonal 5 (9)(17)(25)(33)
    (bo[16] == le and bo[24] == le and bo[32] == le and bo[40] == le) or # diagonal 6 (16)(24)(32)(40)
    (bo[3] == le and bo[11] == le and bo[19] == le and bo[27] == le) or # diagonal 7 (3)(11)(19)(27)
    (bo[10] == le and bo[18] == le and bo[26] == le and bo[34] == le) or # diagonal 8 (10)(18)(26)(34)
    (bo[17] == le and bo[25] == le and bo[33] == le and bo[41] == le) or # diagonal 9 (17)(25)(33)(41)
    (bo[4] == le and bo[12] == le and bo[20] == le and bo[28] == le) or # diagonal 10 (4)(12)(20)(28)
    (bo[11] == le and bo[19] == le and bo[27] == le and bo[35] == le) or # diagonal 11 (11)(19)(27)(35)
    (bo[18] == le and bo[26] == le and bo[34] == le and bo[42] == le) or # diagonal 12 (18)(26)(34)(42)
    (bo[7] == le and bo[13] == le and bo[19] == le and bo[25] == le) or # diagonal 13 (7)(13)(19)(25)
    (bo[14] == le and bo[20] == le and bo[26] == le and bo[32] == le) or # diagonal 14 (14)(20)(26)(32)
    (bo[21] == le and bo[27] == le and bo[33] == le and bo[39] == le) or # diagonal 15 (21)(27)(33)(39)
    (bo[6] == le and bo[12] == le and bo[18] == le and bo[26] == le) or # diagonal 16 (6)(12)(18)(26)
    (bo[13] == le and bo[19] == le and bo[25] == le and bo[31] == le) or # diagonal 17 (13)(19)(25)(31)
    (bo[20] == le and bo[26] == le and bo[32] == le and bo[38] == le) or # diagonal 18 (20)(26)(32)(38)
    (bo[5] == le and bo[11] == le and bo[17] == le and bo[23] == le) or # diagonal 19 (5)(11)(17)(23)
    (bo[12] == le and bo[18] == le and bo[24] == le and bo[30] == le) or # diagonal 20 (12)(18)(24)(30)
    (bo[19] == le and bo[25] == le and bo[31] == le and bo[37] == le) or # diagonal 21 (19)(25)(31)(37)
    (bo[4] == le and bo[10] == le and bo[16] == le and bo[22] == le) or # diagonal 22 (4)(10)(16)(22)
    (bo[11] == le and bo[17] == le and bo[23] == le and bo[29] == le) or # diagonal 23 (11)(17)(23)(29)
    (bo[18] == le and bo[24] == le and bo[30] == le and bo[36] == le))  # diagonal 24 (18)(24)(30)(36)
#

Answer 1

(bo[11] == le and bo[12] == le and bo[13] == le and bo[14] == le) # 2nd row 4

You missed an or at the end of this line.

Answer 2

When you are working on a two dimensional board, consider using a two dimensional array.

Try to find the logic behind the winning condition instead of enumerate all possible configurations.

Here a quite verbose (quick and dirty) example of how I would approach this topic:

#! /usr/bin/python3

class Board:
    def __init__ (self, width, height):
        self.width = width
        self.height = height
        # empty string means empty tile
            # initialize an empty board
        self.tiles = [ [' ' for x in range (width) ] for y in range (height) ]

    def __setitem__ (self, key, value):
        # only allow for X or O
        if value not in 'XO':
            raise Exception ('Invalid character')
        x, y = key
        # once a tile is set, it can't be changed
        if self.tiles [y] [x] != ' ':
            raise Exception ('Tile already taken')
        self.tiles [y] [x] = value

    def __getitem__ (self, key):
        x, y = key
        try:
            tile = self.tiles [y] [x]
        except IndexError:
            # return empty when out of bounds,
            # thus we don't need to care about bounds in winner (self)
            return ' '
        return self.tiles [y] [x]

    def pprint (self):
        #print it prettily
        horizontal = '+-' * self.width + '+'
        print (horizontal)
        for line in self.tiles:
            print ('|{}|'.format ('|'.join (line) ) )
            print (horizontal)

    def winner (self):
        #kept intentionally explicit
        for x in range (self.width):
            for y in range (self.height):
                tile = self [x, y]
                # if the tile is empty, no winning configuration can start from here
                if tile == ' ': continue
                # the horizontal line
                hor = [self [x + off, y] for off in range (1, 4) ]
                # the vertical line
                vert = [self [x, y + off] for off in range (1, 4) ]
                # the ascending diagonal
                asc = [self [x + off, y - off] for off in range (1, 4) ]
                # the descending diagonal
                desc = [self [x + off, y + off] for off in range (1, 4) ]
                # if any of these straights contains only same symbol as tile, we have a winner
                if any (all (x == tile for x in straight) for straight in (hor, vert, asc, desc) ):
                    return tile

b = Board (7, 6)
b [4, 1] = 'O'
b [3, 2] = 'O'
b [2, 3] = 'O'
b [1, 4] = 'O'
b [1, 5] = 'X'

b.pprint ()         
print ('Winner is', b.winner () )