No tienes acceso a esta clase

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

Proyecto: aplicando ciclos

38/38
Recursos

Aquí encuentras el próximo curso recomendado de Python: Curso de Python: Comprehensions, Funciones y Manejo de Errores. 💚😉

Aportes 291

Preguntas 19

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

import random 

options = ('piedra', 'papel', 'tijera')
rounds = 1
computer_wins = 0 
user_wins = 0

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

while True:
    print('***' * 10)
    print('Round ', rounds)
    print('***' * 10)
    
    print(f'''
🤖 Computer wins: {computer_wins}
🙋 User wins: {user_wins}
          ''')
    
    user_option = input('>>> Piedra, papel o tijera => ').lower()
    rounds += 1
    
    if not user_option in options:
        print('Esa opción no es valida')
        
    computer_option = random.choice(options)

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

    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
    
    if computer_wins == 3:
        print('🎖️ El ganador es Computer 🎖️')
        break
    
    if user_wins == 3:
        print('🎖️ El ganador es User 🎖️')
        break

Me encantó este proyecto.

Creo que hay un error en el último paso, cuando Nicolás coloca la línea rounds +=1 debajo de las opciones de input del usuario:

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

 rounds += 1  
  
 if not user_option in options:
    print('Esa opción no es válida', '\n')

puesto que al ingresar una opción diferente de las tres (Ej: anillo), seguiría la cuenta de ROUND:

El lugar correcto para colocar la línea mencionada sería por debajo de la sentencia continue:

if not user_option in options:
      print('Esa opción no es válida', '\n')
      continue 

rounds += 1  
    
computer_option = random.choice(options)
print('User options =>', user_option)

y de esta manera, la cuenta del ROUND no se vería afectada al ingresar una opción inválida:

El profesor explicó muy bien! Disculpen si capaz hago preguntas un poco tontas, estoy aprendiendo de a poco y es algo que me está costando pero no quiero bajar los brazos! Quiero seguir porque es algo que me gusta y mucho (Aunque recién empiezo) Es algo que me atrapó desde la primera clase. Gracias Platzi por darme la posibilidad de poder tomar un curso como éstos totalmente gratis. Fue una gran ayuda para mí ya que en estos momentos no podría haberlo cursado sin ustedes y el PlatziDay.

Infinitas gracias! Que todo lo bueno que den les vuelva triplicado.

Saludos

import random

i=1
user_gana = 0
computer_gana = 0

while i<4:
  print("RONDA {}" .format(i))
  user_option = input("piedra, papel o tijera: ")
  options = ("piedra", "papel", "tijera")
  computer_option = random.choice(options)
  print("el computador eligio: {}".format(computer_option))
  
  if user_option == computer_option:
    print("empate")
  elif user_option == "piedra":
    if computer_option == "tijera":
      print("ganaste")
      user_gana += 1
    else:
      print("perdiste")
      computer_gana += 1
  elif user_option == "papel":
    if computer_option == "tijera":
      print("perdiste")
      computer_gana += 1
    else:
      print("ganaste")
      user_gana += 1
  elif user_option == "tijera":
    if computer_option == "papel":
      print("ganaste")
      user_gana += 1
    else:
      print("perdiste")
      computer_gana += 1
  else:
    print("opción incorrecta")

  print("****"*10)

  i+=1

if user_gana > computer_gana:
  print("el ganador es user")
else:
  print("el ganador es computer")


En la clase del profesor indica que es True. Soporte ayuda

tambien hay un cuirso de free code camp en espa;ol en youtube

https://www.youtube.com/watch?v=DLikpfc64cA&list=PL4ONm-ifcbQKNVdqTi8Ky5CqQuFrxebM7

El examen no está optimizado para móvil, no se ven las imágenes

Aqui les dejo mi aporte, trate de evitar los if y manejar las respuestas a traves del uso de las listas

import random

#definimos las opciones y los posibles resultados
options = ('piedra','papel', 'tijera')
user_points = 0
computer_points = 0
results = [
['piedra','piedra'],[0,0],
['papel','papel'],[0,0],
['tijera','tijera'],[0,0],
['piedra', 'papel'],[0,1],
['piedra','tijera'],[1,0],
['papel','piedra'],[1,0],
['papel','tijera'],[0,1],
['tijera','papel'],[1,0],
['tijera','piedra'],[0,1]
]

#primero hacemos la prueba para un caso especifico
#user_option = "tijera"
#computer_option = "piedra"

#Hacemos el juego repetible hasta los 2pts
round = 0
while user_points < 2 and computer_points < 2:

  #Definimos las respuestas de cada jugador
  computer_option = random.choice(options)
  user_option = input('Elige piedra, papel o tijera => ')
  user_option = user_option.lower()

  #Controlamos que los campos incertados sean correctos
  while user_option != 'piedra' and user_option != 'papel' and user_option != 'tijera':
    print('Por favor, elige una alternativa correcta')
    user_option = input('Elige piedra, papel o tijera => ')
    user_option = user_option.lower()
  
  #Le damos formato al juego
  round = round +1
  print('*'*10)
  print('ROUND ', round)
  print('*'*10)  
    
  #Creamos una lista con la combinacion elegida del juego
  game_combination = [user_option, computer_option] 
  #Mostramos al usuario las elecciones del juego
  print('Usted eligio',user_option)
  print('La computadora eligio', computer_option)

  #Esto me da la posicion donde se encuentra la combinacion de puntos a repartir
  winner_combination = results.index(game_combination) +1

  if user_option == computer_option:
    print("It's a tie")
    
  #Mostramos los resultados del juego
  print('In this game you earned', results[winner_combination][0], 'pts')
  print('In this game computer earned', results[winner_combination][1], 'pts')
  
  #Agregamos los puntos obtenidos
  user_points += results[winner_combination][0]
  computer_points += results[winner_combination][1]

  #Mostramos al usuario el resultado acumulado de los juegos
  print('You have ', user_points, 'pts')
  print('Computer has ', computer_points, 'pts')
  if user_points < 2 and computer_points < 2:
    print("Let's play again :) ")
  elif user_points == 2 or computer_points == 2:
    print('Game Over')
    print('_'*10)
    if user_points > computer_points:
      print("You Win :) ")
      print('-'*10)
    else: 
      print("Computer Wins :( ")
      print('_'*10)

XD ![](https://static.platzi.com/media/user_upload/image-879af388-b335-473b-a1b7-7c9794b2e331.jpg)

test final respuests
Resumen
1.
¿Para qué sirve type() en Python?

Indica el tipo de dato de una variable u objeto.
2.
¿Qué obtenemos al utilizar el operador + en strings? Por ejemplo:

‘Hola,’ + " " + 'Platzinauta’
Se concatena las cadenas de texto.
3.
¿Cuál es el tipo de dato float?
Es el tipo de dato con el se representa cualquier número. Por ejemplo, 9, 10.27, 7.679.

REPASAR CLASE
4.
¿Cuál es el tipo de dato int?
Tipo de dato con el que se representan números enteros. Por ejemplo, 19.

¿Qué se obtiene al ejecutar la siguiente conversión en Python?

carbon.png
4
6.
¿Qué se obtiene al ejecutar la siguiente línea en Python?

print((8 / 2) + 4 * 8)
Considera el orden en que se ejecutan los operadores aritméticos.

36
7.
¿Para qué sirven los operadores aritméticos en Python?
Para ejecutar operaciones matemáticas fundamentales como suma, resta, multiplicación y división.
8.
¿Cuál es el resultado de la siguiente comparación en Python?

8000 > 3330
True

¿Qué resultaría de la siguiente expresión lógica en Python?
carbon (9).png

False

¿Qué resultaría de la siguiente expresión lógica en Python?

carbon (10).png
True

¿Para qué se usa el operador not en Python?

Para negar un valor booleano dentro del programa.
12.
¿Para qué se utilizan condicionales como if en un programa?

Para que el programa decida ejecutar una parte del programa con base en si se cumple una condición.
13.
¿Cuál es el resultado de la siguiente condicional en Python?

carbon (6).png
Welcome to New York City
14.
¿Para qué se utiliza el método lower() en Python?

Para pasar toda un string a minúsculas.
15.
¿Qué se obtiene al ejecutar el siguiente código con el método replace() en strings en Python?

carbon (8).png
Juan Salvador
16.
¿Qué se obtiene al ejecutar primos[3] si tenemos la siguiente lista de Python?
primos = [2, 3, 5, 7, 11, 13, 17, 19]

3
REPASAR CLASE
17.
¿Qué es una lista en Python?
Son un tipo de datos donde se pueden almacenar colecciones de datos de cualquier tipo.
18.
¿Qué se obtiene al ejecutar lo siguiente en una lista de Python?
carbon (2).png

[‘MX’, ‘CO’, ‘PE’, ‘AR’, ‘ES’, 'BR, ‘CL’]
19.
¿Cuál es la principal diferencia entre una tupla y una lista en Python?
Las tuplas son inmutables y en las listas sí podemos modificar sus elementos.
20.
¿Cuál es la forma correcta de crear un diccionario en Python?
inventory = {‘televisions’: 100, ‘computers’: 45, ‘smartphones’: 200, ‘tablets’: 34}
21.
¿Para qué sirven los diccionarios en Python?
Para guardar valores a los que podamos acceder fácilmente con su llave.
22.
¿Qué se obtiene al ejecutar el siguiente ciclo while en Python?
carbon (1).png

Imprimirá “La población es menor a la esperada” mientras suma 0.05 a la variable population hasta que su valor sea de 8.85. En ese momento termina el ciclo e imprimirá “La población es de 8.85 millones de habitantes”.
23.
¿Qué se obtiene al ejecutar el siguiente ciclo for en Python?

carbon (11).png
Imprimirá uno por uno de los elementos de la lista en Python. Itera dentro de la lista.
24.
¿Cuál es la diferencia entre un ciclo for y un while?

Con el ciclo for tenemos definido cuántas veces iteramos, mientras que en el while es indefinido hasta que se cumpla la condición que indica.
Ver menos

Por favor prueben mi código y denme su retroalimentación.

https://replit.com/@NicoleVasconez1/Python#main.py

Excelente

import random

#opciones de la pc almacenadas como tuplas
option = ("piedra", "papel", "tijera")
puntos_user = 0
puntos_pc = 0

print("El primero en llegar a 3 puntos gana!")

while (puntos_user < 3 and puntos_pc < 3):
  user_option = input("Piedra, papel o tijera => ")
  user_option = user_option.lower()
  #pasa la respuesta del user a minus

  if not user_option in option:
    print("Así no se puede jugar :(")
    continue

  #elección aleatoria de la pc
  pc = random.choice(option)

  #imprimir un espacio y las opciones de cada uno
  print(" ")
  print("Jugador elije => ", user_option)
  print("PC elije => ", pc)
  
  if user_option == pc:
    print("Empate!")
  elif user_option == "piedra":
    if pc == "tijera":
      print("El jugador gana la ronda!")
      puntos_user += 1
    else:
      print("La PC gana la ronda!")
      puntos_pc += 1
  elif user_option == "tijera":
    if pc == "papel":
      print("El jugador gana la ronda!")
      puntos_user += 1
    else:
      print("La PC gana la ronda!")
      puntos_pc += 1
  elif user_option == "papel":
    if pc == "piedra":
      print("El jugador gana la ronda!")
      puntos_user += 1
    else:
      print("La PC gana la ronda!")
      puntos_pc += 1
  else:
    print(":(")

  #contador total
  print(" ")
  print("Jugador = ", puntos_user, "PC = ", puntos_pc)
  if puntos_user > puntos_pc:
    print("El Jugador va ganando!")
  elif puntos_user < puntos_pc:
    print("La PC va ganando!")
  else:
    print("El Jugador y la PC están empatados!")

print(" ")
if puntos_user > puntos_pc :
  print ("¡¡¡El Jugador ganó!!!")
else:
  print ("¡¡¡La PC ganó!!!")
print ("__________________________")  

Mi aporte:

import random

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

scoring_dict = {
    'Jugador1' : 0,
    'Jugador2' : 0
}

def play_function(dict_play, winning_move):
    for key, value in dict_play.items():
        if value == winning_move:
            winner = key
    return winner


while scoring_dict['Jugador1'] < 2 and scoring_dict['Jugador2'] < 2:
    # Elección jugador 1
    player1 = input('¿piedra, papel o tijera?').lower()
    # Jugada no valida
    if player1 not in game_options:
        print(player1, ' no es una opción de juego valida')
    else:
        # Elección jugador 2
        player2 = random.choice(game_options) 
        print(player1, ' vs ', player2) 
        # Diccionario con las jugadas
        game_dict = {
            'Jugador1' : player1,
            'Jugador2' : player2
        }
        # Evaluar resultados
        winner = ''
        if player1 == player2:
            print('No hay puntos')
            print(scoring_dict)
        elif (player1 == 'tijera' and player2 == 'papel') or (player2 == 'tijera' and player1 == 'papel'):
            winner = play_function(game_dict,'tijera')
            print('Tijera corta a papel, gana: ' + winner)
            scoring_dict[winner] += 1
            print(scoring_dict)
        elif (player1 == 'tijera' and player2 == 'piedra') or (player2 == 'tijera' and player1 == 'piedra'):
            winner = play_function(game_dict,'piedra')
            print('Piedra destruye a tijera, gana: ' + winner)
            scoring_dict[winner] += 1
            print(scoring_dict)
        elif (player1 == 'papel' and player2 == 'piedra') or (player2 == 'papel' and player1 == 'piedra'):
            winner = play_function(game_dict,'papel')
            print('Papel envuelve a la piedra, gana: ' + winner)
            scoring_dict[winner] += 1
            print(scoring_dict)
        if scoring_dict['Jugador1'] == 2 or scoring_dict['Jugador2'] == 2:  
            supreme_winner = play_function(scoring_dict, 2) 
            print('')
            print('El juego ha terminado, gana: ¡' + supreme_winner + '!')    
    print('')

#vamos hacer un juego con los condicionales como proyecto final
import random

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

computer_wins = 0
user_wins = 0

contador = 1

while True:
print("" * 10)
print(“ROUND”, contador)
print("
" * 10)

print(“computer_wins”, computer_wins)
print(“user_wins”, user_wins)

user_option = input(“piedra,papel,tijera=>”)
user_option = user_option.lower()
#no emtedi para que era este otro asi que lo comnte ya que prefiero hacer lass cosa a mis estilocontador+= 1

if not user_option in options:
print(“esa opcion no es valida”)
continue

cumputer_option = random.choice(options)

print(“user option =>”, user_option)
print(“cumputer_option=>”, cumputer_option)

if user_option == cumputer_option:
print(“empate!”)
#vemos los if internos
elif user_option == “papel”:
if cumputer_option == “tijera”:
print(“tijera le gana a papel”)
print(“computer gana!”)
computer_wins += 1
#con esta ultima parte ya hicimos la logica del juego
else:
print(“papel le gana a piedra”)
print(“user gano!”)
user_wins += 1
elif user_option == “papel”:
if cumputer_option == “piedra”:
print(“papel gana a piedra”)
print(“user gana!”)
user_wins += 1
else:
print(“tijera gana a papel”)
print(“cumputer gano!”)
computer_wins += 1
elif user_option == “tijera”:
if cumputer_option == “papel”:
print(“tijera gana a papel”)
print(“user gano!”)
user_wins += 1
else:
print(“papel gana a piedra”)
print(“cumputer gano”)
computer_wins += 1

if user_wins == 2:
print("" * 10)
print(“EL GANADOR FUE NI MA NI MENOS QUE EL USARIO”)
print(“FELICIDADES”)
print("
" * 10)
break

if computer_wins == 2:
print("" * 10)
print(“EL GANADOR FUE NI MA NI MENOS QUE EL CUMPUTADOR”)
print(“FELICIDADES”)
print("
" * 10)
break

contador += 1

Muchas gracias profesor, excelente curso!!! nos vemos en el siguiente.

comparto el mio 😃


import random

options_list = ('rock', 'paper', 'scissors')

machine_wins = 0
user_wins = 0

while machine_wins <3 and user_wins <3:

  
  #elegimos nuestra opcion de la lista disponible
  user_option = input('\nChoose a option: rock, paper, scissors: \n').lower()
  if user_option not in options_list:
    print('Choose a correct option')
  

  ##La maquina elige su opcion
  machine_option = options_list[random.randint(0, len(options_list)-1)]
  print('La maquina escogio: ' + machine_option)
  
  ##Ahora debemos comparar ambas opciones
  if user_option == 'rock' and machine_option == 'rock':
    print('Empate!!')
  elif user_option == 'rock' and machine_option == 'paper':
    print('La maquina Gana!!')
    machine_wins += 1
    print(machine_wins)
  elif user_option == 'rock' and machine_option == 'scissors':
    print('El humano Gana!!')
    user_wins+=1
    print(user_wins)
  elif user_option == 'paper' and machine_option == 'paper':
    print('Empate!!')
  elif user_option == 'paper' and machine_option == 'rock':
    print('El humano Gana!!')
    user_wins+=1
    print(user_wins)
  elif user_option == 'paper' and machine_option == 'scissors':
    print('La maquina Gana!!')
    machine_wins += 1
    print(machine_wins)
  elif user_option == 'scissors' and machine_option == 'paper':
    print('El humano Gana!!')
    user_wins+=1
    print(user_wins)
  elif user_option == 'scissors' and machine_option == 'rock':
    print('La maquina Gana!!')
    machine_wins += 1
    print(machine_wins)
  elif user_option == 'scissors' and machine_option == 'scissors':
    print('Empate!!')

if user_wins > 2:
  print("Felicidades Humano ganaste el juego!!")
elif machine_wins > 2:
  print("Felicidades Maquina Ganaste el juego!!")

Fue un curso bastante ágil y útil, pues me motivó a retomar el lenguaje y a reforzar mi objetivo de entrarle al data science con todo este año.

`Asi esta mi codigo antes de ver la clase:` ```js import random options = ("rock", "paper", "scissors") user_wins = 0 pc_wins = 0 ties = 0 while user_wins < 2 and pc_wins < 2: user_option = input("Select rock, paper or scissors: ").lower() pc_option = random.choice(options) if not user_option in options: print("Insert a correct option") else: print(f"User option: {user_option}") print(f"Pc option: {pc_option}") if user_option == pc_option: print("Tie") ties += 1 elif (user_option == "rock" and pc_option == "paper") or (user_option == "scissors" and pc_option == "rock") or (user_option == "paper" and pc_option == "scissors"): print('Pc won') pc_wins += 1 elif (pc_option == "rock" and user_option == "paper") or (pc_option == "scissors" and user_option == "rock") or (pc_option == "paper" and user_option == "scissors"): print('You won') user_wins += 1 print("User wins:", user_wins) print("Pc wins:", pc_wins) print("Ties:", ties) if user_wins > pc_wins: print("YOU WON!") else: print("YOU LOOSE!") ```
Gracias a este curso pude aprender las bases de como funciona python, yo ya tenia experiencia en otros lenguajes como java, js, c++. Por lo que entenderlo es basicamente lo mismo pero con otra forma. Ahora pude realizar un pequeño analizador lexico de forma muy sencilla que requeria mi profesor de lenguajes y automatas. No les voy a mentir no me salió a la primera pero programar en saber leer errores y ya con eso tienes mucha ventaja. Aqui les dejo el codigo en python y una captura de los resultados. ```js matrizErrores = [[1, 2, 3, 4, 5, 6, 7, 507], [1, 500, 500, 500, 500, 500, 500, 500], [501, 501, 501, 501, 501, 501, 501, 501], [502, 502, 502, 502, 502, 502, 502, 502], [503, 503, 503, 503, 503, 503, 503, 503], [504, 504, 504, 504, 504, 504, 504, 504], [505, 505, 505, 505, 505, 6, 7, 505], [507, 507, 507, 507, 507, 8, 507, 507], [506, 506, 506, 506, 506, 8, 506, 506]] #creamos una matriz de estados finales listTest = ['(', ')','A','3', '%'] # creamos una lista con los caracteres que queremos comprobar AP = 0 #va a apuntar a la posicion de la lista listTest iteracion = 0 #nos sirve para saber en que iteracion estamos def inspecciona(): global AP if len(listTest) <= AP: return 7 elif listTest[AP].isalpha(): return 0 elif listTest[AP] == '(': return 1 elif listTest[AP] == ')': return 2 elif listTest[AP] == ',': return 3 elif listTest[AP] == ';': return 4 elif listTest[AP].isdigit(): return 5 elif listTest[AP] == '.': return 6 else: return 7 #Dependiendo del valor que tenga AP es la posicion que va a analizar de la lista listTest y la va a evaluar con alguna de las condiciones del alfabeto de la tabla de estados def avanza(): #funcion que avanza en la lista listTest global AP AP += 1 def analizadorLexico(): #Basicamente recibe el estado y columna de la matriz de estados finales y devuelve el estado siguiente, si el estado siguiente es menor a 500 entonces se detiene el ciclo y retorna el estado nuevo estado = 0 c = inspecciona() #5 global iteracion nuevo_estado = matrizErrores[estado][c] #[0][5]]=6 while nuevo_estado < 500: avanza() #=> . siguiente: 6 siguiente print('iteracion=>', iteracion, 'estado=>', estado, 'c=>', c, 'matriz=>', matrizErrores[estado][c], 'nuevo_estado=>', nuevo_estado) c = inspecciona() #=> 6 siguiente:5 estado = nuevo_estado #=> 6 siguiente: 7 nuevo_estado = matrizErrores[estado][c] # => matriz[7][5] = 8 print('estado=>', estado, 'c=>', c, 'matriz=>', matrizErrores[estado][c], 'nuevo_estado=>', nuevo_estado) #=>7 iteracion += 1 return nuevo_estado def analizadorSintactico(): #mientras token sea diferente del estado final 507, se va ir imprimiendo los tokens token = 0 statEnd = 507 while token != statEnd: token = analizadorLexico() print(token) print('---------------------------------------------------------') analizadorSintactico()#mandamos a llamar a la funcion que analiza el token ```matrizErrores = \[\[1, 2, 3, 4, 5, 6, 7, 507], \[1, 500, 500, 500, 500, 500, 500, 500], \[501, 501, 501, 501, 501, 501, 501, 501], \[502, 502, 502, 502, 502, 502, 502, 502], \[503, 503, 503, 503, 503, 503, 503, 503], \[504, 504, 504, 504, 504, 504, 504, 504], \[505, 505, 505, 505, 505, 6, 7, 505], \[507, 507, 507, 507, 507, 8, 507, 507], \[506, 506, 506, 506, 506, 8, 506, 506]] #creamos una matriz de estados finales listTest = \['(', ')','A','3', '%'] # creamos una lista con los caracteres que queremos comprobar AP = 0 #va a apuntar a la posicion de la lista listTest iteracion = 0 #nos sirve para saber en que iteracion estamos def inspecciona(): global AP if len(listTest) <= AP: return 7 elif listTest\[AP].isalpha(): return 0 elif listTest\[AP] == '(': return 1 elif listTest\[AP] == ')': return 2 elif listTest\[AP] == ',': return 3 elif listTest\[AP] == ';': return 4 elif listTest\[AP].isdigit(): return 5 elif listTest\[AP] == '.': return 6 else: return 7 \#Dependiendo del valor que tenga AP es la posicion que va a analizar de la lista listTest y la va a evaluar con alguna de las condiciones del alfabeto de la tabla de estados def avanza(): #funcion que avanza en la lista listTest global AP AP += 1 def analizadorLexico(): #Basicamente recibe el estado y columna de la matriz de estados finales y devuelve el estado siguiente, si el estado siguiente es menor a 500 entonces se detiene el ciclo y retorna el estado nuevo estado = 0 c = inspecciona() #5 global iteracion nuevo\_estado = matrizErrores\[estado]\[c] #\[0]\[5]]=6 while nuevo\_estado < 500: avanza() #=> . siguiente: 6 siguiente print('iteracion=>', iteracion, 'estado=>', estado, 'c=>', c, 'matriz=>', matrizErrores\[estado]\[c], 'nuevo\_estado=>', nuevo\_estado) c = inspecciona() #=> 6 siguiente:5 estado = nuevo\_estado #=> 6 siguiente: 7 nuevo\_estado = matrizErrores\[estado]\[c] # => matriz\[7]\[5] = 8 print('estado=>', estado, 'c=>', c, 'matriz=>', matrizErrores\[estado]\[c], 'nuevo\_estado=>', nuevo\_estado) #=>7 iteracion += 1 return nuevo\_estado def analizadorSintactico(): #mientras token sea diferente del estado final 507, se va ir imprimiendo los tokens token = 0 statEnd = 507 while token != statEnd: token = analizadorLexico() print(token) print('---------------------------------------------------------') analizadorSintactico()#mandamos a llamar a la funcion que analiza el token ![](https://static.platzi.com/media/user_upload/image-d693d851-27fd-4c5f-90b4-ad40247074d0.jpg)
#Tijera corta a papel, papel tapa a piedra, piedra aplasta a lagarto, lagarto envenena a Spock, Spock rompe a tijera, tijera decapita a lagarto, lagarto devora a papel, papel desautoriza a Spock, Spock vaporiza a piedra, y como siempre, piedra aplasta a tijera

import random

# Asignación de emojis a cada opción
emojis = {
  "piedra": "✊",
  "papel": "✋",
  "tijera": "✌️",
  "lagarto": "🦎",
  "spock": "🖖"
}

def obtener_opcion_usuario():
    opciones = ["piedra", "papel", "tijera", "lagarto", "spock"]
    mensaje_opciones = ", ".join([f"{emojis[op]} ({op})" for op in opciones])
    
    while True:
        opcion_usuario = input(f"Elige una opción ({mensaje_opciones}): ").lower()
        if opcion_usuario in opciones:
            return opcion_usuario
        else:
            print("Opción inválida. Inténtalo de nuevo.")

def obtener_opcion_computadora():
    opciones = ["piedra", "papel", "tijera", "lagarto", "spock"]
    return random.choice(opciones)

def determinar_ganador(opcion_usuario, opcion_computadora):
    reglas_para_ganar = {
      "piedra": ["tijera", "lagarto"],
      "papel": ["piedra", "spock"],
      "tijera": ["papel", "lagarto"],
      "lagarto": ["papel", "spock"],
      "spock": ["piedra", "tijera"]
    }

    if opcion_usuario == opcion_computadora:
        return "Empate"
    elif opcion_computadora in reglas_para_ganar[opcion_usuario]:
        return "Ganaste"
    else:
        return "Perdiste"

def jugar_varias_veces(numero_de_veces):
    victorias_usuario = 0
    victorias_computadora = 0

    for _ in range(numero_de_veces):
        opcion_usuario = obtener_opcion_usuario()
        opcion_computadora = obtener_opcion_computadora()

        print(f"Tú elegiste: {opcion_usuario} {emojis[opcion_usuario]}")
        print(f"La computadora eligió: {opcion_computadora} {emojis[opcion_computadora]}")

        resultado = determinar_ganador(opcion_usuario, opcion_computadora)
        print(resultado)

        if resultado == "Ganaste":
            victorias_usuario += 1
        elif resultado == "Perdiste":
            victorias_computadora += 1

    print(f"\nResultado final después de {numero_de_veces} rondas:")
    print(f"Victorias del usuario: {victorias_usuario}")
    print(f"Victorias de la computadora: {victorias_computadora}")

if __name__ == "__main__":
    while True:
        try:
            numero_de_veces = int(input("¿Cuántas rondas quieres jugar? "))
            jugar_varias_veces(numero_de_veces)
            break
        except ValueError:
            print("Por favor, introduce un número válido.")

Excelente profesor, excelente curso

Comparto mis apuntes en Notion

import random
target = 1
roundWinC = 0
roundWinU = 0
while roundWinU <= target and roundWinC <= target :
userOption = input(‘Eleccion ‘).title()
option = [‘Piedra’,‘Papel’,‘Tijera’]
computerOption = random.choice(option)
if userOption in option:
print(f’La eleccion de usuario fue {userOption} y la de la maquina fue {computerOption}’)
if userOption != computerOption:
print(f’----------> {userOption} contra {computerOption} <----------’)
if computerOption == ‘Papel’ and userOption != ‘Tijera’:
print(f’gana Maquina con {computerOption}’)
roundWinC += 1
elif computerOption == ‘Papel’ and userOption == ‘Tijera’:
print(f’gana user con {userOption}’)
roundWinU += 1
elif computerOption == ‘Tijera’ and userOption != ‘Piedra’:
print(f’gana Maquina con {computerOption}’)
roundWinC += 1
elif computerOption == ‘Tijera’ and userOption == ‘Piedra’:
print(f’gana user con {userOption}’)
roundWinU += 1
elif computerOption == ‘Piedra’ and userOption != ‘Papel’:
print(f’gana Maquina con {computerOption}’)
roundWinC += 1
elif computerOption == ‘Piedra’ and userOption == ‘Papel’:
print(f’gana user con {userOption}’)
roundWinU += 1
else:
print(‘sigue Jugando misma eleccion’)
else:
print(f’{userOption} no es una opcion del juego la opciones son {option}’)
print(f’Asi vamos Computer con {roundWinC} y User con {roundWinU}’)
if roundWinU > target:
print(f’Gana User’)
elif roundWinC > target:
print(f’Gana Maquina’)

import random

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

computer_wins=0
user_wins =0
round = 1

while True:

  print("x" * 10)
  print("ROUND", round)
  print("x" * 10)

  print("computer_wins", computer_wins)
  print("user_wins", user_wins)

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

  round += 1
  
  if not user_option in options:
    print("Esa opcion no es validad")
    continue
  
  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 gana")
      user_wins += 1
    else:
      print("papel gana a piedra")
      print("computer gana")
      computer_wins += 1
  elif user_option == "papel":
    if computer_option == "piedra":
      print("papel gana a piedra")
      print("User gana")
      user_wins += 1
    else:
      print("tijera gana a papel")
      print("Computer gana")
      computer_wins += 1
  elif user_option == "tijera":
    if computer_option == "papel":
      print("tijera gana a papel")
      print("Users gana")
      user_wins += 1
    else:
      print("piedra gana a tijera")
      print("Computer gana")
      computer_wins += 1


  if computer_wins == 2:
      print("x" * 10)
      print("La computadora gana")
      print("x" * 10)
      break
  if user_wins == 2:
      print("x" * 10)
      print("El usuario gana")
      print("x" * 10)
      break

from ast import While
from random import choice

round = 1
wins_user = 0
wins_computer = 0

while True:
    print('*' * 20)
    print(f'ROUND {round}')
    print('*' * 20)
    print(f'Marcador \n Computer: {wins_computer} \n User:{wins_user}')
    round += 1

    # Selección Piedra, Papel o Tijera
    user_option = input('Elije entre piedra, papel o tijera:')
    user_option = user_option.lower()
    computer_option = choice(['piedra', 'papel', 'tijera'])

    #Casos de Victoria
    caso1 = computer_option == 'piedra' and user_option == 'papel'
    caso2 = computer_option == 'papel' and user_option == 'tijera'
    caso3 = computer_option == 'tijera' and user_option == 'piedra'

    #Caso de Empate
    Caso4 = computer_option == user_option

    if caso1 or caso2 or caso3: 
        print(f'la computadora saco: {computer_option}')
        print('Ganaste')
        wins_user += 1 
    elif Caso4:
        print(f'la computadora saco: {computer_option}')
        print('Empate')
    else:
        print(f'la computadora saco: {computer_option}')
        print('Perdiste')
        wins_computer +=1

    if wins_user == 2 or wins_computer ==2:
        break

Mi aporte:

import random
options = ('piedra','papel','tijera')
u_wins = 0
c_wins = 0
counter = 0
repeat = 30
number_wins = 2
while True:
    counter += 1
    u_temp = u_wins
    print("*"*repeat)
    print("\n\tRound ",counter,"\n")
    print("*"*repeat)
    u_option = input("Piedra, Papel o Tijera => ").lower()
    c_option = random.choice(options)
    print(">>> Computer option: "+c_option)
    print(">>> User option: "+u_option)
    if(not u_option in options):
        print("La opcion "+u_option+" no es correcta")
        continue
    if(u_option == c_option):
        print("·"*repeat)
        print("\tEMPATE")
        print("·"*repeat)
        continue
    if(u_option == 'piedra'):
        u_wins += 1 if c_option == 'tijera' else 0
        c_wins += 1 if c_option == 'papel' else 0
    elif(u_option == 'papel'):
        u_wins += 1 if c_option == 'piedra' else 0
        c_wins += 1 if c_option == 'tijera' else 0
    else:
        u_wins += 1 if c_option == 'papel' else 0
        c_wins += 1 if c_option == 'piedra' else 0
    print((u_option if u_wins > u_temp else c_option )+" gana a "+(c_option if u_wins > u_temp else u_option ))
    print("·"*repeat)
    print("\tGANA ",('USER' if u_wins > u_temp else 'COMPUTER' ))
    print("·"*repeat)
    if u_wins >= number_wins or c_wins >= number_wins:
        print("="*repeat)
        print("RESULTADO FINAL:\n\tUSER => ",u_wins,"\n\tCOMPUTER => ",c_wins)
        break

Aquí mi código :


# importación de modulos
from random import choice

print(
    """
_______________________________________________

reglas del juego 
_______________________________________________

piedra gana a tijeras
tijeras gana a papel
papel gana piedra
________________________________________________
""")

# ajustes de la partida
round = 1
rondasPc = 0
rondasPlayer = 0
rondasParaGanar = int(input ('rondas que se deben ganar '))

while True:
    # Intro
    print(f"""------------------------------------
    RONDA NUMERO {round}
    ---------------------------------------------
    """)

    print(f"""-----------------------------------
    El marcador va  player {rondasPlayer} , {rondasPc} pc
    ----------------------------------------------
    """)

    # eleccion de los jugadores
    playerOption = input(
        'elige una de las siguientes opciones. piedra, papel o tijeras:')
    options = ('piedra', 'papel', 'tijeras')
    pcOption = choice(options)

    # preprocesamiento de la elección de los jugadores
    playerOption = playerOption.replace(' ', '')
    playerOption = playerOption.lower()

    # comprobacion de opciones validas pj1
    if playerOption in options:
        correctj1 = True
    else:
        correctj1 = False

    # logica del juego
    if not correctj1:
        mensaje = f'error, !!!!!!!!!! {playerOption} es una opción invalida, volver a elegir !!!!!!!'
        print(mensaje)
    else:
        # condiciones del juego con las cuales el jugador  gana
        condicion1 = playerOption == 'tijeras' and pcOption == 'papel'
        condicion2 = playerOption == 'papel' and pcOption == 'piedra'
        condicion3 = playerOption == 'piedra' and pcOption == 'tijeras'
        condiciones = condicion1 or condicion2 or condicion3

        if condiciones:
            mensaje = f' resultado: el jugador 1 gana el match con {playerOption} contra {pcOption} del pc'
            rondasPlayer = rondasPlayer + 1

        if playerOption == pcOption:
            mensaje = f' resultado: match empatado con {pcOption}'
        elif not condiciones:
            mensaje = f' resultado: el pc gana el match con {pcOption} contra {playerOption} del jugador'
            rondasPc = rondasPc + 1

        print(mensaje)

        if rondasParaGanar == rondasPc or rondasParaGanar == rondasPlayer:
            break

        round = round + 1

```python import random print("🤖 Bienvenido al juego de piedra, papel o tijera \n") options = ["piedra", "papel", "tijera"] user_count = 0 computer_count = 0 while user_count < 2 and computer_count < 2: try: user_option = input("👉 Elige una opción (piedra, papel o tijera): ").lower() if user_option not in options: raise ValueError("❌ Opción no válida \n") computer_option = random.choice(options) print("🤖 Computer option:", computer_option, "\n") # if (user_option == computer_option): print("😒 Empate!") elif user_option == "piedra": if computer_option == "tijera": print("piedra gana a tijera") print("👨 user gano!") user_count += 1 else: print("Papel gana a piedra") print("🤖 computer gano!") computer_count += 1 elif user_option == "papel": if computer_option == "piedra": print("papel gana a piedra") print("👨 user gano!") user_count += 1 else: print("tijera gana a papel") print("🤖 computer gano!") computer_count += 1 elif user_option == "tijera": if computer_option == "papel": print("tijera gana a papel") print("👨 user gano!") user_count += 1 else: print("piedra gana a tijera") print("🤖 computer gano!") computer_count += 1 print("\n **** MARCADOR ****") if (user_count > computer_count): print("User:", user_count, "Computer:", computer_count, "\n") if (user_count == 2): print("👨 Usuario ganó el juego!") else: print("Computer:", computer_count, "User:", user_count, "\n") if (computer_count == 2): print("🤖 Computer ganó el juego!") except ValueError as error: print(error) ```
una solucion elegante para cuando no solo hay 3 opciones sino mas y asi evitar hacer todos los if/else que estos implica es usar una matriz cuyos valores seran 0 y 1 y las filas y columnas son las opciones de jugador y maquina respectiva entonces se busca en la matriz y si es 1 gana jugador y 0 pierde jugador
Hola te invito a que veas este tutorial para randomizar música! Explora géneros nuevos! <https://platzi.com/tutoriales/10002-python/38196-como-hacer-un-randomizador-de-musica/>
```js import random #Contendra el historial de las jugadas. history = [ { "name": "pc", "wins": [], "loses": [], "draws": [], "rounds": [1], }, { "name": "user", "wins": [], "loses": [], "draws": [], "rounds": [1] }] i = 0 # Cuenta el indice de los numero de round j = 0 #Cuenta el número de empates Options = ('piedra', 'papel', 'tijera') #Ciclo de la lógica principal while True: if (history[0]['wins'].count(1) >= 3): print("¡PC HA GANADO!") break elif (history[1]['wins'].count(1) >= 3): print("¡FELICIDADES HAS GANADO!") break print("-"*15) print(f"|| R0NDA {history[0]['rounds'][i]}||") #Accede a nuestra lista historial en el primer elemento de la lista en la key 'rounds' y el primer valor de esa lista PCPlay = random.choice(Options) UserPlay = input("Jugada Usuario = ") UserPlay = UserPlay.lower() if not UserPlay in Options: print("Jugada no validaa") continue elif UserPlay == PCPlay: print(f"Jugada PC = {PCPlay}") print("¡EMPATE!") history[0]['draws'].append(1) #Guarda el empate para la PC y el Usuario con un 1 history[1]['draws'].append(1) elif (UserPlay == 'piedra' and PCPlay == 'tijera') or (UserPlay == 'papel' and PCPlay == 'piedra') or (UserPlay == 'tijera' and PCPlay == 'papel'): print(f"Jugada PC = {PCPlay}") print(f"¡GANA USUARIO LA R0NDA {history[0]['rounds'][i]}!") history[0]['loses'].append(1) #Guarda la victoria para el Usuario con un 1 history[1]['wins'].append(1) #Guarda la derrota para la PC con un 1 else: print(f"Jugada PC = {PCPlay}") print(f"¡GANA PC LA R0NDA {history[0]['rounds'][i]}!") history[0]['wins'].append(1) #Guarda la victoria para la PC con un 1 history[1]['loses'].append(1) #Guarda la derrota para el usuario con un 1 i += 1 history[0]['rounds'].append(i+1) #Aumenta y almacena el número de rounds en la lista del diccionario history[1]['rounds'].append(i+1) # i + 1 porque i es el indide que inicia en 0 y los rounds inician en 1. print("_"*15) print("|| STATS ||") print(f"|| Victorias totales: {history[1]['wins'].count(1) } ||") print(f"|| Derrotas totales: {history[1]['loses'].count(1) } ||") print(f"|| Empates totales: {history[1]['draws'].count(1) } ||") ''' NOTAS DE MEJORA: Puede usarse para consultar estadisticas del juego por ronda. Podrías guardar la derrota o victoria de cada jugada. ''' ```*import* random *#Contendra el historial de las jugadas.*history *=* \[    {        "name": "pc",        "wins": \[],        "loses": \[],        "draws": \[],        "rounds": \[1],    },    {        "name": "user",        "wins": \[],        "loses": \[],        "draws": \[],        "rounds": \[1]    }] i *=* 0 *# Cuenta el indice de los numero de round*j *=* 0 *#Cuenta el número de empates*Options *=* ('piedra', 'papel', 'tijera')*#Ciclo de la lógica principalwhile* True:    *if* (history\[0]\['wins'].count(1) *>=* 3):        print("¡PC HA GANADO!")        *break*    *elif* (history\[1]\['wins'].count(1) *>=* 3):        print("¡FELICIDADES HAS GANADO!")        *break*     print("-"*\**15)    print(*f*"|| R0NDA {history\[0]\['rounds']\[i]}||") *#Accede a nuestra lista historial en el primer elemento de la lista en la key 'rounds' y el primer valor de esa lista*     PCPlay *=* random.choice(Options)    UserPlay *=* input("Jugada Usuario = ")    UserPlay *=* UserPlay.lower()    *if* *not* UserPlay *in* Options:        print("Jugada no validaa")        *continue*    *elif* UserPlay *==* PCPlay:        print(*f*"Jugada PC = {PCPlay}")        print("¡EMPATE!")        history\[0]\['draws'].append(1) *#Guarda el empate para la PC y el Usuario con un 1*        history\[1]\['draws'].append(1)    *elif* (UserPlay *==* 'piedra' *and* PCPlay *==* 'tijera') *or* (UserPlay *==* 'papel' *and* PCPlay *==* 'piedra') *or* (UserPlay *==* 'tijera' *and* PCPlay *==* 'papel'):        print(*f*"Jugada PC = {PCPlay}")        print(*f*"¡GANA USUARIO LA R0NDA {history\[0]\['rounds']\[i]}!")        history\[0]\['loses'].append(1) *#Guarda la victoria para el Usuario con un 1*        history\[1]\['wins'].append(1) *#Guarda la derrota para la PC con un 1*    *else*:        print(*f*"Jugada PC = {PCPlay}")        print(*f*"¡GANA PC LA R0NDA {history\[0]\['rounds']\[i]}!")        history\[0]\['wins'].append(1) *#Guarda la victoria para la PC con un 1*        history\[1]\['loses'].append(1) *#Guarda la derrota para el usuario con un 1*         i *+=* 1    history\[0]\['rounds'].append(i*+*1) *#Aumenta y almacena el número de rounds en la lista del diccionario*    history\[1]\['rounds'].append(i*+*1) *# i + 1 porque i es el indide que inicia en 0 y los rounds inician en 1.* print("\_"*\**15)print("||                       STATS                        ||")print(*f*"|| Victorias totales: {history\[1]\['wins'].count(1) } ||")print(*f*"|| Derrotas totales: {history\[1]\['loses'].count(1) } ||")print(*f*"|| Empates totales: {history\[1]\['draws'].count(1) }  ||")    '''NOTAS DE MEJORA:Puede usarse para consultar estadisticas del juego por ronda.Podrías guardar la derrota o victoria de cada jugada. '''
```python import random #Contendra el historial de las jugadas. history = [ { "name": "pc", "wins": [], "loses": [], "draws": [], "rounds": [1], }, { "name": "user", "wins": [], "loses": [], "draws": [], "rounds": [1] }] i = 0 # Cuenta el indice de los numero de round j = 0 #Cuenta el número de empates Options = ('piedra', 'papel', 'tijera') #Ciclo de la lógica principal while True: if (history[0]['wins'].count(1) >= 3): print("¡PC HA GANADO!") break elif (history[1]['wins'].count(1) >= 3): print("¡FELICIDADES HAS GANADO!") break print("-"*15) print(f"|| R0NDA {history[0]['rounds'][i]}||") #Accede a nuestra lista historial en el primer elemento de la lista en la key 'rounds' y el primer valor de esa lista PCPlay = random.choice(Options) UserPlay = input("Jugada Usuario = ") UserPlay = UserPlay.lower() if not UserPlay in Options: print("Jugada no validaa") continue elif UserPlay == PCPlay: print(f"Jugada PC = {PCPlay}") print("¡EMPATE!") history[0]['draws'].append(1) #Guarda el empate para la PC y el Usuario con un 1 history[1]['draws'].append(1) elif (UserPlay == 'piedra' and PCPlay == 'tijera') or (UserPlay == 'papel' and PCPlay == 'piedra') or (UserPlay == 'tijera' and PCPlay == 'papel'): print(f"Jugada PC = {PCPlay}") print(f"¡GANA USUARIO LA R0NDA {history[0]['rounds'][i]}!") history[0]['loses'].append(1) #Guarda la victoria para el Usuario con un 1 history[1]['wins'].append(1) #Guarda la derrota para la PC con un 1 else: print(f"Jugada PC = {PCPlay}") print(f"¡GANA PC LA R0NDA {history[0]['rounds'][i]}!") history[0]['wins'].append(1) #Guarda la victoria para la PC con un 1 history[1]['loses'].append(1) #Guarda la derrota para el usuario con un 1 i += 1 history[0]['rounds'].append(i+1) #Aumenta y almacena el número de rounds en la lista del diccionario history[1]['rounds'].append(i+1) # i + 1 porque i es el indide que inicia en 0 y los rounds inician en 1. print("_"*15) print("|| STATS ||") print(f"|| Victorias totales: {history[1]['wins'].count(1) } ||") print(f"|| Derrotas totales: {history[1]['loses'].count(1) } ||") print(f"|| Empates totales: {history[1]['draws'].count(1) } ||") ''' NOTAS DE MEJORA: Puede usarse para consultar estadisticas del juego por ronda. Podrías guardar la derrota o victoria de cada jugada. ''' ```*import* random *#Contendra el historial de las jugadas.*history *=* \[    {        "name": "pc",        "wins": \[],        "loses": \[],        "draws": \[],        "rounds": \[1],    },    {        "name": "user",        "wins": \[],        "loses": \[],        "draws": \[],        "rounds": \[1]    }] i *=* 0 *# Cuenta el indice de los numero de round*j *=* 0 *#Cuenta el número de empates*Options *=* ('piedra', 'papel', 'tijera')*#Ciclo de la lógica principalwhile* True:    *if* (history\[0]\['wins'].count(1) *>=* 3):        print("¡PC HA GANADO!")        *break*    *elif* (history\[1]\['wins'].count(1) *>=* 3):        print("¡FELICIDADES HAS GANADO!")        *break*     print("-"*\**15)    print(*f*"|| R0NDA {history\[0]\['rounds']\[i]}||") *#Accede a nuestra lista historial en el primer elemento de la lista en la key 'rounds' y el primer valor de esa lista*     PCPlay *=* random.choice(Options)    UserPlay *=* input("Jugada Usuario = ")    UserPlay *=* UserPlay.lower()    *if* *not* UserPlay *in* Options:        print("Jugada no validaa")        *continue*    *elif* UserPlay *==* PCPlay:        print(*f*"Jugada PC = {PCPlay}")        print("¡EMPATE!")        history\[0]\['draws'].append(1) *#Guarda el empate para la PC y el Usuario con un 1*        history\[1]\['draws'].append(1)    *elif* (UserPlay *==* 'piedra' *and* PCPlay *==* 'tijera') *or* (UserPlay *==* 'papel' *and* PCPlay *==* 'piedra') *or* (UserPlay *==* 'tijera' *and* PCPlay *==* 'papel'):        print(*f*"Jugada PC = {PCPlay}")        print(*f*"¡GANA USUARIO LA R0NDA {history\[0]\['rounds']\[i]}!")        history\[0]\['loses'].append(1) *#Guarda la victoria para el Usuario con un 1*        history\[1]\['wins'].append(1) *#Guarda la derrota para la PC con un 1*    *else*:        print(*f*"Jugada PC = {PCPlay}")        print(*f*"¡GANA PC LA R0NDA {history\[0]\['rounds']\[i]}!")        history\[0]\['wins'].append(1) *#Guarda la victoria para la PC con un 1*        history\[1]\['loses'].append(1) *#Guarda la derrota para el usuario con un 1*         i *+=* 1    history\[0]\['rounds'].append(i*+*1) *#Aumenta y almacena el número de rounds en la lista del diccionario*    history\[1]\['rounds'].append(i*+*1) *# i + 1 porque i es el indide que inicia en 0 y los rounds inician en 1.* print("\_"*\**15)print("||                       STATS                        ||")print(*f*"|| Victorias totales: {history\[1]\['wins'].count(1) } ||")print(*f*"|| Derrotas totales: {history\[1]\['loses'].count(1) } ||")print(*f*"|| Empates totales: {history\[1]\['draws'].count(1) }  ||")    '''NOTAS DE MEJORA:Puede usarse para consultar estadisticas del juego por ronda.Podrías guardar la derrota o victoria de cada jugada. '''
Hola, hice el juego con diccionario. Aqui esta mi code :) `import`` random` `#Contendra el historial de las jugadas.``history ``=`` [    {        "name": "pc",        "wins": [],        "loses": [],        "draws": [],        "rounds": [1],    },    {        "name": "user",        "wins": [],        "loses": [],        "draws": [],        "rounds": [1]    }]` `i ``=`` 0 ``# Cuenta el indice de los numero de round``j ``=`` 0 ``#Cuenta el número de empates``Options ``=`` ('piedra', 'papel', 'tijera')``#Ciclo de la lógica principalwhile`` True:    ``if`` (history[0]['wins'].count(1) ``>=`` 3):        print("¡PC HA GANADO!")        ``break``    ``elif`` (history[1]['wins'].count(1) ``>=`` 3):        print("¡FELICIDADES HAS GANADO!")        ``break` `    print("-"``*``15)    print(``f``"|| R0NDA {history[0]['rounds'][i]}||") ``#Accede a nuestra lista historial en el primer elemento de la lista en la key 'rounds' y el primer valor de esa lista ``    PCPlay ``=`` random.choice(Options)    UserPlay ``=`` input("Jugada Usuario = ")    UserPlay ``=`` UserPlay.lower()    ``if`` ``not`` UserPlay ``in`` Options:        print("Jugada no validaa")        ``continue``    ``elif`` UserPlay ``==`` PCPlay:        print(``f``"Jugada PC = {PCPlay}")        print("¡EMPATE!")        history[0]['draws'].append(1) ``#Guarda el empate para la PC y el Usuario con un 1``        history[1]['draws'].append(1)    ``elif`` (UserPlay ``==`` 'piedra' ``and`` PCPlay ``==`` 'tijera') ``or`` (UserPlay ``==`` 'papel' ``and`` PCPlay ``==`` 'piedra') ``or`` (UserPlay ``==`` 'tijera' ``and`` PCPlay ``==`` 'papel'):        print(``f``"Jugada PC = {PCPlay}")        print(``f``"¡GANA USUARIO LA R0NDA {history[0]['rounds'][i]}!")        history[0]['loses'].append(1) ``#Guarda la victoria para el Usuario con un 1``        history[1]['wins'].append(1) ``#Guarda la derrota para la PC con un 1``    ``else``:        print(``f``"Jugada PC = {PCPlay}")        print(``f``"¡GANA PC LA R0NDA {history[0]['rounds'][i]}!")        history[0]['wins'].append(1) ``#Guarda la victoria para la PC con un 1``        history[1]['loses'].append(1) ``#Guarda la derrota para el usuario con un 1    ` `    i ``+=`` 1    history[0]['rounds'].append(i``+``1) ``#Aumenta y almacena el número de rounds en la lista del diccionario``    history[1]['rounds'].append(i``+``1) ``# i + 1 porque i es el indide que inicia en 0 y los rounds inician en 1.` `print("_"``*``15)print("||                       STATS                        ||")print(``f``"|| Victorias totales: {history[1]['wins'].count(1) } ||")print(``f``"|| Derrotas totales: {history[1]['loses'].count(1) } ||")print(``f``"|| Empates totales: {history[1]['draws'].count(1) }  ||")    ` `'''NOTAS DE MEJORA:Puede usarse para consultar estadisticas del juego por ronda.Podrías guardar la derrota o victoria de cada jugada.` `'''`
<u>Mis Respetos eres un Crack enseñando</u>
Aqui dejo Piedra, papel, tijera, lagarto, spock ![]()![]()![](https://static.platzi.com/media/user_upload/1-9d94dd0b-b433-4abe-9109-6a6eef362904.jpg) ![](https://static.platzi.com/media/user_upload/2-9feff429-5b1b-460a-8cdc-3f67805044b8.jpg) ![](https://static.platzi.com/media/user_upload/3-9f14a79e-199b-4609-9d86-b3595a96489a.jpg)
Este es mi codigo: ```js import random as rd print('Este es el juego de piedra, papel o tijera.'); game_options = ('piedra', 'papel', 'tijera'); rondas = 0 user_victories = 0 computer_victories = 0 while True: rondas += 1 print('*' * 12) print(f'Ronda {rondas}') print('*' * 12) user_option = input('Elige piedra, papel o tijera: ').lower(); if user_option in game_options: computer_option = rd.choice(game_options) print(f'Has escogido {user_option}') print(f'La computadora ha escogido {computer_option}') if user_option == computer_option: print('Esto es un empate, seleccionaron la misma opcion'); elif user_option == 'piedra': if computer_option == 'tijera': print('Piedra gana a tijera'); print('El o la usuario ha ganado.'); user_victories += 1; else: print('Papel gana a piedra'); print('La computadora ha ganado.'); computer_victories += 1; elif user_option == 'papel': if computer_option == 'tijera': print('Tijera gana a papel'); print('La computadora ha ganado.'); computer_victories += 1; else: print('Papel gana a piedra'); print('El o la usuario ha ganado.'); user_victories += 1; elif user_option == 'tijera': if computer_option == 'papel': print('Tijera gana a papel'); print('El o la usuario ha ganado.'); user_victories += 1; else: print('Piedra gana a tijera'); print('La computadora ha ganado.'); computer_victories += 1; if user_victories == 2: print('Una maravillosa vicotria de la o el usuario.'); break if computer_victories == 2: print('Una maravillosa vicotria de la compu.'); break print('*' * 12) print(f'El marcador es {user_victories} punto(s) a favor del usario y {computer_victories} punto(s) a favor de la compu.') else: print('Esa opción no es valida, escoge de nuevo (tienes 2 oportunidades más).') i = 0 while i < 2: i += 1 user_option = input('Elige piedra, papel o tijera: ').lower(); if user_option in game_options: break if user_option in game_options: computer_option = rd.choice(game_options) print(f'Has escogido {user_option}') print(f'La computadora ha escogido {computer_option}') if user_option == computer_option: print('Esto es un empate, seleccionaron la misma opcion'); elif user_option == 'piedra': if computer_option == 'tijera': print('Piedra gana a tijera'); print('El o la usuario ha ganado.'); user_victories += 1; else: print('Papel gana a piedra'); print('La computadora ha ganado.'); computer_victories += 1; elif user_option == 'papel': if computer_option == 'tijera': print('Tijera gana a papel'); print('La computadora ha ganado.'); computer_victories += 1; else: print('Papel gana a piedra'); print('El o la usuario ha ganado.'); user_victories += 1; elif user_option == 'tijera': if computer_option == 'papel': print('Tijera gana a papel'); print('El o la usuario ha ganado.'); user_victories += 1; else: print('Piedra gana a tijera'); print('La computadora ha ganado.'); computer_victories += 1; else: print('Gracias por jugar.') print('*' * 12) print(f'El marcador es {user_victories} punto(s) a favor del usario y {computer_victories} punto(s) a favor de la compu.') if user_victories == 2: print('Una maravillosa vicotria de la o el usuario.'); break if computer_victories == 2: print('Una maravillosa vicotria de la compu.'); break ```
```python import os import random import platform opciones = ( "papel", "tijera", "piedra", ) os.system("cls" if platform.system() == "Windows" else "clear") puntos_usuario = 0 puntos_pc = 0 ronda = 1 ganador = {"usuario": "", "pc": ""} while True: print(f"\n-------- 👑 RONDA : {ronda}\n") opcion_usuario = input("piedra, papel o tijera >> ").strip().lower() if opcion_usuario not in opciones: print("OPCION NO VALIDA 😝") continue else: indice_pc = random.randint(0, 2) indice_usuario = opciones.index(opcion_usuario) diferencia = indice_usuario - indice_pc if diferencia == 0: ganador["usuario"] = "🟰" ganador["pc"] = "🟰" elif diferencia == 1 or diferencia == -2: ganador["usuario"] = "✅" ganador["pc"] = "❌" puntos_usuario += 1 else: ganador["usuario"] = "❌" ganador["pc"] = "✅" puntos_pc += 1 print( f"\nusuario => {opciones[indice_usuario]} {ganador['usuario']}" ) print(f"pc => {opciones[indice_pc]} {ganador['pc']}") print(f"\nusuario 😋: [{puntos_usuario}] - pc 🤖: [{puntos_pc}]") if puntos_usuario - puntos_pc == 2: print("\n🥳👋👋👋 USUARIO GANÓ!!") break if puntos_pc - puntos_usuario == 2: print("\n🤖🦾🦾🦾 PC GANÓ!!") break ronda += 1 print(f"\n-------- GAME OVER --------\n") ```
```js import random resultado_Juego = 0 ganados = 0 perdidos = 0 empatados = 0 mensaje = '' historialU = [] historialPc = [] while resultado_Juego <=3: li = ('PIEDRA', 'PAPEL', 'TIJERA') user = input('piedra papel o tijera =>').upper() pc = random.choice(li) if user == li[0] and pc == li[0] or \ user == li[1] and pc == li[1] or \ user == li[2] and pc == li[2]: empatados += 1 print(f'Has empatado {empatados}') elif user == li[0] and pc == li[1] or \ user == li[1] and pc == li[0] or \ user == li[2] and pc == li[1]: ganados += 1 print(f'Ganaste con {user}') else: perdidos += 1 print(f'Computador gano con {pc}') historialU.append(user) historialPc.append(pc) if ganados == 3: mensaje = (f'Ganaste con {ganados} victorias') break if perdidos == 3: mensaje = (f'Perdiste con {ganados} victorias') break print(mensaje) print('*' * 10) preguntaH = int(input('para ver el historial escribe 1: ')) if preguntaH ==1: print('Tu historial: ', historialU) print('Pc historial: ', historialPc) else: print('adios') ```import random resultado\_Juego = 0ganados = 0perdidos = 0empatados = 0mensaje = ''historialU = \[]historialPc = \[]     while resultado\_Juego <=3:    li = ('PIEDRA', 'PAPEL', 'TIJERA')    user = input('piedra papel o tijera =>').upper()    pc = random.choice(li)        if user == li\[0] and pc == li\[0] or \        user == li\[1] and pc == li\[1] or \        user == li\[2] and pc == li\[2]:        empatados += 1        print(f'Has empatado {empatados}')    elif user == li\[0] and pc == li\[1] or \        user == li\[1] and pc == li\[0] or \        user == li\[2] and pc == li\[1]:        ganados += 1        print(f'Ganaste con {user}')    else:        perdidos += 1        print(f'Computador gano con {pc}')     historialU.append(user)    historialPc.append(pc)     if ganados == 3:        mensaje = (f'Ganaste con {ganados} victorias')        break    if perdidos == 3:        mensaje = (f'Perdiste con {ganados} victorias')        break     print(mensaje)print('\*' \* 10)preguntaH = int(input('para ver el historial escribe 1: '))if preguntaH ==1:    print('Tu historial: ', historialU)        print('Pc historial: ', historialPc)    else:    print('adios')
Metí todo este código en una función. Pedí nombre del Jugador y las opciones para el usuario. import random \# defino mi table de juegos def juego(): \#pedir nombre del jugador y defino contadores y variables nombre = input("Nombre del Jugador ") round = int(input("Ingrese el numero de rondas: ")) lista = \["Piedra", "Papel", "Tijera"] ronda = 1 counter = 0 computer\_win = 0 user\_win = 0 computadora = random.choice(lista) while ronda < round: print("\*" \* 50) print( "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Bienvenido al Juego de Piedra, Papel o Tijera \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" ) print("\*" \* 50) \# ingresamos nuestra eleccion para empezar a jugar eleccion = input("Ingrese su eleccion: ") eleccion = eleccion.title() \# validamos que sea la eleccion correcta if eleccion == "Piedra": if computadora == "Piedra": print("Empate") print("\*" \* 20) print("Ronda", ronda) print("\*" \* 20) print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 \#este contador es indispensable para que el juego no se repita elif computadora == "Papel": print("Perdiste") print("\*" \* 20) print("Ronda", ronda) print("\*" \* 20) computer\_win += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 elif computadora == "Tijera": print("Ganaste") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) user\_win += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 elif eleccion == "Papel": if computadora == "Piedra": print("Ganaste ya que Papel le gana a Piedra:") print("\*" \* 20) print("Ronda: ", ronda) print("\*" \* 20) user\_win += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 elif computadora == "Papel": print("Esto es un empate") print("\*" \* 20) print("Ronda:", ronda) print("\*" \* 20) print("Puntaje Computadora: ", computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 elif computadora == "Tijera": print("Gano la Computadora ya que Tijera le gana a Papel") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) computer\_win += 1 counter += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 elif eleccion == "Tijera": if computadora == "Piedra": print("Gano la Computadora") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) computer\_win += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 if computadora == "Papel": print("Gano el Usuario") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) user\_win += 1 print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 if computadora == "Tijera": print("Esto es un empate") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) ronda += 1 counter += 1 else: print("Opcion Invalida") print("\*" \* 20) print("Ronda :", ronda) print("\*" \* 20) print('Puntaje Computadora: ', computer\_win) print(f"Puntaje {nombre}: ", user\_win) continue if computer\_win > user\_win: print( f"xxxxxxxxxxxxx Gano la computadora en {counter} rondas xxxxxxxxxxxxxxxxxxxxxx" ) elif user\_win > computer\_win: print( f"xxxxxxxxxxxxxxx Ganaste {nombre} en {counter} rondas xxxxxxxxxxxxxxxxxxxxxxxxxx" ) else: print("Esto es un empate") juego()
```js import random proceder = "si" afirma = "si" juego = ("piedra", "papel", "tijera") ganar = 0 perder = 0 print("\n¡¡¡Bienvenido al Juego ", juego[0], ", ", juego[1], " o ", juego[2], "!!!\n") while proceder == afirma: name = input("Insera el nombre de usuario=> ") name = name.title() perde = 0 gana = 0 while perde < 2 and gana < 2: elije = f"{name}, por favor elige entre piedra, papel o tijera=> " print("\n", "*" * 9) print(" ROUND", (gana + perde) + 1) print("", "*" * 9, "\n") aleatorio = random.choice(juego) jugador1 = input(elije) jugador1 = jugador1.lower() if jugador1 == aleatorio: print("\nEmpataste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") elif ( (jugador1 == "piedra" and aleatorio == "papel") or (jugador1 == "papel" and aleatorio == "tijera") or (jugador1 == "tijera" and aleatorio == "piedra") ): perde += 1 perder += 1 print("\nPerdiste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") elif ( (jugador1 == "piedra" and aleatorio == "tijera") or (jugador1 == "papel" and aleatorio == "piedra") or (jugador1 == "tijera" and aleatorio == "papel") ): print("\nGanaste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") gana += 1 ganar += 1 else: print("\nNo ingresaste ninguna opcion valida\n") mensaje = '¿Deseas continuar? ingresa la palabra \n "si" o "no"\n=>' proceder = input(mensaje) proceder = proceder.lower() if perder > ganar: print("\nPerdiste las partida, lo siento\n ") print(f"Numero de victorias {ganar} \nNumero de derrotas {perder}") else: print("\n¡¡¡Ganaste!!! Felicidades\n") print(f"Numero de victorias {ganar} \nNumero de derrotas {perder}") ```
import random proceder = "si"afirma = "si"juego = ("piedra", "papel", "tijera")ganar = 0perder = 0print("\n¡¡¡Bienvenido al Juego ", juego\[0], ", ", juego\[1], " o ", juego\[2], "!!!\n")while proceder == afirma: name = input("Insera el nombre de usuario=> ") name = name.title() perde = 0 gana = 0 while perde < 2 and gana < 2: elije = f"{name}, por favor elige entre piedra, papel o tijera=> " print("\n", "\*" \* 9) print(" ROUND", (gana + perde) + 1) print("", "\*" \* 9, "\n") aleatorio = random.choice(juego) jugador1 = input(elije) jugador1 = jugador1.lower() if jugador1 == aleatorio: print("\nEmpataste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") elif ( (jugador1 == "piedra" and aleatorio == "papel") or (jugador1 == "papel" and aleatorio == "tijera") or (jugador1 == "tijera" and aleatorio == "piedra") ): perde += 1 perder += 1 print("\nPerdiste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") elif ( (jugador1 == "piedra" and aleatorio == "tijera") or (jugador1 == "papel" and aleatorio == "piedra") or (jugador1 == "tijera" and aleatorio == "papel") ): print("\nGanaste\n") print(f"Elejiste {jugador1} contra {aleatorio}\n") gana += 1 ganar += 1 else: print("\nNo ingresaste ninguna opcion valida\n") mensaje = '¿Deseas continuar? ingresa la palabra \n "si" o "no"\n=>' proceder = input(mensaje) proceder = proceder.lower()if perder > ganar: print("\nPerdiste las partida, lo siento\n ") print(f"Numero de victorias {ganar} \nNumero de derrotas {perder}")else: print("\n¡¡¡Ganaste!!! Felicidades\n") print(f"Numero de victorias {ganar} \nNumero de derrotas {perder}")
```python import random print("Bienvenido a Juego") proceder = "si" afirma = "si" juego = ("piedra", "papel", "tijeras") ganar = 0 perder = 0 while proceder == afirma: perde = 0 gana = 0 while perde < 3 and gana < 3: print("*" * 10) print("ROUND", (gana + perde) + 1) print("*" * 10) aleatorio = random.choice(juego) jugador1 = input("Jugador 1, elige piedra, papel o tijeras=>") jugador1 = jugador1.lower() if jugador1 == aleatorio: print("empate") print(f"elejiste {jugador1} contra {aleatorio}") elif ( (jugador1 == "piedra" and aleatorio == "papel") or (jugador1 == "papel" and aleatorio == "tijeras") or (jugador1 == "tijeras" and aleatorio == "piedra") ): perde += 1 perder += 1 print("perdiste") print(f"elejiste {jugador1} contra {aleatorio}") elif ( (jugador1 == "piedra" and aleatorio == "tijeras") or (jugador1 == "papel" and aleatorio == "piedra") or (jugador1 == "tijeras" and aleatorio == "papel") ): print("ganaste") print(f"elejiste {jugador1} contra {aleatorio}") gana += 1 ganar += 1 else: print("No ingresaste ninguna opcion valida") proceder = input( 'Si deseas continuar ingresa la palabra "si" o si deseas parar ingresa la palabra "no"' ) proceder = proceder.lower() print("la opcion es", proceder) if perder > ganar: print("Perdiste las partida, lo siento") print(f"numero de victorias {ganar} y numero de derrotas{perder}") else: print("¡¡¡Ganaste!!! Felicidades") print(f"numero de victorias {ganar} y numero de derrotas{perder}") ```import random print("Bienvenido a Juego")proceder = "si"afirma = "si"juego = ("piedra", "papel", "tijeras")ganar = 0perder = 0while proceder == afirma: perde = 0 gana = 0 while perde < 3 and gana < 3: print("\*" \* 10) print("ROUND", (gana + perde) + 1) print("\*" \* 10) aleatorio = random.choice(juego) jugador1 = input("Jugador 1, elige piedra, papel o tijeras=>") jugador1 = jugador1.lower() if jugador1 == aleatorio: print("empate") print(f"elejiste {jugador1} contra {aleatorio}") elif ( (jugador1 == "piedra" and aleatorio == "papel") or (jugador1 == "papel" and aleatorio == "tijeras") or (jugador1 == "tijeras" and aleatorio == "piedra") ): perde += 1 perder += 1 print("perdiste") print(f"elejiste {jugador1} contra {aleatorio}") elif ( (jugador1 == "piedra" and aleatorio == "tijeras") or (jugador1 == "papel" and aleatorio == "piedra") or (jugador1 == "tijeras" and aleatorio == "papel") ): print("ganaste") print(f"elejiste {jugador1} contra {aleatorio}") gana += 1 ganar += 1 else: print("No ingresaste ninguna opcion valida") proceder = input( 'Si deseas continuar ingresa la palabra "si" o si deseas parar ingresa la palabra "no"' ) proceder = proceder.lower() print("la opcion es", proceder)if perder > ganar: print("Perdiste las partida, lo siento") print(f"numero de victorias {ganar} y numero de derrotas{perder}")else: print("¡¡¡Ganaste!!! Felicidades") print(f"numero de victorias {ganar} y numero de derrotas{perder}")```js ```
This is mi code (Estoy tomando el curso de ingles simultaneo a este) import random options = ('piedra', 'papel', 'tijera') user\_wins = 0 computer\_wins = 0 empate = 0 ronda = 1 while True: print('\*'\*10) print(f'Round {ronda}') print('\*'\*10) ronda +=1 user\_option = input("piedra, papel o tijera: ") user\_option= user\_option.lower() computer\_option = random.choice(options) print('User option=>',user\_option) print('Computer option=>', computer\_option) if not user\_option in options: print('Opcion invalida') continue if user\_option == computer\_option: print("¡Empate!") empate += 1 elif user\_option == "piedra": if computer\_option == "tijera": print("Piedra mata 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 == "tijera": print("Tijera corta a Papel") print("\*\*\*\*¡Computer Gano!\*\*\*\*") computer\_wins +=1 else: print("Papel cubre a Piedra") print("\*\*\*\*¡User Gano!\*\*\*\*") user\_wins += 1 elif user\_option == "tijera": if computer\_option == "piedra": print("Piedra mata a Tijera") print("\*\*\*\*¡Computer Gano!") computer\_wins +=1 else: print("Tijera corta a Papel") print("\*\*\*\*¡User Gana!") user\_wins += 1 print('Victories ',user\_wins) print('Loses ',computer\_wins) print('Draws ',empate) if computer\_wins>=2: print('You loose') break if user\_wins>=2: print('You win') break
```js import random options = ('piedra', 'papel', 'tijera') print(options) user_option = input('Type your choice => ').lower() computer_option = random.choice(options) computer_wins = 0 user_wins = 0 while user_option not in options: print('Invalid election, type again') user_option = input('Type your choice=> ').lower() print('Computer choice => ', computer_option) while computer_wins < 3 and user_wins < 3: print('***********************************') if computer_option == user_option: user_option = input('Tie, type again => ').lower() computer_option = random.choice(options) print('Computer choice => ', computer_option) continue elif user_option == 'piedra': if computer_option == 'papel': print('Computer wins') computer_wins += 1 else: print('User wins') user_wins += 1 elif user_option == 'papel': if computer_option == 'tijera': print('Computer wins') computer_wins += 1 else: print('User wins') user_wins += 1 else: if computer_option == 'piedra': print('Computer wins') computer_wins += 1 else: print('User wins') user_wins += 1 print('Games won by computer= ',computer_wins) print('Games won by user= ',user_wins) print('***********************************') if user_wins == 3: print('The user is the champion') break elif computer_wins == 3: print('The computer is the champion') break print(options) user_option = input('Type your choice => ').lower() computer_option = random.choice(options) while user_option not in options: print('Invalid election, type again') user_option = input('Type your choice => ').lower() print('Computer choice => ', computer_option) ```
```js import random options = ('piedra', 'papel', 'tijera') rounds = 1 user_wins = 0 computer_wins = 0 user_name = input('Ingrese su nombre: ') while True: print('*' * 10) print('ROUND', rounds) print('*' * 10) print(f'Partidas ganadas por {user_name}: {user_wins}') print(f'Partidas ganadas por la computadora: {computer_wins}') usuario = input("piedra, papel o tijera => ") usuario = usuario.lower() if not usuario in options: print("Esta opción no es válida") continue computadora = random.choice(options) if usuario == computadora: print("Empate!") elif usuario == "piedra": if computadora == "tijera": print("piedra le gana a tijera") print(user_name, "ganó!!") user_wins += 1 else: print("papel le gana a piedra") print("computadora ganó!!") computer_wins += 1 elif usuario == "papel": if computadora == "piedra": print("papel le gana a piedra") print(user_name, "ganó!!") user_wins += 1 else: print("tijera le gana a papel") print("computadora ganó!!") computer_wins += 1 elif usuario == "tijera": if computadora == "papel": print("tijera le gana a papel") print(user_name, "ganó!!") user_wins += 1 else: print("piedra le gana a tijera") print("computadora ganó!!") computer_wins += 1 if user_wins == 2: print("El ganador es =>", user_name) break if computer_wins == 2: print("El ganador es la computadora") break rounds += 1 ```import random options = ('piedra', 'papel', 'tijera') rounds = 1 user\_wins = 0 computer\_wins = 0 user\_name = input('Ingrese su nombre: ') while True: print('\*' \* 10) print('ROUND', rounds) print('\*' \* 10) print(f'Partidas ganadas por {user\_name}: {user\_wins}') print(f'Partidas ganadas por la computadora: {computer\_wins}') usuario = input("piedra, papel o tijera => ") usuario = usuario.lower() if not usuario in options: print("Esta opción no es válida") continue computadora = random.choice(options) if usuario == computadora: print("Empate!") elif usuario == "piedra": if computadora == "tijera": print("piedra le gana a tijera") print(user\_name, "ganó!!") user\_wins += 1 else: print("papel le gana a piedra") print("computadora ganó!!") computer\_wins += 1 elif usuario == "papel": if computadora == "piedra": print("papel le gana a piedra") print(user\_name, "ganó!!") user\_wins += 1 else: print("tijera le gana a papel") print("computadora ganó!!") computer\_wins += 1 elif usuario == "tijera": if computadora == "papel": print("tijera le gana a papel") print(user\_name, "ganó!!") user\_wins += 1 else: print("piedra le gana a tijera") print("computadora ganó!!") computer\_wins += 1 if user\_wins == 2: print("El ganador es =>", user\_name) break if computer\_wins == 2: print("El ganador es la computadora") break rounds += 1
`import random` `options = ('piedra', 'papel', 'tijera')` `rounds = 1` `user_wins = 0` `computer_wins = 0` `user_name = input('Ingrese su nombre: ')` `while True:` ` print('*' * 10)` ` print('ROUND', rounds)` ` print('*' * 10)` ` print(f'Partidas ganadas por {user_name}: {user_wins}')` ` print(f'Partidas ganadas por la computadora: {computer_wins}')` ` ` ` usuario = input("piedra, papel o tijera => ")` ` usuario = usuario.lower()` ` if not usuario in options:` ` print("Esta opción no es válida")` ` continue` ` ` ` computadora = random.choice(options)` ` ` ` if usuario == computadora:` ` print("Empate!")` ` ` ` elif usuario == "piedra":` ` if computadora == "tijera":` ` print("piedra le gana a tijera")` ` print(user_name, "ganó!!")` ` user_wins += 1` ` else:` ` print("papel le gana a piedra")` ` print("computadora ganó!!")` ` computer_wins += 1` ` ` ` elif usuario == "papel":` ` if computadora == "piedra":` ` print("papel le gana a piedra")` ` print(user_name, "ganó!!")` ` user_wins += 1` ` else:` ` print("tijera le gana a papel")` ` print("computadora ganó!!")` ` computer_wins += 1` ` ` ` elif usuario == "tijera":` ` if computadora == "papel":` ` print("tijera le gana a papel")` ` print(user_name, "ganó!!")` ` user_wins += 1` ` else:` ` print("piedra le gana a tijera")` ` print("computadora ganó!!")` ` computer_wins += 1` ` if user_wins == 2:` ` print("El ganador es =>", user_name)` ` break` ` if computer_wins == 2:` ` print("El ganador es la computadora")` ` break` ` rounds += 1`
```js import random options = ('piedra', 'papel', 'tijera') computer_wins = 0 user_wins = 0 rounds = 1 while True: print('*' * 20) print('ROUND', rounds) print('*' * 20) print('computer_wins', computer_wins) print('user_wins', user_wins) user_option = input('piedra, papel o tijera => ') user_option = user_option.lower() rounds += 1 if not user_option in options: print('esa option no es valida') continue computer_option = random.choice(options) if user_option == computer_option: print('Empate!') elif user_option == 'piedra': if computer_option == 'tijera': print('piedra gana a tijera') print('user gana!') user_wins += 1 else: print('Papel gana a piedra') print('computer gana!') computer_wins += 1 elif user_option == 'papel': if computer_option == 'piedra': print('papel gana a piedra') print('user gana!') user_wins += 1 else: print('tijera gana a papel') print('computer gana!') computer_wins += 1 elif user_option == 'tijera': if computer_option == 'papel': print('tijera gana a papel') print('user gana!') user_wins += 1 else: print('piedra gana a tijera') print('computer gana!') computer_wins += 1 if computer_wins == 2: print('El ganador es la computadora') break if user_wins == 2: print('El ganador es el usuario') break ```import random options = ('piedra', 'papel', 'tijera') computer\_wins = 0 user\_wins = 0 rounds = 1 while True: print('\*' \* 20) print('ROUND', rounds) print('\*' \* 20) print('computer\_wins', computer\_wins) print('user\_wins', user\_wins) user\_option = input('piedra, papel o tijera => ') user\_option = user\_option.lower() rounds += 1 if not user\_option in options: print('esa option no es valida') continue computer\_option = random.choice(options) if user\_option == computer\_option: print('Empate!') elif user\_option == 'piedra': if computer\_option == 'tijera': print('piedra gana a tijera') print('user gana!') user\_wins += 1 else: print('Papel gana a piedra') print('computer gana!') computer\_wins += 1 elif user\_option == 'papel': if computer\_option == 'piedra': print('papel gana a piedra') print('user gana!') user\_wins += 1 else: print('tijera gana a papel') print('computer gana!') computer\_wins += 1 elif user\_option == 'tijera': if computer\_option == 'papel': print('tijera gana a papel') print('user gana!') user\_wins += 1 else: print('piedra gana a tijera') print('computer gana!') computer\_wins += 1 if computer\_wins == 2: print('El ganador es la computadora') break if user\_wins == 2: print('El ganador es el usuario') break
import random options = ('piedra', 'papel', 'tijera') computer\_wins = 0 user\_wins = 0 rounds = 1 while True: print('\*' \* 20) print('ROUND', rounds) print('\*' \* 20) print('computer\_wins', computer\_wins) print('user\_wins', user\_wins) user\_option = input('piedra, papel o tijera => ') user\_option = user\_option.lower() rounds += 1 if not user\_option in options: print('esa option no es valida') continue computer\_option = random.choice(options) if user\_option == computer\_option: print('Empate!') elif user\_option == 'piedra': if computer\_option == 'tijera': print('piedra gana a tijera') print('user gana!') user\_wins += 1 else: print('Papel gana a piedra') print('computer gana!') computer\_wins += 1 elif user\_option == 'papel': if computer\_option == 'piedra': print('papel gana a piedra') print('user gana!') user\_wins += 1 else: print('tijera gana a papel') print('computer gana!') computer\_wins += 1 elif user\_option == 'tijera': if computer\_option == 'papel': print('tijera gana a papel') print('user gana!') user\_wins += 1 else: print('piedra gana a tijera') print('computer gana!') computer\_wins += 1 if computer\_wins == 2: print('El ganador es la computadora') break if user\_wins == 2: print('El ganador es el usuario') break
Gracias Nico!!! vales mil y aprendí muchísimo \---
***Finalizamos el curso!!!! (-)***
```python #Modules import random #Mutable Variables score_user = 0 score_pc = 0 round = 0 #Immutable Variables values = (1, 2, 3) options = ('Rock 🪨', 'Paper 📃', 'Scissors ✂️') verdict = ('You Win 😆', 'You Lose 🫠', 'It is a Tie 🪢') jokes = ('Long live Skynet! 🦾', 'Ask ChatGPT for Help! 🤖') #Welcome print('WELCOME TO ROCK, PAPER & SCISSORS 🪨 📃 ✂️') print('') print('Try beating the PC, 2 out of 3 times 🤖') #Game Logic while score_user != 2 or score_pc != 2: #Input and Round print('') round += 1 print('ROUND', round) print('Select an Option:') print('') print('1. Rock 🪨') print('2. Paper 📃') print('3. Scissors ✂️') print('') selection = input('Write here your option (1, 2 or 3): ') print('') #Filtering Invalid Options if not (selection.isdigit()) or (not int(selection) in values): print('Please, write a valid option and try again.') print('') print('-' * 17) continue #Requesting Options option_pc = random.choice(options) option_user = options[int(selection) - 1] print("User's Choice: " + option_user) print("PC's Choice: " + option_pc) print('') #Game Veredicts if option_user == option_pc: print(verdict[2].upper()) elif (option_user == options[0] and option_pc == options[2]) or ( option_user == options[2] and option_pc == options[1]) or (option_user == options[1] and option_pc == options[0]): print(option_user + ' beats ' + option_pc) print('') print(verdict[0].upper()) score_user += 1 elif (option_user == options[2] and option_pc == options[0]) or ( option_user == options[1] and option_pc == options[2]) or (option_user == options[0] and option_pc == options[1]): print(option_pc + ' beats ' + option_user) print('') print(verdict[1].upper()) print('') print(random.choice(jokes)) score_pc += 1 #Scores print('') print('User Score:', score_user) print('PC Score:', score_pc) print('') print('-' * 17) #Closing if score_user == 2 and score_pc < 2: print('') print('USER WINS! 🤩') if score_user < 2 and score_pc == 2: print('') print('GAME OVER! 😵') if score_user == 2 or score_pc == 2: break ```
![](https://static.platzi.com/media/user_upload/image-397f9d40-e282-46cd-8e73-cce4007d3ff6.jpg)
'''success''' import random user\_name = input('escribe tu nombre: ') print('-.-'\*10) print('Bienvenido ' , user\_name, ' a los juegos del hambre') print('.-.'\*10) round = 1 user\_victories = 0 computer\_victories = 0 game\_options = ('piedra', 'papel', 'tijera') while True: print('Ronda ', round) print('Current score: ', user\_name, ':', user\_victories, 'vs. Computer: ', computer\_victories) user\_option = input('Elige piedra, papel o tijera: ').lower() if user\_option not in game\_options: print('Selecciona una opcion correcta:') continue computer\_option = random.choice(game\_options) print('La computadora escogio', computer\_option) if user\_option == computer\_option: print('Han empatado!') elif (user\_option == 'piedra' and computer\_option == 'tijera') or \\ (user\_option == 'papel' and computer\_option == 'piedra') or \\ (user\_option == 'tijera' and computer\_option == 'papel'): print('Ganaste la ronda') user\_victories += 1 else: print('La computadora gano la ronda') computer\_victories += 1 round += 1 if user\_victories == 2: print('Conseguiste ganar, bien hecho!') break elif computer\_victories == 2: print('Haz sido derrotado :(') break
import random

options = ('piedra', 'papel', 'tijera')
computer_wins = 0
user_wins = 0
rounds = 1
points_win = int(input('Con cuantos puntos se gana la partida?'))

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 opción no es valida')
    else: 
        print('User option => ', user_option)
        computer_option = random.choice(options)
        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ó')
                computer_wins += 1
        elif user_option == 'papel':
            if computer_option == 'piedra':
                print('papel gana a piedra')
                print('user ganó')
                user_wins += 1
            else:
                print('tijera gana a papel')
                print('computer ganó')
                computer_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ó')
                computer_wins += 1
        if computer_wins == points_win:
            print("El ganador es la computadora", computer_wins, '-', user_wins)
            break
        
        if user_wins == points_win:
            print("El ganador es el usuario", user_wins, '-', computer_wins)
            break
        rounds += 1

Estuvo interesante el curso, demasiado básico. Faltaron las funciones :(
Cuidado al responder: Una cosa es Iterar y otra muy distinta es ejecutar. ![](https://static.platzi.com/media/user_upload/image-1431d7ef-66d9-4843-ad7e-d61c686b66e8.jpg)
![](https://static.platzi.com/media/user_upload/image-d02ac2dd-8a01-444e-8409-7c9db43e2780.jpg)
```js ``` ```js ``` ```python ```
import randomoptions = ('piedra', 'papel', 'tijera') computer\_win = 0user\_win = 0rounds = 1while True: #repetir        print('\*' \* 10)    print('round #', rounds)    print("rondas ganadas usuario: ", user\_win)    print("rondas ganadas computer: ", computer\_win)        useroption = input('piedra, papel o tijera: ')    useroption = useroption.lower()    rounds += 1 #incrementa el #de round     if not useroption in options:        print('opcion no es valida')        continue     computeroption = random.choice(options)     print('user option: ', useroption)     #empate ==    if useroption == computeroption:        print('Empate!')    elif useroption == 'piedra':        if computeroption == 'tijera':            print('piedra gana a tijera')            print('user gano')            user\_win += 1        else:            print('papel gana a piedra')            print('computador gano')            computer\_win += 1    elif useroption == 'papel':        if computeroption == 'piedra':            print('papel gana a piedra')            print('user gano')            user\_win += 1        else:            print('tijera gana a papel')            print('computador gano')            computer\_win += 1    elif useroption == 'tijera':        if computeroption == 'papel':            print('tijera gana a papel')            print('user gano')            user\_win += 1        else:            print('piedra gana tijera')            print('computador gano')            computer\_win += 1    #si el computador o el usuario llegan a dos rodas ganadas hay ganador definitivo    if computer\_win == 2:        print("ganador definitivamente computador")        print("Puntajes finales")        print("rondas ganadas usuario: ", user\_win)        print("rondas ganadas computer: ", computer\_win)        break    if user\_win == 2:        print("ganador definitivamente user")        print("Puntajes finales")        print("rondas ganadas usuario: ", user\_win)        print("rondas ganadas computer: ", computer\_win)        break   
Yo lo hice de esta manera, Una lucha epica al mejor de 5 entre la maquina y yo :) ```python import random user_wins = 0 computer_wins = 0 round = 0 print("***Bienvenido al Piedra Papel o Tijera***") print("***Opciones***") options = ("piedra", "papel", "tijera") user_option = input("piedra, papel o tijera: ").lower() while round < 5: print("******" * 2) print("***Ronda***", round + 1) print("******" * 2) computer_option = random.choice(options) if user_option == computer_option: print("empate") elif user_option == "piedra" and computer_option == "tijera": print("Ganaste!!") print("Piedra gana a tijera") user_wins += 1 elif user_option == "papel" and computer_option == "piedra": print("Ganaste!!") print("Papel gana a piedra") user_wins += 1 elif user_option == "tijera" and computer_option == "papel": print("Ganaste!!") print("Tijera gana a papel") user_wins += 1 else: print("Perdiste :(") print(f"Elegiste: {user_option}") print(f"La computadora eligió: {computer_option}") computer_wins += 1 if user_wins == 3 or computer_wins == 3: break if user_option not in options: print('Esa opción no es válida', '\n') continue round += 1 user_option = input("piedra, papel o tijera: ").lower() print("******" * 3) print("****Resultado****") print("******" * 3) if user_wins > computer_wins: print("Ganaste el juego") elif user_wins == computer_wins: print("Empate") elif user_wins < computer_wins: print("Perdiste el juego") ```import random user\_wins = 0 computer\_wins = 0 round = 0 print("\*\*\*Bienvenido al Piedra Papel o Tijera\*\*\*") print("\*\*\*Opciones\*\*\*") options = ("piedra", "papel", "tijera") user\_option = input("piedra, papel o tijera: ").lower() while round < 5: print("\*\*\*\*\*\*" \* 2) print("\*\*\*Ronda\*\*\*", round + 1) print("\*\*\*\*\*\*" \* 2) computer\_option = random.choice(options) if user\_option == computer\_option: print("empate") elif user\_option == "piedra" and computer\_option == "tijera": print("Ganaste!!") print("Piedra gana a tijera") user\_wins += 1 elif user\_option == "papel" and computer\_option == "piedra": print("Ganaste!!") print("Papel gana a piedra") user\_wins += 1 elif user\_option == "tijera" and computer\_option == "papel": print("Ganaste!!") print("Tijera gana a papel") user\_wins += 1 else: print("Perdiste :(") print(f"Elegiste: {user\_option}") print(f"La computadora eligió: {computer\_option}") computer\_wins += 1 if user\_wins == 3 or computer\_wins == 3: break if user\_option not in options: print('Esa opción no es válida', '\n') continue round += 1 user\_option = input("piedra, papel o tijera: ").lower() print("\*\*\*\*\*\*" \* 3) print("\*\*\*\*Resultado\*\*\*\*") print("\*\*\*\*\*\*" \* 3) if user\_wins > computer\_wins: print("Ganaste el juego") elif user\_wins == computer\_wins: print("Empate") elif user\_wins < computer\_wins: print("Perdiste el juego")
tengo un error y sale que tijera le gana a piedra y gana computadora...
```js import random def paper_rocks_scissors(scoreboard: list[int] = [0, 0]): game = { 'player_1': '', 'player_2': '' } def validate_option(player: str): if (game[player] != '3' and game[player] != '2' and game[player] != '1'): print('Esta opcion no es valida, empieza de nuevo') exit() game['player_1'] = input('Escoge una opcion! \n1) Piedra 🪨 \n2) papel 🧻 \n3) tijeras ✂️') validate_option('player_1') game['player_2'] = random.choice(('1', '2', '3')) if game['player_1'] and game['player_2']: print(f'Tu Escogiste {game["player_1"]}') print(f'Tu contrincante escogio {game["player_2"]}') win_conditions = ( (game['player_1'] == '1' and game['player_2'] == '3'), (game['player_1'] == '2' and game['player_2'] == '1'), (game['player_1'] == '3' and game['player_2'] == '2'), ) try: if win_conditions.index(True) >= 0: print('Has ganado! 🏆') scoreboard[0] += 1 except: if game['player_1'] == game['player_2']: print('Han Empatado') else: print('Has perdido 😔') scoreboard[1] += 1 repeat = input(f'El marcador va: {scoreboard[0]} vs {scoreboard[1]} \nQuieres jugar de nuevo? (si/no) 🎮') if repeat == 'si': paper_rocks_scissors(scoreboard=scoreboard) else: message = f'Gracias por jugar! 🎉 \n El marcador final es: {scoreboard[0]} vs {scoreboard[1]}' if scoreboard[0] == scoreboard[1]: print(f'{message}, Han empatado! 🏅') elif scoreboard[0] > scoreboard[1]: print(f'{message}, Has ganado! 🏅') else: print(f'{message}, Has perdido! 😔') paper_rocks_scissors() ```✅🎮
```python import random user_wins=0 computer_wins=0 rounds=1 while True: print('*'*20) print('ROUND',rounds) options = ('piedra', 'papel', 'tijeras') user_option = (input('piedra, papel o tijeras? =>').lower()) computer_option =random.choice(options) if user_option not in options: print('La opción no es válida 🚫') print("La opción del pc es "+ computer_option) if user_option == computer_option: print("¡Empate!") elif user_option=="piedra": if computer_option=="tijeras": print("piedra gana a tijeras") print("¡Ganaste!🎆") user_wins +=1 else: print("Papel gana a tijeras") print("Perdiste") computer_wins+=1 elif user_option=="papel": if computer_option== "piedra": print("papel gana a piedra") print("¡Ganaste!🎆") user_wins +=1 else: print("tijeras gana a papel") print("Perdiste") computer_wins+=1 elif user_option=="tijeras": if computer_option=="papel": print("tijeras gana a papel") print("¡Ganaste!🎆") user_wins +=1 else: print("piedra gana a tijeras") print("Perdiste") computer_wins+=1 rounds+=1 if (user_wins>=2): print(f"Ganaste {user_wins} de 3 veces") print("Eres el ganador🎆🎆🎆") elif (computer_wins>=2): print(f"Computadora ganó {computer_wins} de 3 veces") print("La computadora es la ganadora🎆🎆🎆") if (user_wins>=2 or computer_wins>=2): break ```
Dejo aquí mi humilde código (? ![](https://static.platzi.com/media/user_upload/codigo-bce03449-8766-49f2-bbbe-45307c150060.jpg)
pobre bart siempre usa piedra * la siempre confiable piedra nadie le gana
Lo hice de tal forma que el usuario decide cuando terminar el juego: ```python import random #importa la función random al código over= False confirmation = 'y' pc_wins= 0 user_wins=0 rounds=1 empates = 0 while over == False: print('*' * 10) print(' ROUND ', rounds) print('*' * 10) options = ('piedra', 'papel', 'tijeras') continua = ('y','n') user_option=input('Elige => Piedra, papel o tijeras: ') user_option=user_option.lower() #evito que por las mayusculas no las reconozca #eliminando las opciones random que escribe el usuario: while not user_option in options: #aqui preguntamos si lo que escribe el usuario no está dentro de mis opciones pues que lo mande a la gaver print('Esa opción no existe') user_option=input('Elige => Piedra, papel o tijeras: ') user_option=user_option.lower() #evito que por las mayusculas no las reconozca pc_option= random.choice(options) # añadiendo aleatoriedad con la funcion random que elije algo al azar de la tupla o lista print('opción del usuario: ', user_option) print('opción del pc: ', pc_option) #Caso de Empate if user_option == pc_option: print('Empate') empates += 1 #En caso de elegir piedra elif user_option == 'piedra': if pc_option == 'tijeras': print('Piedra gana a tijeras') print('Ganó el usuario') user_wins += 1 else: print('Papel gana a piedra') print('ganó la PC') pc_wins += 1 #En caso de elegir papel elif user_option == 'papel': if pc_option == 'tijeras': print('Tijeras gana a papel') print('Ganó el PC') pc_wins += 1 else: print('Papel gana a piedra') print('ganó el usuario') user_wins += 1 #En caso de elegir tijeras elif user_option == 'tijeras': if pc_option == 'papel': print('Tijeras gana a papel') print('Ganó el usuario') user_wins += 1 else: print('Piedra gana a tijeras') print('ganó el PC') pc_wins += 1 print('\n') print('Así van las cuentas: ') print('Victorias del usuario: ', user_wins) print('Victorias de la PC: ', pc_wins) print('Empates: ', empates) print('\n') rounds += 1 confirmation = input ('¿Quieres jugar otra vez? Y/N ') confirmation=confirmation.lower() while not confirmation in continua: confirmation = input ('Elija entre => Y/N ') confirmation=confirmation.lower() if confirmation == 'n': over= True if user_wins > pc_wins: print('*' * 35) print('El usuario es el ganador esta vez') print('*' * 35) elif user_wins < pc_wins: print('*' * 30) print('El PC es el ganador esta vez') print('*' * 30) else: print('*' * 20) print('Es un rotundo empate') print('*' * 20) ```
`import random` `options = ('piedra', 'papel', 'tijera')results = {  'piedra': {    'piedra': 'empate',    'papel': 'perdiste',    'tijera': 'ganaste'  },  'papel': {    'piedra': 'ganaste',    'papel': 'empate',    'tijera': 'perdiste'  },  'tijera': {    'piedra': 'perdiste',    'papel': 'ganaste',    'tijera': 'empate'  }}` `attempts = 0win = lose = draw = 0count_computer = count_user = 0` `print('Elige el número de una opcion...')` `for index, option in enumerate(options):    print(index + 1, '.-', option)` `while True:    print('¿Listo?...')    try:        try:            option_selected = int(input('Comencemos, escribe el número:  '))            if(option_selected < 1 or option_selected > 3):                print('La opción no esta dentro del catálogo. Por favor, ingresa un número del 1 al 3.')                continue            chosen_option = options[option_selected - 1]            random_value = random.choice(options)            result = results[chosen_option][random_value]            print('Eligiste: ', chosen_option, 'Maquina eligio: ', random_value)            if result == 'empate':                draw += 1                print('Hubo un empate.')            elif result == 'perdiste':                count_computer +=1                lose += 1                print('La máquina ganó.')            else:                count_user +=1                win += 1                print('¡Ganaste!')` `            if(count_computer == 2):                print('Se acabó el juego, te gano la computadora')                print('Los resultadosa son lo siguientes: ')                print('Empates: ', draw)                print('Perdidos: ', lose)                print('Ganados: ', win)                break            if(count_user == 2):                print('Se acabó el juego, le ganaste a la computadora')                print('Los resultadosa son lo siguientes: ')                print('Empates: ', draw)                print('Perdidos: ', lose)                print('Ganados: ', win)                break        except ValueError:            print("Ese no es un número. Por favor, ingresa un número del 1 al 3.")` `    except KeyboardInterrupt:        print('\nJuego interrumpido. Gracias por jugar!')`
```python import random choices = ('Rock', 'Paper', 'Scissors') total_rounds = 1 user_wins = 0 cpu_wins = 0 def print_score(user_wins, cpu_wins): print(f'{"-" * 10}Score{"-" * 10}' f'\nUser --> {user_wins}' f'\nCPU --> {cpu_wins}' f'\n{"-" * 25}') def get_user_pick(): user = '' userPick = int( input( 'Please pick rock, paper or scissors (Enter the number accordingly):' '\n 1. Rock' '\n 2. Paper' '\n 3. Scissors' '\n')) if (userPick == 1): user = choices[0] elif (userPick == 2): user = choices[1] elif (userPick == 3): user = choices[2] return user def random_cpu_pick(): cpu = random.choice(choices) return cpu def get_winner(user, cpu): result = '' if (user == cpu): result = 'Tie' if (user == choices[0] and cpu == choices[2]): result = 'User wins' if (user == choices[2] and cpu == choices[1]): result = 'User wins' if (user == choices[1] and cpu == choices[0]): result = 'User wins' if (user == choices[0] and cpu == choices[1]): result = 'CPU wins' if (user == choices[2] and cpu == choices[0]): result = 'CPU wins' if (user == choices[1] and cpu == choices[2]): result = "CPU wins" return result while (True): print('*' * 20) print('ROUND', total_rounds) print('*' * 20) userPick = get_user_pick() cpuPick = random_cpu_pick() winner = get_winner(userPick, cpuPick) if (userPick in choices): print(f'You picked --> {userPick}' f'\nThe CPU picked --> {cpuPick}' f'\n{winner}') else: print('Error. Your pick is not valid') continue if ('User' in winner): user_wins += 1 print_score(user_wins, cpu_wins) if (user_wins == 2): print('User takes it all') break if ('CPU' in winner): cpu_wins += 1 print_score(user_wins, cpu_wins) if (cpu_wins == 2): print('Machine is better than you') break total_rounds += 1 ```
wow
![](https://static.platzi.com/media/user_upload/imagen-926d3bd5-0e10-454f-b02d-147bd1c909d1.jpg) ![](https://static.platzi.com/media/user_upload/imagen-d9761713-3c00-4d46-9885-618a13633180.jpg) ![](https://static.platzi.com/media/user_upload/imagen-66d81b84-9795-4b66-a793-1551b336abeb.jpg)

import random # Importar el módulo random para generar la elección de la computadora

Paso 1: Solicitar al usuario el número de intentos

num_intentos = int(input("¿Cuántos intentos deseas jugar? "))

Diccionario de datos para mapear opciones

opciones = {1: ‘piedra’, 2: ‘papel’, 3: ‘tijera’}

Inicializar contadores de victorias del usuario y la computadora

victorias_usuario = 0
victorias_computadora = 0

Comenzar el bucle de juego

for intento in range(1, num_intentos + 1):
print(f"\nIntento {intento}😊

# Paso 2: Obtener la elección del usuario
print("Elige: 1 - Piedra, 2 - Papel, 3 - Tijera")
eleccion_usuario = int(input("Tu elección: "))

# Validar la elección del usuario
if eleccion_usuario not in opciones:
    print("Elección no válida. Por favor, elige 1, 2 o 3.")
    continue  # Reiniciar el bucle si la elección no es válida

eleccion_usuario_texto = opciones[eleccion_usuario]
print(f"Elegiste: {eleccion_usuario_texto}")

# Paso 3: Generar la elección aleatoria de la computadora
eleccion_computadora = random.randint(1, 3)
eleccion_computadora_texto = opciones[eleccion_computadora]
print(f"La computadora elige: {eleccion_computadora_texto}")

# Paso 4: Determinar el ganador del intento
if eleccion_usuario == eleccion_computadora:
    print("Empate en este intento.")
elif (
    (eleccion_usuario == 1 and eleccion_computadora == 3) or
    (eleccion_usuario == 2 and eleccion_computadora == 1) or
    (eleccion_usuario == 3 and eleccion_computadora == 2)
):
    print("¡Ganaste este intento!")
    victorias_usuario += 1
else:
    print("La computadora gana este intento.")
    victorias_computadora += 1

Paso 5: Mostrar el resultado final

print("\nResultados Finales:")
print(f"Victorias del Usuario: {victorias_usuario}")
print(f"Victorias de la Computadora: {victorias_computadora}")

if victorias_usuario > victorias_computadora:
print("¡Felicidades, ganaste el juego!")
elif victorias_usuario < victorias_computadora:
print(“La computadora ganó el juego. ¡Mejor suerte la próxima vez!”)
else:
print(“El juego terminó en empate.”)

![](https://static.platzi.com/media/user_upload/Captura%20de%20Pantalla%202024-01-02%20a%20la%28s%29%2017.18.51-8472fbd7-d59e-43b1-b0dc-48a9b1a30dcc.jpg)
```js import random opciones=("piedra","papel","tijera") puntuacion_jugador=0 puntuacion_computadora=0 mejor_de = 3 for _ in range(mejor_de): eleccion_jugador = input("Inserte: piedra, papel o tijera: ").lower() #lower():minusculas print(f"Ingresaste: {eleccion_jugador}") eleccion_computadora = random.choice(opciones) print(f"La computadora eligio:{eleccion_computadora}") if ( (eleccion_jugador == "piedra" and eleccion_computadora == "tijera") or (eleccion_jugador == "tijera" and eleccion_computadora == "papel") or (eleccion_jugador == "papel" and eleccion_computadora == "piedra") ): print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("¡Ganaste esta ronda!") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") puntuacion_jugador += 1 elif eleccion_jugador == eleccion_computadora: print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("Empate!") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") else: print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("La computadora gana esta ronda.") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") puntuacion_computadora += 1 if (puntuacion_jugador>=2): print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("") print("¡Ganaste!") print("") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") elif (puntuacion_jugador<=1) and (puntuacion_computadora<=1): print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("") print("¡Empataste con la computadora!") print("") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") else: print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") print("") print("") print("¡Perdiste!") print("") print("") print("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-") ```Dejo aca mi codigo!
`import random` `list_choices = ["piedra", "papel", "tijera"]` `puntos_user = 0` `puntos_bot = 0` `print("¡Bienvenido a piedra, papel o tijera!")` `print("--------------------------------------")` `while puntos_user < 3 and puntos_bot < 3:` ` user_choise = str(input("Elija una opcion entre piedra papel o tijera: "))` ` user_choice = user_choise.lower()` ` if user_choise not in list_choices:` ` print("Esa palabra no esta dentro de las tres opciones...")` ` continue` ` bot_choise = random.choice(list_choices)` ` if user_choise == "papel" and bot_choise == "papel" or user_choise == "piedra" and bot_choise == "piedra" or user_choise == "tijera" and bot_choise == "tijera":` ` print("empate")` ` continue` ` elif user_choise == "piedra" and bot_choise == "papel" or user_choise == "papel" and bot_choise == "tijera" or user_choise == "tijera" and bot_choise == "piedra":` ` print("bot win round, bot choice: " + bot_choise)` ` puntos_bot += 1` ` elif bot_choise == "piedra" and user_choise == "papel" or bot_choise == "papel" and user_choise == "tijera" or bot_choise == "tijera" and user_choise == "piedra":` ` print("user win round, bot choice: " + bot_choise)` ` puntos_user += 1` ` if puntos_user == 3:` ` print("USER WIN MATCH")` ` elif puntos_bot == 3:` ` print("BOT WIN MATCH")`
import random vidas = 3 vidaspc = 3 print("Juego de piedra papel o tijera") print("------------------------------") print() def juego(): global vidas global vidaspc opcion = input("Escoge entre piedra, papel o tijera: ") opcion = opcion.lower() print("Escogiste",opcion) lista =\["piedra","papel","tijera"] pc = random.choice(lista) if pc == "piedra": if opcion == pc: print("empataste pc escogio", pc) elif opcion == "papel": print("Ganaste pc escogio", pc) vidaspc = vidaspc-1 elif opcion == "tijera": vidas = vidas-1 print("Perdiste, PC escogio", pc) else: print("Elige entre piedra, papel o tijera") elif pc == "papel": if opcion == pc: print("empataste pc escogio", pc) elif opcion == "tijera": print("Ganaste pc escogio", pc) vidaspc = vidaspc-1 elif opcion == "piedra": vidas = vidas -1 print("Perdiste, PC escogio", pc) else: print("Elige entre piedra, papel o tijera") elif pc == "tijera": if opcion == pc: print("empataste pc escogio", pc) elif opcion == "piedra": print("Ganaste pc escogio", pc) vidaspc = vidaspc-1 elif opcion == "papel": vidas = vidas-1 print("Perdiste, PC escogio", pc) else: print("Elige entre piedra, papel o tijera") else: print("Fin") while vidas > 0 : if vidas > 0 and vidaspc > 0 : juego() print("Te quedan:",vidas,"vidas") print("A PC le quedan:",vidaspc,"vidas") if vidas > 0 and vidaspc > 0 : print("Denuevo!") print("") else: print() elif vidas > 0 and vidaspc <= 0: print("PC pierde") break elif vidaspc > 0 and vidas <= 0: print("Perdiste") break print("Perdiste")
?jhv
Juego Papel, Piedra o Tijera con número de rondas <https://replit.com/@luisguil/JuegoPapelPiedraTijera?v=1>
interesante
Muy bueno el curso como introduccion a Python ⭐⭐⭐⭐⭐
Muy buen curso!
```python import random rounds = 1 wins = 0 losses = 0 while (wins < 3) and (losses < 3): print("*" * 10) print("Round: ", rounds) print("*" * 10) rounds += 1 def get_user_choice(): print('Juego de piedra, papel o tijera') user_choice = int( input(''' ingrese: 1) para Piedra 2) para Papel 3) para Tijera ''')) return user_choice def choice(a): choices = {1: 'Piedra', 2: 'Papel', 3: 'Tijeras'} return choices.get(a, 'Perder') def tex(user, pc): print(f'Has elegido: {choice(user)}') print(f'El enemigo ha elegido: {choice(pc)}') def main(): global wins, losses user = get_user_choice() pc = random.randint(1, 3) tex(user, pc) if pc == user: print('Es un empate') elif (user, pc) in [(1, 3), (2, 1), (3, 2)]: print('Has ganado 😎') wins += 1 else: print('Has perdido 😭') losses += 1 if __name__ == "__main__": main() ```import random rounds = 1wins = 0losses = 0 while (wins < 3) and (losses < 3):  print("\*" \* 10)  print("Round: ", rounds)  print("\*" \* 10)  rounds += 1   def get\_user\_choice():    print('Juego de piedra, papel o tijera')    user\_choice = int(        input('''      ingrese:       1) para Piedra       2) para Papel       3) para Tijera      '''))    return user\_choice   def choice(a):    choices = {1: 'Piedra', 2: 'Papel', 3: 'Tijeras'}    return choices.get(a, 'Perder')   def tex(user, pc):    print(f'Has elegido: {choice(user)}')    print(f'El enemigo ha elegido: {choice(pc)}')   def main():    global wins, losses    user = get\_user\_choice()    pc = random.randint(1, 3)     tex(user, pc)     if pc == user:      print('Es un empate')    elif (user, pc) in \[(1, 3), (2, 1), (3, 2)]:      print('Has ganado 😎')      wins += 1    else:      print('Has perdido 😭')      losses += 1   if \_\_name\_\_ == "\_\_main\_\_":    main()
Hice este codigo, con todo en ingles ya que estamos, pero le inclui descripciones en español para el que quiera entender. ```python import random options = ('rock', 'paper', 'scissors') #declaramos el enfrentamiento como una funcion para no agregar otro bodoque de texto al codigo def battle (a, b): if ((a == 'rock' and b == 'scissors') or (a == 'scissors' and b == 'rock')): winner = 'rock' return winner elif ((a == 'paper' and b == 'scissors') or (a == 'scissors' and b == 'paper')): winner = 'scissors' return winner else: winner = 'paper' return winner #declaracion de variables que usaremos dentro del loop user_choice = 'none' user_win = 0 computer_win = 0 replay = 'first play' print ('\nThis is THE rock paper and scissors game\n') #loop principal while (user_choice != 'quit'): #adentro de este if esta la logica del juego, saldremos de esta rama una vez uno llegue a 3 victorias if (computer_win < 3 and user_win < 3): print('The one who gets to three wins first will win the game \n\nThe score right now is: \nComputer =', computer_win, '\nUser =', user_win, '\n') user_choice = input('Type rock, paper or scissors. If you want to quit, type quit: ') computer_choice = random.choice(options) user_choice = user_choice.lower() if (user_choice == 'quit'): print ("\nYOU HAVE QUITTED") #al declarar el user_choice como quit el programa automaticamente terminara else: print ('\nYour choice ==> ', user_choice) print ("Computer's choice ==> ", computer_choice) if (computer_choice == user_choice): print("\nIt's a TIE!\n") elif (not user_choice in options): print ("\nYou didn't type a valid option\n") else: #aca invocamos la funcion que preparamos antes, haciendo las cosas mas simples. if (battle (user_choice, computer_choice) == user_choice): print ('\nUser wins this round\n') user_win +=1 else: print ('\nComputer wins this round\n') computer_win +=1 #Cuando uno llegue a 3 victorias, el programa pasara a esta instancia dando un score final y dandole la posibilidad al usuario de jugar de nuevo. else: if (user_win == 3): while (user_win == 3): print('FINAL SCORE:\n COMPUTER ==>', computer_win, '\n USER ==>', user_win) print('\nUSER WON') replay = input('\nDo you want to play again? y/n: ') if (replay == 'y'): user_win = 0 computer_win = 0 replay = 'again' #seteamos todos los scores a 0 para volver al juego continue elif (replay == 'n'): user_choice = 'quit' #aca rompemos el sub-ciclo while con un break y el ciclo while que engloba todo mediante el quit break else: print("You didn't type a valid option") #gracias al sub ciclo while si el usuario no escribe algo correcto, podra volver a intentarlo continue else: while (computer_win == 3): print('FINAL SCORE:\n COMPUTER ==>', computer_win, '\n USER ==>', user_win) print('\nCOMPUTER WON') #a partir de aca se repite el codigo de arriba replay = input('\nDo you want to play again? y/n: ') if (replay == 'y'): user_win = 0 computer_win = 0 replay = 'again' continue elif (replay == 'n'): user_choice = 'quit' break else: print("\nYou didn't type a valid option\n") continue ```

import random

def piedra_papel_tijeras():
""“
Función que devuelve una lista con las opciones del jugador y el ordenador.
”""
opciones = [“piedra”, “papel”, “tijeras”]
ordenador = random.choice(opciones)
return opciones, ordenador

def ganar(jugador, ordenador):
""“
Función que devuelve True si el jugador gana, False en caso contrario.
”""
if jugador == ordenador:
return False
elif jugador == “piedra” and ordenador == “tijeras”:
return True
elif jugador == “papel” and ordenador == “piedra”:
return True
else:
return False

def jugar():
""“
Función principal del juego.
”"“
opciones, ordenador = piedra_papel_tijeras()
jugador = input(”¿Qué elegiría? (piedra, papel, tijeras)? “)
if ganar(jugador, ordenador):
print(”¡Has ganado!")
else:
print("¡Has perdido!")

while True:
jugar()
print("¿Quieres jugar de nuevo? (s/n)? ")
respuesta = input().lower()
if respuesta != “s”:
break

import random

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

computer_wins = 0
user_wins = 0

round = 1

print(“Juega piedra papel o tijeras, gana 3 veces para ser el vencedor”)

while True:
print("" * 10)
print(“ROUND”, round)
print("
" * 10)

user_option = input("Elige entre piedra, papel o tijera: ")
user_option = user_option.lower()

if not user_option in options:
print(“opción no válida”)
continue

computer_option = random.choice(options)

if user_option == computer_option:
print(“empate!”)

elif user_option == “piedra”:
if computer_option == “tijera”:
print(“piedra gana a tijera”)
print(“Ganaste la ronda”)
user_wins += 1
else:
print(“papel gana a la piedra”)
print(“Gano la computadora 😦”)
computer_wins += 1

elif user_option == “papel”:
if computer_option == “piedra”:
print(“papel gana a piedra”)
print(“Ganaste la ronda”)
user_wins += 1
else:
print(“tijera gana a papel”)
print(“Gano la computadora 😦”)
computer_wins += 1

elif user_option == “tijera”:
if computer_option == “papel”:
print(“tijera gana a papel”)
print(“Ganaste la ronda”)
user_wins += 1
else:
print(“piedra gana a tijera”)
print(“Gano la computadora 😦”)
computer_wins += 1

if user_wins == 3:
print(“Felicidades!!! eres el gran vencedor”)
break

print("Victorias del usuario: ", user_wins)

print("Victorias de la computadora: ", computer_wins)

if computer_wins == 3:
print(“La computadora ha ganado, sigue intentado”)
break

round += 1

`import random` `round = 1winner = False` `userPoints = 0pcPoints = 0` `def figure(a):        figures = {1:'🥌 rock',2:'📃 paper',3:'✂️ scissors'}    return figures[a]` `print('Welcome to rock, paper, scissors game!')` `while winner == False:    print("This is the round number ",round)    print(f"\n User has {userPoints} points and PC has {pcPoints} points.\n")        user = int(input('Select a figure: 1=Rock🥌, 2=Paper📃, 3=Scissors✂️'))    pc = random.randrange(1,3)        print(f"User selected {figure(user)} and PC selected {figure(pc)}")        if user == pc:        print("DRAW")    elif (user==1 and pc==3)or(user==2 and pc==1)or(user==3 and pc==2):        print("USER WINS!")        userPoints+=1    else:        print("PC WINS!")        pcPoints+=1        round+=1        if userPoints - pcPoints == 2:        print("--------------------USER WINS THE GAME--------------------")        winner = True    elif pcPoints - userPoints == 2:        print("--------------------PC WINS THE GAME--------------------")        winner = True`

Que Buen curso!!!

import random options = ('piedra', 'papel', 'tijera') 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) user\_option = input('piedra, papel o tijera => ') user\_option = user\_option.lower() rounds += 1 if not user\_option in options: print('esa opcion no es valida') continue 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 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 if computer\_wins == 2: print('El ganador es la computadora') break if user\_wins == 2: print('El ganador es el usuario') break
Buen curso para repasar!, muchas gracias

Me encanto este curso. Aprendi mucho para mejorar mis habilidades basicas para data science. El camino es muy largo pero llegare a mi resultado.

en lugar de poner while True, no sería mejor poner una condición que pueda suceder en algún momento de la ejecución? Como while not(user\_wins == 2) or (computer\_wins == 2): código

**Aqui esta mi aporte
**

<code> 
import random
print(" "*20)
print("*"*20)
print("Welcome to the rock, paper and scissors,  game!")
print("*"*20)
options = ("piedra","papel","tijera")

rounds = 1
computer_win = 0
user_win = 0

while True:
  print(" "*20)
  print("*"*10)
  print("ROUND ", rounds)
  print("*"*10)
  print(" "*20)
  print("El computador lleva", computer_win, " y el usuario lleva" , user_win, "victoria(s)")
  print(" "*20)
  user = input("¿piedra, papel o tijera?: ")
  computer_option = random.choice(options)
  print(" "*20)
  print("El usuario eligio = ", user)
  print("la computadora eligio = ", computer_option)
  user = user.lower()
  if not user in options:
    print("*"*20)
    print("Esa opción no es valida, repite la ronda")
    print("*"*20)
    continue
    

    
  if user == computer_option:
      print(" "*20)
      print("Empate!")
    
  elif (user == "piedra" and computer_option ==
      "tijera") or \
       (user == "papel" and computer_option ==
      "piedra") or \
       (user == "tijera" and computer_option == 
      "papel"):
      print(" "*20)
      print("Ganaste")
      user_win += 1
  else:
      print(" "*20)
      print("Perdiste")
      computer_win +=1

  if computer_win == 2 :
    print(" "*20)
    print("El Computador Gano el Juego !!!!")
    break

  if user_win == 2 : 
    print(" "*20)
    print("Ganaste el Juego !!!!")
    break
  rounds +=1

Esta es mi solución: ```js import random #JUEGO PIEDRA, PAPEL O TIJERA #Tupla con la opciones a escoger opcionesJuego = ("piedra", "papel", "tijera") #Inicializacion de variables para el ciclo while puntosUsuario = 0 puntosMaquina = 0 while puntosMaquina < 3 and puntosUsuario < 3: #Input para escoger la opcion user_option = input("Escoge: PIEDRA, PAPEL O TIJERA => ") #tratamiento de los datos del input para dejarlos en minuscula user_option = user_option.lower() #Validacion del input del usuario if user_option in opcionesJuego: print(f'opcion correcta, escogiste => {user_option}') else: while not user_option in opcionesJuego: user_option = input("Escoge: PIEDRA, PAPEL O TIJERA => ") user_option = user_option.lower() print(f'opcion correcta, escogiste => {user_option}') #Generacion de opcion de juego de la maquina computer_option = random.choice(opcionesJuego) print(f'La computadora Escogio: {computer_option}') #Condicionales para saber quien gano if user_option == computer_option: print("EMPATE") elif user_option == opcionesJuego[2] and computer_option == opcionesJuego[1]: puntosUsuario += 1 print("Ganamos") elif user_option == "papel" and computer_option == "piedra": puntosUsuario += 1 print("Ganamos") elif user_option == "piedra" and computer_option == "tijera": puntosUsuario += 1 print("Ganamos") else: puntosMaquina += 1 print("PERDIMOS") print(f'TUS PUNTOS SON: {puntosUsuario}') print(f'LOS PUNTOS DE LA MAQUINA SON: {puntosMaquina}') #Condicional para generar texto del ganador if puntosMaquina == 3 or puntosUsuario == 3: if puntosMaquina == 3: print("gano la MAQUINA") else: print("FELICIDADES GANASTE") ```
import random

options = ("piedra", "papel" , "tijera");

rounds = 1;
pc_wins = 0;
user_wins = 0;

while True:

    print("*" *20);
    print("ROUND", rounds);
    print("*" *20);

    print("pc wins", pc_wins);
    print("user wins", user_wins);

    user = input("Elige una opción: piedra, papel o tijera ").lower();

    rounds += 1;

    if not user in options:
        print("Debiste escoger entre piedra, papel o tijera.");
        continue;

    pc = random.choice(options);

    if user == pc:
        print(pc);
        print("Empate.");
    elif user == "piedra":
        if pc == "papel":
            print(pc);
            print("Perdiste.");
            pc_wins += 1;
        if pc == "tijera":
            print(pc);
            print("Ganaste.");
            user_wins += 1;
    elif user == "papel":
        if pc == "piedra":
            print(pc);
            print("Ganaste.");
            user_wins += 1;
        if pc == "tijera":
            print(pc);
            print("Perdiste.");
            pc_wins += 1;
    elif user == "tijera":
        if pc == "piedra":
            print(pc);
            print("Perdiste.");
            pc_wins += 1;
        if pc == "papel":
            print(pc);
            print("Ganaste.");
            user_wins += 1;
    else:
        print("Entrada invalida.");

    if pc_wins == 2:
        print("pc VENCEDOR!");
        break;

    if user_wins == 2:
        print("user VENCEDOR!");
        break;
Ya estamos terminando el curso y yo sigo en ciertas ocasiones, colocando en ciertas líneas el ";" jaja xD la costumbre

Dejo mi aporte, espere les sea útil, definí varias funciones para tenerlo más ordenado, también definí variables globales para usarlas dentro de diferentes funciones y use un cosito que borra la pantalla de la consola en cada iteración de while

import random

import os

#Variabes Globales para usar dentro de funciones diferentes
ganar_maquina = 0
ganar_usuario = 0


# pedimos al usuario que elija una opcion, y validamos que lo que elijio este en las opciones
def obtener_opcion_usuario():
    opciones = ["piedra", "papel", "tijera", "lagarto", "spok"]
    while True:
        opcion_usuario = input(f"Elige una opcion {(opciones)}: ").lower()
        if opcion_usuario in opciones:
            return opcion_usuario
        else:
          #cuando la opcion no es valida borra lo que habia anterior mente en la pantalla
            os.system('clear')
            print(f"{opcion_usuario} no es una opcion valida: intentalo de nuevo")
            print("*" * 30)

        

# hacemos que la computadora elija de manera aleatoria con la libreria random
def optener_opcion_computadora():
    opciones = ["piedra", "papel", "tijera", "lagarto", "spok"]
    return random.choice(opciones)


# mediante los if y los elif comparamos todas las combinaciones y retornamos el resultado
def elegir_ganador(opcion_usuario, opcion_computadora):
    #Aqui estan las variables que definimos en el entorno global
    global ganar_maquina
    global ganar_usuario
    if opcion_usuario == opcion_computadora:
        return "Empate"
    elif (opcion_usuario == "tijera" and opcion_computadora == "papel"):
        ganar_usuario += 1
        return "Tú Ganas: Tijera corta Papel"
    elif (opcion_usuario == "tijera" and opcion_computadora == "lagarto"):
        ganar_usuario += 1
        return "Tú Ganas: Tijera decapita lagarto"
    elif (opcion_usuario == "tijera" and opcion_computadora == "piedra"):
        ganar_maquina += 1
        return "Tú Pierdes: piedra aplasta tijera"
    elif (opcion_usuario == "tijera" and opcion_computadora == "spok"):
        ganar_maquina += 1
        return "Tú pierdes: spok rompe tijera"
    elif (opcion_usuario == "papel" and opcion_computadora == "piedra"):
        ganar_usuario += 1
        return "Tú Ganas: papel tapa piedra"
    elif (opcion_usuario == "papel" and opcion_computadora == "spok"):
        ganar_usuario += 1
        return "Tu ganas: papel desautoriza spok"
    elif (opcion_usuario == "papel" and opcion_computadora == "tijera"):
        ganar_maquina += 1
        return "Tu pierdes; tijera corta papel"
    elif (opcion_usuario == "papel" and opcion_computadora == "lagarto"):
        ganar_maquina += 1
        return "Tu pierndes; lagarto devora pepel"
    elif (opcion_usuario == "piedra" and opcion_computadora == "tijera"):
        ganar_usuario += 1
        return "Tu ganas: la buena pidra aplasta tijera"
    elif (opcion_usuario == "piedra" and opcion_computadora == "lagarto"):
        ganar_usuario += 1
        return "Tu ganas: piedra descalabra lagarto"
    elif (opcion_usuario == "piedra" and opcion_computadora == "papel"):
        ganar_maquina += 1
        return "Tu pierdes; papel tapa pidra"
    elif (opcion_usuario == "piedra" and opcion_computadora == "spok"):
        ganar_maquina += 1
        return "tu piedes: spok vaporiza pidra"
    elif (opcion_usuario == "lagarto" and opcion_computadora == "spok"):
        ganar_usuario += 1
        return "tu ganas : lagarto envenena a spok"
    elif (opcion_usuario == "lagarto" and opcion_computadora == "papel"):
        ganar_usuario += 1
        return "tu ganas: lagarto devora papel"
    elif (opcion_usuario == "lagarto" and opcion_computadora == "tijera"):
        ganar_maquina += 1
        return "tu piedes; tijera decapita a lagarto"
    elif (opcion_usuario == "lagarto" and opcion_computadora == "piedra"):
        ganar_maquina += 1
        return "tu pierdes; piedra descalabra lagarto"
    elif (opcion_usuario == "spok" and opcion_computadora == "tijera"):
        ganar_usuario += 1
        return "Tu ganas: spok rompe tijera"
    elif (opcion_usuario == "spok" and opcion_computadora == "piedra"):
        ganar_usuario += 1
        return "tu ganas; spok vaporiza pidra"
    elif (opcion_usuario == "spok" and opcion_computadora == "papel"):
        ganar_maquina += 1
        return "tu pierdes: papel desautoriza spok"
    elif (opcion_usuario == "spok" and opcion_computadora == "lagarto"):
        ganar_maquina += 1
        return "Tu pierdes; lagarto envenena a spok"
    else:
        print("opcion invalida, ententa de nuevo")


# definimos jugar y comparamos las opciones elejidas
def jugar():
    #Aqui estan las variables que definimos en el entorno global
    global ganar_maquina
    global ganar_usuario
    rounds = 1
    while True:
      
        print('*' * 40)
        print('ROUND', rounds)
        print('*' * 40)

        opcion_usuario = obtener_opcion_usuario()
        opcion_computadora = optener_opcion_computadora()

        print("*" * 40)
        os.system('clear')
        print(f"===> Tú elegiste {opcion_usuario}")
        print(f"===> La computadora eligio {opcion_computadora}")

        resultado = elegir_ganador(opcion_usuario, opcion_computadora)
        print("*" * 40)

        print(resultado)
        print("*" * 40)
        print(f"El usuario ah ganado {ganar_usuario} veces \nLla computadora ah ganado {ganar_maquina} veces")

        rounds += 1
        # Cuando entre a cualquiera de estos 2 if el ejecutara el breake y terminara el juego
        if ganar_maquina == 2:
            os.system('clear')
            print('ROUND', rounds)
            print(f"El usuario ah ganado {ganar_usuario} veces \nLla computadora ah ganado {ganar_maquina} veces")
            print("La computadora ganó")
            break
        if ganar_usuario == 2:
            os.system('clear')
            print('ROUND', rounds)
            print(f"El usuario ah ganado {ganar_usuario} veces \nLa computadora ah ganado {ganar_maquina} veces")
            print("Tú ganas")
            break
#Inuciamos la funcion Jugar
if True:
    jugar()
<code> 
import random

opciones_ganadoras = {"piedra": "tijera", "papel": "piedra", "tijera": "papel"}


def determinar_ganador(user, computer):
  if user == computer:
    return "Empate!"
  if computer == opciones_ganadoras[user]:
    return "Jugador gana!"
  return "Computadora gana!"


opciones = ("piedra", "papel", "tijera")

user = ""
while user not in opciones:
  user = input("Ingrese una opción válida: ")
computer = random.choice(opciones)
print(f"Jugador eligió: {user}")
print(f"Computadora eligió: {computer}")
#print(opciones_ganadoras[user])
print(determinar_ganador(user, computer))