😢 스터디노트(Python 중급 문제풀이 3~8)

꼭꼭 다시풀어보기!! 😰

💡 [연습문제] 모듈 04

• 💡 itertools :
  - from itertools import permutations → 순열 함수 사용 가능, list를 입력해야 하고 list 형태로 반환

💡 순열 계산 모듈을 만들고 다음 순열 계산 결과를 출력

# permultation 파일 

def getPermulatationCnt(n,r,logPrint = True):
    result = 1

    for n in range(n,n-r,-1):
        if logPrint == True: print('n : {}'.format(n)) # ★★★
        result = result * n
    return result

from itertools import permutations

def gerPermultation(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 permultation as pt

#n = int(input('numN 입력 : '))
#r = int(input('numR 입력 : '))

#print(f'{n}P{r} : {pt.getPermulatationCnt(n,r,logPrint=False)}')
listVar = {1,2,3,4,5,6,7,8}
rVar = 3
pt.gerPermultation(listVar, rVar)

---

[연습문제] 모듈 05

• 💡 itertools :
  - from itertools import combinations → 조합 함수 사용 가능, list를 입력해야 하고 list 형태로 반환
  

💡 조합 계산 모듈을 만들고 다음 조합 계산 결과를 출력

# combination 파일

def getCombination(n,r, logPrint = True):

    resultP = 1
    resultR = 1
    resultC = 1

    for i in range(n, n-r,-1):
        resultP  = resultP  * i

    if logPrint : print(f'resultP : {resultP}')

    for i in range(r, 0,-1):
        resultR  = resultR  * i
        if logPrint: print(f'resultR : {resultR}')

    resultC = int(resultP / resultR)
    if logPrint : print(f'result : {resultC}')

    return resultC



from itertools import combinations

def printCombinations(ns,r): #리스트로 받아야 함(?)
    cList = list(combinations(ns,r))
    print(f'{len(ns)}C{r} : {len(cList)}')

    for i in combinations(ns,r):
        print(i, end=',')

# 조합 계산 모듈을 만들고 다음 조합 계산 결과를 출력

import combination as ct

numN = int(input('numN 입력 : '))
numR = int(input('numR 입력 : '))

#ct.getCombination(numN, numR)
print(f'{numN}C{numR} : {ct.getCombination(numN,numR, logPrint=False)}')


listVar = {1,2,3,4,5,6,7,8}
rVar = 3
ct.printCombinations(listVar, rVar)

---

💡 [연습문제] 모듈 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 getUtilityRate():
    result = (getUtilityBill() / getIncome()) * 100
    return result

def getFormated(num):
    return format(num,',')

# 수입과 공과금을 입력하면 공과금 총액과 수입 대비 공과금 비율을 계산하는 모듈을 생성

import utilitybill as ub

inputIncome = int(input('수입 입력 : '))
ub.setIncome(inputIncome)
inputWaterPrice = int(input('수도요금 입력 : '))
ub.setWaterPrice(inputWaterPrice)
inputEletricPrice = int(input('전기요금 입력 : '))
ub.setElectricPrice(inputEletricPrice)
inputGasPrice = int(input('가스요금 입력 : '))
ub.setGasPrice(inputGasPrice)

print(f'공과금 : {ub.getFormated(ub.getUtilityBill())}')
print('수입 대비 공과금 비율 : {} %'.format(ub.getUtilityRate()))

---

[연습문제] 모듈 07

다음과 같이 패키지와 모듈을 만들고 연산 결과를 출력

# basic_operator 파일

def add(num1, num2):
    print(f'{num1} + {num2} = {num1 + num2}')
    return num1 + num2

def sub(num1, num2):
    print(f'{num1} - {num2} = {num1 - num2}')
    return num1 - num2

def mul(num1, num2):
    print(f'{num1} * {num2} = {round(num1 * num2,2)}')
    return num1 * num2

def div(num1, num2):
    print(f'{num1} / {num2} = {round(num1 / num2,2)}')
    return num1 / num2

def calculator(num1,num2):
    add(num1,num2)
    sub(num1,num2)
    mul(num1,num2)
    div(num1,num2)

# developer_operator 파일

def mod(num1, num2):
    print(f'{num1} % {num2} = {round(num1 % num2,2)}')
    return num1 % num2

def flo(num1, num2):
    print(f'{num1} // {num2} = {round(num1 // num2,2)}')
    return num1 // num2

def exp(num1, num2):
    print(f'{num1} ** {num2} = {round(num1 ** num2,2)}')
    return num1 ** num2

def calculator(num1,num2):
    mod(num1,num2)
    flo(num1,num2)
    exp(num1,num2)

# triangle_square_area 파일

def calculatorTriangleSquareArea(num1,num2):
    triangle = num1 * num2 / 2
    square = num1 * num2
    print('삼각형 넓이 : {}' .format(round(triangle,1)))
    print('사각형 넓이 : {}'.format(round(square, 1)))
    return [triangle,square]

# circle_area 파일

def calculatorCircleArea(num):
    print(f'원의 넓이 : {num*num*3.14}')
    return num * num * 3.14

# 다음과 같이 패키지와 모듈을 만들고 연산 결과를 출력

import arithmetic.basic_operator as bo
import arithmetic.developer_operator as do
import shape.triangle_square_area as tsa
import shape.circle_area as ca


number1 = float(input('숫자1 입력 : '))
number2 = float(input('숫자2 입력 : '))
bo.calculator(number1,number2)
do.calculator(number1,number2)

width = float(input('숫자1 입력 : '))
height = float(input('숫자1 입력 : '))
tsa.calculatorTriangleSquareArea(width,height)

radius = float(input('반지름 입력 : '))
ca.calculatorCircleArea(radius)

---

💡 [연습문제] 클래스 01

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

# member 파일

class Member:
    def __init__(self, id, pw):
        self.id = id
        self.pw = pw


class MemberResitory:
    def __init__(self):
        self.members = {}

    def addMember(self, m):
        self.members[m.id] = m.pw # member에서 선언한 것과 동일해야 한다

    def loginMember(self, id, pw):
        isMember = id in self.members

        if isMember and self.members[id] == pw:
            print('{id} : Log-in success!!')
        else:
            print('{id} : Log-in fail!!')

    def removeMember(self, id, pw):
        del self.members[id]

    def printMembers(self):
        for mk in self.members.keys():
            print(f'ID : {mk}')
            print(f'PW : {self.members[mk]}')

# 중급 - practice 클래스 01

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

import member as mb

mems = mb.MemberResitory()

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')

---

💡 [연습문제] 클래스 02

💡 TV클래스를 다음과 같은 상속 구조로 만들고 객체를 생성

# smartTv 파일

class NormalTv:
    def __init__(self, inch = 32, color = 'black', resolution = 'full-HD'):
        self.inch = inch
        self.color = color
        self.resolution = resolution
        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,inch, color,resolution = '4K' ):
        super().__init__(inch,color,resolution)

    def setSmartTv(self,s):
        self.smartTv = s

class Tv8K(NormalTv):
    def __init__(self, inch, color, resolution = '8K'):
        super().__init__(inch,color,resolution)

    def setSmartTv(self,s):
        self.smartTv = s

    def setAiTv(self,s):
        self.aiTv = s

#  TV클래스를 다음과 같은 상속 구조로 만들고 객체를 생성

import smartTv

my4kTv = smartTv.Tv4K(65,'silver','4k')
my4kTv.setSmartTv('on')
my4kTv.turnOn()
my4kTv.printTvInfo()
my4kTv.turnOff()

friendTv = my4kTv = smartTv.Tv4K(55,'white','4k')
friendTv.setSmartTv('off')
friendTv.turnOn()
friendTv.printTvInfo()
friendTv.turnOff()

my8KTv = smartTv.Tv8K(75,'black','8k')
my8KTv.setSmartTv('on')
my8KTv.setAiTv('on')
my8KTv.turnOn()
my8KTv.printTvInfo()
my8KTv.turnOff()

my8KTv = smartTv.Tv8K(86,'red','8k')
my8KTv.setSmartTv('on')
my8KTv.setAiTv('off')
my8KTv.turnOn()
my8KTv.printTvInfo()
my8KTv.turnOff()

---

💡 [연습문제] 클래스 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 regisBook(self,book):
        self.bDic[book.bisbn] = book

    def removeBook(self,isbn):
        del self.bDic[isbn]

    def printBooksInfo(self):
        for i in self.bDic.keys():
            b = self.bDic[i]
            print(f'책 이름 : {b.bname}')
            print(f'가격 이름 : {b.bprice}')
            print(f'isbn 이름 : {b.bisbn}')

    def printBookInfo(self,isbn):
        if isbn in self.bDic:
            b = self.bDic[isbn]
            print(f'책 이름 : {b.bname}')
            print(f'가격 이름 : {b.bprice}')
            print(f'isbn 이름 : {b.bisbn}')
        else:
            print('lookup result does not exist')

#  다음 명세서를 참고해서 도서 관리 프로그램을 생성

import book

myBookRepository = book.BookRepository()

book1 = book.Book('python',20000,'123456')
myBookRepository.regisBook(book1)
myBookRepository.regisBook(book.Book('java',25000,'987456'))
myBookRepository.regisBook(book.Book('c++',30000,'942154'))
print()
myBookRepository.printBooksInfo()
myBookRepository.removeBook('123456')
print()
myBookRepository.printBooksInfo()
print()
myBookRepository.printBookInfo('987456')

---

[연습문제] 클래스 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]}')


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] registWord() : {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('책','book')
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()

---

💡 [연습문제] 클래스 05

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

# 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} >> 컴퓨터 승!')
            if self.cNum < self.uNum:
                print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >> 유저 승!')
            if self.cNum == self.uNum:
                print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >> 무승부!')코드를 입력하세요

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

import Dice

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

---

💡 [연습문제] 클래스 06

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

# 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)

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

# racing 파일

from time import sleep

class CarRacing:

    def __init__(self):
        self.cars = []
        self.rankings = []

    def addCar(self,c):
        self.cars.append(c)

    def startRacing(self):
        for i in range(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()

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

from car_games import racing as rc
from  car_games import car

myCarGame = rc.CarRacing()
car1 = car.Car('car01','white',250)
car2 = car.Car('car02','black',200)
car3 = car.Car('car03','yellow',220)
car4 = car.Car('car04','red',280)
car5 = car.Car('car05','blue',150)

myCarGame.addCar(car1)
myCarGame.addCar(car2)
myCarGame.addCar(car3)
myCarGame.addCar(car4)
myCarGame.addCar(car5)

myCarGame.startRacing()

---

💡 [연습문제] 클래스 06

💡 다음과 같이 mp3 플레이어 클래스를 만들고 노래 등록 후 재생

# mp3player 파일

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'제목 : {self.title}, 가수 : {self.singer}, 재생시간 : {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:
            while self.isLoop:
                for song in self.songList:
                    print(f'title : {song.title}, singer : {song.singer}, play time : {song.play_time}')
                    sleep(song.play_time)
        else:
            for song in self.songList:
                print(f'title : {song.title}, singer : {song.singer}, play time : {song.play_time}')
                sleep(song.play_time)

    def shuffle(self):
        random.shuffle(self.songList)

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

# 다음과 같이 mp3 플레이어 클래스를 만들고 노래 등록 후 재생

import mp3player as mp3

song1 = mp3.Song('신호등','이무진',3)
song2 = mp3.Song('Permission','방탄소년단',4)
song3 = mp3.Song('Butter','방탄소년단',2)
song4 = mp3.Song('Weekend','태연',5)
song5 = mp3.Song('좋아좋아','조정석',4)

player = mp3.Player()
player.addSong(song1)
player.addSong(song2)
player.addSong(song3)
player.addSong(song4)
player.addSong(song5)

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

---

💡 [연습문제] 예외처리 01

💡 사용자가 입력한 숫자를 이용해서 산술연산 결과를 출력하는 모듈을 만들되, 예상하는 예외에 대한 예외처리 코드를 작성

# calculator 파일 

def add(n1,n2) :
    print('덧셈 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')
        return
    result = n1 + n2
    print(f'{n1} + {n2} = {result}')

def sub(n1,n2) :
    print('뺄셈 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')
    result = n1 - n2
    print(f'{n1} - {n2} = {result}')

def mul(n1,n2) :
    print('곱셈 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')
    result = n1 * n2
    print(f'{n1} * {n2} = {result}')

def div(n1,n2) :
    print('나눗셈 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')

    # if  n2 == 0:
    #     print(f'{n2}으로 나눌 수 없습니다.')
    #     return  # ★

    try:
        result = round(n1 / n2,1)
        print(f'{n1} / {n2} = {result}')
    except ZeroDivisionError as e:
        print(e)
        print(f'{n2}으로 나눌 수 없습니다.')

def mod(n1,n2) :
    print('나머지 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')

    # if  n2 == 0:
    #     print(f'{n2}으로 나눌 수 없습니다.')
    #     return  # ★

    try:
        result = round(n1 % n2, 1)
        print(f'{n1} % {n2} = {result}')
    except ZeroDivisionError as e:
        print(e)
        print(f'{n2}으로 나눌 수 없습니다.')

def flo(n1,n2) :
    print('몫 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')

    # if  n2 == 0:
    #     print(f'{n2}으로 나눌 수 없습니다.')
    #     return  # ★

    try:
        result = round(n1 // n2, 1)
        print(f'{n1} // {n2} = {result}')
    except ZeroDivisionError as e:
        print(e)
        print(f'{n2}으로 나눌 수 없습니다.')

def exp(n1,n2) :
    print('거듭제곱 연산')
    try:
        n1 = float(n1)
    except:
        print('첫 번째 피연산자는 숫자가 아닙니다.')
        return  # ★
    try:
        n2 = float(n2)
    except:
        print('두 번째 피연산자는 숫자가 아닙니다.')
    result = n1 ** n2
    print(f'{n1} ** {n2} = {result}')

# 사용자가 입력한 숫자를 이용해서 산술연산 결과를 출력하는 모듈을 만들되, 예상하는 예외에 대한 예외처리 코드를 작성

import calculator as cc

num1 = input('첫 번째 피연산자 입력 : ')
num2 = input('두 번째 피연산자 입력 : ')

cc.add(num1,num2)
cc.sub(num1, num2)
cc.mul(num1, num2)
cc.div(num1, num2)
cc.mod(num1, num2)
cc.flo(num1, num2)
cc.exp(num1, num2)

---

💡 [연습문제] 예외처리 02

💡 1부터 1000까지의 소수인 난수 10개를 생성하되, 소수가 아니면 사용자 예외가 발생하도록 프로그램을 생성

# prime_module 파일

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 = []

n = 0
while n < 10:
    rn = random.randint(2, 1000)
    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}')

---

💡 [연습문제] 예외처리 03

• 💡 globals() : 전역변수 반환

상품 구매에 따른 ‘총 구매 금액’을 출력하되, 다음과 같이 개수가 잘 못 입력된 경우 별도로 출력하도록 프로그램 생성

# calculationPurchase 파일

g1Price = 1200; g2Price = 1000; g3Price = 800;
g4Price = 2000; g5Price = 900


class invalidLiteralError(Exception):

    def __init__(self,str):
        super().__init__(f'invalid literal for int() with base 10 : {str}')

def calculator(*gcs):

    gcdDic = {}
    againCntInput = {}

    for idx, gc in enumerate(gcs):
        try:
            gcdDic[f'g{idx+1}'] = int(gc)
        except Exception as e:
            againCntInput[f'g{idx+1}'] = gc
            print(e)

    totalPrice = 0
    for g in gcdDic.keys():
        totalPrice += gcdDic[g] * globals()[f'{g}Price'] # ★★★★★ globals() : 전역변수 반환

    print('-'*30)
    print(f'총 구매 금액 : {format(totalPrice,",")} 원')
    print('-' * 10,'미결제 항목','-'*10)
    for g in againCntInput.keys():
        print(f'상품 : {g}\t\t 구매 개수 : {againCntInput[g]}')
    print('-' * 30)

# 상품 구매에 따른 ‘총 구매 금액’을 출력하되, 다음과 같이 개수가 잘 못 입력된 경우
# 별도로 출력하도록 프로그램 생성

import calculationPurchase as  cp

g1Cnt = input('good1 구매 개수 : ')
g2Cnt = input('good1 구매 개수 : ')
g3Cnt = input('good1 구매 개수 : ')
g4Cnt = input('good1 구매 개수 : ')
g5Cnt = input('good1 구매 개수 : ')

cp.calculator(g1Cnt,g2Cnt,g3Cnt,g4Cnt,g5Cnt)

---

💡 [연습문제] 예외처리 04

💡 상품 구매에 따른 ‘총 구매 금액’을 출력하되, 다음과 같이 개수가 잘 못 입력된 경우 별도로 출력하도록 프로그램 생성

# 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')
    if m == '':
        raise emptyDataException('mail')
    if p == '':
        raise emptyDataException('password')
    if a == '':
        raise emptyDataException('address')
    if ph == '':
        raise emptyDataException('phone')

class RegistMember():

    def __init__(self,n,m,p,a,ph):
        self.m_name = n
        self.m_email = m
        self.m_pw = p
        self.m_addr = a
        self.m_phone = ph
        print('Membership completed!')

    def printMemberInfo(self):
        print(f'm_name : {self.m_name}')
        print(f'm_email : {self.m_email}')
        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_address = input('주소 입력 : ')
m_phone = input('연락처 입력 : ')

try:
    mem.checkInputData(m_name,m_mail,m_pw,m_address,m_phone)
    newMember = mem.RegistMember(m_name,m_mail,m_pw,m_address,m_phone)
    newMember.printMemberInfo()
except mem.emptyDataException as e:
    print(e)

---

💡 [연습문제] 예외처리 05

다음과 같은 은행 계좌 계설 및 입/출금 프로그램을 생성

# bank 파일

import random

class PrivateBank:

    def __init__(self,bank,account_name):
        self.bank = bank
        self.account_name = account_name


        while True:
            newAccount = random.randint(10000,99999)
            if bank.isAccount(newAccount) :
                continue
            else:
                self.account_no = newAccount
                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}')



class Bank:
    def __init__(self):
        self.accounts = {}

    def addAccount(self,privateBank):
        self.accounts[privateBank.account_no] = privateBank

    def isAccount(self,account_no):
        return account_no in self.accounts

    def doDeposit(self,account_no, m):
        pb = self.accounts[account_no]
        pb.totalMoney = pb.totalMoney + m

    def doWithdraw(self, account_no, m):
        pb = self.accounts[account_no]
        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()

name_account_name = input('통장 계설을 위한 예금주 입력 : ')
myAccount = bank.PrivateBank(koreaBank,name_account_name)
myAccount.printBankInfo()

while True:
    selectNumber = int(input('1. 입금, \t2. 출금, \t3. 종료 : '))

    if selectNumber == 1:
        money = int(input('입금액 입력 : '))
        koreaBank.doDeposit(myAccount.account_no, money)
        myAccount.printBankInfo()

    elif selectNumber == 2:
        money = int(input('출금액 입력 : '))
        try:
            koreaBank.doWithdraw(myAccount.account_no, money)
            # myAccount.printBankInfo()
        except bank.LackException as e:
            print(e)
        finally:
            myAccount.printBankInfo()
    elif selectNumber == 3:
        print('bye~')
        break
    else:
        print('잘못 입력했습니다. 다시 선택하세요.')

---

💡 [연습문제] 텍스트 파일 01

💡 회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 ‘한 줄 일기’를 쓰고 읽는 프로그램을 생성

# 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
    dates = []
    with open(filePath,'r') as f:
        dates = f.readlines()
    return dates

# 회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 ‘한 줄 일기’를 쓰고 읽는 프로그램을 생성
import diary

members = {}
url = 'C:/Users/파이썬 중급 pythontxt/' # 경로 수정 필요

def printMembers():
    for member in members.keys():
        print(f'ID : {member}\t PW : {members[member]}')

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(url,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(url,fileName)
            for d in datas:
                print(d,end='')
        else:
            print('login fail!')
            printMembers()
    elif selectNum == 4:
        print('bye~')
        break

---

💡 [연습문제] 텍스트 파일 02

텍스트 파일에 수입과 지출을 기록하는 가계부 생성

import time

def getTime():
    lt = time.localtime()
    st = time.strftime('%Y-%m-%d %H:%M:%S',lt)
    return st



while True:

    selectNumber = int(input('1. 입금, \t2. 출금, \t3. 종료 : '))

    if selectNumber == 1:
        money = int(input('입금액 입력 : '))
        with open('C:/Users/파이썬 중급 pythontxt/bank/money.txt','r') as f: # 경로수정 필요
            m = f.read()
        with open('C:/Users/파이썬 중급 pythontxt/bank/money.txt','w') as f: #덮어쓰기 # 경로수정 필요
            f.write(str(int(m)+ money))

        memo = input('입금 내역 입력 : ')
        with open('C:/Users/파이썬 중급 pythontxt/bank/poketMoneyRegister.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('C:/Users/파이썬 중급 pythontxt/bank/money.txt', 'r') as f: # 경로 수정 필요
            m = f.read()
        with open('C:/Users/파이썬 중급 pythontxt/bank/money.txt', 'w') as f:  # 덮어쓰기 # 경로 수정 필요
            f.write(str(int(m) - money))

        memo = input('출금 내역 입력 : ')
        with open('C:/Users/파이썬 중급 pythontxt/bank/poketMoneyRegister.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('다시 입력하세요!')

---

💡 [연습문제] 텍스트 파일 03

💡 사용자가 입력한 숫자의 약수를 텍스트 파일에 기록

# 사용자가 입력한 숫자의 약수를 텍스트 파일에 기록

# def divisor(num):
#     list = []
#     for n in range(1, num+1):
#         if num % n == 0:
#             list.append(n)
#     return list
#
#
# number = int(input('0보다 큰 정수 입력 : '))
#
# if number > 0:
#     divList = divisor(number)
#     with open('C:/Users/파이썬 중급 pythontxt/divisor.txt','a') as f: #경로 수정 필요
#         f.write(f'{number}의 약수 : {divList} \n')
#     print('divisor write complete!')
#
# else:
#     print('0보다 큰 정수를 다시 입력해주세요')


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('C:/Users/파이썬 중급 pythontxt/divisor2.txt', 'a') as f: #경로 수정 필요
            f.write(f'{inputNumber}의 약수 : {divisor}\n')

    except Exception as e:
        print(e)
    else:
        print('divisor write complete!')

💡 사용자가 입력한 숫자까지의 소수를 텍스트 파일에 기록

# 사용자가 입력한 숫자까지의 소수를 텍스트 파일에 기록

# def primeNumber(num):
#     list = []
#     for n in range(2,num+1):
#         flag = True
#         for i in range(2, n):
#             if n % i == 0:
#                 flag = False
#                 break
#         if flag :
#             list.append(n)
#     return list
#
# number = int(input('0보다 큰 정수 입력 : '))
#
# if number > 0:
#     primeList = primeNumber(number)
#     with open('C:/Users/파이썬 중급 pythontxt/primeNumber.txt','a') as f: #경로 수정 필요
#         f.write(f'{number}의 소수 : {primeList} \n')
#         print('prime write complete!')
# else :
#     print('0보다 큰 정수를 다시 입력해주세요')


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('C:/Users/파이썬 중급 pythontxt/prime2.txt', 'a') as f: #경로 수정 필요
            f.write(f'{inputNumber}의 소수 : {prime}\n')
    except Exception as e:
        print(e)
    else:
        print('prime write complete!')

---

[연습문제] 텍스트 파일 04

두 개의 수를 입력하면 공약수를 텍스트 파일에 작성

# 두 개의 수를 입력하면 공약수를 텍스트 파일에 작성

# inputNumber1 = int(input('1보다 큰 정수 입력 : '))
# inputNumber2 = int(input('1보다 큰 정수 입력 : '))
#
# commonDivisor = []
#
#
# if inputNumber1 == inputNumber2:
#     print(' 값을 다시 입력해주세요')
# elif inputNumber1 < inputNumber2:
#     for num in range(1, inputNumber1):
#         if inputNumber1 % num == 0 and inputNumber2 % num == 0:
#             commonDivisor.append(num)
# else:
#     for num in range(1, inputNumber2):
#         if inputNumber1 % num == 0 and inputNumber2 % num == 0:
#             commonDivisor.append(num)
#
# if len(commonDivisor) > 0:
#     try:
#         with open('C:/Users/파이썬 중급 pythontxt/commonDivisor.txt','a') as f: # 경로 수정 필요
#             f.write(f'{inputNumber1}와 {inputNumber2}의 공약수 : {commonDivisor} \n')
#     except Exception as e:
#         print(e)
#     else:
#         print('common factor write complete!')



inputNumber1 = int(input('1보다 큰 정수 입력 : '))
inputNumber2 = int(input('1보다 큰 정수 입력 : '))

common = []
for i in range(1, (inputNumber1) + 1):
    if inputNumber1 % i == 0 and inputNumber2 % i == 0:
        common.append(i)

if len(common) > 0:
    try:
        with open('C:/Users/파이썬 중급 pythontxt/commonDivisor2.txt','a') as f: # 경로 수정 필요
             f.write(f'{inputNumber1}와 {inputNumber2}의 공약수 : ')
            f.write(f'{common} \n')
    except Exception as e:
        print(e)
    else:
        print('common factor write complete!')

두 개의 수를 입력하면 최대공약수를 텍스트 파일에 작성

# 두 개의 수를 입력하면 최대공약수를 텍스트 파일에 작성

# inputNumber1 = int(input('1보다 큰 정수 입력 : '))
# inputNumber2 = int(input('1보다 큰 정수 입력 : '))
#
# commonDivisor = ''
#
#
# if inputNumber1 == inputNumber2:
#     print(' 값을 다시 입력해주세요')
# elif inputNumber1 < inputNumber2:
#     for num in range(1, inputNumber1):
#         if inputNumber1 % num == 0 and inputNumber2 % num == 0:
#             commonDivisor = num
# else:
#     for num in range(1, inputNumber2):
#         if inputNumber1 % num == 0 and inputNumber2 % num == 0:
#             commonDivisor = num
#
# if commonDivisor != '':
#     try:
#         with open('C:/Users/이태완/Desktop/제로베이스/파이썬 중급 pythontxt/greatestCommonDivisor.txt','a') as f:
#             f.write(f'{inputNumber1}와 {inputNumber2}의 공약수 : {commonDivisor} \n')
#     except Exception as e:
#         print(e)
#     else:
#         print('common factor write complete!')


inputNumber1 = int(input('1보다 큰 정수 입력 : '))
inputNumber2 = int(input('1보다 큰 정수 입력 : '))

maxComNum = 0
for i in range(1, (inputNumber1) + 1):
    if inputNumber1 % i == 0 and inputNumber2 % i == 0:
        maxComNum = i


try:
    with open('C:/Users/이태완/Desktop/제로베이스/파이썬 중급 pythontxt/maxComNum2.txt','a') as f:
        f.write(f'{inputNumber1}와 {inputNumber2}의 공약수 : ')
        f.write(f'{maxComNum} \n')
except Exception as e:
    print(e)
else:
    print('common factor write complete!')

---

💡 [연습문제] 텍스트 파일 05

• datetime() : 날짜 표기 (import datetime from datetime)
• timedelta() : 시간을 더하거나 뺄 수 있다(?) (import datetime from timedelta)

💡 섬마을에 과일, 생선, 야채를 판매하는 배가 다음 주기로 입항한다고 할 때, 모든 배가 입항하는 날짜를 텍스트 파일에 기록 (첫 입항일은 2021년 1월 1일 오전 10시로 한다.)

#  섬마을에 과일, 생선, 야채를 판매하는 배가 다음 주기로 입항한다고 할 때,
# 모든 배가 입항하는 날짜를 텍스트 파일에 기록해보자.
# (첫 입항일은 2021년 1월 1일 오전 10시로 한다.

import time

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) # datetime() : 날짜 표기 ★ 

with open('C:/Users/이태완/Desktop/제로베이스/파이썬 중급 pythontxt/arrive.txt','a') as f:
    f.write(f'2021년 모든 선박 입항일\n')
    f.write(f'{baseTime}\n')

nexTime = baseTime + timedelta(days=minDay) # timedelta() : 시간을 더하거나 뺄 수 있다(?) ★ 
while True:
    with open('C:/Users/이태완/Desktop/제로베이스/파이썬 중급 pythontxt/arrive.txt','a') as f:
        f.write(f'{nexTime}\n')

    nexTime = nexTime + timedelta(days=minDay)
    if nexTime.year > 2021:
        break

💻 출처 : 제로베이스 데이터 취업 스쿨