함수문제풀이4~7(클래스53)
mem = mb.Member(mId, mPw)
mems.addMember(mem)
class MemberRepository:
def __init__(self):
self.members = {}
def addMember(self, m):
self.members[m.id] = m.pw#m.id key로 사용하여 m.pw 값으로 저장
def loginMember(self, i, p): #매개변수 i,p로 전달된 아이디와 패스워드 확인하여 로그인
isMember = i in self.members
if isMember and self.members[i] ==p: #아이디(is Member)랑 패스워드가 같다면 로그인 실행
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): #self.member에 저장된 회원 정보 출력
for mk in self.members.keys():# 반복문 내에서 회원 정보의 아이디 패스워드 출력
print(f'ID: {mk}') #아이디 출력
print(f'PW: {self.members[mk]}')#패스워드 출력
############################################
#실행
import member as mb
#mem은 아래의코드는 모듈class MEmberRspository의 self.members{} 딕셔너리에 들어가서 기능이 구현된다.
# class MemberRepository:
# def __init__(self):
# self.members = {}
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()
함수문제풀이4~7(클래스54)
class NormalTv:
def __init__(self, i=32, c='black', r='full-HD'):
self.inch = 1
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): #상위클래스 상속하고 4k 해상도 tv 클래스 생성
def __init__(self, i, c, r='4k'):
super().__init__(i,c,r)#class NormalTv의
# def __init__(self, i=32, c='black', r='full-HD') 다음부분을상속한다.
def setSmartTv(self, s):
self.smartTv = s
def setAiTv(self, a):
self.aiTv = a
class Tv8k(NormalTv): #상위클래스 상속하고 8k 해상도 tv 클래스 생성
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 smartTv as st
#4k해상도 출력
# my4KTv = st.Tv4k('65', 'silver','4k')
# my4KTv.setSmartTv('on')
# my4KTv.turnOn()
# my4KTv.printTvinfo()
# my4KTv.turnOff()
#
# print('--------------')
# friend4KTv = st.Tv4k('55','white','4k')
# friend4KTv.setSmartTv('off')
# friend4KTv.turnOn()
# friend4KTv.printTvinfo()
# friend4KTv.turnOff()
#8k 해상도 출력하기
#Tv4k클래스의 매개변수를 할당해주고 그것을 my8Ktv변수로 초기화한다.
my8KTv = st.Tv4k('75','black','8k')
my8KTv.setSmartTv('on')
my8KTv.setAiTv('on')
my8KTv.turnOn()
my8KTv.printTvinfo()
my8KTv.turnOff()
print('-------------------------------')
friend8KTv = st.Tv4k('86','red','8k')
friend8KTv.setSmartTv('on')
friend8KTv.setAiTv('on')
friend8KTv.turnOn()
friend8KTv.printTvinfo()
friend8KTv.turnOff()
함수문제풀이4~7(클래스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#책 한권 들어오면 bDic 딕셔너리에 저장(isbn 키값)
#딕셔너리bDic에 키값Isbn을 넣는다.(책을 분류 와 관리를 위해서)
def removeBook(self, isbn): # isbn으로 책 한권 저장
del self.bDic[isbn] #책한권 삭제
def printBookInfo(self): #저장소에 등록된 책의 모든정보 출력
for isbn in self.bDic.keys():#self.bDic 딕셔너리의 모든키를 반복적으로 가져온다.
#이것으로 모든 책에 대해 반복적으로 작업을 수행한다.
b = self.bDic[isbn]#반복중인 키를 사용하여 self.bDic에서 책 객체b를 가져온다.
print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')#책 b를 사용하여 책 이름, 가격, 키값을 출력
def printBookInfo(self, isbn): #한권의 책만 정보를 출력(어떤 책인지 정보를 얻기위해 isbn 사용 isbn에 정보가 있진 않고 책의 정볼를 가져오는 기능을 한다.)
# 책 정보는 self.bDic에 있다.
if isbn in self.bDic: # 책정보self.bDic에 정보가 있으면 객체를 가져오기 위해isbn 키로 사용
b = self.bDic[isbn]
print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')
else:
print('Lookup result does not exitst')#책이 없다.
##############실행
import book as bk
myBRepository = bk.BookRepository()
myBRepository.registBook(bk.Book('python',20000,'1234567890'))
myBRepository.registBook(bk.Book('jav',23000,'09876564321'))
myBRepository.registBook(bk.Book('c++',27000,'5678904321'))
myBRepository.printBookInfo('1234567890')
myBRepository.printBookInfo('09876564321')
myBRepository.printBookInfo('5678904321')
- isbn 책의 분류와 관리를 한다.
함수문제풀이4~7(클래스56)
from abc import ABCMeta
from abc import abstractmethod
#추상메소드
# 상위 클래스에서 하위 클래스에 메서드 구현을 강요
# 추상 메소드는 하위 클래스에서 반드시 구현되어야 한다.
#추상 메소드를 정의할때는 @abstractmeThod 데코레이더를 사용한다.
class AbsDictionary(metaclass=ABCMeta):
def __init__(self):
self.wordDic = {} #단어를 저장할 공간 생성
@abstractmethod
def registWord(self, w1, w2): #단어 등록
pass
@abstractmethod
def removeWord(self, w1, w2):
pass
@abstractmethod
def updateWord(self, w1, w2):
pass
@abstractmethod
def searchWord(self, w1):
pass
#한영 사전
class KorToEng(AbsDictionary): #한영사전 클래스
def __init__(self): #AbsDictionary의 새성자를 호출하여 초기화
#하위 클래스에서 추가적인 초기화를 진행 하도록 한다.
super().__init__()
def registWord(self, w1, w2): #단어 등록
print(f'[KorToEng] registWord(): {w1} to{w2}')
self.wordDic[w1] = w2 #딕셔너리로 w2를 w1에 등록
#ex) 사과=apple
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():#딕셔너리(wordDic) 반복하여 k 변수에 할당
#등록된 단어와 해당하는 정보를 한 줄씩 출력한다.
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로 초기화
#dic는 사용자 임의 지정 이름이다. 딕셔너리 x
# KorToEng클래스의 registWord(self, w1, w2) 매개변수에 단어 등록
kTe.registWord('책', 'bok')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'student')
kTe.registWord('선생님', 'teacher')
kTe.printWords()
#단어 수정
kTe.updateWord('책', 'book') #위에 bok을 bookr으로 교체
kTe.printWords()
#단어 검색
print(f'책 : {kTe.searchWord("책")}')
print(f'나비 : {kTe.searchWord("나비")}')
print(f'선생님 : {kTe.searchWord("선생님")}')
#단어 삭제
kTe.removeWord('책')
kTe.printWords() #실행해보면 책이 사라진걸 확인할 수 있다.
함수문제풀이4~7(클래스57)
import random as rd
class Dice:
def __init__(self): #객체가 생성될 때 초기 속성 설정
self.cNum = 0 #컴퓨터가 굴러서 나온 숫자
self.uNum = 0#유저가 굴러서 나온 숫자
def steCnum(self): #사용자의 cNum 설정
print('[Dice] steCnum()')
self.cNum = rd.randint(1, 6) #랜덤숫자 3이나오면 cNum=3이 된다.
def steUnum(self):
print('[Dice] steUnum()')
self.uNum = rd.randint(1, 6)
def startGame(self): #주사위 게임 시작 함수
print('[Dice] startGame()')
#유저와 컴퓨터의 주사위 숫자를 결정하기 위해 다음 코드 사용
self.steCnum() # 컴퓨터 주사위 숫자 설정
self.steUnum() # 유저 주사위 숫자 설정
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() #클래스Dice로 dc 생성 주사위 게임 진행을 한다.
dc.startGame() #시작
dc.printResult() #결과
함수문제풀이4~7(클래스58)
#자동차 모듈
import random
class Car:
def __init__(self, n = 'fire car', c='red', s= 200): #최대속도 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): #자동차 속도 함수 0~max까지 무작위 속도 반환
return random.randint(0, self.max_speed)
def getDistanceForHour(self): #1시간 동안 이동한 거리 계산
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): #10바퀴 돈다
print(f'Racing: {i+1}바퀴') # 1바퀴 , 2바퀴, 3바퀴....10바퀴 까지 출력하는 내장함수 부분
for car in self.cars:
car.distance += car.getDistanceForHour()#한시간동안 이동한 함수를 car파일에서 함수를 불러온다.
sleep(1) #1초동안 잠깐 스톱 1초마다 출력된다.
self.printCurrentCarDistance()# 자동차 이동거리 메소드 출력
def printCurrentCarDistance(self): #자동차 이름과 이동거리를 출력하는 함수
for car in self.cars:#self.cars 리스트에 저장된 자동차 객체를 반복하면서 이름과 이동거리 출력
print(f'{car.name}: {car.distance} \t\t', end='')
print()
def addCar(self, c):# 자동차 객체(Car 클래스의 인스턴스)를 self.cars리스트에 추가
#c 매개 변수로 적달된 자동차 객체를 append()를 사용하여 자동차를 추가
self.cars.append(c)
################################################################
#실행
from CarGame import racing as rc
from CarGame 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()
함수문제풀이4~7(클래스59)
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) #추가한 노래 s를 songList에 담기
def play(self): #노래 재생 함수
if self.isLoop: #isLoop 가 True 노래 반복 재생
while self.isLoop:
for s in self.songList: # 리스트에 저장된 sonList 추가한 노래 s만큼 반복
print(f'Title: {s.title}, Singer: {s.singer}, Play time: {s.play_time} sec')
sleep(s.play_time)# 시간을 주어 노래를 잠깐 멈춘다.
else: # isLoop가 False
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(self.songList)
def setIsLoop(self, flag): #노래 재생 반복 여부 함수
self.isLoop = flag
#################################################
#실행
import mp3player as mp3
s1 = mp3.Song('신호등', '이무진', 3)
s2 = mp3.Song('가시', '버즈', 3)
s3 = mp3.Song('my way', '이수', 3)
s4 = mp3.Song('next level', '에스파', 3)
s5 = mp3.Song('라일락', '아이유', 3)
player = mp3.Player()
player.addSong(s1)
player.addSong(s2)
player.addSong(s3)
player.addSong(s4)
player.addSong(s5)
player.setIsLoop(False)
player.shuffle()
player.play()
함수문제풀이4~7(60예외처리)
def add(n1, n2):
print('덧셈 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두 번째 피연산자는 숫자가 아닙니다.')
return
print(f'{n1} + {n2} = {n1 + n2}')
def sub(n1, n2):
print('뺄셈 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두 번째 피연산자는 숫자가 아닙니다.')
return
print(f'{n1} - {n2} = {n1 - n2}')
def mul(n1, n2):
print('곱셈 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두 번째 피연산자는 숫자가 아닙니다.')
return
print(f'{n1} * {n2} = {n1 * n2}')
def div(n1, n2):
print('나눗셈 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두 번째 피연산자는 숫자가 아닙니다.')
return
#방법1
# if n2 == 0: #나눗셈의 경우 0이되면 안됨으로 추가 코드 작성 해주자
# print('0으로 나눌수 없습니다.')
# return
#방법2 try ~ except
try:
print(f'{n1} / {n2} = {n1 / n2}')
except ZeroDivisionError as e:
print(e)
print('0으로 나눌 수 없습니다.')
def mod(n1, n2):
print('나머지 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두 번째 피연산자는 숫자가 아닙니다.')
return
if n2 == 0:
print('0으로 나눌 수 없습니다.')
return
print(f'{n1} % {n2} = {n1 % n2}')
def exp(n1, n2):
print('거듭제곱 연산')
try:
n1 = float(n1)
except:
print('첫 번째 피연산자는 숫자가 아닙니다.')
return
try:
n2 = float(n2)
except:
print('두번째 피연산자는 숫자가 아닙니다')
return
print(f'{n1} ** {n2} = {n1 ** n2}')
###실행###################################
import calculator as cc
num1 = input('첫 번째 피연산자 입력: ')
num2 = input('두 번째 피연산자 입력: ')
cc.add(num1 ,num2)
# cc.sub(num1, num2)
# cc.exp(num1, num2)
# cc.mul(num1, num2)
# cc.div(num1, num2)
# cc.mod(num1, num2)
함수문제풀이4~7(61예외처리)
모듈
#사용자 예외 클래스 생성
#Exception은 파이썬에서 제공하는 클래스이다.
class NotPrimeException(Exception): #소수가 아닌 경우 클래스
def __init__(self, n):
super().__init__(f'{n}is not prime number') #Exception을 상속
#소수인 경우 예외 클래스 생성
class PrimeException(Exception):
def __init__(self, n):
super().__init__(f'{n} is prime number.') #PrimeException의 Exception을 상속
def isPrime(number): #난수가 소수인지 아닌지 판단하는 함수만들기
flag = True
for n in range(2, number): #2부터 사용자가 입력한 값까지 반복
if number % n == 0: #0이면 소수가 아니다.
flag = False
break
if flag ==False: #소수가 아니면
raise NotPrimeException(number) #강제 예외 발생 raise
else:
raise PrimeException(number) #소수 클래스
#######################실행##################
import random
import prime_module as pm #소수 판별, 소수 생성, 소인수분해 기능
primeNumbers = []
n = 0
while n < 10:
rn = random.randint(1, 1000) #난수1~1000까지 랜덤 생성 하여 변수 rn에 초기화
if rn not in primeNumbers:#랜덤에서 숫자를 받은 rn이 primeNumbers 리스트에 없다면
#pm.isPrime(rn)함수를 호출하고 예외 처리 수행
try:
pm.isPrime(rn)#rn 변수의 소수 여부 확인
except pm.NotPrimeException as e:#소수가 아니면 NotPrimeException 예외 발생
#예외 발생하면 e에 할당
print(e)
continue #다시 while문으로 간다.
except pm.PrimeException as e:# 호출 시 발생할 수 있는 예외 처리부분
#소수 확인에 실패했을때 예외 발생
#예외 처리후 PrimeNumbers리스트에 rn 추가
print(e)
primeNumbers.append(rn)
#1. except pm.NotPrimeException, 2. except pm.PrimeException 차이점
#1번 예외는 숫자가 소수가 아닐때 발생
#2번 예외는 숫자를 소수인지 판별 과정에서 오류날때 예외가 발생
else:#랜덤으로 초기화된 rn이 중복된 숫자인 경우 처리하는 부분
#primeNumbers 리스트에 데이터가 이미 존재한 경우 실행한다.
print(f'{rn}is overlap number') #중복된 숫자 출력
continue
n +=1 #while문 종료를 위한 조건 부분
print(f'primeNumbers: {primeNumbers}')
함수문제풀이4~7(62예외처리)
g1Price = 1200; g2Price = 1000; g3Price = 800
g4Price = 2000; g5Price = 900;
def formatedNumber(n):
return format(n, ',')
def calculator(*gcs):#*gcs로 임의의 개수의 매개변수를 받는다.
gcsDic = {}
againCntInput = {}
for idx, gc in enumerate(gcs): #gcs를 반복하면서 idx,gc반환
try:#try~except로 요소(gc)를 정수로 변환하여 gcsDic 딕셔너리에 추가
gcsDic[f'g{idx+1}'] = int(gc)#gcsDic는 상품 번호와 개수를 저장
#gcs가 3,5,2이면
#idx(인덱스)는 0, gc는 3 , --> gcsDic--> {'g1':3}이 된다.
#두번째 반복에선 인덱스2, gc는5 --> gcsDic -->{'g2':5} 된다.
#g1Price,g2Price....등은 g1,g2,g3,g4,g5를 의미한다.
#위에서 미리적은 금액g1Price = 1200; 은 인덱스 0이 된다.
#즉 g1Price =1200 --> gcsDic['g1']
#미결제(예외처리 부분)
except Exception as e:#위에서 변환이 안되면 againCntInput 딕셔너리에 요소 저장
againCntInput[f'g{idx+1}'] = gc
print(e)
totalPrice = 0 #상품 가격 (g1,g2..) 해당 상품 개수를 곱하여 total 금액 계산
for g in gcsDic.keys():#gcsDic의 딕셔너리 모든 키 반환(g1g2등이 키로 사용)
#for 반복으로 상품 번호 반복하면서 상품 가격,개수를 곱하여 totalPrice 누적
totalPrice += globals()[f'{g}Price'] * gcsDic[g]#globals로 변수명을 바로 찾는다.
#g1Price 1200 gcsDic['g1']이 3이면 totalPrice += 1200* 3
print('-------------------------------')
print(f'총 구매 금액: {formatedNumber(totalPrice)}원')
print('-----------미결제 항목--------')
for g in againCntInput.keys():
print(f'상품: {g}, \t 구매 개수: {againCntInput[g]}')
print('----------------------------')
#실행###################################
import calculatorPurchase as cp
g1Cnt = input('goods1 구매 개수: ')
g2Cnt = input('goods2 구매 개수: ')
g3Cnt = input('goods3 구매 개수: ')
g4Cnt = input('goods4 구매 개수: ')
g5Cnt = input('goods5 구매 개수: ')
g6Cnt = input('goods5 구매 개수: ')
cp.calculator(g1Cnt ,g2Cnt ,g3Cnt ,g4Cnt ,g5Cnt )
- def calculator(gcs):#gcs로 임의의 개수의 매개변수를 받는다.
함수문제풀이4~7(63예외처리)
모듈
#회원 관리 모듈
class EmptyDataException(Exception): #사용자 예외클래스는 Exception함수를 상속받는다.
def __init__(self, i): #어떠한 것이 비었는지 알아야 함으로 i를 받는다.
super().__init__(f'{i}is empty!')
def checkInputData(n,m,p,a,ph ): #n이름, m 메일, p패스워드 a주소 , ph연락처
#각각의 매개변수가 비어있으면 처리하는 부분
#예외가 발생하면 각 항목 name,mail등 문구 출력 ex) name is empty!
if n =='':
raise EmptyDataException('name')#강제 에러 발생 raise 사용
elif m =='':
raise EmptyDataException('mail')
elif p == '':
raise EmptyDataException('password')
elif a =='':
raise EmptyDataException('address')
elif ph =='':
raise EmptyDataException('phone')
class RegistMember(): ##회원 가입 클래스 생성
def __init__(self,n,m,p,a,ph):
self.m_name = n
self.m_mail = m
self.m_pw= p
self.m_addr = a
self.m_phone = ph
print('Membership complete!!')
def printMemberInfo(self): #회원 정보
print(f'm_name: {self.m_name}')
print(f'm_mail: {self.m_mail}')
print(f'm_pw: {self.m_pw}')
print(f'm_addr: {self.m_addr}')
print(f'm_phone: {self.m_phone}')
#####################실행################
import mem
m_name = input('이름 입력:')
m_mail = input('메일 주소 입력:')
m_pw = input('비밀번호 입력:')
m_addr = input('주소 입력:')
m_phone = input('연락처 입력:')
#예외 처리부분 만들기
#mem.checkInputData 함수 호출할때 발생하는 mem.EmptyDataException 예외를 처리하는 코드이다.
#모듈에서 만든 클래스들을 불러오기
try:
mem.checkInputData(m_name,m_mail,m_pw,m_addr,m_phone) #여기서 예외가 발생하면 다음 except에서 블록에서 처리한다.
newMember = mem.RegistMember(m_name,m_mail,m_pw,m_addr,m_phone)#등록
newMember.printMemberInfo() #유저정보
except mem.EmptyDataException as e: #mem.EmptyDataException 예외 클래스 지정하고
#as e는 예외 객체 변수 e에 할당
print(e)
함수문제풀이4~7(64예외처리)
import random
class PrivateBank: #개인통장
def __init__(self, bank, account_name):
self.bank = bank
self.account_name = account_name
while True: #새로운계좌 계설
newAccountNo = random.randint(10000,99999)#1만~9만9999까지의 계좌번호
if bank.isAccount(newAccountNo): #isAccount 새로운계좌 번호가 이미 만들어졌는지 확인
continue # 계좌번호가 존재하면 다시 while 루프
else:
self.account_no = newAccountNo #계좌번호가 새로나오면 self.account_no에 설정
break
self.totalMoney = 0
bank.addAccount(self) #내가 가입할려는 bank 에다가 내 계좌를 넣는다. self(나 자신을 나타내는 키워드)
def prinBankInfo(self): #내통장의 장고를 볼려면
print('-' *40)
print(f'account_name : {self.account_name}')#통장 이름
print(f'account_no : {self.account_no}') #내통장 계좌번호
print(f'account_no: {self.totalMoney}')#잔고
print('-' * 40)
class Bank:
def __init__(self): #Bank 클래스의 인스턴스가 생성될 때 호출되는 생성자
self.accounts = {}
def addAccount(self, privateBank):#새로운 개인 계좌 생성 privateBank=개인계좌
self.accounts[privateBank.account_no] = privateBank#개인계좌의 account_no를 key값으로설정
#privateBank.account_no를 self.accounts 키로 사용하여 privateBank를 저장한다.
def isAccount(self, ano):#신규계좌 만들어질때 기존 계좌번호인지 확인여부 체크 ano= 계좌번호 넘버
return ano in self.accounts #self.accounts안에 ano가 있는지 확인
def doDeposit(self, ano, m): #ano 계좌번호, m 금액
pb = self.accounts[ano] #본인통장가져오기
pb.totalMoney = pb.totalMoney + m #합계는 기존돈 + 금액
def doWithdraw(self, ano, m):
pb = self.accounts[ano]# 본인통장겨져오기
if pb.totalMoney - m< 0: #출금 할려는 금액이 0보다 작으면 문제발생
raise LackException(pb.totalMoney, m)#강제 에러 발생 (개인통장잔액, 출금금액)
pb.totalMoney = pb.totalMoney - m
class LackException(Exception):
def __init__(self, m1, m2): #잔금과,출금할려는 금액을 매개변수둔다(한눈에 보기 편할려고)
super().__init__(f'잔고 부족!!, 잔액: {m1}, 출금액: {m2}') #에러메시지 출력부분이다.
##########실행############################################
import bank
koreaBank = bank.Bank()
new_account_name = input('통장 계설 예금주 입력:')
myAccount = bank.PrivateBank(koreaBank, new_account_name)#새로운 계좌 등록
myAccount.prinBankInfo()
while True:
selectNumber = int(input('1.입금, \t 2.출금,\t 3.종료'))
if selectNumber == 1:
m = int(input('임금액 입력 :'))
koreaBank.doDeposit(myAccount.account_no, m)
myAccount.prinBankInfo()
elif selectNumber ==2: #출금
m= int(input('출금액 입력:'))
try:
koreaBank.doWithdraw(myAccount.account_no, m)
except bank.LackException as e :
print(e)
finally: #예외가 발생하든 안하든 계좌정보 출력하기
myAccount.prinBankInfo()
elif selectNumber == 3:
print('bye')
break #while문 탈출
else:
print('잘못 입력 했습니다. 다시 선택')
함수문제풀이4~7(65텍스트파일)
모듈
import time
def writeDiary(u, f, d): #일기 작성 함수 생성(이름:u 파일경로:f 일기내용 d)
lt = time.localtime() #현재 시간을 가져온다.
#strftime()에서 사용되는 형식 지정자 %I:시간 %M:분 %S:초 %p:오전 , 오후
timeStr = time.strftime('%Y-%m-%d %I:%M:%S %p', lt) #시간정보를 문자열로 변환
filePath = u +f + d #사용자 이름, 파일 경로, 일기 내용을 조합하여 파일 경로 생성하는 변수
with open(filePath,'a') as f: #with as문으로 파일을 자동으로 닫는다. , open함수로 filePath 열기 , a는 기존애 있는 파일내용을 이어쓰기
f.write(f'[{timeStr}]{d} \n')#파일 일기 사용하기 위해 사용 d는 일기내용을 나타내는 변수
def readDiary(u, f): #내용이 필요 없음으로 d는 뺸다.(사용자 이름:u 파일경로:f)
filePath = u + f #사용자 이름 + 파일경로 합하여 파일 경로 생성
datas = [] #파일에서 읽은 일기 내용을 저장할 용도로 사용
with open(filePath,'r') as f: #읽기 기능 r 사용
datas = f.readlines() #readlines으로 파일의 모든 줄을 읽고 각줄을 리스트의 요소로 저장
return datas #파일에서 읽은 일기 내용을 담고 있는 리스트
########################################################
#실행
import diary #writeDiary(), freadDiary()함수 정의
members = {} #딕셔너리 선언 회원정보 저장 위한 딕셔너리 생성
uri = 'C:/pythonTxt/'
def printMembers(): #등록 회원 목록 출력
for m in members.keys():#members 딕셔너리를 반복하면서 키를 m에 할당 (m은 members 딕셔너리의 키값(회원ID)이다.)
print(f'ID: {m} \t {members[m]}')
while True:
selectNum = int(input('1.회원가입\t 2.한줄일기쓰기, \t 3.일기보기,\t 4.종료'))
if selectNum ==1:
mId = input('input ID:')
mPw = input('input Pw:')
members[mId] = mPw #입력받은 ID와 비빌번호를 members 딕셔너리에 추가
printMembers() #등록된 회원 정보 출력
elif selectNum == 2: #한줄읽기 본인 파일에서만 사용해야함 로그인 기능 필요
mId = input('input ID:')
mPw = input('input Pw:')
if mId in members and members[mId] == mPw: #입력 ID가 members 딕셔너리에 존재하고 ID에 대한 비밀번호가 입력한 비밀번호와 일치 여부 확인
print('login success!!')
fileName = 'myDiary_' + mId + '.txt'
data = input(('오늘 하루 인상 깊은 일 기록:'))
diary.writeDiary(uri, fileName, data)#uri 경로에 파일 이름이 fileName인 파일에 일기 내용 작성
else: #로그인 오류날때
print('login fail!!')
printMembers()
elif selectNum == 3: #input에서 3번 선택하면 일기를 보는 기능 수행
mId = input('input ID: ')
mPw = input('input PW: ')
if mId in members and members[mId] == mPw: #입력한 ID가 members 딕셔너리에 존재하고,
# 해당 ID에 대한 비밀번호가 입력한 비밀번호와 일치하는지 확인
print('login success!!!')
fileName = 'myDiary_' + mId + '.txt' #로그인되면 다음과 같은 형식 파일 생성
datas = diary.readDiary(uri, fileName) #일기 출력
for d in datas:
print(d, end='')
else:
print('login fail!!')
printMembers()
elif selectNum == 4:
print('bYe')
break
후기:
쉬운 문제는 금방 해석하고 습득이 되었지만 정말 이해가 안 가는 문제풀이도 몇 개 있었다.
함수와 클래스 문제를 풀어보라고 하면.. 끄적이다가 못 풀 거 같다.
아직 파이썬 개념에 대한 확신이 없다.
