3️⃣ 파이썬 중급 문제풀이
40. 함수 (01)
# 함수를 이용한 프로그래밍
# 문제 1
# 다음과 같이 출력될 수 있도록 산술연산 계산기 함수를 이용해서 만들어보자.
def add(n1, n2):
return n1 + n2ㅂ
def sub(n1, n2):
return n1 - n2
def mul(n1, n2):
return n1 * n2
def div(n1, n2):
return n1 / n2
def mod(n1, n2):
return n1 % n2
def flo(n1, n2):
return n1 // n2
def exp(n1, n2):
return n1 ** n2
while True:
print('-' * 60)
selectNum = int(input('1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료'))
if selectNum == 8: #종료할 때를 먼저 구현해주고 while문을 빠져나갈 때를 계산해줌
print('Bye~')
break
num1 = float(input('첫 번째 숫자 입력: '))
num2 = float(input('두 번째 숫자 입력: '))
if selectNum == 1:
print(f'{num1} + {num2} = {add(num1, num2)}')
elif selectNum == 2:
print(f'{num1} - {num2} = {sub(num1, num2)}')
elif selectNum == 3:
print(f'{num1} * {num2} = {mul(num1, num2)}')
elif selectNum == 4:
print(f'{num1} / {num2} = {div(num1, num2)}')
elif selectNum == 5:
print(f'{num1} % {num2} = {mod(num1, num2)}')
elif selectNum == 6:
print(f'{num1} // {num2} = {flo(num1, num2)}')
elif selectNum == 7:
print(f'{num1} ** {num2} = {exp(num1, num2)}')
else:
print('잘못 입력했습니다. 다시 입력하세요.')
print('-' * 60)
41. 함수 (02) - 거리, 속력, 시간 계산
# 다음과 같이 출력될 수 있도록 이동거리와 이동시간을 반환하는 함수를 만들어 보자.
# 거리(km) = 속도(km/h) * 시간(h)
#이동거리
def getDistance(s, h, m):
distance = s * (h + m/60) # 분 단위도 따로 더해준다.
return distance
# 100:75 = 60:x --> x = 75*60 / 100
def getTime(s, d):
time = d / s
print(f'time: {time}')
h = int(time)
m = int((time - h) * 100 * 60 / 100) ###############
return [h, m] #리스트: 자료구조형으로 반환 가능
print('-' * 60)
s = float(input('속도(km/h) 입력: '))
h = float(input('시간(h) 입력: '))
m = float(input('시간(m) 입력: '))
d = getDistance(s, h, m) #변수 안에 넣어줄 수 있음
print(f'{s}(km/h)속도로 {h}(h)시간 {m}분 동안 이동한 거리: {d}(km)')
print('-' * 60)
print('-' * 60)
s = float(input('속도(km/h) 입력: '))
d = float(input('거리(km) 입력: '))
t = getTime(s, d) #변수 안에 넣어줄 수 있음
print(f'{s}(km/h)속도로 {d}(km) 이동한 시간: {t[0]}(h)시간 {t[1]}(m)분') #t의 인덱스 0, 1
print('-' * 60)42. 함수 (03) - 요금 계산
# 다음과 같이 출력될 수 있도록 비행기 티켓 영수증 출력 함수를 만들어 보자.
#문제 풀이
childPrice = 18000
infantPrice = 25000
adultPrice = 50000
specialDC = 50
#천 단위로 끊어주는 함수를 만들어서 사용하면 편리하다!
def formatedNumber(n):
return format(n, ',')
def printAirPlaneReceipt(c1, c2, i1, i2, a1, a2): #매개변수 주기: 각각 인원 수를 따로 지정
cp = c1 * childPrice #child price
cp_dc = int(c2 * childPrice * 0.5)
print(f'유아 {c1}명 요금: {formatedNumber(cp)}원')
print(f'유아 할인 대상 {c2}명 요금: {formatedNumber(cp_dc)}원')
ip = i1 * infantPrice
ip_dc = int(i2 * infantPrice * 0.5)
print(f'소아 {i1}명 요금: {formatedNumber(ip)}원')
print(f'소아 할인 대상 {i2}명 요금: {formatedNumber(ip_dc)}원')
ap = a1 * adultPrice
ap_dc = int(a2 * adultPrice * 0.5)
print(f'성인 {a1}명 요금: {formatedNumber(ap)}원')
print(f'성인 할인 대상 {a2}명 요금: {formatedNumber(ap_dc)}원')
print(f'Total: {formatedNumber(c1 + c2 + i1 + i2 + a1 + a2)}명')
print(f'TotalPrice: {formatedNumber(cp + cp_dc + ip + ip_dc + ap + ap_dc)}원')
childCnt = int(input('유아 입력: '))
specialDCChildCnt = int(input('할인 대상 유아 입력: '))
infantCnt = int(input('소아 입력: '))
specialDCinfantCnt = int(input('할인 대상 소아 입력: '))
adultCnt = int(input('성인 입력: '))
specialDCAdultCnt = int(input('할인 대상 성인 입력: '))
printAirPlaneReceipt(childCnt, specialDCChildCnt, infantCnt, specialDCinfantCnt, adultCnt, specialDCAdultCnt)
43. 함수 (04) - 단리 / 월복리
#다음과 같이 출력될 수 있도록 단리/월복리 계산기 함수를 만들어보자.
def formatedNumber(n):
return format(n, ',')
# 단리
def singleRateCalculator(m, t, r): #t: 기간
totalMoney = 0 # 최종
totalRateMoney = 0
for i in range(t):
totalRateMoney += m * (r * 0.01)
totalMoney = m + totalRateMoney
return int(totalMoney)
# 월복리
def multiRateCalculator(m, t, r): #돈, 기간(년), 이율
t = t * 12 #받는 기간이 '연'이므로 '월'로 환산 필요
rpm = (r / 12) * 0.01 #이자는 '년' 이자이므로 '월'로 환산 필요 // %로 받으니까 0.01을 곱해줌
totalMoney = m
for i in range(t):
totalMoney = totalMoney + (totalMoney * rpm)
return int(totalMoney)
money = int(input('예치금: '))
term = int(input('기간(년): '))
rate = int(input('연 이율(%): '))
print('[단리 계산기]')
print(f'{term}년 후 총 수령액 : {formatedNumber(singleRateCalculator(money, term, rate))}원') #입력 받는대로 던져주기
print('[복리 계산기]')
print(f'{term}년 후 총 수령액 : {formatedNumber(multiRateCalculator(money, term, rate))}원')
44. 함수 (05) - 등차 수열
#다음과 같이 출력될 수 있도록 등차 수열의 n번째 값과 합을 출력하는 함수를 만들어보자.
#공식을 이용해서 직접 구할 수도 있음
#등차 수열 공식: an = a1 + (n-1) * d
#등차 수열 합 공식: sn = n * (a1 + an) / 2
def sequenceCal(n1, d, n):#초항, 공차, n번째 항
valueN = 0; sumN = 0; #n항의 값, n항까지 합의 값
i = 1
while i <= n: #i가 1보다 작거나 같을 때의 값까지
if i == 1: #i==1일 때
valueN = n1
sumN += valueN #n=1이기 때문에 sumN = valueN: 동일!
print(f'{i}번째 항의 값: {valueN}')
print(f'{i}번째 항까지의 값: {sumN}')
i += 1
continue
#나머지 i==2일 때부터
valueN += d #n항의 값: 공차를 더한 값
sumN += valueN #n항까지의 합: n항의 값을 계속해서 더해주면 됨
print(f'{i}번째 항의 값: {valueN}')
print(f'{i}번째 항까지의 값: {sumN}')
i += 1
inputN1 = int(input('a1 입력: '))
inputD = int(input('공차 입력: '))
inputN = int(input('n 입력: '))
sequenceCal(inputN1, inputD, inputN)
45. 함수 (06) - 등비 수열
# 다음과 같이 출력될 수 있도록 등비 수열의 n번째 값과 합을 출력하는 함수를 만들어보자.
# 등비 수열(일반항) 공식: an = a1 * r^(n-1)
# 등비 수열의 (합) 공식: sn = a1 * (1-r^n) / 1-r
def sequenceCal (n1, r, n): #초항, 공비, n번째 항
valueN = 0; sumN = 0
i = 1
while i <= n:
if i == 1:
valueN = n1
sumN = valueN
print(f'{i}번째 항의 값: {valueN}')
print(f'{i}번째 항까지의 값: {sumN}')
i += 1
continue #i가 1인 경우에는 아래 구문을 실행하지 않도록 continue 구문을 사용해준다.
valueN *= r
sumN *= valueN
print(f'{i}번째 항의 값: {valueN}')
print(f'{i}번째 항까지의 값: {sumN}')
i += 1
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))
sequenceCal(inputN1, inputR, inputN)
46. 모듈 (01) - 시험 합불 판단
# 모듈: passOrFail
def exampleResult(s1, s2, s3, s4, s5):
passAvgScore = 60;
limitScore = 40 # 변수 지정 중요!!
def getTotal():
totalScore = s1 + s2 + s3 + s4 + s5
print(f'총점: {totalScore}')
return totalScore # return 함수 사용
def getAverage():
avg = getTotal() / 5
print(f'평균: {avg}')
return avg
def printPassOrFail():
print(f'{s1}: Pass') if s1 >= limitScore else print(f'{s1}: Fail')
print(f'{s2}: Pass') if s1 >= limitScore else print(f'{s2}: Fail')
print(f'{s3}: Pass') if s1 >= limitScore else print(f'{s3}: Fail')
print(f'{s4}: Pass') if s1 >= limitScore else print(f'{s4}: Fail')
print(f'{s5}: Pass') if s1 >= limitScore else print(f'{s5}: Fail')
def printFinalPassOrFail():
if getAverage() >= passAvgScore:
if s1 >= limitScore and s2 >= limitScore and s3 >= limitScore and s4 >= limitScore and s5 >= limitScore:
print('Final Pass!!')
else:
print('Final Fail!!')
else: # 60점 미만
print('Final Fail!!')
# getTotal()
getAverage()
printPassOrFail()
printFinalPassOrFail()
# 실행 파일
# 과목별 점수를 입력하면 합격 여부를 출력하는 모듈을 만들어보자.
# (평균 60이상 합격, 과락 40으로 한다.)
import passOrFail as pf
if __name__ == '__main__':
sub1 = int(input('과목1 점수 입력: '))
sub2 = int(input('과목2 점수 입력: '))
sub3 = int(input('과목3 점수 입력: '))
sub4 = int(input('과목4 점수 입력: '))
sub5 = int(input('과목5 점수 입력: '))
pf.exampleResult(sub1, sub2, sub3, sub4, sub5)47. 모듈 (02) - 상품 개수에 따른 할인율 결정 모듈
# 모듈: discount
def calculatorTotalPrice(gs): #goods
if len(gs) <= 0: #리스트형으로!
print('구매 상품이 없습니다.')
return
rate = 25 #최대 25%
totalPrice = 0
rates = {1:5, 2:10, 3:15, 4:20} #할인율을 담고 있는 딕셔너리를 만들어줌
if len(gs) in rates: #할인율
rate = rates[len(gs)]
for g in gs:
totalPrice += g * (1 - rate * 0.01)
return [rate, int(totalPrice)] #이 값이 실행파일에서 말하는 result이고 0번째와 1번째 출력
def formatedNumber(n):
return format(n, ',')# 실행 파일
import discount as dc
if __name__ == '__main__': #실행파일과 같다면
flag = True
gs = [] #구매 상품을 담을 리스트 만들기
while flag:
selecNumber = int(input('상품을 구매 하시겠어요? 1.구매 2.종료'))
if selecNumber == 1:
goods_price = int(input('상품 가격 입력: '))
gs.append(goods_price)
elif selecNumber == 2:
result = dc.calculatorTotalPrice(gs) #dc라는 파이썬 파일에서 calculatorTotalPrice라는 함수를 실행해라
flag = False
print(f'할인율: {result[0]}%')
print(f'합계: {dc.formatedNumber(result[1])}원')
48. 모듈 (03) - 로또 모듈
# 모듈: lotto
import random
#난수 발생 기능
#사용자가 입력한 번호를 저장하는 기능
import random
userNums = []
randNums = []
collNums = []
randBonNum = 0
def setUserNum(ns):
global userNums # 전역변수
userNums = ns
return userNums
def setRandNums():
global randNums # 전역변수
randNums = random.sample(range(1, 46), 6)
return randNums
def setBonNum():
global randBonNum # 전역변수
while True:
randBonNum = random.randint(1,45)
if randBonNum not in randNums: # 보너스 번호는 당첨번호와 겹치지 않기위해
break
return randBonNum
def lottoResult():
global userNums
global randNums
global collNums
collNums = []
for un in userNums: # 선택한 번호가
if un in randNums: # 당첨 번호에 있으면
collNums.append(un) # collNums 리스트에 추가
if len(collNums) == 6:
print('1등 당첨')
print(f'번호: {collNums}')
elif (len(collNums) == 5) and (randBonNum in userNums):
print('2등 당첨')
print(f'번호: {collNums}, 보너스 번호: {randBonNum}')
elif len(collNums) == 5:
print('3등 당첨')
print(f'번호: {collNums}')
elif len(collNums) == 4:
print('4등 당첨')
print(f'번호: {collNums}')
elif len(collNums) == 3:
print('5등 당첨')
print(f'번호: {collNums}')
else:
print('아쉽습니다. 다음 기회에~')
print(f'당첨 번호: {randNums}')
print(f'보너스 번호: {randBonNum}')
print(f'선택 번호: {userNums}')
print(f'일치 번호: {collNums}')
def startLotto(): # 이 안에 전체 내용 정리
n1 = int(input('번호(1~45) 입력: '))
n2 = int(input('번호(1~45) 입력: '))
n3 = int(input('번호(1~45) 입력: '))
n4 = int(input('번호(1~45) 입력: '))
n5 = int(input('번호(1~45) 입력: '))
n6 = int(input('번호(1~45) 입력: '))
selectNums = [n1, n2, n3, n4, n5, n6]
setUserNum(selectNums)
setRandNums()
setBonNum()
lottoResult()# 실행 파일
# 로또 모듈을 만들고 다음과 같이 로또 결과가 출력될 수 있도록 프로그램을 만들어보자.
import lotto as lt
lt.startLotto()49. 모듈 (04) - 순열(P) 모듈
# 모듈: permutation
def getPermutationCnt(n, r, logPrint = True):
result = 1
for n in range(n, (n-r), -1):
if logPrint: print('n: {}'.format(n)) #로그를 찍고 싶을 떄
result = result * n
return result
#####경우의 수까지 알고 싶을 때: 내부 모듈 사용
from itertools import permutations #경우의 수를 실제로 볼 수 있도록 결과를 반환해줌
def getPermutations(ns, r):
pList = list(permutations(ns, r)) #리스트형
print(f'{len(ns)}P{r} 개수: {len(pList)}')
for n in permutations(ns, r):
print(n, end='')
# 실행 파일
import permutation as pt
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
# print(f'{numN}P{numR}: {pt.getPermutationCnt(numN, numR, logPrint=False)}') #로그가 안찍히길 바랄 때
listVar = [1,2,3,4,5,6,7,8]
rVar = 3 #3개씩 뽑아서 나열
pt.getPermutations(listVar, rVar)50. 모듈 (05) - 조합(C) 모듈
# 모듈: combination
def getCombinationCnt(n, r, logPrint = True):
resultP = 1 #순열부터 구하기
resultR = 1
resultC = 1
for n in range(n, (n-r), -1): #1. 순열
resultP = resultP * n
####
if logPrint: print(f'resultP: {resultP}')
for n in range(r, 0, -1): #2. 팩토리얼
resultR = resultR * n
if logPrint: print(f'resultR: {resultR}')
resultC = int(resultP / resultR)
if logPrint: print(f'resultC: {resultC}')
return resultC
#######내부 모듈 이용
from itertools import combinations
def getCombinations(ns, r):
clist = list(combinations(ns, r)) #조합 경우의 수가 들어있는 자료가 만들어짐
print(f'{len(ns)}C{r}: {len(clist)}') # 몇 가지 경우의 수가 나오는지
for n in combinations(ns, r):
print(n, end='')# 실행 파일
import combination as ct
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
print(f'{numN}C{numR}: {ct.getCombinationCnt(numN, numR, logPrint=False)}')
###############
listVar = [1,2,3,4,5,6,7,8]
rVar = 3 #순서에 상관없이 3개씩 묶었을 때
ct.getCombinations(listVar, rVar)51. 모듈 (06) - 공과금 총액 및 비율 구하기 모듈
# 모듈: utilityBill
income = 0
waterPrice = 0; electricPrice = 0; gasPrice = 0
def setIncome(ic): #셋
global income
income = ic
def getIncome(): #가져옴
return income
def setWaterPrice(wp): #셋
global waterPrice
waterPrice = wp
def getWaterPrice(): #가져옴
return waterPrice
def setElectricPrice(ep): #셋
global electricPrice
electricPrice = ep
def getElectricPrice(): #가져옴
return electricPrice
def setGasPrice(gp): #셋
global gasPrice
gasPrice = gp
def getGasPrice(): #가져옴
return gasPrice
def getUtilityBill():
result = waterPrice + electricPrice + gasPrice
return result
def getUtilityBillRate():
result = getUtilityBill() / getIncome() * 100
return result# 실행 파일
# 수입과 공과금을 입력하면 공과금 총액과 수입 대비 공과금 비율을 계산하는 모듈을 만들어보자.
import utilityBill as ub
inputIncome = int(input('수입 입력: '))
ub.setIncome(inputIncome)
inputWaterPrice = int(input('수도요금 입력: '))
ub.setWaterPrice(inputWaterPrice)
inputElectricPrice = int(input('전기요금 입력: '))
ub.setElectricPrice(inputElectricPrice)
inputGasPrice = int(input('가스요금 입력: '))
ub.setGasPrice(inputGasPrice)
print(f'공과금: {ub.getUtilityBill()}원')
print(f'수입 대비 공과금 비율: {ub.getUtilityBillRate()}%')52. 모듈 (07) - 패키지 모듈 만들고 실행하기
# 다음과 같이 패키지와 모듈을 만들고 연산 결과를 출력해 보자.
# 실행파일
from arithmetic import basic_operation as bo
from arithmetic import developer_operation as do
from shape import triangle_square_area as tsa
from shape import circle_area as ca
inputNumber1 = float(input('숫자1 입력: '))
inputNumber2 = float(input('숫자2 입력: '))
print(f'{inputNumber1} + {inputNumber2} = {bo.add(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} - {inputNumber2} = {bo.sub(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} * {inputNumber2} = {bo.mul(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} / {inputNumber2} = {bo.div(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} % {inputNumber2} = {do.mod(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} // {inputNumber2} = {do.flo(inputNumber1, inputNumber2)}')
print(f'{inputNumber1} ** {inputNumber2} = {do.exp(inputNumber1, inputNumber2)}')
inputWidth = float(input('가로 길이 입력: '))
inputHeight = float(input('세로 길이 입력: '))
print(f'삼각형 넓이: {tsa.calTriangleArea(inputWidth, inputHeight)}')
print(f'사각형 넓이: {tsa.calSquareArea(inputWidth, inputHeight)}')
inputRadius = float(input('반지름 입력: '))
print(f'원의 넓이: {ca.calCircleArea(inputRadius)}')53. 클래스 (01) - 회원가입 및 탈퇴
# 클래스: member
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):
if i in self.members:
if self.members[i] == p:
del self.members[i]
print('remove success!!')
else:
print('remove fail!!')
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', 'c')54. 클래스 (02) - 클래스 상속 및 객체 생성
# 클래스: 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' #기본적인 tv
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')
# 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. 클래스 (03) - 도서 정보 및 저장소
# 클래스: book
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, '12345678'))
myBRepository.registbook(bk.Book('java', 25000, '89833040'))
myBRepository.registbook(bk.Book('c/c++', 27000, '23456789'))
myBRepository.printBooksInfo()
print() #띄어쓰기
myBRepository.printBookInfo('23456789')
myBRepository.removeBook('23456789')
myBRepository.printBooksInfo()56. 클래스 (04) - 추상 클래스를 이용하여 사전 만들기
# 클래스: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()
kTe.updateWord('책', 'book') #단어 수정을 원할 때
kTe.printWords()
print(f'책 : {kTe.searchWord("책")}') #검색을 원할 때
print(f'나비 : {kTe.searchWord("나비")}') #검색을 원할 때
print(f'선생님 : {kTe.searchWord("선생님")}') #검색을 원할 때
kTe.removeWord('책')
kTe.printWords()57. 클래스 (05) - 주사위 게임 클래스
# 클래스: dice
import random as rd
class Dice:
def __init__(self):
self.cNum = 0 #컴퓨터
self.uNum = 0 #사용자
def setCnum(self):
print('[Dice] setGame()')
self.cNum = rd.randint(1, 6)
def setUnum(self):
print('[Dice] setGame()')
self.uNum = rd.randint(1, 6) #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()58. 클래스 (06) - 자동차 경주 게임(패키지 사용)
# 클래스: 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}, color: {self.color}, max_speed: {self.max_speed}')
def controlSpeed(self):
return random.randint(0, self.max_speed) #0부터 max_speed 사이의 설정값이 나온다고 가정
def getDistanceForHour(self):
return self.controlSpeed() * 1 #1시간 동안 이동한 거리
# 클래스: racing
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}바퀴') #i는 0 바퀴
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)# 실행 파일
#자동차 경주 게임 클래스를 만들어 보자. 자동차는 랜덤하게 이동하며, 편의상 10초 동안 주행한다고 할 때 가장 멀리 이동한 자동차가 우승하는 게임이다.
#car class: 자동차 등록
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()
#4번이 우승한 것을 알 수 있음59. 클래스 (07) - mp3 플레이어 재생
# 클래스: mp3player
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: #반복 재생이 true라면 무한 반복해라
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# 실행 파일
#다음과 같이 mp3 플레이어 클래스를 만들고 노래 등록 후 재생해보자.
import mp3player as mp3
s1 = mp3.Song('신호등', '이무진', 3)
s2 = mp3.Song('Permission', '방탄소년단', 4)
s3 = mp3.Song('Butter', '방탄소년단', 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) #true를 주면 영원히 반복 재생됨
player.suffle()
player.play()60. 예외처리 (01)
# 모듈
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}')
except ZeroDivisionError as e:
print(e)
print('0으로 나눌 수 없습니다.')
# print(f'{n1} / {n2} = {n1 / n2}')
############
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)61. 예외처리 (02)
# 모듈
class NotPrimeException(Exception):
def __init__(self, n):
super().__init__(f'{n} is not prime number.') #소수가 아니다.
class PrimeException(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 PrimeException(number) #소수일 때# 실행 파일
#1부터 1000까지의 소수인 난수 10개를 생성하되, 소수가 아니면 사용자 예외가 발생하도록 프로그램을 만들어보자.
import random
import prime_module as pm
primeNumbers = []
#언제 끝날지 모를 때: while문을 이용한다.
n = 0
while n < 10: # 0~9까지
rn = random.randint(2, 1000) #1은 소수도, 합성수도 아니기 때문에 제외해야 한다.
if rn not in primeNumbers: #중복되지 않는 난수
try:
pm.isPrime(rn) #소수인지 판단
except pm.NotPrimeException as e:
print(e)
continue #소수가 아니면 필요가 없기 때문에 컨티뉴
except pm.PrimeException as e: #소수라면 프라임익셉션 실행
print(e)
primeNumbers.append(rn)
else:
print(f'{rn} is overlap number.') #중복
continue
n += 1
print(f'primeNumbers: {primeNumbers}')62. 예외처리 (03)
# 모듈
#상품가격 정하기
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() 함수: 위에 있는 변수 참조 가능 -> g: g1, g2, g3 참조
print('------------------------------------------------')
print(f'총 구매 금액: {formatedNumber(totalPrice)}원')
print('------------------------미결제 항목------------------------')
for g in againCntInput.keys():
print(f'상품: {g}, \t 구매 개수: {againCntInput}')
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)63. 예외처리 (04)
#회원 관리 모듈
#예외 클래스 만들기
class EmptyDataException(Exception): #사용자 예외 클래스를 상속 받는다.
def __init__(self, i): #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 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('연락처 입력: ')
try:
mem.checkInputData(m_name, m_mail, m_pw, m_addr, m_phone)
newMember = mem.RegistMember(m_name, m_mail, m_pw, m_addr, m_phone)
newMember.printMemberInfo()
except mem.EmptyDataException as e:
print(e)64. 예외처리 (05) - 은행 계좌 개설 및 출금
# 모듈
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): #true면 기존에 있는 것이기 때문에 계속 돌려야 함
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 #account에 추가해주는데, 개인계좌의 account number를 키 값 => 으로 한 value를 개인 계좌로
def isAccount(self, ano):
return ano in self.accounts #ano, 즉 account number가 있는지 반환해주면 됨
def deDeposit(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): #잔고, 출금 금액을 받음
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.deDeposit(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('잘못 입력했습니다. 다시 선택하세요.')65. 텍스트 파일 (01) - readlines()
# 모듈
import time
def writeDiary(u, f, d):
lt = time.localtime()
timeStr = time.strftime('%Y-%m-%d %I:%M:%s %p', lt) #streamformattime: time의 형식을 지정해 줌
filePath = u + f
with open(filePath,'a') as f:
f.write(f'[{timeStr}] {d}\n')
def readDiary(u, f, d): #내용은 필요 없음
filePath = u + f
datas = []
with open(filePath,'r') as f:
datas = f.readlines() #여러줄을 한 번에 읽는다
return datas# 실행 파일
#텍스트 파일 읽기/쓰기 프로그래밍
#회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 '한 줄 일기'를 쓰고 읽는 프로그램을 만들어보자.
import diary
members = {} #딕셔너리로 선언: 아이디와 패스 관리
uri = '/Users/user1/Downloads/pythonEx/'
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 #id가 키 값, pw가 벨류값
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, data)
for d in datas:
print(d, end='')
else:
print('login fail!!')
printMembers()
elif selectNum == 4:
print('Bye~')
break #while문을 빠져나온다.66. 텍스트 파일 (02) - 수입, 지출 기록 가계부(r, w, a)
#텍스트 파일에 수입과 지출을 기록하는 가계부를 만들어보자.
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/user1/Downloads/pythonEx/pythonTxt/bank.txt', 'r') as f: #입금 이력 파일, 잔고 파일 2개 필요! #읽기 모드는 파일이 없으면 에러가 나기 때문에!
m = f.read()
with open('/Users/user1/Downloads/pythonEx/pythonTxt/bank.txt', 'w') as f: #w모드: 잔고를 쓸 때는 기존 내용을 갱신해야 하기 때문!
f.write(str(int(m) + money)) #기존 잔고: m -> 눈으로는 숫자로 보여도 실제로는 문자열 -> int로 캐스팅/ 사용자가 입금한 금액: money
memo = input('입금 내역 입력: ')
with open('/Users/user1/Downloads/pythonEx/pythonTxt/poketMoneyRegister.txt', 'a') as f:
f.write('-----------------------------------------------')
f.write(f'{getTime()} \n')
f.write(f'[입금] {memo} : {str(money)}원 \n')
f.write(f'[잔액] : {str(int(m) + money)}원 \n')
print('입금 완료!!')
print(f'입금 후 잔액: {int(m) + money}') #기존에 있던 money
elif selectNumber == 2:
money = int(input('출금액 입력: '))
with open('/Users/user1/Downloads/pythonEx/pythonTxt/bank.txt', 'r') as f: #입금 이력 파일, 잔고 파일 2개 필요! #읽기 모드는 파일이 없으면 에러가 나기 때문에!
m = f.read()
with open('/Users/user1/Downloads/pythonEx/pythonTxt/money.txt', 'w') as f: #w모드: 잔고를 쓸 때는 기존 내용을 갱신해야 하기 때문!
f.write(str(int(m) - money)) #기존 잔고: m -> 눈으로는 숫자로 보여도 실제로는 문자열 -> int로 캐스팅/ 사용자가 입금한 금액: money
memo = input('출금 내역 입력: ')
with open('/Users/user1/Downloads/pythonEx/pythonTxt/poketMoneyRegister.txt', 'a') as f:
f.write('-----------------------------------------------')
f.write(f'{getTime()} \n')
f.write(f'[출금] {memo} : {str(money)}원 \n')
f.write(f'[잔액] : {str(int(m) - money)}원 \n')
print('출근 완료!!')
print(f'출금 후 잔액: {int(m) - money}') #기존에 있던 money
67. 텍스트 파일 (03) - 소수 기록
# 소수
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/user1/Downloads/pythonEx/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 complete!!')68. 텍스트 파일 (04) - 공약수, 최대공약수 구하기
#공약수
num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
common = []
for i in range(1, (num1 + 1)):
if num1 % i == 0 and num2 % i == 0: #동시에 0이면 공약수
common.append(i) # 차이점
if len(common) > 0:
try:
with open('/Users/user1/Downloads/pythonEx/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/user1/Downloads/pythonEx/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!!')69. 텍스트 파일 (05) - 최대공약수(선박 입항 주기)
#과일 선박: 3일 주기 / 생선 선박: 4일 주기 / 야채 선박: 5일 주기
#배 입항 날짜
ship1= 3
ship2 = 4
ship3 = 5
maxDay = 0 #최대 공약수 초기값
for i in range(1, (ship1 + 1)): #1번배가 들어오는날까지 최대 공약수 구하기
if ship1 % i == 0 and ship2 % i ==0: #ship1,ship2가 나누어떨어지면 maxDay변수에저장
maxDay = i #1,2번 선박의 최대 공약수이다.(maxDay 최대 공약수)
minDay = (ship1 * ship2) // maxDay #최소 공배수
newDay = minDay
for i in range(1, (newDay + 1)):
if newDay % i == 0 and ship3 % i == 0:
maxDay = i #ship1,ship2,ship3의 최대 공약수
minDay = (newDay * ship3) // maxDay #배 3개에 대한 최소 공배수
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)
with open('/Users/user1/Downloads/pythonEx/pythonTxt/arrive.txt', 'a') as f:
f.write(f'2021년 모든 선박 입항일\n')
f.write(f'{baseTime}\n')
nextTime = baseTime + timedelta(days=minDay)
while True:
with open('/Users/user1/Downloads/pythonEx/pythonTxt/arrive.txt', 'a') as f:
f.write(f'{nextTime}\n')
nextTime = nextTime + timedelta(days=minDay)
if nextTime.year > 2021:
break
데이터 분석 공부 기록