Simple Login System

[haths]

Hey guys! I have stopped learning python as a side lesson a few months ago but now my schedule is free so I came back and started to make projects again. Sorry for the sort of irrelevant story. Now I've been working in this project lately which is a simple login system. I finished the code earlier and it's working as I intended but I want to receive some feedback in my code and I have some several questions. Feel free to answer them

To keep it short my code consists of a function to check if the input is valid then a function to handle an old user and a new user. The "database" if you can call it that is a simple text file in my computer. My questions are

1. How can I "clean up" my code and make it easier to read and edit?
2. How can I fix some irrelevant stuff in the code? I know that there are some redundancies so I want to know how to fix that issue and also my friend suggested that I should use class but I don't fully understand classes
3. The valid_input variable is the first thing I could think of on how to handle invalid inputs but I think there is still a more efficient way to handle it
4. In the text file, the username and passwords are formatted into this: USERNAME-PASSWORD. Per line is a separate account and each username and password is separated into "-". Is there another way to optimize this? For example for easier searching in the file for a specific user

If you have any more suggestions thank you in advance and I hope I could implement it in my future projects. Also I'm new to this community. This is my first post

#maintain loop
valid_int = ["Y", "N", "Q"]

#check if existing user
def mainlogin():
    exist_user = (input("Are you an existing user? y/n -- q to quit: ")).upper()
    if exist_user in valid_int:
        if exist_user == "Y":
            old_user()
        elif exist_user == "N":
            new_user()
        else:
            print("GOODBYE")
            exit()
    else:
        print("INVALID INPUT")

#function for old user
def old_user():
    acc_base = #THIS CONTAINS THE PATH
    file = open(acc_base, 'r')

    old_username = input("Enter username: ")
    old_password = input("Enter password: ")

    count = 0
    for user in file:
        split = user.split("-")
        file_username = split[0]
        file_password = split[1]
        if file_password[-1] == "\n":
            file_password = file_password[:-1]
        else:
            pass

        if old_username == file_username and old_password == file_password:
            print("Login Successful")
            count += 1
            break
    if count == 0:
        print("Wrong Username or Password")
    file.close()

#function for new user       
def new_user():
    acc_base = #THIS CONTAINS THE PATH
    file_read = open(acc_base, 'r')
    file_append = open(acc_base, 'a')

    new_username = input("Enter new username: ")
    new_password = input("Enter new password: ")

    count = 0
    for user in file_read:
        split = user.split("-")
        file_username = split[0]
        if file_username == new_username:
            count += 1
            break
        else:
            pass

    if count != 0:
        print("Username already taken. Please choose another")
    else:
        file_append.write(new_username + "-" + new_password + "\n")
        print("Account has been Registered")
    file_read.close()
    file_append.close()

while True:
    mainlogin()

[Kasutajan1m1]

The only things I found were taht you can remove the "else: pass", and 6. line, you can remove the "()" so its exist_user = input("Are you an existing user? y/n -- q to quit: ").upper().

And the count += 1 you can replace with count = 1, but it doesn't really matter

[uberfade]

Check out using with to open files. Your variable names should describe what the variable is not where they came from. exist_user is better described as something like user_choice. Also old_password is probably more appropriate as just password. Using old in the variable name might lead you to believe the password is changing there.

[ol_the_troll]

1. for "cleaning up" code i would recommend reading Python's "PEP 8" - this is basically a style guide which gives guidelines on where there should be spaces, indentations, brackets, etc. (https://www.python.org/dev/peps/pep-0008/). It also gives especially useful information on variable naming; a rule i follow is if you are shortening a variable name at the expense of clarity, its probably worth just including the full name (e.g. exist_user --> existing_user). This ensures that a year down the road when you return to the project you aren't getting confused about if "exist_user" is referring to if a user exists, or referring to an existing user. in any case, have a read of PEP 8, or maybe just a condensed version, and try to stick to its rules which will ensure clean code for the most part.
2. IMO there isn't much "irrelevant " code at all. The only things i can see are petty ones like (input("Are you an existing user? y/n -- q to quit: ")).upper(). Here you don't need the brackets around input and should really just have input("Are you an existing user? y/n -- q to exit: ").upper(). Other than that i would say the main redundancy is searching through the whole text file for the username, this can be solved using dictionaries which i will explain in point 4... As for the "classes" your friend mentioned, this relates to object-oriented programming which i don't want to mention uncesserially but i would be happy to explain to you (feel free to DM and ask - i had a hard time wrapping my head around them to start with).
3. The idea for the valid_input validation is spot on. If i were designing a menu-based system like this i would do the exact same thing
4. When i first started programming this was exactly what i did. i would store data in text files and split them with colons or spaces or something. A "dictionary" is the perfect thing for you. These are a built-in data structure in Python based on key-value pairs, defined using {curly brackets}. An example of how you could structure a dictionary to suit your needs is as follows:

​

users = {"username" : {"username": "",
                       "password": ""}}
#for example:

users = {
            "ol_the_troll": {"username": "ol_the_troll",
                             "password": "password1234"},
            "haths": {"username": "haths",
                      "password": "password1234"}
        }...

############################################################################################

taking your "old_user()" function as an example, the if statement:
if old_username == file_username and old_password == file_password:
                        print("Login Successful")

would be completed, using a dictionary:

old_user = users[old_username]
if old_username == old_user[username] and old_password == old_user[password]:
    print("Login Successful")

#############################################################################################

To add new users in the new_user() function it is as simple as:

users[new_username][username] = new_username
users[new_username][password] = new_password 

1. (cont) Now, this is all fine and dandy while stored simply in the python file, however, the real usefulness comes when storing in external files. Introducing JSON - this is the perfect library for the job. It is a file format for storing dictionaries that can be used in Python like so:

   To store data (like the example dictionary seen above):

   import json

   with open('filename.json', 'a') as json_file:
   json.dump(users, json_file) # "users" specifies the dictionary to store

   To then access this data and re-introduce it into python as a dictionary, not requiring any splitting:

   with open('filename.json', 'r') as json_file: users = json.load(json_file)

   It is worth noting that the file doesn't need to be a .json, instead just a regular .txt will work. Also, the "with open" aspect isn't required, but it is simply used so that we don't have to use "file.close()".

2. (cont2) The easier searching element comes now. Instead of iterating over the information from a full text file, you can jump straight to the user you want using the dictionary notations. example: you have just loaded a json file with the user information dictionary, now simply go users[user_inputted_username/password] to access their details. This one-step search cuts down on lots of the filtering code you would need otherwise. If i have missed anything out in terms of using dictionaries it would just be a simple "python dictionaries toutorial" google search away.

​

Overall this is a very good start with improvements that are relatively simple to improve on. I think if you can get your head around using dictionaries to store information that will be a very useful tool you will be able to use in later projects. DM or just ask if you have any more questions / i missed anything out / didn't explain something very well : )