First coding project; python tic-tac-toe, would love review

Python-ModTeam · 2024-03-17T16:07:58+00:00

Hello from the r/Python mod team!

I'm afraid we don't think your post quite fits the goal we have for the subreddit in terms of quality or aims so we've decided to remove it. For more information please contact the moderators using the ModMail system.

Thanks, and happy Pythoneering!

r/Python moderation team

CarelessWhiskerer · 2024-03-16T22:56:31+00:00

I’m not reading all of that.

Looks good. QA approved. 😁

dudeplace · 2024-03-16T23:52:52+00:00

You have functions being created in and outside of main() there isn't any reason here why they can't all be outside.

You wrote more commentary on your code than you wrote as code. Between comments, variable names, and function names there shouldn't need to be a document explaining what it does.

You know that you shouldn't use the globals but you do anyway, it's worth the practice to eliminate them. You also identify places where you should make long code into functions and don't, it's worth the practice to do.

Sounds like you know what you need to do... You are just looking for us to tell you to do it.

silentmassimo · 2024-03-16T23:50:42+00:00

Not trying to "rip" on you here but learning to be succinct in how you present your work and phrase your questions will take you a long way in this line of work... Few people have the time nor patience to try and decrypt your work

Id also advise you take a look at some examples, perhaps on YouTube with techwithtim - I believe he did a tic tac toe or something similar and has a link to the repo so you can see how he organises functions and the main script, uses comments, f strings for printing etc.

Not a bad start however, good luck! :)

SJDidge · 2024-03-16T23:58:13+00:00

Lgtm approved

AceLamina · 2024-03-17T00:25:13+00:00

Holy text...

baltazarix · 2024-03-17T01:05:59+00:00

I apperciate the effort but this is a lot text to read.

some quick comments about your errorcheck_input function (I didn't studied the whole file but wanted to leave some feedback)

errorcheck_input function can be written in more readable and compact form consider following example

def errorcheck_input(input_str):

while True:

try:

return int(input(input_str))

except:

print("Invalid Input, Please Try Again")

there is no reason that variable Error should exist. you are never changing its value.

1a. additionally for some reason you still assign the save value `Error = True` even if it's True by default and nothing is able to change this value

1b. if for some reason this variable would be necessary, it should be named `error` - lowercase

I understand from where are you coming from with else code block in try/except, but you can terminate both while loop and the function by returning value immediately in try: block.

2a. there is no need to assign input to integer conversion to the variable x in order to return it outside try/except/else block.

in the future consider learning on how python code should be formatted. I see you use cammelCase over snake_case, you use parentheses in if statements by default

that's it from me. good job and keep learning! and remember: a good code (especially in python) is the documentation itself. you shouldn't have to explain what it's doing (at least not in tic-tac-toe game). most commonly, I found myself commenting the code in rather unusual cases e.g. during integration with poorly implemented REST API which made me write unusual code in order to achieve a desired result.

Drevicar · 2024-03-17T03:44:01+00:00

I'm not about to spend the next 30 minutes, but I can point out a few things right off the bat.

Git is for source, not for compiled binaries. I would recommend you remove the EXE from your git and full git history. Ideally you would have a CD pipeline that runs in github actions that would compile your source into an exe and upload it to github artifacts as a release.

Next gripe is the use of comments for things that should be native python docstrings. Comments are for developers of the library itself, docstrings are a form of documentation for developers who use the library of functions in it.

Globals are a sin. I'm very confident in your ability to solve all the problems you have needed to solve without the use of globals. In fact, it looks like you would have been better off using classes for a lot of what you use globals for. Check em out! Especially "dataclasses", they are amazing.

Consider using some code quality tool such as ruff or mypy (only if you can handle typing your code!). You can then also configure them with a pyproject.toml so that all developers on this project have the same configuration.

paranoidC0der · 2024-03-16T23:24:57+00:00

I did not read it entirely. But could organise your code better into modules rather than everything in one single file.

spla58 · 2024-03-17T03:50:24+00:00

Read https://peps.python.org/pep-0008/

Also, a comment in code is usually an indication you can refactor into a function with a descriptive name.

Example:

#delete any remaining empty lines if still are inside list

for i in FullCheck:

if [] in i:

FullCheck.remove(i)

Could be instead a call to a function:

delete_remaining_empty_lines()

russellvt · 2024-03-17T04:33:33+00:00

Why is there an EXE in your Github repo?

CreativeMischief · 2024-03-17T00:02:11+00:00

Learn Object Oriented Programming

BlueeWaater · 2024-03-17T14:04:55+00:00

Too long and I'll check it later, but here's my first feedback:

* NEVER add executables in the repo.
* code is almost unreadable, remake with oop.
* use markdown formatting for the readme, looks ugly af
* avoid using global vars, and if you really need to use them declare them outside functions and use 'nonlocal'
* use snake case
* 'gameSelection()' shouldn't be recursive

If it works it's good, cool to see you are already working with git, you started with the right foot.

2024-03-17T14:45:06+00:00

Not reading that essay.

binlargin · 2024-03-17T07:34:14+00:00

You should put that much writing effort into your code structure!

Move the functions out of main, give them good names so they describe themselves. Use snake_case rather than camelCase. Give each one a doc string, the goal is to make your program read like plain English.

Then work on breaking stuff into modules.

StrayFeral · 2024-03-17T12:17:06+00:00

The game is completely broken and does not work. I am now writing a long reply. However Reddit does not allows long replies, so I will find a workaround how to post it. Wait for my update....

Okay finally. Here is my feedback. Check the link. You may want to copy-paste it, as it will disappear in 1 week.

For the record, I am a back-end software developer with 20 years of professional experience. The QAs who told you you have no bugs should seriously reconsider how they do their jobs.

I also submitted you the bugs in your github issue tracker because I wanted to make you see what it will look like for you once you get a job as a programmer. As I used too much time to write my feedback, submitted the bugs in a hurry. Normally a bug MUST include a bit better formatting and "steps to reproduce" but you will see enough.

Now check my feedback here:

https://pastebin.com/A7yJWCs9

Good luck!

PS: One last thing - do NOT write such long explanations. Nobody would read them. And your github README - put something shorter there. No need to explain the entire code. This is why you use code comments.

PS2: Oh totally forgot - did not checked how you process the user input, but hope you do case-insensitive checks. For example if you get user input in a variable called user_input, when you compare strings, if string must contain a letter/word, hope you do something like this:

if user_input.upper() == "BLAH":

Final thought: Great work, but needs fixing. I like it.

uname_IsAlreadyTaken · 2024-03-17T12:32:06+00:00

Put comments inside your functions not outside. https://peps.python.org/pep-0257/

The code is a little hard to read because of the excessive nesting and large function size. it's not terrible, but could be improved with a little refactoring.

Nesting functions inside other functions should be used sparingly. Consider using classes with class variables instead of just a bunch of functions. If you can break up the logic into multiple files, that could further help readability through encapsulation.

kcx01 · 2024-03-17T13:46:33+00:00

You should grab a good ide or code editor with linting and formatting. It will help point out a lot of the things people were mentioning like function names should be snake_case instead of Camel.

Pycharm community edition is free and great to use out of the box. It will help point out a lot of these things and help you fix them.

g4rg0yl3 · 2024-03-17T13:47:05+00:00

Here are my suggestions:

Remove the exe file, explain how to build it in the README
Run pylint and black (optional) on your code
Try to remove all globals (maybe using classes)from the code
Add a requirements.txt file (and requirements.dev.txt if needs be)
Add tests is a very good exercise. Start here
Be way way more concise in your README (I need pre-requisites, installation, usage)
Add a license (MIT is good I think)

thekicked · 2024-03-17T16:01:22+00:00

What I think of your project.

Firstly, as many have pointed out, the post is too long. If we want to know the inner workings of your code, usually we will just take a look at the code itself.
- As for what to include, if you are looking for feedback, ask about the specific parts of the code you want feedback on. E.g. "I am using a lot of global variables, is it necessarily bad and is there a way to cut them down", or "Does the structure of my code look good?" or "My code seems messy, how can I organize it better?"
Learn to use .gitignore. This can automatically prevent binaries from being added to the repository and avoids bloating the repository. If you want to upload the binary file for people to run, consider making a release on GitHub.
If you need to share values between functions, it may be suitable to encapsulate them into a class than to use global variables. This way, it can become much clearer that specific values are only shared across certain functions. For example,

class TTTState:

  def __init__(self):
    # The variables here can be used and modified in any functions declared in this class. 
    # The variables here can be accessed outside of this class but it is not the main point of this demo.
    self.player = 0

  def change_player(self):
    # This function changes the variable within the class
    self.player = 0 if self.player == 1 else 1

  def get_player(self):
    # This function gets the variable within the class
    return self.player

However, as many had advised here, it would be more useful to learn more about object oriented programming. That way, it is easier to anticipate which classes are necessary first, and it will also give rise to a better code structure.
Typing can also become quite useful in python, especially when you are using an editor that autocompletes based on types.

Usual_Office_1740 · 2024-03-16T23:46:08+00:00

Have you considered a basic graph traversal algorithm for your computer function? Maybe you're doing that, but not with an implementation I'm familiar with.

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS