제로베이스 데이터 파트타임 스쿨 학습 일지 [25.04.06]

김뚱입니다 2025. 4. 6. 21:28

[강의 요약]

[Ch 04. 파이썬 중급 문제풀이] 강의 수강

40_[연습문제] 함수(01)부터 45_[연습문제] 함수(06)까지 강의 수강하였음

🐢 100일 챌린지 🔥 : [▰▰▰▰▰▰▰▰▰▰░                                           ] 21/100일 (21%)

주말에 너무 피곤했는데 쉴 시간이 없어서 울면서 작성 중

[연습문제_함수 (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)

★ 출력 결과 ★

------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 1
첫 번째 숫자 입력: 10
두 번째 숫자 입력: 3.14
10.0 + 3.14 = 13.14
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 2
첫 번째 숫자 입력: 3.14
두 번째 숫자 입력: 0.12
3.14 - 0.12 = 3.02
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 3
첫 번째 숫자 입력: 3
두 번째 숫자 입력: 7
3.0 * 7.0 = 21.0
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 4
첫 번째 숫자 입력: 10
두 번째 숫자 입력: 3
10.0 / 3.0 = 3.3333333333333335
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 5
첫 번째 숫자 입력: 10
두 번째 숫자 입력: 3
10.0 % 3.0 = 1.0
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 6
첫 번째 숫자 입력: 10
두 번째 숫자 입력: 3
10.0 // 3.0 = 3.0
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 7
첫 번째 숫자 입력: 10
두 번째 숫자 입력: 3
10.0 ** 3.0 = 1000.0
------------------------------------------------------------
1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.나머지, 6.몫, 7.제곱승, 8.종료 8
Bye~

☆ 설명 ☆

함수 분리를 통해 연산 기능을 구조화
- 코드의 재사용성과 가독성 향상
무한 루프 + 조건문을 활용
- 메뉴 기반 사용자 인터페이스 구현
float형 입력
- 정수뿐만 아니라 실수 계산도 가능

[연습문제_함수 (02)]

▶ 실습 코드 : 이동 거리 계산

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

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)

★ 출력 결과 ★

속도(km/h) 입력: 90
시간(h) 입력: 2
시간(m) 입력: 45
90.0(km/h)속도로 2.0(h)시간 45.0(m)분 동안 이동한 거리: 247.5(km)

▶ 실습 코드 : 이동 시간 계산

def getTime(speed, distance):
    time = distance / speed
    print(f'time: {time}')
    h = int(time)
    m = int((time - h) * 100 * 60 / 100)
    return [h, m]

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)

★ 출력 결과 ★

속도(km/h) 입력: 90
거리(km) 입력: 247.5
time: 2.75
90.0(km/h) 속도로 247.5(km) 이동한 시간: 2(h)시간 45(m)분

▶ 요약

getDistance(speed, hour, minute)
- 속도와 시간(h, m)을 입력받아 이동 거리를 반환
getTime(speed, distance)
- 속도와 이동 거리를 입력받아 이동 시간(h, m)을 리스트로 반환
convertFloatToMinute(f)
- 소수점 시간 → 분(minute)으로 변환 (보조 함수)

[연습문제_함수 (03)]

▶ 실습 코드 : 비행기 티켓 영수증 출력 함수

childPrice = 18000        # 24개월 미만
infantPrice = 25000       # 만 12세 미만
adultPrice = 50000        # 만 12세 이상
specialDC = 50            # 할인율 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)

★ 출력 결과 ★

childPrice(24개월 미만)		: 18,000원
infantPrice(만12세 미만)		: 25,000원
adultPrice(만12세 이후)		: 50,000원
국가 유공자 및 장애우 할인		: 50%

유아 입력: 1
할인대상 유아 입력: 1
소아 입력: 2
할인대상 소아 입력: 1
성인 입력: 2
할인대상 성인 입력: 0
========================================
유아 1명 요금: 18,000원
유아 할인 대상 1명 요금: 9,000원
소아 2명 요금: 50,000원
소아 할인 대상 1명 요금: 12,500원
성인 2명 요금: 100,000원
성인 할인 대상 0명 요금: 0원
========================================
Total: 7명
TotalPrice : 189,500원
========================================

▶ 요약

formatedNumber(n)
- 금액에 쉼표를 붙여 가독성 있게 변환
printAriPlaneReceipt(...)
- 인원수와 할인대상 수를 입력받아 총 인원 및 요금 출력
할인율
- 국가유공자 및 장애우는 50% 할인 적용

[연습문제_함수 (04)]

▶ 실습 코드 : 팩토리얼 계산 함수

# 함수 정의
def recursionFun(n):
    if n == 1:
        return n
    return n * recursionFun(n - 1)

# 출력 형식 정리 함수
def formatedNumber(n):
    return format(n, ',')

# 실행 코드
inputNumber = int(input('input number: '))
result = recursionFun(inputNumber)
print(formatedNumber(result))

★ 출력 결과 ★

input number: 5
120

input number: 10
3,628,800

input number: 20
2,432,902,008,176,640,000

▶ 실습 코드 : 단리/월복리 계산기

# 단리 계산 함수
def singleRateCalculator(m, t, r):
    total = m + m * (r * 0.01) * t
    return int(total)

# 월복리 계산 함수
def multiRateCalculator(m, t, r):
    t *= 12
    rpm = (r / 12) * 0.01
    total = m
    for i in range(t):
        total += total * rpm
    return int(total)

# 실행 코드
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))}원')

★ 출력 결과 ★

예치금(원): 10000000
기간(년): 3
연 이율(%): 3

[단리 계산기]
3년 후 총 수령액: 10,900,000원

[월복리 계산기]
3년 후 총 수령액: 10,940,514원

▶ 요약

formatedNumber(n)
- 숫자에 쉼표를 붙여 가독성 있게 출력
recursionFun(n)
- 재귀 함수를 사용해 n! (팩토리얼) 계산
singleRateCalculator(m, t, r)
- 단리 계산: 원금과 이율, 기간을 이용해 총 수령액 계산
- 연 단위로 단순 누적 이자 계산
multiRateCalculator(m, t, r)
- 월복리 계산: 매달 복리로 원금에 이자를 더해 수령액 계산
- 기간은 연 단위를 월 단위로 환산
이자 계산 방식
- 단리: 원금 × 이율 × 기간
- 월복리: 매달 이자를 원금에 더한 뒤 다음 이자 계산에 반영

[연습문제_함수 (05)]

▶ 실습 코드 : 등차수열의 항과 합 구하기

# 반복문 계산 함수
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)

★ 출력 결과 ★

a1 입력: 2  
공차 입력: 3  
n 입력: 7  

1번째 항의 값: 2  
1번째 항까지의 합: 2  
2번째 항의 값: 5  
2번째 항까지의 합: 7  
3번째 항의 값: 8  
3번째 항까지의 합: 15  
4번째 항의 값: 11  
4번째 항까지의 합: 26  
5번째 항의 값: 14  
5번째 항까지의 합: 40  
6번째 항의 값: 17  
6번째 항까지의 합: 57  
7번째 항의 값: 20  
7번째 항까지의 합: 77  
--------------------------------------------------  
7번째 항의 값: 20  
7번째 항까지의 합: 77

▶ 요약

sequenceCal(n1, d, n)
- 반복문을 사용하여 등차수열의 각 항과 합을 출력
sequenceCal01(n1, d, n)
- 등차수열의 공식을 사용해 n번째 항과 총합을 한 번에 계산
공식 요약
- aₙ = a₁ + (n - 1) × d
- Sₙ = n × (a₁ + aₙ) / 2

[연습문제_함수 (06)]

▶ 실습 코드 : 등비수열의 항과 합 구하기

# 반복문을 이용해서 등비 수열 계산
def sequenceCal(n1, r, 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 *= 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)

★ 출력 결과 ★

a1 입력: 2  
공비 입력: 3  
n 입력: 5

1번째 항의 값: 2  
1번째 항까지의 합: 2  
2번째 항의 값: 6  
2번째 항까지의 합: 8  
3번째 항의 값: 18  
3번째 항까지의 합: 26  
4번째 항의 값: 54  
4번째 항까지의 합: 80  
5번째 항의 값: 162  
5번째 항까지의 합: 242  
--------------------------------------------------
5번째 항의 값: 162  
5번째 항까지의 합: 242

▶ 요약

sequenceCal(n1, r, n)
- 반복문을 통해 등비수열의 n번째 항과 누적 합을 계산하여 출력
- i == 1일 때는 초항을 그대로 사용하고, 이후부터 공비만큼 곱함
sequenceCal01(n1, r, n)
- 등비수열의 공식을 이용해 n번째 항과 총합을 계산하여 출력
  - 일반항: aₙ = a₁ × rⁿ⁻¹
  - 합: Sₙ = a₁ × (1 - rⁿ) / (1 - r)
입력값
- a₁ : 초항 (첫 번째 항의 값)
- r : 공비 (항마다 곱해지는 값)
- n : 출력할 항의 개수

[나의 생각 정리]

함수로 나누니 코드가 깔끔하고 재사용이 쉬워졌음
조건이나 계산 방식이 명확히 분리되어 가독성이 좋음

[적용점]

복잡한 계산 로직을 분리하고 싶을 때?
- 함수로 따로 정의해두자
입력값에 따라 다양한 출력을 하고 싶을 때?
- 조건문 + 함수 조합으로 깔끔하게 처리
금액, 거리, 시간 등 반복 계산이 필요할 때?
- 함수와 반복문을 활용해 자동화 가능
수식 기반 문제를 풀 때?
- 공식 기반 계산 함수(return)로 빠르게 구현 가능
재사용 가능한 기능을 모듈화하고 싶을 때?
- 함수로 정리해두면 다른 프로젝트에서도 쉽게 가져다 쓸 수 있음

“이 글은 제로베이스 데이터 스쿨 주 3일반 강의 자료 일부를 발췌하여 작성되었습니다.”