Refactor game

Re armar el programa en base a un proyecto anterior termina siendo confuso. Era mejor empezar desde cero, uno se pasa mas tiempo tratando de seguir el armado de este Frankestein que aplicando lo aprendido hasta ahora.

Mi aporte:

import random 

print("""
      [ 🤖 Bienvenido al juego Piedra, Papel o tijera 🙋]
                  >>> Ingresa una opción <<<
      """)


def choose_options():
    options = ('piedra', 'papel', 'tijera')
    user_option = input('>>> Piedra, papel o tijera => ').lower()
   
    if not user_option in options:
        print('Esa opción no es valida')
        #continue
        return None, None 
    
    computer_option = random.choice(options)

    print('User option => ', user_option)
    print('Computer option => ', computer_option)
    return user_option, computer_option


def check_rules(user_option, computer_option, user_wins, computer_wins):
    if user_option == computer_option:
        print('Empate!\n')
    elif user_option == 'piedra':
        if computer_option == 'tijera':
            print('🪨 Piedra gana a tijera ✂️')
            print('¡User gana!\n')
            user_wins += 1
        else:
            print('📄 Papel gana a piedra 🪨')
            print('¡Computer gana!\n')
            computer_wins += 1
    elif user_option == 'papel':
        if computer_option == 'piedra':
            print('📄 Papel gana a piedra 🪨')
            print('¡User gana!\n')
            user_wins += 1
        else:
            print('✂️ Tijera gana a papel 📄')
            print('¡Computer gana!\n')
            computer_wins += 1
    elif user_option == 'tijera':
        if computer_option == 'papel':
            print('✂️ Tijera gana a papel 📄')
            print('¡User gana!\n')
            user_wins += 1
        else:
            print('🪨 Piedra gana a tijera ✂️')
            print('¡Computer gana!\n')
            computer_wins += 1
            
    return user_wins, computer_wins


def check_winner(user_wins, computer_wins):
    
    print(f'''
    🤖 Computer wins: {computer_wins}
    🙋 User wins: {user_wins}
            ''')
    
    if user_wins == 3:
        print('🎖️ El ganador es User 🎖️')
        exit()
        
    if computer_wins == 3:
        print('🎖️ El ganador es Computer 🎖️')
        exit()


def run_game():
    
    computer_wins = 0 
    user_wins = 0
    rounds = 1

    while True:
        print('***' * 10)
        print('Round ', rounds)
        print('***' * 10)

        rounds += 1
              
        user_option, computer_option = choose_options()
        user_wins, computer_wins = check_rules(user_option, computer_option,user_wins, computer_wins)
        check_winner(user_wins, computer_wins) 
        
                    
run_game()

Extraño a Facundo, este men no sabe explicar bien.

Aquí les dejo otra opción. Ejemplo de como las matemáticas nos pueden ayudar a reducir código

Los cursos anteriores con el profe Facundo, eran excelentes, pero estos están increiblemente aun mejor! maravilloso, excelente muestra de que Platzi implementa mejora ocntinua.

Con algo de Art ASCII:

Me gusta hacer los ejercicios que propone el maestro antes de ver el video.

Si me sale igual que a él, confirmo mi conocimiento.
Si me sale distinto, aprendo algo nuevo.
Si no me sale, no me frustro y veo la clase para ver como se resolvía el problema que no me dejó avanzar.

En cualquier caso, salgo ganando 😁. 100% recomendado 👌

Es muy feo refactorizar, pero mas vale acostumbrarse, es parte del trabajo. Les dejo la función que faltaba al reto

def check_wins(user_wins, computer_wins):
  if computer_wins == 2:
    print('El ganador es la computadora')
    exit()
  
  if user_wins == 2:
    print('El ganador es el usuario')
    exit()

Esta clase se fue de las manos :S

Sin duda la identación es un tema a tener muy en cuenta a la hora de realizar nuestros códigos.

Mi aportación agregando el def check_winner:

import random


def choose_options():
  options = ('piedra', 'papel', 'tijera')
  user_option = input('piedra, papel o tijera =>')
  user_option = user_option.lower()
  
  if not user_option in options:
    print('No es una opcion valida')
    # continue
    return None, None

  computer_option = random.choice(options)

  print('User option => ', user_option)
  print('Computer option => ', computer_option)
  return user_option, computer_option

def check_rules(user_option, computer_option, user_wins, computer_wins):
  if user_option == computer_option:
    print('Empate!')
  elif user_option == 'piedra':
    if computer_option == 'tijera':
      print('piedra gana a tijera')
      print('user gano!')
      user_wins += 1
    else:
      print('Papel gana a piedra')
      print('Computer gano!')
      computer_wins +=1
  elif user_option == 'papel':
    if computer_option == 'piedra':
      print('papel gana a piedra')
      print('user gano!')
      user_wins += 1
    else:
      print('Tijera gana a papel')
      print('Computer gano!')
      computer_wins +=1
  elif user_option == 'tijera':
    if computer_option == 'papel':
      print('Tijera gana a papel')
      prin('User gano')
      user_wins +=1
    else:
      print('piedra gana a tijera')
      print('Computer gano!')
      computer_wins +=1
  return user_wins, computer_wins

def check_winner(user_wins, computer_wins):
    if computer_wins == 2:
      print('El ganador es la computadora')
      exit()
    if user_wins == 2:
      print('El ganador es el usuario')
      exit()

def run_game():
  computer_wins = 0
  user_wins = 0
  rounds = 1
  while True:
    print('*' * 10)
    print('ROUND', rounds)
    print('*' * 10)
  
    print('computer_wins', computer_wins)
    print('user_wins', user_wins)
    rounds += 1

    user_option, computer_option = choose_options()
    user_wins, computer_wins = check_rules(user_option, computer_option,user_wins, computer_wins)
    check_winner(user_wins, computer_wins)
run_game()

A mi pareció bien, muy ajustado a la realidad en cuento a lo que corresponde a retomar código y refactorizar.

En muchas ocasiones tenemos que hacer cambios a código que hemos hecho meses atrás y eso es difícil.

No me había tocado alguna clase con tantas quejas, recuerden que el inglés es indispensable para crecer en este ámbito (Yo diría que ya es indispensable para cualquier profesión en este mundo globalizado); re-factorizar es necesario para trabajar en cualquier empresa con software existente (se llama dar mantenimiento al código) no siempre se podrá empezar desde cero ya que implica costos elevados y tiempo; adaptarse y eliminar esos sesgos cognitivos que impiden nuestro crecimiento (Si pueden inviertan en su salud mental).

Aquí les dejo un articulo que les puede ayudar.
(https://www.psiquion.com/blog/sesgos-cognitivos#:~:text=Los sesgos cognitivos son un,hora de interpretar la realidad.)

No se desanimen, y piensen positivo (pero no se excedan que también hace daño jajaja)

Y pensaba que en el curso anterior ya habiamos logrado lo máximo cno el juego de piedra papel o tijera

Esta clase es la primera que no me gustó, es mejor cuando se empieza desde 0 los códigos, hay cosas que uno no recuerda del todo bien y al modificar un código viejo, uno se pierde más 😭

no se podia hacer ese ejemplo desde cero? porque no entendi nada nada, quitar poner modificar asi no entendi

este curso y con todo en ingles queda uno loco

Todo un reto esto de refactorizar pero ayuda a tener otra perspectiva ✔

Les comparto mi código refactorizado, incluí una validación para que no muestre como Empate las opciones no válidas (que retornan None, None) y la función check_winner

# Refactor game

import random

def choose_options():

  # Creamos una tupla de opciones
  options = ("piedra", "papel", "tijera")

  # Solicitamos la opcion al usuario
  user_option = input("Piedra, Papel o Tijera => ")
  
  # Convertimos a minúscula el texto ingresado por el usuario
  user_option = user_option.lower()
   #print(user_option)
  
  if user_option not in options:
    print(f"La opcion {user_option} no es válida")
    #continue
    return None, None
  
  # Seleccionamos la opción de manera aleatoria
  computer_option = random.choice(options)
  print("computer => ", computer_option)

  # La funcion retorna multiples valores
  return user_option, computer_option

def check_rules(user_option, computer_option, user_wins, computer_wins):
  if user_option == computer_option and (user_option != None and computer_option != None):
    print("Empate!")
  elif user_option == "piedra":
    if computer_option == "tijera":
      print(f"{user_option} gana a {computer_option}. User ganó!")
      user_wins += 1
    else:
      print(f"{computer_option} gana a {user_option}. Computer ganó!")
      computer_wins += 1
  elif user_option == "papel":
    if computer_option == "piedra":
      print(f"{user_option} gana a {computer_option}. User ganó!")
      user_wins += 1
    else:
      print(f"{computer_option} gana a {user_option}. Computer ganó!")
      computer_wins += 1
  elif user_option == "tijera":
    if computer_option == "papel":
      print(f"{user_option} gana a {computer_option}. User ganó!")
      user_wins += 1
    else:
      print(f"{computer_option} gana a {user_option}. Computer ganó!")
      computer_wins += 1
  
  return user_wins, computer_wins

def check_winner(user_wins, computer_wins):
  if computer_wins == 2:
      print("El ganador es la computadora!")
      exit()
  if user_wins == 2:
      print("El ganador es el usuario!")
      exit()

def run_game():
  # Contadores de rondas ganadas
  computer_wins = 0
  user_wins = 0
  # Contador de rondas
  rounds = 1
  
  while True:

    print("*" * 10)
    print("ROUND", rounds)
    print("*" * 10)
  
    print("computer_wins =>", computer_wins)
    print("user_wins =>", user_wins)

    # Incrementamos el contador de rondas
    rounds += 1
  
    # Almacenamos los valores retornados por la funcion
    user_option, computer_option = choose_options()
  
    user_wins, computer_wins = check_rules(user_option, computer_option, user_wins, computer_wins)

    check_winner(user_wins, computer_wins)

run_game()

No entendi nada

Me parece muy útil que se definan funciones y que se agrupe las líneas de código en cada función y que no queden líneas sueltas. Como Python es el primer lenguaje que estoy aprendiendo, supongo que cuando se elabora programas más complejos se elabora primero los alcances de cada bloque. Hice unos bloques para entender mejor el código del juego piedra, papel o tijera.

![](

me ha gustado mucho el curso, sin embargo, esta clase se puede prestar para confusión por la indentación al corregir un código como este

Es bastante confuso todos los pasos y cortes de codigo que hay para el uso de de las funciones, considero es mejor hacer el ejercicio desde 0 para aprender mejor

Excelente ejercicio, realizar una factorización es de las mejores maneras de aprender.
Este ejercicio toma su tiempo entenderlo, sobre todo entender el flujo de las variables y cómo van cambiando.

Aquí esta mi aporte mejorado con func y variables globales, es un appraoch diferente:

import random
# Define the options
options = ('piedra', 'papel', 'tijera')

while True:

  counter = 0
  empate = 0
  perdiste = 0
  ganaste = 0
  
  # Define the results dictionary
  results = {
    'piedra': {
      'piedra': 'empate',
      'papel': 'perdiste',
      'tijera': 'ganaste'
    },
    'papel': {
      'piedra': 'ganaste',
      'papel': 'empate',
      'tijera': 'perdiste'
    },
    'tijera': {
      'piedra': 'perdiste',
      'papel': 'ganaste',
      'tijera': 'empate'
    }
  }
  
  def preprocess_game(chosen_option):
    global empate, perdiste, ganaste
    random_value = random.choice(options)
    result = results[chosen_option][random_value]
    if result == 'empate':
      empate += 1
    elif result == 'perdiste':
      perdiste += 1
    else:
      ganaste += 1
    print(
      f"{result}, elegiste {chosen_option} y la máquina eligió {random_value}."
    )
  
  # Prompt the user to choose an option
  for i in range(3):
    print('*' * 10)
    print('ROUND ', counter + 1)
    print('*' * 10)
    for index, chosen_option in enumerate(options):
      print(f"{index+1}. {chosen_option}")
  
    # Get user input and convert to integer
    while True:
      try:
        option_selected = int(
          input("Ingresa el número de la opción que deseas: "))
        counter += 1
        if option_selected < 1 or option_selected > len(options):
          print(
            "Ese número no es una opción válida. Por favor, ingresa un número del 1 al 3."
          )
        if counter <= 3:
          preprocess_game(options[option_selected - 1])
          #print(empate, perdiste, ganaste)
        if counter == 3:
          # Get the variable name with the maximum value
          max_var = max(['empate', 'perdiste', 'ganaste'], key=locals().get)
          
          # Check if the machine or the player won
          if max_var == 'empate':
            print('\033[33m' + 'Hubo un empate por lo que volveras a jugar' + '\033[0m')
            break
            
          elif max_var == 'perdiste':
            print('\033[31m' + 'La máquina ganó' + '\033[0m')
            break
          else:
            print('\033[32m' + 'Ganasteeeee!' + '\033[0m')
            # Print the results
            print("\nResultados finales:\n")
            print(f"\033[33mEmpates:\033[0m {empate}")
            print(f"\033[31mPerdiste:\033[0m {perdiste}")
            print(f"\033[32mGanaste:\033[0m {ganaste}")
            break
        else:
          break
      except ValueError:
        print("Ese no es un número. Por favor, ingresa un número del 1 al 3.")
        
  # check if is empate to iterate again
  if max_var != 'empate':
    # exit the while loop
    break

En mi caso, decidí hacer algunos cambios en la lógica del combate (utilicé la lógica que Freddy Vega usa en el curso de introducción a la programación), además de añadirle una lista de narradores y una de oponentes que son elegidos al azar para hacer más interactivo y visual el proyecto. Mi meta es hacer más complejo este juego conforme avance en los cursos:

"""
PIEDRA, PAPEL o TIJERAS MK2

Esta es una versión mejorada del juego realizado en el curso básico de Python mediante la implementación de funciones, alcance(scope) y 
"""

import random as rd

opponents = ('SHELLMINATOR', 'K-REN 9000', 'PYMASTER 420')
narrators = ('BOB THOMPSON', 'COTTON MCKNIGHT', 'JOHN DOE')

# ASIGNACION DE PERSONAJES:
narrator = rd.choice(narrators)
user_name = input(f'[{narrator}]: ¿Cómo te llaman en las calles?\n> ').capitalize()
opponent = rd.choice(opponents)

# FUNCIONES:
def weapon_select():
  weapons = ('piedra', 'papel', 'tijeras')
  user_weapon = input(f'[{narrator}]: ¿Qué escogerá "{user_name}", piedra, papel o tijeras?\n> ').lower()
  
  if not user_weapon in weapons:
    print(f'[{narrator}]: ¿PERO QUÉEEE? {user_name} ESCOGIÓ {user_weapon}, lo cual no es una opción válida')
    return None, None
  
  print(f'[{narrator}]: {user_name} escogió ¡¡¡{user_weapon}!!!')
  opponent_weapon = rd.choice(weapons)
  print(f'[{narrator}]: {opponent} escogió ¡¡¡{opponent_weapon}!!!')
  return user_weapon, opponent_weapon

def duel(user_weapon,opponent_weapon,user_wins,opponent_wins):

  if user_weapon == opponent_weapon:
    print(f'[{narrator}]: ¡¡ESTO ES UN EMPATE!!')
  elif user_weapon == 'piedra' and opponent_weapon == 'tijeras':
    print('GANASTE')
    user_wins +=1
  elif user_weapon == 'papel' and opponent_weapon == 'piedra':
    print('GANASTE')
    user_wins +=1
  elif user_weapon == 'tijeras' and opponent_weapon == 'papel':
    print('GANASTE')
    user_wins +=1
  else:
    print('PERDISTE')
    opponent_wins +=1

  return user_wins, opponent_wins

def check_scores(opponent_score, user_score):
  print(f'[{narrator}]: ESTE ES EL MARCADOR ACTUAL:\n[{user_name}]: {user_score}\n[{opponent}]: {opponent_score}')
  if opponent_score == 2:
    print(f'{opponent} GANÓ')
  elif user_score == 2:
    print(f'{user_name} GANÓ')
    
def game():
  user_wins = 0
  opponent_wins = 0
  rounds = 1

  while rounds < 3:
    user_weapon, opponent_weapon = weapon_select()
    user_wins, opponent_wins = duel(user_weapon,     opponent_weapon,user_wins,opponent_wins)

    check_scores(opponent_wins, user_wins)
    rounds += 1

# INICIO DEL JUEGO:
game()

La verdad esque estoy de acuerdo con varios usuarios. Debio hacer esto con funciones desde 0. Desarmar y armar todo el codigo causa mucha confusion, toca ver el video una primera vez para ver como lo hace, una segunda para armarlo y una tercera para corregir los errores al hacerlo para emular su codigo, es terriblemente trabajoso y no se siente como poner en practica lo aprendido sino tratar de seguir su ritmo.

Mi mente al rearmar lo que ya había entendido bien xD

Mi único cambio sugerido al código del juego por el momento es modificar la impresión del contador, con las veces que gana la computadora y el usuario, me parece que se entiende mejor ponerlo al final, de lo contrario el resultado no llega a 2.

como que tenia prisa!!!

No entiendo nada. Bah, en realidad sí entiendo lo que hace pero no entiendo cómo se da cuenta de todas esas cosas. Puedo copiar el código e ir siguiendo lo que dice el profe, pero falta un poco más de explicaciones con respecto a porqué decide tal o cual cosa.

en esta clase no entendi NADAAAAA, mala idea escoger un codigo largo.

salio mejor, reescribir el juego que solo modificarlo

Entiendo lo que el profe empezó hacer, pero debió hacerlo desde el principio del curso, ya que veníamos viendo otros temas,

o por lo menos partir la clase en funciones más pequeñas

Que tristeza yo quede mas perdido no entendí nada para mi fue mas confusión

Esta es ni solución

import random

OPTION = ('piedra', 'papel', 'tijera')
score_gamer = 0
score_user = 0

def choose_option() -> str:
    """Elegimos piedra, papel o tijera"""

    game_option = random.choice(OPTION)
    user_option = input("Teclea opcion: Piedra, Papel o Tijera: ").lower()

    return game_option, user_option


def select_winner (game, user):
    """Seleccionamos quien ha sido el ganador de la jugada"""
    global score_gamer
    global score_user
    # Opciones ganadoras
    battle_result = [
        [4, 1, 0],
        [1, 4, 2],
        [0, 2, 4]
    ]
    game_idx = OPTION.index(game)
    user_idx = OPTION.index(user)
    if game == user:
        return 'Empate'
    else:
        win = battle_result[game_idx][user_idx]
        if game == OPTION[win]:
            score_gamer += 1
            return "Game"
        if user == OPTION[win]:
            score_user += 1
            return "User"

# Press the green button in the gutter to run the script.
if __name__ == '__main__':

    while True:
        game_option, user_option = choose_option()
        print(f'Game -> {game_option}, User -> {user_option}')
        winner = select_winner(game_option, user_option)
        print(f'El ganador es {winner}')
        print(f'PUNTUACION. Game = {score_gamer} / User = {score_user}')
        # Queremos continuar el juego
        seguir = input("Quiere jugar otra partida (S/N): ")
        print(seguir)
        if seguir.lower() != 's':
            print("No continua el juego")
            break
        print("Continua el juego")

Alguien se a preguntado ¿Por qué la computadora gana un 98.9%?

Para jugar con la compu y un amigo.

#PIEDRA, PAPEL y TIJERA PROYECTOOO
print()
print("BIENVENIDO AL JUEGO DE PIEDRA, PAPEL Y TIJERA")
print(" \n ")

bis = {1: "Piedra", 2: "papel", 3: "tijeras"}

compu = 0
jugador = ""
jugador2 = ""
conjuga = 0
concom = 0
ronda = 1


#validacion y eleccion compu
def validacione(e, f):
  e = input(
    f"{f}Ingrese 1-piedra, 2-papel y 3-tijera o algun numero al lado de lado de la palabra "
  )
  e=e.lower()
  
  print()
  while not (e == "1" or e == "2" or e == "3" or e == "piedra" or e == "papel"
             or e == "tijera"):
    print()
    e = input(
      f"{f}por favor ingrese 1-piedra, 2-papel y 3-tijera o algun numero al lado de lado de la                   palabra "
    )  #Validacion de que ingrese un dato correcto
  return e


def validacion(a, j):
  bib = {"piedra": 1, "papel": 2, "tijera": 3}

  if a == "1" or a == "2" or a == "3":
    a = int(a)
  else:
    a = bib[a]
  print(j, (bis[a]))
  return a


#compu eleccion
def computa(b):
  import random
  eleccioncom = [1, 2, 3]
  random.shuffle(eleccioncom)
  b = random.choice(eleccioncom)
  print()
  print("Computadora", bis[b])
  print()
  return b


#Eleccion de juego
elecc = (input("Ingrese 1-Jugar solo 2-Jugar con amigo"))
print("\n")
while not (elecc == "1" or elecc == "2"):
  elecc = (input("Por favor ingrese 1-Jugar solo 2-Jugar con amigo"))

if elecc == "1":
  #Llamadas

  jugador = validacione(jugador, "")

  print("RONDA", ronda)
  print()
  jugador = validacion(jugador, "Jugador")

  compu = computa(compu)

  #Comparacion
  while conjuga < 3 and concom < 3:

    if ((jugador > compu and jugador == 1 and compu == 2) or
        (jugador < compu and jugador == 1
         and compu == 3)) or (jugador == 2 and jugador > compu) or (
           (jugador == 3 and compu == 2 and jugador > compu) or
           (jugador == 3 and jugador < compu)):
      print("Gana jugador")
      conjuga += 1
    elif jugador == compu:
      print("Empate")
    else:
      print("Gano compu")
      concom += 1

    print(f"jugador lleva {conjuga}  compu lleva {concom}")
    if conjuga < 3 and concom < 3:
      ronda += 1
      print("\n")
      print("RONDA", ronda)
      print()
      jugador = validacione(jugador, "")
      jugador = validacion(jugador, "Jugador")
      compu = computa(compu)

    if conjuga==3:
      print("GANA JUGADOR 1") 
    elif concom==3:
      print("GANA COMPUTADORA")
  

else:
  print("RONDA 1")
  jugador = validacione(jugador, "Turno de jugador 1--> ")
  jugador2 = validacione(jugador2, "Turno de jugador 2--> ")
  print("")
  jugador = validacion(jugador, "Jugador 1--> ")
  print("")
  jugador2 = validacion(jugador2, "Jugador 2--> ")

while conjuga < 3 and concom < 3:

  if ((jugador > jugador2 and jugador == 1 and jugador2 == 2) or
      (jugador < jugador2 and jugador == 1
       and jugador2 == 3)) or (jugador == 2 and jugador > jugador2) or (
         (jugador == 3 and jugador2 == 2 and jugador > jugador2) or
         (jugador == 3 and jugador < jugador2)):
    print("Gana jugador 1")
    conjuga += 1
  elif jugador == jugador2:
    print("Empate")
  else:
    print("Gano jugador 2")
    concom += 1

  print(f"jugador 1 lleva--> {conjuga}  jugador 2--> lleva {concom}")
  if conjuga < 3 and concom < 3:
    ronda += 1
    print("\n")
    print("RONDA", ronda)
    print()

    jugador = validacione(jugador, "Turno jugador 1--> ")
    jugador2 = validacione(jugador2, "Turno de jugador 2--> ")
    print("")
    jugador = validacion(jugador, "Jugador 1 --> ")
    print("")
    jugador2 = validacion(jugador2, "Jugador 2--> ")
    print("")
  if conjuga==3:
   print("GANA JUGADOR 1") 
  elif concom==3:
    print("GANA JUGADOR 2")
  

Mi aporte ^^

import random

def choose_options():
    options = ('piedra', 'papel', 'tijera')
    user_option = input('piedra, papel o tijera => ').lower()
    
    if not user_option in options:
        print('🤚 Esa opcion no es valida')
        return None, None
    
    computer_option = random.choice(options)
    return user_option, computer_option
    
def who_wins_this_round(user_opt, computer_opt, scores):
    winner = ''
    user_win_condition = [ ('tijera', 'papel'), ('papel', 'piedra'), ('piedra', 'papel') ]
    
    if user_opt == computer_opt:
        winner = "🛑"
    else:
        user_win = (user_opt, computer_opt) in user_win_condition
        winner = '👤' if user_win else '💻'
        scores[winner] = scores.get(winner, 0) + 1
    print(f"[👤 {scores['👤']}] {user_opt}\n[💻 {scores['💻']}] {computer_opt}\nGanador: {winner}!")

def who_wins_this_game(scores):
    if any(map(lambda s: s >= 3, scores.values())):
        winner = max(scores, key=scores.get)
        print(f'El ganador del juego es ---> {winner}')
        exit()

def run_game():
    scores = {
        '👤': 0,
        '💻': 0,
    }
    rounds = 1
    while True:
        print(f'\n[Round #{rounds}] ', end='')
        user_option, computer_option = choose_options()
        if None not in [user_option, computer_option]:
            who_wins_this_round(user_option, computer_option, scores)
            who_wins_this_game(scores)
            rounds += 1
run_game()

mi aporte un poco optimizado

<code> import random

# Define las opciones y las reglas del juego
OPTIONS = {'piedra': {'tijera': 'user', 'papel': 'cpu'},
           'papel': {'piedra': 'user', 'tijera': 'cpu'},
           'tijera': {'papel': 'user', 'piedra': 'cpu'}}

def choose_options():
    user_option = input('piedra, papel o tijera => ').lower()
    if user_option not in OPTIONS:
        print('esa opcion no es valida')
        return None, None
    cpu_option = random.choice(list(OPTIONS.keys()))
    print('user option =>', user_option)
    print('cpu option =>', cpu_option)
    return user_option, cpu_option

def check_rules(user_option, cpu_option, user_wins, cpu_wins):
    result = OPTIONS[user_option][cpu_option]
    if result == 'user':
        print(f'{user_option} gana a {cpu_option}')
        print('¡user gana!')
        user_wins += 1
    elif result == 'cpu':
        print(f'{cpu_option} gana a {user_option}')
        print('¡cpu gana!')
        cpu_wins += 1
    else:
        print('¡EMPATE!')
    return user_wins, cpu_wins

def run_game():
    cpu_wins = 0
    user_wins = 0
    for round in range(1, 4):
        print('*' * 12)
        print(f'ROUND {round}')
        print('*' * 12)
        print('-' * 12)
        print(f'points USER => {user_wins}')
        print(f'points CPU => {cpu_wins}')
        print('-' * 12)
        user_option, cpu_option = choose_options()
        if user_option is None:
            continue
        user_wins, cpu_wins = check_rules(user_option, cpu_option, user_wins, cpu_wins)
        if cpu_wins == 2:
            print('*** ¡El ganador rotundo es la CPU! ***')
            break
        elif user_wins == 2:
            print('*** ¡El ganador rotundo es la USER! ***')
            break

# Ejecuta el juego
run_game()

hago mi aporte con mi refactorizacion del codigo. Dicho codigo es diferente al propuesto en esta clase ya que trate de optimizar la ejecucion de las reglas por medio de una tupla

import random

def game_stats(rounds, user_wins, computer_wins):
    print("*" * 10)

    print("Ronda", rounds, ": ")

    print("*" * 10)

    print("Victorias de user: ", user_wins, "/ 2")

    print("Victorias de computer: ", computer_wins, "/ 2")

    print("*" * 10)

    print("Elige una opcion: ") 

def player_options_selection():
    options = ("piedra", "papel", "tijeras")
    user_option = input('piedra, papel o tijeras => ')
    user_option = user_option.lower()

    while not user_option in options:
        print("Elige una opcion valida: ")
        user_option = input('piedra, papel o tijeras => ')

    computer_option = random.choice(options)

    print("*" * 10)

    print("Opcion de user: ", user_option)

    print("opcion de computer:", computer_option)

    return user_option, computer_option

def round_winner(user_option, computer_option, user_wins, computer_wins):
    win = ("piedratijeras", "tijeraspapel", "papelpiedra")

    fight = user_option + computer_option

    print("Resultado: ")

    if user_option == computer_option:
        print('Empate!')

    elif fight in win:
        print("user gana la ronda")
        user_wins +=1

    else:
        print("computer gana la ronda")
        computer_wins +=1

    print("*" * 10)

    return user_wins, computer_wins

def match_winner(user_wins, computer_wins):
    if user_wins > computer_wins:
        print("User gana la partida")

    else: 
        print("Computer gana la partida")

def run_game():
    rounds = 1

    user_wins = 0

    computer_wins = 0

    while user_wins != 2 and computer_wins != 2:

        game_stats(rounds, user_wins, computer_wins)

        user_option, computer_option = player_options_selection()

        user_wins, computer_wins = round_winner(user_option, computer_option, user_wins, computer_wins)

        rounds +=1

    match_winner(user_wins, computer_wins)

run_game()

ejercicio de piedra papel o tijera

# Imports
import random
import time
import getpass

# Write animation
def write_fx(frase):
    for letra in frase:
        print(letra, end='', flush=True)
        time.sleep(0.010)
    
# game
def play(num1, num2, cpu_cs):
     
    empty = 0

    computer_wins = 0

    user_wins = 0

    rounds = 0


    while True:
        
        num2 = random.choice(cpu_cs)


        if num1 == num2:
            time.sleep(1)
            result = '\n    [*] Nadie gana'
            empty += 1
            rounds += 1

        elif num1 =='tijeras' and num2 == 'piedra' or num1 == 'papel' and num2 == 'tijeras' or num1 == 'piedra' and num2 == 'papel':
            time.sleep(1)
            result = '\n    [*] La maquina gana'
            computer_wins += 1
            rounds += 1

        elif num1 == 'piedra' and num2 == 'tijeras' or num1 == 'tijeras' and num2 == 'papel' or num1 == 'papel' and num2 == 'piedra':
            time.sleep(1)
            result = '\n    [*] El jugador gana'
            user_wins += 1
            rounds += 1

        if user_wins == 2:
            write_fx(f'''   
    Resultado de Partida numero {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')
            table('EL Usuario :D', rounds, user_wins, computer_wins, empty)
            break

        elif computer_wins == 2:
            write_fx(f'''   
    Resultado de Partida numero {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')
            table('La Maquina :D', rounds, user_wins, computer_wins, empty)
            break

        else:
            write_fx(f'''   
    RESULTADO DE PARTIDA NUMERO {rounds}   
                
            {result}

    La seleccion de la maquina fue {num2}''')

                
            write_fx(f'''
            
    vuelve a escoger entre 
            
    [*] Piedra
    [*] Papel
    [*] Tijeras
            
    para la siguiente ronda: ''')
            
            num1 = input('').lower().replace(' ','')

            if num1 not in cpu_cs:
                write_fx('\n    Comando no valido')
                time.sleep(1)
                
                write_fx(f'''
            
    vuelve a escoger entre 
            
    [*] Piedra
    [*] Papel
    [*] Tijeras
            
    para la siguiente ronda: ''')
                num1 = input('').lower().replace(' ','')
                continue

# User Interface
def table(nom, var1, var2, var3, var4):
    time.sleep(1)
    write_fx(f'''
    
     ________________________________________________________________
    | Partidas | ganadas por usuario | ganadas por maquina | Empates |
    |------------------------------------------------------|---------|
    |     {var1}    |         {var2}           |         {var3}           |    {var4}    |
     ----------------------------------------------------------------
    
    El ganador de la ronda es  {nom} 

                        
                        
                         ██████╗   ██████╗
                        ██╔════╝  ██╔════╝
                        ██║░░██╗  ██║░░██╗
                        ██║░░╚██╗ ██║░░╚██╗
                        ╚██████╔╝ ╚██████╔╝
                         ╚═════╝   ╚═════╝

    ''')


def home():
    choices = ('piedra', 'papel', 'tijeras')

    write_fx ('''
    
    Bienvenido a piedra, papel o tijeras

    El juego es en partidas, el primero en ganar
    2 partidas gana la ronda.

    [*] Piedra
    [*] Papel
    [*] Tijeras
    
    Escribe cual va a escoger aca --> ''')

    user_cs = input('').lower().replace(' ','')

    comp_cs = random.choice(choices)

    if user_cs not in choices:
        write_fx('\n    Comando no valido')
        time.sleep(1)
        home()

    else:
        play(user_cs, comp_cs, choices)

        write_fx(f'\n\n    Preciona enter para volver a jugar')
        getpass.getpass(' ')
        home()

if __name__ == '__main__':
    home()

La verdad, me costó un poco, pero se hizo así:

import random

def choose_options():
options = (‘piedra’, ‘papel’, ‘tijera’)
user_option = input('piedra, papel o tijera => ')
user_option = user_option.lower()

if not user_option in options:
print(‘esa opcion no es valida’)
# continue
return None, None

computer_option = random.choice(options)

print(‘User option =>’, user_option)
print(‘Computer option =>’, computer_option)
return user_option, computer_option

def check_rules(user_option, computer_option, user_wins, computer_wins):
if user_option == computer_option:
print(‘Empate!’)
elif user_option == ‘piedra’:
if computer_option == ‘tijera’:
print(‘piedra gana a tijera’)
print(‘user gano!’)
user_wins += 1
else:
print(‘Papel gana a piedra’)
print(‘computer gano!’)
computer_wins += 1
elif user_option == ‘papel’:
if computer_option == ‘piedra’:
print(‘papel gana a piedra’)
print(‘user gano’)
user_wins += 1
else:
print(‘tijera gana a papel’)
print(‘computer gano!’)
computer_wins += 1
elif user_option == ‘tijera’:
if computer_option == ‘papel’:
print(‘tijera gana a papel’)
print(‘user gano!’)
user_wins += 1
else:
print(‘piedra gana a tijera’)
print(‘computer gano!’)
computer_wins += 1
return user_wins, computer_wins

def check_winner(user_wins, computer_wins):
if computer_wins == 2:
print(‘El ganador es la computadora’)
#break
exit()

if user_wins == 2:
print(‘El ganador es el usuario’)
#break
exit()

def run_game():
computer_wins = 0
user_wins = 0
rounds = 1
while True:
print(’’ * 10)
print(‘ROUND’, rounds)
print(’’ * 10)

print('computer_wins', computer_wins)
print('user_wins', user_wins)
rounds += 1

user_option, computer_option = choose_options()
user_wins, computer_wins = check_rules(user_option, computer_option, user_wins, computer_wins)
check_winner(user_wins, computer_wins)

run_game()

En lo personal me parece interesante ir trabajando un proyecto a lo largo del curso. Eso hace que se internalicen conceptos y temas principales de los que hemos ido viendo. Está bueno también hacer foco en cuál es la condición del proyecto, su estado y dejar en claro como continuaremos con el nombrando los temarios con los qiue lo vamos a trabajar. Es una buena guía para saber como guardar la información tomar nota y luego continuar con esto para volver a conectar con los conceptos. Pero me parece buena idea.