Ytdyklly

I'm trying to develop a program in Python that allows the user to import datasets and perform operations on them using pandas and numpy so she/he can skip writing all the preprocessing code her/himself.

I have two questions. Am I using my functions poorly? For example, can I create cleaner, more efficient code by using more classes and creating objects with def SomeCode(self, etc, etc)? I still struggle with understanding the concept of init and self because I mainly use Python to clean and analyze data. I'm worried I'm writing some real spaghetti code.

Second, I need to save the state of the data frame after it's been operated on. For example, at the beginning of the program, the user imports a dataset and it's read into the variable df. The user then has options to perform operations on the dataset, such as drop columns by index, rename columns, etc. After a user operates on the data frame, I need to save the new state of the data frame and have it reflected everywhere else in the program. So the next time the user displays the dataset, he sees the dataset with the changes. For example, if the user re-displays the columns, the columns he dropped earlier are not displayed.

Thank you!

class Clean:



# Imports file, displays some information about the dataset

def Main():

    while True:

        file_name = input("nPlease enter the name of the .csv file you want to process (if the .csv file is not in the same directory as this program, please provide relative path): n")

        try:

            print("Reading in file...n")

            df = pd.read_csv(file_name) # Reads in file and stores it in df variable

            df_types = (df.dtypes) # Reads in data types of dataset

            df_columns = (df.columns) # Reads in columns of dataset

            df_shape = (df.shape) # Reads in the 'shape' or dimensions of dataset

            df_null_values = (df.isnull().sum(axis=0)) # Reads in the counts of null values in columns



            # Prints information to screen

            print("Here is some information about your dataframe...n")

            time.sleep(.5)

            print("Your data types: nn{}".format(df_types))

            time.sleep(.5)

            print("nYour column names:n {}".format(df_columns))

            time.sleep(.5)

            print("nThe shape of your dataframe is {}n".format(df_shape))

            time.sleep(.5)

            print("Here is the count of null values per column:n{}n".format(df_null_values))



        except (FileNotFoundError):

            print("File path does not exist. Please enter valid path.n")

        else:

            break



    # Ran when user types in "exit" at any point in the program

    def ExitProgram():

            double_check = input("Are you sure you want to exit the program? (yes/no) (NOTE: Saying 'no' will return you to option menu.)n")

            if double_check in yes_values:

                print("nThanks for cleaning your dirty data!")

                exit()

            elif double_check in no_values:

                DoNext()



    def SaveDataframeState(temp_df):

        temp_file_name = "temp.csv"

        temp_df.to_csv(temp_file_name)

        df = pd.read_csv(temp_file_name)



    # Hashes columns to an index

    def ColumnsToIndex():

        column_list = 

        index_of_list = 



        for col in df_columns:

            column_list.append(col)

            length_of_list = len(column_list)

        for num in range(length_of_list):

            index_of_list.append(num)

        hash = {k:v for k, v in zip(index_of_list, column_list)}

        print("nHere is the index of columns...n")

        for k,v in hash.items():

            print(k, ":", v)

    ColumnsToIndex()



    # Displays the amount of rows user inputs

    def DisplayInputtedRows():

        while True:

            try:

                rows_to_display = input("nHow many rows would you like to display? (Note: Whole dataset will have a limited display in terminal)n")

                time.sleep(.5)

                print(df.head(int(rows_to_display))) # prints inputted rows to screen

            except (ValueError):

                print("Please pass an integer.")

            else:

                break

    DisplayInputtedRows()



    # Displays the amount of rows user inputs when they type 'row' on option menu

    def RedisplayRows():

        while True:

            try:

                rows_to_redisplay = input("nHow many rows would you like to display? (Note: Whole dataset will have a limited display in terminal)n")

                time.sleep(.5)

                print(df.head(int(rows_to_redisplay)))

                DoNext()

            except (ValueError):

                print("Please pass an integer.")

            else:

                break



    def RenameColumns():

        print("nHere are your columns by name:n{}".format(df_columns))

        rename_columns = input("nWhat columns would you like to rename?n")

        print(rename_columns)

        if rename_columns == "return":

            DoNext()

        elif rename_columns == 'exit':

            ExitProgram()



    def DropOneColByIndex():

        drop_one_col_by_index = input("What columns do you want to drop? Please type in the index:n")

        temp_df = df.drop(df.columns[int(drop_one_col_by_index)], axis=1)

        print(temp_df.head())

        DoNext()



    def DropColumnsByIndexPrompt():

        print("Here are your columns by name:n{}".format(df_columns))

        ColumnsToIndex()



        drop_more_than_one_col = input("nWould you like to drop ONLY 1 COLUMN? Types 'yes' to ONLY drop 1 COLUMN, type 'no' to drop MORE THAN 1 COLUMN.n")



        if drop_more_than_one_col in yes_values:

            DropOneColByIndex()

        elif drop_more_than_one_col in no_values:

            print()

        elif drop_more_than_one_col == "return":

            DoNext()

        elif drop_more_than_one_col== 'exit':

            ExitProgram()



    time.sleep(.5)



    def DropColumnsByDatatype():

        print("Here are your columns by data-type:n{}".format(df_types))

        drop_columns_by_datatype = input("nWhat columns would you like to drop?n")

        if drop_columns_by_datatype == "return":

            DoNext()

        elif drop_columns_by_datatype == 'exit':

            ExitProgram()



    # Main option screen where user can select operations on dataframe

    def DoNext():

        print("n(NOTE: If at any point in the program you want to exit back to this option menu, just type 'return'.)n")

        print("(NOTE: At this part of the program you can also redisplay rows by typing 'rows'.)n")



        do_next = input("nWhat would you like to do next?n[0] Rename Columns n[1] Drop Column(s) by Index n[2] Drop Column(s) by Data-typen")

        if do_next == '0':

            RenameColumns()

        elif do_next == '1':

            DropColumnsByIndexPrompt()

        elif do_next == '2':

            DropColumnsByDatatype()

        elif do_next == 'exit':

            ExitProgram()

        elif do_next == "rows":

            RedisplayRows()

    DoNext()



Main()