Python Hangman w/ Tkinter GUI

import tkinter as tk
import random as r

#########################################################################################################################
#imports the words from cars.txt and states.txt and formats them into lists
infile1 = open("cars.txt","r")
infile2 = open("states.txt","r")

cars = infile1.readlines()
states = []
for x in range(len(cars)):
    cars[x] = cars[x].split(",")

cars = [item for sublist in cars for item in sublist]
cars = [item.strip("\n") for item in cars]

for i in infile2:
    states.append(i.strip("\n").strip(" "))

infile1.close()
infile2.close()

cars.remove('Citroën')
###########################################################################################################################
#chooses two words from the lists cars and states
def choose_words():

    r.shuffle(cars)
    r.shuffle(states)

    state = states[r.randint(0, len(states)-1)]
    car = cars[r.randint(0, len(cars)-1)]
    print(car)
    print(state)

    return car, state

#handles the press of the exit button in the windows manager to properly break program loop
def emergency_break():
    global playAgain

    app.destroy()
    playAgain=False

#main window of the program
class mainWindow(tk.Tk):

    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)

        window = tk.Frame(self)

        window.pack(side="top", fill="both", expand=True)

        window.grid_rowconfigure(0, weight=1)
        window.grid_columnconfigure(0, weight=1)

        self.frames = {}

        for F in (start, play, gameOver):

            frame = F(window, self)

            self.frames[F] = frame

            frame.grid(row=0, column=0, sticky="nsew")

        self.show_frame(start)

    #raises the frame passed to it to the front
    def show_frame(self, contr):
        frame = self.frames[contr]
        frame.tkraise()

    #closes the mainWindow and breaks program loop
    def close_mainWindow(self, again=False):
        global playAgain
        if again == False:
            self.destroy()
            playAgain = False

        else:
            self.destroy()

class start(tk.Frame):

    def __init__(self, parent, contr):
        tk.Frame.__init__(self, parent)

        askStart = tk.Label(self, text="Would you like to play Hangman?", font=("Verdana", 12))
        askStart.grid(row=0, column=0, sticky="n")

        buttonFrame = tk.Frame(self)
        buttonFrame.grid(row=1, column=0, stick="n")

        Cars = tk.Button(buttonFrame, text="Cars", font="Verdana", command=lambda: self.play_with_word(contr,*choose_words(), useCar=True))
        Cars.grid(row=1, column=0, sticky="s", padx=5, pady=10)

        Cars = tk.Button(buttonFrame, text="States", font="Verdana", command=lambda: self.play_with_word(contr,*choose_words(), useState=True))
        Cars.grid(row=1, column=1, sticky="s", padx=5, pady=10)

        cancel = tk.Button(buttonFrame, text="Cancel", font="Verdana", command=lambda: contr.close_mainWindow())
        cancel.grid(row=1, column=2, sticky="s", padx=5, pady=10)

    #sets the answerWord to either car or state based on user selection
    #these words are selected in the choose_words function
    def play_with_word(self, contr, car, state, useCar=False, useState=False):
        global answerWord

        if useCar == True:
            answerWord = car

        elif useState == True:
            answerWord = state

        play.reveal(play, start=True)
        contr.show_frame(play)

class play(tk.Frame):

    def __init__(self, parent, contr):
        tk.Frame.__init__(self, parent)
        global guess, hiddenWord

        hiddenWord = tk.StringVar()
        hiddenWord.trace("w", lambda name, index, mode, hiddenWord=hiddenWord: self.call_back_hiddenWord())
        guess = tk.StringVar()
        guess.trace("w", lambda name, index, mode, guess=guess: self.call_back_guess(guess))

        self.gameLabel = tk.Label(self, text="Hangman", font=("Verdana", 12))
        self.gameLabel.grid(row=0, column=0, sticky="n", padx=10, pady=10)

        guessFrame = tk.Frame(self)
        guessFrame.grid(row=1, column=0, sticky="nsew")

        guessBox = tk.Label(guessFrame, text="Guess a letter: ", font="Verdana")
        guessBox.grid(row=0, column=0, sticky="w")

        self.guessEntry = tk.Entry(guessFrame,textvariable=guess)
        self.guessEntry.grid(row=0, column=1, sticky="w")

        self.enterGuess = tk.Button(self, text="Guess", font="Verdana", command=lambda: self.check_guess(contr))
        self.enterGuess.grid(row=2, column=0, padx=10, pady=10, sticky="n")

        self.hiddenWordBox = tk.Entry(self, textvariable=hiddenWord, font=("Verdana",10), justify='center', width=35)
        self.hiddenWordBox.grid(row=3, column=0, sticky="n")

        self.guesses = tk.Text(self, font="Verdana", width=25, height=1)
        self.guesses.grid(row=4, column=0, sticky="n")

        gameFrame = tk.Frame(self)
        gameFrame.grid(row=5, column=0, sticky="nsew")

        self.man_images = []
        self.man_images.append(tk.PhotoImage(file='image0.gif'))
        self.man_images.append(tk.PhotoImage(file='image1.gif'))
        self.man_images.append(tk.PhotoImage(file='image2.gif'))
        self.man_images.append(tk.PhotoImage(file='image3.gif'))
        self.man_images.append(tk.PhotoImage(file='image4.gif'))
        self.man_images.append(tk.PhotoImage(file='image5.gif'))
        self.man_images.append(tk.PhotoImage(file='image6.gif'))

        self.gameDisplay = tk.Canvas(gameFrame, width=300, height=300)
        self.gameDisplay.grid(row=0, column=0, sticky="n")

        self.hangMan = self.gameDisplay.create_image(0, 0, anchor='nw', image=self.man_images[numWrong])

    #reveals the letter in hiddenWordBox widget as it corresponds to the answerWord
    def reveal(self, start=False, full=False):
        global hiddenWord, charList

        if start == True:
            for i in answerWord:
                if i == " ":
                    charList.append(" ")
                else:
                    charList.append("__")
            hiddenWord.set(" ".join(charList))

        elif full == True:
            hiddenWord.set(answerWord)

        else:
            c = guess.get()
            for i in answerWord:
                if i == c.lower():
                    charList[answerWord.index(i)] = i
                elif i == c.upper():
                    charList[answerWord.index(i)] = i
            hiddenWord.set(" ".join(charList))

    #checks to see if guessed letter is in the answerWord
    def check_guess(self, contr):
        global numWrong

        g = guess.get().lower()
        if numWrong < 6:
            if (g in answerWord.lower()) == True:
                self.reveal()
                self.guessEntry.delete(0, 'end')

            else:
                self.guesses.insert(tk.END, g + " ")
                self.guessEntry.delete(0, 'end')
                numWrong += 1
                self.gameDisplay.itemconfig(self.hangMan, image=self.man_images[numWrong])
                if numWrong == 6:
                    self.guessEntry.config(state='disabled')
                    self.gameLabel.config(text="GAME OVER!")
                    self.reveal(full=True)
                    self.enterGuess.config(text='Continue', command=lambda: contr.show_frame(gameOver))

    #def check_word(self):

    #prevents user from entering more than one letter into guessEntry widget
    def call_back_guess(self,guess):
        try:
            c = guess.get()[0]
            guess.set(c)
        except IndexError:
            pass

    #prevents user from modifying contents of hiddenWordBox
    def call_back_hiddenWord(self):
        self.reveal()

class gameOver(tk.Frame):

    def __init__(self, parent, contr):
        tk.Frame.__init__(self, parent)

        lossLabel = tk.Label(self, justify="center", text="GAME OVER!", font=("Verdana", 20))
        lossLabel.grid(row=0, column=0, sticky="n", padx=10, pady=10)

        playAgainButtonFrame = tk.Frame(self)
        playAgainButtonFrame.grid(row=1, column=0, sticky='nsew')

        acceptDefeat = tk.Button(playAgainButtonFrame, text="Quit", font="Verdana", command=lambda: contr.close_mainWindow())
        acceptDefeat.grid(row=0, column=0, sticky="n", padx=10, pady=10)

        keepPlaying = tk.Button(playAgainButtonFrame, text="Play Again", font="Verdana", command=lambda: contr.close_mainWindow(again=True))
        keepPlaying.grid(row=0, column=1, stick="n", padx=10, pady=10)


playAgain = True

while playAgain == True:
    numWrong = 0
    charList = []
    app = mainWindow()
    app.protocol('WM_DELETE_WINDOW', lambda: emergency_break())
    app.mainloop()