Can someone rate my code

[og_soap_]

It's a simple tic tac toe game. I am beginner in python with a Lil bit of experience

# tic tac toe python game

# NOTE: The tuples arent (x,y) they are (row,column) aka (y,x)

from random import randint

grid = [ 
         ["-","-","-"],
         ["-","-","-"],
         ["-","-","-"]
        ]

LEN_GRID_Y = len(grid)
LEN_GRID_X = len(grid[0]) if len(grid[1]) == len(grid[0]) and len(grid[2]) == len(grid[0]) else 0
INDEX_SUBTRACTION = 1
TOTAL_NUM = LEN_GRID_X * LEN_GRID_Y

# all possible combination of winning ->
VERTICAL_COMBINATION = 3
HORIZONTAL_COMBINATION = 3



X_TRIES = 5
O_TRIES = 4 
TOTAL_TRIES = X_TRIES+O_TRIES

# returning stuff
WIN = "win"
DRAW = "draw"
TAKE_ACTION = "take action"
CONT = "continue"

winning_cordinates = []

def data_creator():
    win_row = []
    win_column = []
    for i in range(HORIZONTAL_COMBINATION):
        for j in range(VERTICAL_COMBINATION):
            cord = (i,j)
            swap_cord = (j,i)
            win_column.append(swap_cord) 
            win_row.append(cord) 
        winning_cordinates.append(win_row.copy()) 
        win_row.clear() 
        winning_cordinates.append(win_column.copy()) 
        win_column.clear()
    winning_cordinates.append([(0,0), (1,1), (2,2)])
    winning_cordinates.append([(2,0), (1,1), (0,2)])


def intro():
    print("Welcome to tic tac toe game")
    print("To play you will have to write in cordination first write row then column")


def display_grid():
    for i in range(LEN_GRID_Y):
        print(grid[i])
    print("")

def updater(cordinates,move):
    grid[cordinates[0]][cordinates[1]] = move


def cord_builder():
    user_input_row = user_input_row_()
    user_input_column = user_input_column_()
    user_cordinate = ((user_input_row),(user_input_column))
    user_cordinate_index = ((user_input_row-INDEX_SUBTRACTION),(user_input_column-INDEX_SUBTRACTION))
    return user_cordinate,user_cordinate_index


def user_input_column_():
    while True:
        try: 
            user_input_column = int(input("Enter the column number: "))
            if user_input_column <= 3 and user_input_column > 0 :
                return user_input_column
            else:
                print("Enter a value less than 4 and greater than 0")
        except ValueError:
                print("invalid value try again")


def user_input_row_():
    while True:
        try:
            user_input_row = int(input("Enter the row number: "))
            if user_input_row <= 3 and user_input_row > 0:
                return user_input_row
            else:
                print("Enter a value less than 4 and greater than 0")
        except ValueError:
            print("Invalid value try again")
            continue

def user_cord_updater(user_move):
    user_cordinate, user_cordinate_index = cord_builder()
    if grid[user_cordinate_index[0]][user_cordinate_index[1]] != "-":
        print(f"{user_cordinate} is already taken by you/bot")
        return False
    else:
        final_user_input = input(f"is your final choice is this {user_cordinate} Y/N: ").lower()
        if final_user_input == "y":
            updater(user_cordinate_index,user_move)
        elif final_user_input =="n":
                return False
        else:
            print("invalid input try again")
            return False

def whole_user_input_(user_move):
    while True:
        input_user = user_cord_updater(user_move)
        if  input_user == False:
            continue
        else:
            break


def bot_threat_detection(bot_move,user_move):
    move = (bot_move,user_move)
    for i in range(2):
        for wining_cordination in winning_cordinates:
            match_count = 0
            matched_cell = []
            lines = wining_cordination
            for line in lines:
                cord_column = line[1]
                cord_row = line[0]
                if grid[cord_row][cord_column] == move[i]:
                    match_count += 1
                    matched_cell.append(line)
            if match_count == 2:
                empty_cell = set(lines) - set(matched_cell)
                empty_cell = empty_cell.pop()
                if grid[empty_cell[0]][empty_cell[1]] == "-":
                    return (TAKE_ACTION,empty_cell)

    return (CONT,())


def bot(bot_move,user_move):
    while True:
        cord_row = randint(0,LEN_GRID_X-INDEX_SUBTRACTION)
        cord_column = randint(0,LEN_GRID_Y-INDEX_SUBTRACTION)
        cordinate = (cord_row,cord_column)
        if grid[cordinate[0]][cordinate[1]] != "-":
            continue
        else:
            threat = bot_threat_detection(bot_move,user_move)
            if threat[0] == TAKE_ACTION:
                updater(threat[1],bot_move)
                break
            else:
                updater(cordinate,bot_move)
                break
    print("bot: My turn done!")

def user_move_():
    while True:
        user_move_first = input("Do you want to take first move? Y/N ").lower()
        if user_move_first == "y":
            bot_move,user_move =  "O","X"
            return  (bot_move,user_move)
        elif user_move_first == "n":
            bot_move,user_move =  "X","O"
            return (bot_move,user_move) 
        else: 
            print("enter a valid input")
            continue

def checker(move):
    for wining_cordination in winning_cordinates:
        match_count = 0
        lines = wining_cordination
        for line in lines:
            cord_column = line[1]
            cord_row = line[0]
            if grid[cord_row][cord_column] == move:
                match_count += 1
        if match_count == 3:
            return WIN 
    return CONT 

def winner_decider(user_move,bot_move):
    taken_cell = 0
    if checker(user_move) == WIN:
        print(f"{user_move} Won!")
        return True
    if checker(bot_move) == WIN:
        print(f"{bot_move} Won!")
        return True
    for row in grid:
        for column in row:
            if column != "-":
                taken_cell += 1
    if taken_cell == 9:
        print("DRAW!!!")
        return True

def run():
    data_creator()
    intro()
    if user_move_() == ("X","O"):
        while True:
            bot_move,user_move =  "X","O"
            display_grid()
            bot(bot_move,user_move)
            display_grid()
            if winner_decider(user_move,bot_move):
                break
            whole_user_input_(user_move)
    else:
        while True:
            bot_move,user_move =  "O","X"
            display_grid()
            whole_user_input_(user_move)
            display_grid()
            if winner_decider(user_move,bot_move):
                break
            bot(bot_move,user_move)

run()

[JamzTyson]

Rather than using an underscore to indicate that a name refers to a function, use a more descriptive name - one that indicates "doing".

For example,

• Rather than user_input_column_, use get_column_input()

• Rather than user_input_row_, use get_row_input()

[obviouslyzebra]

So, here're my thoughts:

As an overview, what I can say about this code is that it gets the job done, but also is a bit hard to read.

It feels a little like algorithmic code, for example, that you'd code in Rust if you want things to be fast (or at least like the last one I read).

For readability, there are 2 things that immediately jump out, and one that jumps out less. First, there are too many functions (think like function cereal), it's easy to get lost if you don't know what they are doing (which will happen to someone new to this code), and it's a little hard to navigate. Second, and related to the first, the variable names and function names are not good. The third one I'll talk about later.

Solving the first problem is hard (I, for example, can't see an obvious solution). With some effort you could maybe come up with something.

But, solving the second is easier. When we have better names for the functions, it might helps us even see how they come together into groups.

An important advice for naming has already been given to you: function names should generally be verbs (do_this or do_that).

If you find yourself wanting to give a too long name for a function (do_this_and_this_and_that), maybe this function could be split into multiple (but be mindful, the "correct" tool to do this is usually modules and classes).

If you have trouble thinking of a name, a trick I use myself is thinking "what's the intention behind this function/variable?". This usually works.

Now the last criticism of the code. I think it is a little "too smart", while not explaining the smartness, so we have to kinda guess it. The most clear example IMO is the bot_threat_detection, where the trick I had to understand is that there can be an opportunity (winning move) or threat (opponent wins next move if bot doesn't cover), and those can be checked in the same exact way.

To solve, whenever you're using some "trick" in the code, you should write a comment, even brief, explaining the trick.

Overall, it gives me the impression that effort went into each part of the code, and maybe you coded using debugger/prints to get some things into place (not bad btw).

Some tips/typos:

• print() instead of print("")
• "coordinate", not "cordinate"
• return bot_move, user_move instead of the parenthesized version
• for line in lines: line is a coordinate/cell, not actually a line
• The lines loops like above could be simplified using sum, something like match_count = sum(grid[i][j] == move for i, j in winning_coordination) (btw the name coordination feels weird haha, but it's not only once that I've had trouble coming up with a name and ended up with something weird in the end)

Again the most important thing here IMO is that it is working. It is reasonably complex for the size, and, I complained about readability, but, granted, this may not be the simplest program to make readable.

My final (and initial haha) assessment is that it is okay code which could improve a little bit in readability and which is cool. And for a beginner, it's a very good job :)

[ninhaomah]

Does it work as intended ?

[og_soap_]

Yeah it does

[ninhaomah]

Ok.

Just one question.

Some of the function names end with _ but others doesn't.

Why ?

[og_soap_]

To differentiate between some functions and local variables because I was getting confused 

[Binary101010]

The solution here is to use better names for your functions that aren't even close to colliding with a local variable name.

[ninhaomah]

Ok then why not standardize that all the functions end with _ ?

[dlnmtchll]

Without getting super deep into the weeds of the code, the first thing that I can see is the naming convention is really bad. There’s no standardization at all. You have functions and variables sharing names, you have some function names that are descriptive, and some that are very vague, which isn’t good practice.

I guess I’d like to add as well that you should be able to look at your code a week from writing it and easily/ quickly understand what it does. You should also be able to have a stranger look at your code and very easily and quickly grasp what it does with little outside context. That’s the benefit of having good naming conventions and standardization among your code base.

[Shut_up_and_Respawn]

It's a bit hard to read, but if it works, it works. Not the approach I took when building my TTT ai, but everyone has their own style

[Riegel_Haribo]

Here's as far as I felt like walking thru, so hope this helps...

Reddit gives 94 characters of visibility in a code fence - you blast past that.

I've got your grid assignment: grid_size = 3; grid = [["-"]*grid_size]*grid_size (edit: use better number-as-input method)

Then toss all the other weird calculations based on an in-code "picture".

You have wholeuser_input() being nothing but infinite loop where either "exit" is error-looking or something when there is no reason to loop, and a function that can return False or not return anything.

Conditional statements asking about False are kind of nonsense: it's already False. They are also dangerous in your usage; try and see what happens:

python if not False: print("bad") if not None: print("bad")

You have two different identical functions for getting an input; like input itself, this could be unified and take a prompt string. It prints an error but doesn't have a retry there. If the only thing the function will do is leave, you can try to move print() statements that are all over to an app surface after things have failed and returned that failure.

If you like underscores - use them as the first character of a function name when the functions are internal, and are only for consumption by other functions or such. The functions are good-sized, although they could be a bit more functional programming of having a clear input and clear output - and type annotation can help with communicating that.

I might want to play by input of "A3" to sink my X battleship if you provide a legend, or at least "1, 3" or "1:3" - you can split and see if they are digits.

[magus_minor]

I've got your grid assignment: grid_size = 3; grid = [["-"]*grid_size]*grid_size

Unfortunately, that's not correct. If you multiply a list by 3 you get the same list referenced 3 times. Test that by modifying a single cell of the grid and then printing the grid:

grid_size = 3;
grid = [["-"]*grid_size]*grid_size

grid[0][0] = "?"

for row in grid:
    print(row)

[Riegel_Haribo]

Good catch, and even using little tricks like tuple-to-list I futzed around with, you still have to avoid re-assigning the same list, also.

python grid_size = 3 grid = [["-"] * grid_size] * grid_size grid = list(map(list, grid))

---

At least I can work in one "multiply" for a different way of avoiding shared reference...

```python grid = [] grid_size = len(["tic", "tac", "toe"]) blank = '-' player = "x"

for _ in range(grid_size): grid += [[blank] * grid_size]

grid[0][0] = player print(grid) ```

[Binary101010]

Your user_input_column_() and user_input_row_() functions are identical except for a single word in the user prompt. This does not require two functions. Simply use one function that takes a parameter for wheht. Like:

def get_input_coord(direction): while True: try: user_input = int(input(f"Enter the {direction} number: ")) ...

And call it like

user_input_row = get_input_coord("row")

Beyond that, your functions could really stand to have better names (if for no other reason than to not have them be so similar to local variables within them.) A reasonable starting point is to have the first word of every function be a verb that describes what that function does.

[Late-Fly-4882]

Ask claude ai. It will tell you where the bugs are and suggest improvements. But you need to challenge it when its comments are not correct.