중급 파이썬 문제풀이 Part 3 - 클래스

객체를 이용한 프로그래밍

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

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 member as mb

mems = mb.MemberRepository()

for i in range(3):
    mId = input('아이디 입력: ')
    mPw = input('비밀번호 입력: ')
    mem = mb.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()

#54강. 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}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 setSmartTv(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.setSmartTv('on')
    my4KTv.turnOn()
    my4KTv.printTvInfo()
    my4KTv.turnOff()

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

import smartTv as st

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


friend4KTv = st.Tv4k('55', 'white', '4K')
friend4KTv.setSmartTv('off')
friend4KTv.turnOn()
friend4KTv.printTvInfo()
friend4KTv.turnOff()



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


friend8KTv = st.Tv8k('86', 'red', '8K')
friend8KTv.setSmartTv('on')
friend8KTv.setAiTv('off')
friend8KTv.turnOn()
friend8KTv.printTvInfo()
friend8KTv.turnOff()

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

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')


if __name__ == '__main__':
    br = BookRepository()

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

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

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()

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

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]}')


if __name__ == '__main__':
    kTe = KorToEng()
    
    # 단어 등록
    kTe.registWord('책', 'bok')
    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()

import ADictionary as dic

kTe = dic.KorToEng()

# 단어 등록
kTe.registWord('책', 'bok')
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()

 

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

dice모듈을 생성합니다.

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} >> 무승부!!')


if __name__ == '__main__':
    dc = Dice()
    dc.startGame()
    dc.printResult()

import dice

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

 

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

car_game > racing

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)

car_ game > car

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



if __name__ == '__main__':
    tempCar = Car('myCar', 'black', 250)
    tempCar.printCarInfo()
    print(tempCar.controlSpeed())

result

from car_game import racing as rc
from car_game import car

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()

# 59강. 다음과 같이 MP3 플레이어 클래스를 마들고 노래 등록 후 재생해보자,

mp3.player

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

import mp3player as mp3

s1 = mp3.Song('신호등', '이무진', 3)
s2 = mp3.Song('Permission to Dance', '방탄소년단', 4)
s3 = mp3.Song('Butter', '방탄소년단', 2)
s4 = mp3.Song('Weekend', 'TAEYEON', 5)
s5 = mp3.Song('좋아좋아', '조정석', 4)

player = mp3.Player()
player.addSong(s1)
player.addSong(s2)
player.addSong(s3)
player.addSong(s4)
player.addSong(s5)

player.setIsLoop(False)
player.suffle()
player.play()