5일차 [ 파이썬 기초 (가위바위보 고도화,묵찌빠) ]

가위바위보 고도화

# 두 명의 사용자 이름과 가위바위보 중 하나씩 받고 
# 그 두개의 입력을 받아 승패여부를 결정하는 함수 실행

"""
포함 구문
- while
- try/except
- Error class
"""
import enum
class RockScissorPaper(enum.Enum):
    가위 = {
        "바위":"패배",
        "보":"승리"
    }

    바위 = {
        "보":"패배",
        "가위":"승리"
    }
    보 = {
        "가위":"패배",
        "바위":"승리"
    }
class InputError(Exception):
    def __init__(self):
        super().__init__('가위,바위,보 중 하나 입력해주세요.')

def rock_scissor_paper_game(u1,u2):
    if u1 == u2:
        return "무승부."
    else:
        return RockScissorPaper[u1].value[u2]
        

if __name__ == "__main__":
    try:
        # 입력값 확인
        rsp = RockScissorPaper.__members__
        u1 = input('사용자 1의 선택을 입력해주세요.: ')
        if u1 not in rsp:
            raise InputError()
        u2 = input('사용자 2의 선택을 입력해주세요.: ')
        if u2 not in rsp:
            raise InputError()
        
        # 승패 여부 결정
        result = rock_scissor_paper_game(u1, u2)
        print(f"사용자1이 사용자2에게 {result}")
    except Exception as e:
        print(e)

RockScissorPaper.__members__
def rock_scissor_paper_game(rsp_input):
    u1,u2 = rsp_input.split(',')
    rsp = RockScissorPaper.__members__

    assert (u1 in rsp) and (u2 in rsp), "가위,바위,보 중 하나 입력해주세요"
    
    if u1 == u2:
        return "무승부."
    else:
        return RockScissorPaper[u1].value[u2]
        

if __name__ == "__main__":
    rsp_input = input('가위바위보 중 하나씩 2개를 콤마로 구분하여 \
                      입력해주세요. ex)가위, 바위: ')
    result = rock_scissor_paper_game(rsp_input)
    print(f"첫번째 사용자가 두번째 사용자에게 {result}")

 

컴퓨터와 가위바위보 하기

# 사용자가 가위바위보 중 하나 입력시 
# 컴퓨터가 랜덤하게 선택한 바에 따라 승패 결정하기
# 무승부시 다시 시작작

import enum
import random

class RockScissorPaper(enum.Enum):
    가위 = {
        "바위":"패배",
        "보":"승리"
    }

    바위 = {
        "보":"패배",
        "가위":"승리"
    }
    보 = {
        "가위":"패배",
        "바위":"승리"
    }


class InputError(Exception):
    def __init__(self):
        super().__init__('가위,바위,보 중 하나 입력해주세요.')

def get_input():
        u1 = input('사용자 1의 선택을 입력해주세요.: ')
        if u1 not in rsp:
            raise InputError()
        else:
            return u1

def rock_scissor_paper_game(u1,computer_selection):
    if u1 == computer_selection:
        return "무승부."
    else:
        return RockScissorPaper[u1].value[computer_selection]
        


if __name__ == "__main__":
    try:
        # 입력값 확인
        rsp = RockScissorPaper.__members__
        u1= get_input()
        # computer이 가위,바위,보 중 하나 선택
        computer_selection = random.choice(list(rsp.keys()))
        print(f'컴퓨터는 {computer_selection}')

        # 승패 여부 결정
        # assert u1 != computer_selection, '무승부입니다. 다시 게임을 시작합니다.'
        if u1 == computer_selection:
            print('무승부입니다. 다시 게임을 시작합니다.')
            u1=get_input()
            result = rock_scissor_paper_game(u1, computer_selection)
            print(result)
        else:
            result = rock_scissor_paper_game(u1,computer_selection)
            print(result)
    except Exception as e:
        print(e)

챗지피티가 짜준 코드

import random

def get_computer_choice():
    choices = ['가위', '바위', '보']
    return random.choice(choices)

def get_user_choice():
    user_input = input("가위, 바위, 보 중 하나를 선택하세요: ")
    while user_input not in ['가위', '바위', '보']:
        print("잘못된 입력입니다. 다시 선택하세요.")
        user_input = input("가위, 바위, 보 중 하나를 선택하세요: ")
    return user_input

def determine_winner(user_choice, computer_choice):
    if user_choice == computer_choice:
        return "비겼습니다!", True
    elif (user_choice == '가위' and computer_choice == '보') or \
         (user_choice == '바위' and computer_choice == '가위') or \
         (user_choice == '보' and computer_choice == '바위'):
        return "사용자가 이겼습니다!", False
    else:
        return "컴퓨터가 이겼습니다!", False

def play_game():
    while True:
        user_choice = get_user_choice()
        computer_choice = get_computer_choice()
        print(f"사용자 선택: {user_choice}")
        print(f"컴퓨터 선택: {computer_choice}")
        result, is_draw = determine_winner(user_choice, computer_choice)
        print(result)
        if not is_draw:
            break

if __name__ == "__main__":
    play_game()

상수 enum활용해서 다시 작성

# 사용자 입력, 컴퓨터 입력
# 사용자 입력값이 제대로 되었는 지 스크리닝
# 비기면 다시 시작
# 이겼는 지, 졌는 지 판별
import random
import enum
class RockScissorPaper(enum.Enum):
    가위 = {
        "바위":"패배",
        "보":"승리"
    }

    바위 = {
        "보":"패배",
        "가위":"승리"
    }
    보 = {
        "가위":"패배",
        "바위":"승리"
    }


def get_user_choice():
    user_choice = input('가위,바위,보 중 하나를 입력해주세요: ')
    assert user_choice in RockScissorPaper.__members__,'다시 입력해주세요.'
    return user_choice 

def get_computer_choice():
    computer_choice = random.choice(list(RockScissorPaper.__members__.keys()))
    return computer_choice

def determine_winner(user_choice,computer_choice):
    if user_choice ==computer_choice:
        print('비겼습니다. 게임을 다시 시작합니다.')
        
    else:
        user_choice_enum = RockScissorPaper[user_choice]
        computer_choice_enum = RockScissorPaper[computer_choice]
        res = user_choice_enum.value[computer_choice_enum.name]
        print(f'사용자가 {user_choice}, 컴퓨터가 {computer_choice}로 유저가 {res}했습니다.')

def start_game():
    while True:
        user_choice = get_user_choice()
        computer_choice = get_computer_choice()
        determine_winner(user_choice,computer_choice)
        if user_choice != computer_choice:
            break

if __name__=='__main__':
    start_game()

 

묵찌빠

# 가위바위보 게임
# 1.두 명이 (유저, 컴퓨터) 가위,바위,보 중 하나 낸다.
# 2.가위바위보가 비기면 게임 재개
# 3.두 명이 가위바위보를 낼 때 같은 묵찌빠 중 하나를 외칠 때 
#  - 다른 것을 외치면 가위바위보 재개
#  - 같은 것을 외치면 가위바위보에서 이긴 사람이 최종 승자


import enum
import random

class RockPaperSissors(enum.Enum):
    가위 = {
        '바위':'패배',
        '보':'승리'
    }
    바위 = {
        '보':'패배',
        '가위':'승리'
    }
    보 = {
        '가위':'패배',
        '바위':'승리'
    }

RPS = RockPaperSissors

class 묵찌빠(enum.Enum):
    묵 = {'묵':True,'찌':False,'빠':False},
    찌 = {'묵':False,'찌':True,'빠':False},
    빠 = {'묵':False,'찌':False,'빠':True},

def get_rps_choice():
    computer_rps = random.choice(list(RockPaperSissors.__members__.keys()))
    user_rps = input('가위,바위,보 중 하나를 입력하세요: ')
    assert user_rps in RPS.__members__.keys(), '가위,바위,보 중 하나를 다시 입력하세요.'
    print(f'유저:{user_rps},컴퓨터:{computer_rps}')
    return computer_rps,user_rps

def get_mjb_choice():
    computer_mjb = random.choice(list(묵찌빠.__members__.keys()))
    user_mjb = input('묵,찌,빠 중 하나를 입력하세요.: ')
    assert user_mjb in 묵찌빠.__members__.keys(), '묵,찌,빠 중 하나를 다시 입력하세요.'
    return computer_mjb, user_mjb

# 가위바위보 게임
# 1.두 명이 (유저, 컴퓨터) 가위,바위,보 중 하나 낸다.
# 2.가위바위보가 비기면 게임 재개
# 3.두 명이 가위바위보를 낼 때 같은 묵찌빠 중 하나를 외칠 때 
#  - 다른 것을 외치면 가위바위보 재개
#  - 같은 것을 외치면 가위바위보에서 이긴 사람이 최종 승자

def start_game():
    while True:
        # 2.가위바위보가 다르면 게임 재개 (둘 중 하나 선택)
        computer_rps, user_rps = get_rps_choice()
        if not (computer_rps != user_rps):
            print('비겼습니다 .게임을 다시 시작합니다.')
            continue

        # 3.두 명이 가위바위보를 낼 때 같은 묵찌빠 중 하나를 외칠 때 
        computer_mjb, user_mjb = get_mjb_choice()
        #  - 3-1. 다른 것을 외치면 가위바위보 재개
        if not (computer_mjb == user_mjb):
            print(f'유저:{user_mjb},컴퓨터:{computer_mjb}\n묵찌빠 중 하나가 같지 않습니다. 게임을 다시 시작합니다.')
            continue

        #  - 3-2. 같은 것을 외치면 가위바위보에서 이긴 사람이 최종 승자
        if computer_mjb == user_mjb:
            result = RPS[user_rps].value[RPS[computer_rps].name]
            print(f'유저가 {user_rps,user_mjb},컴퓨터가 {computer_rps, computer_mjb}를 내어 \n\
            유저가 {result}했습니다.')
            break

        
if __name__=='__main__':
    start_game()