¡Conoce otros proyectos de este curso!

Lo más importante es atreverse y dejar el miedo a fallar. Los desaciertos son solo una oportunidad de mejorar 🔥

Do it, and do it again, but never give up 💪

Hola, compartó el juego donde permite que el user iteractue con el prompt y tenga tres intentos, a lo último este totaliza y muestra si gano, empato o perdio.

import random

# Define the options
options = ('piedra', 'papel', 'tijera')
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'
  }
}

# Prompt the user to choose an option
print("Escoge una opción:")
for i in range(3):
  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:
        # Process user input
        chosen_option = options[option_selected - 1]
        # Generate random value to choose one of the 3 options
        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}."
        )
        results_dict = {
          'empate': empate,
          'perdiste': perdiste,
          'ganaste': ganaste
        }

      if counter == 3:
        # Get the variable name with the maximum value
        max_var = max(results_dict, key=results_dict.get)

        # Check if the machine or the player won
        if max_var == 'empate':
          print("Hubo un empate.")
        elif max_var == 'perdiste':
          print("La máquina ganó.")
        else:
          print("Ganasteeeee!")
          
        # 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.")

Este es mi proyecto, le puse un while que se detendrá solo cuando el usuario teclee salir

import random
options = ('piedra', 'papel', 'tijera')

while True :
	player = (input('escoja piedra, papel o tijera para jugar 		 
        o salir para terminar el juego: ')).lower()
	computer = random.choice(options)
  
	if player == computer:
    		print('Empate!')
  	elif player == 'tijera':
  		if computer == 'papel':
      			print('Ganaste!')
    		else: 
       			print('Perdiste')
  	elif player == 'papel':
    		if computer == 'piedra':
      			print('Ganaste!')
    		else:
      			print('Perdiste')
  	elif player == 'piedra':
    		if computer == 'tijera':
      			print('Ganaste!')
    		else:
      			print('perdiste!')
  	else:
    		if player == 'salir':
      			print('fin del juego, adios')
      			break
   		 else:  
      			print('opción inválida')
      			continue
  	print('Usted escogió: ', player)
  	print('La computadora escogió: ',computer )

#trate de mejorar un poco el comportamiento y que sea un poco mas legible, pruébenlo

  import random
  
  options = ('piedra', 'papel', 'tijera')
  
  computer_wins = 0
  user_wins = 0
  
  rounds = 1
  
  
  user_name = input('Como te llamaremos? -> ')
  
  message_win = f'{user_name} ganaste esta vez'
  message_lose = "Te gano la computadora esta vez"
  
  message_final_win = f'{user_name} eres el ganador absoluto'
  message_final_lose = "Perdiste contra la computadora, mejor suerte para la proxima"
  
  while True:
  
      print('*' * 10)
      print('ROUND', rounds)
      print('*' * 10)
    
      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
  
      rounds += 1
  
      computer_option = random.choice(options)
      print('-' * 10)
      print(f'{user_name} option =>', user_option)
      print('Computer option =>', computer_option)
      print('-' * 10)
  
      if user_option == computer_option:
          print('Empate!')
      elif user_option == 'piedra':
          if computer_option == 'tijera':
              print('piedra gana a tijera')
              print(message_win)
              user_wins += 1
          else:
              print('Papel gana a piedra')
              print(message_lose)
              computer_wins += 1
      elif user_option == 'papel':
          if computer_option == 'piedra':
              print('papel gana a piedra')
              print(message_win)
              user_wins += 1
          else:
              print('tijera gana a papel')
              print(message_lose)
              computer_wins += 1
      elif user_option == 'tijera':
          if computer_option == 'papel':
              print('tijera gana a papel')
              print(message_win)
              user_wins += 1
          else:
              print('piedra gana a tijera')
              print(message_lose)
              computer_wins += 1
  
      print('-' * 10)
  
      print("Computer wins: ", computer_wins)
      print(f'{user_name} wins: ', user_wins)
  
      if computer_wins == 2:
        print('==*' * 10)
        print(message_final_lose)
        break
  
      if user_wins == 2:
        print('==*' * 10)
        print(message_final_win)
        break

Aprendi lo básico de Python

Me doy cuenta que aprender a programar es un reto doble como el que enfrentan los recién nacidos: aprender a hablar y aprender a pensar. Se aprende a pensar en la medida en la que se aprende a hablar y viceversa. Por eso es tan importante aprender bien la sintaxis del lenguaje utilizado, la parte lógica fluirá mucho más fácil.

Juego de Piedra, Papel o Tijera

import random

# Variables que sirven de contador para el juego
rounds = 0
usuario_win = 0
maquina_win = 0

# Funcion para contar los parametros del usuario
def contador(rounds, usuario_win, maquina_win):
    return f'Ronda: {rounds}\nUsuario: {usuario_win}\nIA: {maquina_win}\n'

# Ciclo para contar las rondas perdidas y ganadas
while True:

    while not maquina_win == 2 or usuario_win == 2: 
        if usuario_win == 2 or maquina_win == 2:
            break
    # Selección del usuario
        print('-' * 30)
        usuario = input('Piedra, Papel o Tijera\nUsuario: ')
        usuario = usuario.lower()

    # Eleccion random del computador
        opciones = ["piedra",'papel','tijera']
        maquina = random.choice(opciones)
        print('IA:',maquina,'\n')

    # Elecciones del juego
        if maquina == usuario:
            rounds += 1
            print('Empate',
                '\nRonda:', rounds,'\n'
                '\nUsuario:', usuario_win,
                '\nIa:', maquina_win,'\n')

    # Esto es cuando gana el usuario
        elif maquina == 'papel' and usuario == 'tijera':
            usuario_win += 1
            rounds += 1
            print('\nTijera gana a papel \nGanó Usuario\n')
            print(contador(rounds, usuario_win, maquina_win))
            
        elif maquina == 'piedra' and usuario == 'papel':
            usuario_win += 1
            rounds += 1
            print('Papel gana a piedra \nGanó Usuario\n')
            print(contador(rounds, usuario_win, maquina_win))

        elif maquina == 'tijera' and usuario == 'piedra':
            usuario_win += 1
            rounds += 1
            print('Piedra gana a tijera \nGanó Usuario\n')
            print(contador(rounds, usuario_win, maquina_win))
            
    # Esto es cuando gana la maquina
        elif maquina == 'piedra' and usuario == 'tijera':
            print('Piedra gana a tijera \nGanó IA\n')
            maquina_win += 1
            rounds += 1
            print(contador(rounds, usuario_win, maquina_win))
            
        elif maquina == 'tijera' and usuario == 'papel':
            print('Tijera gana a papel \nGanó IA\n')
            maquina_win += 1
            rounds += 1
            print(contador(rounds, usuario_win, maquina_win))
            
        elif maquina == 'papel' and usuario == 'piedra':
            print('Papel gana a piedra \nGanó IA\n')
            maquina_win += 1
            rounds += 1
            print(contador(rounds, usuario_win, maquina_win))
        else:
            print('Elección incorrecta')
            print(contador(rounds, usuario_win, maquina_win))

    # Fin del juego 
    if usuario_win == 2:
        print('Ganaste')
        break
    else: 
        maquina_win == 2
        print('Perdiste')
        break

Les dejo mis notas.
Repositorio:

AQUI TIERNE UN JUEGO SENCILLO. TITULO MICHI. https://pythonmichi.blogspot.com/

Aquí dejo mi código de piedra papel o tijera, se puede pulir más pero traté de hacerlo con la menor cantidad de líneas

import random

options = (1, 2, 3)
pc_win = 0
user_win = 0
rounds = 1

while not pc_win == 2 or user_win == 2:
  print('*' * 10)
  print('ROUND', rounds)
  print('*' * 10)
    
  user_option = int(input('[1]piedra, [2]papel o [3]tijera => '))
    
  if user_option == 1:
    print('Elegiste => piedra')
  elif user_option == 2:
    print('Elegiste => papel')
  elif user_option == 3:
    print('Elegiste => tijera')
  else:
    print('Opción no válida')
    continue
    
  pc_option = random.choice(options)

  if pc_option == 1:
    print('PC eligió => piedra')
  elif pc_option == 2:
     print('PC eligió => papel')
  else:
     print('PC eligió => tijera')

  
  
  if user_option == pc_option:
    print('Empate')
  elif user_option - pc_option == 1 or user_option - pc_option == -2:
    print('Ganaste')
    user_win += 1
    print('Has ganado ', user_win)
  else:
    print('Perdiste')
    pc_win += 1
    print('Has perdido ', pc_win)
  print('\n')
 
  rounds += 1

Yo tambien hice un juego en Python. El juego es ahorcados:
#AHORACADO
import random
#Palabra a adivinar posiblemente
palabras = [“perro”, “gato”, “loro”, “lobo”, “gallina”, “tigre”, “leon”, “aguila”, “raton”, “mosca”]
#Palabra a adivinar
palabra_generada = random.choice(palabras)
#Palabra que se estará formando por partes
palabra_por_partes = ["", "", “", "”, “", "”, “", "”, “", "”, “", "”]
palabra_unida = “”

vida = 5
letra = ""
palabra_a_formarse = [len(palabra_generada)]
respuesta_definitiva = “”

print("¡Bienvenido al juego de AHORACADOS!")
print(“Temática: Animales”)
print(“Recuerda que tienes 5 vidas”)

repetir = 1

while repetir == 1:
palabra_generada = random.choice(palabras)
palabra_por_partes = ["", "", “", "”, “", "”, “", "”, “", "”, “", "”]
palabra_unida = “”

vida = 5
letra = ""
palabra_a_formarse = [len(palabra_generada)]
respuesta_definitiva = ""

while respuesta_definitiva != palabra_generada:
    letra = input("Insertar letra...")
    if letra in palabra_generada:
        for elemento in range(len(palabra_generada)):
            if palabra_generada[elemento] == letra:
                palabra_por_partes[elemento] = letra
            else:
                palabra_por_partes[elemento] == "@"
        for elemento in palabra_por_partes:
            if len(palabra_unida) >= len(palabra_generada):
                palabra_unida += ""
            else:
                palabra_unida += elemento
        if palabra_generada in palabra_unida:
            print("FELICIDADES! LA PALABRA ERA:", palabra_generada)
            break
        print("Palabra formada en juego: ", palabra_unida)
        palabra_unida = ""
    else:
        vida -= 1
        print("¡ERROR! ", vida, " vidas")
        if vida == 0:
            print("PERDISTE...")
            print("La palabra era:", palabra_generada)
            break
repetir = int(input("¿Deseas empezar nuevamente la partida? | 1. Sí | 2. No |"))
if(repetir == 2):
    print("GRACIAS POR JUGAR :D")

HOLA, envio el juego adivina adivinador jajaja
import random

Generar un número aleatorio entre 1 y 100

numero_secreto = random.randint(1, 100)

Inicializar las variables

intentos = 0
adivinado = False

print("¡Bienvenido al juego de adivinanzas!")

while not adivinado:
# Solicitar al jugador que ingrese un número
numero = int(input("Ingresa un número entre 1 y 100: "))

# Incrementar el contador de intentos
intentos += 1

# Comprobar si el número coincide con el número secreto
if numero == numero_secreto:
    print("¡Felicidades! ¡Adivinaste el número en", intentos, "intentos!")
    adivinado = True
elif numero > numero_secreto:
    print("Demasiado alto. Intenta de nuevo.")
else:
    print("Demasiado bajo. Intenta de nuevo.")

Yo les quiero compartir un proyecto que hice en la universidad, es un valuador de opciones financieras, tanto americanas como europeas. El proyecto es perfectible, pero me gustaría que si hay alguien por aquí que conoce o le gusta el mundo de las finanzas me haga un pull request para que practiquemos. https://github.com/JavisG300/Modelacion-Financiera

Hola, mi proyecto fue un juego de Lotería donde se implementan los conceptos aprendidos Tipos de datos, Condicionales, Ciclos, Manejo de Listas y Diccionarios.

Adjunto el código completo y solicito su consideración si es apto para ser publicado en la lista de proyectos del curso. Muchas Gracias!

“”“
Programa elaborado por Alejandro Riaño Velasco - JUEGO DE LOTERÍA.
16 de mayo de 2023
"”"

#INICIO DEL PROGRAMA

print("*** INICIO DEL PROGRAMA ***")
mensaje01 = " BIENVENIDO AL JUEGO DE LOTERÍA “
print (”\n",mensaje01.center(50,"="))

import random # Se importa la librería de random de Python para poder usar la función de randit()’

person = {
‘name’ : ‘’,
‘lastName’ : ‘’,
}

nombreUsuario = (input(’\nIngrese sus nombres: '))
apellidoUsuario = (input('Ingrese sus apellidos: '))
person[‘name’] = nombreUsuario
person[‘lastName’] = apellidoUsuario

juegos = int(input(f’\nBienvenido(a) {person[“name”]} {person[“lastName”]}.\nIngrese la cantidad de veces que desea jugar: '))

listaJuegos = []
for elemento in range(1, juegos+1):
listaJuegos.append(elemento)
print(’\nVas a jugar ‘, listaJuegos[-1], ’ veces’)

for juego in listaJuegos:
numeroLoteria = random.randint(1, 10) # Se usa la función randit para que asigne un valor aleatorio de 1 a 10
intentos = 0 # Inicializamos los intentos en cero
print(f’\n----- INICIO DEL JUEGO: {juego} -----’)
while True: # Se coloca el valor en Verdadero para que el ciclo While se ejecute de manera indefinida
bandera = False # Se inicializa en falso para poder entrar en el ciclo While
while bandera == False:
numeroUsuario = input("\nAdivina el número secreto del 1 al 10: “)
bandera = numeroUsuario.isnumeric() # Se evalúa si el valor ingresado es Entero Positivo
if bandera == False:
print(”\nHaz ingresado un valor incorrecto, deben ser valores enteros positivos, del 1 al 10")
elif int(numeroUsuario) >= 1 and int(numeroUsuario) <= 10: # Se evalúa si el valor ingresado sea de 1 a 10
bandera = True
numeroUsuario = int(numeroUsuario) # Convierte el valor texto en entero para poder hacer operaciones matemáticas con él
else:
bandera = False
print("\nHaz ingresado un valor incorrecto, deben ser valores enteros positivos, del 1 al 10")
intentos += 1
if numeroUsuario == numeroLoteria: # Evalúa el valor ingresado por el usuario vs el que se tiene de Lotería
print("\n¡FELICIDADES! Adivinaste la LOTERÍA en", intentos, “intentos.”)
break # Esta sentencia rompe el ciclo ya que el número ya fue adivinado
elif numeroUsuario > numeroLoteria: # Evalúa si el valor ingresado por el usuario es menor al que se tiene de Lotería
print("\nEl número secreto es menor que", numeroUsuario)
else: # Evalúa si el valor ingresado por el usuario es mayor al que se tiene de Lotería
print("\nEl número secreto es mayor que", numeroUsuario)
print(f"\n------ FIN DEL JUEGO: {juego} ------")
print("\nTe quedan “, listaJuegos[-1]-juego, " juegos.”) # Hace el conteo de los juegos restantes
print(f"\nMuchas gracias {person[‘name’]} {person[‘lastName’]}. Vuelve pronto.")

Este es mi proyecto, el computador adivina un numero que define el usuario, entre un rango definido:

#computador adivina numero secreto
import random
print("JUEGO DE ADIVINAR NUMERO SECRETO")
low=int(input('define un número mínimo:'))
high=int(input('define un número máximo:'))
feedback=''
contador=0
print("El computador adivinará el número secreto entre ",low, " y ", high, "piensa tu número secreto")

while feedback!='c':
  #difinir numero del PC
  if high!=low:
    propuestaPC= random.randint(low,high)
    print(f'el computador eligió {propuestaPC}') 
  else:
    propuestaPC= low #pudiera ser tambien high, son iguales
  #indicar retroalimentación
  
  feedback=input(f'Es {propuestaPC} muy alto (h), es muy bajo (b) o esta correcto (c)?').lower()
  print(feedback, type(feedback))
  if feedback=='h':
    high=propuestaPC - 1
  elif feedback=='b':
    low=propuestaPC + 1
  contador+=1
print(f'El computador adivinó en {contador} intentos, {propuestaPC}, es el  numero secreto')
  

Esto como un segundo proyecto.

Grafico de una Función Cuadrática y Lineal con Python

from matplotlib import pyplot

Función cuadratica

def f1(x):
return( x**2)+(8/3)*x+4

Función Lineal

def f2(x):
return(-3/2)*x + 2

Valores del eje x que toma el grafico

x = range(-5,8)

Graficar ambas funciones

pyplot.plot(x,[f1(i) for i in x])
pyplot.plot(x,[f2(i) for i in x])

Establecer el color en los ejes

pyplot.axhline(0,color=‘black’)
pyplot.axvline(0,color=‘black’)

Limites de los valores de los ejes

pyplot.xlim(-8,9)
pyplot.ylim(-8,9)

Guardar grafico como imagen png

pyplot.savefig(‘output.png’)

Graficando

pyplot.show()

Hola, estoy comenzando en el mundo de la programación.
Mi proyecto consiste en lo siguiente: utilizando la misma lógica de piedra, papel o tijera, escribí un código para el juego sencillo de lanzar una moneda al aire.
En el juego intervienen dos jugadores que colocan sus nombres y escogen una opción (cara o cruz). La computadora simula el lanzamiento de la moneda, cuyo resultado es aleatorio: cara o cruz.
Gana una ronda el jugador, cuya elección es igual a la de la computadora. El ganador final es el que gana primero dos rondas.

Hay varias cosas que mejorar en este juego, por ejemplo, que se pueda intercalar quien escoge primero su opción, para que sea más parecido al juego real.

Este es mi código:

import random

print("TE INVITO A JUGAR CARA O CCRUZ CON UNA MONEDA")

nombre_jugador_1 = input("Eres el jugador 1, cual es tu nombre? => ")
nombre_jugador_2 = input("Eres el jugador 2, cual es tu nombre? => ")


options = ("cara", "cruz")

nombre_jugador_1_wins = 0
nombre_jugador_2_wins = 0

rounds = 1


while True:

  print("*" * 30)
  print('ROUND', rounds)
  print("*" * 30)
  
  print("Hola ", nombre_jugador_1)
  jugador_1 = input("Escoge cara o cruz => ")
  jugador_1 = (jugador_1.lower())

  print("Hola ", nombre_jugador_2)
  jugador_2 = input("Escoge cara o cruz => ")
  jugador_2 = (jugador_2.lower())

  rounds += 1
  
  computadora = random.choice(options)

  print("jugador_1 ", nombre_jugador_1, " escogió => ", jugador_1)
  print("jugador_2 ", nombre_jugador_2, " escogió => ", jugador_2)
  print("computadora => ", computadora)

  if jugador_1 == computadora:
    print("GANÓ => ", nombre_jugador_1)
    nombre_jugador_1_wins += 1

  else:
    print("GANÓ => ", nombre_jugador_2)
    nombre_jugador_2_wins += 1

  if nombre_jugador_1_wins == 2:
    print("EL GANADOR FINAL ES => ", nombre_jugador_1)
    break

  if nombre_jugador_2_wins == 2:
    print("EL GANADOR FINAL ES => ", nombre_jugador_2)
    break
 

Comparto el código para el juego de piedra papel o tijera:

1. El usuario escoge cuantas partidas desea jugar
2. En caso de empate al final de estas partidas, el cliente puede elegir jugar una partida de desempate.
3. Si el usuario escoge una opción no valida, se indica que escoja una opción valida.

import random

print(‘Juego de piedra, papel o tijera\n’)

Escoger la cantidad de partidas a disputar

count = int(input(’¿Cuántas partidas deseas disputar? '))

Contadores para saber las partidas ganadas

resultados_pc = 0
resultados_usuario = 0
resultados_empates = 0

Diccionario para mapear opciones con sus cadenas de texto correspondientes

opciones = {
1: ‘Piedra’,
2: ‘Papel’,
3: ‘Tijera’
}

Verificar la elección del usuario para que sea una de las 3 opciones

def verificar_opcion(opcion):
while opcion not in opciones.keys():
print(‘La opción ingresada no es válida. Por favor, elija una opción disponible.’)
opcion = int(input('Ingrese:\n1 para piedra\n2 para papel\n3 para tijera\nHas elegido: '))
return opcion

#imprimir resultado del PC y el cliente
def imprimir_resultados(usuario, pc):
print(f’\nHas elegido: {opciones[usuario]}’)
print(f’El PC ha elegido: {opciones[pc]}’)

Loop principal para el juego

while True:
for i in range(count):
# Entrada del usuario
usuario = int(input('Ingrese:\n1 para piedra\n2 para papel\n3 para tijera\nHas elegido: '))
usuario = verificar_opcion(usuario)

    # Selección aleatoria del PC
    pc = random.randint(1, 3)

    # Verificación de los resultados
    if pc == usuario:
        imprimir_resultados(usuario, pc)
        print('\nEmpate\n\n')
        resultados_empates += 1
    elif (usuario == 1 and pc == 3) or (usuario == 2 and pc == 1) or (usuario == 3 and pc == 2):
        imprimir_resultados(usuario, pc)
        print('\nHas ganado\n\n')
        resultados_usuario += 1
    else:
        imprimir_resultados(usuario, pc)
        print('\nHas perdido\n\n')
        resultados_pc += 1

print(f'\nUsuario: {resultados_usuario}\nPC: {resultados_pc}\nEmpates: {resultados_empates}')

if resultados_pc == resultados_usuario:
    respuesta = input("Se ha presentado un empate contra el PC. ¿Desea jugar una partida adicional? (s/n) ")
    if respuesta == 's':
        count = 1
        continue
    else:
        break
else:
    break

import random

options = ('piedra', 'papel', 'tijera')

# -1 => draw, 0 => lose, 1 => win
#        piedra papel tijera
# piedra  -1     0      1
# papel    1    -1      0
# tijera   0     1     -1
game_matrix = [[-1,0,1],[1,-1,0],[0,1,-1]]

# lists to save result tuples
user_games_history = []
computer_games_history = []

while len(user_games_history) < 3 and len(computer_games_history) < 3:
    #user selection
    user_option = input('ingrese piedra, papel o tijera =>  ')
    user_option = user_option.lower()

    if not user_option in options:
        print('opción no válida :(')
        continue
    
    #computer selection
    computer_option = random.choice(options)
    result = game_matrix[options.index(user_option)][options.index(computer_option)]

    match result:
        case -1: 
            print('Empate :/ ')
        case 0 :
            print('Perdiste :C ', f' computador: {computer_option}')
            computer_games_history.append((user_option,computer_option))
        case 1 :
            print('Ganaste :) ', f' computador: {computer_option}')
            user_games_history.append((user_option,computer_option))

print('Juego terminado')
print('Resultados de partidas')
games = user_games_history if len(user_games_history) == 3 else computer_games_history
for game in games:
    print(f'Tú: {game[0]}, computador: {game[1]}')

https://replit.com/@marcocarrera/Python-MC#main.py

Les dejo mi aporte de mi juego
Espero les ayude en algo

Les dejo mi codigo. espero les sirva 😃

<import random
import time
resultadoDePartida = "GANASTE"
options = ("piedra","papel","tijeras")
userWins = 0
computerWins = 0 
reinicio = 1
while reinicio == 1:
    rounds = int(input("Introduzca las rondas que desea jugar: "))
    time.sleep(0.7)
    while rounds > 0:
        userOption = (input("seleccione entre piedra, papel o tijeras: "))
        userOption = userOption.lower()
        computerOption = random.choice(options)
        if not userOption in options:
            print("la opcion no es valida")
            break
        else:
            print ("seleccionaste: ",userOption, "la computadora selecciono: ",computerOption)
            time.sleep(0.7)
            if userOption == computerOption:
                print("Es un empate")
                time.sleep(1)
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "piedra" and computerOption == "tijeras"):
                print (resultadoDePartida)
                time.sleep(1)
                userWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "piedra" and computerOption == "papel"):
                print("NO", resultadoDePartida)
                time.sleep(1)
                computerWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "papel" and computerOption == "piedra"):
                print(resultadoDePartida)
                time.sleep(1)
                userWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "papel" and computerOption == "tijeras"):
                print("NO", resultadoDePartida)
                time.sleep(1)
                computerWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "tijeras" and computerOption == "piedra"):
                print("NO", resultadoDePartida)
                time.sleep(1)
                computerWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
            elif (userOption == "tijeras" and computerOption =="papel"):
                print(resultadoDePartida)
                time.sleep(1)
                userWins += 1
                print("puntos del usuario", userWins, "puntos de la computadora", computerWins)
                time.sleep(1)
        rounds -= 1
        print("rondas restantes = ", rounds)
        time.sleep(1)
        print("*"* 70)
    if rounds == 0:
        if userWins > computerWins:
            print("Eres el vencedor. Felicidades!")
        elif userWins < computerWins:
            print("La computadora fue la vencedora")
        elif userWins == computerWins: 
            print("Quedo en empate")
    reinicio -=1
    reinicioTotal = (input("Desea volver a jugar, responda si o no ===> "))
    reinicioTotal = reinicioTotal.lower()
    if reinicioTotal == "si":
        reinicio +=1
        computerWins == 0
        userOption == 0
    else:
        print("gracias por jugar :)") > 

Comparto mi proyecto de piedra, papel o tijera en Python.

import random

options = ('piedra', 'papel', 'tijera')
games = 1
user_wins = 0
comp_wins = 0
print('Hola usuario, este es el juego de Piedra, Papel o Tijera 😊')
print('Tienes 5 posibles juegos para ganarme')
print('si alguno de nosotros gana 3, se acaba el juego. Buena suerte, aunque no será tan fácil')


while games <= 5:
  if  user_wins == 3 or comp_wins == 3:
    break

  print('*'*20, 'JUEGO #', games, '*'*20)

  user_option = input('piedra, papel o tijera => ')
  user_option = user_option.lower()

  while not user_option in options:
    print('esa opción no es válida')
    user_option = input('Escoge bien: piedra, papel o tijera => ')

  computer_option = random.choice(options)

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

  if user_option == computer_option:
    print('empate!')
  elif user_option == 'piedra':
    if computer_option == 'tijera':
      print('piedra gana a tijera')
      print('user ganó!')
      user_wins += 1
    else:
      print('papel gana a piedra')
      print('computer ganó!')
      comp_wins += 1
  elif user_option == 'papel':
    if computer_option == 'piedra':
      print('papel gana a piedra')
      print('user ganó!')
      user_wins += 1
    else:
      print('piedra gana a tijera')
      print('computer ganó!')
      comp_wins += 1
  elif user_option == 'tijera':
    if computer_option == 'papel':
      print('tijera gana a papel')
      print('user ganó!')
      user_wins += 1
    else:
      print('piedra gana a tijera')
      print('computer ganó!')
      comp_wins += 1

  print('_'*20)
  print('Ganadas por el usuario =>', user_wins)
  print('Ganadas por el computador =>', comp_wins)
  if user_wins > comp_wins:
    print('** vas ganando usuario por diferencia de', int(user_wins-comp_wins))
  elif user_wins == comp_wins:
    print('* vamos empatados *')
  else:
    print('** voy ganando por diferencia de', int(comp_wins-user_wins))
  games +=1

print('*'*20)
print('*    GAMES OVER    *')
print('*'*20)
print('ganadas por el usuario =>', user_wins)
print('ganadas por el computador =>', comp_wins)
if user_wins > comp_wins:
  print('GANASTE USUARIO POR', int(user_wins-comp_wins), 'DE VENTAJA')
elif user_wins == comp_wins:
  print('QUEDAMOS EMPATADOS, DEBERÍAMOS SEGUIR JUGANDO, DALE "RUN" OTRA VEZ!')
else:
  print('GANÉ YO EL COMPUTADOR POR', int(comp_wins-user_wins), 'DE VENTAJA')

  

https://replit.com/@JuanferYepes/Python1#main.py

Acá esta mi resultado, debo decir que tomé como ejemplo el 3er código que nos dejaron donde se optimiza el código.
.
Inicialmente lo había hecho de una forma menos optima y me sirvió bastante ver este ejemplo, su lógica es muy buena.

Me apoyé en los proyectos de esta clase. Dejo mi código:

print(“BIENVENIDO AL JUEGO DEL PIEDRA, PAPEL O TIJERA”)
print(“Gana el juego el que gana 3 partidas primero”)
print(" ")

import random

options = (“piedra”, “papel”, “tijera”) # Tupla

computer_wins = 0
user_wins = 0

partida = 1

while True:

print('=' * 60)
print('PARTIDA', partida)
print('=' * 60)

print("Puntos de la computadora -->", computer_wins)
print("Tus puntos -->", user_wins)

user_option = input("Elige tu opción: piedra, papel o tijera --> ")
user_option = user_option.lower()

partida += 1 

# REGLAS

if not user_option in options:
  print("Esa opción no es válida, elige nuevamente")
  print(" ")
  continue
  
computer_option = random.choice(options)

print("Tu elección -->", user_option)
print("Elección de la computadora -->", computer_option)

if user_option == computer_option:
  print("¡Empate!")
  print(" ")
elif user_option == "piedra":
  if computer_option == "tijera":
    print("Piedra gana a tijera")
    print("¡Ganaste!")
    print(" ")
    user_wins += 1
  else:
    print("Papel gana a piedra")
    print("¡Ganó la computadora!")
    print(" ")
    computer_wins += 1
elif user_option == "papel":
  if computer_option == "piedra":
    print("Papel gana a piedra")
    print("¡Ganaste!")
    print(" ")
    user_wins += 1
  else:
    print("Tijera gana a papel")
    print ("¡Ganó la computadora!")
    print(" ")
    computer_wins += 1
elif user_option == "tijera":
  if computer_option == "papel":
    print("Tijera gana a papel")
    print("¡Ganaste!")
    print(" ")
    user_wins += 1
  else:
    print("Piedra gana a tijera")
    print("¡Ganó la computadora!")
    print(" ")
    computer_wins += 1
        
if computer_wins == 3:
    print("*"*40)
    print('La computadora ganó el juego al vencerte en 3 partidas')
    print("*"*40)
    print("Partidas ganadas por la computadora -->", computer_wins)
    print("Partidas ganadas por usted -->", user_wins)
    break

if user_wins == 3:
    print("*"*80)
    print("Ganaste el juego al vencer 3 partidas a la computadora")
    print("*"*80)
    print("Partidas ganadas por usted -->", user_wins)
    print("Partidas ganadas por la computadora -->", computer_wins)
    break

https://replit.com/@Edcastillo23/FundamentosPythonPlatzi?v=1

Hasta ahora va así

Después de sudar, ver errores, buscar en internet y pedir ayuda… Aquí está mi esfuerzo. Estaré atento ante cualquier presencia de errores que perciban o Feedback que quieran dar 😄

import random


options = ("Piedra", "Papel", "Tijera")

numGames = input('¿Cuántas partidas quieres jugar?')

while not numGames.isdigit():
  print("Selecciona un valor numerico")
  numGames = input('¿Cuántas partidas quieres jugar?')

numGames = int(numGames)

while (numGames % 2) != 1:
  print("Ingresa un valor impar")
  numGames= int(input('¿Cuántas partidas quieres jugar?'))
  
necessaryWins = (numGames / 2) + 0.5
botWins = 0
userWins = 0


def jugar():

  randomResult = random.randint(0, 2)
  userResult = input("¿Qué escogerás?")
  userResult = userResult.lower().capitalize()

  while not userResult in options:
    print("Ingresa un dato válido")
    userResult = input("¿Qué escogerás?")
    userResult = userResult.lower().capitalize()
  

  
  def perder():
    print(f"El bot escogió {options[randomResult]} y tú escogiste {userResult}. Perdiste")
    global botWins
    botWins += 1
    
  def ganar():
    print(f"El bot escogió {options[randomResult]} y tú escogiste {userResult}. Ganaste")
    global userWins
    userWins += 1
    
  def empate():
    print(f"El bot escogió {options[randomResult]} y tú escogiste {userResult}. Empate")

  
  if (randomResult == 0 and userResult == "Tijera") or (randomResult == 1 and userResult == "Piedra") or (randomResult == 2 and userResult == "Papel"):
    perder()
  elif (randomResult == 0 and userResult == "Papel") or (randomResult == 1 and userResult == "Tijera") or (randomResult == 2 and userResult == "Piedra"):
    ganar()
  elif (options[randomResult] == userResult):
    empate()

  print(f'El bot ha ganado {botWins}')
  print(f'El usuario ha ganado {userWins}')

while botWins < necessaryWins and userWins < necessaryWins:
  jugar()
  if botWins == necessaryWins:
    print("Esta ronda la ha ganado el bot!")
  elif userWins == necessaryWins:
    print("Esta ronda la has ganado!")

Así quedó mi proyecto! Cualquier recomendación es bienvenida!

import random # random numeric value

options = ('ROCK', 'PAPER', 'SCISSORS')
user_count = 0
computer_count = 0

print("Let's play! The best of 5 rounds wins!")


while user_count < 3 and computer_count < 3: 
  # user and computer option selection:
  user_option = input('Choose one option: ROCK, PAPER, SCISSORS: ').upper()
  computer_option = random.choice(options)

  # to reset the loop if the user doesn't choose a valid option
  if not user_option in options:
    print('Please, choose a right option')
    continue
    
  # conditional to know who wins:
  if user_option == computer_option:
    print("Draw!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'ROCK' and computer_option == 'SCISSORS':
    print("User wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    user_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'ROCK' and computer_option == 'PAPER':
    print("Computer wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    computer_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'PAPER' and computer_option == 'SCISSORS':
    print("Computer wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    computer_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'PAPER' and computer_option == 'ROCK':
    print("User wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    user_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'SCISSORS' and computer_option == 'ROCK':
    print("Computer wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    computer_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')
  elif user_option == 'SCISSORS' and computer_option == 'PAPER':
    print("User wins!")
    print("User option: ",user_option)
    print("Computer option: ",computer_option)
    user_count += 1
    print(f'User: {user_count}')
    print(f'Computer: {computer_count}')

# and the winner is...
if user_count == 3:
  print('User wins!!')
elif computer_count == 3:
  print('Computer wins!!')

Hola! Les comparto mi juego, en el que quien gana es el primero en acertar 3 puntos

import random

options = ('piedra','papel','tijera')
conteo_ganaste=0
conteo_perdiste=0

print('Bienvenido al torneo mundial de piedra papel o tijera: humanos contra máquinas. El ganador será quien gane 3 veces por primera vez. Que la suerte esté de tu lado!')

print('********************************')

while conteo_ganaste<3 and conteo_perdiste<3:
  user_option= input('Piedra, Papel o Tijera => ')
  user_option = user_option.lower()
  
  if (not user_option in options):
    print('esa opción no es válida')
  
  computer_option = random.choice(options)
  
  print('User option =>', user_option)
  print('Computer option =>', computer_option)
  
  
  if user_option == computer_option:
    print('Empate')
    print('Puntos usuario => ', conteo_ganaste)
    print('Puntos computador => ',conteo_perdiste)
    print('********************************')

  elif user_option == 'piedra':
    if computer_option == 'papel':
      print('Papel gana a Piedra')
      print('Perdiste :(')
      conteo_perdiste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      
    else:
      print('Piedra gana a Tijera')
      print('Ganaste!')
      conteo_ganaste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      
  elif user_option == 'papel':
    if computer_option == 'tijera':
      print('Tijera gana a Papel')
      print('Perdiste :(')
      conteo_perdiste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      
    else:
      print('Papel gana a Piedra')
      print('Ganaste!')
      conteo_ganaste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      
  elif user_option == 'tijera':
    if computer_option == 'piedra':
      print('Piedra gana a Tijera')
      print('Perdiste :(')
      conteo_perdiste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      
    else:
      print('Tijera gana a Papel')
      print('Ganaste!')
      conteo_ganaste +=1
      print('Puntos usuario => ', conteo_ganaste)
      print('Puntos computador => ',conteo_perdiste)
      print('********************************')

      

print('**************************')

if conteo_ganaste==3:
  print('Ganaste el torneo!!!')
else:
  print('Perdiste el torneo :(')

Así quedó mi proyecto

Primero le pregunta al usuario cuantos puntos se necesita acumular para ganar el juego, eventualmente le pregunta al usuario por cada turno la opción (piedra, papel o tijera).
Dependiendo de quien gane, muestra un mensaje y los datos del juego actual. Finalmente, le pregunta al usuario si desea jugar o no otra partida.

aqui dejo mi aporte, link como codigo

https://replit.com/@SebastianArena5/Python-Platzi#main.py

import random

options = ("Piedra","Papel","Tijera")

computer_wins = 0
user_wins = 0
draws = 0
round = 1

print("-" * 60)
print(" ")
print("Bienvenido al juego de Piedra, Papel o Tijera!!!")
print(" ")
print("-" * 60)
print(" ")

#Validacion del numero de rondas a jugar
while True:
  max_rounds = input("¿Cuantas rondas quieres jugar? => ")

  if not max_rounds.isnumeric() or int(max_rounds) <= 0:
    print("-" * 60)
    print(" ")
    print("Has elegido una opcion incorrecta, prueba con una nueva")
    print(" ")
    print("-" * 60) 
    print(" ")
    continue

  max_rounds = int(max_rounds)
  print("-" * 60)
  if max_rounds == 1:
    print(f"Jugaremos {max_rounds} ronda. Que gane el mejor :) ")
  else:
    print(f"Jugaremos un total de {max_rounds} rondas. Que gane el mejor :) ")
  break

#Ciclo para jugar la cantidad dicha por max_rounds
while round <= max_rounds:  
  print("-" * 60)
  print(" ")
  print("Resumen de la/las partidas")
  print("Maximo de rondas a jugar =>",max_rounds)
  print("Puntuaciones: ")
  print("-> User Wins => ",user_wins)
  print("-> Computer Wins => ",computer_wins)
  print("-> Empates =>",draws)
  print(" ")
  print("-" * 60)
  print(" ")
  print("*" * 10)
  print("Ronda #",round)
  print("*" * 10)
  print(" ")
  
  user_option = input("Escoge una de las siguientes opciones: piedra, papel o tijera => ")
  user_option = user_option.capitalize()

  round += 1

  if not user_option in options:
    print("Esa opcion no es valida. Las opciones validas son piedra, papel o tijera, intenta de nuevo")
    round -= 1
    continue

  computer_option = random.choice(options)
  print(" ")

  print("User Option =>", user_option)
  print("Computer Option =>", computer_option)
  print(" ")

  if user_option == computer_option:
    print("Empate!")
    print(" ")
    draws += 1
    
  elif user_option == "Piedra":
    if computer_option == "Tijera":
      print("Piedra gana a Tijera")
      print("User gano!")
      print(" ")
      user_wins += 1
      
    else:
      print("Papel gana a Piedra")
      print("Computer gano!")
      print(" ")
      computer_wins += 1
      
  elif user_option == "Papel":
    if computer_option == "Piedra":
      print("Papel gana a Piedra")
      print("User gano!")
      print(" ")
      user_wins += 1
      
    else:
      print("Tijera gana a Papel")
      print("Computer gano!")
      print(" ")
      computer_wins += 1
      
  elif user_option == "Tijera":
    if computer_option == "Papel":
      print("Tijera gana a Papel")
      print("User gano!")
      print(" ")
      user_wins += 1
      
    else:
      print("Piedra gana a Tijera")
      print("Computer gano!")
      print(" ")
      computer_wins += 1

# Validacion de quien gana, junto al resumen total
print("-" * 60)
print(" ")
print("Resumen total de la/las partidas")
print("Rondas jugadas =>",max_rounds)
print("Puntuaciones: ")
print("-> User Wins => ",user_wins)
print("-> Computer Wins => ",computer_wins)
print("-> Empates => ",draws)
print(" ")

if user_wins == computer_wins:
  if draws == 1:
    print(f"Hubo un empate entre User y Computer, cada uno con un total de {user_wins} victorias, junto a {draws} empate")
    print(" ")
    print("-" * 60)
    print(" ")
  else:
    print(f"Hubo un empate entre User y Computer, cada uno con un total de {user_wins} victorias, junto a {draws} empates")
    print(" ")
    print("-" * 60)
    print(" ")
  
    
elif user_wins > computer_wins:
  if draws == 1:
    print(f"Gano el User con {user_wins} victorias sobre la/las {computer_wins} de Computer, junto a {draws} empate")
    print(" ")
    print("-" * 60)
    print(" ")
  else:
    print(f"Gano el User con {user_wins} victorias sobre la/las {computer_wins} de Computer, junto a {draws} empates")
    print(" ")
    print("-" * 60)
    print(" ")
    
else:
  if draws == 1:
    print(f"Gano Computer con {computer_wins} victorias sobre la/las {user_wins} de User, junto a {draws} empates")
    print(" ")
    print("-" * 60)
    print(" ")
  else:
    print(f"Gano Computer con {computer_wins} victorias sobre la/las {user_wins} de User, junto a {draws} empates")
    print(" ")
    print("-" * 60)
    print(" ")

ASI ME QUEDO A MI

import random

options = ('piedra', 'papel', 'tijera')

print('WELCOME TO THE "PIEDRA, PAPEL O TIJERA" GAME')

rounds = int(input('El primero en llegar a cuantos es el ganador? => '))
print('OK! El primero en llegar a', rounds, 'es el ganador')
print("Are you ready? Let's go!")

won = 0
losses = 0

while won < rounds or losses < rounds:
  player = input('Piedra, papel o tijera? -> ')
  player = player.lower()

  if not player in options:
    print('Opcion invalida')
    continue

  computer = random.choice(options)

  print('Elegiste ', player)
  print('Computadora eligio ', computer)

  if player == computer:
    print('EMPATE!  TU:', won, 'COMPUTADORA', losses)
  elif player == 'piedra' and computer == 'tijera' or player == 'papel' and computer == 'piedra' or player == 'tijera' and computer == 'papel':
    won += 1
    print('GANASTE!  TU:', won, 'COMPUTADORA:', losses)
    if won == rounds:
      print('FELICIDADES ERES EL GANADOR')
      break
      
  else:
    losses += 1
    print('PERDISTE!  TU:', won, 'COMPUTADORA:', losses)
    if losses == rounds:
      print('HAZ SIDO DERROTADO')
      break
      

import random
options = (‘piedra’, ‘papel’,’ tijera’)

com_win = 0
user_win =0
rounds = 1

while True:
print(’*’ 10)
print('ROUNDS ‘, rounds)
print(’’ *10)

print('puntos computadora', com_win)
print('puntos del usuario', user_win)
user_opc = input('elija entre piedra, papel o tijera ').lower()
rounds += 1
if user_opc != options:
    print('esa opcion no es valida, por favor elija Piedra, Papel o Tijera')
    continue
com_opc = random.choice(options)
print('opcion de usuario ', user_opc)
print('opcion computadora', com_opc)
if user_opc == com_opc:

    print('empate')
elif user_opc == 'piedra':
    if com_opc == 'tijera':
        print ('piedra gana a tijera')
        print('usuario gana')
        user_win +=1
    else:
        print('papel gana a piedra') 
        print('computadora gano')
        com_win +=1
elif user_opc == 'papel':
    if com_opc == 'piedra':
        print('papel gana a la piedra')
        print('usuario gano')
        user_win +=1
    else:
        print('tijera gana a papel')
        print('computer gana')
        com_win +=1
elif user_opc == 'tijera':
    if com_opc == 'papel':
        print('tijera gana a papel')
        print('usuario gana')
        user_win +=1
    else:
        print('piedra gana a tijera')
        print('computer gana')
        com_win +=1

if com_win == 2:
    print('El ganador absoluto es la computadora')
    break
if user_win == 2:
    print('El ganador absoluto es el usuario')
    break

import random

compu_points = 0
user_points = 0
while abs(compu_points - user_points) < 2:
  option = ("Piedra", "Papel", "Tijera")
  computer_option = random.choice(option)

  user_option = str(input("Elige Piedra, Papel o Tijera: ")).capitalize()
  
  if not user_option in option:
    print("Elije una opcion valida")
  elif user_option == computer_option:
    print(f"Computer:{computer_option}")
    print("Empate!")
  elif computer_option == "Piedra" and user_option == "Tijera":
    print(f"Compurer:{computer_option}")
    compu_points += 1
    print(f"Computer = {compu_points} Tu = {user_points}")
  elif computer_option == "Papel" and user_option == "Piedra":
    print(f"Computer:{computer_option}")
    compu_points += 1
    print(f"Computer = {compu_points} Tu = {user_points}")
  elif computer_option == "Tijera" and user_option == "Papel":
    print(f"Computer:{computer_option}")
    compu_points += 1
    print(f"Computer = {compu_points} Tu = {user_points}")
  else:
    print(f"Computer:{computer_option}")
    user_points += 1
    print(f"Computer = {compu_points} Tu = {user_points}")

if compu_points > user_points:
  print("---Perdiste!---")
else:
  print("---Ganaste!---")

Solución pensada en una matriz de reglas donde la fila corresponde al jugador y la columna al computador:

import random

options = ['papel', 'piedra', 'tijera']
rules = [
    ['Empate', 'Jugador', 'Computador'],
    ['Computador', 'Empate', 'Jugador'],
    ['Jugador', 'Computador', 'Empate']
]
round = 1
computer_points = 0
player_points = 0
continue_game = True

print('Bienvenido al juego piedra, papel o tijera\n')

while continue_game:
    victories = input('Ingresa el número de victorias a jugar: ')
    if not victories.isdigit():
        print('Número de victorias inválido')
        continue
    victories = int(victories)

    while computer_points < victories and player_points < victories:
        print(f"\nRonda: { round }")
        player_opt = input('Jugador: piedra, papel o tijera: ')

        if not player_opt in options:
            print("Opción inválida\n")
            continue

        computer_opt = random.choice(options)
        player_idx = options.index(player_opt)
        computer_idx = options.index(computer_opt)

        result = rules[player_idx][computer_idx]
        if result == 'Computador':
            computer_points += 1
        elif result == 'Jugador':
            player_points += 1

        print(f"Computador: {computer_opt} - Jugador: {player_opt} - Ganador: {result}")
        print(f"Computador: {computer_points} / Jugador: {player_points}")
        round += 1

    if computer_points == 3:
        print("\n¡Lo sentimos, te ha ganado un cerebro positrónico jajajjajja!")
    else:
        print("\n¡Felicitaciones, le has ganado a un cerebro positrónico!")

    retry = input("\n¿Otra ronda? (y/n) ")
    if not retry == 'y':
        continue_game = False

import random


def who_wins(your_option, npc_option):
    play_versus = {
        "rock": {
            "scissors": "won",
            "paper": "lost",
            "rock": "draw"
        },
        "paper": {
            "rock": "won",
            "scissors": "lost",
            "paper": "draw"
        },
        "scissors": {
            "paper": "won",
            "rock": "lost",
            "scissors": "draw"
        }
    }
    return play_versus[your_option][npc_option]


def playGame():
    options = ("rock", "paper", "scissors")
    play = True
    while play:
        print("*" * 6, "Game of rock, paper and scissors", "*" * 6)
        your_option = ""
        while your_option not in options:
            your_option = input("Enter your choice between rock, paper and scissors: ").lower()
        
        npc_option = random.choice(options)
        
        print(f"Your option is {your_option} and the npc option is {npc_option}")

        game_result = who_wins(your_option, npc_option)

        print(f"Your {your_option} {game_result} against the npc {npc_option}")
        print(f"You {game_result} in the game.")

        if input('Enter "yes" to play again: ').lower() != "yes":
            play = False


if __name__ == '__main__':
    playGame()

import random
while True:
print(“Eliga ina opcion\n1) Tijera\n2) Papel\n3) Piedra\n”)
value_user = int(input("El valor es: "))
value_random = random.randint(1,3)
if value_user 1 and value_random2:
print(“Ganaste!!!”)
break
elif value_user == 2 and value_random3:
break
elif value_user == 3 and value_random1:
break
elif value_user == value_random:
print(“Empatee”)
else:
print(“Perdiste \nVuelve a Intentarlo”)

import random

def rps_game():

    #define las opciones diponibles en el juego
    option = ["piedra", "papel", "tijera"]
    games = int(input("Cuantas veces quieres jugar: "))
  
    
    
    user_wins = 0
    pc_wins = 0
    total_games = 0

  

    while total_games < games and user_wins < 3 and pc_wins < 3:
          # Pide al usuario que elija su opcion
        user_selection = input("Elige piedra, papel o tijera: ")
        pc_selection = random.choice(option) 
        print("Elegiste: ", user_selection)
        print("El pc eligio: ", pc_selection)

    
        if user_selection == pc_selection:
            print("Empataste")
        elif user_selection == "piedra" and pc_selection == "tijera":
            print("GANASTE")
            user_wins += 1
        elif user_selection == "tijera" and pc_selection == "papel":
            print("GANASTE")
            user_wins += 1
        elif user_selection == "papel" and pc_selection == "piedra":
            print("GANASTE")
            user_wins += 1
        else:
            print("Perdiste")
            pc_wins +=1
        total_games += 1
    print()
if __name__ == "__main__":
    rps_game()

ronda=1
computer=0
user=0
while ronda<4:
print("")
print("RONDA: ",ronda)
import random
options=(“piedra”,“papel”,“tijera”)
computer_option=random.choice(options)
user_option=input(“piedra, papel o tijera? “)
user_option=(user_option.lower())
if not user_option in options:
print(user_option,” no es válido, no hay juego”)
break
else:
print("computer_option: “,computer_option)
print(“user_option: “,user_option)
if user_optioncomputer_option:
print(“Empate!”)
elif computer_option"piedra” and user_option==“papel”:
print(“papel gana a piedra”)
print(“user ganó!”)
user+=1
elif computer_option==“piedra” and user_option==“tijera”:
print(“piedra gana a tijera”)
print(“computer ganó!”)
computer+=1
elif computer_option==“papel” and user_option==“piedra”:
print(“papel gana a piedra”)
print(“computer ganó!”)
computer+=1
elif computer_option==“papel” and user_option==“tijera”:
print(“tijera gana a papel”)
print(“user ganó!”)
user+=1
elif computer_option==“tijera” and user_option==“piedra”:
print(“piedra gana a tijera”)
print(“user ganó!”)
user+=1
elif computer_option==“tijera” and user_option==“papel”:
print(“tijera gana a papel”)
print(“computer ganó!”)
computer+=1
ronda+=1
print(””)
print("FINAL DE LAS RONDAS: user: “,user,” computer: ",computer)
if user>computer:
print(“user GANOOOO!!!”)
elif computer>user:
print(“computer GANOOOO!!!”)
else:
print(“EMPATEEE!!!”)

Este juego lo hice al principio de la clase, solo quiero sacar el nuevo diploma de python.