Katelyn Kerr's Portfolio

                    while 1:
                        original = "abcdefghijklmnopqrstuvwxyz ,.!?"
                        original_123 = "abcdefghijklmnopqrstuvwxyz ,.!?0123456789"
                        lazy_dog = "thequickbrownfxjmpsvlazydg ,.!?"
                        bookworm = "zxvtrpnljhfdbaceglkmoqsuwy ,.!?9753102468"
                        backwards = "zyxwvutsrqponmlkjihgfedcba ,.!?9876543210"
                        keyboard = "qwertyuiopasdfghjklzxcvbnm ,.!?7894561230"
                        keyboard_diagonal = "qazwsxedcrfvtgbyhnujmikolp ,.!?0142753869"
                        split = "nopqrstuvwxyzabcdefghijklm ,.!?5678901234"
                    
                    
                        response = input("Would you like to encrypt(e) or decrypt(d) or quit(q)?").lower()
                        print(response)
                    
                    
                        if response == "e":
                            print("Encrypt")
                            response_encrypt_code = input("What code would you like to encrypt in? Lazy dog, bookworm, backward, keyboard, keyboard diagonal, or split.").lower()
                            if response_encrypt_code == "lazy dog":
                                response_encrypt_lazy_dog = input("What would you like to encrypt?").lower()
                                lazy_dog = str.maketrans(original, lazy_dog)
                                encrypted_final_message_lazy_dog = response_encrypt_lazy_dog.translate(
                                    lazy_dog
                                )
                                print(encrypted_final_message_lazy_dog)
                    
                    
                            elif response_encrypt_code == "bookworm":
                                response_encrypt_bookworm = input("What would you like to encrypt?").lower()
                                bookworm = str.maketrans(original_123, bookworm)
                                encrypted_final_message_bookworm = response_encrypt_bookworm.translate(
                                    bookworm
                                )
                                print(encrypted_final_message_bookworm)
                    
                    
                            elif response_encrypt_code == "backwards":
                                response_encrypt_backwards = input(
                                    "What would you like to encrypt?"
                                ).lower()
                                backwards = str.maketrans(original_123, backwards)
                                encrypted_final_message_backwards = response_encrypt_backwards.translate(
                                    backwards
                                )
                                print(encrypted_final_message_backwards)
                    
                    
                            elif response_encrypt_code == "keyboard":
                                response_encrypt_keyboard = input("What would you like to encrypt?").lower()
                                keyboard = str.maketrans(original_123, keyboard)
                                encrypted_final_message_keyboard = response_encrypt_keyboard.translate(
                                    keyboard
                                )
                                print(encrypted_final_message_keyboard)
                    
                    
                            elif response_encrypt_code == "keyboard diagonal":
                                response_encrypt_keyboard_diagonal = input(
                                    "What would you like to encrypt?"
                                ).lower()
                                keyboard_diagonal = str.maketrans(original_123, keyboard_diagonal)
                                encrypted_final_message_keyboard_diagonal = (
                                    response_encrypt_keyboard_diagonal.translate(keyboard_diagonal)
                                )
                                print(encrypted_final_message_keyboard_diagonal)
                    
                    
                            elif response_encrypt_code == "split":
                                response_encrypt_split = input("What would you like to encrypt?").lower()
                                split = str.maketrans(original_123, split)
                                encrypted_final_message_split = response_encrypt_split.translate(split)
                                print(encrypted_final_message_split)
                    
                    
                            else:
                                print("Please input the name of the code you would like to encrypt in.")
                    
                    
                        elif response == "d":
                            print("Decrypt")
                            response_decrypt_code = input("What code would you like to decrypt in? Lazy dog, bookworm, backward, keyboard, keyboard diagonal, or split.").lower()
                            if response_decrypt_code == "lazy dog":
                                response_decrypt_lazy_dog = input("What would you like to decrypt?").lower()
                                lazy_dog = str.maketrans(lazy_dog, original)
                                decrypted_final_message_lazy_dog = response_decrypt_lazy_dog.translate(
                                    lazy_dog
                                )
                                print(decrypted_final_message_lazy_dog)
                    
                    
                            elif response_decrypt_code == "bookworm":
                                response_decrypt_bookworm = input("What would you like to decrypt?").lower()
                                bookworm = str.maketrans(bookworm, original_123)
                                decrypted_final_message_bookworm = response_decrypt_bookworm.translate(
                                    bookworm
                                )
                                print(decrypted_final_message_bookworm)
                    
                    
                            elif response_decrypt_code == "backwards":
                                response_decrypt_backwards = input(
                                    "What would you like to decrypt?"
                                ).lower()
                                backwards = str.maketrans(backwards, original_123)
                                decrypted_final_message_backwards = response_decrypt_backwards.translate(
                                    backwards
                                )
                                print(decrypted_final_message_backwards)
                    
                    
                            elif response_decrypt_code == "keyboard":
                                response_decrypt_keyboard = input("What would you like to decrypt?").lower()
                                keyboard = str.maketrans(keyboard, original_123)
                                decrypted_final_message_keyboard = response_decrypt_keyboard.translate(
                                    keyboard
                                )
                                print(decrypted_final_message_keyboard)
                    
                    
                            elif response_decrypt_code == "keyboard diagonal":
                                response_decrypt_keyboard_diagonal = input(
                                    "What would you like to decrypt?"
                                ).lower()
                                keyboard_diagonal = str.maketrans(keyboard_diagonal, original_123)
                                decrypted_final_message_keyboard_diagonal = (
                                    response_decrypt_keyboard_diagonal.translate(keyboard_diagonal)
                                )
                                print(decrypted_final_message_keyboard_diagonal)
                            elif response_decrypt_code == "split":
                                response_decrypt_split = input("What would you like to decrypt?").lower()
                                split = str.maketrans(split, original_123)
                                decrypted_final_message_split = response_decrypt_split.translate(split)
                                print(decrypted_final_message_split)
                    
                    
                            else:
                               print("Please input the name of the code you would like to decrypt in.")
                    
                    
                        elif response == "q":
                            response_quit = input("Are you sure you want to quit? Yes(y). No(n).").lower()
                            if response_quit == "y":
                                print("Yes. Quitting now. See you soon. ;)")
                                break
                            elif response_quit == "n":
                                print("No. Looping now.")
                            else:
                                print(
                                    "oops. Please try again. Please note that the only resonsense it will accept are y or n."
                                )
                    
                    
                        else:
                            print(
                                "oops. Please try again. Please note that the only resonsense it will accept are e or d or q."
                            )
                

                    number = 47
                    While number == 47:
                        guess = int(input("Guess:"))
                            if guess == number:
                                print("Congrats! You got it.")
                                break
                            elif guess < number:
                             print("Higher!")
                                break
                            elif guess > number:
                                print("Lower!")
                                break
                        break
                

This stylesheet is very messy, my apologizes.