As a programming exercise, I've attempted a Tic-Tac-Toe solver which takes a finished board and determines a winner.  On top of checks for malformed input/ambiguous games (e.g. both players with winning positions), what else can I do to improve this? In particular, is the coding style acceptable and are there better ways to check for win conditions? def tictac(b):         Parses a tic-tac-toe board and returns a winner.    Input: a list of lists containing values 0 or 1.    0 corresponds to 'noughts' and 1 to 'crosses'    e.g.    >>> gameboard = [[0,0,1],[0,1,0],[1,1,0]]    >>> tictac(gameboard)    X wins        # If the sum of a column/row/diagonal is 0, O wins.    # If the sum is number of rows/columns, X wins.    winner =     board_range = range(len(b))    # Check rows and columns.    for i in board_range:        row_sum = sum(b[i])        col_sum = sum([x[i] for x in b])         if row_sum == 0 or col_sum == 0:            winner =  O wins        elif row_sum == len(b) or col_sum == len(b):            winner =  X wins    # Check the diagonals.    fwd_diag_sum = sum([b[i][i] for i in board_range])    bck_diag_sum = sum([b[i][len(b)-i-1] for i in board_range])    if fwd_diag_sum == 0 or bck_diag_sum == 0:                winner =  O wins    if fwd_diag_sum == len(b) or bck_diag_sum == len(b):                winner =  X wins    if winner:        print winner    else:        print Game is a tie!For convenience, here's a little test function too:def test_tic_tac():    def pretty_print(b):            for row in b:                print row    gameboard = [[0,0,1],[0,1,0],[1,1,0]]    pretty_print(gameboard)    tictac(gameboard)    gameboard = [[0,1,1],[0,0,0],[1,1,0]]    pretty_print(gameboard)    tictac(gameboard)    gameboard = [[1,0,1],[0,0,1],[0,1,0]]    pretty_print(gameboard)    tictac(gameboard)    gameboard = [[0,0,1,0],[1,1,0,1],[0,1,1,1],[0,1,0,1]]    pretty_print(gameboard)    tictac(gameboard)
Tic-Tac-Toe solver
python;python 2.7;tic tac toe
Missing handling for incomplete boards of finished gamesThe program works only with complete boards. It won't work with this finished game with incomplete board, which is kind of a big drawback for a game evaluator:    ox o oo x xReturn result instead of printingIt would be better to not have the board evaluation logic and printing in the same method.You should split these steps into separate functions.This will make some optimizations easier (see my next point).It will also help improving your testing technique.Testing by reading output is not convenient.It's best when tests either pass or fail,so that you can verify if the program behaves correctly just by checking that everything passes.One way to achieve this is using assertions, for example:assert X wins == evaluate_board([[0, 0, 1], [0, 1, 0], [1, 1, 0]])A better way is using the unittest package of Python,and splitting your test method to distinct test cases for different kinds of winning positions, such as win by row sum, col sum, diagonal.Wasted operationsIn the loop that checks the row and column sums,once you found a winner, the loop happily continues,and after the loop you check the diagonals,when in fact you could return the winner as soon as you see it:if row_sum == 0 or col_sum == 0:    return O winsBy returning sooner,the final if winner statements could be replaced with a simple return Game is a tie!Duplicated string literalsThe O wins, X wins string literals appear multiple times.It would be better to avoid such code duplication,as it's prone to errors if you ever change the message format,you have to remember to make the same change everywhere.Coding styleYou should follow PEP8.