[제로베이스] 데이터취업스쿨 11기_6주차

임동혁·2023년 2월 10일
데이터분석제로베이스취업
0

zbdata

목록 보기
7/7

- 연산자 연습문제


출처:제로베이스

productPrice = int(input('상품 가격 입력: '))
payMoney = int(input('지불 금액: '))
if payMoney > productPrice:
    change = payMoney - productPrice
    change = change - (change % 10)
    print('거스름 돈: {}(원단위 절사)'.format(change))

paper50000 = 50000; paper10000 = 10000; paper5000 = 5000; paper1000 = 1000
coin500 = 500; coin100 = 100; coin10 = 10

paper50000cnt = 0; paper10000cnt = 0; paper5000cnt = 0; paper1000cnt = 0
coin500cnt = 0; coin100cnt = 0; coin10cnt = 0

print('-' * 30)
if change > paper50000:
    paper50000cnt = change // paper50000
    change = change % paper50000
if change > paper10000:
    paper10000cnt = change // paper10000
    change = change % paper10000
if change > paper5000:
    paper5000cnt = change // paper5000
    change = change % paper5000
if change > paper1000:
    paper1000cnt = change // paper1000
    change = change % paper1000
if change > coin500:
    coin500cnt = change // coin500
    change = change % coin500
if change > coin100:
    coin100cnt = change // coin100
    change = change % coin100
if change > coin10:
    coin10cnt = change // coin10
    change = change % coin10

print('50,000 {}장'.format(paper50000cnt))
print('10,000 {}장'.format(paper10000cnt))
print('5,000 {}장'.format(paper5000cnt))
print('1,000 {}장'.format(paper1000cnt))
print('500 {}개'.format(coin500cnt))
print('100 {}개'.format(coin100cnt))
print('10 {}개'.format(coin10cnt))
print('-' * 30)


출처:제로베이스

korScore = int(input('국어 점수 입력: '))
engScore = int(input('영어 점수 입력: '))
matScore = int(input('수학 점수 입력: '))
sumScore = (korScore + engScore + matScore)
avgScore = sumScore / 3

max = 0
maxName = 0
min = 0
minName = 0

print('총점: {}'.format(sumScore))
print('평균: %.2f' %avgScore)
print('-' * 30)

if korScore  > engScore :
    max = korScore
    maxName = '국어'
    min = engScore
    minName = '영어'
else :
    max = engScore
    maxName = '영어'
    min = korScore
    minName = '국어'
if matScore > max:
    max = matScore
    maxName = '수학'
elif matScore < min:
    min = matScore
    minName = '수학'

differnce = max - min


print('최고 점수 과목(점수): {}({})'.format(maxName,max))
print('최저 점수 과목(점수): {}({})'.format(minName,min))
print('최고, 최저 점수 차이: {}'.format(differnce))
print('-' * 30)


출처:제로베이스

hou = int(input('시간 입력: '))
min = int(input('분 입력: '))
sec = int(input('초 입력: '))

houToSec = hou * 60 * 60
minToSec = min * 60
total = houToSec + minToSec + sec

print('{}초'.format(format(total, ',')))

format(Data(이렇게 들어가는 순간 더이상 숫자X 문자), ',' <- 구분자 자동으로 해줌)


출처:제로베이스

money = int(input('금액 입력: '))
ratio = float(input('이율 입력: '))
date = int(input('기간 입력: '))
finalMoney = money

for i in range(date) :
    finalMoney = finalMoney + (finalMoney*ratio/100)
    # print('n년차 : %d, 금액 : %f' % ((i+1),finalMoney))

print('-' * 30)
print('이율: {}%'.format(ratio))
print('원금: {}원'.format(format(money,',')))
print('{}년 후 금액: {}원'.format(date,format(int(finalMoney),',')))
print('-' * 30)


출처:제로베이스

groundTemp = 29
height = 60
hegitTemp = 0.8

curHeight = int(input('고도 입력: '))

curTemp = groundTemp - (curHeight // height * hegitTemp)

if curHeight % height != 0:
    curTemp -= hegitTemp

print('지면 온도 : {}'.format(groundTemp))
print('고도 %dm의 기온: %.2f'%(curHeight,curTemp))


출처:제로베이스

bread = 197
milk = 152
student = 17

print('학생 한명이 가지는 빵 개수 : {}'.format(bread//student))
print('학생 한명이 가지는 우유 개수 : {}'.format(milk//student))
print('남는 빵 개수 : {}'.format(bread%student))
print('남는 우유 개수 : {}'.format(milk%student))


출처:제로베이스

myAge = int(input('나이 입력: '))
if myAge <= 19 or myAge >= 65 :
    birthNum = int(input('출생 연도 끝자리 입력: '))
    if birthNum == 1 or birthNum == 6 :
        print('월요일 접종 가능!!')
    elif birthNum == 2 or birthNum == 7 :
        print('화요일 접종 가능!!')
    elif birthNum == 3 or birthNum == 8 :
        print('수요일 접종 가능!!')
    elif birthNum == 4 or birthNum == 9 :
        print('목요일 접종 가능!!')
    elif birthNum == 5 or birthNum == 0 :
        print('금요일 접종 가능!!')
else :
    print('하반기 일정 확인하세요.')


출처:제로베이스

toInch = 0.039
length = int(input('길이(mm) 입력: '))
inchLength = length * toInch

print('%dmm -> %.3finch' % (length,inchLength))

- 조건문 연습문제


출처:제로베이스

speed = int(input('속도 입력: '))
if speed <= 50:
    print('안전속도 준수!!')
else :
    print('안전속도 위반!! 과태료 50,000원 부과 대상!!!')


출처:제로베이스

message = input('메시지 입력: ')
lenMsg = len(message)

if lenMsg <= 50:
    print('SMS 발송!!')
    print('메시지 길이: {}'.format(lenMsg))
    print('메시지 발송 요금: 50원')
else :
    print('MMS 발송!!')
    print('메시지 길이: {}'.format(lenMsg))
    print('메시지 발송 요금: 100원')


출처:제로베이스

# 답안 1
korAvg = 85; engAvg = 82; matAvg = 89
sciAvg = 75; hisAvg = 94
totalAvg = korAvg + engAvg + matAvg + sciAvg + hisAvg
avgAvg  = int(totalAvg/5)

korScore = int(input('국어 점수 입력: '))
engScore = int(input('영어 점수 입력: '))
matScore = int(input('수학 점수 입력: '))
sciScore = int(input('과학 점수 입력: '))
hisScore = int(input('국사 점수 입력: '))

totalScore = korScore + engScore + matScore + sciScore + hisScore
avgScore = int(totalScore/5)

korGap = korScore - korAvg
engGap = engScore - engAvg
matGap = matScore - matAvg
sciGap = sciScore - sciAvg
hisGap = hisScore - hisAvg
totalGap = totalScore - totalAvg
avgGap = avgScore - avgAvg

print('-' * 70)
print('총점: {}({}), 평균:{}({})'.format(totalScore,totalGap,avgScore,avgGap))
print('국어: {}({}), 영어: {}({}), 수학: {}({}), 과학: {}({}), 국사: {}({})'.format(
    korScore, korGap, engScore, engGap, matScore, matGap, sciScore, sciGap, hisScore, hisGap
))
print('-' * 70)

str = '+' if korGap > 0 else '-'
print('국어 편차: {}({})'.format(str * abs(korGap), korGap))
str = '+' if engGap > 0 else '-'
print('영어 편차: {}({})'.format(str * abs(engGap), engGap))
str = '+' if matGap > 0 else '-'
print('수학 편차: {}({})'.format(str * abs(matGap), matGap))
str = '+' if sciGap > 0 else '-'
print('과학 편차: {}({})'.format(str * abs(sciGap), sciGap))
str = '+' if hisGap > 0 else '-'
print('국사 편차: {}({})'.format(str * abs(hisGap), hisGap))
str = '+' if totalGap > 0 else '-'
print('총점 편차: {}({})'.format(str * abs(totalGap), totalGap))
str = '+' if avgGap > 0 else '-'
print('평균 편차: {}({})'.format(str * abs(avgGap), avgGap))

print('-' * 70)
# 답안 2
avgKor = 85
avgEng = 82
avgMat = 89
avgSie = 75
avgHis = 94
avgAvgScore = int((avgKor + avgEng + avgMat + avgSie + avgHis) /5)

korScore = int(input('국어 점수 입력: '))
engScore = int(input('영어 점수 입력: '))
matScore = int(input('수학 점수 입력: '))
sieScore = int(input('과학 점수 입력: '))
hisScore = int(input('국사 점수 입력: '))

totalScore = korScore + engScore + matScore + sieScore + hisScore
avgScore = int(totalScore / 5)

devKor = korScore - avgKor
devEng = engScore - avgEng
devMat = matScore - avgMat
devSie = sieScore - avgSie
devHis = hisScore - avgHis

devTotal = devKor + devEng + devMat + devSie + devHis
devAvg = int(avgScore - avgAvgScore)

print('-' * 70)
print('총점 : {}({}), 평균: {}({})'.format(totalScore,devTotal,avgScore,devAvg))
print('-' * 70)

if devKor > 0 :
    print('국어 편차: {}({})'.format(('+' * devKor), devKor))
else :
    print('국어 편차: {}({})'.format(('-' * abs(devKor)), devKor))

if devEng > 0 :
    print('영어 편차: {}({})'.format(('+'*devEng),devEng))
else :
    print('영어 편차: {}({})'.format(('-' * abs(devEng)), devEng))

if devMat > 0 :
    print('수학 편차: {}({})'.format(('+'*devMat),devMat))
else :
    print('수학 편차: {}({})'.format(('-' * abs(devMat)), devMat))

if devSie > 0 :
    print('과학 편차: {}({})'.format(('+'*devSie),devSie))
else :
    print('과학 편차: {}({})'.format(('-' * abs(devSie)), devSie))

if devHis > 0 :
    print('국사 편차: {}({})'.format(('+'*devHis),devHis))
else :
    print('국사 편차: {}({})'.format(('-' * abs(devHis)), devHis))

if devTotal > 0 :
    print('총점 편차: {}({})'.format(('+'*devTotal),devTotal))
else :
    print('총점 편차: {}({})'.format(('-' * abs(devTotal)), devTotal))

if devAvg > 0 :
    print('평균 편차: {}({})'.format(('+'*devAvg),devAvg))
else :
    print('평균 편차: {}({})'.format(('-' * abs(devAvg)), devAvg))

print('-' * 70)


출처:제로베이스

import random

num = random.randint(1,2)
userNum = int(input('홀/짝 선택: 1.홀 \t 2.짝 '))
print(num)

if num == 1 and userNum == 1 :
    print('빙고!! 홀수!!!')
elif num == 2 and userNum == 2:
    print('빙고!! 짝수!!!')
elif num == 1 and userNum == 2:
    print('실패!! 홀수!!!')
elif num == 2 and userNum == 1:
    print('실패!! 짝수!!!')
#비트 논리 연산자 체크하기 and와 &의 차이


출처:제로베이스

import random

comNum = random.randint(1, 3)
userNum = int(input('가위,바위,보 선택: 1.가위 \t 2.바위 \t 3.보 : '))

if (comNum == 1 and userNum == 2) or (comNum == 2 and userNum == 3) or (comNum == 3 and userNum == 1) :
    print('컴퓨터 : 패, 유저 : 승')
elif comNum == userNum :
    print('무승부')
else :
    print('컴퓨터 : 승, 유저 : 패')

print('컴퓨터: {}, 유저: {}'.format(comNum,userNum))


출처:제로베이스

category = int(input('업종선택(1.가정용 \t 2.대중탕용 \t 3.공업용): '))
usage = int(input('사용량 입력: '))
print('=' * 40)
print('상수도 요금표')
print('-' * 40)
if category == 1 :
    price = usage * 540
elif category == 2:
    if usage <= 50 :
        price = usage * 820
    elif usage > 50 and usage <= 300 :
        price = usage * 1920
    else :
        price = usage * 2400
elif category == 3:
    if usage <= 500 :
        price = usage * 240
    else :
        price = usage * 470

print('사용량 \t : \t 요금')
print('{} \t : \t {}'.format(usage,format(price,',')))
print('=' * 40)


출처:제로베이스

import datetime

dustScore = int(input('미세먼지 수치 입력: '))
kindCar = int(input('차량 종류 선택: 1.승용차 \t 2.영업용차 '))
carNum = int(input('차량 번호 입력: '))
date = datetime.datetime.today()
today = datetime.datetime.today().day
print('-' * 30)
print(date)
print('-' * 30)

# 차량 2부제 : 날짜가 짝수인 날에는 짝수 번호 차량이, 홀수인 날에는 홀수 번호 차량이 운행
# 짝수, 홀수 구분은 차번호 가장 끝자리로 함
# 차량 5부제 : (1,6),(2,7),(3,8),(4,9),(5,0) 5그룹으로 묶어서 각 그룹별 끝자리 같은날 운행 X

if dustScore <= 150:
    if (carNum % 10) == (today % 10) or ((carNum +5) % 10) == (today % 10) :
    # == if (carNum % 5) == (today %5)
        print('차량 5부제 적용')
        print('차량 5부제로 금일 운행제한 대상 차량입니다!!')
    else :
        print('금일 운행 가능합니다!!')
else :
    if kindCar == 1 :
        if (carNum % 2) == (today % 2) :
            print('차량 2부제 적용')
            print('차량 2부제로 금일 운행제한 대상 차량입니다!!')
        else :
            print('금일 운행 가능합니다!!')
    else :
        if (carNum % 10) == (today % 10) or ((carNum + 5) % 10) == (today % 10):
            print('차량 5부제 적용')
            print('차량 5부제로 금일 운행제한 대상 차량입니다!!')
        else:
            print('금일 운행 가능합니다!!')
print('-' * 30)


출처:제로베이스

import random
randNum = random.randint(1 , 1000)
cnt = 0

while True :
    userNum = int(input('1에서 1000까지의 정수 입력: '))
    cnt += 1
    if userNum == randNum :
        print('빙고!')
        break
    elif userNum > randNum :
        print('난수가 작다!')
    elif userNum < randNum :
        print('난수가 크다!')

print('난수: {}, 시도 횟수: {}'.format(randNum,cnt))


출처:제로베이스

inTemp = int(input('실내온도 입력: '))
airState = 0

if inTemp <= 18 :
    airState = 'OFF'
elif inTemp > 18 and inTemp <= 22 :
    airState = '매우 약'
elif inTemp > 22 and inTemp <= 24 :
    airState = '약'
elif inTemp > 24 and inTemp <= 26 :
    airState = '중'
elif inTemp > 26 and inTemp <= 28 :
    airState = '강'
elif inTemp > 28 :
    airState = '매우 강'

print('에어컨: {}!!'.format(airState))

- 반복문 연습문제


출처:제로베이스

for i in range(1 , 101) :
    if i < 10 :
        if i % 2 == 0 :
            print('[{}]: 짝수!')
        else :
            print('[{}]: 홀수!')
    else :
        num10 = 0
        num1 = 0

        if (i // 10) % 2 == 0 :
            num10 = '짝수!!'
        else :
            num10 = '홀수!!'

        if (i % 10) == 0 :
            num1 = 0
        elif ((i % 10) % 2) == 0 :
            num1 = '짝수!!'
        else :
            num1 = '홀수!!'
        print('[{}] 십의자리: {}, 일의자리: {}'.format(i,num10,num1))


출처:제로베이스

userNum = int(input('정수 입력: '))
sum = 0
oddSum = 0
evenSum = 0
factorial = 1

for i in range(1 , userNum+1) :
    sum += i
    factorial *= i
    if i % 2 == 0 :
        evenSum += i
    else :
        oddSum += i

print('합 결과 : {}'.format(sum))
print('홀수 합 결과 : {}'.format(oddSum))
print('짝수 합 결과 : {}'.format(evenSum))
print('합 결과 : {}'.format(format(factorial , ',')))


출처:제로베이스

#1
line = int(input('Line 수 : '))

for i in range(1, line+1) :
    print('*' * i , end='')
    print()

print('-' * 30)

#2
for i in range(1,line+1) :
    print(' ' * (line-i)+'*' * i , end='')
    print()

print('-' * 30)

#3
for i in range(line,0,-1) :
    print('*' * i , end ='')
    print()

print('-' * 30)

#4
for i in range(line,0,-1) :
    print(' ' * (line - i) + '*' * i, end='')
    print()

print('-' * 30)

#5
for i in range(1, line+1) :
    print('*' * i , end='')
    print()
for i in range(line-1,0,-1) :
    print('*' * i , end ='')
    print()

print('-' * 30)

#6
for i in range(1,line+1) :
    print(' ' * (i-1) + '*')

print('-' * 30)

#7
for i in range(line,0,-1) :
    print(' ' * (i-1) + '*')

print('-' * 30)

#8
for i in range(1,line+1) :
    print(' ' * (line-i)+'*' * i , end='')
    print('*' * (i-1),end='')
    print()
for i in range(line,0,-1) :
    print(' ' * (line - i) + '*' * i, end='')
    print('*' * (i-1), end='')
    print()
#1
for i in range(1 , 6):
    for j in range(i):
        print('*', end='')
    print()
print('-'*20)
#2
for i1 in range(1, 6):
    for i2 in range(6 - i1 -1):
        print(' ',end='')
    for i3 in range(i1):
        print('*',end='')
    print()
print('-'*20)
#3
for i in range(5, 0, -1):
    for j in range(i):
        print('*', end='')
    print()
print('-'*20)
#4
for i in range(5, 0, -1):
    for j in range(5 - i):
        print(' ',end='')
    for j in range(i):
        print('*', end='')
    print()
print('-'*20)
#5
for i in range(1, 10):
    if i < 5:
        for j in range(i):
            print('*', end='')
    else:
        for j in range(10 - i):
            print('*', end='')
    print()
print('-'*20)
#6
for i in range(1,6):
    for j in range(1,6):
        if j == i:
            print('*',end='')
        else:
            print(' ',end='')
    print()
print('-'*20)
#7
for i in range(5, 0, -1):
    for j in range(1,6):
        if j == i:
            print('*', end='')
        else:
            print(' ', end='')
    print()
print('-'*20)
#8

for i in range(1,11):
    if i < 6 :
        for j1 in range(5-i) :
            print(' ',end='')
        for j2 in range(i*2-1) :
            print('*',end='')
    else :
        for j1 in range(i-6) :
            print(' ',end='')
        for j2 in range(2*(11-i)-1) :
            print('*',end='')
    print()


출처:제로베이스

busA = 15
busB = 13
busC = 8

totalMin = 60 * 17
for i in range(totalMin + 1) :
    if i < 20 or i > (totalMin - 60) :
        if i % busA == 0 and i % busB == 0 :
            print('busA와 busB 동시 정차!!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
    else :
        if i % busA == 0 and i % busB == 0:
            print('busA와 busB 동시 정차!!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
        elif i % busA == 0 and i % busC == 0:
            print('busA와 busC 동시 정차!!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
        elif i % busB == 0 and i % busC == 0:
            print('busB와 busC 동시 정차!!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))


출처:제로베이스

gearATCnt = int(input('GearA 톱니수 입력: '))
gearBTCnt = int(input('GearB 톱니수 입력: '))

gearA = 0
gearB = 0
leastNum = 0

flag = True
while flag:


    if gearA != 0:
        if gearA != leastNum:
            gearA += gearATCnt
        else :
            flag = False

    else :
        gearA += gearATCnt

    if gearB != 0 and gearB % gearATCnt == 0:
        leastNum = gearB
    else:
        gearB += gearBTCnt

print('최초 만나는 톱니수(최소공배수): {}톱니'.format(leastNum))
print('gearA 회전수 : {}회전'.format(int(leastNum/gearATCnt)))
print('gearB 회전수 : {}회전'.format(int(leastNum/gearBTCnt)))


출처:제로베이스

# year = int(input('연도 입력: '))
#
# if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
#     print('{}년: 윤년!!'.format(year))
# else:
#     print('{}년: 평년!!'.format(year))

for year in range(2022, (2022+101)) :
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        print('{}년: 윤년!!'.format(year))
    else:
        print('{}년: 평년!!'.format(year))

- 함수란?

  • 파이썬의 함수는 수학의 함수와 동일함.

  • input -> 함수 -> output

  • 함수는 파이썬에서 기본으로 제공하는 내장함수와 사용자가 직접 선언하는 사용자 함수가 있음.

    출처:제로베이스

  • 함수는 특정 기능을 재사용하기 위해서 사용함.

  • 함수명은 기능을 알 수 있게 작명하는게 좋음.

  • 함수는 def키워드, 함수명, :, 들여쓰기를 이용해서 선언함.

  • 함수는 선언만 해선 실행안됨 호출을 해줘야 실행이됨.

    출처:제로베이스

def addCal() :
    n1 = int(input('n1 입력: '))
    n2 = int(input('n2 입력: '))

    print(f'n1 + n2 = {n1 + n2}')

addCal()
  • 함수 내에서 또 다른 함수를 호출할 수 있음.
def fun1():
    print('fun1 호출!')
    fun2()

def fun2():
    print('fun2 호출!')
    fun3()

def fun3():
    print('fun3 호출!')
    

fun1()
def guguDan2():
    for i in range(1,10):
        print('2 * {} = {}'.format(i, 2*i))
    guguDan3()

def guguDan3():
    for i in range(1,10):
        print('3 * {} = {}'.format(i, 3*i))
    guguDan4()

def guguDan4():
    for i in range(1,10):
        print('4 * {} = {}'.format(i, 4*i))
    guguDan5()

def guguDan5():
    for i in range(1,10):
        print('5 * {} = {}'.format(i, 5*i))

guguDan2()

  • pass를 이용해서 실행문을 생략할 수 있음.

  • 함수 호출 시 함수에 데이터를 전달할 수 있음.

  • 인수와 매개변수는 쌍이기 때문에 항상 갯수가 일치해야 함.

    출처:제로베이스

def greet(customer):
    print('{}님 안녕하세요.'.format(customer))

greet('홍길동')
greet('박찬호')
def calculator(n1,n2):
    print(f'{n1} + {n2} = {n1 + n2}')
    print(f'{n1} - {n2} = {n1 - n2}')
    print(f'{n1} * {n2} = {n1 * n2}')
    print(f'{n1} / {n2} = {n1 / n2}')

calculator(10,20)
  • 매개변수 개수가 정해지지 않은 경우 '*'를 이용한다.
def printNumber(*numbers):
    for number in numbers:
        print(number, end="")
    print()

printNumber()
printNumber(10)
printNumber(10, 20)
printNumber(10, 20, 30)

  • return 키워드를 이용하면 함수 실행 결과를 호출부로 반활할 수 있음.

  • 함수가 return 을 만나면 실행을 종료함.

    출처:제로베이스

  • 전역 변수 : 함수 밖에 선언된 변수로 어디에서나 사용은 가능하지만, 함수 안에서 수정할 수는 없음.

    출처:제로베이스

  • 지역 변수 : 함수 안에 선언된 변수로 함수 안에서만 사용 가능함.

    출처:제로베이스

  • global 키워드 : global을 사용하면 함수 안에서도 전역변수의 값을 수정할 수 있음.

    출처:제로베이스

totalVisit = 0

def countTotalVisit() :
    global totalVisit

    totalVisit += 1
    print(f'누적 방문객: {totalVisit}')

countTotalVisit()
countTotalVisit()
countTotalVisit()
countTotalVisit()
countTotalVisit()

  • 중첩 함수 : 함수 안에 또 다른 함수가 있는 형태.

    출처:제로베이스

  • 내부 함수를 함수 밖에서 호출할 수 없음.

def calculator(n1,n2,operator):

    def addCal():
        print(f'덧셈 연산: {n1 + n2}')

    def subCal():
        print(f'뺄셈 연산: {n1 - n2}')

    def mulCal():
        print(f'곱셈 연산: {n1 * n2}')

    def divCal():
        print(f'나눗셈 연산: {n1 / n2}')

    if operator == 1:
        addCal()
    elif operator == 2 :
        subCal()
    elif operator == 3 :
        mulCal()
    elif operator == 4 :
        divCal()

while True:
    num1 = float(input('실수(n1) 입력: '))
    num2 = float(input('실수(n2) 입력: '))
    operatorNum = int(input('1.덧셈, 2.뺄셈, 3.곱셈, 4.나눗셈, 5.종료'))

    if operatorNum == 5:
        print("Bye~")
        break
    calculator(num1,num2,operatorNum)
  • lambda 함수 : labmda 키워드를 이용하면 함수 선언을 보다 간단하게 할 수 있음.

    출처:제로베이스
# def calculator(n1, n2):
#     return n1 + n2
#
# returnValue = calculator(10,20)
# print(f'returnValue: {returnValue}')


calculator = lambda n1, n2: n1 + n2
returnValue = calculator(10,20)
print(f'returnValue: {returnValue}')
getTriangleArea = lambda n1, n2: n1 * n2 / 2
getSquareArea = lambda n1, n2: n1 * n2
getCircleArea = lambda r : r * r * 3.14

width = int(input('가로 길이 입력: '))
height = int(input('세로 길이 입력: '))
radius = int(input('반지름 길이 입력: '))

triangleValue = getTriangleArea(width, height)
squareValue = getSquareArea(width, height)
circleValue = getCircleArea(radius)

print(f'삼각형 넓이: {triangleValue}')
print(f'사각형 넓이: {squareValue}')
print(f'원 넓이: {circleValue}')
  • 모듈이란? 이미 만들어진 훌륭한 기능으로 사용자는 쉽게 사용할 수 있음.

    출처:제로베이스

-파이썬 모듈은 내부 모듈, 외부 모듈, 사용자 모듈로 구분할 수 있음.
내부 모듈 -> 파이썬 설치 시 기본적으로 사용할 수 있는 모듈
외부 모듈 -> 별도 설치 후 사용할 수 있는 모듈
사용자 모듈 -> 사용자가 직접 만든 모듈

import random

rNum = random.randint(1,10)
print(f'rNum : {rNum}')

rNums = random.sample(range(101), 10)
print(f'rNums : {rNums}')
  • 모듈은 파이썬 파일이다! 모듈은 특정 기능을 가지고 있는 파이썬 파일을 말한다.
#calculator 모듈
def add(n1,n2):
    print(f'덧셈 결과 출력 : {n1 + n2}')

def sub(n1,n2):
    print(f'뺄셈 결과 출력 : {n1 - n2}')

def mul(n1,n2):
    print(f'곱셈 결과 출력 : {n1 * n2}')

def div(n1,n2):
    print(f'나눗셈 결과 출력 : {n1 / n2}')
lotto 모듈
import random

def getLottoNumbers():
    result = random.sample(range(1,45), 6)

    return result
# import calculator
#
# calculator.add(10,20)
# calculator.sub(10,20)
# calculator.mul(10,20)
# calculator.div(10,20)

import lottoMachine

result = lottoMachine.getLottoNumbers()
result.sort(reverse=False)

print(f'lotto numbers: {result}')
  • import 키워드를 이용해서 모듈을 임포트 한다.
  • as 키워드를 이용해서 모듈 이름을 단축 시킬 수 있음.
import calculator as ct

ct.add(10,20)
ct.sub(10,20)
ct.mul(10,20)
ct.div(10,20)
  • from ~ as 키워드를 이용해서 모듈의 특정 기능만 사용할 수 있음.
  • from 키워드를 이용해서 가져오면 모듈명을 이용해서 접근하지 않고 바로 함수명을 이용해서 프로그램을 실행시킬 수 있음.
from calculator import * # calculator의 모든 기능을 다 가져오겠다.
# from calculator import add
# from calculator import sub
# from calculator import mul, div

add(10,20)
sub(10,20)
mul(10,20)
div(10,20)
  • name 전역변수
  • name 에는 모듈 이름이 저장되거나 'main'이 저장된다.


출처:제로베이스

  • 다른 모듈들은 각 파일명이 저장되는데 실행파일엔 main이 저장됨.
import addModule
import subModule
import mulModule
import divModule

def mod(n1,n2):
    return n1 % n2

if __name__ == '__main__':
    print(addModule.add(10,20))
    print(subModule.sub(10,20))
    print(mulModule.mul(10,20))
    print(divModule.div(10,20))
  • 단위 환산 모듈 연습문제
# 모듈 파일
def cmToMm(n):
    return round(n * 10 , 3)

def cmToInch(n):
    return round(n * 0.393 , 3)

def cmToM(n):
    return round(n * 0.01, 3)


def cmToFt(n):
    return round(n * 0.032, 3)

if __name__ == '__main__':
    print(f'10cm: {cmToMm(10)}mm')
    print(f'10cm: {cmToInch(10)}inch')
    print(f'10cm: {cmToM(10)}m')
    print(f'10cm: {cmToFt(10)}ft')
# 실행 파일
import unitConversion as uc


if __name__ == '__main__':
    inputNumber = int(input('길이(cm) 입력: '))

    returnValue = uc.cmToMm(inputNumber)
    print(f'returnValue: {returnValue}mm')

    returnValue = uc.cmToInch(inputNumber)
    print(f'returnValue: {returnValue}inch')

    returnValue = uc.cmToM(inputNumber)
    print(f'returnValue: {returnValue}m')

    returnValue = uc.cmToFt(inputNumber)
    print(f'returnValue: {returnValue}ft')
  • 패키지 : 패키지를 이용하면 관련 있는 모듈을 그룹으로 관리할 수 있음.

    출처:제로베이스
from CalculatorForInt import addCal
from CalculatorForInt import subCal
from CalculatorForInt import mulCal
from CalculatorForInt import divCal

print(addCal.add(10,20))
print(subCal.sub(10,20))
print(mulCal.mul(10,20))
print(divCal.div(10,20))

from CalculatorForFloat import addCal
from CalculatorForFloat import subCal
from CalculatorForFloat import mulCal
from CalculatorForFloat import divCal

print(addCal.add(10,20))
print(subCal.sub(10,20))
print(mulCal.mul(10,20))
print(divCal.div(10,20))

  • site-packages에 있는 모듈은 어디서나 사용할 수 있음.

  • site-packages에 약수와 소수를 리스트로 반환하는 모듈 만들기 연습문제

# divisor_pac module

def divisor(n) :
    divisorList = []
    for i in range(1,n+1):
        if n % i == 0:
            divisorList.append(i)
    return divisorList


def prime_number(n) :
    primeList = []
    for i in range(1,n+1):
        divisorLen = len(divisor(i))
        if divisorLen == 2 :
            primeList.append(i)
    return primeList

if __name__ == '__main__':
    print(f'10의 약수: {divisor(10)}')
    print(f'50까지의 소수: {prime_number(50)}')
# 실행 파일

from divisor_pac import divisor_mod as dm

print(f'10의 약수: {dm.divisor(10)}')
print(f'50까지의 소수: {dm.prime_number(50)}')
  • 자주 사용하는 모듈 : 수학, 난수, 시간 모듈은 코딩할 때 유용하게 사용됨.
#수학 관련 함수

#합
listVar = [2,5,3.14,58,10,2]
print(f'sum(listvar): {sum(listVar)}')

#최댓값
listVar = [2,5,3.14,58,10,2]
print(f'max(listvar): {max(listVar)}')

#최솟값
listVar = [2,5,3.14,58,10,2]
print(f'min(listvar): {min(listVar)}')

#거듭제곱
print(f'pow(13,2): {pow(13,2)}')
print(f'pow(13,3): {pow(13,3)}')
print(f'pow(13,4): {pow(13,4)}')
print(f'pow(13,5): {pow(13,5)}')

#반올림
print(f'{round(3.141592, 1)}')
print(f'{round(3.141592, 2)}')
print(f'{round(3.141592, 3)}')
print(f'{round(3.141592, 4)}')
print(f'{round(3.141592, 5)}')
import math

#절댓값
print(f'math.fabs(-10): {math.fabs(-10)}')
print(f'math.fabs(-10): {math.fabs(-0.12895)}')

#올림
print(f'math.ceil(5.21): {math.ceil(5.21)}')
print(f'math.ceil(5.21): {math.ceil(-5.21)}')

#내림
print(f'math.floor(5.21): {math.floor(5.21)}')
print(f'math.floor(5.21): {math.floor(-5.21)}')

#버림
print(f'math.trunc(5.21): {math.trunc(5.21)}')
print(f'math.trunc(5.21): {math.trunc(-5.21)}')

#최대공약수
print(f'math.gcd(14,21): {math.gcd(14,21)}')

#팩토리얼
print(f'math.factorial(10) : {math.factorial(10)}')

#제곱근
print(f'math.sqrt(4): {math.sqrt(4)}')
print(f'math.sqrt(4): {math.sqrt(12)}')

import time

lt = time.localtime()
print(f'time.localtime(): {lt}')
print(f'lt.tm_year: {lt.tm_year}')
print(f'lt.tm_mon: {lt.tm_mon}')
print(f'lt.tm_mday: {lt.tm_mday}')
print(f'lt.tm_hour: {lt.tm_hour}')
print(f'lt.tm_min: {lt.tm_min}')
print(f'lt.tm_sec: {lt.tm_sec}')
print(f'lt.tm_wday: {lt.tm_wday}')
  • 객체지향 프로그래밍 : 객체를 이용한 프로그램으로 객체는 속성과 기능으로 구성됨.
    객체(Object) = 속성(Attribute) + 기능(Function)

    출처:제로베이스

-객체는 클래스에서 생성됨. 클래스는 객체를 만들기 위한 하나의 틀(ex:붕어빵 틀)

출처:제로베이스

  • 객체 사용의 장점 : 코드 재사용, 모듈화에 좋음.

    출처:제로베이스

  • 클래스는 class 키워드와 속성(변수), 기능(함수)를 이용해서 만듬.

  • 클래스 이름은 함수와 다르게 첫번째 문자를 대문자로 하는게 관례.

    출처:제로베이스

  • 클래스 안에 있는 특정한 기능은 매개변수로 self로 받아야됨. self가 있다는 것은 클래스안에 포함된 기능이라고 생각하면 됨.

  • 객체는 클래스의 생성자를 호출한다.

    출처:제로베이스

class Car:

    def __init__(self, col, len):
        self.color = col
        self.length = len

    def doStop(self):
        print('STOP!!')

    def doStart(self):
        print('STRAT!!')

    def printCarInfo(self):
        print(f'self.color: {self.color}')
        print(f'self.length: {self.length}')

car1 = Car('red',200)
car2 = Car('blue',300)

car1.printCarInfo()
car2.printCarInfo()

car1.doStop()
car1.doStart()
  • 객체 속성은 변경할 수 있음.
class NewGenerationPC:

    def __init__(self,name,cpu,memory,ssd):
        self.name = name
        self.cpu = cpu
        self.memory = memory
        self.ssd = ssd

    def doExcel(self):
        print('EXCEL RUN!!')

    def doPhotoshop(self):
        print('PHOTOSHOP RUN!!')

    def printPCInfo(self):
        print(f'self.name: {self.name}')
        print(f'self.cpu: {self.cpu}')
        print(f'self.memory: {self.memory}')
        print(f'self.ssd: {self.ssd}')

myPc = NewGenerationPC('myPc','i5','16G','256G')
myPc.printPCInfo()

friendPc = NewGenerationPC('friendPc','i7','32G','512G')
friendPc.printPCInfo()

#객체 속성 변경
myPc.cpu = 'i9'
myPc.memory = '64G'
myPc.ssd = '1T'
myPc.printPCInfo()
class Calculator:

    def __init__(self):
        self.number1 = 0
        self.number2 = 0
        self.result = 0

    def add(self):
        self.result = self.number1 + self.number2
        return self.result

    def sub(self):
        self.result = self.number1 - self.number2
        return self.result

    def mul(self):
        self.result = self.number1 * self.number2
        return self.result

    def div(self):
        self.result = self.number1 / self.number2
        return self.result


num = Calculator()
num.number1 = 10
num.number2 = 20
print(num.add())
print(num.sub())
print(num.mul())
print(num.div())
  • 변수는 객체의 메모리 주소를 저장하고 이를 이용해서 객체를 참조한다.

    출처:제로베이스
class Robot:

    def __init__(self, color, height, weight):
        self.color = color
        self.height = height
        self.weight = weight

    def printRobotInfo(self):
        print(f'color: {self.color}')
        print(f'height: {self.height}')
        print(f'weight: {self.weight}')

rb1 = Robot('red',200,80)
rb2 = Robot('blue',300,120)
rb3 = rb1 #얕은복사 객체가 카피된게 아니라 객체가 가지고 있는 메모리 주소가 카피된 것

rb1.printRobotInfo()
rb2.printRobotInfo()
rb3.printRobotInfo()

rb1.color = 'gray'
rb1.height = 250
rb1.weight = 100

rb1.printRobotInfo()
rb2.printRobotInfo()
rb3.printRobotInfo()

  • copy()를 이용하면 새로운 객체로 만들 수 있음

  • 얕은 복사란, 객체 주소를 복사하는 것으로 객체 자체가 복사되지 않음.

    출처:제로베이스

  • 깊은 복사란, 객체 자체를 복사하는 것으로 또 하나의 객체가 만들어짐

    출처:제로베이스

class TemCls:

    def __init__(self,n,s):
        self.number = n
        self.str = s

    def printClsInfo(self):
        print(f'self.number: {self.number}')
        print(f'self.str: {self.str}')


# 얕은 복사
# tc1 = TemCls(10, 'Hello')
# tc2 = tc1
#
# tc1.printClsInfo()
# tc2.printClsInfo()
#
# tc2.number = 3.14
# tc2.str = 'Bye'
#
# tc1.printClsInfo()
# tc2.printClsInfo()

# 깊은 복사

# import copy
#
# tc1 = TemCls(10,'Hello')
# tc2 = copy.copy(tc1)
#
# tc1.printClsInfo()
# tc2.printClsInfo()
#
# tc2.number = 3.14
# tc2.str = 'Bye'
#
# tc1.printClsInfo()
# tc2.printClsInfo()
import copy

scores = [9,8,5,7,6,10] # 리스트도 객체
scoresCopy = []

# scoresCopy = scores # 얕은 복사
# print(f'id(scores): {id(scores)}')
# print(f'id(scoresCopy): {id(scoresCopy)}')

# for s in scores: # 깊은 복사
#     scoresCopy.append(s)
#
# print(f'id(scores): {id(scores)}')
# print(f'id(scoresCopy): {id(scoresCopy)}')

# scoresCopy.extend(scores) # 깊은 복사 2
# print(f'id(scores): {id(scores)}')
# print(f'id(scoresCopy): {id(scoresCopy)}')

# scoresCopy = scores.copy() # 깊은 복사 3
# print(f'id(scores): {id(scores)}')
# print(f'id(scoresCopy): {id(scoresCopy)}')

# scoresCopy = scores[:] # 깊은 복사 4
# print(f'id(scores): {id(scores)}')
# print(f'id(scoresCopy): {id(scoresCopy)}')
  • 상속이란? 클래스는 또 다른 클래스를 상속해서 내 것처럼 사용할 수 있음.

    출처:제로베이스
class NormalCar:

    def drive(self):
        print('[NormalCar] drive() called!!')

    def back(self):
        print('[NormalCar] back() called!!')

class TurboCar(NormalCar): # NormalCar 상속

    def turbo(self):
        print('[TurboCar] turbo() called!!')


myTurboCar = TurboCar()

myTurboCar.turbo()
myTurboCar.drive()
myTurboCar.back()
class CalculatorSuper:

    def add(self, n1, n2):
        return n1 + n2

    def sub(self, n1, n2):
        return n1 - n2

class CalculatorChild(CalculatorSuper):

    def mul(self, n1, n2):
        return n1 * n2

    def div(self, n1, n2):
        return n1 / n2

myCalculator = CalculatorChild()

print(myCalculator.add(10,20))
print(myCalculator.sub(10,20))
print(myCalculator.mul(10,20))
print(myCalculator.div(10,20))
  • 객체가 생성될 때 생성자를 호출하면 init()가 자동 호출됨.
class Calculator:

    def  __init__(self):
        print('[Calculator] __init__() called!!')

Calculator()
  • init()가 속성을 초기화 한다.
class Calculator:

    def  __init__(self,n1,n2):
        print('[Calculator] __init__() called!!')
        self.num1 = n1
        self.num2 = n2

cal = Calculator(10,20)
print(f'cal.num1: {cal.num1}')
print(f'cal.num2: {cal.num2}')

class Calculator:

    def  __init__(self,n):
        print('[Calculator] __init__() called!!')
        self.num1 = n
        self.num2 = 100

cal = Calculator(3.14)
print(f'cal.num1: {cal.num1}')
print(f'cal.num2: {cal.num2}')
  • 상위 클래스의 속성을 초기화하기 위해서 super()를 이용한다.

    출처:제로베이스
class P_Class:

    def __init__(self, pNum1, pNum2):
        print('[P_Class] __init__() called!!')
        self.pNum1 = pNum1
        self.pNum2 = pNum2


class C_Class(P_Class):

    def __init__(self, cNum1, cNum2):
        print('[C_Class] __init__() called!!')

        # 방법 1 P_Class.__init__(self, cNum1, cNum2)
        super().__init__(cNum1,cNum2) # super를 쓸땐 괄호안에 self 안써도됨

        self.cNum1 = cNum1
        self.cNum2 = cNum2

cls = C_Class(10,20)
  • 클래스 상속 연습문제

    출처:제로베이스
class MidExam :

    def __init__(self,s1,s2,s3):
        print('[MidExam] __init__()')

        self.mid_kor_score = s1
        self.mid_eng_score = s2
        self.mid_mat_score = s3

    def printScores(self):
        print(f'mid_kor_score: {self.mid_kor_score}')
        print(f'mid_eng_score: {self.mid_eng_score}')
        print(f'mid_mat_score: {self.mid_mat_score}')

class EndExam(MidExam):

    def __init__(self,s1,s2,s3,s4,s5,s6):
        print('[EndExam] __init__()')

        super().__init__(s1,s2,s3)

        self.end_kor_score = s4
        self.end_eng_score = s5
        self.end_mat_score = s6

    def printScores(self):
        super().printScores()
        print(f'end_kor_score: {self.end_kor_score}')
        print(f'end_eng_score: {self.end_eng_score}')
        print(f'end_mat_score: {self.end_mat_score}')

    def getTotalScore(self):
        total = self.mid_kor_score + self.mid_eng_score+ self.mid_mat_score
        total += self.end_kor_score + self.end_eng_score+ self.end_mat_score

        return total

    def getAverageScore(self):
        return self.getTotalScore() / 6

exam = EndExam(85,90,88,75,85,95)
exam.printScores()

print(f'Total: {exam.getTotalScore()}')
print(f'Average: {round(exam.getAverageScore(),2)}')
  • 다중 상속 : 2개 이상의 클래스를 상속하는 것.
class Car01:

    def drive(self):
        print('drive() method called!!')

class Car02:

    def turbo(self):
        print('turbo() method called!!')

class Car03:

    def fly(self):
        print('fly() method called!!')

class Car(Car01,Car02,Car03):

    def __init__(self):
        pass

myCar = Car()
myCar.drive()
myCar.turbo()
myCar.fly()
class BasicCalculaotr:

    def add(self, n1, n2):
        return n1 + n2

    def sub(self, n1, n2):
        return n1 - n2

    def mul(self, n1, n2):
        return n1 * n2

    def div(self, n1, n2):
        return n1 / n2

class DeveloperCalculator:

    def mod(self, n1, n2):
        return n1 % n2

    def flo(self, n1, n2):
        return n1 // n2

    def exp(self, n1, n2):
        return n1 ** n2

class NewCalculator(BasicCalculaotr,DeveloperCalculator):

    def __init__(self):
        pass

cal = NewCalculator()

print(f'cal.add(10,20): {cal.add(10,20)}')
print(f'cal.sub(10,20): {cal.sub(10,20)}')
print(f'cal.mul(10,20): {cal.mul(10,20)}')
print(f'cal.div(10,20): {cal.div(10,20)}')

print(f'cal.mod(10,20): {cal.mod(10,20)}')
print(f'cal.flo(10,20): {cal.flo(10,20)}')
print(f'cal.exp(2,5): {cal.exp(2,5)}')

  • 다중 상속을 너무 남발하면 안됨. 꼭 필요할 때만 사용해야됨! 중복된 코드가 있으면 개발자 입장에서 헷갈릴 수 있으니깐!

  • 오버라이딩 : 메서드를 재정의 한다!

  • 오버라이딩 : 하위 클래스에서 상위 클래스의 메서드를 재정의(override)한다.

    출처:제로베이스

class Robot:

    def __init__(self,c,h,w):
        self.color = c
        self.height = h
        self.weight = w

    def fire(self):
        print('미사일 발사!!')

    def printRobotInfo(self):
        print(f'self.color: {self.color}')
        print(f'self.height: {self.height}')
        print(f'self.weight: {self.weight}')

class NewRobot(Robot):

    def __init__(self,c,h,w):
        super().__init__(c,h,w)

    def fire(self):
        print('레이저 발사!!') #오버라이딩

myRobot = NewRobot('red',200,300)
myRobot.printRobotInfo()
myRobot.fire()
  • 오버라이딩 연습문제

    출처:제로베이스
class TriangleArea:

    def __init__(self,w,h):
        self.width = w
        self.height = h

    def printTriangleAreaInfo(self):
        print(f'self.width: {self.width}')
        print(f'self.height: {self.height}')

    def getArea(self):
        return self.width * self.height / 2

class NewTriangleArea(TriangleArea):

    def __init__(self,w,h):
        super().__init__(w,h)

    def getArea(self):
        return str(super().getArea()) + '㎠'

ta = NewTriangleArea(7,5)
ta.printTriangleAreaInfo()
triangleArea = ta.getArea()
print(f'triangleArea : {triangleArea}')
  • 추상클래스 : 상위 클래스에서 하위 클래스에 메서드 구현을 강요한다.
  • 추상클래스를 쓰는 이유 : 어떠한 특정기능을 상속받았을 때 각자 알아서 입맞에 맞춰 고쳐 쓰기 위해 사용함.
  • 추상클래스를 만들기 위해선, 모듈을 abc패키지에서 모듈을 가져오고 메타클래스와 데코레이션을 선언을 해줘야함!

    출처:제로베이스
from abc import ABCMeta
from abc import abstractmethod

class AirPlane(metaclass=ABCMeta):

    @abstractmethod # 추상클래스
    def flight(self):
        pass

    def forward(self):
        print('전진!!')

    def backward(self):
        print('후진!!')

class Airliner(AirPlane):

    def __init__(self, c):
        self.color = c

    def flight(self):
        print('시속 400km/h 비행!!')

al = Airliner('red')
al.flight()
al.forward()
al.backward()

class fighterPale(Airliner):

    def __init__(self,c):
        self.color = c

    def flight(self):
        print('시속 700km/h 비행!!')

fl = fighterPale('blue')
fl.flight()
fl.forward()
fl.backward()

  • 예외란? 예상하지 못한 문제로 프로그램 실행이 어려운 상태.

  • 문법적인 문제는 없으나 실행 중 발생하는 예상하지 못한 문제.

    출처:제로베이스

  • 예외 관련 클래스는 Exception 클래스를 상속한다.

    출처:제로베이스

# 예외 예시 1
def add(n1, n2):
    print(n1 + n2)

def div(n1, n2):
    print(n1 / n2)

fn = int(input('input firstNum: '))
sn = int(input('input secondNum: '))

add(fn, sn)
div(fn, sn)

# 예외 예시 2
print(int('hello'))

# 예외 예시 3
lists = [1,2,3,4,5,6]
print(lists[6])

  • 예외 처리 : 예상하지 못한 예외가 프로그램 전체 실행에 영향이 없도록 처리함.

    출처:제로베이스

  • try~except : 예외 발생 예상 구문을 try~except로 감싼다.

n1 = 10; n2 = 0

try:
    print(n1 / n2)
except:
    print('예상치 못한 문제가 발생했습니다!')
    print('다음 프로그램이 정상 실행됩니다.')
print(n1 * n2)
print(n1 - n2)
print(n1 + n2)
nums = []

n = 1
while n<6 :
    try:
        num = int(input('input number: '))
    except:
        print('예외 발생!!')
        continue

    nums.append(num)
    n+=1

print(f'nums: {nums}')
  • try~except~else : 예외가 발생하지 않은 경우 실행하는 구문이다
nums = []
n = 1

while n < 6 :

    try:
        num = int(input('input number: '))
    except:
        print('예외 발생!!')
        continue
    else:
        if num % 2 == 0 :
            nums.append(num)
            n += 1
        else:
            print('홀수입니다.',end='')
            print('다시 입력하세요.')
            continue

print(f'nums: {nums}')
eveList = []; oddList= []; floatList = []

n = 1
while n < 6:

    try:
        num = float(input('input number: '))

    except:
        print('exception raise!!')
        print('input number again!!')
        continue

    else:
        if num - int(num) != 0:
            print('float number!')
            floatList.append(num)
        else :
            if num % 2 == 0:
                print('even number!')
                eveList.append(int(num))
            else :
                print('odd number!')
                oddList.append(int(num))

    n += 1

print(f'eveList: {eveList}')
print(f'oddList: {oddList}')
print(f'floatList: {floatList}')
  • finally : 예외 발생과 상관없이 항상 실행한다.
try :
    inputData = input('input number: ')
    numInt = int(inputData)
except:
    print('exception raise!!')
    print('not number!!')
else:
    if numInt % 2 == 0:
        print('even number!!')
    else:
        print('odd number!!')

finally:
    print(f'inputData: {inputData}')
evenList = []; oddList = []; floatList = []; dataList = []

n = 1
while n < 6 :

    try:
        data = input('input number: ')
        floatNum = float(data)

    except:
        print("exception raise!!")
        print('not number!!')
        continue

    else:
        if floatNum - int(floatNum) != 0:
            print('float number!!')
            floatList.append(floatNum)
        else:
            if floatNum % 2 == 0:
                print('even number!!')
                evenList.append(int(floatNum))
            else:
                print('odd nubmer!!')
                oddList.append(int(floatNum))
        n+=1
    finally:
        dataList.append(data)

print(f'evenList: {evenList}')
print(f'oddList: {oddList}')
print(f'floatList: {floatList}')
print(f'dataList: {dataList}')
  • Exception : 예외 담당 클래스
num1 = int(input('input number1: '))
num2 = int(input('input number2: '))

try :
    print(f'num1 / num2 = {num1 / num2}')
except Exception as e:
    print('0으로 나눌 수 없습니다.')
    print(f'exception: {e}')

print(f'num1 * num2 = {num1 * num2}')
print(f'num1 - num2 = {num1 - num2}')
print(f'num1 + num2 = {num1 + num2}')
  • raise 키워드를 이용하면 예외를 발생시킬 수 있음.
def divCalculator(n1, n2):


    if n2 != 0 :
        print(f'{n1} / {n2} = {n1/n2}')
    else:
        raise Exception('0으로 나눌 수 없습니다.')


num1 = int(input('input number1: '))
num2 = int(input('input number2: '))

try:
    divCalculator(num1, num2)
except Exception as e:
    print(f'Exception: {e}')
  • 사용자 예외 클래스 : Exception 클래스를 상속해서 사용자 예외 클래스를 만들 수 있다.
class NotUseZeroException(Exception):

    def __init__(self,n):
        super().__init__(f'{n}은(는) 사용할 수 없습니다.')

def divCalculator(n1, n2):

    if n2 == 0:
        raise NotUseZeroException(n2)
    else:
        print(f'{n1} / {n2} = {n1 / n2}')

num1 = int(input('input number1: '))
num2 = int(input('input number2: '))

try:
    divCalculator(num1,num2)
except NotUseZeroException as e:
    print(e)
  • 사용자 예외 클래스 연습문제

    출처:제로베이스
class PasswordLengthShortException(Exception):

    def __init__(self,str):
        super().__init__(f'{str}: 길이 5미만!!')

class PasswordLengthLongException(Exception):

    def __init__(self,str):
        super().__init__(f'{str}: 길이 10초과!!')

class PasswordWrongException(Exception):

    def __init__(self,str):
        super().__init__(f'{str}: 잘못된 비밀번호!!')

adminPw = input('input admin password: ')

try:
    if len(adminPw) < 5:
        raise PasswordLengthShortException(adminPw)
    elif len(adminPw) > 10:
        raise PasswordLengthLongException(adminPw)
    elif adminPw != 'admin1234' :
        raise PasswordWrongException(adminPw)
    elif adminPw == 'admin1234' :
        print('빙고!!')


except PasswordLengthShortException as e1:
    print(e1)

except PasswordLengthLongException as e2:
    print(e2)

except PasswordWrongException as e3:
    print(e3)
  • open(),read(),write(),close()를 이용하여 텍스트 파일을 다룰 수 있음.

    출처:제로베이스
file = open('C:/pythonTxt/test.txt', 'w') # 파일이 없으면 파일을 새로생성함.

strCnt = file.write("Hello world!")
print(f'strCnt: {strCnt}')

file.close()
  • 파일 작성 연습문제
    -> 시스템 시간과 일정을 텍스트 파일에 작성해 보자.
import time

lt = time.localtime()

dateStr = '[' + str(lt.tm_year) + '년 ' + \
          str(lt.tm_mon) + '월 ' + str(lt.tm_mday) + '일] '

todaySchedule = input('오늘 일정: ')

file = open('C:/pythonTxt/test.txt', 'w')
file.write(dateStr + todaySchedule)
file.close()
  • read() 함수를 이용하여 파일 문자열을 읽을 수 있음.
file = open('C:/pythonTxt/test.txt', 'r')

str = file.read()
print(f'str: {str}')
file.close()
  • 파일 읽기 연습 문제

    출처:제로베이스
file = open('C:/pythonTxt/about_python.txt', 'r')
# 파일 안열리면 'UTF-8로 인코딩하면됨'file = open('C:/pythonTxt/about_python.txt', 'r', encoding='UTF8')

str = file.read()
print(f'str: {str}')

file.close()

str = str.replace('Python','파이썬',2) # Python -> 파이썬으로 2개만
print(f'str: {str}')

file = open('C:/pythonTxt/about_python.txt', 'w')
file.write(str)
file.close()
  • 파일 모드는 파일을 어떤 목적으로 open 할지 정함.
  • 'w' 쓰기 전용(파일이 있으면 덮어 씌움)
  • 'a' 쓰기 전용(파일이 있으면 덧붙임)
  • 'x' 쓰기 전용(파일이 있으면 에러 발생)
  • 'r' 읽기 전용(파일이 없으면 에러 발생)
uri = 'C:/pythonTxt/'

# 'w' 파일 모드
# file = open(uri + 'hello.txt', 'w')
# file.write('Hello python!!')
# file.close()

# 'a' 파일 모드
# file = open(uri + 'hello.txt', 'a')
# file.write('\nNice to meet you!!')
# file.close()

# 'x' 파일 모드
# file = open(uri + 'hello_01.txt', 'x')
# file.write('\nNice to meet you!!')
# file.close()

# 'r' 파일 모드
# file = open(uri + 'hello_01.txt', 'r')
# str = file.read() # 무조건 문자열로 처리됨
# print(f'str: {str}')
# file.close()
  • 파일 모드 연습문제
    -> 사용자가 입력한 숫자에 대한 소수를 구하고 이를 파일에 작성해보자.
uri = 'C:/pythonTxt/'

def writePrimeNumber(n):

    file = open(uri + 'prime_numbers.txt', 'a')
    file.write(str(n))
    file.write('\n')
    file.close()

inputNumber = int(input('0보다 큰 정수 입력: '))

for number in range(2, (inputNumber+1)) :
    flag = True
    for n in range(2, number):
        if number % n == 0:
            flag = False
            break
    if flag:
        writePrimeNumber(number)
  • with ~as문을 이용하면 파일 닫기(close)를 생략할 수 있음.
uri = 'C:/pythonTxt/'

# file = open(uri + '5_037.txt', 'a')
# file.write('python study!!')
# file.close()

# file = open(uri + '5_037.txt', 'r')
# print(file.read())
# file.close()

with open(uri + '5_037.txt', 'a') as f:
    f.write('python study!!')

with open(uri + '5_037.txt', 'r') as f:
    print(f.read())
  • with~as문 연습문제
    -> 로또 번호 생성기 프로그램을 만들고 파일에 번호를 출력해 보자.
import random

uri = 'C:/pythonTxt/'

def writeNumbers(nums):
    for idx, num in enumerate(nums):
        with open(uri + 'lotto.txt', 'a') as f:
            if idx < len(nums) -2:
                f.write(str(num) + ', ')
            elif idx == len(nums) -2:
                f.write((str(num)))
            elif idx == len(nums) -1:
                f.write('\n')
                f.write('Bonus: ' + str(num))
                f.write('\n')

rNums = random.sample(range(1,46), 7)
print(f'rNums: {rNums}')

writeNumbers(rNums)
  • writelines()는 리스트(List)또는 튜플 데이터를 파일에 쓰기 위한 함수이다.
languages = ('c/c++', 'java', 'c#', 'python', 'javascript')

uri = 'C:/pythonTxt/'
# for item in languages:
#     with open(uri + 'languages.txt', 'a' ) as f:
#         f.write(item)
#         f.write('\n')


with open(uri + 'languages.txt', 'a' ) as f:
    f.writelines(item + '\n' for item in languages)

with open(uri + 'languages.txt', 'r' ) as f:
    print(f.read())
  • wrtielines() 연습문제
    -> 딕셔너리에 저장된 과목별 점수를 파일에 저장하는 코드를 작성하자.
uri = 'C:/pythonTxt/'

scoreDic = {'kor' : 85, 'eng': 90, 'mat': 92, 'sci': 79, 'his': 82}
for key in scoreDic.keys():
    with open(uri + 'scoreDic.txt', 'a') as f:
        f.write(key + '\t:' + str(scoreDic[key]) + '\n')
# 딕셔너리, 리스트 자체를 저장하고 싶을 때
uri = 'C:/pythonTxt/'
scoreList = [84,68,97,67,57]
scoreDic = {'kor' : 85, 'eng': 90, 'mat': 92, 'sci': 79, 'his': 82}
with open(uri+ 'scores.txt', 'a') as f:
    print(scoreList, file=f)
  • readlines() : 파일의 모든 데이터를 읽어서 리스트 형태로 반환함.
  • reaedline() : 한 행을 읽어서 문자열로 반환함.
uri = 'C:/pythonTxt/'

# with open(uri + 'lans.txt', 'r') as f:
#     lanList = f.readlines()
#
# print(f'lanList: {lanList}')
# print(f'lanList type: {type(lanList)}')

with open(uri + 'lans.txt', 'r') as f:
    line = f.readline()

    while line != '':
        print(f'line: {line}', end='')
        line = f.readline()
  • readline() 연습문제
    -> 파일에 저장된 과목별 점수를 파이썬에서 읽어, 딕셔너리에 저장하는 코드를 만들어보자.
scoreDic = {}
uri = 'C:/pythonTxt/'

with open(uri + 'scores.txt', 'r') as f:
    line = f.readline()


    while line != '' :
        tempList = line.split(':')  # 구분자를 정해주면 구분자를 기준으로 리스트로 분류해줌
        scoreDic[tempList[0]] = int(tempList[1].strip('\n')) # 매개변수에 특정한 값을 넣으면 그 값을 없앰
        line = f.readline()

print(f'scoreDic: {scoreDic}')
profile
임동혁
데이터분석 지망생
이전 포스트

[제로베이스] 데이터취업스쿨 11기_5주차

0개의 댓글