중급 연습 문제 풀이 - 추상 클래스

파이썬의 추상 클래스를 활용한 문제 풀이

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

# member.py
# 두 개의 클래스를 만들어줄 것이다
# 1. 가입할 수 있는 클래스
class Member:
    def __init__(self,i,p):
        self.id = i
        self.pw = p

# 2. 여러명의 회원 관리 클래스
class MemberRepository
    def __init__(self):
        self.members = {} #회원을 관리할 전체 목록

    # 회원이 추가되는 기능
    def addMember(self, m):
        self.members[m.id] = m.pw

    # 로그인 기능
    def loginMember(self, i, p):
        # self.members 에 해당 id와 pw가 있는지 확인
        isMember = i in self.members

        if isMember and self.members[isMember] == 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()

# 여기서 회원 정보를 입력받는다.
# 먼저 3명의 정보를 입력받자
for i in range(3):
	mId = input('아이디 입력: ')
	mPw = input('비밀번호 입력: ')

	mem = mb.Member(mId,mPw) 
	mems.addMember(mem)

# 3명의 회원이 잘 추가됐는지 확인
mems.printMembers()

EX 2. tv클래스를 상속구조로 만들고 객체를 생성해보자.

# mytv.py
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'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

import mytv as mt

my4kTv = mt.Tv4k(65,'silver','4k')
my4kTv.setSmartTv('on')
my4kTv.turnOn()
my4kTv.printTvInfo()

EX 3. 도서 관리 프로그램을 만들어보자.

# library.py
class Book:

    def __init__(self,n,p,isbn):
        self.bName = n
        self.bPrice = p
        self.bIsbn = isbn # 책의 구분 번호

class BookRepository(Book):

    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 library as lb

my_lb = lb.BookRepository()

# 책 생성
my_lb.registBook(lb.Book('python',20000,'12345'))
my_lb.registBook(lb.Book('java',25000,'123456'))
my_lb.registBook(lb.Book('c++',27000,'1234567'))

my_lb.printBooksInfo()
my_lb.removeBook('12345')
my_lb.printBooksInfo()

EX 4. 추상클래스를 사용해서 한영사전을 만들어보자.

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 s in self.wordDic.keys():
            print(f'{s}: {self.wordDic[s]}')

import library as lb

kTe = lb.KortoEng()

kTe.registWord('책','bok')
kTe.registWord('나비','butterfly')
kTe.registWord('연필','pencil')
kTe.registWord('학생','student')
kTe.registWord('선생님','teacher')

kTe.printWords()
kTe.updateWord('책','book')

print(kTe.searchWord('책'))

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

# dice.py
import random as rd

class Dice:

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

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

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

    def startGame(self):
        print(f'[Dice] startGame()')

        self.setCnum()
        self.setUnum()

    def printResult(self):
        print(f'[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 dice

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

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

# car.py
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}, color : {self.color}, max_speed : {self.max_speed}')

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

    def getDistanceForHour(self):
        return self.controlSpeed() * 1  # 한시간동안 이동한 거리

# racing.py
from time import sleep

class CarRacing:

    def __init__(self):
        # 자동차 목록
        self.cars = []
        self.rankings = []

    def startRacing(self):
        for i in range(10): # 한바퀴를 도는 시간을 1초라고 하고 10바퀴를 돌자
            print(f'Racing : {i+1}바퀴')
            for car in self.cars: # 모든 차들이 움직여야 되니까
                car.distance += car.getDistanceForHour()

            sleep(1) # 잠시 프로그램을 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 car
import racing 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','blue', 280)
car05 = car.Car('Car05','red', 150)

# 자동차 추가해주기
myCarGame.addCar(car01)
myCarGame.addCar(car02)
myCarGame.addCar(car03)
myCarGame.addCar(car04)
myCarGame.addCar(car05)

myCarGame.startRacing()

EX 7. mp3 플레이어 클래스를 만들고 노래 등록 후 재생해보자.

# song.py
from time import sleep
import random
# 노래에 대한 정보를 나타내는 클래스
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): # 노래 재생하는 함수
        # 1. 반복재생하는지의 여부에 따라 달라짐
        if self.isLoop == False:
            for s in self.songList:
                print(f'Title : {s.title}, Singer: {s.singer}, Play time: {s.play_time}sec')
        else:
            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)

    def shuffle(self): # 셔플할지 말지 설정하는 함수, random 의 shuffle 모듈을 사용래서 리스트 순서를 섞여준다.
        random.shuffle(self.songList)

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

import song

s1 = song.Song('좋은날','아이유',3)
s2 = song.Song('목요일밤','어반자카파',2)
s3 = song.Song('nike shoes','빈지노',4)
s4 = song.Song('꺼내먹어요','자이언티',4)
s5 = song.Song('한숨','이하이',5)

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

player.setIsLoop(False)
player.shuffle()
player.play()

🔜 다음 스터디 노트..

다음 스터디 노트에는 예외 처리와 관련된 연습 문제 풀이를 정리한다.