🔥파이썬 중급 문제

1. 파이썬 중급(이론) 문제 목차

1.함수

01_함수란
계산기 만들기

02_함수 선언과 호출
 오늘 날씨를 출력하는 함수를 선언하고 3번 호출해보자.
 정수 두 개를 입력하면 곱셈과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출해보자.

03_함수 내에서 또 다른 함수 호출
 다음과 같이 구구단 출력 함수가 연쇄적으로 호출되도록 함수를 선언해보자.

04_인수와 매개변수
 국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 만들어 보자.

05_데이터 반환
 사용자가 길이(cm)를 입력하면 mm로 환산한 값을 반환하는 함수를 만들어보자.

06_지역변수와 젼역변수
 사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이를 출력하는 함수를 만들어보자.
 방문객 수를 카운트하는 함수를 만들어보자.

07_중첩함수
 calculator()함수를 선언하고 calculator() 안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 선언하자.

08_lambda 함수
 삼각형, 사각형, 원의 넓이를 반환하는 lambda함수를 만들어보자.

2. 모듈

09_모듈
 ramdom 모듈을 이용해서 1부터 10까지의 정수 중 난수 1개를 발생시켜 보자.
 ramdom 모듈을 이용해서 0부터 100사이의 난수 10개를 발생시켜 보자.

10_모듈제작
 로또 번호(6개)를 출력하는 모듈을 만들어 보자.
 문자열을 거꾸로 반환하는 모듈을 만들어보자.

11_모듈사용
 국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈을 만들어보자.

12_실행(메인) 파일 (01)

13_실행(메인) 파일 (02)
 단위 환산 모듈을 만들고 cm를 mm, inch, m, ft로 변환해보자.

14_패키지

15_site-packages
 site-packages에 약수와 소수를 리스트로 반환하는 모듈을 만들어보자.

16_자주 사용하는 외부 모듈

3. 클래스

17_객체지향 프로그래밍
계산기 클래스 만들기
자동차 클래스 만들기

18_클래스와 객체 생성
 비행기 클래스를 만들고 비행기 객체 5개를 생성해 보자.

19_객체 속성 변경
속성 변경을 통한 PC업그레이드 해보기
 계산기 클래스를 만들고 사칙연산을 실행해 보자.

20_객체와 메모리
 국어, 영어, 수학 점수를 입력받아 리스트에 저장하고 원본을 유지한 상태로, 복사본을 만들어 과목별 점수를 10% 올렸을 경우에 평균을 출력해 보자.

21_얕은복사와 깊은복사
 선수의 원본 점수를 이용해서 평균을 출력하고, 최고값과 최저값을 제외한 평균을 출력하는 프로그램을 만들어보자.

22_클래스 상속
 덧셈, 뺄셈 기능이 있는 클래스를 만들고, 이를 상속하는 클래스를 만들어서 곱셈과 나눔셈 기능을 추가해 보자.

23_생성자 (01)

24_생성자 (02)
 중간고사 클래스와 기말고사 클래스를 상속관계로 만들고 각각의 점수를 초기화하자. 또한 총점 및 평균을 반환하는 기능도 만들어보자.

25_다중 상속
 BasicCalculator와 DeveloperCalculator 클래스를 다음과 같이 만들고 이들 클래스를 상속해서 Calculator 클래스를 만들고 사용해 보자.

26_오버라이딩

• 로봇 클래스 상속받아 뉴로봇 클래스 만들기
   삼각형 넓이를 계산하는 클래스를 만들고 이를 상속하는 클래스에서 getArea()를 오버라이딩 해서 출력 결과가 다음과 같을 수 있도록 클래스를 만들어보자.

27_추상클래스
 계산기 추상 클래스를 만들고 이를 이용해서 새로운 계산기 클래스를 만들어 보자. 추상 클래스에는 덧셈, 뺄셈, 곱셈, 나눗셈 기능이 선언되어 있어야 한다.

4. 예외처리

28_예외란

29_예외처리
 사용자로부터 숫자 5개를 입력받을 때 숫자가 아닌 자료형이 입력되면 예외 처리하는 프로그램을 만들어보자.

30_try ~ except ~ else
 사용자로부터 숫자 5개를 입력받아 짝수, 홀수, 실수로 구분해서 각각을 리스트에 저장하는 프로그램을 만들어보자.

31_finally
 사용자로부터 숫자 5개를 입력받아 짝수, 홀수, 실수와 입력한 모든 데이터를 각각 출력하는 프로그램을 만들어보자.

32_Exception 클래스
 raise 키워드를 이용하면 예외를 발생시킬 수 있다.
 사용자가 문자 메시지를 보낼때 10글자 이하면 SMS로 발송하고, 10글자를 초과하면 MMS로 발송하는 프로그램을 예외처리를 이용해서 만들어보자.

33_사용자 Exception 클래스
 관리자 암호를 입력하고 다음 상태에 따라 예외 처리하는 예외 클래스를 만들어보자.
• 암호 길이가 5미만인 경우: PasswordLengthShortException
• 암호 길이가 10을 초과하는 경우: PasswordLengthLongException
• 암호가 잘못된 경우: PasswordWrongException

5. 텍스트파일

34_텍스트 파일 쓰기
 다음과 같이 시스템 시간과 일정을 텍스트 파일에 작성해 보자.

35_텍스트 파일 읽기
 다음 텍스트 파일에서 ‘Python’을 ‘파이썬’으로 변경해서 파일에 다시 저장해보자.

36_텍스트 파일 열기
 사용자가 입력한 숫자에 대한 소수를 구하고 이를 파일에 작성해보자.

37_with ~ as문
 로또 번호 생성기 프로그램을 만들고 파일에 번호를 출력해 보자.

38_writelines()
 딕셔너리에 저장된 과목별 점수를 파일에 저장하는 코드를 작성하자.

39_readlines(), readline()
 파일에 저장된 과목별 점수를 파이썬에서 읽어, 딕셔너리에 저장하는 코드를 만들어보자.

---

2. 파이썬 중급 연습문제 리스트

1.함수

01 산술 연산 계산기를 함수 만들기
02 이동거리, 이동시간 반환하는 함수 만들기
03 비행기 티켓 영수증 출력 함수 만들기
04 재귀함수를 이용해 팩토리얼 함수 만들기 + 단리/월복리 계산기 함수 만들기
05 등차수열의 n번째 값과 합을 출력하는 함수 만들기
06 등비수열의 n번째 값과 합을 출력하는 함수 만들기

2. 모듈

01 과목별 점수를 입력해 합격 여부를 출력하는 모듈 만들기
02 상품 구매 개수에 따라 할인율이 결정되는 모듈 만들기
03 로또 모듈 만들어 로또 결과가 출력될 수 있는 프로그램 만들기
04 순열 계산 모듈 만들기
05 조합 계산 모듈 만들기
06 수입과 공과금을 입력해 공과금 총액과 수입 대비 공과금 비율을 계산하는 모듈 만들기
07 패키지와 모듈을 만들어 연산결과 출력하기

3. 클래스

01 회원가입 클래스와 회원정보를 관리하는 클래스를 만들고 회원가입 로그인 구현하기
02 TV클래스를 상소구조로 만들어 객체 생성하기
03 명세서를 참고해 도서 관리 프로그램 만들기
04 한영, 한일 사전 클래스 만들기 (# 추상클래스 #@)
05 주사위 게임 클래스를 만들고 컴퓨터와 사용자의 게임 결과를 출력하기
06 자동차 경주 게임 클래스 만들기
07 mp3 플레이어 클래스를 만들고 노래 등록 후 재생하기

4. 예외처리

01 산술연산 결과를 출력하고 예상되는 예외처리 코드 작성하기
02 1부터 1000까지의 소수인 난수를 10개 생성하되 소구가 아니면 사용자 예외가 발생하도록 하는 프로그램 만들기
03 총구매금액을 출력하되 개수가 잘못 입력된 경우 별도로 출력하도록 하는 프로그램 만들기
04 회원 가입 프로그램을 만들되 입력하지 않은 항목이 있는 경우 에러 메시지를 출력하는 프로그램 만들기
05 은행 계좌 개설 및 입/출금 프로그램 만들기

5. 텍스트파일

01 회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 한줄 일기를 쓰고 읽는 프로그램 만들기
02 수입과 지출을 기록하는 가계부 만들기
03 숫자의 약수와 소수를 텍스트 파일에 기록하기
04 두개의 수를 입력하면 공약수, 최대공약수를 텍스트 파일에 작성하기
05 배(과일)가 입항하는 날짜를 텍스트 파일에 기록해보기

3. 파이썬 중급 연습문제

링크:파이썬 중급 연습문제풀이

1.함수(01~06)

01 산술 연산 계산기를 함수 만들기

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

02 이동거리, 이동시간 반환하는 함수 만들기 (문2)

# 거리(km) = 속도(km/h) * 시간(h)
def getDistance(speed, hour, minute):
    distance = speed * (hour + (minute / 60))

    return distance


def getTime(speed, distance):

    # 100 : 75 = 60 : x  -->  x = 75 * 60 / 100
    time = distance / speed
    print(f'time: {time}')
    h = int(time)
    m = int((time - h) * 100 * 60 / 100)
    # m = convertFloatToMinute(time - h)

    return [h, m]


def convertFloatToMinute(f):
    return int(f * 100 * 60 / 100)


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}(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)분')
print('-' * 60)

03 비행기 티켓 영수증 출력 함수 만들기

childPrice = 18000
infantPrice = 25000
adultPrice = 50000
specialDC = 50

def formatedNumber(n):
    return format(n, ',')

def printAriPlaneReceipt(c1, c2, i1, i2, a1, a2):

    print('=' * 40)
    cp = c1 * childPrice
    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('=' * 40)
    print(f'Total: {formatedNumber(c1 + c2 + i1 + i2 + a1 + a2)}명')
    print(f'TotalPrice : {formatedNumber(cp + cp_dc + ip + ip_dc + ap + ap_dc)}원')
    print('=' * 40)


print(f'childPrice(24개월 미만)\t\t: {formatedNumber(childPrice)}원')
print(f'infantPrice(만12세 미만)\t\t: {formatedNumber(infantPrice)}원')
print(f'adultPrice(만12세 이후)\t\t: {formatedNumber(adultPrice)}원')
print(f'국가 유공자 및 장애우 할인\t\t: {specialDC}%')
print()

childCnt = int(input('유아 입력: '))
specialDCChildCnt = int(input(f'할인대상 유아 입력: '))

infantCnt = int(input('소아 입력: '))
specialDCInfantCnt = int(input(f'할인대상 소아 입력: '))

adultCnt = int(input('성인 입력: '))
specialDCAdultCnt = int(input(f'할인대상 성인 입력: '))


printAriPlaneReceipt(childCnt, specialDCChildCnt,
                infantCnt, specialDCInfantCnt,
                adultCnt, specialDCAdultCnt)

04 재귀함수를 이용해 팩토리얼 함수 만들기 + 단리/월복리 계산기 함수 만들기

def formatedNumber(n):
    return format(n, ',')


def recursionFun(n):

    if n == 1:
        return n
    return n * recursionFun(n - 1)

inputNumber = int(input('input number: '))
inputNumberFormated = formatedNumber(recursionFun(inputNumber))
print(inputNumberFormated)

# 단리 계산기
def singleRateCalculator(m, t, r):
    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
    totalMoney = m

    for i in range(t):
        totalMoney += totalMoney * rpm

    return int(totalMoney)



money = int(input('예치금(원): '))
term = int(input('기간(년): '))
rate = int(input('연 이율(%): '))

print()
print('[단리 계산기]')
print('=' * 30)
print(f'예치금\t: {formatedNumber(money)}원')
print(f'예치기간\t: {term}년')
print(f'연 이율\t: {rate}%')
print('-' * 30)
amount = formatedNumber(singleRateCalculator(money, term, rate))
print(f'{term}년 후 총 수령액: {amount}원')
print('=' * 30)


print()
print('[월복리 계산기]')
print('=' * 30)
print(f'예치금\t: {formatedNumber(money)}원')
print(f'예치기간\t: {term}년')
print(f'연 이율\t: {rate}%')
print('-' * 30)
amount = formatedNumber(multiRateCalculator(money, term, rate))
print(f'{term}년 후 총 수령액: {amount}원')
print('=' * 30)

05 등차수열의 n번째 값과 합을 출력하는 함수 만들기

def sequenceCal(n1, d, n):

    valueN = 0
    sumN = 0
    i = 1
    while i <= n:

        if i == 1:
            valueN = n1
            sumN += valueN
            print('{}번째 항의 값: {}'.format(i, valueN))
            print('{}번째 항까지의 합: {}'.format(i, sumN))
            i += 1
            continue

        valueN += d
        sumN += valueN
        print('{}번째 항의 값: {}'.format(i, valueN))
        print('{}번째 항까지의 합: {}'.format(i, sumN))
        i += 1


def sequenceCal01(n1, d, n):

    # 등차 수열(일반항) 공식: an = a1 + (n-1) * d
    valueN = n1 + (n-1) * d
    print('{}번째 항의 값: {}'.format(n, valueN))

    # 등차 수열(합) 공식: sn = n(a1 + an) / 2
    sumN = n * (n1 + valueN) / 2
    print('{}번째 항까지의 합: {}'.format(n, int(sumN)))


inputN1 = int(input('a1 입력: '))
inputD = int(input('공차 입력: '))
inputN = int(input('n 입력: '))

sequenceCal(inputN1, inputD, inputN)
print('-' * 50)
sequenceCal01(inputN1, inputD, inputN)

06 등비수열의 n번째 값과 합을 출력하는 함수 만들기

def sequenceCal(n1, r, n):

    valueN = 0
    sumN = 0
    i = 1

    while i <= inputN:

        if i == 1:
            valueN = n1
            sumN += valueN
            print('{}번째 항의 값: {}'.format(i, valueN))
            print('{}번째 항까지의 합: {}'.format(i, sumN))
            i += 1
            continue

        valueN *= r
        sumN += valueN
        print('{}번째 항의 값: {}'.format(i, valueN))
        print('{}번째 항까지의 합: {}'.format(i, sumN))
        i += 1



def sequenceCal01(n1, r, n):

    # 등비 수열(일반항) 공식: an = a1 * r^(n-1)
    valueN = n1 * (r ** (n - 1))
    print('{}번째 항의 값: {}'.format(n, valueN))

    # 등비 수열(합) 공식: sn = a1 * (1 - r^n) / (1-r)
    sumN = n1 * (1 - (r ** n)) / (1 - r)
    print('{}번째 항까지의 합: {}'.format(n, int(sumN)))



inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))


sequenceCal(inputN1, inputR, inputN)
print('-' * 50)
sequenceCal01(inputN1, inputR, inputN)

2. 모듈(01~07)

01 과목별 점수를 입력해 합격 여부를 출력하는 모듈 만들기

# passOrFail.py
def exampleResult(s1, s2, s3, s4, s5):

    passAvgScore = 60
    limitScore = 40

    def getTotal():
        totalScore = s1 + s2 + s3 + s4 + s5
        print(f'총점: {totalScore}')
        return totalScore

    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 s2 >= limitScore else print(f'{s2}: Fail')
        print(f'{s3}: Pass') if s3 >= limitScore else print(f'{s3}: Fail')
        print(f'{s4}: Pass') if s4 >= limitScore else print(f'{s4}: Fail')
        print(f'{s5}: Pass') if s5 >= 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:
            print('Final Fail!!')


    getAverage()
    printPassOrFail()
    printFinalPassOrFail()



if __name__ == '__main__':
    sub1 = int(input('과목1 점수 입력: '))
    sub2 = int(input('과목2 점수 입력: '))
    sub3 = int(input('과목3 점수 입력: '))
    sub4 = int(input('과목4 점수 입력: '))
    sub5 = int(input('과목5 점수 입력: '))

    exampleResult(sub1, sub2, sub3, sub4, sub5)


def exampleResult(*s):

    passAvgScore = 60
    limitScore = 40

    def getTotal():
        totalScore = sum(s)
        print(f'총점: {totalScore}')
        return totalScore

    def getAverage():
        avg = getTotal() / len(s)
        print(f'평균: {avg}')
        return avg

    def printPassOrFail():
        for idx, score in enumerate(s):
            print(f'과목{idx+1}: Pass') if score >= limitScore else print(f'과목{idx+1}: Fail')

    def printFinalPassOrFail():

        result = 'Final Pass!!'

        if getAverage() >= passAvgScore:
            for idx, score in enumerate(s):
                if score < limitScore:
                    result = 'Final Fail!!'
                    break
        else:
            result = 'Final Fail!!'

        print(result)

    getAverage()
    printPassOrFail()
    printFinalPassOrFail()

if __name__ == '__main__':
    sub1 = int(input('과목1 점수 입력: '))
    sub2 = int(input('과목2 점수 입력: '))
    sub3 = int(input('과목3 점수 입력: '))
    sub4 = int(input('과목4 점수 입력: '))
    sub5 = int(input('과목5 점수 입력: '))
    exampleResult(sub1, sub2, sub3, sub4, sub5)

# ex.py
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)

02 상품 구매 개수에 따라 할인율이 결정되는 모듈 만들기

# discount.py
def calculatorTotalPrice(gs):

    if len(gs) <= 0:
        print('구매 상품이 없습니다.')
        return

    rate = 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)]


def formatedNumber(n):
    return format(n, ',')
# ex.py
import  discount as dc

if __name__ == '__main__':
    flag = True
    gs = []

    while flag:
        selectNumber = int(input('상품을 구매 하시겠어요? 1.구매 2.종료 '))

        if selectNumber == 1:
            goods_price = int(input('상품 가격 입력: '))
            gs.append(goods_price)

        elif selectNumber == 2:
            result = dc.calculatorTotalPrice(gs)
            flag = False


    print(f'할인율: {result[0]}')
    print(f'합계: {dc.formatedNumber(result[1])}원')

03 로또 모듈 만들어 로또 결과가 출력될 수 있는 프로그램 만들기

# lotto.py
import random

userNums = []; randNums = []; collNums = []
randBonuNum = 0

def setUserNums(ns):
    global userNums
    userNums = ns

def getUserNums():
    return userNums

def setRandNums():
    global randNums
    randNums = random.sample(range(1, 46), 6)

def getRandNums():
    return randNums

def setBonuNum():
    global randBonuNum

    while True:
        randBonuNum = random.randint(1, 45)
        if randBonuNum not in randNums:
            break

def getBonuNum():
    return randBonuNum

def lottoResult():
    global userNums
    global randNums
    global collNums

    collNums = []
    for un in userNums:
        if  un in randNums:
            collNums.append(un)

    if len(collNums) == 6:
        print(f'1등 담첨!!')
        print(f'번호: {collNums}')

    elif (len(collNums) == 5) and (randBonuNum in userNums):
        print(f'2등 담첨!!')
        print(f'번호: {collNums}, 보너스 번호: {randBonuNum}')

    elif len(collNums) == 5:
        print(f'3등 담첨!!')
        print(f'번호: {collNums}')

    elif len(collNums) == 4:
        print(f'4등 담첨!!')
        print(f'번호: {collNums}')

    if len(collNums) == 3:
        print(f'5등 담첨!!')
        print(f'번호: {collNums}')

    else:
        print('아쉽습니다. 다음 기회에~')
        print(f'기계 번호: {randNums}')
        print(f'보너스 번호: {randBonuNum}')
        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]

    setUserNums(selectNums)
    setRandNums()
    setBonuNum()

    lottoResult()
# ex.py
import lotto as lt

lt.startLotto()

04 순열 계산 모듈 만들기

# permutation.py
def getPermutaionCnt(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 getPermutaions(ns, r):

    pList = list(permutations(ns, r))
    print(f'{len(ns)}P{r} 개수: {len(pList)}')

    for n in permutations(ns, r):
        print(n, end=', ')



if __name__ == '__main__':
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))


    print(f'{numN}P{numR}: {getPermutaionCnt(numN, numR, logPrint=False)}')

    ns = [1, 2, 3, 4, 5, 6, 7, 8]
    getPermutaions(ns, 3)


# ex.py
import permutation as pt

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

# print(f'{numN}P{numR}: {pt.getPermutaionCnt(numN, numR)}')
print(f'{numN}P{numR}: {pt.getPermutaionCnt(numN, numR, logPrint=False)}')



listVar = [1, 2, 3, 4, 5, 6, 7, 8]
rVar = 3
pt.getPermutaions(listVar, rVar)

05 조합 계산 모듈 만들기

# combination.py
def getCombinationCnt(n, r, logPrint = True):

    resultP = 1
    resultR = 1
    resultC = 1

    for n in range(n, (n - r), -1):
        resultP = resultP * n
    if logPrint: print('resultP : {}'.format(resultP))


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

    resultC = int(resultP / resultR)
    if logPrint: print('resultC: {}'.format(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=', ')



if __name__ == '__main__':
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))


    print(f'{numN}C{numR}: {getCombinationCnt(numN, numR, logPrint=False)}')

    ns = [1, 2, 3, 4, 5, 6, 7, 8]
    getCombinations(ns, 3)



# ex.py
import combination as ct

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

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



listVar = [1, 2, 3, 4, 5, 6, 7, 8]
rVar = 3
ct.getCombinations(listVar, rVar)

06 수입과 공과금을 입력해 공과금 총액과 수입 대비 공과금 비율을 계산하는 모듈 만들기

# utilityBill.py
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 setElectricPrice(ep):
    global electricPrice
    electricPrice = ep

def setGasPrice(gp):
    global gasPrice
    gasPrice = gp

def getUtilityBill():
    result = waterPrice + electricPrice + gasPrice
    return result

def getUtilityBillRate():
    result = getUtilityBill() / getIncome() * 100
    return round(result, 2)

def formatedNumber(n):
    return format(n, ',')


# ex.py
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.formatedNumber(ub.getUtilityBill())}원')
print(f'수입 대비 공과금 비율: {ub.getUtilityBillRate()}%')

07 패키지와 모듈을 만들어 연산결과 출력하기

# 1. arithmetic 폴더 생성 후 안에 basic_operator.py, developer_oerator.py 모듈 생성

# basic_operator.py
def add(n1, n2):
    return round(n1 + n2, 2)

def sub(n1, n2):
    return round(n1 - n2, 2)

def mul(n1, n2):
    return round(n1 * n2, 2)

def div(n1, n2):
    return round(n1 / n2, 2)
    
# developer_oerator.py 
def mod(n1, n2):
    return round(n1 % n2, 2)

def flo(n1, n2):
    return round(n1 // n2, 2)

def exp(n1, n2):
    return round(n1 ** n2, 2)
    
# 2. shape 폴더 생성 후 안에 circle_area.py, triangle_square_area.py 모듈 생성

# circle_area.py
def calCircleArea(r):
    return round(r ** 2 * 3.14, 2)
    
# triangle_square_area.py
def calTriangleArea(w, h):
    return round(w * h / 2, 2)

def calSquareArea(w, h):
    return round(w * h, 2)
    
# 3. arithmetic 폴더와 shape 폴더 경로에 실행파일 만들기 
# ex.py
from arithmetic import basic_operator as bo
from arithmetic import developer_oerator 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)}')

3. 클래스 (01~07)

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

# member.py
class Member:
    def __init__(self, i, p):
        self.id = i
        self.pw = p


class MemberRepository:

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

    def addMember(self, m):
        self.members[m.id] = m.pw

    def loginMember(self, i, p):
        isMember = i in self.members

        if isMember and self.members[i] == p:
            print(f'{i}: Log-in success!!')

        else:
            print(f'{i}: Log-in fail!!')

    def removeMember(self, i, p):
        del self.members[i]

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

# ex.py
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()

02 TV클래스를 상소구조로 만들어 객체 생성하기

# smartTv.py
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


if __name__ == '__main__':
    my4KTv = Tv4k('65', 'silver', '4K')
    my4KTv.setSmartTv('on')
    my4KTv.turnOn()
    my4KTv.printTvInfo()
    my4KTv.turnOff()

    my8KTv = Tv8k('75', 'black', '8K')
    my8KTv.setSmartTv('on')
    my8KTv.setAiTv('on')
    my8KTv.turnOn()
    my8KTv.printTvInfo()
    my8KTv.turnOff()

# ex.py
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()

03 명세서를 참고해 도서 관리 프로그램 만들기

# book.py
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')


if __name__ == '__main__':
    br = BookRepository()

    br.registBook(Book('python', 20000, '1234567890'))
    br.registBook(Book('java', 25000, '852147963'))
    br.registBook(Book('c/c++', 27000, '951378624'))
    br.registBook(Book('javascript', 15000, '9874563254'))

    br.printBooksInfo()
    br.printBookInfo('1234567890')
    br.removeBook('1234567890')
    br.printBooksInfo()

# ex.py
import book as bk

myBReposit = bk.BookRepository()

myBReposit.registBook(bk.Book('python', 20000, '1234567890'))
myBReposit.registBook(bk.Book('java', 25000, '852147963'))
myBReposit.registBook(bk.Book('c/c++', 27000, '951378624'))
myBReposit.registBook(bk.Book('javascript', 15000, '9874563254'))

myBReposit.printBooksInfo()
myBReposit.printBookInfo('1234567890')
myBReposit.removeBook('1234567890')
myBReposit.printBooksInfo()



friendBReposit = bk.BookRepository()

friendBReposit.registBook(bk.Book('python', 10000, '1234567890'))
friendBReposit.registBook(bk.Book('java', 15000, '852147963'))
friendBReposit.registBook(bk.Book('c/c++', 17000, '951378624'))
friendBReposit.registBook(bk.Book('javascript', 5000, '9874563254'))

friendBReposit.printBooksInfo()
friendBReposit.printBookInfo('1234567890')
friendBReposit.removeBook('1234567890')
friendBReposit.printBooksInfo()

04 한영, 한일 사전 클래스 만들기 (# 추상클래스 #@)

# ADictionary.py
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:
            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:
            print(f'{k} : {self.wordDic[k]}')


if __name__ == '__main__':
    kTe = KorToEng()
    
    # 단어 등록
    kTe.registWord('책', 'bok')
    kTe.registWord('나비', 'butterfly')
    kTe.registWord('연필', 'pencil')
    kTe.registWord('학생', 'studen')
    kTe.registWord('선생님', 'teacher')

    # 단어 수정
    kTe.updateWord('책', 'book')
    kTe.updateWord('학생', 'student')

    # 단어 검색
    print(f'책 : {kTe.searchWord("책")}')
    print(f'나비 : {kTe.searchWord("나비")}')
    print(f'연필 : {kTe.searchWord("연필")}')
    print(f'학생 : {kTe.searchWord("학생")}')
    print(f'선생님 : {kTe.searchWord("선생님")}')
    
    # 단어 삭제
    kTe.removeWord('책')

    # 사전 출력
    kTe.printWords()

    
# ex.py
import ADictionary as dic

kTe = dic.KorToEng()

# 단어 등록
kTe.registWord('책', 'bok')
kTe.registWord('나비', 'butterfly')
kTe.registWord('연필', 'pencil')
kTe.registWord('학생', 'studen')
kTe.registWord('선생님', 'teacher')

# 단어 수정
kTe.updateWord('책', 'book')
kTe.updateWord('학생', 'student')

# 단어 검색
print(f'책 : {kTe.searchWord("책")}')
print(f'나비 : {kTe.searchWord("나비")}')
print(f'연필 : {kTe.searchWord("연필")}')
print(f'학생 : {kTe.searchWord("학생")}')
print(f'선생님 : {kTe.searchWord("선생님")}')

# 단어 삭제
kTe.removeWord('책')

# 사전 출력
kTe.printWords()


kTj = dic.KorToJpa()

# 단어 등록
kTj.registWord('책', '本')
kTj.registWord('나비', '蝶')
kTj.registWord('연필', '鉛筆')
kTj.registWord('학생', '学生')
kTj.registWord('선생님', '先生')

# 단어 수정
kTj.updateWord('책', '蝶')
kTj.updateWord('학생', '学生')

# 단어 검색
print(f'책 : {kTj.searchWord("책")}')
print(f'나비 : {kTj.searchWord("나비")}')
print(f'연필 : {kTj.searchWord("연필")}')
print(f'학생 : {kTj.searchWord("학생")}')
print(f'선생님 : {kTj.searchWord("선생님")}')

# 단어 삭제
kTj.removeWord('책')

# 사전 출력
kTj.printWords()

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

# dice.py
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} >> 무승부!!')


if __name__ == '__main__':
    dc = Dice()
    dc.startGame()
    dc.printResult()

# ex.py
import dice

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

06 자동차 경주 게임 클래스 만들기

# 1. car_game 폴더 만든 후 car.py, racing.py 생성

# car.py
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):
        return random.randint(0, self.max_speed)

    def getDistanceForHour(self):
        return self.controlSpeed() * 1



if __name__ == '__main__':
    tempCar = Car('myCar', 'black', 250)
    tempCar.printCarInfo()
    print(tempCar.controlSpeed())

# racing.py
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)
        
# 2. car_game 폴더 경로에 ex.py 파일 생성

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

07 mp3 플레이어 클래스를 만들고 노래 등록 후 재생하기

# mp3player.py
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:
            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


# ex.py
import mp3player as mp3

s1 = mp3.Song('신호등', '이무진', 3)
s2 = mp3.Song('Permission to Dance', '방탄소년단', 4)
s3 = mp3.Song('Butter', '방탄소년단', 2)
s4 = mp3.Song('Weekend', 'TAEYEON', 5)
s5 = mp3.Song('좋아좋아', '조정석', 4)

player = mp3.Player()
player.addSong(s1)
player.addSong(s2)
player.addSong(s3)
player.addSong(s4)
player.addSong(s5)

player.setIsLoop(False)
player.suffle()
player.play()

4. 예외처리(01~05)

01 산술연산 결과를 출력하고 예상되는 예외처리 코드 작성하기

# calculator.py
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

    print(f'{n1} / {n2} = {n1 / n2}')
    
    # 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 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} = {int(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}')

# ex.py
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.py
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)

# ex.py
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 총구매금액을 출력하되 개수가 잘못 입력된 경우 별도로 출력하도록 하는 프로그램 만들기

# calculatePurchase.py
g1price = 1200; g2price = 1000; g3price = 800
g4price = 2000; g5price = 900

def formatedNumber(n):
    return format(n, ',')

def calculate(*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]

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

# ex.py
import calculatePurchase as cp

g1Cnt = input('goods1 구매 개수: ')
g2Cnt = input('goods2 구매 개수: ')
g3Cnt = input('goods3 구매 개수: ')
g4Cnt = input('goods4 구매 개수: ')
g5Cnt = input('goods5 구매 개수: ')

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

04 회원 가입 프로그램을 만들되 입력하지 않은 항목이 있는 경우 에러 메시지를 출력하는 프로그램 만들기

# mem.py
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')
    else:
        return True

class RegisteMember():

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

    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}')
        
# ex.py
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.RegisteMember(m_name, m_mail, m_pw, m_addr, m_phone)
    newMember.printMemberInfo()

except mem.EmptyDataException as e:
    print(e)

05 은행 계좌 개설 및 입/출금 프로그램 만들기

# bank.py
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):
        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):
        super().__init__(f'잔고부족!!, 잔액: {m1}, 출금액: {m2}')

# ex.py
import bank

koreaBank = bank.Bank()

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

while True:

    selectNumber = int(input('1.입금, \t2.출금, \t3.종료 '))
    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('잘못 입력했습니다. 다시 선택하세요. ')

5. 텍스트파일(01~05)

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

# diary.py
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):
    lt = time.localtime()
    timeStr = time.strftime('%Y-%m-%d %I:%M:%S %p', lt)

    filePath = u + f
    datas = []
    with open(filePath, 'r') as f:
        datas = f.readlines()

    return datas
    
# ex.py
import diary

members = {}
uri = 'C:/pythonTxt/'

def printMembers():
    for m in members.keys():
        print(f'ID: {m} \t PW: {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
        printMembers()

    elif(selectNum == 2):
        mId = input('input ID: ')
        mPw = input('input PW: ')

        if mId in members and members[mId] == mPw:
            print('login success!!')
            fileName = 'myDaiary_' + 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 = 'myDaiary_' + 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

02 수입과 지출을 기록하는 가계부 만들기

import time

limitSpendMoney = 2000


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('C:/pythonTxt/bank/money.txt', 'r') as f:
            m = f.read()

        with open('C:/pythonTxt/bank/money.txt', 'w') as f:
            f.write(str(int(m) + money))

        memo = input('입금 내역 입력: ')
        with open('C:/pythonTxt/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('C:/pythonTxt/bank/money.txt', 'r') as f:
            m = f.read()

        with open('C:/pythonTxt/bank/money.txt', 'w') as f:
            f.write(str(int(m) - money))

        memo = input('출금 내역 입력: ')
        with open('C:/pythonTxt/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('잘못 입력하셨습니다.')

03 숫자의 약수와 소수를 텍스트 파일에 기록하기 (2문)

# 약수
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:/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 complete!')


#소수
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:/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!')

04 두개의 수를 입력하면 공약수, 최대공약수를 텍스트 파일에 작성하기 (3문)

# 수 두개의 공약수
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('C:/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:
        maxNum = i

try:
    with open('C:/pythonTxt/maxComNum.txt', 'a') as f:
        f.write(f'{num1}와 {num2}의 최대공약수: {maxNum}\n')

except Exception as e:
    print(e)

else:
    print('max common factor write complete!')



# 수 세개의 공약수
num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
num3 = int(input('1보다 큰 정수 입력: '))

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

if len(common) > 0:
    try:
        with open('C:/pythonTxt/common.txt', 'a') as f:
            f.write(f'{num1}, {num2}, {num3}의 공약수: ')
            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보다 큰 정수 입력: '))
num3 = int(input('1보다 큰 정수 입력: '))
maxComNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i == 0 and num2 % i == 0 and num3 % i == 0:
        maxComNum = i

try:
    with open('C:/pythonTxt/maxComNum.txt', 'a') as f:
        f.write(f'{num1}, {num2}, {num3}의 최대공약수: {maxComNum}\n')

except Exception as e:
    print(e)

else:
    print('max common factor write complete!')

05 배(과일)가 입항하는 날짜를 텍스트 파일에 기록해보기

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

# print('최대공약수: {}'.format(maxDay))

minDay = (ship1 * ship2) // maxDay
# print('{}, {}의 최소공배수: {}'.format(ship1, ship2, minDay))


newDay = minDay
for i in range(1, (newDay + 1)):
    if newDay % i == 0 and ship3 % i == 0:
        maxDay = i

# print('최대공약수: {}'.format(maxDay))

minDay = (newDay * ship3) // maxDay
# print('{}, {}, {}의 최소공배수: {}'.format(ship1, ship2, ship3, minDay))

# print('{}일마다 모든 선박이 입항합니다.'.format(minDay))


from datetime import datetime
from datetime import timedelta

n = 1
baseTime = datetime(2021, 1, 1, 10, 0, 0)
# baseTime = datetime.now()

# print(f'2021년 모든 선박 입항일: {baseTime}')
with open('C:/pythonTxt/arrive.txt', 'a') as f:
    f.write(f'2021년 모든 선박 입항일\n')
    f.write(f'{baseTime}\n')

nextTime = baseTime + timedelta(days=minDay)
while True:

    # print(f'2021년 모든 선박 입항일: {nextTime}')
    with open('C:/pythonTxt/arrive.txt', 'a') as f:
        f.write(f'{nextTime}\n')

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