Develop Reference

How to compare user inputted string to a character(single letter) of a word in a list?

I'm trying to create a hangman game with python. I know there is still a lot to complete but I'm trying to figure out the main component of the game which is how to compare the user inputted string (one letter) with the letters in one of the three randomly selected words.
import random
print("Welcome to hangman,guess the five letter word")
words =["china", "ducks", "glass"]
correct_word = (random.choice(words))
guess = input(str("Enter your guess:"))
guess_left = 10
guess_subtract = 1
if guess == "":
guess_left = guess_left - guess_subtract
print("you have" + guess_left + "guesses left")

I think you need a skeleton and then spend some time to improve the game.
import random
print "Welcome to hangman, guess the five letter word"
words = ["china", "ducks", "glass"]
correct_word = (random.choice(words))
trials = 10
for trial in range(trials):
guess = str(raw_input("Enter character: "))
if (len(guess) > 1):
print "You are not allowed to enter more than one character at time"
continue
if guess in correct_word:
print "Well done! '" + guess + "' is in the list!"
else:
print "Sorry " + guess + " does not included..."
Your next step could be print out something like c_i__ as well as the number of trials left. Have fun :)
When you finish with the implementation, take some time and re-implement it using functions.

I've completed this project yesterday; (to anyone else reading this question) take inspiration if needed.
import random
stages = ['''
+---+
| |
O |
/|\ |
/ \ |
|
=========
''', '''
+---+
| |
O |
/|\ |
/ |
|
=========
''', '''
+---+
| |
O |
/|\ |
|
|
=========
''', '''
+---+
| |
O |
/| |
|
|
=========''', '''
+---+
| |
O |
| |
|
|
=========
''', '''
+---+
| |
O |
|
|
|
=========
''', '''
+---+
| |
|
|
|
|
=========
''']
#used to choose random word
random_lst=['addition','adequate','adjacent','adjusted','advanced','advisory','advocate','affected','aircraft','alliance','although','aluminum','analysis','announce','anything','anywhere','apparent','appendix','approach','approval','argument','artistic','assembly']
chosen_word = random.choice(random_lst)
#used to create display list + guess var
print("Welcome to hangman! ")
print("--------------------")
print("you have 6 lives." )
print(" ")
print (stages[-1])
display = []
for letters in chosen_word:
display += "_"
print(display)
print(" ")
#used to check if guess is equal to letter, and replace pos in display if yes.
lives = 6
game_over = False
#use the var guesses to store guesses and print at every guess to let player know what letters they tried already.
guesses = ""
while not game_over:
guess = input("Guess a letter. ")
print(" ")
guesses += (guess + " , ")
for pos in range(len(chosen_word)):
letter = chosen_word[pos
if letter == guess:]
display[pos] = letter
print("√")
print("- - -")
print(" ")
if display.count("_") == 0:
print("Game over. ")
game_over = True
elif guess not in chosen_word:
lives -= 1
print(f"Wrong letter. {lives} lives left. ")
print("- - - - - - - - - - - - - - - - - - -")
print(" ")
if lives == 0:
print (stages[0])
elif lives == 1:
print (stages[1])
elif lives == 2:
print (stages[2])
elif lives == 3:
print(stages[3])
elif lives == 4:
print(stages[4])
elif lives == 5:
print(stages[5])
elif lives == 6:
print(stages[6])
elif lives == 0:
game_over = True
print("Game over. ")
print(f"letters chosen: {guesses}")
print(" ")
print(display)
print(" ")
if lives == 0 or display.count("_") == 0:
break
if lives == 0:
print("Game over. You lose.")
elif lives > 0:
print("Congrats, you win! ")

What you can do is treat the string like an array/list.
So if you use loops:
x = ""#let's assume this is the users input
for i in range(len(y)): #y is the string your checking against
if x == y[i]:
from here what I'm thinking is that if they are equal it would add that letter to a string
Let's say the string is "Today was fun" then would have an array like this, [""."" and so on but you'd have to find a way to factor in spaces and apostrophes. So if the letter is == to that part of the string
#this is a continuation of the code, so under if
thearray[theposition] == the letter
But looking a your code your game is diffrent from the regular one so, also consider using a while look
gamewon = False
number of trials = 10
while gamewon == False and number of trials > 0:
#the whole checking process
if x == guess:
gamewon == True
print ........# this is if your doing word for word else use
the code above
else:
number of trials = number of trials - 1
I think that's it I know its a bit all over the place but you can always ask for help and I'll explain plus I was referring to your code things i thought you could fix

First you should accept both a and A by using guess = guess.lower(). The you have to search the string for the character guessed and find the positions.
guess = guess.lower()
# Find the position(s) of the character guessed
pos = [idx for idx,ch in enumerate(correct_word) if ch == guess]
if pos:
print('Letter Found')
guess_left -= 1
Another way to understand the for-loop is:
pos = []
for idx,ch in enumerate(correct_word):
if ch == guess:
pos.append(idx)

Ascii arrays in hangman is not updating [closed]

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 7 years ago.
Improve this question
I have created a hangman game in python 3. The game is working fine. The letters are working fine. Everything is working fine. There is one thing that is bothering me. After I type the wrong word, the ascii drawing is not updating. It is still on the first drawing though the life gets reduced. It is made for five chances and after five attempts player gets killed. The drawing is not updating.
I am doing lessons from invent with python.
import random
HANGMANPICS = ['''
+---+
| |
|
|
|
|
=========''', '''
+---+
| |
O |
|
|
|
=========''', '''
+---+
| |
O |
| |
|
|
=========''', '''
+---+
| |
O |
/| |
|
|
=========''', '''
+---+
| |
O |
/|\ |
|
|
=========''', '''
+---+
| |
O |
/|\ |
/ |
|
=========''', '''
+---+
| |
O |
/|\ |
/ \ |
|
=========''']
words = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
def getRandomWord(wordList):
wordIndex = random.randint(0, len(wordList) - 1)
return wordList[wordIndex]
def displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord):
print(HANGMANPICS[len(missedLetters)])
print()
print('Missed letters:', end =' ')
for letter in missedLetters:
print(letter, end=' ')
print()
blanks = '_' * len(secretWord)
for i in range(len(secretWord)):
if secretWord[i] in correctLetters:
blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
for letter in blanks:
print(letter, end=' ')
print()
def getGuess(alreadyGuessed):
while True:
print('Guess a letter.')
guess = input()
guess = guess.lower()
if len(guess) != 1:
print('Please enter a single letter')
elif guess in alreadyGuessed:
print('You have already guessed this letter.Choose again')
elif guess not in 'abcdefghijklmnopqrstuvwxyz':
print('Please enter a letter.')
else:
return guess
def playAgain():
print('Want to play again, yes or no?')
return input().lower().startswith('y')
print('H A N G M A N')
missedLetters = ''
correctLetters = ''
secretWord = getRandomWord(words)
gameIsDone = False
while True:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
#let the player type the letter
guess = getGuess(missedLetters + correctLetters)
if guess in secretWord:
correctLetters = correctLetters + guess
foundAllLetters = True
for i in range(len(secretWord)):
if secretWord[i] not in correctLetters:
foundAllletters = False
break
if foundAllLetters:
print('Yes the secret word is' + secretWord + 'You have won')
gameIsDone = True
else:
missedletters = missedLetters + guess
#check players has guessed to many times and lost
if len(missedLetters) == len(HANGMANPICS) - 1:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
print('You have run out of guesses! \nAfter ' + str(len(missedLetters)) + ' missed guesses and ' + str(len(correctLetters)) + ' correct guesses , the word was ' + secretword + '!')
gameIsDone = True
#Ask the player if they want to play again
if gameIsDone:
if playAgain():
missedLetters = ''
correctLetters = ''
gameIsDone = False
secretWord = getRandomWord(words)
else:
break

Check your capitalization of your variables:
# You have
missedletters = missedLetters + guess
# should be
missedLetters = missedLetters + guess
^
Also:
# You have
... + ' correct guesses , the word was ' + secretword + '!')
# should be
... + ' correct guesses , the word was ' + secretWord + '!')
^
The first issue was causing your board not to update -- the second one caused it not run (for me).

Hangman game code

I would like to get some help regarding the hangman game. I've created this piece of code and have spent a lot of time trying to refine it but I still can't get the correct output. Would really appreciate your help!
word = choose_word(wordlist)
letters = 'abcdefghijklmnopqrstuvwxyz'
numLetters = len(word)
print numLetters
import re
def hangman(word, numLetters):
print 'Welcome to the game, Hangman!'
print 'I am thinking of a word that is', numLetters, 'letters long'
remainingGuesses = 8
print 'You have', remainingGuesses, 'guesses left.'
letters = 'abcdefghijklmnopqrstuvwxyz'
print 'Available letters:', letters
guess = raw_input("Please guess a letter:")
def filled_word(wordy, guessy):
emptyWord = ['_']*numLetters
if wordy.find(guessy) != -1:
position = [m.start() for m in re.finditer(guessy, wordy)]
for x in position:
emptyWord[x] = guessy
strWord = ''.join(emptyWord)
print 'Good guess =', strWord
else:
strWord = ''.join(emptyWord)
print 'Oops! That letter is not in my word:', strWord
filled_word(word, guess)
emptyWord = ['_']*numLetters
print 'emptyWord =', ['_']*numLetters
while '_' in emptyWord and remainingGuesses>0:
remainingGuesses -= 1
print 'You have', remainingGuesses, 'guesses left'
letters = 'abcdefghijklmnopqrstuvwxyz'
def unused_letters(letters):
letters = 'abcdefghijklmnopqrstuvwxyz'
unusedLetters = str(list(letters).remove(guess))
letters = unusedLetters
return unusedLetters
letters = unused_letters(letters)
print 'Available letters:', letters
guess = raw_input("Please guess a letter:")
if word.find(guess) != -1:
position = [m.start() for m in re.finditer(guess, word)]
for x in position:
emptyWord[x] = guess
strWord = ''.join(emptyWord)
print 'Good guess ='+strWord
emptyWord = list(strWord)
else:
strWord = ''.join(emptyWord)
print 'Oops! That letter is not in my word:', strWord
print hangman(word, numLetters)
print '___________'
print 'Congratulations, you won!'
So the problem is that when I run this, the code runs smoothly until from the second guess onwards, I get Available letters = None instead of the specific letters.
Also, the letter I guess which does appear in the word is not stored. i.e. in guess 1, the code returns the word (for example) 'd____', but in guess 2, upon guessing 'e', the code returns the word 'e_' instead of 'd_e__'. Is it because of the assignment of variables? Of local and global variables? Am quite confused about this.
Would really appreciate the help! Thanks a lot! :)

def choose_word():
word = 'alphabeth'
return {'word':word, 'length':len(word)}
def guess_letter(word_, hidden_word_, no_guesses_, letters_):
print '---------------------------------------'
print 'You have', no_guesses_, 'guesses left.'
print 'Available letters:', letters_
guess = raw_input("Please guess a letter:")
guess = guess.lower()
if guess in letters_:
letters_ = letters_.replace(guess, '')
if guess in word_:
progress = list(hidden_word_)
character_position = -1
for character in word_:
character_position += 1
if guess == character:
progress[character_position] = guess
hidden_word_ = ''.join(progress)
print 'Good guess =', hidden_word_
else:
print 'Oops! That letter is not in my word:', hidden_word_
no_guesses_ = no_guesses_ - 1
else:
print 'The letter "', guess, '" was already used!'
no_guesses_ = no_guesses_ - 1
if hidden_word_ == word_:
print 'Congratulations, you won!'
return True
if no_guesses_ == 0 and hidden_word_ != word_:
print 'Game over! Try again!'
return False
return guess_letter(word_, hidden_word_, no_guesses_, letters_)
def hangman():
hangman_word = choose_word()
print 'Welcome to the game, Hangman!'
print 'I am thinking of a word that is', hangman_word['length'], 'letters long.'
hidden_word = ''.join(['_'] * hangman_word['length'])
no_guesses = 8
letters = 'abcdefghijklmnopqrstuvwxyz'
guess_letter(hangman_word['word'], hidden_word, no_guesses, letters)
hangman()

There are multiple errors in the code. Here it is corrected:-
import re
def unused_letters( letters, guess ): # your main problem is corrected here.
unusedLetters = list( letters )
unusedLetters.remove( guess )
letters = ''.join( unusedLetters )
return letters
def filled_word( wordy, guessy ):
if wordy.find( guessy ) != -1:
position = [m.start() for m in re.finditer( guessy, wordy )]
for x in position:
filled_word.emptyWord[x] = guessy
strWord = ''.join( filled_word.emptyWord )
print 'Good guess.'
print 'Current word: %s' % ''.join( filled_word.emptyWord )
else:
strWord = ''.join( filled_word.emptyWord )
print 'Oops! That letter is not in my word:', strWord
def hangman( word, numLetters ): # you dont need the previous check. Let all be done in the main loop
print 'Welcome to the game, Hangman!'
print 'I am thinking of a word that is', numLetters, 'letters long'
remainingGuesses = 8
letters = 'abcdefghijklmnopqrstuvwxyz'
try:
# # memoizing the current word. for more info, try to understand that functions are
# # also objects and that we are assigning a new attribute the function object here.
filled_word.emptyWord
except:
filled_word.emptyWord = ['_'] * numLetters
while '_' in filled_word.emptyWord and remainingGuesses > 0:
print 'You have', remainingGuesses, 'guesses left'
print 'Available letters:', letters
guess = raw_input( "Please guess a letter:" )
# print 'guess: %s' % guess
if guess in letters:
filled_word( word, guess )
letters = unused_letters( letters, guess )
else:
print 'You guessed: %s, which is not in Available letters: %s' % ( guess, ''.join( letters ) )
print 'Current word: %s' % ''.join( filled_word.emptyWord )
remainingGuesses -= 1
word = "godman"
print hangman( word, numLetters = len( word ) )
if '_' in filled_word.emptyWord:
print 'Ahh ! you lost....The hangman is hung'
else:
print 'Congratulations, you won!'
You can still make it better by checking if the remaining number of guesses are less than the letters to be filled, and take a decision on whether to fail the player or allow it to continue playing.

class Hangman():
def init(self):
print "Welcome to 'Hangman', are you ready to die?"
print "(1)Yes, for I am already dead.\n(2)No, get me outta here!"
user_choice_1 = raw_input("->")
if user_choice_1 == '1':
print "Loading nooses, murderers, rapists, thiefs, lunatics..."
self.start_game()
elif user_choice_1 == '2':
print "Bye bye now..."
exit()
else:
print "I'm sorry, I'm hard of hearing, could you repeat that?"
self.__init__()
def start_game(self):
print "A crowd begins to gather, they can't wait to see some real"
print "justice. There's just one thing, you aren't a real criminal."
print "No, no. You're the wrong time, wrong place type. You may think"
print "you're dead, but it's not like that at all. Yes, yes. You've"
print "got a chance to live. All you've gotta do is guess the right"
print "words and you can live to see another day. But don't get so"
print "happy yet. If you make 6 wrong guess, YOU'RE TOAST! VAMANOS!"
self.core_game()
def core_game(self):
guesses = 0
letters_used = ""
the_word = "pizza"
progress = ["?", "?", "?", "?", "?"]
while guesses < 6:
guess = raw_input("Guess a letter ->")
if guess in the_word and not in letters_used:
print "As it turns out, your guess was RIGHT!"
letters_used += "," + guess
self.hangman_graphic(guesses)
print "Progress: " + self.progress_updater(guess, the_word, progress)
print "Letter used: " + letters_used
elif guess not in the_word and not(in letters_used):
guesses += 1
print "Things aren't looking so good, that guess was WRONG!"
print "Oh man, that crowd is getting happy, I thought you"
print "wanted to make them mad?"
letters_used += "," + guess
self.hangman_graphic(guesses)
print "Progress: " + "".join(progress)
print "Letter used: " + letters_used
else:
print "That's the wrong letter, you wanna be out here all day?"
print "Try again!"
def hangman_graphic(self, guesses):
if guesses == 0:
print "________ "
print "| | "
print "| "
print "| "
print "| "
print "| "
elif guesses == 1:
print "________ "
print "| | "
print "| 0 "
print "| "
print "| "
print "| "
elif guesses == 2:
print "________ "
print "| | "
print "| 0 "
print "| / "
print "| "
print "| "
elif guesses == 3:
print "________ "
print "| | "
print "| 0 "
print "| /| "
print "| "
print "| "
elif guesses == 4:
print "________ "
print "| | "
print "| 0 "
print "| /|\ "
print "| "
print "| "
elif guesses == 5:
print "________ "
print "| | "
print "| 0 "
print "| /|\ "
print "| / "
print "| "
else:
print "________ "
print "| | "
print "| 0 "
print "| /|\ "
print "| / \ "
print "| "
print "The noose tightens around your neck, and you feel the"
print "sudden urge to urinate."
print "GAME OVER!"
self.__init__()
def progress_updater(self, guess, the_word, progress):
i = 0
while i < len(the_word):
if guess == the_word[i]:
progress[i] = guess
i += 1
else:
i += 1
return "".join(progress)
game = Hangman()

You can take an idea from my my program. RUN IT FIRST.
import random
# Starter code start
# The variable word is a random word from the text file 'words.txt'
words = list()
with open("words.txt") as f:
for line in f:
words.append(line.lower())
word = random.choice(words).strip().upper()
# This is the starter code that chooses a word
# Starter code end
letter = ''
# This is the input of letters the user will type in over and over
word_index = 0
# This is the index for the input correct word to be checked against the correct letters
correct_letters = ''
# This is the variable for the correct letters as a list, once the user types them in and they are deemed correct
correct_letters_index = 0
# This is the index to print the correct letters from, in a while statement below. This gets reset to 0 after every time the letters are printed
incorrect_letters = ''
# This is the variable to hold the incorrect letters in.
lives = 6 # ♥
# is the variable to hold the 6 lives, printed as hearts in
win_user = 0
# This is the variable that determines if the user wins or not
guessed_letters = ''
# this variable checks for repeated letters (incorrect + correct ones)
while win_user != len(word) and lives != 0: # 1 mean yes the user have win
if lives == 6:
print(
'''
|--------------------|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|_________________________________________
'''
)
elif lives == 5:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
|
|
|
|
|
|
|
|
|_________________________________________
'''
)
elif lives == 4:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
| |
| |
| |
|
|
|
|
|
|_________________________________________
'''
)
elif lives == 3:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
| \ |
| \ |
| \|
|
|
|
|
|
|_________________________________________
'''
)
elif lives == 2:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
| \ | /
| \ | /
| \|/
|
|
|
|
|
|_________________________________________
'''
)
elif lives == 1:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
| \ | /
| \ | /
| \|/
| |
| |
| /
| /
| /
|_________________________________________
'''
)
# This is the while loop that prints only if the player has remaining lives and has not won yet; It prints the ascii drawing for the hangman with the body parts
print("Remaining lives:", end=' ')
for left_lives in range(lives):
print("♥", end=' ') # This prints the remaining lives as hearts
print()
# labels all correct letters like: cake into _ _ _ _
while word_index != (len(word)) and word_index <= (len(word) - 1):
while correct_letters_index != (len(correct_letters)) and word_index <= (len(word) - 1):
if word[word_index] != correct_letters[correct_letters_index]:
correct_letters_index += 1
elif word[word_index] == correct_letters[correct_letters_index]:
print(word[word_index], end=' ')
word_index += 1
correct_letters_index = 0
if word_index <= (len(word) - 1):
print("__", end=' ')
correct_letters_index = 0
word_index += 1
print()
# This goes through the correct word, and prints out the correct letters that have been typed in, in order
# It also types out the blank spaces for letters
if win_user != len(word):
# This asks the user for another letter, and sets the checking value on the correct word back to 0 for the next run through
letter = str(input("Enter a letter: ")).upper()
if letter in guessed_letters:
print("The letter had already been guessed: " + str(letter))
if letter not in guessed_letters:
if letter not in word:
incorrect_letters += letter
guessed_letters += incorrect_letters
lives -= 1
elif letter in word:
correct_letters += letter
guessed_letters += correct_letters
for user_word in word:
if letter in user_word:
win_user += 1
# This takes in the letter if it has not previously been deemed in a variable, either correct or not.
# It also checks if the letter is correct, or not, and adds it to the variable
# If the letter has already been typed, it will also let the user know that
word_index = 0
if lives == 0:
print(
'''
|--------------------|
| |
| **|**
| * ()() *
| ** ▼ **
| ** (---) **
| *****
| \ | /
| \ | /
| \|/
| |
| |
| / \\
| / \\
| / \\
|_________________________________________
'''
)
# This prints the full hangman, and that the user loses if their lives reach 0
print("User Looses !!")
print("Incorrect letters typed: " + str(incorrect_letters))
print("The word is: " + str(word))
elif win_user == len(word):
print("The word is: " + str(word))
# This prints the user wins if all characters are printed out for the correct word
print("Incorrect letters typed: " + str(incorrect_letters))
print("User Wins !")
print(
'''
☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺
☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺☻☺
'''
)

Hangman Game Correct Words Function

import random
HANGMANPICS = ['''
+------+
| |
| |
|
|
|
|
|
|
|
|
==============''', '''
+ +
| |
| |
O |
|
|
|
|
|
|
|
==============''', '''
+------+
| |
| |
| |
O |
| |
| |
| |
|
|
==============''']
words = 'ant baboon badger bat bear beaver beetle bird camel cat clam cobra cougar coyote crab crane crow deer dog donkey duck eagle ferret fish fox frog goat goose hawk iguana jackal koala leech lemur lion lizard llama mite monkey moose moth mouse mule newt otter owl oyster panda parrot pigeon python quail rabbit ram rat raven rhino salmon seal shark sheep skunk sloth slug snail snake spider squid stork swan tick tiger toad trout turkey turtle wasp weasel whale wolf wombat worm zebra'.split()
# This function returns a random string from the list of strings.
def getRandomWord(wordList):
wordIndex = random.randint(0, len(wordList) - 1)
return wordList[wordIndex]
def displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord):
print HANGMANPICS[len(missedLetters)]
print
print 'Missed Letters:',
for letter in missedLetters:
print letter,
print
blanks = '_' * len(secretWord)
for i in range(len(secretWord)):
if secretWord[i] in correctLetters:
blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
for letter in blanks:
print letter,
print
def getGuess(alreadyGuessed):
while True:
print 'Guess a letter.'
guess = raw_input()
guess = guess.lower()
if len(guess) != 1:
print 'Please enter a single letter.'
elif guess in alreadyGuessed:
print 'You have already guessed that letter. Choose again.'
elif guess not in 'abcdefghijklmnopqrstuvwxyz':
print 'Please enter a LETTER.'
else:
return guess
def playAgain():
print 'Do you want to play again? (yes or no)'
return raw_input().lower().startswith('y')
print 'HANGMAN'
missedLetters = ''
correctLetters = ''
secretWord = getRandomWord(words)
gameIsDone = False
while True:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
guess = getGuess(missedLetters + correctLetters)
if guess in secretWord:
correctLetters = correctLetters + guess
foundAllLetters = True
for i in range(len(secretWord)):
if secretWord[i] not in correctLetters:
foundAllLetters = False
break
if foundAllLetters:
print 'Yes! The secret word is "' + secretWord + '"! You have won!'
gameIsDone = True
else:
missedLetters = missedLetters + guess
if len(missedLetters) == len(HANGMANPICS) - 1:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
print 'You have run out of guesses!\nAfter ' + str(len(missedLetters)) + ' missed guesses and ' + str(len(correctLetters)) + ' correct guesses, the word was "' + secretWord + '"'
gameIsDone = True
if gameIsDone:
if playAgain():
missedLetters = ''
correctLetters = ''
gameIsDone = False
secretWord = getRandomWord(words)
else:
break
In the second function displayBoard, 4 parameters are passed. I understand HANGMANPICS, missedLetters and secretWord, but I don't understand where the argument for correctLetters is defined/substituted.
In layman's term (as I am a newbie), where does it say what correctLetters should do? I have been studying this game for a week now, and so far everything seems Ok, except this one.
Please help.

correctLetters is initialized in this line:
correctLetters = ''
and appended to inside the while loop that contains the bulk of the game logic:
if guess in secretWord:
correctLetters = correctLetters + guess
It is used to keep track of correctly guessed letters, and passed to displayBoard so that they can be shown on screen.
As an aside, since white space is important in Python code, it's worth formatting your question correctly.

Doing a quick keyword search for correctLetters you can see it is described as a string. In the function displayBoard you can see it used on line 78.
if secretWord[i] in correctLetters:
blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
It is being used to put in the letter instead of a blank if the user has guessed that letter.
It is described on one of the bullets here
It's usage is explained here

What part of Hangman repeats the letter [closed]

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
I have trouble here.
In the Hangman Game (Python) .
What is the part of this code that makes this:?
For example:
(The Secret Word is "door")
_ _ _ r
Guess the letter: o
_ o o r <---puts 2 times the letter "o"
Here is the code:
import random
HANGMANPICS = ['''
+---+
| |
|
|
|
|
=========''', '''
+---+
| |
O |
|
|
|
=========''', '''
+---+
| |
O |
| |
|
|
=========''', '''
+---+
| |
O |
/| |
|
|
=========''', '''
+---+
| |
O |
/|\ |
|
|
=========''', '''
+---+
| |
O |
/|\ |
/ |
|
=========''', '''
+---+
| |
O |
/|\ |
/ \ |
|
=========''']
words = 'ant baboon badger bat bear beaver camel cat clam cobra cougar coyote crow deer dog donkey duck eagle ferret fox frog goat goose hawk lion lizard llama mole monkey moose mouse mule newt otter owl panda parrot pigeon python rabbit ram rat raven rhino salmon seal shark sheep skunk sloth snake spider stork swan tiger toad trout turkey turtle weasel whale wolf wombat zebra'.split()
def getRandomWord(wordList):
# This function returns a random string from the passed list of strings.
wordIndex = random.randint(0, len(wordList) - 1)
return wordList[wordIndex]
def displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord):
print(HANGMANPICS[len(missedLetters)])
print()
print('Missed letters:', end=' ')
for letter in missedLetters:
print(letter, end=' ')
print()
blanks = '_' * len(secretWord)
for i in range(len(secretWord)): # replace blanks with correctly guessed letters
if secretWord[i] in correctLetters:
blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
for letter in blanks: # show the secret word with spaces in between each letter
print(letter, end=' ')
print()
def getGuess(alreadyGuessed):
# Returns the letter the player entered. This function makes sure the player entered a single letter, and not something else.
while True:
print('Guess a letter.')
guess = input()
guess = guess.lower()
if len(guess) != 1:
print('Please enter a single letter.')
elif guess in alreadyGuessed:
print('You have already guessed that letter. Choose again.')
elif guess not in 'abcdefghijklmnopqrstuvwxyz':
print('Please enter a LETTER.')
else:
return guess
def playAgain():
# This function returns True if the player wants to play again, otherwise it returns False.
print('Do you want to play again? (yes or no)')
return input().lower().startswith('y')
print('H A N G M A N')
missedLetters = ''
correctLetters = ''
secretWord = getRandomWord(words)
gameIsDone = False
while True:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
# Let the player type in a letter.
guess = getGuess(missedLetters + correctLetters)
if guess in secretWord:
correctLetters = correctLetters + guess
# Check if the player has won
foundAllLetters = True
for i in range(len(secretWord)):
if secretWord[i] not in correctLetters:
foundAllLetters = False
break
if foundAllLetters:
print('Yes! The secret word is "' + secretWord + '"! You have won!')
gameIsDone = True
else:
missedLetters = missedLetters + guess
# Check if player has guessed too many times and lost
if len(missedLetters) == len(HANGMANPICS) - 1:
displayBoard(HANGMANPICS, missedLetters, correctLetters, secretWord)
print('You have run out of guesses!\nAfter ' + str(len(missedLetters)) + ' missed guesses and ' + str(len(correctLetters)) + ' correct guesses, the word was "' + secretWord + '"')
gameIsDone = True
# Ask the player if they want to play again (but only if the game is done).
if gameIsDone:
if playAgain():
missedLetters = ''
correctLetters = ''
gameIsDone = False
secretWord = getRandomWord(words)
else:
break
Thank you guys :)

This part right here:
blanks = '_' * len(secretWord)
for i in range(len(secretWord)): # replace blanks with correctly guessed letters
if secretWord[i] in correctLetters:
blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
for letter in blanks: # show the secret word with spaces in between each letter
print(letter, end=' ')