Hangman Game Hints Function

I am struggling to find a way to implement 2 helper functions intended to compare a word with a list of words(checking length) and then to compare letters in those words to show possible matches to the secret word in a game of hangman.

I feel like the way I implemented a few of previous functions may be the reason why I am struggling to find a good way to add these 2 new functions. The current code functions as intended minus the two new functions I would like to add which are shown below.

def match_with_gaps(my_word, other_word):
    '''
    my_word: string with _ characters, current guess of secret word
    other_word: string, regular English word
    returns: boolean, True if all the actual letters of my_word match the 
        corresponding letters of other_word, or the letter is the special symbol
        _ , and my_word and other_word are of the same length;
        False otherwise: 
    '''
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    



def show_possible_matches(my_word):
    '''
    my_word: string with _ characters, current guess of secret word
    returns: nothing, but should print out every word in wordlist that matches my_word
             Keep in mind that in hangman when a letter is guessed, all the positions
             at which that letter occurs in the secret word are revealed.
             Therefore, the hidden letter(_ ) cannot be one of the letters in the word
             that has already been revealed.
           
    # FILL IN YOUR CODE HERE AND DELETE "pass" 

Here is the code as a whole. I just have the secret word on apple to test the code.
Any help would be greatly appreciated!!

import random
import string
letters_guessed = []


WORDLIST_FILENAME = "words.txt"


def load_words():
    """
    Returns a list of valid words. Words are strings of lowercase letters.
    
    Depending on the size of the word list, this function may
    take a while to finish.
    """
    print("Loading word list from file...")
    # inFile: file
    inFile = open(WORDLIST_FILENAME, 'r')
    # line: string
    line = inFile.readline()
    # wordlist: list of strings
    wordlist = line.split()
    print("  ", len(wordlist), "words loaded.")
    return wordlist



def choose_word(wordlist):
    """
    wordlist (list): list of words (strings)
    
    Returns a word from wordlist at random
    """
    return random.choice(wordlist)

# end of helper code

# -----------------------------------

# Load the list of words into the variable wordlist
# so that it can be accessed from anywhere in the program
wordlist = load_words()


def is_word_guessed(secret_word, letters_guessed):
    '''
    secret_word: string, the word the user is guessing; assumes all letters are
      lowercase
    letters_guessed: list (of letters), which letters have been guessed so far;
     assumes that all letters are lowercase
    returns: boolean, True if all the letters of secret_word are in letters_guessed;
     False otherwise#
    '''
    ## FILL IN YOUR CODE HERE AND DELETE "pass"
    for e in secret_word:
        if e not in letters_guessed:
            return True
    print("You Have guessed the secret word!")
    return False

        
            

            
            
                  
            
            
            


    
   



def get_guessed_word(secret_word, letters_guessed):
    '''
    secret_word: string, the word the user is guessing
    letters_guessed: list (of letters), which letters have been guessed so far
    returns: string, comprised of letters, underscores (_), and spaces that represents
      which letters in secret_word have been guessed so far.
    '''
    
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    correct_guess = []
    for e in secret_word:
        if e in letters_guessed:
            correct_guess.append(e)
        else:
            correct_guess.append('_ ')
    print(''.join(correct_guess))
            
            
            
    
            
            
            
        
            
            
            
            
            
        
            
            
           

            
def get_available_letters(letters_guessed):
    '''
    letters_guessed: list (of letters), which letters have been guessed so far
    returns: string (of letters), comprised of letters that represents which letters have not
      yet been guessed.
    '''
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    for e in available_letters:
        if e in letters_guessed:
            available_letters.remove(e)
    print(("Available Letters: "),' '.join(available_letters))
    
    

# def hangman(secret_word):
#     '''
#     secret_word: string, the secret word to guess.
    
#     Starts up an interactive game of Hangman.
    
#     * At the start of the game, let the user know how many 
#       letters the secret_word contains and how many guesses s/he starts with.
      
#     * The user should start with 6 guesses

#     * Before each round, you should display to the user how many guesses
#       s/he has left and the letters that the user has not yet guessed.
    
#     * Ask the user to supply one guess per round. Remember to make
#       sure that the user puts in a letter!
    
#     * The user should receive feedback immediately after each guess 
#       about whether their guess appears in the computer's word.

#     * After each guess, you should display to the user the 
#       partially guessed word so far.

#     Follows the other limitations detailed in the problem write-up.
#     '''
#     # FILL IN YOUR CODE HERE AND DELETE "pass"
#     num_guesses = 6
#     num_warning = 3
#     unique_char = set()
#     print("Welcome to the game Hangman!")
#     print("I am thinking of a word that is", len(secret_word), "letters long.")
#     print("You have", num_guesses,"guesses left.")
#     while is_word_guessed(secret_word, letters_guessed):
#         if num_guesses != 0:
#             player_turn = input("Enter Guess: ")
#             letters_guessed.append(player_turn)
#             for l in player_turn:
#                 if l not in available_letters:
#                     num_warning -=1
#                     print("You may only enter lowercase alphabetic letters that have not already ")
#                     get_available_letters(letters_guessed)
#                     get_guessed_word(secret_word, letters_guessed)
#                     if num_warning <= 0:
#                         num_guesses -= 1
#                         print("You have 0 warnings remaining")
#                         print("You have", num_guesses,"guesses left.")
#                         break
#                     else:
#                         print("You have",num_warning,"warnings remaining")
#                         print("You have", num_guesses,"guesses left.")
#                 elif player_turn not in secret_word:
#                     num_guesses -= 1
#                     get_available_letters(letters_guessed)
#                     get_guessed_word(secret_word, letters_guessed)
#                     print("You have", num_guesses,"guesses left.")
#                     print("I'm sorry, that letter was not in the Secret Word.")
#                 else: 
#                     get_available_letters(letters_guessed)
#                     get_guessed_word(secret_word, letters_guessed)
#                     print("Good Guess!")
#                     print("You have", num_guesses,"guesses left.")
                
#                 for character in secret_word:
#                     unique_char.add(character)
                
#             continue
#         print("I'm sorry you have lost!")
#         print("The secret word was",secret_word)
#         break
#     score = len(unique_char)*num_guesses
#     print("Your score is",score)  
    
    
    
    
    



# When you've completed your hangman function, scroll down to the bottom
# of the file and uncomment the first two lines to test
#(hint: you might want to pick your own
# secret_word while you're doing your own testing)


# -----------------------------------



def match_with_gaps(my_word, other_word):
    '''
    my_word: string with _ characters, current guess of secret word
    other_word: string, regular English word
    returns: boolean, True if all the actual letters of my_word match the 
        corresponding letters of other_word, or the letter is the special symbol
        _ , and my_word and other_word are of the same length;
        False otherwise: 
    '''
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    



def show_possible_matches(my_word):
    '''
    my_word: string with _ characters, current guess of secret word
    returns: nothing, but should print out every word in wordlist that matches my_word
             Keep in mind that in hangman when a letter is guessed, all the positions
             at which that letter occurs in the secret word are revealed.
             Therefore, the hidden letter(_ ) cannot be one of the letters in the word
             that has already been revealed.

    '''
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    pass



def hangman_with_hints(secret_word):
    '''
    secret_word: string, the secret word to guess.
    
    Starts up an interactive game of Hangman.
    
    * At the start of the game, let the user know how many 
      letters the secret_word contains and how many guesses s/he starts with.
      
    * The user should start with 6 guesses
    
    * Before each round, you should display to the user how many guesses
      s/he has left and the letters that the user has not yet guessed.
    
    * Ask the user to supply one guess per round. Make sure to check that the user guesses a letter
      
    * The user should receive feedback immediately after each guess 
      about whether their guess appears in the computer's word.

    * After each guess, you should display to the user the 
      partially guessed word so far.
      
    * If the guess is the symbol *, print out all words in wordlist that
      matches the current guessed word. 
    
    Follows the other limitations detailed in the problem write-up.
    '''
    # FILL IN YOUR CODE HERE AND DELETE "pass"
    num_guesses = 6
    num_warning = 3
    unique_char = set()
    print("Welcome to the game Hangman!")
    print("I am thinking of a word that is", len(secret_word), "letters long.")
    print("You have", num_guesses,"guesses left.")
    while is_word_guessed(secret_word, letters_guessed):
        if num_guesses != 0:
            player_turn = input("Enter Guess: ")
            letters_guessed.append(player_turn)
            for l in player_turn:
                if l not in available_letters:
                    num_warning -=1
                    print("You may only enter lowercase alphabetic letters that have not already ")
                    get_available_letters(letters_guessed)
                    get_guessed_word(secret_word, letters_guessed)
                    if num_warning <= 0:
                        num_guesses -= 1
                        print("You have 0 warnings remaining")
                        print("You have", num_guesses,"guesses left.")
                        break
                    else:
                        print("You have",num_warning,"warnings remaining")
                        print("You have", num_guesses,"guesses left.")
                elif player_turn not in secret_word:
                    num_guesses -= 1
                    get_available_letters(letters_guessed)
                    get_guessed_word(secret_word, letters_guessed)
                    print("You have", num_guesses,"guesses left.")
                    print("I'm sorry, that letter was not in the Secret Word.")
                else: 
                    get_available_letters(letters_guessed)
                    get_guessed_word(secret_word, letters_guessed)
                    print("Good Guess!")
                    print("You have", num_guesses,"guesses left.")
                
                for character in secret_word:
                    unique_char.add(character)
                
            continue
        print("I'm sorry you have lost!")
        print("The secret word was",secret_word)
        break
    score = len(unique_char)*num_guesses
    print("Your score is",score)  
    



# When you've completed your hangman_with_hint function, comment the two similar
# lines above that were used to run the hangman function, and then uncomment
# these two lines and run this file to test!
# Hint: You might want to pick your own secret_word while you're testing.



if __name__ == "__main__":
    # pass

    # To test part 2, comment out the pass line above and
    # uncomment the following two lines.
    available_letters = string.ascii_lowercase
    available_letters = list(available_letters[:])
    #secret_word = choose_word(wordlist)
    secret_word = 'apple'
    #hangman(secret_word)

    
###############
    
    # To test part 3 re-comment out the above lines and 
    # uncomment the following two lines. 
    
    #secret_word = choose_word(wordlist)
    hangman_with_hints(secret_word)

Hello Rufus,
So I’m not going to implement some code here. However, the re library in the python standard library might be what you’re looking for. It’s a powerful pattern matching tool you should try out.

https://docs.python.org/3/library/re.html

Okay, I’ll look into it. Thank you!

I read through that and while I’m sure that documentation definitely covers the easiest way of doing what I am attempting to do, it may be a little advanced to the current lecture/lesson I am learning from. I believe the issue I am having is stemmed from this block.

def get_guessed_word(secret_word, letters_guessed):
    '''
    secret_word: string, the word the user is guessing
    letters_guessed: list (of letters), which letters have been guessed so far
    returns: string, comprised of letters, underscores (_), and spaces that represents
      which letters in secret_word have been guessed so far.
    '''

    correct_guess = []
    for e in secret_word:
        if e in letters_guessed:
            correct_guess.append(e)
        else:
            correct_guess.append('_ ')
    print(''.join(correct_guess))

The variable “correct_guess” is redefined at the start of this code block to prevent my output from printing multiple iterations of the same thing (the current guess, showing correct letters and -'s) which is what happens when I define this variable outside of the code block.

When I end the program and check my variable explorer there isn’t any “correct_guess” variable for me to cross reference in my hint helper function.

I think this is where I am running into issues checking my wordlist against anything.

I have tried adding another tag to it.
Examples
(my_word = correct_guess)
(my_word =
my_word + correct_guess)
Etc. With no luck so far.

If you have any advice of how to overcome this issue, I would appreciate it.

Thanks again for the link and expanding my known available resources.