[오늘 배운 내용]
[클래스 연습문제]
- 1) 회원가입 클래스와 회원정보를 관리하는 클래스를 만들고 회원가입 로그인 기능을 구현해보자.
# 모듈: member
class Member:
def __init__(self, i, p):
self.id = i
self.pw = p
class MemberRepository:
def __init__(self):
self.members = {} # 사용자 아이디: key 값, # 사용자 전체 정보: value 값
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()- 2) TV 클래스를 다음과 같은 상속 구조로 만들고 객체를 생성해보자.
- set 메서드 관련 개념 이해 필요(점프 투 파이썬 참조)
# 모듈: smartTV
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# 실행파일
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') # 이 경우, 주석처리해도 NormalTv의 함수로 인해 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()
- 3) 도서 정보, 도서 저장소 객체 만들기
# 모듈: book
# 도서 정보(도서명, 가격, 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
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,'7593028382'))
myBRepository.registBook(bk.Book('c/c++',20000,'1308024573'))
myBRepository.printBooksInfo()
myBRepository.printBookInfo('7593028382')
myBRepository.removeBook('1234567890')
print()
myBRepository.printBooksInfo()- 4) 추상 클래스를 이용해서 한/영 사전 클래스를 만들어보자.
# 모듈: ADictionary
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]}')# 실행파일
import ADictionary as dic
kTe = dic.KorToEng()
kTe.registWord('책', 'bok')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'student')
kTe.registWord('선생님', 'teacher')
kTe.printWords()
print()
kTe.updateWord('책', 'book')
kTe.printWords()
print()
print(f'책: {kTe.searchWord("책")}')
print(f'나비: {kTe.searchWord("나비")}')
print(f'선생님: {kTe.searchWord("선생님")}')
print()
kTe.removeWord("책")
kTe.printWords()- 5) 주사위 게임 클래스를 만들고 컴퓨터와 사용자의 게임 결과 출력하기
# 모듈: 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} -> 무승부!!')# 실행파일
import dice
dc = dice.Dice()
dc.startGame()
dc.printResult()
- 6) 자동차 경주 클래스, 자동차는 랜덤하게 이동하며, 10초 동안 가장 멀리 이동한 자동차가 우승
패키지 car_game 안에 모듈 car, racing
# 모듈: 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): # 0~최고 스피드 중 랜덤하게 스피드 낼 수 있음.
return random.randint(0, self.max_speed)
def getDistanceForHour(self): # 편의상 한 시간 동안 이동한 거리로 설정
return self.controlSpeed() * 1# 모듈: 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)# 실행파일
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()- 7) mp3 플레이어 클래스를 만들고 노래 등록 후 재생해보자.
# 모듈: mp3player
import random
from time import sleep
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}, Singer: {self.singer}, Play time: {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:
print(f'Title: {s.title}, Singer: {s.singer}, Play time: {s.playtime}sec')
sleep(s.playtime)
else: # 노래가 반복재생 되지 않는 경우
for s in self.songList:
print(f'Title: {s.title}, Singer: {s.singer}, Play time: {s.playtime}sec')
sleep(s.playtime)
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('Permission', '방탄소년단', 4)
s3 = mp3.Song('Butter', '방탄소년단', 2)
s4 = mp3.Song('Weekend', 'Taeyon', 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.shuffle()
player.play()[예외 연습문제]
- 1) 사용자가 입력한 숫자를 이용해서 산술연산 결과를 출력하는 모듈을 만들되, 예상하는 예외에 대한 예외처리 코드를 작성해보자.
# 모듈: calculator
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
# if n2 == 0: # 기본적인 방법
# print('0으로 나눌 수 없습니다.')
# return
try:
print(f'{n1}/{n2} = {n1 / n2}') # Exception 활용한 방법
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 flo(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.exp(num1,num2)- 2) 1부터 1000까지의 소수인 난수 10개를 생성하되, 소수가 아니면 사용자 예외가 발생하도록 프로그램을 만들어보자.
# 모듈: prime_module
class NotPrimeException(Exception): # 소수가 아닌 경우에 발생하는 예외
def __init__(self, n):
super().__init__(f'{n} is not prime number.')
class isPrimenumber(Exception): # 소수인 경우
def __init__(self, n):
super().__init__(f'{n} is prime number.')
def isPrime(number): # 숫자가 소수인지 아닌지 판단하는 함수
flag = True
for n in range(2,number):
if number % n == 0:
flag = False
break
if flag == False:
raise NotPrimeException(number)
else:
raise isPrimenumber(number)# 실행파일
import random
import prime_module as pm
primeNumbers = []
n = 1
while n < 10: # 소수가 아니면 예외가 발생하기 때문에, 언제까지 반복될지 몰라 while 반복 사용
rn = random.randint(2,1000)
if rn not in primeNumbers: # 난수가 리스트의 숫자와 중복되지 않을 경우
try:
pm.isPrime(rn)
except pm.NotPrimeException as e:
print(e)
continue
except pm.isPrimenumber as e:
print(e)
primeNumbers.append(rn)
else: # 난수가 리스트의 숫자와 중복될 경우
print(f'{rn} is overlap number')
continue
n += 1
print(f'primeNumbers: {primeNumbers}')
- 3) 상품 구매에 따른 '총 구매 금액'을 출력하되, 다음과 같이 개수가 잘못 입력된 경우 별도로 출력하는 프로그램
# 모듈: calculatorPurchase
g1Price = 1200; g2Price = 1000; g3Price = 800; g4Price = 2000; g5Price = 900
def formatedNumber(n):
return format(n, ',')
def calculator(*gcs): # 상품을 몇개 살지 모르기 때문에
gcsDic = {} # 상품 목록화
againCntInput = {} # 재결재 해야 하는 상품들
for idx, gc in enumerate(gcs):
try:
gcsDic[f'g{idx+1}'] = int(gc)
except Exception as e:
againCntInput[f'g{idx+1}'] = gc
print(e)
totalPrice = 0
for g in gcsDic.keys():
totalPrice += globals()[f'{g}Price'] * gcsDic[g] # globals()를 사용하면 전역변수들을 다 데려온다.
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 구매 개수: ')
cp.calculator(g1Cnt, g2Cnt, g3Cnt, g4Cnt, g5Cnt)- 4) 회원가입 프로그램을 만들되 입력하지 않은 항목이 있는 경우 에러 메시지를 출력하는 프로그램을 만들어보자.
# 모듈: mem
class EmptyDataException(Exception):
def __init__(self, i):
super().__init__(f'{i} is empty!')
def checkInputData(n, m, p, a, ph):
if n == '':
raise EmptyDataException('name')
elif m == '':
raise EmptyDataException('mail')
elif p == '':
raise EmptyDataException('password')
elif a == '':
raise EmptyDataException('address')
elif ph == '':
raise EmptyDataException('phone')
class RegisMember():
def __init__(self, n, m, p, a, ph):
self.m_name = n
self.m_mail = m
self.m_password = p
self.m_address = 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_password: {self.m_password}')
print(f'm_address: {self.m_address}')
print(f'm_phone: {self.m_phone}')# 실행파일
import mem
m_name = input('이름 입력: ')
m_mail = input('메일 주소 입력: ')
m_pw = input('비밀번호 입력: ')
m_addr = input('주소 입력: ')
m_phone = input('연락처 입력: ')
try:
mem.checkInputData(m_name, m_mail, m_pw, m_addr, m_phone)
newMember = mem.RegisMember(m_name, m_mail, m_pw, m_addr, m_phone)
newMember.printMemberInfo()
except mem.EmptyDataException as e:
print(e)
- 5) 은행 계좌 개설 및 입/출금 프로그램을 만들어보자.
- 역대급 헬 난이도..
# 모듈: bank
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)
if bank.isAccount(newAccountNo):
continue
else:
self.account_no = newAccountNo
break
self.totalMoney = 0
bank.addAccount(self)
def printBankInfo(self):
print('-'* 40)
print(f'account_name: {self.account_name}')
print(f'account_no: {self.account_no}')
print(f'totalMoney: {self.totalMoney}')
print('-' * 40)
class Bank:
def __init__(self):
self.accounts = {}
def addAccount(self, privateBank):
self.accounts[privateBank.account_no] = privateBank
def isAccount(self, ano): # 신규 계좌번호가 기존에 있는 번호인지 (acountnumber)
return ano in self.accounts
def doDeposit(self, 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:
raise LackException(pb.totalMoney, m)
pb.totalMoney = pb.totalMoney - m
class LackException(Exception):
def __init__(self, m1, m2): # m1: 잔고, m2: 출금 금액
super().__init__(f'잔고 부족!! 잔액: {m1}, 출금액: {m2}')
# 실행파일
import bank
koreaBank = bank.Bank()
new_account_name = input('통장 개설을 위한 예금주 입력: ')
myAccount = bank.PrivateBank(koreaBank, new_account_name)
myAccount.printBankInfo()
while True:
selectNumber = int(input('1.입금, \t 2.출금, \t 3.종료'))
if selectNumber == 1:
m = int(input('입금액 입력: '))
koreaBank.doDeposit(myAccount.account_no, m)
myAccount.printBankInfo()
elif selectNumber == 2:
m = int(input('출금액 입력: '))
try:
koreaBank.doWithdraw(myAccount.account_no, m)
except bank.LackException as e:
print(e)
finally:
myAccount.printBankInfo()
elif selectNumber == 3:
print('bye!')
break
else:
print('잘못 입력했습니다. 다시 선택하세요.')
[ 텍스트 파일 연습문제]
- 1) 회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 '한 줄 일기'를 쓰고 읽는 프로그램을 만들어보자.
모듈: diary
import time
def writeDiary(u, f, d):
lt = time.localtime()
timeStr = time.strftime('%Y-%m-%d %I:%M:%s %p', lt)
filePath = u + f
with open(filePath, 'a') as f:
f.write(f'[{timeStr}] {d}\n')
def readDiary(u, f):
filePath = u + f
datas = []
with open(filePath, 'r') as f:
datas = f.readlines()
return datas실행파일)
import diary
members = {}
uri = '/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt'
def printMembers():
for m in members.keys():
print(f'ID: {m} \t PW: {members[m]}')
while True:
selectNum = int(input('1.회원가입 2.한줄 일기 쓰기 3.일기 보기 4.종료'))
if selectNum == 1:
mId = input('input ID: ')
mPw = input('input PW: ')
members[mId] = mPw
printMembers()
elif selectNum == 2:
mId = input('input ID: ')
mPw = input('input PW: ')
if mId in members and members[mId] == mPw:
print('login success!!')
fileName = 'myDiary_' + mId + '.txt'
data = input('오늘 하루 인상 깊은 일을 기록하세요.')
diary.writeDiary(uri, fileName, data)
else:
print('login fail!!')
printMembers()
elif selectNum == 3:
mId = input('input ID: ')
mPw = input('input PW: ')
if mId in members and members[mId] == mPw:
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('Good bye!')
break
- 2) 텍스트 파일에 수입과 지출을 기록하는 가계부를 만들어보자.
- 돈만 들어오고 빠져나가는 잔고 통장 파일, 거래내역이 나타나는 통장 파일 두개가 필요함.
import time
def getTime():
lt = time.localtime
st = time.strftime('%Y-%m-%d %H:%M:%S')
return st
while True:
selectNumber = int(input('1.입금, \t 2.출금, \t 3.종료'))
if selectNumber == 1:
money = int(input('입금액 입력: ')) # 잔고 통장
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/money.txt', 'r') as f:
m = f.read()
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/money.txt', 'w') as f:
f.write(str(int(m) + money))
memo = input('입금 내역 입력: ') # 입출금 내역 통장
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/pocketMoneyRegister.txt', 'a') as f:
f.write('-----------------------------\n')
f.write(f'{getTime()} \n')
f.write(f'[입금]{memo} : {str(money)}원 \n')
f.write(f'[잔액] : {str(int(m) + money)}원 \n')
print('입금 완료!!')
print(f'기존 잔액: {m}')
print(f'입금 후 잔액: {int(m) + money}')
elif selectNumber == 2:
money = int(input('출금액 입력: ')) # 잔고 통장
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/money.txt', 'r') as f:
m = f.read()
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/money.txt', 'w') as f:
f.write(str(int(m) - money))
memo = input('출금 내역 입력: ') # 입출금 내역 통장
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/bank/pocketMoneyRegister.txt', 'a') as f:
f.write('-----------------------------\n')
f.write(f'{getTime()} \n')
f.write(f'[출금]{memo} : {str(money)}원 \n')
f.write(f'[잔액] : {str(int(m) - money)}원 \n')
print('출금 완료!!')
print(f'기존 잔액: {m}')
print(f'출금 후 잔액: {int(m) - money}')
elif selectNumber == 3:
print('Bye~')
break
else:
print('다시 입력하세요.')
- 3) 사용자가 입력한 숫자의 약수와 소수를 텍스트 파일에 기록해보자.
# 약수 텍스트 파일에 기록하기
inputNumber = int(input('0보다 큰 정수 입력: '))
divisor = []
for number in range(1,inputNumber+1):
if inputNumber % number == 0:
divisor.append(number)
if len(divisor) > 0:
try:
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/divisor.txt', 'a') as f:
f.write(f'{inputNumber}의 약수: ')
f.write(f'{divisor}\n')
except Exception as e:
print(e)
else:
print('divisor write comple')
# 소수 텍스트 파일에 기록하기
inputNumber = int(input('0보다 큰 정수 입력: '))
prime = []
for number in range(2, inputNumber + 1):
flag = True
for n in range(2, number):
if number % n == 0:
flag = False
break
if flag:
prime.append(number)
if len(prime) > 0:
try:
with open ('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/prime.txt', 'a') as f:
f.write(f'{inputNumber}까지의 소수')
f.write(f'{prime}\n')
except Exception as e:
print(e)
else:
print('prime write comple')- 4) 두 개의 수를 입력하면 공약수와 최대 공약수를 텍스트 파일에 작성해보자.
# 수 두개의 공약수 구하기
num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
common = []
for i in range(1,(num1+1)):
if num1 % i == 0 and num2 % i == 0:
common.append(i)
if len(common) > 0:
try:
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/common.txt', 'a') as f:
f.write(f'{num1}과 {num2}의 공약수: ')
f.write(f'{common}\n')
except Exception as e:
print(e)
else:
print('common factor write complete!!')
# 수 두개의 최대공약수 구하기
num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
maxComNum = 0
for i in range(1,(num1+1)):
if num1 % i == 0 and num2 % i == 0:
maxComNum = i
try:
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/maxComNum.txt', 'a') as f:
f.write(f'{num1}과 {num2}의 최대 공약수: {maxComNum} \n')
except Exception as e:
print(e)
else:
print('max common factor write complete!!')- 5)
# 3개의 수의 최소공배수를 구할때는 2개의 최소공배수 먼저 구한다.
ship1 = 3
ship2 = 4
ship3 = 5
maxDay = 0
for i in range(1, ship1+1):
if ship1 % i == 0 and ship2 % i == 0:
maxDay = i
minDay = (ship1 * ship2) // maxDay
newDay = minDay
for i in range(1, newDay + 1):
if newDay % i == 0 and ship3 % i == 0:
maxDay = i
minDay = (newDay * ship3) // maxDay
print(f'minDay: {minDay}')
print(f'maxDay: {maxDay}')
from datetime import datetime
from datetime import timedelta
n = 1
baseTime = datetime(2021, 1, 1, 10, 0, 0) # 기준일: 2021년 1월 1일 10시 0분 0초
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/arrive.txt', 'a') as f:
f.write(f'2021년 모든 선박 입항일 \n')
f.write(f'{baseTime}\n')
nextTime = baseTime + timedelta(days=minDay) # timedelta 모듈: 기존의 날짜에 숫자를 더하면 그 숫자가 더해진 해당하는 날짜 계산
while True:
with open('/Users/chulmin/Library/Mobile Documents/com~apple~CloudDocs/pythonTxt/arrive.txt', 'a') as f:
f.write(f'{nextTime}\n')
nextTime = nextTime + timedelta(days=minDay)
if nextTime.year > 2021: # 무한반복하다가 날짜가 2022년으로 넘어가면 안되므로
break
늘 온 마음을 다해 :)