20.[python중급 문제풀이]클래스(6.14)

[Python 중급 문제풀이]
클래스 (01-07)

클래스(01)

---

회원가입 클래스와 회원정보를 관리하는 클래스를 만들고
회원가입 로그인 기능을 구현해 보자.

class Member:
    def __init__(self,i,p):
        self.id= i
        self.pw=p


class MemberRepository:

    def __init__(self):
        self.members={}

    def addMember(self,m):
        self.members[m.id]=m.pw

    def loginMember(self,i,p):
        isMember =i  in self.members

        if isMember and self.members[i]==p:
            print(f'{i} : Log-in success!!')

        else:
            print(f'{i} :Log-in fail!!')


    def removeMember(self,i,p):
        del self.members[i]

    def printMembers(self):
        for mk in self.members.keys():
            print(f'ID: {mk}')
            print(f'PW: {self.members[mk]}')


import hi

mems=hi.MemberRepository()

for i in range(3):
    mId=input('아이디 입력:')
    mPw=input('비밀번호 입력: ')
    mem=hi.Member(mId,mPw)
    mems.addMember(mem)
mems.printMembers()

mems.loginMember('abc@gmail.com', '1234')
mems.loginMember('def@gmail.com', '5678')
mems.loginMember('ghi@gmail.com', '9012')
mems.removeMember('abc@gmail.com','1234')
mems.printMembers()

클래스(02)

---

TV클래스를 다음과 같은 상속 구조로 만들고 객체를 생성해 보자.

class NormalTv:

    def __init__(self,i=32,c='black',r='full-HD'):
    self.inch=i
    self.color=c
    self.resolution=r
    self.smartTv='off'
    self.aiTv='off'

    def turnOn(self):
        print('TV power on!')

    def turnOff(self):
        print('TV power off!')

    def printTvInfo(self):
    print(f'inch: {self.inch}')
    print(f'color: {self.color}')
    print(f'resolution: {self.resolution}')
    print(f'smartTv: {self.smartTv}')
    print(f'aiTv: {self.aiTv}')

class Tv4k(NormalTv):

    def __init__(self,i,c,r='4k'):
        super().__init__(i,c,r)

    def setSmarTv(self,s):
        self.smartTv=s

class Tv8K(NormalTv):

    def __init__(self,i,c,r='8K'):
    super().__init__(i,c,r)

    def setSmartTv(self,s):
        self.smartTv=s

    def setAiTv(self,a):
        self.aiTv=a

if __name__ == '__main__':
    my4KTv= Tv4k('65,'silver','4k')
    my4KTv.setSmarTv('on')
    my4KTv.turnOn()
    my4KTv.printTvInfo()
    my4KTv.turnOff()

    my8KTv=Tv8K('75','black','8K')
    my8KTv.setSmarTv('on')
    my8KTv.turnOn()
    my8KTv.printTvInfo()
    my8KTv.turnOff()

 import hi

my4KTv=hi.Tv4k('65','silver','4K')
my4KTv.setSmarTv('on')
my4KTv.turnOn()
my4KTv.printTvInfo()
my4KTv.turnOff()

friend4KTv= hi.Tv4k('55','white','4K')
friend4KTv.setSmarTv('on')
friend4KTv.turnOn()
friend4KTv.printTvInfo()
friend4KTv.turnOff()



my8KTv= hi.Tv8K('75','black','8K')
my8KTv.setSmartTv('on')
my8KTv.setAiTv('on')
my8KTv.turnOn()
my8KTv.printTvInfo()
my8KTv.turnOff()

friend8KTv= hi.Tv8K('586','red', '8K')
friend8KTv.setSmartTv('on')
friend8KTv.setAiTv('off')
friend8KTv.turnOn()
friend8KTv.printTvInfo()
friend8KTv.turnOff()
  

클래스(03)

---

다음 명세서를 참고해서 도서 관리 프로그램을 만들어보자.

class Book:

    def __init__(self, name, price, isbn):
        self.bName = name
        self.bPrice = price
        self.bIsbn = isbn


class BookRepository:

    def __init__(self):
        self.bDic = {}

    def registBook(self, b):
        self.bDic[b.bIsbn] = b

    def removeBook(self, isbn):
        del self.bDic[isbn]

    def printBooksInfo(self):
        for isbn in self.bDic.keys():
            b = self.bDic[isbn]
            print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')

    def printBookInfo(self, isbn):
        if isbn in self.bDic:
            b = self.bDic[isbn]
            print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')

      else:
          print('Lookup result does not exist')

import book as bk

myBReposit = bk.BookRepository()

myBReposit.registBook(bk.Book('python', 20000, '1234567890'))
myBReposit.registBook(bk.Book('java', 25000, '852147963'))
myBReposit.registBook(bk.Book('c/c++', 27000, '951378624'))
myBReposit.registBook(bk.Book('javascript', 15000, '9874563254'))

myBReposit.printBooksInfo()
myBReposit.printBookInfo('1234567890')
myBReposit.removeBook('1234567890')
myBReposit.printBooksInfo()



friendBReposit = bk.BookRepository()

friendBReposit.registBook(bk.Book('python', 10000, '1234567890'))
friendBReposit.registBook(bk.Book('java', 15000, '852147963'))
friendBReposit.registBook(bk.Book('c/c++', 17000, '951378624'))
friendBReposit.registBook(bk.Book('javascript', 5000, '9874563254'))

friendBReposit.printBooksInfo()
friendBReposit.printBookInfo('1234567890')
friendBReposit.removeBook('1234567890')
friendBReposit.printBooksInfo()

클래스(04)

---

다음 추상 클래스를 이용해서 한/영, 한/일 사전 클래스를 만들어보자.

from abc import ABCMeta
from abc import abstractmethod

class AbsDictionary(metaclass=ABCMeta):

    def __init__(self):
        self.wordDic = {}

    @abstractmethod
    def registWord(self, w1, w2):
        pass

    @abstractmethod
    def removeWord(self, w1):
        pass

    @abstractmethod
    def updateWord(self, w1, w2):
        pass

    @abstractmethod
    def searchWord(self, w1):
        pass


class KorToEng(AbsDictionary):

    def __init__(self):
        super().__init__()

    def registWord(self, w1, w2):
        print(f'[KorToEng] registWord() : {w1} to {w2}')
        self.wordDic[w1] = w2

    def removeWord(self, w1):
        print(f'[KorToEng] removeWord() : {w1}')
        del self.wordDic[w1]

    def updateWord(self, w1, w2):
        print(f'[KorToEng] updateWord() : {w1} to {w2}')
        self.wordDic[w1] = w2

    def searchWord(self, w1):
        print(f'[KorToEng] searchWord() : {w1}')
        return self.wordDic[w1]

    def printWords(self):
        for k in self.wordDic:
            print(f'{k} : {self.wordDic[k]}')


class KorToJpa(AbsDictionary):

    def __init__(self):
        super().__init__()

    def registWord(self, w1, w2):
        print(f'[KorToJpa] registWord() : {w1} to {w2}')
        self.wordDic[w1] = w2

    def removeWord(self, w1):
        print(f'[KorToJpa] removeWord() : {w1}')
        del self.wordDic[w1]

    def updateWord(self, w1, w2):
        print(f'[KorToJpa] updateWord() : {w1} to {w2}')
        self.wordDic[w1] = w2

    def searchWord(self, w1):
        print(f'[KorToJpa] searchWord() : {w1}')
        return self.wordDic[w1]

    def printWords(self):
        for k in self.wordDic:
            print(f'{k} : {self.wordDic[k]}')

import book as dic

kTe = dic.KorToEng()

# 단어 등록
kTe.registWord('책', 'book')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'studen')
kTe.registWord('선생님', 'teacher')

# 단어 수정
kTe.updateWord('책', 'book')
kTe.updateWord('학생', 'student')

# 단어 검색
print(f'책 : {kTe.searchWord("책")}')
print(f'나비 : {kTe.searchWord("나비")}')
print(f'연필 : {kTe.searchWord("연필")}')
print(f'학생 : {kTe.searchWord("학생")}')
print(f'선생님 : {kTe.searchWord("선생님")}')

# 단어 삭제
kTe.removeWord('책')

# 사전 출력
kTe.printWords()


kTj = dic.KorToJpa()

# 단어 등록
kTj.registWord('책', '本')
kTj.registWord('나비', '蝶')
kTj.registWord('연필', '鉛筆')
kTj.registWord('학생', '学生')
kTj.registWord('선생님', '先生')

# 단어 수정
kTj.updateWord('책', '蝶')
kTj.updateWord('학생', '学生')

# 단어 검색
print(f'책 : {kTj.searchWord("책")}')
print(f'나비 : {kTj.searchWord("나비")}')
print(f'연필 : {kTj.searchWord("연필")}')
print(f'학생 : {kTj.searchWord("학생")}')
print(f'선생님 : {kTj.searchWord("선생님")}')

# 단어 삭제
kTj.removeWord('책')

# 사전 출력
kTj.printWords()

클래스(05)

---

주사위 게임 클래스를 만들고 컴퓨터와 사용자의 게임 결과를 출력해 보자.

import random as rd

class Dice:

    def __init__(self):
            self.cNum=0
            self.uNum=0

    def setCnum(self):
            print('[Dice]  setCnum()')
            self.cNum=rd.randint(1,6)

    def setUnum(self):
            print('[Dice]  setUnum()')
            self.uNum=rd.randint(1,6)

    def startGame(self):
            print('[Dice] startGame()')
            self.setCnum()
            self.setUnum()

    def printResult(self):
            print('[Dice] printResult()')

            if self.cNum==0 or self.uNum==0:
                print('주사위 숫자 설정 전 입니다. ')

            else:
                    if self.cNum> self.uNum:
                       print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >>컴퓨터 승!!')

                    elif self.cNum < self.uNum:
                        print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >>유저 승!!')

                    elif self.cNum == self.uNum :
                      print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >>무승부!!')


import exe

dc =exe.Dice()
dc.startGame()
dc.printResult()

클래스(06)

---

자동차 경주 게임 클래스를 만들어 보자. 자동차는 랜덤하게 이동하며, 편의상 10초동안 주행한다고 할 때 가장 멀리 이동한 자동차가 우승하는 게임이다.

import random

class Car:

    def __init__(self, n='fire car', c='red', s=200):
        self.name = n
        self.color = c
        self.max_speed = s
        self.distance = 0

    def printCarInfo(self):
        print(f'name: {self.name}, '
              f'color: {self.color}, '
              f'max_speed: {self.max_speed}, '
              f'current_speed: {self.cur_speed}')

    def controlSpeed(self):
        return random.randint(0, self.max_speed)

    def getDistanceForHour(self):
        return self.controlSpeed() * 1

from time import sleep

class CarRacing:

    def __init__(self):
        self.cars = []
        self.rankings = []

    def startRacing(self):
        for i in range(10):
            print(f'Racing: {i+1}바퀴')
            for car in self.cars:
                car.distance += car.getDistanceForHour()

            sleep(1)
            self.printCurrentCarDistance()

    def printCurrentCarDistance(self):
        for car in self.cars:
            print(f'{car.name}: {car.distance}\t\t', end='')
        print()

    def addCar(self, c):
        self.cars.append(c)



import CarRacing as rc

myCarGame = rc.CarRacing()
car01 = car.Car('Car01', 'white', 250)
car02 = car.Car('Car02', 'black', 200)
car03 = car.Car('Car03', 'yellow', 220)
car04 = car.Car('Car04', 'red', 280)
car05 = car.Car('Car05', 'blue', 150)

myCarGame.addCar(car01)
myCarGame.addCar(car02)
myCarGame.addCar(car03)
myCarGame.addCar(car04)
myCarGame.addCar(car05)

myCarGame.startRacing()

클래스(07)

---

다음과 같이 mp3 플레이어 클래스를 만들고 노래 등록 후 재생해보자.

import random
from time import sleep

class Song:

    def __init__(self, t, s, pt):
        self.title = t
        self.singer = s
        self.play_time = pt

    def printSongInfo(self):
        print(f'Title: {self.title}, Singer: {self.singer}, Play time: {self.play_time}')


class Player:

    def __init__(self):
        self.songList = []
        self.isLoop = False

    def addSong(self, s):
        self.songList.append(s)

    def play(self):
        if self.isLoop:
            while self.isLoop:
                for s in self.songList:
                   print(f'Title: {s.title}, Singer: {s.singer}, Play time: {s.play_time}sec')
                  sleep(s.play_time)
        else:
            for s in self.songList:
                print(f'Title: {s.title}, Singer: {s.singer}, Play time: {s.play_time}sec')
                sleep(s.play_time)

    def suffle(self):
        random.shuffle(self.songList)

    def setIsLoop(self, flag):
        self.isLoop = flag