No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Reto final: Juego del Ahorcado o Hangman Game

20/21
Recursos

Aportes 340

Preguntas 30

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Hangman

Les comparto mi versión del juego.

<h3>Código</h3>

Link: https://github.com/JoseNoriegaa/python-cli-hangman/blob/master/main.py

<h3>Capturas del juego</h3>

Les comparto mi juego!

Código en Github

Tiene varias funcionalidades, es el mayor proyecto que he hecho hasta ahora como developer 😎.


ultimo dia de la suscripcion, ultimo curso …byeeee ,nunca paresn de aprender !!!

Me tardé dos días para programar el juego. Buscaba en internet las dudas que me surgían, pues no quería ver el código de mis compañeros. Quise hacerlo por mis propios medios y lo logré! Sé que es un código muy artesanal y probablemente tenga varias cosas por mejorar o sintetizar, pero me siento muy feliz (no soy ingeniero, soy economista con pocos meses inmiscuido en programación 😄).

Hola. Este es mi reto de Hangman Game espero les pueda servir de guía 🐍:
Link: //github.com/hackmilo/HangmanGame-JuegoAhorcado

Menú de inicio:

Hangman:

Ganador:

Perdedor:

✔ Esto les servirá para remover acentos a la hora de comparar el input con la letra:

    def normalize(s): # It removes the accents of a string
        replacements = (
            ("á", "a"),
            ("é", "e"),
            ("í", "i"),
            ("ó", "o"),
            ("ú", "u"),
        )
        for a, b in replacements:
            s = s.replace(a, b).replace(a.upper(), b.upper())
        return s

data.txt :
crema
café
estrella
explosión
guitarra
plástico
navaja
martillo
libros
lápiz
lapicera
aluminio
embarcación
letra
agujeta
ventana
librería
sonido
universidad
rueda
perro
llaves
camisa
pelo
papá
sillón
felicidad
catre
teclado
servilleta
escuela
pantalla
sol
codo
tenedor
estadística
mapa
agua
mensaje
lima
cohete
rey
edificio
césped
presidencia
hojas
parlante
colegio
granizo
pestaña
lámpara
mano
monitor
flor
música
hombre
tornillo
habitación
velero
abuela
abuelo
palo
satélite
templo
lentes
bolígrafo
plato
nube
gobierno
botella
castillo
enano
casa
libro
persona
planeta
televisor
guantes
metal
teléfono
proyector
mono
remera
muela
petróleo
percha
remate
debate
anillo
cuaderno
ruido
pared
taladro
herramienta
cartas
chocolate
anteojos
impresora
caramelos
living
luces
angustia
zapato
bomba
lluvia
ojo
corbata
periódico
diente
planta
chupetín
buzo
oficina
persiana
puerta
tío
silla
ensalada
pradera
zoológico
candidato
deporte
recipiente
diarios
fotografía
ave
hierro
refugio
pantalón
barco
carne
nieve
tecla
humedad
pistola
departamento
celular
tristeza
hipopótamo
sofá
cama
árbol
mesada
campera
discurso
auto
cinturón
rúcula
famoso
madera
lentejas
piso
maletín
reloj
diputado
cuchillo
desodorante
candado
luz
montañas
computadora
radio
moño
cuadro
calor
partido
teatro
bife
fiesta
bala
auriculares

Si lees esto, confía en tí. Tú puedes.

Llevo apróximadamente cinco días con el reto. En un día ya tenía el programa funcional, los demás días a decir verdad los fui descansando después de muchas horas de estudio a lo largo de los últimos meses. Estos días estuve haciéndole mejoras al programa y tomando en cuenta el feedback de mi familia para mejorarlo.

El reto es cómo harías tú mismo el programa con todo lo aprendido. Notarás (porque me pasó) que podías empezar por cualquier lado y que tienes ya muchas herramientas a tu disposición, pero te preguntabas cómo arrancar.

Trata de hacer el reto tu mismo. Busca en internet, foros y blogs cómo se hace lo que quieres hacer. Te sorprenderás de muchas otras cosas que ni sabías. Al final, nada más complaciente que mirar el programa como producto final funcional, que te das cuenta que ya estás a otro nivel que ayer, y que sí, tu programa puede ser mejorado, pero date cuenta que lo lograste. Posteriormente toma el feedback de los demás sobre tu código y mejoralo. El feedback también nos mejora.

Pronto les comparto mi código por github (tengo meses de no usarlo y ya olvidé varios conceptos, solo refresco mi memoria y lo subo): tiene manejo de errores, utilicé recomendaciones de Stackoverflow, además de que si te sabes la palabra, solo lo escribes y tienes la oportunidad de ganar. Si fallas, es un strike. Gracias master Facundo.

Logré el reto, este es el enlace al repositorio con los archivos del mismo Repositorio.
Para el que empieza perdido en el juego les comparto el camino que seguí para desarrollarlo, aunque las sugerencias al código son muy bien recibidas, se que tiene mucho por mejorar. Estos son los pasos:

-Leer el archivo con las palabras. (También vi que algunos lo creaban en el caso que el archivo no estuviera, me pareció buena función y lo agregue).
-Escoger una palabra del archivo aleatoriamente.
-Recibir una letra de parte del jugador.
-Crear un string o lista con el caracter “_” debe ser del tamaño de la palabra escogida.
-Las tildes generan problemas, se deben traducir en letras sin tildes.
-Encontrar las veces que la letra se encuentra en la palabra y en que posición están.
-Ubicar la letra en la posición correspondiente dentro del espacio con las rayas al piso.
-Reescribir cada vez que el usuario adivina una letra.
-Validar si ya encontró la palabra completa.
-Crear el sistema de puntos.
-Crear el banner con código ASCII, hay varias paginas para hacerlo fácilmente (solo hay que tener en cuenta que algunos caracteres se ven en windows y en linux no)

Espero a alguien le sirva de ayuda.!

Con esta herramienta pase de texto a ascii

https://patorjk.com/software/taag/#p=display&f=Graffiti&t=Type Something

espero les sirva 😄

✔ Este es mi resultado, tiene sistema de puntos, vidas, ilustraciones 4k, aprueba de tíldes, mayus., minus. y números: https://github.com/CesarHera/Intermediate_Python/blob/master/hangman.py

Espero a alguien le ayude 🛒

Buenas a todos/as en esta maravillosa comunidad:
Les dejo mi versión del Hangman Game. Una maravillosa experiencia de programación.

https://github.com/Mgobeaalcoba/python_intermedio_platzi/blob/main/juego_del_ahorcado.py

Aquí dejo mi solución al reto

import random
import os

def run():
    intentos=5
    acierto=0
    lista=[]
    final=""

    #Abriendo el archivo
    with open("./data.txt","r",encoding="utf-8")as f:
        for i in f:
            lista.append(i.rstrip("\n"))
    
    #Obtenido palabra random
    palabra=random.choice(lista)
    
    adivina =["_" for i in palabra ]
    print(""" 
        Bienvenido/a al juego del ahorcado 
        la palabra que debes adivinar es """  +"_ "*len(palabra)
        +"Tienes " +str(intentos)+" intentos")
    while(True):

        letra=input("Ingresa una letra ").lower()
        if(len(letra)>=2 or letra.isalpha==False):
            letra=""
            print(" Has ingresado un caracter inválido")
            continue

        for count, i in enumerate(palabra):
            if letra == i:
                adivina[count]=letra
                acierto+=1
        print("acertaste "+ str(acierto)+" veces la letra "+ letra)
        acierto=0
        if letra not in palabra:
            intentos -=1
            print("fallaste te restan "+ str(intentos)+ " intentos")
        
        for i in adivina:
            print(i , end=" ")
            final+=i
        if final == palabra:
            print("Has ganado, la palabra correcta es "+final)
            break
        if intentos ==0:
            print("Has perdido, mejor suerte la próxima la palabra correcta era "+ palabra)
            break
        final=""        

if __name__ == "__main__":
    run()

El resultado:

Finalmente hace uso de POO y uso de un archivo JSON para el manejo de las palabras en el uso del juego.

Repositorio:
Github

aqui esta mi codigo, intente hacerlo de la manera mas corta y sensilla posible por que en el primer intento el codigo era un desastre a mi criterio

import random
import os

def run():
    with open('./DATA.txt' , 'r' , encoding='utf-8') as data:
        lista = [i.strip() for i in data]
 
    palabra = random.choice(lista) 
    palabra_oculta_lista = ['_' for i in range( len(palabra) )  ]
    string_palabra_oculta = "".join(palabra_oculta_lista)


    while palabra  != string_palabra_oculta:

        os.system("clear")
        print(f'Juguemos ahorcado, adivina la palabra, {len(palabra)} letras')
        print(string_palabra_oculta) 
        letra = input('Presiona una tecla y despues enter    ').lower()

        iterador = 0
        for i in palabra:   
            if i == letra:
                palabra_oculta_lista[iterador] = i
            iterador += 1  

        string_palabra_oculta = "".join(palabra_oculta_lista)
          
    if palabra == string_palabra_oculta:
        os.system("clear")
        print(f'Felicidades la palabra era  {string_palabra_oculta}')


if __name__ == '__main__':
    run()

Listo, terminé el proyecto, creó que aun se puede mejorar así que probablemente lo seguiré mejorando.
Aquí dejo el link del proyecto en GitHub por si lo quieren revisar o checar los futuros avances: https://github.com/pegadro/Hangman-Game

Caso en el que se gana:

Caso en el que se pierde:

Mi solución:

""" Final Challenge: Hangman Game """

# Game class
from game import Game
import os

def main():
    game = Game()
    word = game.get_random_word()
    lengh = len(word) - 1
    found = False
    hidden_word = ['_'] * lengh
    tries = 0

    print("Welcome to Hangman Game")

    while not found:
        print(hidden_word)

        if tries >= 7:
            print("YOU LOSE!!!")
            print(hidden_word)
            print(f'The word was: {word}')
            print(f'intentos: {tries}')
            break

        user_letter = input("Enter a letter: ")
        if len(user_letter) != 1:
            os.system('clear')
            continue

        result = Game.is_correct(user_letter, word)

        if result == '_':
            os.system('clear')
            tries += 1
            continue
        else:
            for index in result:
                hidden_word[index] = user_letter

        try:
            hidden_word.index('_')
            os.system('clear')
        except ValueError:
            print("YOU WIN!!!")
            print(hidden_word)
            print(f'The word is: {word}, adivinaste en {tries} intentos')
            found = True

        print(f'intentos: {tries}')


if __name__ == '__main__':
    main()

""" Game class with methods to help play Hangman """

# random to select random word
import random

class Game:

    def __init__(self):
        """ open file with words """
        self.words = []
        with open('data.txt', mode='r', encoding='utf-8') as file:
            for word in file:
                self.words.append(word)


    def get_random_word(self):
        """ choose and return a random word """
        words_with_accents = {'á': 'a','é': 'e','í': 'i','ó': 'o','ú': 'u'}
        word = lambda words: random.choice(self.words)
        random_word = word(self.words)

        for letter in random_word:
            if letter in words_with_accents:
                new_letter = words_with_accents[letter]
                random_word = random_word.replace(letter, new_letter)

        return random_word


    @staticmethod
    def is_correct(user_letter, word):
        """ return indices where user_letter is in word """
        indices = [index for index, value in enumerate(word) if value == user_letter]

        if indices:
            return indices

        return '_'

el archivo con las palabras se llama data.txt

Hola!
En la clase del curso de python principiante donde se dio el reto de crear un videojuego, yo hice el juego del ahorcado con películas infantiles. Me costó mucho trabajo sobre todo por la lógica que quería controlar, que es llevar contador de aciertos y errores. Les dejo el código a continuación:

https://github.com/21wlvvs/PreparacionPlatzi/blob/master/CursoPython_Basico/008_JuegoAhorcado.py

Ahora, con este reto, tomé el mismo código e hice adecuaciones con respecto al nuevo aprendizaje. Sigue siendo sobre películas, pero ahora recibe un top 100 mundial con nombre en inglés. Tanto en código como en funcionalidad, considero que es mejor. Les dejo el código a continuación (explorando en GitHub, encontrarán también el archivo donde se extraen la información, para hacer funcionar el programa):

https://github.com/21wlvvs/PreparacionPlatzi/blob/master/CursoPython_Intermedio/007_JuegoAhorcado_Final.py

Me siento muy orgulloso de mi avance y de mis logros, agradezco sus comentarios 😄

Reto final:

import random
import os

HANGMAN_IMAGES = ['''

   +---+
   |   |
       |
       |
       |
       |
 =========''', '''

   +---+
   |   |
   O   |
       |
       |
       |
 =========''', '''

   +---+
   |   |
   O   |
   |   |
       |
       |
 =========''', '''

   +---+
   |   |
   O   |
  /|   |
       |
       |
 =========''', '''

   +---+
   |   |
   O   |
  /|\  |
       |
       |
 =========''', '''

   +---+
   |   |
   O   |
  /|\  |
  /    |
       |
 =========''', '''

   +---+
   |   |
   O   |
  /|\  |
  / \  |
       |
 =========''']

def cleanScreen(): 
    if os.name == "posix":
        os.system ("clear")
    elif os.name == "ce" or os.name == "nt" or os.name == "dos":
        os.system ("cls")


def getSecretWord():
    words = []
    with open('./archivos/data.txt','r',encoding='utf8') as f:
        for line in f:
            line = line.upper()
            line = line.rstrip()
            line = normalize(line)
            words.append(line)

    posicion = random.randint(0, len(words) - 1)
    secret_word = words[posicion]
    return secret_word


def normalize(s): # It removes the accents of a string
        replacements = (
            ("á", "a"),
            ("é", "e"),
            ("í", "i"),
            ("ó", "o"),
            ("ú", "u"),
        )
        for a, b in replacements:
            s = s.replace(a, b).replace(a.upper(), b.upper())
        return s    

def printHead(word_game, count_wrong):
    label_head = """ 
    ===============================  
         EL JUEGO DEL AHORCADO     
    ===============================    """    
    print(label_head)
    print(HANGMAN_IMAGES[count_wrong]) 
    print('')
    print('Adivina la palabra oculta\n')
    print(''.join(word_game))

 
def run():
    secret_word = getSecretWord()    

    loser = False
    winner = False
    word_game = ['_' for i in range(0, len(secret_word))]

    count_wrong = 0
    max_wrong = len(HANGMAN_IMAGES) - 1

    while loser == False and winner == False:        
        printHead(word_game, count_wrong)
        letter = input('\nIngresa una letra y presiona enter: ')
        letter = letter.upper()

        if letter in secret_word:
            pos = 0
            ini = 0
            fin = len(secret_word)
            while pos >= 0:                
                pos = secret_word.find(letter, ini, fin)
                if pos >= 0:
                    word_game[pos] = letter

                ini = pos + 1

        else:
            count_wrong += 1

        if count_wrong >= max_wrong:
            loser = True
            
        if secret_word == str("").join(word_game):
            winner = True 
        
        cleanScreen()


    printHead(word_game, count_wrong)

    if winner:
        print('\nGANASTE!!!')
    else:
        print('\nPERDISTE!!!')        
        print(f'La palabra oculta era {secret_word}')


if __name__ == '__main__':
    run()

¡Hola a todos!
Anexo el código del reto del curso. Realmente me costó algo de trabajo y sé que no es perfecto, pero funciona y eso me emociona a seguir adelante con este lenguaje. Cualquier feedback lo agradeceré mucho.

import random
import os
import time
      
def palabra_aleatoria():
    with open("./archivos/data.txt","r", encoding="utf-8") as f:
        my_list= []
        for i in (f):
            my_list.append(i)
        palabra_aleatoria = str(random.choice (list(my_list)))
        palabra_aleatoria= palabra_aleatoria.strip()
        palabra_aleatoria= palabra_aleatoria.upper()
    cadena= str(palabra_aleatoria)
    mapeo= {
        ord('Á'): 'A',
        ord('É'): 'E',
        ord('Í'): 'I',
        ord('Ó'): 'O',
        ord('Ú'): 'U',        
    }
    cadena= cadena.translate(mapeo)
    return cadena

def comparar(palabra, cadena):
    while palabra != cadena:
        print('Adivina la palabra de '+ str(len(palabra)) + ' letras.')
        letra= (input('Introduce una letra: ')).upper()
        assert len(letra) == 1, "Solo se puede ingresar una letra, ni + ni -"
        assert letra.isalpha(), "Solo se pueden ingresar letras"
        cadena_t= " ".join(cadena)
        os.system("clear")
        for indice, valor in enumerate (palabra):
            if valor == letra:
                cadena[indice] = letra
                cadena_t= " ".join(cadena)
                os.system("clear")
                print(cadena_t)
            else:
                os.system("clear")
                print(cadena_t)
    os.system("clear")
    print("La palabra es "+str("".join(palabra))+", así que GANASTE, muchas felicidades!")
    time.sleep(3)
    os.system("clear")
    

def run():
    palabra_random= list(palabra_aleatoria())
    os.system("clear")
    print('!Bienvenido al juego del ahorcado!')
    lineas = list(len(palabra_random)*"_")
    print(" ".join(lineas))
    print(comparar(palabra_random, lineas))
    A= """¿Otra partida?
    1.- Claro        2.- Deseo seguir mi camino 
    : """
    respuesta= int(input(A))
    assert respuesta == 1 or respuesta == 2, "Solo puedes elegir entre las dos opciones mostradas en pantalla."
    if respuesta == 1:
        run()
    else:
        print("Un placer jugar contigo, vuelve pronto !")

if __name__ == '__main__':
    run()

Así es como luce en cuanto a la interfaz:

Reto cumplido, me demoré un poco, pero lo logré:

Mi codigo es:

import random
from functools import reduce
import os, sys
import time
#import threading
#from time import time


def read():
    palabras=[]
    with open("./archivos/data.txt", "r",encoding="utf-8") as f:
        for line in f:
            palabras.append(line)
    return palabras


def azar(x):
    ran=list(normalize(random.choice(x)))
    ran.pop(len(ran)-1)
    return(ran) 


def normalize(s):
    replacements=(
        ("á", "a"),
        ("é","e"),
        ("í","i"),
        ("ó","o"),
        ("ú","u"),
    )
    for a,b in replacements:
        s=s.replace(a,b)
    return s


def dibujo(i):
    if i==0:
        print("""
         VAMOS BIEN, NO DEJES QUE ME AHORQUEN
            +---+
                !
                !
                !
                !
                !
                !
        ---------
        ---------""")
    elif i==1:
        print(""" 
        OH! OH! CUIDADO
            +---+
           /    !
                !
                !
                !
                !
                !
        ---------
        ---------
        
        """)
    elif i==2:
        print(""" 
        CONCENTRATE!!
            +---+
           /    !
          O     !
                !
                !
                !
                !                
        ---------
        ---------
        
        """)
    elif i==3:
        print("""
        NO TE EQUIVOQUES MAS POR FAVOR
            +---+
           /    !
          O     !
          |     !
                !
                !
                !
        ---------
        ---------
        
        """)
    elif i==4:
        print("""
        TENGO MIEDO
            +---+
           /    !
          O     !
         /|\    !
                !
                !
                !
        ---------
        ---------
        
        """)
    elif i==5:
        print("""
        NO ME QUIERO IR
            +---+
           /    !
          O     !
         /|\    !
         /      !
                !
                !
        ---------
        ---------
        
        """)
    elif i==6:
        print("""
        HASTA LA VISTA BABY
            +---+
           /    !
          o     !
         /|\    !
         / \    !
                !
                !
        ---------
        ---------
        
        """)
    elif i==7:
        print("""
        ESTOY VIVO

            \O/
             |
            / \ 
                
        """)
    elif i==8:
        print("""
        ADIOS
            +---+
           /    !
          o     !
         /|\    !
         / \    !
                !
                !
        ---------
        ---------
        
        """)


 
def run():
    os.system("clear")
    print("¡ADIVINA LA PALABRA!", "\n")
    word=azar(read())
    #print(word)
    #print(len(word))
    new=["_ "]*(len(word))
    print(" ".join(new),"\n")
    error=0
    while error !=6 and new !=word:
        print("RECUERDA QUE SOLO TIENES 20 SEGUNDOS POR LETRA, APÚRATE","\n")

        inicio_time=time.time()
        letra=input("Ingresa una letra: ").lower()
        try:
            if letra.isalpha()==True and len(letra)==1:
            
                index=0
                valor=[]
                
                #errror=0
                
                for i in word:
                    if i==letra:
                        new[index]=letra
                        valor.append(0)
                    else:
                        valor.append(1)         
                    index+=1
                    os.system("clear")

                
                    

                valor_multiplicado=reduce(lambda a,b: a*b,valor)
                if valor_multiplicado==1:
                    error+=1
                    os.system("clear")
                print("PRUEBA OTRA VEZ")
                dibujo(error)
                                 
                print(" ".join(new),"\n")
               

            else:
                raise ValueError("Ingrese una letra, no otros valores")
            
        except ValueError as ve:
            print(ve)

        final_time=time.time()
        total_time=final_time-inicio_time
                
        if total_time>20:            
            os.system("clear")
            dibujo(8)
            print("SE TE ACABÓ EL TIEMPO","\U0001F62D") 
            sys.exit() 
        #print(total_time)

    if new==word:
        os.system("clear")
        dibujo(7)
        print("FELICIDADES, GANASTE Y GRACIAS A TI NO ME HAN AHORCADO", "\U0001F600"),"\n"
    else:
        os.system("clear")
        dibujo(8)
        print("PERDISTE, ME AHORCARON","\U0001F62D","\n")    


if __name__== "__main__":
    run()


Aqui esta el reto final 😃

espero algun feedback
link: https://github.com/angelchoque/HangMan
![](

Este es el codigo como lo resolvi.
Seguramente tendra opciones de mejora, tales como volverlo mas modular, es decir crear mas funciones y llamados a funciones.

me parecio muy interesante el metodo join() que se aplica a las listas, ya que es como si permitiera modificar posiciones en strings, algo que cuando aun no lo habia leido me estaba rompiendo la cabeza para resolverlo.
Definnitivamente Python tiene una funcion para todo.

Tambien me parecio muy interesante el uso de una librei llamada snoop, la cual permite verificar paso a paso en concola la ejecucion del una funcion, muy util para ver todo lo que el programa esta haciendo en el background.

Gracias facmartoni por el curso.

import os
import random
# import snoop # Importo la biblioteca ncesaria para visualizar la ejecucion de lasa funciones linea a linea.
# @snoop # Funcion para visulizar la salida de una funcion en consola, cada operacion
def run():
    os.system('cls')
    words = [] # lista para recibir las palabras secretas
    print('Welcome to the Hang Man Gam3\nTry to find the secret word\n') # Presentacion inicial del juego
    with open('./archivos/data.txt', 'r', encoding='utf-8') as f: # Apertura del archivo de texto en modo de solo lectura
        for line in f: # Se va a leer cada linea x separado para poder eliminar los saltos de linea y espacios
            words.append(line.strip()) # Se agrega cada linea sin espacios o saltos de linea a la lista words[]
    secret = random.sample(words, k=1) # Se escoge solo una palabra secreta dentro del listao de palabras disponible
    secret = secret[0] # Se castea la plabra de una lista a un string, ya que se requiere solamente la palabra
    changes = secret.maketrans('áéíóúAEIOU', 'aeiouaeiou') # Se realiza la devolucion del string sin mayusculas o tildes, 
    # print(changes) #  Lo use para visualizar la salida del metodo maketrans, el cual es un objeto que sirve para hacer una transformacion del texto 
    secret = secret.translate(changes) # Realiza el cambio en el string secret segun la transformacion realizada con el metodo maketrans()
    # secret = enumerate(secret) # Enumerate() devuelve el indice y el valor en un objeto iterable
    # secret = dict(secret) # creo un diccionario con el indice y el valor de la palabra secreta
    pos = ['_'for i in range(len(secret))] # Lista para recoger las posiciones iguales entre la palabra digitada por el usuario y la palabra secreta
    lifes = len(secret)
    # print(secret)
    aciertos = 0
    while lifes > 0 and aciertos < len(secret):
        print('Remain Lifes are ', lifes)
        word = input('Stroke an letter and press Enter: ')
        word = word.translate(changes) #Le quito las mayusculas o tildes a la plabra digitada por el usuario
        os.system('cls')

        for key in range(len(secret)): #recorro la palabra secreta para verificar si la letra introducida por el usuario esta en la palabra.
            if secret[key] == word:
                pos[key] = word #Si la letra esta en la palabra la alimento en la posicion en la que esta.
                aciertos = aciertos + 1 #Se cuenta el numero de palabras correctas para compararlas
                # print(aciertos) # Impresion de control
            if aciertos == len(secret): # Se comprueba si ya estan todas las letras adivinadas, en caso de ser asi, se imprime "You Win y termina el programa
                print("You Win\n")
                break #Se utiliza para que salga del ciclo for, y no se imprima varias veces mas el texto You Win
        print(''.join(pos)) # Se imprime la lista pos, que es mi palabra adivinada con el metodo join que lo une usando el separador '' es decir queda todo el texto unido
        # print(secret)
        lifes -= 1  # Contador de Vidas para el juego, cada vez que se ejecuta y llega aqui se ha acabado una vida.

    print('La palabra secreta es', secret)

if __name__ == '__main__':
    run()

Aqui esta mi proyecto de este curso. He usado webscraping para mi propia base de datos. Y además aproveché los generadores (yield) para poder leer de mejor manera los archivos .txt con los dibujos que he echo.
https://github.com/Pepool17/Hangman-Game

Hola, comparto mi versión del juego por [GitHub]
(https://github.com/pomarrc/hangman_game)
Se hizo uso de:

  • List comprehensions.

  • La función enumerate().

  • Manejo de errores: try, raise, except.

Hola, les dejo mi aporte. Este es mi código, aprecio cualquier observación que tengan. Le puse un contador con corazones estilo Zelda jajaja y atrapé los posibles errores de introducir números o más de una letra. Repositorio

import os
import random

os.system("clear")

def choice_word():
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        words = [i.replace('\n', '') for i in f]
        return random.choice(words)


def run():
    guess = choice_word().lower()
    guess = guess.replace('á', 'a')
    guess = guess.replace('é', 'e')
    guess = guess.replace('í', 'i')
    guess = guess.replace('ó', 'o')
    guess = guess.replace('ú', 'u')

    intentos = ['♥' for i in range(0, 10)  ]
    secret_word = ["-" for i in range(0, len(guess))]

    while(len(intentos) > 0):
        word_added = False
        try:
            print('_____________________')
            print(" ".join(intentos))    
            print("¡Adivina la palabra!\n")
            print(" ".join(secret_word))
            letter = input("\nIntroduce una letra: ").lower()
            os.system("clear")
            if letter.isnumeric() or len(letter) != 1:
                raise ValueError
            for index, letter_guess in enumerate(guess):
                if letter == letter_guess:
                    secret_word[index] = letter
                    word_added = True
            if word_added == False:
                    intentos.pop()
            if "".join(secret_word) == guess:
                print('\n_____________________')
                print(" ".join(intentos))
                print("\n" + "  ".join(secret_word))
                print('\nLo lograste')
                break
        except ValueError:
            if letter.isnumeric():    
                print("No hay números en esta palabra")
                intentos.pop()
            elif len(letter) >= 1:
                print("Debes ingresar una letra a la vez")
                intentos.pop()
            elif len(letter) == 0:
                print("Debes ingresar al menos una letra ")
                intentos.pop()
    if len(intentos) == 0:
        print('\n_____________________')
        print(" ".join(intentos))
        print("Se acabaron los intentos, la palabra correcta era:\n \n" + " ".join(guess))

if __name__ == "__main__":
    run()

He aqui mi version del reto:

import os
import time
import random
from hangman_pics import HANGMANPICS as hg


def get_word_language():
    """Decides the language of the words to guess"""
    print("""
          First choose the language of the words""")

    while True:
        lang = input("English(n) or Espanol(s)(n/s) or (0/1): ").lower()
        if lang == 'n' or len(lang) < 0 or lang == '0':
            print(f"You chose English.")
            return lang
        elif lang == 's':
            print(f"Elegiste Espanol.")
            return lang
        else:
            print("You should try with a valid option.")


def hangman_pic(pics, tries):
    """Shows the ascii art of the hangman"""
    print(f"Your tries: {tries}")
    print("#"*30)
    print(pics[tries])
    print("#"*30)


def data(lang):
    """Gets the words for the database"""
    words = []

    if lang == 'n':
        with open('./words.txt', 'r')as f:
            for line in f:
                words.append(line)

        word = random.choice(words)
        return word.strip()

    else:

        with open('./palabras.txt', 'r', encoding='utf-8') as f:
            for line in f:
                words.append(line)

        word = random.choice(words) 
        return word.strip()


def hangman():
    """The logic of the game"""
    lang = get_word_language()
    word = data(lang)
    try:
        hidden_word = ['-' for i in range(len(word))]
        tries = 0
        wrong_letters = set()
        right_letters = set()

        while tries <= 7:
            #if lost the game
            if tries == 6:
                os.system('clear')
                hangman_pic(hg, tries)
                print("-"*30)
                print(f"You lost, The word is {word}")
                print("-"*30)
                play = input("Do you want to play again?.(y/n)")
                if play == 'y':
                    hangman()
                    break
                else:
                    break
            time.sleep(2)
            os.system('clear')
            hangman_pic(hg, tries)
            print(hidden_word)

            current_letter = input("guess a letter: ").lower()

            #get the index if the letter is right
            letter_box = []
            for idx in range(len(word)):
                if word[idx] == current_letter:
                    letter_box.append(idx)

            #if the letter it's not in the word
            if len(letter_box) == 0:
                tries += 1
                if current_letter in wrong_letters:
                    print("-"*30)
                    print(f"Used letters\n[{''.join(wrong_letters)}]")
                    print(f"Used letters\n[{''.join(right_letters)}]")
                    print(f"'{current_letter}' already guessed.")
                    print("-"*30)

                else:
                    print("-"*30)
                    print(f"your letter is not in the word.")
                    print("-"*30)
                    wrong_letters.add(current_letter)
            else:
                right_letters.add(current_letter)
                if current_letter in hidden_word:
                    tries += 1
                    print("")
                    print("you already used that letter".upper())
                    print("You lost an point")
                    print("")
                    continue

                for idx in letter_box:
                    hidden_word[idx] = current_letter

                #prove if the word is already guessed
                try:
                    hidden_word.index('-')
                except ValueError as ve:
                    #print(ve)
                    print("*"*30)
                    print("You have won. the word is ", word )
                    print("*"*30)
                    break

    except KeyboardInterrupt as ki:
        print("\nYou stopped the program.")


def run():
    print("""
          WELCOME TO HANGMAN GAME""")

    hangman()
    print("""
          THAT'S IT, SEE YOU LATER""")


if __name__ == '__main__':
    run()

Base mi solucion en otro curso dode hacen este ejercicio.
que les parece?

Así quedó mi juego



Mi código quedó así 😄

import random
import os
import sys
import pyfiglet
import time
import random
import string

def clear():
    if os.name == "posix":
        os.system ("clear")
    else:
        os.system ("cls")

def read_archivo():
    with open("./ahorcado/ahorcado.txt", "r", encoding="utf-8") as f:
        palabras=[palabra.replace("\n", "") for palabra in f]
    return palabras

def quitar_acentos(palabras):
    letras={
        "á" : "a",
        "é" : "e",
        "í" : "i",
        "ó" : "o",
        "ú" : "u"
    }
    
    new_words=[]
    for palabra in palabras:
        for letra in letras:
            if letra in palabra:
                palabra=palabra.replace(letra, letras.get(letra))
        new_words.append(palabra)
    
    #convertimos a mayúsculas
    for i in range(len(new_words)):
        new_words[i]=new_words[i].upper()
    #print(new_words)
    return new_words

def victoria(word):
    clear()
    print(pyfiglet.figlet_format("You Win", font="doh"))
    print("la palabra era:", word)
    time.sleep(2)
    sys.exit()

def perder(word):
    clear()
    print(pyfiglet.figlet_format("You Lose", font="doh"))
    print("La palabra era:", word)
    time.sleep(2)

def juego(word, all_letters, list_word):
    vidas=7
    print(pyfiglet.figlet_format("HangMan", font="doh"))
    print("No presiones nada aún")
    time.sleep(2)

    incognita=["_" for i in range(len(word))]
    
    while vidas>0:
        clear()
        print("vidas disponibles:", vidas,"\n")
        print("\t", end="")
        for i in incognita:
            print(i, end="")
        print("\n")
        try:
            letra=input("Ingrese la letra: ")
            if letra=="":
                raise ValueError("Tienes que ingresar una letra")
            elif letra in all_letters:
                letra=letra.upper()
                if letra in word:
                    for i in range(len(word)):
                        if letra==word[i]:
                            incognita[i]=letra
                    if list_word==incognita:
                        victoria(word)
                else:
                    vidas-=1
            else:
                raise ValueError("Tienes que ingresar una letra")
        except ValueError as ve:
            print(ve)
            time.sleep(1)
    perder(word)

def run():
    palabras=read_archivo()
    new_words=quitar_acentos(palabras)
    numero=random.randint(0, len(new_words)-1)
    
    word=new_words[numero]
    all_letters=string.ascii_letters+"ñ"+"Ñ"
    list_word=list(word)

    juego(word, all_letters, list_word)


if __name__=="__main__":
    run()```

Sencillo pero es trabajo honesto:

## JUEGO DEL AHORCADO

import os
import random
import time

TITLE = " ..:::: AHORCADO ::::.."
HANGMANPICS = ['''
  +---+
      |
      |
      |
      |
      |
=========''',
'''
  +---+
  |   |
      |
      |
      |
      |
=========''',
'''
  +---+
  |   |
  O   |
      |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
  |   |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|   |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========''']

LIFES = 7
lifes = LIFES

def select_word():
    with open("./data.txt", "r", encoding="utf-8") as f: 
        list = [line for line in f]
        dic = {list.index(word): word for word in list}
        last_index = list.index(list[-1])
        random_index = random.randrange(0, last_index)
        word = dic.get(random_index)
        return word[0:-1]


def init(word):
    os.system("cls")
    size = len(word)
    box = []
    for i in range(0, size):
        box.insert(i, "_") 
    print(TITLE)
    print("\n" + HANGMANPICS[LIFES-lifes])
    print("\n" + " ".join(box))
    return box


def check_input(guess, word):
    char = input("\nIngresa una letra (Chances = " + str(lifes) + "): ")
    while True:
        try:
            if char.isalpha() and len(char) == 1:
                return char
                break
            else:
                raise Exception
        except Exception:
            char = input("Error: Ingresa solo una letra: ")


def search(char, word, box):
    global lifes
    if word.count(char) > 0:
        for index, item in enumerate(box):
            if char == word[index]:
                box[index] = char    
    else:
        print("Fallaste!")
        time.sleep(1)
        lifes = lifes - 1
    return box


def refresh(box):
    os.system("cls")
    print(TITLE)
    print("\n" + HANGMANPICS[LIFES-lifes])
    print("\n" + " ".join(box))
    array = "".join(box)
    return array


def run():
    word = select_word()
    box = init(word)
    guess = ""

    while guess != word and lifes > 0:
            char = check_input(guess, word)
            box = search(char, word, box)
            guess = refresh(box)
    
    if lifes > 0:
        print("\nAdivinaste la palabra ", word.upper())
    else:
        print("\nAhorcado!!")
        print("La palabra correcta es ", word.upper())



if __name__ == '__main__':
    run()

Para el que no lo haya logrado hacer, aquí el profesor lo resuelve, en un reto que hubo en un live: https://www.youtube.com/watch?v=G2q6PUUDdRw&t=40s

Me tomo 2 dias, hay muchas cosas que podria mejorarse pero esto es lo que logre armar leyendo un poco de documentacion.

import random
import os
import sys

def get_word(num):
    with open("./files/DATA.txt", "r") as sw:
        for i, value in enumerate(sw):
            if i == num:
                return value


def display_screen(word):
    empty = []
    for i in word:
        empty.append("_")
    return empty


def run():
    energy = 5   

    secret_word = get_word(random.randint(0, 170))
    secret_word = secret_word.upper()
    secret_array = list(secret_word)
    secret_array.pop(len(secret_array) - 1) # Removing '\n'

    empty = display_screen(secret_array)

    os.system("clear")
    
    while empty != secret_array:
        if energy == 0:
            print("You lose")
            sys.exit()
        
        print("Welcome to Hangman Game [type EXIT to quit] \tEnergy: " + str(energy))
        # print(secret_array)
        print(empty)

        empty_aux = empty.copy()

        letter = input("type a letter: ").upper()
        if letter == "EXIT":
            sys.exit()
        
        # check_letter(letter, secret_array, empty)
        for i, value in enumerate(secret_array):
            if value == letter:
                empty[i] = letter

        if empty_aux == empty:
            energy = energy - 1
        
        os.system("clear")


if __name__ == '__main__':
    run()

no hice el hangman, mas bien se me ocurrio hacer un arrow man ajajjajaj en donde en lugar de ahorcarse hice que se le clave una flecha en la cabeza…pero en si tiene la misma logica, la grafica cambia pero es lo mismo…

Me paso lo siguiente:

  • Al leer el archivo txt, me mostraba palabras con secuencias de escape asi “sofia\n”, lo cual hice un replace para eliminarlo.

  • Tambien habian palabras con acentos, en este caso elimine acentos con lo siguiente:

      text = unicodedata.normalize('NFD', line.replace("\n", ""))
      text = text.encode('ascii', 'ignore')
      text = text.decode("utf-8")    

Link al codigo fuente

                                 Juego del ahorcado 

Aquí les comparto mi versión del juego y también el repositorio, intentare ir mejorándolo con el tiempo 😄
https://github.com/ZaktorG/Juego-del-Ahorcado


Me demoré más de lo que pensé (sólidos 4 días) pero al final quedó bastante bien 😁 Dejo el código por aquí, espero que a alguien le sirva.
PD: lo hice con pokemon, porque si

Hangman pokemon

import random
import os
import banners


def get_random_pokemon():
    with open('./files/pokemon.txt', 'r', encoding='utf-8')as f:
        pokemon = [line.upper().rstrip() for line in f]
        POKEMON = list(random.choice(pokemon))
        secret_pokemon = ['_' for letter in POKEMON]
    return POKEMON, secret_pokemon

def clear_and_print(POKEMON, secret_pokemon, attemps):
    os.system('clear')
    print(banners.HANGMANPICS[attemps])
    #print(' '.join(POKEMON))
    print(' '.join(secret_pokemon))


def game(POKEMON, secret_pokemon, attemps):
    while True:
        letter = input('Guess a letter to find the pokemon 👉').upper()
        assert len(letter) == 1 and letter.isalpha(), 'You only can type a letter'
        if letter in POKEMON:
            for i, value in enumerate(POKEMON):
                if letter == value:
                    secret_pokemon[i] = letter
        else:
            attemps = attemps + 1
        clear_and_print(POKEMON, secret_pokemon, attemps)
        if secret_pokemon == POKEMON:
            print(banners.WON)
            print('The pokemon was ' + str(' '.join(secret_pokemon)))
            break
        if attemps == 6:
            print(banners.LOSE)
            print('The pokemon was ' + str(' '.join(POKEMON)))
            break

def run():
    print(banners.hello_banner)
    input('Press any button to start to play 💥 Or press ctrl + C to exit')
    POKEMON, secret_pokemon = get_random_pokemon() #Firts step -> Read, choice and create a list with the pokemon
    attemps = 0 # User has only 6 attemps, count start in 0
    clear_and_print(POKEMON, secret_pokemon, attemps) # Second step -> clear the console and print the void list
    game(POKEMON, secret_pokemon, attemps)
        
        
if __name__ == '__main__':
    run()

Aquí coloco mi codigo, muchas gracias por el curso

import random
import re
import unidecode
import os

RE_IS_VALID_CHAR = re.compile(r'(?i)[a-z]') # This RE selects all a-z

def read_words_file () -> list:
    '''
    Read the file with name data.txt with words in every new line and return a list of all words in the file.
    '''
    with open('data.txt', mode='r', encoding='utf-8') as words_file:
        words = [word.rstrip () for word in words_file]
        return words

def pick_a_random_word () -> str:
    '''
    Picks a random word from the file containing the list of words
    '''
    words = read_words_file ()
    words_file_size = len (words)
    index_of_random_word = random.randint (0,words_file_size - 1)
    random_selected_word = words [index_of_random_word]
    return random_selected_word

def valid_char (letter: str) -> bool:
    '''
    Return true if letter is on range [a-z] without checking Caps and including accents.
    Be careful because this function only works when a letter is passed as an argument.
    '''
    is_valid_char = False if RE_IS_VALID_CHAR.match(letter) != None else True
    return is_valid_char

def is_same_letter (letter_1:str, letter_2:str)-> bool:
    return letter_1 == letter_2
    
def check_letter_in_word (word: str, letter: str) -> list:
    '''
    Check if char is in word, if word contains char, returns a list of the indices inside the word where the char appears, if the list is empty, the char is not in word
    '''
    return [idx for idx, char in enumerate(word) if char == letter]
    
def user_letter () -> str:
    selected_letter = input ("Pick a letter: ")
    selected_letter = unidecode.unidecode(selected_letter)
    if len (selected_letter) != 1:
        raise ValueError ("A single letter is expected")
    if valid_char (selected_letter):
        raise ValueError ("Invalid character")
    return selected_letter

def game_not_ended (palabra_a_adivinar, solución_jugador, lifes):
    return palabra_a_adivinar != solución_jugador and lifes > 0

def main():
    try:
        word = pick_a_random_word ()
        formated_word = unidecode.unidecode(word)
        formated_word = formated_word.lower()
        user_solution = '_' * len (word)
        lifes = 10
        while game_not_ended(word, user_solution, lifes):
            try:
                selected_letter = user_letter()
                selected_letter = unidecode.unidecode(selected_letter).lower()
            except ValueError as e:
                print (e)
                continue
            
            os.system("clear")
            attempt = check_letter_in_word (formated_word, selected_letter)
            if len(attempt) == 0:
                lifes = lifes - 1
                print ("Wrong guess!")

            for idx in attempt:
                user_solution = user_solution[:idx] + word[idx] + user_solution[idx + 1:]
            print (user_solution)
            print ("You have: {0} lifes left.".format(lifes))
        
        if lifes == 0:
            print ("You lost :(")
        else:
            print ("You won the game! c:")

    except FileNotFoundError:
        print ("File data.txt not found")
    except KeyboardInterrupt:
        print ("\nExiting the game! Goodbye!")

if __name__ == '__main__':
    main ()    

Siento que voy a usar muchisimos for i, me confirman?

Hangman en python
Keep it simple

import random
import os


def getData(filepath):
    words = []
    with open (filepath, "r", encoding="utf-8") as f:
        for line in f:
            words.append(line.strip().upper())
    return words


def run():
    data = getData(filepath="./files/data.txt")
    word = random.choice(data)
    word_list = [letter for letter in word]
    word_set = set(word_list)
    hits = []
    while(True):
        os.system("clear")
        print("ADIVINA LA PALABRA")

        #printing the current state of word
        for letter in word_list:
            #print (letter)
            if letter in hits:
                print(letter + " ", end="")
            else:
                print("- ", end="")
        print()
        #Inputing the shot
        shot = input("Ingresa una letra: ").strip().upper()
        assert shot.isalpha(), "Solo puedes ingresar letras"

        if shot in word_list and shot not in hits:
            hits.append(shot)

        #Ending the game winning or "." character
        if len(hits) == len(word_set):
            print("GANASTE!!")
            break
        

if __name__ == '__main__':
    run()

Yo no me siento capacitado para a hacer esto.
Ser’ia mejor tener gu’ia del profe par air resolviendo dudas, e ir mirando procesos, tener una versión del profesor par auno comparar, no sólo las de lso cmpañeros , porque hay varias personas que tienen ya mucho nivel y vinien al curso a repasar, u otros por el certificado, y desde luego comparten muchas cosas que podrían ser interesantantes, pero que al estar más allá dle nivel de uno, como principiante, son puro white noise. Además sonfrustrantes. Por eso la importancia de ver qué seríamos capaces de a hacer con la información dada, luego si en otro momento, empezar a crecer el desafío. Yo empecé muy contento, y vehía todo como muy coherente, pero este curso , el intermedio, no lo he disfrutado, todo el tiempo me siento perdido, no he sentido d edonde vengo ni para donde voy, es importante desplegar desde el principio los logros, los aprendizaje que se esperan obtener en el curso, y que el profe proceda a desarrollar lso desafíos en la clase siguiente, así sea de forma rápida, ya mencioné por qué no siempre la información d elso compañeros es vien aprovechada por los proncipiantes, la mayoría de la información ese código se nos escapa.
Voy a emepzar de cero de nuevo, este curso,a ver si sí soy capáz de realizar esta tarea.
Ojalña los nuevos cursos sean mejor.

AQUÍ LES DEJO MI VERSIÓN!
LA HIZE CON MUCHO AMOR ^^
CUALQUIER CRÍTICA CONSTRUCTIVA ES BIENVENIDA 😄
https://github.com/PROGRAMAMAN/HANGMAN

Hola! Así es como se ve el mío.
Les comparto el link directo al repositorio en Github. Al momento de comentar esto, es la primera versión, aunque lo iré mejorando para optimizar el código:
https://github.com/miguelhernandezk/the_hangman/






import random
from os import system

# En la función read se realiza la lectura del archivo y cada palabra se almacena en la lista
def read():
    lista = []
    with open("palabras.txt", "r",encoding="utf-8") as f:
        for x in f:
            for word in x.split(): # Utilizo el metodo .split() para que no considere los enters (\n)
                lista.append(word)
    
    seleccion = random.randint(0,len(lista)-1) # Hago uso del metodo random para que escoja un palabra aleatoria
    return lista[seleccion]

def game():
    palabra = read() # Aca almacenamos la palabra
    palabra = list(palabra) # La palabra se convierte en lista
    guiones = ["-" for i in palabra] # segun la longitud de la palabra almacenamos una cantidad de guiones
    
    while (''.join(palabra)!=''.join(guiones)):  # Mientras palabra != guiones
        print(''.join(guiones))
        letra = input("Escriba una letra: ")
        letra = letra.upper()
        guiones = [letra if x == letra else y for (x,y) in zip(palabra,guiones)] 
        # Para un x que recorre la lista "palabra" y un y que recorre la lista "guiones".
        # Si x es igual a la letra digitada, entonces se reemplaza en la lista "guiones".
        # Caso contrario se almacena el elemento de la lista "guiones" en la misma lista.
        
        system("cls")

    print("Felicidades el personaje era: ",''.join(palabra))
    
if __name__ == "__main__":
    game()

Hola todos comparto mi código. Espero sus observaciones
https://github.com/estebanpuma/hangman_game.git

Reto terminado!
Comparto mi [Repositorio]
(https://github.com/jramireztabares87/Python/tree/main/Proyectos)


les dejo mi aporte del juego del ahorcado
https://github.com/Sabbrakaddabra/hangman

Aquiles comparto mi código y les sirva , espero que les guste , acepto comentarios.
Link: https://github.com/Yoltic2/hang-man

Les comparto esta pagina donde pueden generar los texto con código ASCII :

https://www.topster.es/texto-ascii/small.html

AQUÍ EL RETO


Lo hice sumamente sencillo e intenté hacer el código muy legible.

Para ejecutarlo debes primero ejecutar en tu consola pip install unidecode es un módulo que usé para quitar las tildes de la lista de palabras.

PD: En la función verify_letter() retorno una lista con las posiciones donde hizo match la letra que ingresó el usuario con la palabra oculta, el tema es que ese trozo lo puedes hacer también con la función enumerate() que dijo el profesor, Aquí mas info.

Mi código:

import os
import random
from unidecode import unidecode


def random_word() -> str:
    with open('./data.txt', 'r', encoding ='utf-8') as f:
        words = [word[:-1] for word in f]
        random_word = random.choice(words)
    return unidecode(random_word)


def verify_letter(letter, word) -> list:
    letter_list = [i for i in word]
    lenght = len(letter_list)
    coincidences = []
    for i in range(lenght):
        if letter == letter_list[i]:
            coincidences.append(i)  #Add the letters position
    return coincidences


def prompt():
    word = random_word()
    underscores = ['_' for i in range(len(word))]
    while True:
        try:
            print('\n\n' + ' '.join(underscores) + '\n')
            letter = input('Type a letter: ').lower()
            if letter.isnumeric():
                raise ValueError ('Numbers are not allowed')
            if len(letter) > 1:
                raise ValueError ('**Only accepts a single letter**')
        except ValueError as ve:
            print(ve)
            continue

        coincidences = verify_letter(letter, word)
        if len(coincidences) > 0:
            for i in coincidences:
                underscores[i] = letter
            os.system("clear")
        else:
            os.system("clear")
            print('Noup, try with another')

        if '_' not in underscores:
            print(f'Congratulations! You have completed the word {word}')
            break


def run():
    prompt()


if __name__ == '__main__':
    run()

Pues aqui esta mi codigo tiene fallas y use cosas que no porque no sabia que existia la condicion “If” …“in”… entonces hice que las letras se buscaran en un diccionario formado por la palabra, logre que pudiera diferenciar entre numeros y letras pero la falla es que si ingresas la misma letra muchas veces te lo toma como correcto y terminas ganando el juego sin que en realidad adivines la palabra completa. Voy a intentar corregirlo otro dia y tratar de acerlo mas corto con “if” “in”

import random
from functools import reduce
import os

data = []
palabra = {}
acierto = []
longitud = []

def read():
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        for line in f:
            line = line.replace("\n", "")
            data.append(line)


def crea_palabra():
    x = random.choice(data)
    acentos ={"á":"a", "é":"e", "í":"i", "ó":"o", "ú":"u"}
    for key in acentos:
        if key in x:
            x =x.replace(key, acentos[key])
    # print(x)
    for n, letter in enumerate(x, start=1):
        palabra[n] = letter
        longitud.append(n)
    # print(palabra)
    z = "_ "
    for i in range(1,len(x)+1):
        acierto.append(z)


def adivinador():
    valor_palabra = reduce(lambda a,b: a+b, longitud)
    while valor_palabra > 0:
        print("Juego del Ahorcado\n")
        print("Adivina la palabra\n")
        print(acierto)
        print("\n")
        letra = input("Ingresa una letra: ")
        if letra.isnumeric() == False:
            for key in palabra:
                if palabra[key] == letra:
                    acierto[key-1] = letra
                    valor_palabra= valor_palabra-key
            os.system("cls")
            print("\n")
        else:
            print("Debes ingresar una letra")
        


def run():
    read()
    crea_palabra()
    adivinador()
    print("Juego del Ahorcado\n")
    print("Adivina la palabra\n")
    print(acierto)
    print("\n")
    print("Ganaste")
    
    


if __name__=="__main__":
    run()

Hangman

Me demore una semanita, pero aca lo hice.

Me fui un paso más allá y use la GUI de Tkinter para hacer el juego, además de incluirle lo recomendado de puntaje, incluí un sistema para poder crear y cambiar las listas de palabras en archivos .json.

Link a el Repo en GitHub

Hola Comunidad, comparto mi aporte, disponible en github:
link: https://github.com/estebangaviria/handman_game

Reto y no es un código limpio pero tiene varios ejemplos comentados del porque…

from os import system
# libreria para manejar el titulo y dar formato al texto
import pyfiglet
'''
autor: @jose_mateo_2010

'''
draw = ['''
  +---+
  |   |
      |
      |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
      |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
  |   |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|   |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========''', '''
  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========''']


# funcion que lee un archivo y devuelve una palabra con la libreria random (1)
def archivo():
    with open("./archivos/data.txt", "r", encoding='utf-8') as f:
        lista = [line1 for line1 in f if line1.strip()]
    from random import choice
    palabra = choice(lista)
    return palabra


# Funcion que muestra el juego (2)
def proceso(titulo, palabra, palabra2, cont, caja, especial):
    while True:
        system("cls")
        print(titulo)
        print("---------------")
        print(palabra)
        print("---------------")
        print(draw[cont])
        print(len(palabra)*"**")
        # utilizo join para unir la lista en un string
        print(" ".join(palabra2))
        print()
        print(len(palabra)*"**")

        # manejo de errores
        try:
            letter = input("Ingrese una letra: ")

            for l, v in enumerate(palabra):
                # compara la letra ingresada con la letra de la palabra
                if letter == v:
                    palabra2[l] = letter
                # si la letra se encuentra en el diccionario especial y letra ingresada es igual a la letra del diccionario
                # se reemplaza la letra ingresada por la letra del diccionario
                if v in especial and letter == especial.get(v):
                    palabra2[l] = v

            # si la palabra2 es igual a palabra, se cumple la condicion de ganar
            if "".join(palabra2) == palabra:
                system("cls")
                print(draw[cont])
                ganar = pyfiglet.figlet_format("GANASTE...")
                print(ganar)
                print("---------------")
                print("Ganaste 😄😄 !!!")
                print("Palabra: "+" ".join(palabra2))
                print("---------------")
                break

            # si la letra ingresada no se encuentra en la palabra o está em la caja de letras ya ingresadas
            if letter not in palabra or letter in caja or letter == "":
                cont += 1
                if cont == 6:
                    system("cls")
                    print(draw[cont])
                    perdiste = pyfiglet.figlet_format("PERDISTE...")
                    print(perdiste)
                    print("--------------------")
                    print("Perdiste  😱😱 !!!")
                    print("Palabra: "+palabra)
                    print("--------------------")
                    break
            caja.add(letter)

            # con assert creo el error si letter no es una letra
            assert letter.isalpha(), ":: Error ingrese una letra"

        # aviso del error
        except AssertionError as e:
            system("cls")
            print(titulo)
            print("---------------")
            print(palabra)
            print("---------------")
            print(draw[cont])
            print("---------------------------")
            print(e)
            print("---------------------------")
            input("Presione enter para continuar...")


# funcion que prepara el arranque del juego (3)
def hangman():
    # para quitar los espacios en blanco a principio y final del string
    palabra = archivo().strip()
    # doy como separación un espacio en blanco despues del guión bajo para que la lista no sea de un solo elemento
    palabra2 = (len(palabra) * "_ ")
    # convierto a plabra2 en una lista para poder modificarla por medio de indices
    palabra2 = palabra2.split()
    cont = 0
    caja = set()
    # utilizo el diccionario para manejar las letras con tilde
    especial = {"á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u"}
    titulo = pyfiglet.figlet_format("HANGMAN")

    proceso(titulo, palabra, palabra2, cont, caja, especial)


# funcion principal
def run():
    hangman()


if __name__ == '__main__':
    run()

RETO CUMPLIDO

Reto del juego del ahorcado:

Enlace en GitHub: JosePerez

El juego tiene:

  • 3 vidas
  • posibilidad de tomar otras particas.
  • Inpide la inserción de valores nulos y/o numero.

Les muestro mi versión del juego:

Link: https://github.com/jorgesalinas07/Hangman_game
Algunas imagenes:



Cualquier comentario es bien recibido 😃

#aqui esta
import random
import os

def read():
words = []
with open("./archivo/data.txt", “r”, encoding=“utf-8”) as f:
for line in f:

        words.append(line.strip())
rangopalabra = random.randrange(len(words))
secret_word = words[rangopalabra]
return secret_word

def jugar(palabra_rand):
lista_en = ["_" for x in range(len(palabra_rand))]

for j in range(len(palabra_rand)+4):
    os.system("cls")
    print("ADIVINA LA PALABRA ")
    lista_en2="".join(lista_en) 
    print(lista_en2)
    letra_uno=input("escribe una letra ")
    for i in range(len(palabra_rand)):                                    
        if letra_uno == palabra_rand[i]:
            lista_en[i]=letra_uno                    
return lista_en

def resultado(last_chanse,result_jugar):
if last_chanse == result_jugar:
print(“ganaste”)
else:
print(“perdiste”)

def run():
try:
secret_word1 = read()
new_sentence = secret_word1.maketrans(‘áéíóú’, ‘aeiou’)
secret_word2 = secret_word1.translate(new_sentence)
sizewordran=len(secret_word2)
print(sizewordran*"_")
join_words="".join(jugar(secret_word2))
print(join_words)
os.system(“cls”)
print(secret_word2)
resultado(secret_word2,join_words)

except ValueError:
    print("solo debes ingresar letras")

if name == “main”:
run()

Hangman Game

Les comparto mi versi►2n.

Link Github en caso deseen: https://github.com/FernandoCallasaca/Hangman-game

Captura en caso ganes el juego:

Captura en caso pierdas el juego:

import random
import os

def read_data():
with open("./archivos/data.txt", “r”, encoding=“utf-8”) as f:
datos = [line.strip() for line in f] #El strip es para eliminar el /n que aparece después de cada palara

dicc = {key:value for key, value in enumerate(datos)} #Emnumera los datos
return dicc

def tilde(s):
replacements = ((“á”,“a”),(“é”,“e”),(“í”,“i”),(“ó”,“o”),(“ú”,“u”),)
for a, b in replacements:
s = s.replace(a, b).replace(a, b) #reemplaza las tildes
return s

def run():
os.system(“cls”) #para limpiar la pantalla de inmediato
try:
dicc = read_data() #llama la lista de palabras emnumerados en un diccionario
#randint(inicio,fin), el inicio es 1, y el fin es medido por LEN de la otra función
#random elije de forma aleatoria, get lo toma, y dic_datos lo lleva a palabra, tilde le quita la tilde
palabra_adivinar = tilde(dicc.get(random.randint(1,len(dicc)+1)))
mayus = palabra_adivinar.upper() #lleva a mayúscula la palabra
guiones = len(mayus)*"_" #genera --------------------
print("Adivina la palabra: ")

    while mayus != guiones: #mientras que el número de letras no se complete
        print(guiones)  #comienza con la -----------------
        letra = tilde(input("Ingresa una letra: "))  #ingresa usuario, y se pasa sin tilde
        usuario = letra.upper() #convierte en mayúscula
        if usuario in mayus:  #para comenzar la comparación de la palabra y las letras ingresadas
            guiones = list (guiones) #convierte en lista los guiones
            for i, x in enumerate(mayus): #ennumera las letras de la palabra a adivinar
                if x == usuario:
                #este es el buble que va recorrer el sistema. X va tomar tomar los valores de las letras, 
                #junto a i, es decir, para la palabra CAMA, i=0 x=C, i=1 x=A, .....
                #cundo la letra ingresada sea igual a la letra de la palabra, esta va reemplazar al guión
                    guiones[i] = x
            guiones = "".join(guiones)
        os.system("cls")
    print(f"¡Ganaste! tu palabra era {guiones}")

except ValueError:
    print("Solo debes ingresar letras")

if name== ‘main’:
run()

Ya vi algunos codigos y tengo que admitir que no estoy al nivel, con 15 horas de trabajo este fue mi resultado:

import os
import random

def obtain_word():
    
    with open('./data.txt', 'r', encoding="utf-8") as f:
        palabras = [line.strip("\n") for line in f]  
    
    palabras = list(enumerate(palabras))            
    palabras_dict = dict(palabras)                                                                        
    n = random.randrange(0, 170)
    return(palabras_dict.get(n))
      



def run():
    word = obtain_word()                                                                       
    word_list = list(word)
    letters = []
    letter = ""
    answer = []
    answer = ["_" for i in range(len(word_list))]
    
    while True:
        os.system('cls') 
    
        if letter in word_list:
            letters.append(letter)
    
            for j in range(len(letters)):
    
                for i in range(len(word_list)):
    
                    if letters[j] in word_list[i]:
                        answer[i] = letters[j] 
            
        print('guess the word!')
        print('\n')

        for i in range(len(answer)):
    
            print(answer[i], end =" ")
    
        if answer == word_list:
    
            os.system('cls') 
            os.system('cls')
            print('Ganaste la palabra era: ' + word)
            break
        
        print("\n")
    
        while True:
    
            try:
                letter = input('Input a letter: ')
    
                if len(letter)>1:
    
                    raise ValueError("please enter only one letter")
    
                else:
    
                    break
    
            except ValueError as ve:
    
                print(ve)
        


if __name__=="__main__":
    run()
    
    print('Fin del juego, bien hecho')

Mi código:

import os
import random
from functools import reduce

def normalize(s): #función para eliminar tildes
    replacements = (
        ("á", "a"),
        ("é", "e"),
        ("í", "i"),
        ("ó", "o"),
        ("ú", "u"),
    )
    for a, b in replacements:
        s = s.replace(a, b).replace(a.upper(), b.upper())
    return s

def numbers_and_characters(clave):
    compare_condition=True
    list_numbers_and_characters=["1","2","3","4","5","6","7","8","9","0",".",",","-","(",")","[","]","*","/","+","<",">","'","?","¡","¿","!","#","$","%","&","=","{","}"]
    for compare in list_numbers_and_characters:
        if compare==clave:
            compare_condition=False
            break
    return compare_condition


def first_read(): #Eligiendo una palabra random de la lista
    total_number=0
    words=[]   
    with open("./archivos/juego.txt", "r",encoding="utf-8") as f:
        for list_words in f: # el total de palabras en el archivo
            total_number=total_number+1
            words.append(list_words)        
        random_number=random.randint(0,total_number) #eligiendo un número random
        random_word=words[random_number] #encontrando la palabra random
        new_word=normalize(random_word) #funcion para eliminar tildes
        new_word=new_word.lower() #colocando todas las letras en minusculo
        
        each_word=[] #convirtiendo la palabra en una lista letra por letra
        for number_letters in range(0,len(new_word)-1): 
            each_word.append(new_word[number_letters])
        return each_word


def first_space_print(first_word_and_space): # primera vez que se imprime los espacios en el juego
    space_words="            "
    for first_number_letters in range(0,len(first_word_and_space)): 
            space_words=space_words + " _ "
    return space_words

def guess_words_again(random_word_list,guess_word,clave): #Creando una lista con las palabras correctas + espacios 
    
    guess_word2=[]
    accountant=0
    for words in random_word_list:
        if words==clave:
            guess_word2.append(words)
            accountant=accountant+1
        else:
            guess_word2.append(guess_word[accountant])
            accountant=accountant+1
    return guess_word2

def spaces_and_words(guess_word): #Imprimiendo los espacios y las palabras correctas
    space_words="            "
    for word in guess_word:
        if word==",":
            space_words=space_words + " _ "
        else:
            space_words=space_words + " " + word + " "
    return space_words


def run():
    
    random_word_list=first_read() #Lista de la palabra random
    random_word=reduce(lambda a, b: a + b, random_word_list) #uniendo la lista de la palabra random
    
    guess_word=["," for i in random_word_list] #creando una lista vacia con el mismo numero de elementos de la lista random

    clave=""
    step=1
    end_game=False
    
    while end_game==False:
        os.system ("cls")
        print("""
        *****************************************************
        *****************************************************
                B   I   E   N   V   E   N   I   D   O
        *****************************************************
        *****************************************************
            J   U   E   G   O       D   E   L

                        A   H   O   R   C   A   D   O
        *****************************************************
        *****************************************************
                ┌──────────┐
                │          │
                │          ▀
                │         ┌│┐ 
                │         │││
                │          │
                │         │ │
                │         │ │
                │
                ┴        
        """)
        
        if step==1:
            print(first_space_print(random_word))
            print("\n")
        elif step==2:
            guess_word=guess_words_again(random_word_list,guess_word,clave)
            print(spaces_and_words(guess_word))
            print("\n")
        elif step==3:
            print(spaces_and_words(guess_word))
            print("\n")
            print("ADVERTENCIA : Por favor escriba una letra")
            print("\n")
        elif step==4:
            print(spaces_and_words(guess_word))
            print("\n")
            print("ADVERTENCIA : Por favor escriba una letra no un Número o Caracter")
            print("\n")

        if random_word_list==guess_word:
            end_game=True
        else:
            clave=input("escribe una letra: ")
            if len(clave)==0 or len(clave)>1:
                step=3
            else:
                if numbers_and_characters(clave):
                    step=2
                else:
                    step=4

            clave=normalize(clave)
            clave=clave.lower()

    print("Terminaste el juego")
        

if __name__=="__main__":
    run()

Hola a todos! Pongo el código del reto.
Añadí ASCII art en el título del juego y un sistema para llevar estadísticas de los intentos, de las letras que se van encontrando y al final nos dice el porcentaje de efectividad. Claro que puede mejorarse más, pero el script es funcional. Saludos!

import os
import random

template = """
**  **    ***    **   **  *******   **      **    ***    **   **  
**  **   ** **   ***  **  **        ***    ***   ** **   ***  **  
******   *****   **** **  **  ***   ****  ****   *****   **** **  
**  **  **   **  ** ****  **   **   ** **** **  **   **  ** ****  
**  **  **   **  **  ***  *******   **  **  **  **   **  **  ***  
        ||===================
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        ||                            
        [email protected]          ======== 
        ||                         || 
        ||                         || 
        ||                         || 
        """



def clear():
    os.system('clear')


def read_data(filepath="./archivos/data.txt"):
    words = []
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            words.append(line.strip().upper())
    return words


def run():
    data = read_data( filepath="./archivos/data.txt")
    chosen_word = random.choice(data)
    chosen_word_list = [letter for letter in chosen_word]
    chosen_word_list_underscores = ["_"] * len(chosen_word)
    letter_index_dict = {}
    attempts = int(0)
    found = int(0)
    for idx, letter in enumerate(chosen_word):
        if not letter_index_dict.get(letter):
            letter_index_dict[letter] = []
        letter_index_dict[letter].append(idx)

    while True:
        clear()
        print(template)
        print("Adivina la palabra!")
        for element in chosen_word_list_underscores:
            print(element + " ", end="")
        print("\n")
        print("Intentos:    ", attempts)
        print("Encontradas: ", found)
        letter = input("Ingresa una letra: ").strip().upper()
        attempts = attempts + 1
        print("letter: ", letter)
        assert letter.isalpha(), "Solo puedes ingresar letras"
        # print("data: ", data)
        print("chosen_word: ", chosen_word)
        print("chosen_word_list: ", chosen_word_list)
        print("chosen_word_list_underscores: ", chosen_word_list_underscores)
        print("letter_index_dict: ", letter_index_dict)
        print("attempt: ", found)
        if letter in chosen_word_list:
            print("La letra está en la palabra")
            for idx in letter_index_dict[letter]:
                print("idx: ", idx)
                chosen_word_list_underscores[idx] = letter
                found = found + 1
            print(chosen_word_list_underscores)
        if "_" not in chosen_word_list_underscores:
            print("Ganaste! La palabra era: ", chosen_word)
            result = len(chosen_word)/attempts*100
            print("Porcentaje de efectividad: ", result, " %")
            break


if __name__ == "__main__":
    run()

Hangman con vidas

import os
import random


def read_words():
    words = []
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        words = [line.strip('\n') for line in f]
    return words


def transform_word(word):
    vowels_dict = {
        'á': 'a',
        'é': 'e',
        'í': 'i',
        'ó': 'o',
        'ú': 'u'
    }
    for key, value in vowels_dict.items():
        word = str(word).replace(key, value)
    return word.upper()


def run():
    try:
        words = read_words()
        word_guess = transform_word(random.choice(words))
        guessed = "-" * len(word_guess)
        lineas = "-" * len(word_guess)
        LIFES = 5

        while guessed != word_guess:
            os.system("cls")
            print("Bienvenido al Juego del Ahorcado - Hangman Game")
            print("¡Adivina la palabra!")
            print("Vidas:", LIFES)
            print(guessed)

            if LIFES == 0:
                break

            letra = input("Ingresa una letra: ").upper()
            if letra.isnumeric():
                raise ValueError("Debe ingresar únicamente letras")

            if letra in word_guess:
                lineas = list(lineas)
                for index, element in enumerate(word_guess):
                    if letra == element:
                        lineas[index] = letra
                guessed = ''.join(lineas)
                print(guessed)
            else:
                print(guessed)
                LIFES -= 1
                continue
            
        if LIFES != 0:
            os.system("cls")
            print("¡Ganaste! La palabra era", word_guess)
        else:
            os.system("cls")
            print("¡Game Over! Inténtalo de nuevo")
    except ValueError as ve:
        print(ve)


if __name__=='__main__':
    run() 

Hola amigos, comparto mi versión del juago.

https://github.com/srjulianf/Ahorcado/blob/main/ProyectoFinalAhorcado.py

Rgds,

jULIAN

  • Despues de varios intentos por fin termine.
import random
import os 
import re


def random_word():
    words = []
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        words = list(map(str.rstrip, f))
    return random.choice(words)


def run():
    secret_word = random_word()
    n_word = secret_word.maketrans("áéíóú", "aeiou")
    new_word = secret_word.translate(n_word)
    word_new = [new for new in new_word]
    slices = len(new_word) * ["_"]
    attemps = 0
    while True:
        for character in slices:
            print(character, end=" ")
        print(" adivina la palabra !")
        print("Tienes 10 intentos. ")
        found = False
        try:
            letter_usr = input("Escribe una letra: ").lower()
            assert letter_usr.isalpha(), "Solo se pueden usar letras 😁"
            found = False
            for idx, character in enumerate(word_new):
                if character == letter_usr:
                    slices[idx] = letter_usr
                    found = True
            if not found:
                attemps += 1
            if attemps == 7:
                print("""
              _______   
             |       |
             O       |
            /|\      |
            / \      |
              _______|""")
                print("La respuesta era:", new_word)
                break 
            if "_" not in slices:
                # os.system("clear")
                print("Felicidades ganaste ")
                print("La palabra era: ", new_word )
                break
        except ValueError:
            print("Debes ingresar una letra ")


        if attemps == 0:
            os.system("clear")
            print("""
        _______   
       |       |
               |
               |
               |
        _______|""")
        elif attemps == 1:
            os.system("clear")
            print("""
        _______   
       |       |
       O       |
               |
               |
        _______|""")
        elif attemps == 2:
            os.system("clear")
            print("""
        _______   
       |       |
       O       |
       |       |
               |
        _______|""")
        elif attemps == 3:
            os.system("clear")
            print("""
        _______   
       |       |
       O       | 
      /|       |
               |
        _______|""")
        elif attemps == 4:
            os.system("clear")
            print("""
        _______   
       |       |
       O       |
      /|\      |
               |
        _______|""")
        elif attemps == 5:
            os.system("clear")
            print("""
        _______   
       |       |
       O       |
      /|\      |
      /        |
        _______|""")
        elif attemps == 6:
            os.system("clear")
            print("""
        _______   
       |       |
       O       |
      /|\      |
      / \      |
        _______|""")


if __name__ == "__main__":
    run()

Si ves esto no te rindas, tu puedes resolverlo 😃

Comparto mi repositorio con el código: https://github.com/jesuszelayac/hangmangame

Acá mi reto completado, por si les sirve e guía:
https://github.com/marcos122696/Ahorcado/tree/master

Les comparto mi versión del juego, intenté usar pocos métodos y aplicar la logica necesaria para obtenerlo, es el primer commit https://github.com/GeoPyCanicro/PythonIntermedio/blob/master/hangman.py

Hola amigos,
.

Fue todo una experiencia 😃 cunplir el reto
Lo hice en en Google Colab.
.
https://colab.research.google.com/drive/1Ccg1vQMQaFjoBlZGZ4uVbpsOxGxhVsn8#scrollTo=ed9l5vDPZB8z

.
Dejo el programa utilizado en el reto. Aunque sale movido.

import random
import art
from IPython.display import clear_output
from art import tprint
import emoji

### Dibujo del ahorcado
ERROR = ["  +---+\n  |   |\n      |\n      |\n      |\n      |\n=========", 
        "  +---+\n  |   |\n  O   |\n      |\n      |\n      |\n=========",
        "  +---+\n  |   |\n  O   |\n  |   |\n      |\n      |\n=========",
        "  +---+\n  |   |\n  O   |\n /|   |\n      |\n      |\n=========", 
        "  +---+\n  |   |\n  O   |\n /|\  |\n      |\n      |\n=========",
        "  +---+\n  |   |\n  O   |\n /|\  |\n /    |\n      |\n=========",
        "  +---+\n  |   |\n  O   |\n /|\  |\n / \  |\n      |\n========="]


### Función de impresión en pantalla
def message(word_to_show):

    print('''
##########################################################################
########################                                                                 #######################
########################  Welcome to The Hangman Game     #######################
########################                                                                  #######################
##########################################################################

Adivina la palabra oculta

Cada vez que te equivoques estarás más cerca de ser colgado\n\n''',
word_to_show,'\n\n ')


### Función de selección aleatoria de palabra
def choice_word():
  lines=[]
  with open('data.txt', 'r', encoding='utf-8') as f:
    lines = [line for line in f]
  word = random.choice(lines)
  word = word[:-1]
  return word

### Función de ingreso de letra y control de erroes de ingreso
def ask_letter(to_show, num_err):

  letter_in = input('Ingresa la letra que creas que contenga: ')
  incorrect_in = True

  while incorrect_in == True:
    try:
      if len(letter_in)==0:
        raise ValueError('\n<<<<< Error: Ingresaste vacio '+emoji.emojize(":zipper-mouth_face:")+' >>>>>\n')
      if len(letter_in)>1:
        raise ValueError('\n<<<<< Error: Ingresaste más de una letra '+emoji.emojize(":zipper-mouth_face:")+' >>>>>\n')
      if letter_in.isnumeric():
        raise ValueError('\n<<<<< Error: Ingresaste un número '+emoji.emojize(":zipper-mouth_face:")+' >>>>>\n')
    except ValueError as ve:
      print(ve)
      letter_in = input('Ingresa la letra que creas que contenga: ')
      clear_output()
      message(to_show)
      print(ERROR[num_err])
    else:
      incorrect_in = False
  return letter_in

### Función que define la palabra a mostrar
def wordToShow(word_choiced, letter_entered, posicion, word_showed):
    w=''
    if not posicion:
      w = word_showed

    else: 
      w = [w+letter if  index in posicion else w+'_' for (index, letter) in enumerate(word_choiced)]
      w=' '.join([str(i) for i in w])
    return w

### Función que define las posiciones de coincidencia de la letra ingrada y la palabra
def match(word_choiced, letter_entered, pos_ant):
  match=[]
  match = [index for (index, letter) in enumerate(word_choiced) if letter_entered in letter]

  for i in match:
    if not i in pos_ant:
      pos_ant.append(i)
  return pos_ant, match

### Función principal
def run():
  ## Selección aleatoria de palabras
  word_choiced = choice_word()
  
  ## Primer mensaje en pantalla
  word_to_show = '_ '*len(word_choiced)
  message(word_to_show) 

  ## Definición de parámetros
  posicion=[]
  word_to_comp=' '.join([str(i) for i in word_choiced])
  num_error=0
  while num_error < 7:
    ## Comprueba si ya se completó las palabras 
    if word_to_show == word_to_comp:
      break  
    ## Preguntar por una letra
    letter_entered = ask_letter(word_to_show, num_error)
    ## Posición de los matchs de la letra ingresada con la palabra
    posicion, matched = match(word_choiced, letter_entered, posicion)
    ## Si la letra es correcta
    if matched:
      ## Definir la palabra a mostrar     
      word_to_show = wordToShow(word_choiced, letter_entered, posicion, word_to_show)
      ## Limpiar pantalla
      clear_output()
      ## Mostrar en pantalla
      message(word_to_show)
      if num_error>0:
        print(ERROR[num_error])
    ## Si la letra no es correcta
    else:
      clear_output()
      message(word_to_show)
      print(ERROR[num_error], '\n'+'''
                   <<<<<< Te equivocaste  \U0001F608 >>>>>>>                  
                                                                              
      ''', )
      num_error += 1
  ## Mensaje final si completó la palabra
  if num_error<6:
    clear_output()
    tprint('Ganaste',"rnd-xlarge")
    print('La palabra era: ', word_choiced)      
  ## Mensaje final si no completó la palabra
  else:
    clear_output()
    tprint('Perdiste',"rnd-xlarge")
    print('La palabra era: ', word_choiced)    

if __name__ == '__main__':
  run()

tarde varias horas pero al final pude hacerlo solo 😃.


from random import randint
import os



def getletters():
    data = []
    letters_diccionary = {}
    ##  Get the list of the reandom words
    with open("./carpetaejemplo/data.txt", "r", encoding="utf-8") as f:
        data = [line for line in f]

    ##Getting  the random word and all the letters of that word
    word_goals = randint(0,len(data))
    word_goals = data[word_goals]
    word_goals = word_goals[:len(word_goals)-1:]
    print(word_goals)
    newword_goal = word_goals.maketrans("áéíóú", "aeiou")
    n_word = word_goals.translate(newword_goal)
    #input("hoal " + n_word)
    i= 0
    for letter in n_word:
        letters_diccionary[i]= n_word[i]
        i=i+1  
    return letters_diccionary


def empty_spaces1(nloop):
    
    with open("./carpetaejemplo/hangman_game.txt", "w", encoding="utf-8") as f:
        i = 0
        for i in range(0,20):
            spaces[i] = ""
        for i in range(0,nloop):
            spaces[i] = "_"
        for svalues in spaces.values():
            f.write(svalues)
        return spaces
    



def run():
 
    #We get the random word and the each letter of that word
    letters = getletters()
    print(letters[0])
    print(len(letters))

    #In this function we making the "__" we need for our word
    spaces3 = []
 
    for letra in letters:
        spaces3.append("_")
    # spaces3 = "".join(spaces3)
    # print("**"+str(spaces3))

    #Start the ViewMenu

    ganador = False
    try_number = 15
    
    while ganador == False:
        os.system("clear")
        print("\n\n***********************************************************")
        print("🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮🎮")
        print("🐍🐍BIENVENIDO A TU JUEGO HANGMAN DESARROYADO EN PYTHON🐍🐍")
        print("🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️🕹️")
        print("***********************************************************")
        print("""                                                          

        
                +-----------+
                |           |
                |           |
                            |
                            |
                            |
                            |
                            |
                            |
                            |
                =========================
--------------------------------------------------------
        
        """)
        print("El numero de intentos sobrantes es de: " + str(try_number))
        print("\n\nLa palabra tiene la siguiente cantidad de letras.")        
        print(spaces3)
        posible_try = input("\nIngresa la palabra con la que quieres intentar: ")


        for i in range(0,len(letters)):
            
            if posible_try != letters[i]:
                
                continue
            elif posible_try == letters[i]:
                spaces3[i] = posible_try
                      
        
        try_number= try_number -1


        if try_number < 1:
            os.system("clear")          
            print("\n\n\n"+str(spaces3))
            print("\n\n-------------------------------------------")
            print("😞😞 LO SENTIMOS PERDISTE EL JUEGO 😞😞")
            print("-----------------------------------------------\n\n\n\n")
            print("La palabra era " + str(letters.values()))
            exit()

        if "_" in spaces3:
            continue
        else:
            ganador = True





    os.system("clear")          
    print("\n\n\n"+str(spaces3))
    print("\n\n✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨")
    print("😎😎 FELICIDADES GANASTE EL JUEGO 😎😎")
    print("✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨\n\n\n\n")

if __name__ == "__main__":
    spaces = {}
    run()

Les dejo mi solución, sé que es muy básica, que no he utilizado funciones, assert, try, except, etc de todo lo que hemos visto, pero voy a seguir mejorándola. Empecé muy perdido y esto para mi es un gran avance.

import random
def run():

diccionario = [] 
with open("./archivos/datos.txt", encoding="utf-8") as fname:
    for lineas in fname:
        diccionario.extend(lineas.split())

palabra = random.choice(diccionario).lower()
tablero = ["_"] * len(palabra)
# print(palabra)
# print(tablero)
vidas = 5 

print("Vamos a Jugar al Ahorcado, ")
print("Adivinar letra por letra una palabra")

while vidas>0:
    fallas = 0 
    for letra in palabra:
        if letra in tablero:
            print(letra, end=" ")
        else:
            print("_", end=" ")
            fallas = fallas + 1

    if fallas == 0:
            print("Felicidades, ganaste")
            break 

    tuletra = input("por favor ingrese una letra    ")
    tablero += tuletra

    if tuletra not in palabra:
        vidas = vidas - 1
        print("Equivocación")
        print("Tienes ", +vidas, "vidas")
    if vidas == 0:
        print("perdiste")
else:
    print("Gracias por participar")

if name == “main”:
run()

teto cumplido

Comparto el juego, junto a algunas anotaciones de las clases de este curso.

Todavía debo mejorar el juego pero por ahora funciona, de la misma forma cualquier aporte es bienvenido.

Repo aquí

Esta fue mi manera de hacerlo. Aunque me tomó bastante tiempo, no logré hacer mi propio juego del ahorcado y me vi en la necesidad de buscar un código ajeno, pese a eso me gustó intentarlo y convertir el código que encontré en uno útil para mi.

import random
import os


def random_words():
    words = []
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        [words.append(word.strip("\n")) for word in f]
            
    return words
                        
def user_view(random_word):
    
    count = 5
    hangman = "".join(random_word).upper()
    word_try = "".upper()

    while count > 0:
        os.system("cls")
        print("Can you guess the word?")
        attempts = 0

        for letter in hangman:
            if letter in word_try:
                print(letter, end=" ")
            else:
                print("_", end=" ")
                attempts += 1
        if attempts == 0:
            print("\nGratz, you won.")
            break        

        user_letter = input("\nEnter a letter, pls: ").upper()
        assert user_letter.isalpha(), "Solo puedes ingresar letras"
        word_try += user_letter

        if user_letter not in hangman:
            count -= 1
        if count == 0:
            print(f"Game over.\nThe word is {hangman}")
    
        
   
def run():
    os.system("cls")
    random_word = random.choice(random_words())
    user_view(random_word)
    

if __name__ == '__main__':
    run()

Está solución que deje en Github al reto del ahorcado incluye como mejora:

  • Un sistema de vidas.
  • Uso de 2 archivos txt en vez de 1.
  • Muchos comentarios para entender mejor el uso que cumple cada método y variable.

(PD: El repositorio está público por si algún compañero lo quiere usar como guía) ✌️🤝

Pequeño aporte para el que este teniendo problemas. Yo pase por lo mismo y no supe como hacerlo así que pues revise con amigos y a la final lo resolví gracias a “Enumerate”. Muy buen curso y actividad que me tomo algo asi como 15 horas pero estoy bastante satisfecho de lo que hice.

comparto mi codigo de mi propia version del programa, al incio fue un poco dificil porque no sabia como comenzar, pero poco a poco entre pruebas y aplicando conocimientos paso a paso logre culimar el reto!!!

import random
import os

os.system("clear")

def palabra_aleatoria():
    with open("./DATA.txt", "r", encoding="utf-8") as f:
        list=[i.strip() for i in f]
        return random.choice(list)

def run():
    
    palabra = palabra_aleatoria().lower()
    palabra = palabra.replace('á', 'a')
    palabra = palabra.replace('é', 'e')
    palabra = palabra.replace('í', 'i')
    palabra = palabra.replace('ó', 'o')
    palabra = palabra.replace('ú', 'u')

    palabra_secreta=["_" for i in range(len(palabra))]
    intentos = 0        

    while " ".join(palabra_secreta)  != " ".join(palabra):
        print("*"*166)
        print("-"*25, "ADIVINA LA PALABRA CORRECTA","-"*25)
        # print(palabra)
        print("\n")
        print(" "*15, "palabra escondida:"," ".join(palabra_secreta))
        print("\n")  
        print("""
           ******  *       *    *****  ******* *******    *
           *         *   *        *       *    *     *    *
           ***         *          *       *    *     *    *
           *         *   *        *       *    *     *
           ******  *       *    *****     *    *******    *
      
         """)
        print("Numero de intentos para ganar:   ", intentos) 
        letra=input("ingrese una letra:   ").lower()     
        os.system("clear")            
        
        for contador, letra2 in enumerate(palabra):
            
            if letra == letra2:
                palabra_secreta[contador] = letra2
        intentos += 1        

        
    if " ".join(palabra_secreta)  == " ".join(palabra):

        os.system("clear")
        print("*"*166)
        print("ganaste!!!!----"*50)
        print("*"*23,"LO LOGRASTE EN :  ", intentos, "INTENTOS","*"*23) 
        print("""
           ******  *       *    *****  ******* *******    *
           *         *   *        *       *    *     *    *
           ***         *          *       *    *     *    *
           *         *   *        *       *    *     *
           ******  *       *    *****     *    *******    *
      
      """)
        print("*"*166)
        print("-"*25, "HECHO POR WALTER RODRIGUEZ","-"*25)


import os
import random
def run():
    #para abrir el archivo que tiene todas la palabras y agregar las palabras a una lista

    with open("./archivos/data.txt", "r", encoding="utf-8") as f:
        palabras = [line.replace("\n", "") for line in f]
    
    #para que salgan las palabras aleatoriamente
    random.shuffle(palabras)
    #inicio del juego
    #elige una palabra del documento
    for palabra in palabras:
        #usuario -> palabra que se va creando por lo que inicia el usuario
        usuario = ""

        #El juego iniciará con 15 vidas
        vidas = 15

        #palabra_usuario -> para crear  los _ _ _ _ con base en el largo de la palabra a adivinar
        palabra_usuario = ["_" for letra in range(1, len(palabra)+1)]

        #para eliminar las tildes de la palabra y el usuario no tenga que colocar las vocales con tilde
        tildes = palabra.maketrans('áéíóú', 'aeiou')
        sin_tilde_palabra = palabra.translate(tildes)

        #crear la palabra en lista para poder iterarla más adelante
        palabra_lista = list(sin_tilde_palabra)

        #mientras la palabra del usuario no sea igual a la palabra a adivinar se ejecuta este ciclo while
        while sin_tilde_palabra != usuario:

            #para poder jugar el usuario debe tener más de 0 vidas
            if vidas > 0:

                #imprime en pantalla -> le solicitara al usuario una letra
                print("\nAdivina la palabra! \n")
                print("Tienes "+ str(vidas)+" vidas \n")
                print(" ".join(palabra_usuario))
                letra = input("\ningresa una letra:")

                #depende la letra que ingrese el usuario empezará con este ciclo for a reemplazar los "_ " con la letra que ingreso el usuario para que en el siguiente ciclo se muestre lo del usuario con base en las letras que hace match.
                indice = -1 #el ciclo siempre inicia en -1 porque el primero en revisar será el indice 0
                for caracter in palabra_lista:
                    #este ciclo reemplaza la letra en el mismo index que la palabra que se intenta adivinar
                    indice +=1
                    if letra == caracter:
                        palabra_usuario[indice]=letra
                #crea la nueva palabra que hasta el momento a creado el usuario ej_: _ _a _
                usuario = "".join(palabra_usuario)

                #para limpiar la pantalla 
                os.system("cls")

                #se va ajustando las vidas en cada ciclo
                vidas -= 1

                #si el usuario adivina la palabra si aún no ha perdido todas las vidas
                if sin_tilde_palabra == usuario:
                    print("""
                            ⢀⡴⠑⡄⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
                            ⠸⡇⠀⠿⡀⠀⠀⠀⣀⡴⢿⣿⣿⣿⣿⣿⣿⣿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠑⢄⣠⠾⠁⣀⣄⡈⠙⣿⣿⣿⣿⣿⣿⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⢀⡀⠁⠀⠀⠈⠙⠛⠂⠈⣿⣿⣿⣿⣿⠿⡿⢿⣆⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⢀⡾⣁⣀⠀⠴⠂⠙⣗⡀⠀⢻⣿⣿⠭⢤⣴⣦⣤⣹⠀⠀⠀⢀⢴⣶⣆ 
                            ⠀⠀⢀⣾⣿⣿⣿⣷⣮⣽⣾⣿⣥⣴⣿⣿⡿⢂⠔⢚⡿⢿⣿⣦⣴⣾⠁⠸⣼⡿ 
                            ⠀⢀⡞⠁⠙⠻⠿⠟⠉⠀⠛⢹⣿⣿⣿⣿⣿⣌⢤⣼⣿⣾⣿⡟⠉⠀⠀⠀⠀⠀ 
                            ⠀⣾⣷⣶⠇⠀⠀⣤⣄⣀⡀⠈⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀ 
                            ⠀⠉⠈⠉⠀⠀⢦⡈⢻⣿⣿⣿⣶⣶⣶⣶⣤⣽⡹⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀ 
                             ⠀⠀⠀⠀⠀⠀⠀⠉⠲⣽⡻⢿⣿⣿⣿⣿⣿⣿⣷⣜⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣷⣶⣮⣭⣽⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠀⠀⣀⣀⣈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
                            ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⠻⠿⠿⠿⠿⠛⠉
   .g8MMMbgd       db      `7MN.   `7MF'    db       .MMMMbgd MMP""MM""YMM `7MMMMMYMM  
.dP'     `M      ;MM:       MMN.    M      ;MM:     ,MI    "Y P'   MM   `7   MM    `7  
dM'       `     ,V^MM.      M YMb   M     ,V^MM.    `MMb.          MM        MM   d    
MM             ,M  `MM      M  `MN. M    ,M  `MM      `YMMNq.      MM        MMmmMM    
MM.    `7MMF'  AbmmmqMA     M   `MM.M    AbmmmqMA   .     `MM      MM        MM   Y  , 
`Mb.     MM   A'     VML    M     YMM   A'     VML  Mb     dM      MM        MM     ,M 
  `"bmmmdPY .AMA.   .AMMA..JML.    YM .AMA.   .AMMA.P"Ybmmd"     .JMML.    .JMMmmmmMMM   
---------------------------------------------------------------------------------------""") 
                    print("La palabra correcta era: "+ palabra)
                    vidas = 15
                    respuesta = input("\n ¿Quieres volver a jugar? Marca 1 si quieres o 0 para terminar: ")
                    if respuesta == "1":
                        os.system("cls")
                    else:
                        #si el usuario no quiere volver a jugar se cierra el programa
                        quit()
            #si el usuario pierde todas sus vidas
            else:
                print("""
                    ⠄⢀⣀⣤⣴⣶⣶⣤⣄⡀⠄⠄⣀⣤⣤⣤⣤⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
                    ⣴⣏⣹⣿⠿⠿⠿⠿⢿⣿⣄⢿⣿⣿⣿⣿⣿⣋⣷⡄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
                    ⣿⢟⣩⣶⣾⣿⣿⣿⣶⣮⣭⡂⢛⣭⣭⣭⣭⣭⣍⣛⣂⡀⠄⠄⠄⠄⠄⠄⠄⠄
                    ⣿⣿⣿⣿⡿⢟⣫⣭⣷⣶⣾⣭⣼⡻⢛⣛⣭⣭⣶⣶⣬⣭⣅⡀⠄⠄⠄⠄⠄⠄
                    ⣿⡿⢏⣵⣾⣿⣿⣿⡿⢉⡉⠙⢿⣇⢻⣿⣿⣿⣿⡟⠉⠉⢻⡷⠄⠄⠄⠄⠄⠄
                    ⣿⣷⣾⣍⣛⢿⣿⣿⣿⣤⣁⣤⣿⢏⠸⣿⣿⣿⣿⣷⣬⣥⣾⠁⣿⣿⣷⠄⠄⠄
                    ⣿⣿⣿⣿⣭⣕⣒⠿⠭⠭⠭⡷⢖⣫⣶⣶⣬⣭⣭⣭⣭⣥⡶⢣⣿⣿⣿⠄⠄⠄
                    ⣿⣿⣿⣿⣿⣿⣿⡿⣟⣛⣭⣾⣿⣿⣿⣝⡛⣿⢟⣛⣛⣁⣀⣸⣿⣿⣿⣀⣀⣀
                    ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
                    ⣿⡿⢛⣛⣛⣛⣙⣛⠿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣬⣭⣭⠽⣛⢻⣿⣿⣿⠛⠛⠛
                    ⣿⢰⣿⣿⣿⣿⣟⣛⣛⣶⠶⠶⠶⣦⣭⣭⣭⣭⣶⡶⠶⣾⠟⢸⣿⣿⣿⠄⠄⠄
                    ⡻⢮⣭⣭⣭⣭⣉⣛⣛⡻⠿⠿⠷⠶⠶⠶⠶⣶⣶⣾⣿⠟⢣⣬⣛⡻⢱⣇⠄⠄
                    ⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⠶⠒⠄⠄⠄⢸⣿⢟⣫⡥⡆⠄⠄
                    ⢭⣭⣝⣛⣛⣛⣛⣛⣛⣛⣿⣿⡿⢛⣋⡉⠁⠄⠄⠄⠄⠄⢸⣿⢸⣿⣧⡅⠄⠄
                    ⣶⣶⣶⣭⣭⣭⣭⣭⣭⣵⣶⣶⣶⣿⣿⣿⣦⡀⠄⠄⠄⠄⠈⠡⣿⣿⡯⠁⠄⠄
`7MMMMMMq.`7MMMMMYMM  `7MMMMMMMq.  `7MMMMMYb.`7MMF' .MMMMbgd MMP""MM""YMM `7MMMMMYMM  
  MM   `MM. MM    `7    MM   `MM.   MM    `Yb. MM  ,MI    "Y P'   MM   `7   MM    `7  
  MM   ,M9  MM   d      MM   ,M9    MM     `Mb MM  `MMb.          MM        MM   d    
  MMmmdM9   MMmmMM      MMmmdM9     MM      MM MM    `YMMNq.      MM        MMmmMM    
  MM        MM   Y  ,   MM  YM.     MM     ,MP MM  .     `MM      MM        MM   Y  , 
  MM        MM     ,M   MM   `Mb.   MM    ,dP' MM  Mb     dM      MM        MM     ,M 
.JMML.    .JMMmmmmMMM .JMML. .JMM..JMMmmmdP' .JMML.P"Ybmmd"     .JMML.    .JMMmmmmMMM 
_____________________________________________________________________________________
\n""")
                respuesta = input("\n ¿Quieres volver a jugar? Marca 1 si quieres o 0 para terminar: ")
                if respuesta == "1":
                    os.system("cls")
                    break
                    
                else:
                    #si el usuario no quiere volver a jugar se cierra el programa
                    quit()


    

if __name__ == "__main__":
    run()

Reto:
Imagen
Link al archivo:
ahorcado.py

Les dejo mi versión de juego, disfrute mucho haciéndolo
https://github.com/walthersmith/Hangman

Juego del Ahorcado.

En vez de presentar el famoso muñeco y la horca, en aras de simplificar

(y hacerlo diferente), opté por poner una “barra de vida” al lado de

los intentos restantes de equivocaciones.

import os, random

Cargado del archivo la lista de palabras a usar en el juego.

def lee_archi():
with open("./archivos_prueba/data.txt", “r”, encoding = “utf-8”) as archivo:
for linea in archivo:
palabras.append(linea.rstrip()) # Se elimina último caracter y añade a la lista.

return palabras

De forma aleatoria obtiene la palabra de la lista cargada.

Retorna 2 variables, la palabra en mayúsculas, y la misma palabra con

caracteres sin acento (sí los hubiere).

def aleatorio():
especiales = {
‘Á’: ‘A’,
‘É’: ‘E’,
‘Í’: ‘I’,
‘Ó’: ‘O’,
‘Ú’: ‘U’,
‘Ü’: ‘U’
}

aleatorio = random.choice(palabras).upper() # Obtención de la palabra incógnita.
aleatorio_sin = aleatorio

# Retiro de los acentos (sí los hubiere).
for acento, normal in especiales.items():
    aleatorio_sin = aleatorio_sin.replace(acento, normal)

# Retorno de la palabra incógnita con y sin acentos.
return aleatorio, aleatorio_sin

Uso: equivocaciones(‘cantidad_para_equivocarse’, ‘equivocadas’, ‘cadena_letras_usadas’).

def equivocaciones(x, y, usadas):
print(“Equivocaciones restantes:”, x-y, “O”*(x-y) + “_”*y)
print(“Letras usadas:”, usadas, “\n”)

Generación de la pantalla de juego.

Se pasan valores para ‘maxi’, ‘equi’ u ‘usadas’ para usarlas con

la función “equivocaciones”.

def encabezado(maxi, equi, usadas):
os.system(“cls”)

print("*---------------------------------------------*")
print("* * *> J u e g o   e l   a h o r c a d o <* * *")
print("*---------------------------------------------*\n")
print("Palabra a buscar: ", end="")

for x in incognita: # Presenta la palabra incógnita.
    print(x + " ", end="")
print("\n")

equivocaciones(maxi, equi, usadas)

Se verifica que sólo se haya entrado un caracter.

def verifica(letra):
if len(letra) > 1 or letra.isalpha() == False:
print(“Favor de entrar sólo una letra y/o no dígitos.”)
input(“Presione ‘Enter’ para continuar.”)
return False
else:
return True

Mecánica del juego.

def juego(buscado , busca):
global incognita # Por algo que desconozco, esta función no ‘vé’ la variable
# sin ‘global’, pero otra función anterior si.
equivocadas = 0
max_equivoc = 10
letras_usadas = “”

encabezado(max_equivoc, equivocadas, letras_usadas)

# Bucle para encontrar la palabra incógnita.
while True:
    acierto = False
    letra = input("Digite una letra: ").upper()

    if verifica(letra) == True:
        letras_usadas += letra
        for pos, carac in enumerate(busca):
            if carac == letra:
                inter = list(incognita)
                inter[pos] = buscado[pos] # Uso 'buscado' en caso de vocal con acento.
                incognita = "".join(inter)
                acierto = True

        if acierto == False:
            equivocadas += 1

    encabezado(max_equivoc, equivocadas, letras_usadas)

    if incognita == buscado:
        print("\n¡¡¡ Ha ganado !!!")
        print("La palabra era:", buscado, "\n")
        break

    if max_equivoc == equivocadas:
        print("  * * * ¡ E S T Á   A H O R C A D O ! * * *")
        print("\n¡¡¡ Perdió !!!")
        print("La palabra que buscaba era:", buscado, "\n")
        break

def run():
global palabras # Lista de palabras
palabras = [] # a adivinar.

# Carga de la lista de palabras.
lee_archi()

# Obtención de la palabra a buscar.
buscado, busca = aleatorio()

global incognita # Para que esté accesible a varias funciones.
incognita = "_" * len(busca)

# Arranca la maquinaria del juego.
juego(buscado , busca)

if name == ‘main’:
run()

Tarde mucho pero fue con mucho sacrificio. lo quería hacer, quería demostrarme que era capaz y ahí está. disculpen el “paisa-english”

108 líneas de código y voy al 80%, empezaré a ver los comentarios para obetner más ideas.

listo lo logre 😄, aqui les dejo los mensajes de cuando ganas y píerdes, tambien el codigo por si quieren probar o modificar algo.

from dataclasses import replace
import random
import os


def normalize(j):
    replacements = (
            ("á", "a"),
            ("é", "e"),
            ("í", "i"),
            ("ó", "o"),
            ("ú", "u"),
        )
    for a, b in replacements:
        j = j.replace(a, b)
    return j


IMAGENES_AHORCADO = ['''

   +---+
   |   |
       |
       |
       |
       |

=========''', '''

  +---+
  |   |
  O   |
      |
      |
      |
=========''', '''

  +---+
  |   |
  O   |
  |   |
      |
      |
=========''', '''

  +---+
  |   |
  O   |
 /|   |
      |
      |
=========''', '''

  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========''', '''

  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========''', '''

  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========''']


def game(pal, ola):
    bl = 0
    jes = {}
    for e, j in enumerate(pal.get(ola), start=1):
        jes [e] = normalize(j)
    palabra =[i.replace(i, '_') for i in jes.values()]
    # print(*palabra)
    while bl < 6:
        print(IMAGENES_AHORCADO[bl])
        print(*palabra)
        os.system("clear")
        a = input("ingresa una letra: ")
        assert a.isalpha(), "no puedes ingresar numeros ni cadenas vacias, solo letras"
        assert len(a) < 2, "solo puedes ingresar una letra a la vez"
        if a in jes.values():
            for k, v in jes.items():
                if a == v:
                    palabra[k-1] = a
        else:
            bl += 1
        #com = list(jes.values())
        if "_" not in palabra:#(set(palabra) == set(com)):<-otra forma de hacer la comparacion
            os.system('clear')
            print("felicidades ganaste la palabra era: ", *palabra)
            print('''
            ////////////*******,,,,,,,,,,**////////////////////**************/////////((((((#####%%%%%&%%%%%%%%%######((((((((((((((((##########################%%
            ///@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            ///@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            ///@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@@@@@@@@@@#####%///////////////&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@@@@@@########//////////%.,..%/////&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@@@########%///////////*......////////@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@#########(////////////........................,*%@@@@@@@@*[email protected]@@@@@@@@@@@@@@@@@@@@@@@@@@@&&%&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@&#########(///////////(,..........,.......,.,.......,...,&[email protected]@@@@@@@@@@@@@@@&//************************#@@@@@@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@##########%///////////%,......,.*(,,,,,,,,,,,,,,,/#,,.,...,......%@@@@@@@@@@@@***********************************%@@@@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@##########&//////////#......,%,,,,,,,,,,,,,,,,,,,,,,,,*%,......,.&@@@@@@@@@/**//@%/***//#&@@*****#%#/******/@(/*****(@@@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@&##########%/////////(......%,,(,,,,,,,,/&@,,,,@@@@@@@@%,**,.,[email protected]@@@@@@@*********((@@@@@/*@*****&*/&#@@& #***********/@@@@@@@@@@@@@@##
            (((@@@@@@@@@@@@###########%////////*.....#,,,,,/ /@%@%*,*,,,,(,,,,**,,,,%,%.,,.,@@@@@@&**************/*********************************&@@@@@@@@@@@@##
            (((@@@@@@@@@@@@&############//////(.....&,,,,,,,,,,,,,,,,,,,,,,/(@@@,,*,,,,#.,.&@@@@@#*/********************************************(***@@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@#####&##%%##((/////,.,.%,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*..*@@@@@@*//***********************************(**********&%&@@@@@@@@@@@##
            (((@@@@@@@@@@@@@@@%%#(%####(((##,,,,,,,,,,,#*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#[email protected]@@@@@@(#*******************************/**/***************(@@@@@@@@@@##
            (((@@@@@@@@@@@@%%%#(((####%#/,,,,,,,,,,,,,,,,,%,,,,,,,,,,,,,,,,,,,,,,#,,,,,..&@@@@@@@@***************(///////(#%&%/***********************/@@@@@@@@@##
            (((@@&&@@@@@@&%%%%#((((&#%,,,,,,,,,,,,,,,,,,,,,/,,@@%(**,,,,,**%/,,,*,,,,*..(#@@@@@@@/******************************/#%%(/*******(/*********@@@@@@@@##
            (((@&&&&&&&&&%%%#%((#%,/,,,,(,,,/,,,,*,,,,,*,,,,%,,,,,,,,,,,,,,,,,,*,,,#,..(//@@@@@@@*********************/****/%/*******/#//(#*******(*****/@@@@@@@##
            (((@&@@@&&&&%%#%%%#%,,#,,,,,*,,,*,,,,#,,,,,(,,,,%%*,,,,,,,,,,,,,,,,/#.....&//(#&@@@@#********##***(/*******************%*/*&%******%**********@@@@@@##
            (((@@@@@&@@%%%%%%%,,(,,,,,,,,,#,,(,,,%,,,,,*,,*(.........,,,..,.,.......*%####(((&&&/****************/##(//(#%#(*************/#(***************@@@@@##
            (((@&@@%%%%%%%%%&,,#,,,,,,,,/#((((((#%,,,,,,%(((((((##%%#/**,,*/#%%##((&##%@%((((((&********//%#/*//*/******/#(********************************/@&&@##
            (((@%%%%%%%%%%@@*****,,,,*&###((###(#&,,,**,%###(#((((((((((((((#####@@&&&&&&@##((##%&//*/*//**/*//*//*/*///////*///////*///////*//*////*/////*/@&&@##
            (((@#%%%%%&@@@@@*******/%%%%&&#######%*****&####(#######(((#####%@@&&&&&&&&&&&@##******(/////////////////////////////////////////////////////////&&@##
            (((@*@%&@@@@@@@@@@@&@@@@@@&%%%%%%%%%%%%%%%%%%%&@@@@@&&@@@@@%%%%%%%%%%%%@@&&&&&&@/*******(////////////////////////////////////////////////////////@&@##
            (((@@@@@@@@@@@@@@@@@@@@@@@&%%&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%%%%%*******@@&&&%&@@@@@@@@@@@@@(////////////////////////////////////////////////@&@##
            (((@@@@@@@@@@@@@@@@@@[email protected]@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%&********@&&,.............(@%/////////////////////////////////////////////(@&@##
            (((@@@@@@@@@@@@@@@@......#@@@@(.....,@@@[email protected]@@@[email protected]@@@@,........&@@@@%******(@,[email protected]%#&...../@(....%([email protected]//&,........@@@///////////////////@@@##
            ///@@@@@@@@@@@@@@@@....,@@@@@@@&[email protected]@@.....@@@@....,@@@,....&@@,..../@@@@/*****/,[email protected]@@(,..../@(.,[email protected]@...../@%...../@(///////////////////@##
            ///@@@@@@@@@@@@@@@&,,,,,@@@@@@@@,,,,,@@@,,,,,@@@@,,,,,@@.,,,,,,,,,,,,,,@@@@&//////*,,,,,,,,,,,,,%#((,,,,,%@((((,,,,,@@(((,,,,,@@/((((((((#@@#((((((@##
            ///@@@@@@@@@@@@@@@@,,,,,,@@@@@@,,,,,,@@@,,,,,@@@&,,,,,@@,,,,,@@@@@@&@@@@@@@@//////*,,,,,@###(////(((,,,,,@@((((*,,,,@@((#,,,,,@#(((%@@@@&&&&&@(((((@##
            ///@@@@@@@@@@@@@@@@@%,,,,,,,,,,,,,,&@@@@,,,,,,,,,,,,,,@@@*,,,,,,,,,,,,/@@@@@@/////*,,,,,@(/////////@,,,,,@@&&&&%*,,,,,,,,,,,,@@@%((@@@@@@@@@@@@((((@##
            (((@@@@@@@@@@@@@@@@@@@@@@(*,,,,,,*@@@@@@@@&***&@@@%%%%@@@@@@@#****#@@@@@@@@@@/////%%%%%%@///////////%%%%%@@@@@@@@@@@#*,*/&@@@@@@@(&@@@@@@@@@@@@@#((@##
            ''')
            #bl = 0
            break
        if bl == 6:
            os.system('clear')
            print(IMAGENES_AHORCADO[bl])
            print('''
            &&%%%&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@&%%%%&&@@@@@@@@&&&&&@&@@@@@&#%%#%%%%%&&&&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&@@@&
            &&&&&&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@&&&&@@@@@@@@@@@@@@@@@@@&%%%&&&@@@@@@@@@@@@@@@@@@@@&#%%%%%%%%%%%&&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&@@@&
            &&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@&&@@@@@@@@@@@@@@@@@@@@&&&&&@@@@@@@@@@@@@@@@@@@@@@&%%%%%%%&&&&&&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@&
            &&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@@@@@@@@@@@@@@@@@&%%%%%%&&&@@@@@@&&&&&&&&&&&&@@@@&@@@@@@@@@@@@@@@@@@@@@@@@@&&@@@@&
            &&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@@@@@@@@@@@@@@@@@&%&%&&&&@@@@@@@@@@@@&&&&&&&@@@@@@@@@@&@@@@@@@@&@@@@@&&&&&&&&&&&&%
            &&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@&&&&&&@&@@@@@%%%%%%%########%%%%%%%%%%%%%%
            &&&&&&&&&&&@@@@@&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&@@@&%(/****/%@@@@@@@@@@@@@@@@@&@@&&&&&&@@@@&&&&&@@&@@@@&%#####%%%%%%%%%%%&%%%%%%%%&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@@@@@@@&&%%%#*,,,/%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&@@@@@@@@&&&&&&%%%%%&%&&&&&&&&&&&
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%(/#/,.../&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&@@@&@@@@@@@@@@@@@@@@@@@@&&&&&&&&@&@%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(/#/..../&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@@&&&&&@@@@@@@@@@@@@@@@@@@@@&&&&&&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(.  . .*&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@&&&&&&&%%%%%%%%%&&&&&##%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%,.   .(@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&@@&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&%%%%%#%*,,*##
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#. .. ,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&@@@@@@@@@@@@@@@@@@&&%%%%%%%%%%%%%%%####*,*/#%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#%%###%%%%%%%%%%&&&&&&&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%%%&&%%%%%%%%%%%&&%%%%//#%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@@@@@@@@&&&&&&&&@&%&&&&&&&&&&&&&%%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&&%&&&&&&&&%%########%&@@@@@@@&&&&&&&&&&&&%&&&&&&&&&%%%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&@@@@&@@@@@@@@@@@@@@@@@@@@@@@@@@@&&%%##(((//((((///*********//#%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%.,#@@@@@@&&&@@@&@&&@@@@@@@@@@@@@@@&&&&&&&&&%%#((/****,*,,,,,,,,,,,,,,,,**/#&&&&&&&&&&&&&&&&&&&&&@@@@@@@@@&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%,    .%@@@@&&&@@@@&&@@@@@@@@@@@@@@&&&&%%&&%%%##(/**,,,................,,,,*(%&&&&@@@@@@@@@@@@@@@@@@@@@@@@&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&@@@%,     ,@@@@@@&&&&&&@&&&&@@@@@@@@&&&&%%######(((//*,,,,,.............,,,,,,,**(%%#&@@@@@@@@@@@@@@@@@@@@@@@&&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#/&@@(.    .&@@@@@@@@@&&&&&&&&&&@@&&&%%###((////*******,,,,,,,,,..........,,,,,,***(%&%(&@@@@@@@@@@@@@@@@@@@@@@@@&%
            @@@&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@&/(@@@(.    .#@@@@@@@@@@@@@@@@&&&&&&%(((///////********,,,,,,,,,,..........,,,,,,,**/%&&#*%@@@@@@@@@@@@@@@@@@@@@@@&%
            @&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@&/#@@@@&,      .%@@@@@@@@@@@@@@@@&&%#(/////////*******,,,,,,,,,,,,...,.......,,,,,,,**(%@#.,&@@@@@@@@@@@@@@@@@@@@@@&%
            @&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@&(%@@@@@@@*       .%@@@@@@@@@@@@@&%#(///////////********,,,,,,,,,,,,,.........,,,,,****/(&#..(@@@@@@@@@@@@@@@@@@@@@@&%
            @%&&&%%%&&&&&&@@@@@@@@@@@@@@@@@&(%@@@@@@@@@%.       (@@@@@@@@@&%(//*****/////////*****************,,,,,,,,,,,,,,*/(#%%%%%%(../@@@@@@@@@@@@@@@@@@@@@@&%
            &%%%%%%%&&&&&&@@@@@@@@@@@@@@@@@&&@@@@@@@@@@@%,       (&&@@@@@&#(//******///////////((####%%%%%%%%##(**,,,,,,,*/(#%##((##%%(..*@@@@@@@@@@@@@@@@@@@@@@&%
            @#%%%%%%%%&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@&#.      ,%#&@@@@&#(//******///////(########(**,,****///**,,,,,,*/((#%%#(////#(..*@@@@@@@@@@@@@@@@@@@@@@&%
            @%%%%%%%%%%&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@&@@%.      .%#%@@@&&#(//*******///(/(///******/(%%####(//***,,,,,,///*******/(%&/../@@@@@@@@@@@@@@@@@@@@@@&%
            @%%%%%%%%%&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@&&@&,      .%##@@@@&%#//*******////********,,,,,,************,,,,,,******,***(%&/..(@@@@@@@@@@@@@@@@@@@@@@&%
            &%%%%%%%%&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@&&@@,      .&##&@@@@%(//***************,,,,,,,,,,,,,,,,*******,,,,,,,,,,,,,,*/%&*..%@@@@@@@@@@@@@@@@@@@@@&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%@@@@@@@@@@@@@@,      .&%#&@@@@%#//***********,,,,,,,.....,,,,,,,,,,*****,,.,,*,,,,,,,,*/%#..*&@@@@@@@@@@@@@@@@@@@@@&&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#%@@@&&&&@@@@@@,      .&%%&@@@%#(///********,,,,,,,.............,,,,******,,,,,,,,,,,,,*/(*..#@@@@@@@@@@@@@@@@@@@@@@@&%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%(@@@@@@@@@@@@&.      ,@&&&@@@%(//*//*******,,,,,,,,,...........,,,**////**,,,,,,*,,,,,***..%@@@@@@@@@@@@@@@@@@@@@@@&%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(%@@@@@&&&@@@%.      *@@@@@@&#//**///*********,,,,,,,.......,,,/////////**,,,,,*********.(&&&&&&&&&&&&&&&&&&&&&&@@@&%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@/#@@@@&%%&@@*       #@@@@@@&(****////*********,,,,,,,,,,,,,,*////*******,,...,*/*****/&@@@@@@@@@&&&&&&&&&@@@@@@@@&&%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&/*#&@@@@%,.      *@@%&@@&#/*****************,,,,,,,,,,,,,,,,,***////(/*,,***///**/#%%&&@@@@@@@@@@@@@@@@@@@@&&&&&%%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&(//*,,,...  .(@&&&&&%#(******************,,,,,,,**,,,,,,,,,,,,,,*********//**/%@&&%&&&@@@@@@@@@@@@@@@@@@&&&%%%%%
            &&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%###%@@@@@%%#(((//*************,,,,,,,,,,,,,,,,,,,,,,.....,,,,,*******(%&@@@@@@@@@@@@@@@@@@@@@@@@@&&&%%%%%
            &&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%#(/////***********,,,,,,,,,.,,*(((/****,,,,,........,,****(&&&@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&%%
            &&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%%#(//**************,,,,,,,,...,,,,*((((*,,,....  ..,*,*,*/%&&&&&@@@&%%&&@@@@@@@@@@@@@@@@@@&&&&&&%%
            &&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%###(/***************,,,,,,,,.,,,,,,,,,**/****//(((/*****/%&&&&&%@@@&&&&@@@@@@@@@@@@@@@@@@@@&&&&&&%%
            &&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&%%#####((/***************,,,,,**,,,,,,,,,,,,,,,,,,,,,,,,,,**#%&&&&&&%@@@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&%%
            %%&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&%####(((((//***,,,,,,,,,,,,********,,,***,,,,,,,,,,,,,,,,,,*/%%&&&&&&%%&&&&&&@@@@&@@@@@@@@&&&&&&&&&&&&&&%%
            &&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@&&@&&&&&&&%##(((((((((//****,,,,,,,,,,,,,,******,,,,,,,,,,,,,.,,,,,,,,,*#%%%&&&&&%%@&&@@@&&&@@@@@@@@@@@&&&&&&&&&&&&&%%
            @@@@@@@@@@@@@@@@@@@@@@@@@@&&&&&&&%%%%%%&&&%(/*/((((((//***,,,,,,,,,,,,,,,,,,******,,,.,,,,,,,,,,,,,,,,*#############%%&@@@@@@@@@@@@@@@@&&&%%&&&@&&&&%%
            @@@@@@@@@@@@@@@@@@@@@@@&&%%%%%#####%%%%%%&&%%///((((//***,,,,,,,,,,,,,,,,,,,,.,,,*,,,..............,,/%%%%&&&%%%#######(((#%&@@@@@@@@@@@&&&%&&&&&&&&%%
            @@@@@@@@@@@@@@@@@@@@@&%############&&%%%%%%%%%#%##(/*,,,,,,,,,......,,,,.,..........,,,,..........,*#%%%##%%&&&&%%##((((((((((((#%&@&@@@&&&&&&@@&&&&%%
            @@@@@@@@@@@@@@@@&%%########(((((((%&&%%###########(*,.............  .........          ....,,*/(###%#%%%##((#%%%%%##(((((((((((((((((#%&&&&&&&&&&&&&%%
            @@@@@@@@@@@@&%#########((((///(((#%&%%#(((((((((((((,..     ......                     ,(%(((((#(((((#####((((##%%#(((////////////////((%&&&&&&@&&&&%#
            @@@@@@@@@%#########((((((((/////(#%&%#(//////((((((((/*.                              /%((/////((////((//((//(####(((////////////////////#&&&&&&&&&%%#
            @@@@&%##########((((((((((//////(#%%%((/////////(//. ,/*,.                         .((///*//***/(/***/(((((///(#((((((//(/////////((//((/*(&&&&&&&&&%#
            @&%(########(((((((((((((///**//(#%%#((///////////(*     ....               ...     .,,......,,*/(****(/((((////((##((///(/******/(((///***(&&&&&&&%%#
            #########(((((((///////////****/(#%%%#((///(//******.     ...........                                 .,.,,,****/(##(((///********/(((///***(&&&&&&&%#
            ######((((////////////////*****/(%%##(/(///(((/****,.       .....                                              ..,/#/((/((/*******/(///*//***#&&&&&%%(
            ((##(((/((//****//*////*//*****/(##/**///(////(/***.          ./*////***.                                         .(/////((((//***/(///**///**%&%&%%%(
            //(((////(#/**********/*********(#(/***/(//////(/**.          ***********                                         ,*/(((/(((((((((/(///*//((***%&&%%%(
            ///(/////(%/***********//******/((/****/(////**//*.           *********,                    .,,***,..            .***/(/(((((((((((((/*/(((/****%&&&%(
            /#(///***/%#***********///*****/((/*****/(///****.            ,*******,                      .*****/#.  *.       ./****/((((((((((((((((((/******%&&%(
            */##(/****#%/**********/#(******/((/*****/(((/***.             ****,..                        ,///**(,  ,,       .****/((((((((((((((((((/********#%%(
                
            ''')
            print('''
                                                                                                                      
                    #####  ###### #####   ####     #    #   ##   #####  #####  ######    #    # #   ##      #    # # #      #      #   # 
                    #    # #      #    # #    #    ##  ##  #  #  #    # #    # #         ##  ## #  #  #     #    # # #      #       # #  
                    #    # #####  #    # #    #    # ## # #    # #    # #    # #####     # ## # # #    #    #    # # #      #        #   
                    #####  #      #####  #    #    #    # ###### #    # #####  #         #    # # ######    # ## # # #      #        #   
                    #      #      #   #  #    #    #    # #    # #    # #   #  #         #    # # #    #    ##  ## # #      #        #   
                    #      ###### #    #  ####     #    # #    # #####  #    # ######    #    # # #    #    #    # # ###### ######   #   
                    #    #   ##    ####     #####  ###### #####  #####  # #####   ####                                                   
                    #    #  #  #  #         #    # #      #    # #    # # #    # #    #                                                  
                    ###### #    #  ####     #    # #####  #    # #    # # #    # #    #                                                  
                    #    # ######      #    #####  #      #####  #    # # #    # #    #                                                  
                    #    # #    # #    #    #      #      #   #  #    # # #    # #    #                                                  
                    #    # #    #  ####     #      ###### #    # #####  # #####   ####                                                   
                                                                                                                                        
                                                                                                     
            ''')


def awor():
    words = {}
    with open("./archivos/data.txt", "r", encoding="utf_8") as f:
        for word, j in enumerate(f, start=1):
            words [word] = j.strip('\n')
        num = random.randint(1, 171)
        game(words, num)
        #print(num)


def run():
    awor()


if __name__ == '__main__':
    run() 

Va mi versión
https://github.com/Javezold/hangman
Entiendo hay mucho que no implemente de acuerdo los requerimientos del reto. Es funcional, cumple el propósito pero considero que le falta simplificar mas e implementar todo lo aprendido en este curso. De momento para avanzar entrego esta versión no sin antes decir que la iré mejorando y haciendo modificaciones para que sea ‘pythonico’

Comparto mi solucion del reto, espero que le pueda de ser ayuda a uno de ustedes 😃

import os
import random

names_list = []
vocals_acent = "áéíóú"
vocals_no_acent = "aeiou"
with open("./archivos/data.txt", "r", encoding="utf-8") as f:
    for line in f:
        change = line.maketrans(vocals_acent,vocals_no_acent)
        new_word = line.translate(change)
        names_list.append(new_word.replace("\n",""))

word = random.choice(names_list)
guess_word = ["_" for letter in word]
guess_word_join = " ".join(guess_word)

while True:
    if "".join(guess_word) == word:
        break

    print(f'¡Adivina la palabra! \n {guess_word_join}')
    letter = input("Ingresa una letra: ")

    if letter in word:
        i = 0
        for let in word:
            if let == letter:
                guess_word[i] = letter
            i += 1
        guess_word_join = " ".join(guess_word)

    os.system("clear")

print(f'¡Ganaste! La palabra era {word.upper()}')

Mi código

import os
import random


def interfaz(word, underscores, vidas, lenght):
    while vidas > 0:
        for i in underscores:
            print(i, end=' ')
        print(f'\nVidas: {vidas}')
        eleccion = input('Type a letter: ')
        if len(eleccion) != 1:
            raise ValueError("You can only type one letter at a time.")
        if eleccion == '0' or eleccion == '1' or eleccion == '2' or eleccion == '3' or eleccion == '4' or eleccion == '5' or eleccion == '6' or eleccion == '7' or eleccion == '8' or eleccion == '9':
            raise ValueError("You can only type letters.") #aquí pensaba en hacer un archivo aparte pero creo que hacer un ciclo y ya si es igual mandar el error
        i = 0
        try:
            for letter in word:
                if eleccion == word[i]:
                    underscores[i] = eleccion
                    lenght += 1
                    vidas += 1
                i += 1
            vidas -= 1
            os.system('cls')
            if lenght == len(word):
                underscores = "".join(underscores)
                print(underscores)
                print('Congratulations!')
                print('You´ve guessed the word')
                break
        except ValueError:
            print("Oops! Something went wrong!")
    print('Game over.')


def worter(): #get a random word from the database
    words = []
    with open('./words.txt', 'r', encoding='utf-8') as f:
        for name in f:
            words.append(name)
        
        random_number = random.randint(0, 203)
        word = words[random_number]
        word = word.replace('\n', '')
        underscores = [' _ ' for i in word]
        vidas = 5
        lenght = 0
        interfaz(word, underscores, vidas, lenght)


def run():
    print('Guess the word: ')
    worter()    


if __name__ == '__main__':
    run()
  • Quien puede ayudarme?, me pasa que sé toda la parte técnica, pero a la hora de solucionar algo por mi cuenta me bloqueo, simplemente no sé por donde empezar. 😦

Les quiero compartir mi codigo. Admiro mucho lo que han hecho los otros compañeros!

Codigo en Git Hub (Link)

No paren de aprender!.

Ya quiero programarlo.

import random
import os

HANGMAN= [’’‘
±–+
| |
O |
/|\ |
/ \ |
|
=========’’’, ‘’‘
±–+
| |
O |
/|\ |
/ |
|
=========’’’,’’‘
±–+
| |
O |
/|\ |
|
|
=========’’’,’’‘
±–+
| |
O |
/| |
|
|
=========’’’,’’‘
±–+
| |
O |
| |
|
|
=========’’’,’’‘
±–+
| |
O |
|
|
|
=========’’’, ‘’‘
±–+
| |
|
|
|
|
=========’’’ ]

def getData(filepath):
words = []
with open ("./archivos/data.txt", “r”, encoding=“utf-8”) as f:
for line in f:
words.append(line.strip().upper())
return words

def normalize(s): # It removes the accents of a string
replacements = (
(“á”, “a”),
(“é”, “e”),
(“í”, “i”),
(“ó”, “o”),
(“ú”, “u”),
)
for a, b in replacements:
s = s.replace(a, b).replace(a.upper(), b.upper())
return s
def run():

data = getData(filepath="./archivos/data.txt")
word = random.choice(data)
word_list = [letter for letter in word]
word_set = set(word_list)
attempts = 6
spaces = ["_"] * len(word)

while True:  
    os.system ("cls")
    for character in spaces: 
        print(character, end=" ")
    print(HANGMAN[attempts ])
    letter = input("Elige una letra: ").strip().upper()

    found= False
    for idx, character in enumerate(word):
        if character == letter:
            spaces[idx]=letter
            found= True

    if not found:
        attempts  -=1
    
    if "_" not in spaces:
        os.system("cls")
        print("¡Ganaste!")
        break
        input()

    if attempts  == 0:
        os.system("cls")
        print("Perdiste  ")
        break
        input()

if name==“main”:
run()

<import random
import os
from signal import valid_signals

def read():
     
    with open("./archivos/data.txt", "r", encoding="utf-8") as f:  
        #list_comprehensions
        palabras= [line for line in (f)]
    palabrasrandom = (random.choice(palabras))
    return palabrasrandom

   

def lenpalabra(palabra):
    len_palabra = len(palabra[:-1])
    presentation = ["_"]*len_palabra #parámetros poscicionales no visto por el usurio.
    return presentation 

def changelarge(hiddenword, letra, index):
    hiddenword[index] = letra
    return hiddenword

def imprimirpantalla(vidas):
    print("="*20+" Bienvenido al Hangman Game "+"="*20)
    my_list_ASCII = ['''
                    +---+
                    |   |
                        |
                        |
                        |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                        |
                        |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                    |   |
                        |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                   /|   |
                        |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                   /|\  |
                        |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                   /|\  |
                   /    |
                        |
                  ========= ''', '''
                    +---+
                    |   |
                    O   |
                   /|\  |
                   / \  |
                        |
                  ========= ''']
    my_list_ASCII = my_list_ASCII[::-1]
    print(my_list_ASCII[vidas])  
    
def run():

    selectpalabra = read()
    large = lenpalabra(selectpalabra)

    hits = 0
    objective = len(selectpalabra[:-1])
    vidas = 6
    usedletras = []
    
    
    print("!Adivina la Palabra¡:")
    while vidas > 0 and hits < objective:
    
        imprimirpantalla(vidas)
        print("")
        print("Adivine la siguiente letra. La misma cuenta con " +
              str(len(selectpalabra[:-1]))+" caracteres.")
        print(*large, sep=" ")
        print("")

        letra = input('Ingrese una letra: ').lower()
        assert letra.isalpha(), "debes ingresar solo texto"
        while len(letra) != 1:
            letra = input(

                "Ingreso mas de un dígito. Ingrese solo un digito: ").lower()
            assert letra.isalpha(), "Debe introducir una letra. No numeros" 

        while letra in usedletras:

            letra = input("Ingresó una letra repetida. Ingrese otra que no haya usado: ").lower()

        usedletras.append(letra)
        print("Las letras usadas hasta aquí son: ")
        print(*usedletras, sep=" ")
        hitsbefore = hits
        for i in range(0, len(selectpalabra[:-1])):
            if selectpalabra[i] == letra:
                hits += 1
                print("Excelente. Ha acertado! Ha sumado 1 punto. Quedan " +
                      str(objective-hits)+" letras por encontrar.")
                large = changelarge(large, letra, i)  

        if hitsbefore == hits:
            vidas -= 1
            print("No se encontró la letra elegida. Usted ha perdido una vida. Le quedan: "+str(vidas)+" vidas.")

        input("Presiones Enter para continuar: ")
        os.system("cls")

    if hits == objective:
        imprimirpantalla(vidas)
        print("¡¡¡Felictaciones!!! Usted ha ganado el juego, la palabra es: ", *large, sep=" ")
        # print(*large, sep=" ")
    if vidas == 0:
        imprimirpantalla(vidas)
        print("Game Over. Vuelva a intentarlo mas tarde")
    
    
    

if __name__ == '__main__':
    run()> 

Para hacer el juego de Ahorcado busqué una lista de palabras para incluirlas en el juego, el problema es que tenían su separación en silabas y lo unico que buscaba era la palabra, por lo que utilizando lo que aprendí en este curso creé un sistema de filtrado que me convierte la las lineas del archivo .txt solo en sus palabras

Antes: abrigo (a-bri-go)
Despues: abrigo

¡Aquí está el codigo por si les es de utilidad!

#Limpia un archivo de texto con respecto a unas características especificadas

def run():

    new_list=[]

    with open("Palabras.txt","r",encoding="utf-8") as f:
        
        new_list=[]
        word_list=[word for word in f]

        for word in word_list:

            n_word=''

            for l in word:
                
                if l!=' ':
                    n_word=n_word+l
                else:
                    new_list.append(n_word)
                    break

    f.close()
    print(new_list)

    with open("Resultado.txt","w",encoding="utf-8") as f:

        for w in new_list:
            f.write(w)
            f.write('\n')

            
if __name__=='__main__':
    run()

Aquí dejo mi versión.
Slds

Será muy tarde para postear mi juego? 😅

Se los dejo por aquí:

Hangman Game

Traté de hacerlo lo más modular posible, en caso de querer hacer cambios fácilmente y cosas así… al principio lo traté de hacer solamente con lo que sabía y a mi primera iteración vi los comentarios de la comunidad y agregué cosas que me perecieron esenciales. Los gráficos son diseño simple, pero cumple con todas las reglas y hasta tiene mensajes distintos para cada acción. Espero que les guste 😃

import os
import random


def read_file(path):
    with open(path, 'r', encoding='utf-8') as f:
        return [name.strip().upper() for name in f]


def run():
    life = 6
    score = 0
    while life > 0:
        list_names = read_file('./files/names.txt')
        guess_word = random.choice(list_names)
        name_user = ['_'] * len(guess_word)
        print("""
                     ___________.._______
                | .__________))______|
                | | / /      ||
                | |/ /       ||
                | | /        ||.-''./
                | |/         |/  _  \/
                | |          ||  `/,|
                | |          (\.`_.'
                | |         .-`--'.
                | |        /Y . . Y\.
                | |       // |   | \..
                | |      //  | . |  \..
                | |     ()   |   |   ()
                | |          ||'||
                | |          || ||
                | |          || ||
                | |          || ||
                | |         / | | \.
        -------------------------
        |  -------------------- |
        | |                   | |
        : :                   : :  
        -------------------------
        """)
        while True:
            positions_letter = []
            print('¡Adivina la palabra!')
            print(f'Te quedan {life} vidas')
            print(*name_user, '\n')

            letter = input('Ingresa una letra: ').upper()
            assert len(letter) == 1, 'Ingresar solo una letra'

            if letter in guess_word:
                positions_letter = [index for index, value in
                                    enumerate(guess_word)
                                    if letter == value]
                score += len(positions_letter) * 1
            else:
                life -= 1

            for position in positions_letter:
                name_user[position] = letter

            if '_' not in name_user:
                os.system('clear')
                print(f'\n¡Ganaste! La palabra era: {guess_word}')
                break
            if life == 0:
                os.system('clear')
                print("""            
                    █▀█ █▀▀ █▀█ █▀▄ █ █▀ ▀█▀ █▀▀
                    █▀▀ ██▄ █▀▄ █▄▀ █ ▄█ ░█░ ██▄
                """)
                break
            os.system('clear')
        print(f'\n¡Score Total: {score}')


if __name__ == '__main__':
    run()

Mi aporte !

import os
import random

def read():
    # retorna todas las palabras linea por linea del archivo data.txt
    with open('./data.txt', 'r', encoding='utf-8') as f:
        return [palabra.replace('\n', '') for palabra in f]

def palabra_random():
    # retorna una palabra aleatoria.
    palabras = dict(enumerate(read(), 1))
    aleatorio = random.randint(1, len(read()))
    return palabras.get(aleatorio)

def run():
    palabra_aleatoria = palabra_random()
    palabra_original = [letra for letra in palabra_aleatoria]
    palabra_usuario = ['_' for letra in palabra_aleatoria]
    letras_error = []
    letras_error_dict = []
    ganaste = True

    os.system('cls')
    print(f'palabra_aleatoria: {palabra_aleatoria}')
    print('! + + EL AHORCADO [HANGMAN] + + !\n')
    print(f'    Adivina una palabra de {len(palabra_original)} letras !\n')
    print('--------------------/+/+/-------------------\n')

    while palabra_usuario != palabra_original:
        try:
            letra_input = input('Escribe una letra: ')
            if len(letra_input) == 0:
                raise ValueError('No se puede ingresar una cadena vacia.')
        except ValueError as ve:
            print(ve)

        for i, letra_usuario in enumerate(palabra_usuario):
            if letra_usuario == '_':

                if letra_input == palabra_original[i]:
                    palabra_usuario[i] = letra_input

                elif letra_input not in palabra_original:
                    letras_error.append(letra_input)
                    letras_error_dict = set(letras_error)

            else:
                continue

        os.system('cls')
        cuerpo = [
            '''                 ,#####,
                 #_   _#
                 |a` `a|''',
            '''                 |  u  |
                 \  =  /
                 |\___/|''',
            '''                /:     :\____ ___
      .'   `.-===-\   /-===-.`   '.
     /      .-"""""-.-"""""-.      \ ''',
            '''    /'             =:=             '\.
  .'  ' .:    o   -=:=-   o    :. '  `.
  (.'   /'. '-.....-'-.....-' .'\   '.)''',
            '''  /' ._/   ".     --:--     ."   \_. '\.
 |  .'|      ".  ---:---  ."      |'.  |
 |  : |       |  ---:---  |       | :  |''',
            '''  \ : |       |_____._____|       | : /
  /   (       |----|------|       )   \.
 /... .|      |    |      |      |. ...\ ''',
            '''|::::/'' jgs /     |       \     ''\::::|
'""""       /'    .L_      `\       """"'
           /'-.,__/` `\__..-'\.
          ;      /     \      ;
          :     /       \     |''',
            '''          |    /         \.   |
          |`../           |  ,/
          ( _ )           |  _)
          |   |           |   |
          |___|           \___|''',
            '''          :===|            |==|
           \  /            |__|
           /\/\           /"""`8.__
           |oo|           \__.//___)
           |==|
           \__/
''']

        for i in range(len(letras_error_dict)):
          x = cuerpo[i]
          print(x)

        if len(letras_error_dict) == 9:
          print('--------------------/+/+/-------------------\n')
          print('Perdiste!')
          ganaste = False
          break

        print('! + + EL AHORCADO [HANGMAN] + + !\n')
        print('  '.join(palabra_usuario), '\n\n')
        print('longitud:', len(palabra_original))
        print('letras_error:', letras_error_dict)
        print('errores:', len(letras_error_dict), '/9')
        print('Longitud cuerpo :', len(cuerpo))
        
    if ganaste:
      print('--------------------/+/+/-------------------\n')
      print('Ganaste!')


if __name__ == '__main__':
    run()

Les comparto mi Proyecto. Se aceptan críticas constructivas y sugerencias. Saludos

from random import randint
from os import system
import time

msgError = {0: ‘’,
1: ‘Ingresa una letra valida’,
2: ‘Debes ingresar solo una letra’,
3: ‘Debes ingresar una letra’,
4: ‘La letra no esta en la palabra’,
5: ‘Palabra Adivinada. Felicitaciones!!!’,
6: ‘Letra ya seleccionada’,
7: 'Perdiste!!! Intenta de nuevo. La palabra era '
}

imagen = {0:’’’
_____________
| |
|
|
|
|
|
|
|
|_____________

   ''',
   1:'''
   _____________
   |           |
   |           o
   |          
   |           
   |          
   |
   |
   |

|_____________

   ''',
   2:'''
   _____________
   |           |
   |           o
   |           |
   |           
   |          
   |
   |
   |

|_____________

   ''',
   3:'''
   _____________
   |           |
   |           o
   |          /|
   |           
   |          
   |
   |
   |

|_____________

   ''',
   4:'''
   _____________
   |           |
   |           o
   |          /|\\
   |           
   |          
   |
   |
   |

|_____________

   ''',
   5:'''
   _____________
   |           |
   |           o
   |          /|\\
   |           |
   |          
   |
   |
   |

|_____________

   ''',
   6:'''
   _____________
   |           |
   |           o
   |          /|\\
   |           |
   |          / 
   |
   |
   |

|_____________

   ''',
      7:'''
   _____________
   |           |
   |           o
   |          /|\\
   |           |
   |          / \\
   |
   |
   |

|_____________

   '''
   }

def texto(palabraOculta, numMensaje, lista, palabraFinal):
print(f’’'
Palabra: {palabraOculta} Letras seleccionadas: {lista}

{msgError[numMensaje]} {palabraFinal}
’’’
)

def run():
check = True
intento = 0
letrasSeleccionadas = []
palabraOrig, palabraSeleccionada = palabra()
palabraFinal = revision(palabraSeleccionada, letrasSeleccionadas)
while check == True:
show(palabraFinal, letrasSeleccionadas, seg = 0, img=intento, msg=0)
nuevaLetra = entrada(palabraFinal, letrasSeleccionadas, intento)
letrasSeleccionadas.append(nuevaLetra)
if nuevaLetra in palabraSeleccionada:
palabraFinal = revision(palabraSeleccionada, letrasSeleccionadas)
if not ‘_’ in palabraFinal:
show(palabraFinal, letrasSeleccionadas, seg = 7, img=intento, msg=5)
check = False
else:
intento += 1
if intento == 7:
check = False
show(palabraFinal, letrasSeleccionadas, seg = 7, img=intento, msg=7, final = f’"{palabraOrig}"’)
else:
show(palabraFinal, letrasSeleccionadas, seg = 2, img=intento, msg=4)
show(palabraFinal, letrasSeleccionadas, seg = 0, img=intento, msg=0)

def show(palabraFinal, lista, seg = 0, img = 0, msg = 0, new = 0, final=’’ ):
if new == 0:
system(‘cls’)
print(imagen[img])
texto(palabraFinal, msg, str(lista)[1:-1], final)
time.sleep(seg)
elif new == 1:
system(‘cls’)
print(imagen[img])
texto(palabraFinal, msg, str(lista)[1:-1], final)

def entrada(palabraFinal, letras, intento):
check = True
while check == True:
letra = input('Ingresa una letra: ')
if len(letra) == 1:
checkAlfaNum = letra.isalnum()
checkDigit = letra.isdigit()
if checkAlfaNum == True and checkDigit == False:
check = False
return letra.upper()
else:
show(palabraFinal, letras, seg = 2, img=intento, msg=1)
show(palabraFinal, letras, seg = 0, img=0, msg=0)
elif len(letra) > 1:
show(palabraFinal, letras, seg = 2, img=intento, msg=2)
show(palabraFinal, letras, seg = 0, img=intento, msg=0)

    else:
        show(palabraFinal, letras, seg = 2, img=intento, msg=3)
        show(palabraFinal, letras, seg = 0, img=intento, msg=0)

def revision(palabra, letrasSeleccionadas):
revPal = [x if x in letrasSeleccionadas else ‘_’ for x in palabra]
revPalStr = ’ '.join(revPal)
return revPalStr

def palabra(archivo = ‘./data.txt’):
palabras = []
with open(archivo, “r”, encoding=“utf-8”) as f:
for row in f:
nueva = row
nuevaPalabra = nueva.maketrans(‘áéíóú’, ‘aeiou’)
nuevaPalabra = nueva.translate(nuevaPalabra)
palabras.append(nuevaPalabra.upper())
num = randint(0, len(palabras) - 1)
palabraOrig = palabras[num][:-1]
palabraSep = list(’’.join(palabraOrig))

return palabraOrig, palabraSep

if name == ‘main’:
run()