정리

• 새로운 객체지향이라는 내용을 배웠다. 데이터(속성)과 기능(함수)를 하나로 묶어 "객체"로 다루는 방법이라고 한다. 이해가 잘되지는 않으나 함수를 계속 만들었다보니 어떻게 어떻게 객체지향적(?)으로 코드를 작성은 하고 있다.
• 붕어빵틀과 붕어빵..! 쿠키틀과 쿠키를 잊지말자. 하나의 클래스로 틀을 만들고 계속 해서 값을 찍어낼 수 있게 생각을 하자.

필기

함수복습

• 생각보다 문제가 잘풀렸다. 입력, 계산까지는 잘하는데 마지막 출력에서 버벅인다. 출력에서 항상 뭐가 걸리는걸까...? 진짜 심오하게 생각해 볼 필요가 있다.'

global_x = 10 #함수외부에 변수를 선언함 
def myfunc1():
    #함수내부에서 변수에 값을 할당하는 순간 별도의 변수가 만들어진다.
    #예외적으로 외부 변수를 같이 사용하고 싶다면 global 을 앞에 붙인다. 
    global global_x
    global_x = 30 #global_x 는 지역변수 
                  #함수 내부에서만 존재하는 변수이다. 
    y = 20
    print( global_x, y) 

global_x=100
myfunc1()
print( global_x) # 30이 출력되길 원함 

#함수의 매개변수 기본값 
##dict로 받을때도 호출하는 방식은 유사하다 

def myfunc2(name="홍길동", age=21, phone="010-0000-0001"):
    print(name)
    print(age)
    print(phone) 
    
myfunc2()
myfunc2("임꺽정", 33)#필드 지정을 안하면 차례대로 값이 부여된다.
myfunc2(name="둘리")
myfunc2(age=23) 
myfunc2(phone="8-4833")
#함수를 동적으로 결정된다. 함수를 미리 만들어놓고 호출하면 정적으로 결정할수있는데 
#실행할때 함수가 결정되는 방식을 동적결정 
#컴파일러 언어들의 경우에는 컴파일 시간과 실행시간으로 나뉜다. 
#컴파일시간에 결정되면 정적할당 실행시간에 결정되면 동적할당이라고 한다 
#자바는 컴파일러임에도 불구하고 동적할당, 파이썬은 모든것이 실행시간에 결정된다. 
# 
# 제너레이터(개념만)- 우리가 막 만들어 써야 하는것은 아니고 용어 자체가 중요함 
# 값을 하나씩 생성해서 순회할 수 있는 함수나 객체, range 나 filter 가 해당된다. 
print(range(1, 6)) #range라는 함수는 for문안에서 호출하면 데이터 한개씩 만들어서 던져준다다
for i in range(1,6):
    print(i) 

#함수안에서 값을 반환하려면 return 과 yield 가 있다. 
#return은 값을 반환하면서 함수를 종료한다 
#yield는 값을 반환하는데 함수를 종료하지 않아요 대기상태 

def myrange(start=1, end=5):
    i=start
    while i<=end:
        yield i #이 구문을 만나는 순간 값을 하나 반환하고 멈춘다.
        i = i + 1

gen = myrange(end=1000) #함수 호출해서 저장해놓고 next를 통해서 호출한다. 
#이때 제너레이터 객체가 따로 만들어진다. 내부적으로 파이썬이 일반함수를 제너레이터 객체로 
#만들어서 객체 참조를 gen한테 전달  myrange(함수)=> 제너레이터로 변환 
#next 나 for문으로 
print( next( gen ))
print( next( gen ))
print( next( gen ))
print( next( gen ))
print( next( gen ))

for i in myrange(1, 10):
    print(i)

"""
1. 데이터가 너무 커서 한번에 생성할 수 없을때 
2. 무한한 작업이 필요할때 
3. 파일을 계속 읽어서 처리하고자 할때때
"""

함수활용

# 문제 1
# 입력화면 : 1. 원의면적  2. 사각형면적  3.사다리꼴 면적 0. 종료 

def circle():
    radius = int(input("반지름을 입력하세요 : "))
    circle_area = radius * radius * 3.14
    print(f"\n원의 넓이는 {circle_area} 입니다.\n")

def square():
    width = int(input("가로를 입력하세요 : "))
    length = int(input("세로를 입력하세요 : "))
    square_area = width * length
    print(f"\n사각형의 넓이는 {square_area} 입니다.\n")

def trapezoid():
    upper = int(input("윗변을 입력하세요 : "))
    lower = int(input("아랫변을 입력하세요 : "))
    height = int(input("높이를 입력하세요 : "))
    trapezoid_area = (upper+lower) * height / 2
    print(f"\n사다리꼴의 넓이는 {trapezoid_area} 입니다.\n")
        
def main():
    while True:
            print("1.원의 면적", end = "\t")
            print("2.사각형 면적", end = "\t")
            print("3.사다리꼴 면적", end = "\t")
            print("0.종료")
            choice = int(input("0~3 중 선택하세요 : "))
            if choice == 1:
                circle()
            elif choice == 2:
                square()
            elif choice == 3:
                trapezoid()
            elif choice == 0:
                print("프로그램을 종료합니다.")
                return
            else:
                print("\n잘 고르자. 0~3 사이인데 그걸 못고르냐 친구야")
                print("기회 함 더줄테니까 잘 적자잉\n")
            
# main()

def main2():
    myfunctions = {"1":circle, "2":square, "3":trapezoid} #위에 문제를 dict를 활용해서 풀기
    while True:
            print("1.원의 면적", end = "\t")
            print("2.사각형 면적", end = "\t")
            print("3.사다리꼴 면적", end = "\t")
            print("0.종료")
            choice = (input("0~3 중 선택하세요 : "))
            if choice in myfunctions.keys():
                myfunctions[choice]()
            else:
                return print("프로그램을 종료합니다.")
            
# main2()

# 문제 2. 리스트를 받아가서 리스트안에 중복된 데이터를 제거하고 중복되지 않은 데이터 리스트만 반환하기

# 김성재풀이
def append(): #리스트입력
    list1 = []
    while True:
        s = input("입력하세요(중지하려면 '끝' 입력) : ")
        if s == "끝":
            break
        list1.append(s)
    return list1

def remove(list1): #중복제거
    removelist = list(set(list1))
    return removelist

def main():
    data = []
    while True:
        print("1. 리스트 입력")
        print("2. 중복값 제거한 리스트 반환 ")
        print("3. 종료")
        sel = int(input("1 ~ 3중에 선택하세요 : "))
        if sel == 1:
            data = append()
            print(f"\n원본데이터는 {data}입니다.\n")
        elif sel == 2:
            result = remove(data)
            print(f"\n중복제거한 리스트는 {result}입니다.\n")
        elif sel == 3:
            return print("\n프로그램을 종료합니다.")
            
main()
# 문제 3. myint 함수 : 문자열을 받아가서 정수로 바꾸어서 반환하기. cf. "123"을 넣었을 경우는 123을 반환하고 "123A'등 잘못된 입력은 같은 경우는 -1 반환
def myint(s):
    sum = 0
    for c in s:
        if ord(c) < ord("0") or ord(c) > ord("9"):
            return -1
        sum = sum * 10 + ord(c) - ord("0")
    return sum

print(myint("123") + myint("345"))

# 문제 4. 문장을 받아가서 문자열 뒤집어서 보내는 함수 reverse

def reverse(): # 김성재 풀이
    sen = input("문장을 입력하세요 : ")
    result = sen[::-1]
    print(result)

reverse()

def reverse(s): # 백현숙 강사님 풀이
    result = ""
    for i in range(len(s)-1, -1, -1):
        result += s[i]
    return result

과제

가위바위보_객체지향(김성재풀이)

• 생각보다 과제를 빨리 끝냈다. 객체지향에 대해 이해는 못하지만 어느정도 구조는 이해가 된 상태이다. 생성자를 통해 변수를 만들고 그에 따른 입력/계산/출력의 구조로 코드를 작성했다. 점점 코드가 익숙해지고 있다.

import random

class ScissorsRockPaper:
    def __init__(self): #생성자를 통한 변수 만들기기
        self.choice = [1, 2, 3] #1. 가위, 2.바위, 3.보
        self.drawcount = 0
        self.userwincount = 0
        self.comwincount = 0
         
    def com(self): #컴퓨터 pick
        com_choice = random.randint(1,3)
        return com_choice
    
    def user(self): #사람 pick
        while True:
            user_choice = int(input("\n1.가위, 2.바위, 3.보 (숫자로 선택) : "))
            if user_choice not in self.choice:
                print("다시 입력하세요!!! " )
                continue
            else :
                return user_choice
            
    def whoisWinner(self, user_choice, com_choice): #승패
        if user_choice == com_choice: #무승부
            result = 1
            return result 
        elif (user_choice == 1 and com_choice == 3) or (user_choice == 2 and com_choice == 1) or (user_choice == 3 and com_choice == 2):
            result = 2 #유저가 이기는 경우
            return result
        else:
            result = 3
            return result
        
    def start(self): #게임시작멘트
        print("게임을 시작합니다! 과연 승자는!! ")
        
    def output(self): #결과출력
        self.start()
        for i in range(0,10):
            user_choice = self.user()
            com_choice = self.com()
            result = self.whoisWinner(user_choice, com_choice)
            if result == 1:
                print("무승부")
                self.drawcount += 1
            elif result == 2:
                print("사람 승!")
                self.userwincount += 1
            else :
                result == 3
                print("컴퓨터 승 ㅠㅠ")
                self.comwincount += 1
                
        print("\n게임종료")
        print(f"사람 승 : {self.userwincount}, 컴퓨터 승 : {self.comwincount}, 무승부 {self.drawcount}")
        print(f"사람 승률 : {self.userwincount / 10:.2f}, 컴퓨터 승률 : {self.comwincount / 10:.2f}")
        
game1 = ScissorsRockPaper()
game1.output()

가위바위보_객체지향(백현숙강사님풀이)

코드를 입력하세요

복습

gpt를 이용한 유사예제

"숫자 맞추기 게임" 클래스 만들기

# 사용자가 1~100 사이의 숫자를 맞추는 게임을 클래스 기반으로 만들어라.
# 요구사항:
# GuessNumber 클래스를 만든다.
# 생성자에서 컴퓨터의 랜덤 숫자(1~100)를 생성한다.
# 사용자가 숫자를 입력하면, 컴퓨터 숫자와 비교해 힌트를 준다.
# 입력값이 정답보다 작으면 "UP"
# 입력값이 정답보다 크면 "DOWN"
# 정답이면 시도 횟수와 함께 종료 메시지 출력
# 사용자가 정답을 맞출 때까지 반복한다.
import random

class GuessNumber:
    def __init__(self): #생성자
        self.choice = range(1,101)
        
    def com(self): #컴퓨터 숫자입
        com_choice = random.randint(1,100)
        return com_choice
    
    def user(self): #사람 숫자입력
        while True:
            user_choice = int(input("1~100사이 숫자를 하나 입력하세요 : "))
            if user_choice not in self.choice:
                print("다시 입력하세요. 1~100사이 숫자입니다. ")
            else:
                return user_choice
            
    def compare(self, user_choice, com_choice): #숫자 비교
        while True:
            if user_choice == com_choice:
                return "정답입니다."
            elif user_choice > com_choice:
                return "Down!!"
            else:
                user_choice < com_choice
                return "Up!!"
            
    def start(self): #시작멘트
        print("숫자 맞추기를 시작합니다! ")
        
    def main(self):
        self.start()
        com_choice = self.com()
        while True:
            user_choice = self.user()
            result = self.compare(user_choice, com_choice)
            print(result)
            if result == "정답입니다.":
                break
            
g1 = GuessNumber()
g1. main()

"업다운 숫자 게임 with 제한된 기회" 클래스 만들기

# 위 문제에 "기회 7번" 제한을 추가한 업다운 게임을 객체지향 방식으로 만들어라.
# 요구사항:
# UpDownGame 클래스를 만든다.
# 생성자에서 컴퓨터의 랜덤 숫자(1~50)를 만든다.
# 사용자는 최대 7번의 기회를 가진다.
# 각 입력마다 남은 횟수를 출력하고, 맞추면 "축하합니다!" 메시지.
# 7번 안에 못 맞추면 정답과 함께 실패 메시지를 출력.

import random

class UpDownGame:
    def __init__(self):
        self.choice = range(1,51)
        
    def com(self):
        com_choice = random.randint(1,50)
        return com_choice
    
    def user(self):
        user_choice = int(input("1~50 사이의 숫자를 입력하세요 : "))
        if user_choice not in self.choice:
            return "다시 입력하세요. 1~50사이의 숫자입니다. "
        else:
            return user_choice
        
    def compare(self, user_choice, com_choice):
        while True:
            if user_choice == com_choice:
                return "정답"
            elif user_choice > com_choice:
                return "Down"
            else:
                return "Up"
    
    def start(self):
        print("업다운 숫자게임을 시작합니다. 기회는 총 7번!!")
    
    def main(self):
        self.start()
        com_choice = self.com()
        attempts = 7
        
        while attempts > 0:
            user_choice = self.user()
            result = self.compare(user_choice, com_choice)
            print(result)
            attempts = attempts - 1
            if result == "정답":
                print(f"축하합니다. 정답은 {result}입니다.")
            else:
                print(f"틀렸습니다. 남은 기회는 {attempts}번 입니다.\n")
        else:
            print(f"주어진 기회를 전부 사용했습니다. 정답은 {com_choice}입니다ㅠㅠ ")    
                
game1 = UpDownGame()
game1.main()