클래스
- 객체를 이용한 프로그래밍
1. 회원가입 클래스와 회원정보를 관리하는 클래스를 만들고 회원가입 로그인 기능을 구현해보자
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(): #반복문. 딕셔너리니까 key값
print(f'id: {mk}')
print(f'pw: {self.members[mk]}')
import member as mb
mems = mb.MemberRepository()
for i in range(3): #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()
-->
아이디 입력: abc@gmail.com
비밀번호 입력: 1234
아이디 입력: def@gmail.com
비밀번호 입력: 5678
아이디 입력: ghi@gmail.com
비밀번호 입력: 9012
id: abc@gmail.com
pw: 1234
id: def@gmail.com
pw: 5678
id: ghi@gmail.com
pw: 9012
abc@gmail.com: log-in success
def@gmail.com: log-in success
ghi@gmail.com: log-in success
id: def@gmail.com
pw: 5678
id: ghi@gmail.com
pw: 9012
2. 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) #r 객체 초기화. 새로운 값 집어넣으면서
def setSmartTv(self, s):
self.smartTv = s
class Tv8k(NormalTv):
def __init__(self, i, c, r='8k'):
super().__init__(i, c, r) #r 객체 초기화. 새로운 값 집어넣으면서
def setSmartTv(self, s):
self.smartTv = s
def setAiTv(self, a):
self.aiTv = a
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()
3. 다음 명세서를 참고해서 도서 관리 프로그램을 만들어보자
- 도서정보(도서명, 가격, isbn)
- 도서저장소(도서컨테이너, 도서등록, 도서삭제, 전체 도서 정보 출력, 도서 정보 출력)
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 #키값은 isbn, 밸류값은 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
myBRepository = bk.BookRepository()
myBRepository.registBook(bk.Book('python', 20000, '1234567890'))
myBRepository.registBook(bk.Book('java', 25000, '8901234567'))
myBRepository.registBook(bk.Book('c/c++', 27000, '91234567890'))
myBRepository.printBooksInfo()
myBRepository.printBookInfo('1234567890')
myBRepository.removeBook('91234567890')
print()
myBRepository.printBooksInfo()
#클래스만 있으면 객체는 언제든 바꿔서 생성가능
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 k in self.wordDic.keys(): #모든 단어 출력
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.keys(): #모든 단어 출력
print(f'{k}: {self.wordDic[k]}')
import aDictionary as dic
kTe = dic.KorToEng()
kTe.registWord('책', 'bok')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'student')
kTe.registWord('선생님', 'teacher')
kTe.printWords()
kTe.updateWord('책', 'book')
kTe.printWords()
print(f'책: {kTe.searchWord("책")}')
print(f'나비: {kTe.searchWord("나비")}')
print(f'선생님: {kTe.searchWord("선생님")}')
kTe.removeWord('책')
print()
kTe.printWords()
-->
[KorToEng] registWord(): 책 to bok
[KorToEng] registWord(): 나비 to butterfly
[KorToEng] registWord(): 연필 to pencil
[KorToEng] registWord(): 학생 to student
[KorToEng] registWord(): 선생님 to teacher
책: ['bok']
나비: ['butterfly']
연필: ['pencil']
학생: ['student']
선생님: ['teacher']
[KorToEng] updateWord(): 책 to book
책: ['book']
나비: ['butterfly']
연필: ['pencil']
학생: ['student']
선생님: ['teacher']
[KorToEng] searchWord(): 책
책: ['book']
[KorToEng] searchWord(): 나비
나비: ['butterfly']
[KorToEng] searchWord(): 선생님
선생님: ['teacher']
[KorToEng] removeWord(): 책
나비: ['butterfly']
연필: ['pencil']
학생: ['student']
선생님: ['teacher']
5. 주사위 게임 클래스를 만들고 컴퓨터와 사용자의 게임 결과를 출력해보자
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 dice
dc = dice.Dice()
dc.startGame()
dc.printResult()
6. 자동차 경주 게임 클래스를 만들어보자. 자동차는 랜덤하게 이용하며, 편의상 10초 동안 주행한다고 할 때 가장 멀리 이동한 자동차가 우승하는 게임이다.
import random
class Car:
def __init__(self, n='fire car', c='red', s='200'):
self.name = n
self.color = c
self.maxSpeed = s
self.distance = 0
def printCarInfo(self):
print(f'name: {self.name}, color: {self.color}, maxSpeed: {self.maxSpeed}')
def controlSpeed(self):
return random.randint(0, self.maxSpeed)
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): #1초 동안 1바퀴 돈다고 가정, 거리는 1초에 1바퀴를 1시간으로 가정
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)
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', 'green', 150)
myCarGame.addCar(car01)
myCarGame.addCar(car02)
myCarGame.addCar(car03)
myCarGame.addCar(car04)
myCarGame.addCar(car05)
myCarGame.startRacing()
-->
racing: 1바퀴
Car01: 12 Car02: 198 Car03: 28 Car04: 227 Car05: 87
racing: 2바퀴
Car01: 112 Car02: 213 Car03: 111 Car04: 409 Car05: 199
...
racing: 10바퀴
Car01: 868 Car02: 828 Car03: 1196 Car04: 1224 Car05: 774
7. 다음과 같이 mp3 플레이어 클래스를 만들고 노래 등록후 재생해보자
from time import sleep
import random
class Song:
def __init__(self, t, s, pt):
self.title = t
self.singer = s
self.playtime = pt
def printSongInfo(self):
print(f'title: {self.title}')
print(f'singer: {self.singer}')
print(f'playtime: {self.playtime}')
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: #list에 있는 곡들을 불러와서 돌아가야
print(f'title: {s.title}, singer: {s.singer}, playtime: {s.playtime}sec')
sleep(s.playtime)
else:
for s in self.songList: #리스트 한번 돌고 멈춤
print(f'title: {s.title}, singer: {s.singer}, playtime: {s.playtime}sec')
sleep(s.playtime)
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('손오공', '세븐틴', 4)
s3 = mp3.Song('butter', 'bts', 2)
s4 = mp3.Song('weekend', '태연', 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()
