12시 30분이 고비다. 감기는 다 나은것 같은데 기침은 오지게 나온다. 요즘 회사에서 에너지드링크 없음 못버틸 정도로 몸이 무겁다. 요번주는 사실 너므너므 딴짓만 하고싶다. ㅠㅠㅠ

🔥 3주차 todo 리스트 (5/15~5/21)

파이썬 (중급문풀 5) 파이썬 (중급문풀 67) 파이썬 (중급문풀 8) 기초수학 (기초 12) 기초수학 (기초 3) 기초수학 (기초 4) 기초수학 (기초 56)~
기초수학 (기초 7) 기초수학 (기초 1) 기초수학 (기초 2) 기초수학 (기초문풀 1) 기초수학 (기초문풀 23) 자료구조/알고리즘 (자료구조 1~2) 자료구조/알고리즘 (자료구조 3) 자료구조/알고리즘 (자료구조 4)

📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 진법이란?

• 특정 숫자 몇개를 사용하여 수를 표시하는 방법
  

10진수 →

binary : bin() → 2진수

print('2진수: {}'.format(bin(dNum)))

octal : oct() → 8진수

print('8진수: {}'.format(oct(dNum)))

Haxadecimal : hex() → 16진수

print('16진수: {}'.format(hex(dNum)))

• 10진수를 X진수로 변환 : format()함수

  print('2진수: {}'.format(format(dNum,'#b')))
  print('8진수: {}'.format(format(dNum, '#o')))
  print('16진수: {}'.format(format(dNum, '#x')))
  

print('Type of bin(dNum): {}'.format(type(format(dNum,'#b')))) print('Type of oct(dNum): {}'.format(type(format(dNum,'#o')))) print('Type of hex(dNum): {}'.format(type(format(dNum,'#x'))))

<br/>

- X진수를 10진수로 변환 : format()함수
```python
print('2진수(0b11110) -> 10진수({})'.format(int('0b11110',2)))
print('8진수(0o36) -> 10진수({})'.format(int('0o36',8)))
print('16진수(0x1e) -> 10진수({})'.format(int('0x1e',16)))

• X진수를 X진수로 변환 : format()함수

  print('2진수(0b11110) -> 8진수({})'.format(oct(0b11110)))
  print('2진수(0b11110) -> 10진수({})'.format(int(0b11110)))
  print('2진수(0b11110) -> 16진수({})'.format(hex(0b11110)))
  

print('8진수(0o36) -> 2진수({})'.format(bin(0o36))) print('8진수(0o36) -> 10진수({})'.format(int(0o36))) print('8진수(0o36) -> 16진수({})'.format(hex(0o36)))

print('16진수(0x1e) -> 2진수({})'.format(bin(0x1e))) print('16진수(0x1e) -> 8진수({})'.format(oct(0x1e))) print('16진수(0x1e) -> 10진수({})'.format(int(0x1e)))

<br/>

#### 📝 수열이란?
- 규칙성을 가지고 나열되어 있는 수들.

> an = 일반항

<br/>

#### 📝 항들의 합과 항의 관계
- 특정항은 특정항까지의 합에서 특정항 이전의 항까지의 합과 같다

> an = sn -s(n-1)
`단, n >= 2 / a1 = s1`

<br/>

#### 📝 등차수열
- 연속된 두 항의 차이가 일정한 수열

> 등차수열 ( 일반항 ) 공식
an = a1 + (n-1) * d 
`d = 공차`

> 등차수열 ( 합 ) 공식
sn = n (a1+an) / 2

<br/>

#### 📝 등차중항
- 연속된 세 항에서 가운데 항
<br/>

#### 📝 등비수열
- 연속된 두 항의 비가 일정한 수열
- 등비수열 규칙성을 이용해서 일반항을 구할 수 있다.

> 등비수열 (일반항) 공식
an = a1 * r^(n-1)
`r = 공비`

> 등비수열 (합) 공식
sn = a1 * (1-(r^n) / (1-r)

<br/>

#### 📝 등차중항
- 연속된 세 항에서 가운데 항
- 연속되는 세 항 중 가운데 항은 가운데 항의 거듭제곱과 앞, 뒤로 나란한 항 두개를 곱한 것과 같다.
<br/>

`실습_02`
```python
# 등비수열

# n번째까지 항의 값을 출력 : 일반항
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

valueN = 0

n = 1    # 무한루프 방지
while n <= inputN:

    if n ==1:
        valueN = inputN1
        print('{}번째 항의 값: {}'.format(n, valueN))
        n += 1       # 무한루프 방지
        continue

    valueN *= inputR
    print('{}번째 항의 값: {}'.format(n, valueN))
    n += 1


# n번째 항의 값을 출력 : 일반항(공식이용)
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

# an = a1 * r^(n-1)
valueN = inputN1 * (inputR ** (inputN - 1))
print('{}번째 항의 값: {}'.format(inputN, valueN))

# n번째까지 항의 값의 합을 출력 : 항들의 합(반복문)
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

valueN = 0  # n번째까지의 값을 모르기 때문에 0
sumN = 0    # n번째까지의 합도 모르기 때문에 0
n = 1   # while문 이용으로 무한루프 방지
while n <= inputN:

    if n == 1:
        valueN = inputN1
        sumN += valueN
        # print('{}번째 항까지의 합 : {}'.format(n, sumN))
        n += 1    # 무한 루프 방지
        continue   # 계속실행 : 처음으로 돌아가기

    valueN = valueN * inputR   # a1(첫항) * 사용자가 입력한 공비 = a2항
    sumN = sumN + valueN    # a2항까지의 합
    # print('{}번째 항까지의 합 : {}'.format(n, sumN))
    n += 1

print('{}번째 항까지의 합 : {}'.format(inputN, sumN))


# n번째 항까지의 값의 합을 출력  : 항들의 합(공식)
inputN1 = int(input('a1 입력: '))
inputR = int(input('공비 입력: '))
inputN = int(input('n 입력: '))

# sn = a1 * (1 - r^n) / (1-r)
sumN = inputN1 * (1 - (inputR ** inputN)) / (1 - inputR)
print('{}번째 항까지의 합 : {}'.format(inputN, int(sumN)))

📝 계차수열

• 어떤 수열의 인접하는 두 항의 차로 이루어진 또 다른 수열
  

실습_03

# 계차수열
# an = {3, 7, 13, 21, 31, 43, 57}
# bn = {4, 6, 8, 10, 12, 14}

inputAN1 = int(input('a1 입력: '))
inputAN = int(input('an 공차 입력: '))

inputBN1 = int(input('b1 입력: '))
inputBN = int(input('bn 공차 입력: '))

valueAN = 0
valueBN = 0

n = 1
while n <= inputAN:
    if n == 1:
        valueAN = inputAN1
        valueBN = inputBN1
        print('an의 {}번째의 항의 값: {}'.format(n,valueAN))
        print('bn의 {}번째의 항의 값: {}'.format(n,valueBN))
        n += 1
        continue

    valueAN = valueAN + valueBN
    valueBN = valueBN + inputBN
    print('an의 {}번째의 항의 값: {}'.format(n, valueAN))
    print('bn의 {}번째의 항의 값: {}'.format(n, valueBN))
    n += 1

print('an의 {}번째의 항의 값: {}'.format(inputAN, valueAN))
print('bn의 {}번째의 항의 값: {}'.format(inputAN, valueBN))


# n^2 + n + 1 = an
valueAN = inputAN ** 2 + inputAN + 1
print('an의 {}번째 항의 값: {}'.format(inputAN, valueAN))

📝 피보나치 수열

• 세번째 항은 두번째 항과 첫번째 항을 더한 합이다.
  

실습_04

inputN = int(input('n 입력: '))

valueN = 0
sumN = 0

valuePreN2 = 0
valuePreN1 = 0

n = 1
while n <= inputN:
    if n == 1 or n == 2:
        valueN = 1
        valuePreN2 = valueN
        valuePreN1 = valueN
        sumN += valueN
        n += 1

    else:
        valueN = valuePreN2 + valuePreN1
        valuePreN2 = valuePreN1
        valuePreN1 = valueN
        sumN += valueN
        n += 1

print('{}번째 항의 값: {}'.format(inputN, valueN))
print('{}번째 항까지의 합: {}'.format(inputN, sumN))

📝 팩토리얼

• 1부터 양의 정수 n까지의 정수를 모두 곱한것
  

실습_05

inputN = int(input('n 입력: '))

result = 1
for n in range(1, inputN+1):
    result *= n

print('{} 팩토리얼: {}'.format(inputN, result))


result = 1
n = 1
while n <= inputN:
    result *= n
    n += 1

print('{} 팩토리얼: {}'.format(inputN, result))



def factorialFun(n):
    if n == 1: return 1

    return n * factorialFun(n - 1)

print('{} 팩토리얼: {}'.format(inputN, factorialFun(inputN)))



import math
math.factorial(inputN)

print('{} 팩토리얼: {}'.format(inputN, math.factorial(inputN)))

💡 오늘을 마무리하면서 ...

나 진짜 수학 못하는데 무조건 이해 할때까지 들어봐야겠다 이쯤되면 컴퓨터 과목도 어느 정도는 외우는 암기과목인것 같은 느낌적인 느낌....

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

🔥 3주차 todo 리스트 (5/15~5/21)

파이썬 (중급문풀 5) 파이썬 (중급문풀 67) 파이썬 (중급문풀 8) 기초수학 (기초 12)
기초수학 (기초 3) 기초수학 (기초 4) 기초수학 (기초 56) 기초수학 (기초 7) 기초수학 (기초 1) 기초수학 (기초 2) 기초수학 (기초문풀 1) 기초수학 (기초문풀 23) 자료구조/알고리즘 (자료구조 1~2) 자료구조/알고리즘 (자료구조 3) 자료구조/알고리즘 (자료구조 4)

📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 약수

• 어떤 수를 나누어 떨어지게 하는 수 나머지가 나오면 약수가 아니다.

실습_01

파이썬을 이용해서 사용자가 입력한 숫자의 약수를 출력해보자.

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

for number in range(1, inputNumber + 1):
    if inputNumber % number == 0:
        print('{}의 약수: {}'.format(inputNumber, number))

📝 소수

• 1과 자신만을 약수로 가지는 수 1과 본인 자신의 수 밖에 없다.
  

실습_02

파이썬을 이용해서 사용자가 입력한 숫자까지의 소수를 출력해보자.

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:
        print('{} : 소수!!'.format(number))
    else:
        print('{} : \t\t 합성수!!'.format(number))

📝 소인수

• 약수(인수)중에서 소수인 숫자를 소인수라고 한다.

12의 소인수? 1, 2, 3, 4, 6, 12

📝 소인수분해

• 1보다 큰 정수를 소인수의 곱으로 나타낸 것을 소인수 분해라고 한다.

20의 소인수 분해? 2^2 x 5 = ( 2 x 2 x 5)

📝 소인수분해와 약수

• 소인수 분해를 이용해서 약수를 정확하고 쉽게 구할 수 있다.

20의 소인수 분해? 1, 2, 4, 5, 10, 20

실습_03

파이썬을 이용해서 사용자가 입력한 수를 소인수분해하자.

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

n = 2
while n <= inputNumber:
    if inputNumber % n ==0:
        print('소인수: {}'.format(n))
        inputNumber /= n
    else:
        n += 1

📝 최대공약수

• 두개 이상의 수에서 공통괸 약수를 공약수라고 한다.
• 소인수분해를 이용하면 최대공약수 및 공약수를 구할 수 있다. 공통인 소인수의 거듭제곱에서 지수가 작은 수를 모두 곱한다.
• 좀더 편리하게 최대공약수를 구하는 방법 → 소수로 나눗셈을 하자! 나눠지지 않을때까지 나누기

12와 20의 공약수? 1,2,4 (4의 약수)

실습_04

두개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드를 작성하자.

num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
maxNum = 0

for i in range(1, (num1 +1)):
    if num1 % i == 0 and num2 % i == 0:
        print('공약수: {}'.format(i))
    maxNum = i

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

📝 유클리드 호제법

• 유클리드 호제법을 이용해서 최대공약수를 구할 수 있다. x, y의 최대공약수는 y, r(x % y) 나머지가 0 일때까지 나눗셈한다.
  

실습_05

유클리드 호제법을 이용해서 최대공약수를 구할수 있다.

num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))

temp1 = num1; temp2 = num2

while temp2 > 0:
    temp = temp2
    temp2 = temp1 % temp2
    temp1 = temp

print('{}, {}의 = 최대공약수: {}'.format(num1, num2, temp1))

for n in range(1, (temp1 + 1)):
    if temp1 % n == 0:
        print('{}, {}의 공약수: {}'.format(num1, num2, n))

📝 공배수

• 두개 이상의 수에서 공통된 배수를 공배수라고 한다.

3, 5의 배수 15,30....

📝 최소공배수

• 공배수 중 가장 작은 수를 최소공배수라고 한다.
• 소인수분해를 이용하면 최소공배수 및 공배수를 구할 수 있다.
• 좀 더 편리하게 최소공배수 구하는 방법 → 소수로 나눗셈하자.
  

실습_06

두개의 수를 입력하면 최소공배수를 출력하는 코드를 작성하자.

num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
maxNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i == 0 and num2 % i ==0:
        print('공약수: {}'.format(i))
        maxNum = i

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

minNum = (num1 * num2) // maxNum
print('최소공배수: {}'.format(minNum))

실습_07

세개의 수를 입력하면 최소공배수를 출력하는 코드를 작성하자.

num1 = int(input('1보다 큰 정수 입력: '))
num2 = int(input('1보다 큰 정수 입력: '))
num3 = int(input('1보다 큰 정수 입력: '))
maxNum = 0

for i in range(1, (num1 + 1)):
    if num1 % i == 0 and num2 % i ==0:
        print('공약수: {}'.format(i))
        maxNum = i

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

minNum = (num1 * num2) // maxNum
print('최소공배수: {}'.format(minNum))

newNum =minNum
for i in range(1, (newNum + 1)):
    if newNum % i == 0 and num3 % i == 0:
        maxNum

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

minNum = (newNum * num3) // maxNum
print('{}, {}, {}의 최소공배수: {}'.format(num1, num2, num3, minNum))

실습_08

섬마을에 과일, 생선, 야채를 판매하는 배가 다음 주기로 입할한다고 할떄, 모든 배가 입항하는 날짜를 계산해보자.

과일 선박: 3일주기
생선 선박: 4일주기
야채 선박: 5일주기

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

💡 오늘을 마무리하면서 ...

진짜 인풋이 제대로 되고 있는건지 모르곘다 ㅠㅠ 머리 터질 것만 같아

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

🔥 3주차 todo 리스트 (5/15~5/21)

파이썬 (중급문풀 5) 파이썬 (중급문풀 67) 파이썬 (중급문풀 8)~
기초수학 (기초 12) 기초수학 (기초 3) 기초수학 (기초 4) 기초수학 (기초 56) 기초수학 (기초 7) 기초수학 (기초 1) 기초수학 (기초 2) 기초수학 (기초문풀 1) 기초수학 (기초문풀 23) 자료구조/알고리즘 (자료구조 1~2) 자료구조/알고리즘 (자료구조 3) 자료구조/알고리즘 (자료구조 4)
📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💡 오늘을 마무리하면서 ...

오늘은 중급문풀 나머지를 공부했다. 예외처리도 쉽지 않고 머릿속에 잘 들어오는것 같지도 않고 ㅠㅠ 미쳐버리겠다. ㅠㅠ 코드를 따라 쓰는건 좋은데 일단 내가 영타속도가 어엄청 느리니까 진짜 수업진도가 너무너무 느려서 공부방법을 바꿧다. 종이에다가 코딩한다 생각하고 노트 필기로 바꿨더니 진짜 세상편하다. (마음이 편한건가?? ㅠㅠ) 그동안 문제 풀이 밀려서 너무 기억이 잘 안나서 강좌 다시 듣기 하면서 마무리 수업을 들었다. 아직 나는 부족하다. 마의 코딩테스트가 두려워졌다. ㅠㅠ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

🔥 2주차 todo 리스트 (5/7~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 파이썬 중급2 파이썬 중급3 파이썬 중급4 파이썬 중급56 파이썬 중급7 파이썬 중급89 파이썬 중급문풀12 파이썬 중급문풀3 파이썬 중급문풀4~~

📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

🏅 문제풀이

실습_01

수입과  공과금을  입력하면  공과금  총액과  수입  대비  공과금  비율을  계산하는 
모듈을  만들어보자.

# 모듈파일
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, ',')

# 실행파일
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()}%')

실습_02

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

# 클래스
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]}')


# 실행파일
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()

실습_03

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

# 클래스
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()

# 실행파일
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()

실습_04

명세서를 참고해서 도서관리 프로그램을 만들어 보자.

# 클래스
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()

 # 실행파일
 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()

실습_05

추상 클래스를 이용해서 한/영, 영/한 사전클래스를 만들어보자.

#클래스
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()


# 실행파일
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()

실습_06

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

#클래스
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()


#실행파일
import dice

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

💡 오늘을 마무리하면서 ...

정리가 정말 오래 걸렸고 이해 하기 까지가 엄청 오래 걸렸다. 근데 하나도 이해 안감 ㅠㅠ 소스하나하나 쪼개봐야할듯요 ㅠㅠ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

몸이 아직 회복중인지 정말이지 집중하기가 힘들다. 머리에 안들어오는 중급파이썬도 내 건강에 영향을 미치는 것인지 머리랑 어깨가 엄청 무겁다. ㅠㅠ

🔥 2주차 todo 리스트 (5/7~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 파이썬 중급2 파이썬 중급3 파이썬 중급4 파이썬 중급56~ ~파이썬 중급7~ ~파이썬 중급89 파이썬 중급문풀12~~ 파이썬 중급문풀3 파이썬 중급문풀4

📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

🏅 문제풀이

실습_01

다음과 같이 출력될수 있도록 이동거리와 이동시간을 반환하는 함수를 만들어보자.

def getDistance(speed, hour, minute):
    ditance = speed * (hour + minute / 60)
    return ditance

#100:75 = 60:x  -->  75*60 /100
def getTime(speed, distence):
    time = distence / 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) 입력: '))
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)

실습2

다음과  같이  출력  될  수  있도록  비행기  티켓  영수증  출력  함수를  만들어  보자.

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


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

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

    cp = c1 * childPrice
    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'소아 할인 대상 {i1}명 요금: {formatedNumber(ip_dc)}원')

    ap = a1 * adultPrice
    ap_dc = int(a2 * adultPrice * 0.5)
    print(f'성인{a1}명 요금 : {formatedNumber(ap)}원')
    print(f'성인 할인 대상 {a2}명 요금: {formatedNumber(ap_dc)}원')

    print(f'total: {formatedNumber(c1 + c2 + i1 + i2 + a1 + a2)}명')
    print(f'TotalPrice: {formatedNumber(cp + cp_dc + ip + ip_dc + ap + ap_dc)}원')

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

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

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

printAirPlaneReceipt(childCnt, specialDCChildCnt,
                     infantCnt, specialDCInfanCnt, adultCnt,
        specialDCadultCnt )

실습_03

다음과  같이  출력  될  수  있도록  재귀함수를  이용해서  팩토리얼    함수를  만들어보자.

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

def recursionFun(n):

    if n == 1:
        return n

    return n * recursionFun(n-1)

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

실습_04

다음과  같이  출력  될  수  있도록  단리/월복리  계산기  함수를  만들어보자.

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

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):
    y = 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(f'{term}년 후 총 수령액 : {formatedNumber(singleRatecalculator(money, term, rate))}')

print('[월복리 계산기]')
print(f'{term}년 후 총 수령액 : {formatedNumber(multiRateCalculator(money, term, rate))}')

실습_05

다음과  같이  출력  될  수  있도록  등차  수열의  n번째  값과  합을  출력하는  함수를 
만들어보자.

def sequencecal(n1, d, n):

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

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

            i += 1
            continue

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

        i += 1


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

sequencecal(inputN1, inputD, inputN)

실습_06

다음과  같이  출력  될  수  있도록  등비  수열의  n번째  값과  합을  출력하는  함수를 
만들어보자

def sequencecal(n1, r, n):

    valueN = 0; sumN = 0;

    i = 1
    while i <= n:

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

            i += 1
            continue

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

        i += 1


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

sequencecal(inputN1, inputR, inputN)

실습_07

과목별  점수를  입력하면  합격  여부를  출력하는  모듈을  만들어보자. 
(평균  60이상  합격, 과락  40으로  한다.)

# 모듈파일
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()


#실행파일
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)

실습_08

상품  구매  개수에  따라  할인율이  결정되는  모듈을  만들고, 다음과  같이  계산  결과가 
출력되는  프로그램을  만들어보자.

# 모듈파일
def calculartorTotalPrice(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, ',')


# 실행파일
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.calculartorTotalPrice(gs)
            flag = False

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

실습_09

로또  모듈을  만들고  다음과  같이  로또  결과가  출력될  수  있도록  프로그램을 
만들어보자.


# 모듈파일
import random

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

def setUserNums(ns):
    global userNums
    userNums = ns

def getUserNums():
    return randNums
    randNums = random.sample(range(1, 46), 6)

def getRandNum():
    return randNums

def setBonuNum():
    global randBonuNum

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

def getBonuNum():
    return randBounNum

def lottoResult():
    global userNums
    global randNums
    global collNums

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

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

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

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

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

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

    else:
    print('아쉽습니다. 다음 기회에~')
    print(f'기계 번호 : {randNums}')
    print(f'보너스 번호: {randBonuNums}')
    print(f'선택 번호: {userNums}')
    print(f'일치 번호: {collNums}')


def startLotto():
    n1 = int(input('번호(`1~46 입력: '))
    n2 = int(input('번호(`1~46 입력: '))
    n3 = int(input('번호(`1~46 입력: '))
    n4 = int(input('번호(`1~46 입력: '))
    n5 = int(input('번호(`1~46 입력: '))
    n6 = int(input('번호(`1~46 입력: '))
    selectNums = [n1, n2, n3, n4, n5, n6]

    setUserNums(selectNums)
    setRandNums()
    setBonuNum()

    lottoResult()


#실행파일
import lotto as lt

lt.startLotto()

실습_10

순열  계산  모듈을  만들고  다음  순열  계산  결과를  출력해  보자.
#모듈파일
def getPermutaionCnt(n, r):

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

    return result

#실행파일

import permutation as pt

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

print(f'{numN}P{numR}: {pt.getPermutaionCnt(numN,numR)}')


#모듈파일
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


#실행파일
import permutation as pt

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

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

실습_11

   조합  계산  모듈을  만들고  다음  조합  계산  결과를  출력해  보자.

#모듈파일
def getCombinationCnt(n, r):

    resultP = 1
    resultR = 1
    resultC = 1

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


    for n in range(r, 0, -1):
        resultR = resultR * n

    resultC = int(resultP / resultR)

    return resultC

#실행파일
import combination as ct

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

print(f'{numN}C{numR}: {ct.getCombinationCnt(numN, numR)}')

💡 오늘을 마무리하면서 ...

몸이 무리데쓰네.. 이해는 도무지 안된다. 정상이라는 걸 강조 하니까 열심히 걍 외우는데 맞는가 모르겠다.

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

단기간에 뛰어난 프로그래머가 되려고 하면 절대 성공할 수 없느니라. 웹서핑하다가 본 글...

저질체력인 나에게는 너무 힘든 싸움이다 ㅠㅠ 몸이 아프니까 노트북도 느릿느릿 버벅이고 아픈것 같은 느낌

그럼에도 불구하고...

오늘도 힘내자 !!

🔥 2주차 todo 리스트 (5/8~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 파이썬 중급2 파이썬 중급3 파이썬 중급4 파이썬 중급56~ ~파이썬 중급7~ 예외처리 tryexceptelse finally Excepption 클래스 ~파이썬 중급89 사용자 Exception 클래스 텍스트 파일 쓰기 텍스트 파일 읽기 텍스트 파일 열기 with ~as문 writelines() readlines(), readline()

파이썬 중급문풀1~2 파이썬 중급문풀3 파이썬 중급문풀4

📝 weekly 데이터 사이언스 스쿨 퀴즈 📝 재복습weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 예외란?

• 문법적인 문제는 없으나 실행 중 발생하는 예상치 못한 문제이다.
• 예외 관련 클래스는 인셉션 (Excepion) 클래스를 상속한다.
  

📝 예외처리

• 예상하지 못한 예외가 프로그램 전체에 영향이 없도록 처리하는 것
• 발생한 예외에 대해서 별도 처리한다.
• 예외 발생 예상 구문을 try ~ except 로 감싼다.
• 예외가 발생 하지 않은 경우에는try ~ except ~ else로 마무리 한다.
  

실습_01

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

# 예외가 발생 할 것 같은 구문

nums = []

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

    nums.append(num)
    n += 1

print(f'nums: {nums}')



# 예외가 발생하지 않은 경우 실행하는 경우

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

📝 Finally()

• 예외 발생과 상관없이 무조건 실행할때 항상 실행한다. 외부자원을 가지고 작업을 할때, 자원 해제를 하는 경우
  

예시

try:
    inputData = input('input number: ')
    numInt = int(inputData)
except:
    print('excception raise!!')
    print('not number!!')
else:
    if numInt % 2 == 0:
        print('even number!!')
    else:
        print('odd number')
finally:
    print(f'putData: {inputData}')

실습_02

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

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(int(floatNum))
        else:
            if floatNum % 2 == 0:  # 짝수
                print('even number!!')
                evenList.append(int(floatNum)
            else:    # 홀수
                print('odd number!!')
                oddList.append(floatNum)

        n += 1

    finally:
        dataList.append(data)


print(f'evenList: {evenList}')
print(f'oddList: {oddList}')
print(f'floatList: {floatList}')
print(f'dataList: {dataList}')

📝 Exception (인셉션) 클래스

• 예외담당 클래스라고 이해하자.
• Exception 클래스를 상속해서 사용자 Exception (인셉션) 클래스를 만들 수 있다

예시

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

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

print(f'num1 * num2 = {num1 * num2}')
print(f'num1 - num2 = {num1 - num2}')
print(f'num1 + num2 = {num1 + num2}')

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 키워드

• 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:'))
divcalculator(num1, num2)

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

실습_03

사용자가 문자메세지를 보낼대 10글자 이하면 SMS로 발송하고, 10글자를 초과하면 MMS로 발송하는 프로그램을 예외 처리를 이용해서 만들어 보자.

def sendSMS(msg):

    if len(msg) > 10:
        raise Exception('길이초과!! MMS전환 후 발송!!', 1)
    else:
        print('SMS 발송!!')

def sendMMS(msg):
    if len(msg) <= 10:
        raise Exception('길이 미달!! SMS전환 후 발송!!', 2)
    else:
        print('MMS 발송!!')

msg = input('input message: ')

try:
    sendSMS(msg)
except Exception as e:
    print(f'e: {e.args[0]}')
    print(f'e: {e.args[1]}')

    if e.args[1] == 1:
        sendMMS(msg)
    elif e.args[1] == 2:
        sendSMS(msg)

📝 텍스트 파일

• open() 파일 열기
• read() 읽기
• write() 쓰기
• close() 파일 닫기
  

# 쓰기모드 : write()   /  W
- 기존의 문자는 없애고, 새로운 문자로 대치한다.
- 해당하는 파일이 없으면 새로 생성, 있으면 열린다.

file = open('c:pythonTxt/test.txt', 'w')

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

fille.close()

# 읽기모드 : read() 읽기  /  R 
- 숫자로 읽던 문자로 읽던 무조건 문자열로 불러온다.

file = open('c:pythonTxt/test.txt', 'r')

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

fille.close()

실습_04

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

import time

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

dateStr = '[' + time.strftime('%Y-%m-%d %I:%M:%S %p') + ']'
todaySchedule = input('오늘 일정: ')

file = open('C:/pythonTxt/test.txt', 'w')
file.write(dateStr + todaySchedule)
file.close()

실습_05

file = open('C:/pythonTxt/about_python.txt', 'r', encoding='UTF8')

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

str = str.replace('Python', '파이썬', 2)  # 영문을 한글로 바꿈: 총 3개의 영문에서 2개만 바꾼다.
print(f'str: {str})

file = open('C:/pythonTxt/about_python.txt', 'w')
file.write(str)
file.close()

📝 파일모드

파일 모드는 파일을 어떤 목적으로 open할지 정한다

• W : 쓰기 전용(파일이 있으면 덮어씌움/삭제됨)
• a : 쓰기 전용(파일이 있으면 덧붙임/삭제안됨)
• x : 쓰기 전용(파일이 잇으면 에러발생)
• r : 읽기 전용(파일이 없으면 에러발생)
  

실습_06

uri ='C:/pythonTxt/'

def writePrimeNumber(n):
    file = open(uri + 'prime_number.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문

• file.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()

uri = 'C:/pythonTxt/'

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

실습_07

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

import random

uri = 'C:/pythonTxt/'

def writeNumber(nums):
    for idx, num in enumerate(nums):
        with open(uri + 'lotto.txt', 'a') as f:
            if idx < (len(nums) - 2):
                f.write(str(nums) + ', ')
            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}')

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

languages = ['C/C++', 'java', 'c#', 'python', 'javascript']

uri = 'C:/pythonTxt/'

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()) # 콘솔창에서 읽기

실습_08

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

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


print(scoreDic, file=f)  # 입력된 리스트 통째로 가져오는 코드

📝 텍스트파일: _readlines(), readline()

readlines() 파일의 모든 데이터를 읽어서 리스트 형태로 반환한다. readline() 한 행을 읽어서 문자열로 반환한다.

💡 오늘을 마무리하면서 ...

와 진짜 거짓말 안하고 5번은 본 것 같은 왜케 구조가 헷갈리는지 모르겟다. 더 천천히 쪼개 봐야하나보다. 아니면 아직 내가 아파서 약먹고 몽롱해서 머리에 안들어오는 것일지도... 교수님 정말로 꼼꼼히 설명해주시는것 같은데 머리에 안들어와 ㅠㅠ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

다들 감기 조심하세요. 진짜 요즘 감기는 낫기가 어렵네 ㅠㅠ 미친 기침감기.. 몸살로 오는 것 같아 힘드네 ㅠ

🔥 2주차 todo 리스트 (5/8~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 파이썬 중급2 파이썬 중급3 파이썬 중급4 파이썬 중급56~ 객체와 메모리 얕은 복사와 깊은 복사 클래스상속 생성자(01) 생성자(02) 다중 상속 오버라이딩 추상클래스 예외란?
파이썬 중급7 파이썬 중급89 파이썬 중급문풀12 파이썬 중급문풀3 파이썬 중급문풀4
~📝 weekly 데이터 사이언스 스쿨 퀴즈~ ~📝 재복습weekly 데이터 사이언스 스쿨 퀴즈~~

💻 핵심 내용 정리

📝 얕은복사와 깊은복사

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

• 객체 주소만 복사 (객체는 하나)
• 출력값이 같다.

깊은 복사 객체자체를 복사하는 것으로 또 하나의 객체가 만들어 진다.

• 객체 자체를 복사 (객체가 둘)
• 출력값이 다르다.

예시

class TemCls:
    def __inti__ (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)     #깊은 복사
print(f'id(scores): {id(scores)}')
print(f'id(scoresCopy): {id(scoresCopy)}')

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

scoresCopy = scores[:]      # 깊은복사 _슬라이싱
print(f'id(scores): {id(scores)}')
print(f'id(scoresCopy): {id(scoresCopy)}')

실습_01

📝 상속이란?

• 클래스는 또 다른 클래스를 상속해서 내 것처럼 사용할수 있다.

class1 → (class1) + class2 → (class1 + class2) + class3

• 상위 클래스로 갈수록 이전 클래스는 상속되어진다

예시

class NormalCar:

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

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

class  TurboCar(NormalCar):

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

myTurboCar = TurboCar()

myTurboCar.turbo()
myTurboCar.drive()
myTurboCar.back()

실습_02

뎃셈, 뺄셈 기능이 있는 클래스를 만들고,, 이를 상속하는 클래스를 만들어서 곱세과 나눗 기능을 추가해보자.

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__() 가 자동 호출된다.
• __init__() 가 속성을 초기화 한다.
• 상위클래스의 속성을 초기화 하기 위해서 super()를 이용한다. class.__init__()(self) 강제적으로 출력해서 상위 클래스의 속성를 초기화 할수 있다.
  

예시_01

class Calculator:

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

cal = Calculator()

예시_02

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

📝 다중상속

• 2개 이상의 클래스를 상속한다.
  

📝 오버라이딩

• 하위클래스에서 상위 클래스의 메서드를 재정의(override) 한다.
  

📝 추상클래스

• 상위 클래스에서 하위 클래스에 메서드 구현을 강요한다.
  

💡 오늘을 마무리하면서 ...

너무 힘들어서 어떻게 했는지 모르겠다. 약을 먹음 약을 먹어서 헤롱헤롱~ 퇴근하고 와서 어떻게 잤는지 기억이 안나고 일찍 일어나서 공부한것도 진짜 놀라움 깊은복사 한번 복습해야지.. 스터디노트도 마물하고 공개처리 해야지,, 할고많으당.

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

🔥 2주차 todo 리스트 (5/8~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 파이썬 중급2 파이썬 중급3 모듈 모듈제작 모듈사용 실행(메인)파일(01) 실행(메인)파일(02) 패키지 site-packages 파이썬 중급4 자주 사용하는 외부 모듈 객체지향 프로그래밍 클래스와 객체 생성 객체 속성 변경 객체와 메모리
파이썬 중급56 파이썬 중급7 파이썬 중급89 파이썬 중급문풀12 파이썬 중급문풀3 파이썬 중급문풀4
~📝 weekly 데이터 사이언스 스쿨 퀴즈~ ~📝 재복습weekly 데이터 사이언스 스쿨 퀴즈~~

💻 핵심 내용 정리

📝 모듈

• 이미 만들어진 훌륭한 기능으로 사용자는 쉽게 사용할 수 있다.
• 내부모듈, 외부모듈 그리고 사용자 모듈로 구분할 수 있다.

내부모듈 파이썬 설치시 기본적으로 사용할 수 있는 모듈 외부모듈 별도 설치 후 사용할 수 있는 모듈 사용자 모듈 사용자가 직접 만든 모듈

실습_01

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

import random

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

실습_02

ramdom 모듈을 이용해서 1부터 100사이의 난수 10개를 발생시켜보자.

import random

rNums = random.sample(range(1, 101), 10)
print(f'rNum: {rNum}')

📝 모듈만들기

• 특정 기능을 가지고 있는 파이썬 파일을 말한다.

실습_03

로또번호(6개)를 출력하는 모듈을 만들어 보자.

`모듈파일`
import random

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

    return result

`실행파일`
import lottoMachine

lottoNumbers = lottoMachine.getLottoNumbers()
print(f'lottoNumbers: {lottoNumbers}')

📝 모듈 사용

import import 키워드를 이용해서 모듈을 임포트 한다.

as as 키워드를 이용해서 모듈 이름을 단축시킬수 있다.

from ~ as from ~ as 키워드를 이용해서 모듈의 특정 기능만 사용할수 있다.

실습_04

국어, 영어, 수학점수를 입력하면, 총점 평군을 출력하는 모듈을 만들어보자.

`모듈파일`
scores = []

def addscore(s):
    scores.append(s)

def getScore():
    return scores

def getTotalScore():
    total = 0
    for s in scores:
        total += 0

    return total

def getAvgScore():
    avg = getTotalScore() / len(scores)

    return avg

'실행파일'

📝 실행파일 : 전역변수(기본변수)

• _name_ 에는 모듈 이름이 저장되거나 _main_ 이 저장된다.

예시 addModule.py → name = 'addModule' subModule.py → name = 'subModule' mulModule.py → name = 'mulModule' divModule.py → name = 'divModule'
module.py → name = 'main' # 실행파일

📝 패키지

• 패키지를 이용하면 관련 있는 모듈을 그룹으로 관리 할수 있다.
• site-packages 에 있는 모듈은 어디서나 사용할 수 있다.

  import sys
  

for path in sys.path: print(path)

```

📝 자주 사용하는 모듈

math 모듈 수학 관련 모듈 random 모듈 난수 관련 모듈 time 모듈 시간 관련 모듈

📝 객체 지향 프로그래밍

• 객체를 이용한 프로그램으로 객체는 속성과 기능으로 구성된다.
• 객체는 클래스에서 생성된다. 메모리에 생선된 개체를 내가 원하는 만큼 사용한다.
• 코드 재사용, 모듈화에 좋다. 언제든지 교체가 가능하다.

객체(Object) = 속성(Attribute) + 기능(Function)

📝 class(클래스)

• 클래스는 class 키워드와 속성(변수) 그리고 기능(함수)를 이용해서 만든다.
• 객체는 클래스의 생성자를 호출한다. _init_
• 객체 속성은 변경할 수 있다.
• 변수는 객체의 메모리 주소를 저장하고 이를 이용해서 객체를 참조한다.
  

📝 얕은 복사와 깊은 복사

얕은 복사 객체 주소를 복사하는 것으로 객체 자체가 복사되지 않는다. 깊은 복사 객체 자체를 복사하는 것으로 또 하나의 객체가 만들어진다.

📝 class(클래스) 상속

• 클래스는 또 다른 클래스를 상속해서 내 것처럼 사용 할 수 있다.

📝 생성자

• 객체가 생성 될때 생성자를 호출하면 _init_() 가 자동 호출된다.
• _init_() 가 속성을 초기화 한다.
• 상위클래스의 속성을 초기화 하기 위해서 super() 를 이용한다.
  

📝 다중상속

• 2개 이상의 클래스를 상속하다. 자주 사용하지 말자!!
  

📝 오버라이딩

• 하위클래스에서 상위 클래스의 메서드를 재정의(override)한다.
  

📝 추상클래스

• 상위클래스에서 하위클래스에 메서드 구현을 강요한다.

💡 오늘을 마무리하면서 ...

목감기는 나았지만 기침감기가 심해지고 있다. 체력적으로 버티기 점점 힘이들지만 강의는 열심히 이해할때까지 반복수강중이다. 나중에 더 나노단위로 쪼개서 봐야할것 같다.

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

기초를 이해를 다 하기도 전에 중급이라니... 정말이지 이해하면서 강의 듣는 건 무리일까? 더 나를 악착같이 몰아야하나...

♥ 좋은말 애매한 재능을 뛰어 넘는 유일한 방법은 꾸준히, 주구장창, 질리더라도 계속, 멈추지 않고 그냥 계속 하는 것.

🔥 2주차 todo 리스트 (5/8~5/14)

파이썬 기초문풀4 파이썬 기초문풀5 파이썬 중급1 함수란 함수선언과 호출 함수내에서 또 다른 함수 호출 인수와 매개 변수 데이터변환 파이썬 중급2 지역변수와 전역변수 중첩함수 lambda함수 모듈 모듈제작 파이썬 중급3 파이썬 중급56 파이썬 중급7 파이썬 중급89 파이썬 중급문풀1~2 파이썬 중급문풀3 파이썬 중급문풀4

💻 핵심 내용 정리

📝 함수는 기능이라고 생각하자.

• 파이썬의 함수는 수학의 함수와 동일하다.
• 기본으로 제공하는 내장함수, 사용자가 직접 선언하는 사용자 함수가 있다.
• 함수의 특정 기능을 반복 사용하기 위해서 사용한다.
• 함수의 입력은 한 개가 아니라 여러 개가 되어도 상관없다.
• 입력 변수가 여러개이면 쉼표, 영어로 comma 를 사용하여 함수를 정의한다.
• 입력 변수는 원하는 만큼 얼마든지 만들 수 있다.
• 힘수내에서 또 다른 함수를 호출 할 수 있다.
• pass를 이용해서 실행문을 생략 할 수 있다.
  

함수 선언

def 함수이름 (입력변수이름):
    출력변수를 만드는 명령
      return 출력변수이름

```python
def 함수이름(입력변수1, 입력변수2, 입력변수3):
   출력변수를 만드는 명령
   return 출력변수이름

함수 호출

함수이름 (입력변수이름)

```python
함수이름(입력변수1, 입력변수2, 입력변수3):

예시

# 오늘 날씨를 출력하는 함수를 선언하고 3번 호출하자.
def printWeatherInfo():
    print('오늘 날씨는 맑습니다. 기온은 25도 입니다.')

printWeatherInfo()
printWeatherInfo()
printWeatherInfo()


# 정수 두개를 입력하면 곱세과 나눗셈 연산 결과를 출력하는 함수를 만들고 호출해보자.
def calfun():
    n1 = int(input('n1 입력: '))
    n2 = int(input('n2 입력: '))

    print(f'n1 * n2 = {n1 * n2}')
    print(f'n1 / n2 = {round(n1 / n2, 2)}')

calfun()

📝 인수와 매개변수

• 함수 호출시 함수에 데이터를 전달 할 수 있다.
• 함수에 대입할 데이터 → 인수(파라미터)
• 함수 선언문에서 호출문으로 갈때 필요한 만큼 연결(관계)해주는 함수 → 매개변수
• 인수와 매개변수 개수는 일치해야한다.
• 매개변수 개수가 정해지지않은 경우 '*'를 이용한다.
• return 키워드를 이용하면 함수 실행 결과를 호출부로 반환 할수 있다.
• 함수가 return를 만나면 실행을 종료한다.
  

📝 전역변수

• 함수 밖에 선언된 변수
• 어디에서나 사용은 가능 하지만 함수 안에서 수정 할 수 는 없다.
• 바깥의 변수와 같은 이름의 변수를 함수 안에 만들면 안 된다.
• 함수 안에서는 함수 바깥에 있는 변수의 값을 바꿀 수 없다.
• 함수 안에서 함수 바깥에 있는 변수의 값을 꼭 바꿔야만 한다면 함수 이름 앞에 global 키워드를 선언해 주면 된다.

예시

z = 3

def f2(x):
    y = z * x
    print("y =", y)
    print("z =", z)
    return y

z = 3

def f4(x):
    global z
    z = 99
    y = z * x
    print("y =", y)
    print("z =", z)
    return y

📝 지역변수

• 함수 안에 선언된 변수
• 함수 안에서만 사용가능하다.
• 이름이 같은 변수가 있다고 하더라도 별개의 변수가 된다.
• 함수 바깥에 혹시라도 y라는 변수가 있으면 del 명령으로 지운다. 만약 기존에 y라는 변수가 있었으면 오류가 출력되지 않고 지워지기만 한다.
  

📝 중첩함수

• 함수 안에 또다른 함수가 있는 형태이다.
• 내부함수를 함수 밖에서 호출 할 수 없다.
  

📝 중첩함수

• 함수 안에 또다른 함수가 있는 형태이다.
• 내부함수를 함수 밖에서 호출 할 수 없다.
  

📝 lambda함수

• 함수 선언을 보다 간단하게 할 수 있다.
  

예시

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

문제풀이_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)

💡 오늘을 마무리하면서 ...

건강상태가 안좋아서 집중이 잘 안된다 ㅠㅠ 이겨내야해 제인아 ㅠ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

오늘 감기때문인지 몸이 무거웠다. 공부는 왜 이리 하기 어려운건지.. 책상 앞에서 3시간이 지나도록 시작을 못했다. 오늘 분량을 해치우고 빨리 자자

🔥 1주차 todo 리스트 (5/3~5/7)

파이썬 기초1 파이썬 기초23~ ~파이썬 기초4~ ~파이썬 기초5~ ~파이썬 기초6~ ~파이썬 기초7~ ~파이썬 기초8~ ~파이썬 기초910 파이썬 기초문풀1 파이썬 기초문풀2 파이썬 기초문풀3 📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

🏅 기초 문제풀이

실습_01

체중(g)과 신장(cm)을 입력하면 BMI지수가 출력되는 프로그램을 만들어보자.

weight: 체중입력(g)
height: 신장입력(cm)
weight가 숫자라면 kg으로 환산
height가 숫자라면 m로 환산
BMI계산 (몸무게(kg) / 신장(m) * 신장(m)

weight = input('체중 입력(g): ')
height = input('신장 입력(cm): ')

if weight.isdigit():
    weight = int(weight) / 10

if height.isdigit():
    height = int(height) / 100

print('체중 : {}kg'.format(weight))
print('신장 : {}m'.format(height))

bmi = weight / (height * height)
print('BMI : %.2f' % bmi )

실습_02

다음 코드에서 num1과 num2의  값을 서로 바꾸고 각각 출력해보자.

num1 = 10
num2 = 20
print('num1: {}, num2: {}'.format(num1, num2))

tempNum = num1
num1 = num2
num2 = tempNum
print('num1: {}, num2: {}'.format(num1, num2))

실습_03

중간, 기말고사 점수를 입력하면 총점과 평균이 출력되는 프로그램을 만들어보자.

score1 = input('중간 고사 점수 : ')
score2 = input('기말 고사 점수 : ')

if score1.isdigit() and score2.isdigit():   # 형변환체크(숫자)_ .isdigit()함수
    score1 = int(score1)
    score2 = int(score2)

    totalScore = score1 + score2
    avgScore = totalScore / 2

    print('총점: {}, 평균: {}'.format(totalScore, avgScore))

else:
    print('잘 못 입력했습니다.')

실습_04

키오스크에서 사용 하는 언어 선택 프로그램을 만들어 보자.

selectNum = input('언어선택(choose your language) : 1.한국어 \t 2.English \t')

if selectNum == '1':
    menu ='1.샌드위치 \t 2.햄버거 \t 3. 쥬스 \t 4.커피 \t 5.아이스크림'
if selectNum == '2':
    menu ='1.Sandwich \t 2.Hamburger \t 3. Juice \t 4.Coffe \t 5.Ice cream'

print(menu)

실습_05

나의 나이가 100살이 되는 해의 연도를 구하는 프로그램을 만들어보자.

import datetime

today = datetime.datetime.today()  # 년,월,일,시 출력함수

myAge = input('나이 입력 : ')
if myAge.isdigit():

    afterAge = 100 - int(myAge)
    my100 = today.year + afterAge

    print('{}년({}년후)에 100살!'.format(my100, afterAge))
else:
    print('잘 못 입력했습니다.')

실습_06

상품 가격과 지불금액을 입혁하면 거스름 돈을 계산하는 프로그램을 만들어보자.
단, 거스름돈은 제폐와 동전의 개수를 최소로 하고, 1원 단위를 절사한다.

money50000 = 50000; money10000 = 10000; money5000 = 5000; money1000 = 1000;
money500 = 500; money100 = 100; money10 = 10

money50000Cnt = 0; money10000Cnt = 0; money5000Cnt = 0; money1000Cnt = 0;
money500Cnt = 0; money100Cnt = 0; money10Cnt = 0

productPrice = int(input('상품 가격 입력: '))
payPrice = int(input('지불 금액 입력: '))

if payPrice > productPrice:
    changeMoney = payPrice - productPrice
    changeMoney = (changeMoney // 10) * 10

print('거스름 돈 : {}(원단위 절사)'.format(changeMoney))

if changeMoney > money50000:
    money50000Cnt = changeMoney // money50000
    changeMoney %= money50000

if changeMoney > money10000:
    money10000Cnt = changeMoney // money10000
    changeMoney %= money10000

if changeMoney > money5000:
    money5000Cnt = changeMoney // money5000
    changeMoney %= money5000

if changeMoney > money1000:
    money50000Cnt = changeMoney // money1000
    changeMoney %= money1000

if changeMoney > money500:
    money500Cnt = changeMoney // money500
    changeMoney %= money500

if changeMoney > money100:
    money100Cnt = changeMoney // money100
    changeMoney %= money100

print('-' * 36)
print('50,000 {}장'.format(money50000Cnt))
print('10,000 {}장'.format(money10000Cnt))
print('5,000 {}장'.format(money5000Cnt))
print('1,000 {}장'.format(money1000Cnt))
print('500 {}개'.format(money500Cnt))
print('100 {}개'.format(money100Cnt))
print('10 {}개'.format(money10Cnt))
print('-' * 36)

실습_07

국어, 영어, 수학 점수 입력후, 총점, 평균, 최고점수 과목/최저점수 과목 그리고 최고점수와 최저 점수의 차이를 각각 출력해보자.

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

totalScore = korScore + engScore + matScore
avgScore = totalScore / 3

maxScore = korScore
maxSubject = '국어'
if engScore > maxScore:
    maxScore = engScore
    maxSubject = '영어'

if matScore > maxScore:
    maxScore = matScore
    maxSubject = '수학'

minScore = korScore
minSubject = '국어'
if engScore < minScore:
    minScore = engScore
    minSubject = '영어'

if matScore < minScore:
    minScore = matScore
    minSubject = '수학'

difScore =  maxScore - minScore

print(f'총점: {totalScore}')
print('평균: %.2f' % avgScore)
print('-' * 36)
print(f'최저 점수 과목(점수): {maxSubject}({maxScore})')
print(f'최저 점수 과목(점수): {minSubject}({minScore})')
print(f'최고, 최저 점수 차이: {difScore}')
print('-' * 36)

실습_08

시, 분, 초를 입력하면 초로 호나산하는 프로그램을 만들어 보자.

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

print('{}초'.format(format(hou * 60 * 60 + min * 60 + sec, ',')))

실습_09

금액, 이율, 거치기간을 입력하면 복리ㅣ계산하는 복리계산기 프로그램을 만들어 보자.

money = int(input('금액 입력 : '))
rate = float(input('이율 입력 : '))  # 4.3 %
term = int(input('기간 입력 : '))

targetMoney = money

for i in range(term):
    targetMoney+= (targetMoney * rate * 0.01)

targetMoneyFormated = format(int(targetMoney), ',')  # 원단위 콤마찍기
moneyformated = format(int(money), ',')  # 원단위 콤마찍기

print('-' * 36)
print(f'이율: {rate}')
print(f'원금: {moneyformated}')
print(f'{term}년 후 금액: {targetMoneyFormated}원')
print('-' * 36)

실습_10

고도가 60m 올라갈때마다 기온이 0.8도 내려간다고 할때 고도를 입력하면 기온이 출력되는 프로그램을 만들어보자.(지면온도:29도)

baseTemp = 29
step = 60
stepTemp = 0.8

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

targetTemp = baseTemp -((height // step) * 0.8)
if height % step != 0:
    targetTemp -= stepTemp

print(f'지면온도: {baseTemp}')
print(f'고도 {height}m의 기온: {targetTemp}')

실습_11

백신 접종 대상자를 구분하기 위한 프로그램을 만들어 보자.

inputAge = int(input('나이 입력: '))

if inputAge <= 19 or inputAge >= 65:
    endNum = int(input('출생연도 끝자리 입력: '))

    if endNum == 1 or endNum == 6:
        print('월요일 접종 가능!')
    elif endNum == 2 or endNum == 7:
        print('화요일 접종 가능!')
    elif endNum == 3 or endNum == 8:
        print('수요일 접종 가능!')
    if endNum == 4 or endNum == 9:
        print('목요일 접종 가능!')
    elif endNum == 5 or endNum == 0:
        print('금요일 접종 가능!')
else:
    print('하반기 일정을 확인하세요.')

실습_12

길이(mm)를 입력하면 inch로 환산하는 프로그램을 만들어보자.

1mm = 0.039inch

byInch = 0.039
lengthmm = int(input('길이(mm) 입력 :'))
lengthInch = lengthmm * byInch

print(f'{lengthmm}mm -> {lengthInch}inch')

실습_13

교통  과속  위반  프로그램을  만들어보자.
시속  50km이하    안전속도  준수!!
시속 50km초과  안전속도 위반!! 과태표 50,000원 부과 대상!!!

carSpeed = int(input('속도 입력: '))
limitSpeed = 50

if carSpeed > 50:
    print('안전속도 위반!! 과태료 50,000원 부과 대상!!!')

else:
    print('안전속도 준수!!')

실습_14

문자  메시지  길이에  따라  문자  요금이  결정되는  프로그램을  만들어보자
문자  길이  50이하   SMS발송(50원  부과)
문자 길이 50초과  MMS발송(100원 부과)

message = input('메세지 입력:')
lenMessage = len(message)
msgPrice = 50

if lenMessage <= 50:
    msgPrice = 50
    print('SMS 발송!!')

else:
    msgPrice = 100
    print('MMS 발송!!')

print(f'메세지 길이 : {lenMessage}')
print(f'메세지 발송 요금: {msgPrice}원')

실습_15

국어, 영어, 수학, 과학, 국사  점수를  입력하면  총점을  비롯한  각종  데이터가  출력되는 프로그램을  만들어보자.
목별  점수를  입력하면  총점, 평균, 편차를  출력한다. 평균은  다음과  같다.
(국어: 85, 영어: 82, 수학: 89, 과학: 75, 국사: 94)
각종  편차  데이터는  막대그래프로  시각화한다.

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('-' * 80)
print(f'총점: {totalScore}({totalGap}), 평균: {avgSCore}({avgGap})')
print(f'국어: {korScore}({korGap}), 영어: {engScore}({engGap}), 수학: {matScore}({matGap}),'
      f'과학: {sciScore}({sciGap}), 국사: {hisScore}({hisGap})')

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('-' * 80)

💡 오늘을 마무리하면서 ...

언능 끝내고 쉬고 싶다... 컨디션 조절을 잘 해야 롱런 할수 있다.

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

문제풀이를 하고 나면 조금 지치는 느낌이 들면서도 뭔가 조금씩 퍼즐이 짜맞춰져 지는 그런 느낌이 들어서 하고 나면 뿌듯하다 근데 왜 오지게 이해 안가는 건 안가냐고 ㅠㅠ 언어의 문제인지, 수학의 문제인지 고것이 알고싶다...

🔥 2주차 todo 리스트 (5/8~5/14)

파이썬 기초문풀4 파이썬 기초문풀5
파이썬 중급1 파이썬 중급2 파이썬 중급3 파이썬 중급56 파이썬 중급7 파이썬 중급89 파이썬 중급문풀1~2 파이썬 중급문풀3 파이썬 중급문풀4 📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

🏅 기초문제풀이

실습_01

난수를  이용해서  홀/짝  게임을  만들어보자.

import random

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

if comNum == 1 and userSelect == 1:
    print('빙고!! 홀수')
elif comNum == 2 and userSelect == 2:
    print('빙고!! 짝수')
elif comNum == 1 and userSelect == 2:
    print('실패!! 홀수!!')
elif comNum == 2 and userSelect == 1:
    print('실패!! 짝수!!')

실습_02

난수를  이용해서  가위, 바위, 보  게임을  만들어보자.

import random

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

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


print('컴퓨터: {}, 유저: {}'.format(comNumber, userNumber))

실습_03

아래  요금표를  참고해서  상수도  요금  계산기를  만들어보자.

part = int(input('업종 선택(1.가정용 2.대중탕용 3.공업용) : '))
userWater = int(input('사용량 입력: '))
unitPrice = 0

if part == 1:
    unitPrice = 540

elif part == 2:
    if userWater <= 50:
        unitPrice = 820
    elif userWater > 50 and userWater <= 300:
        unitPrice = 1920
    elif userWater > 300:
        unitPrice = 2400
elif part == 3:
    if userWater <= 500:
        unitPrice = 240
    else:
        unitPrice = 470

userPrice = userWater * unitPrice
userPriceFormated = format(int(userPrice), ',')  # 원단위 콤마찍기

print('=' * 36)
print('상수도 요금표')
print('-' * 36)
print('사용량 \t : \t 요금')
userPrice = userWater * unitPrice
print('{} \t : \t {}원'.format(userWater, userPriceFormated))
print('=' * 36)

실습_04

미세먼지  비상저감조치로  차량  운행제한  프로그램을  다음  내용에  맞게  만들어  보자.

미세먼지  측정  수치가  150이하면  차량  5부제  실시
미세먼지  측정  수치가  150을  초과하면  차량  2부제  실시
차량  2부제를  실시하더라도  영업용차량은  5부제  실시
미세먼지 수치, 차량 종류, 차량 번호를 입력하면 운행 가능 여부 출력

import datetime

today = datetime.datetime.today()
day = today.day

limitDust = 150
dustNum = int(input('미세먼지 수치 입력: '))
carType = int(input('차량 종류 선택 : 1,승용차 2. 영업용차'))
carNumber = int(input('차량 번호 입력 : '))

print('-' * 36)
print(today)
print('-' * 36)

if dustNum > limitDust and carType == 1:
    if (day % 2) ==(carNumber % 2):
        print('차량 2부제 적용')
        print('차량 2부제로 금일 운행제한 대상 차량입니다.')
    else:
        print('금일 운행 가능합니다.')
if dustNum > limitDust and carType == 2:
    if (day % 5) ==(carNumber % 5):
        print('차량 5부제 적용')
        print('차량 5부제로 금일 운행제한 대상 차량입니다.')
    else:
        print('금일 운행 가능합니다.')

if dustNum <= limitDust:
    if (day % 5) == (carNumber % 5):
        print('차량 5부제 적용')
        print('차량 5부제로 금일 운행제한 대상 차량입니다.')
    else:
        print('금일 운행 가능합니다.')
print('-' * 36)

실습_05

PC에서  난수를  발생하면  사용자가  맞추는  게임을  만들어보자.
PC가 난수(1~1000)를 발생하면 사용자가 숫자(정수)를 입력한다.
사용자가  난수를  맞추면  게임이  종료된다.
만약, 못  맞추게  되면  난수와  사용자  숫자의  크고  작음을  출력한  후 사용자한테  다시  기회를  준다.
최종적으로  사용자가  시도한  횟수를  출력한다.

import random

rNum = random.randint(1, 100)
tryCount = 0
gameFlag = True

while gameFlag:
    tryCount += 1
    pNum = int(input('1에서 1,000까지의 정수 입력 : '))

    if rNum == pNum:
        print('빙고!!')
        gameFlag = False
    else:
        if rNum > pNum:
            print('난수가 크다!')
        else:
            print('난수가 작다!')

print('난수: {}, 시도 횟수: {}'.format(rNum, tryCount))

실습_06

실내온도를  입력하면  스마트에어컨  상태가  자동으로  설정되는  프로그램을  만들어보자

innerTemp = int(input('실내온도 입력 : '))

if innerTemp <= 18:
    print('에어컨 상태 : off')
elif innerTemp > 18 and innerTemp <= 22:
    print('에어컨 상태 : 매우 약')
elif innerTemp > 22 and innerTemp <= 24:
    print('에어컨 상태 : 약')
elif innerTemp > 24 and innerTemp <= 26:
    print('에어컨 상태 : 중')
elif innerTemp > 26 and innerTemp <= 28:
    print('에어컨 상태 : 강')
elif innerTemp > 28:
    print('에어컨 상태 : 매우 강')

실습_07

1부터  100까지  정수  중  십의자리와  일의자리에  대해  각각  홀/짝수를 
구분하는 프로그램을  만들어보자.

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

        result10 = ''
        if num10 % 2 == 0:
            result10 = '짝수'
        else:
            result10 = '홀수'

        result1 = '0'
        if num1 != 0:
            if num1 % 2 == 0:
                result1 = '짝수'
            else:
                result1 = '홀수'

        print('[{}] 십의 자리: {}, 일의 자리: {}'.format(i, result10, result1))

실습_08

1부터  사용자가  입력한  정수까지의  합, 홀수의  합, 짝수의  합 
그리고  팩토리얼을 출력하는  프로그램을  만들어보자

fNum = int(input('정수 입력 : '))

addSum = 0   # 합
for i in range(1, (fNum + 1)):
    addSum += i

addSumformated = format(addSum, ',') # 3자리마다 콤마찍기
print('합 결과 : {}'.format(addSumformated))

oddSum = 0   # 홀수
for i in range(1, (fNum + 1)):
    if i % 2 != 0:
        oddSum += i

oddSumformated = format(oddSum, ',') # 3자리마다 콤마찍기
print('홀수 합 결과 : {}'.format(oddSumformated))

evenSum = 0   # 짝수
for i in range(1, (fNum + 1)):
    if i % 2 == 0:
        evenSum += i

evenSumformated = format(evenSum, ',') # 3자리마다 콤마찍기
print('짝수 합 결과 : {}'.format(evenSumformated))

factorialResult = 1   # 팩토리얼
for i in range(1, (fNum + 1)):
    factorialResult *= i

factorialResultformated = format(factorialResult, ',') # 3자리마다 콤마찍기
print('팩토리얼 결과 : {}'.format(factorialResultformated))

실습_09

‘*’를  이용해서  다음과  같이  다양한  모양을  출력해보자.

# 01 좌측정렬
for i in range(1,6):
    for j in range(i):
        print('*', end='')
    print()

# 02 우측정렬
for i1 in range(1,6):
    for i2 in range(6 - i1 - 1):
        print(' ', end='')
    for i3 in range(i1):
        print('*', end='')
    print()

# 03 반전 좌측 정렬
for i in range(5, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

# 03 반전 우측 정렬
for i in range(5, 0, -1):
    for j in range(5 - i):
        print(' ', end='')
    for j in range(i):
        print('*', end='')
    print()

# 04 ▶
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()

# 05 \
for i in range(1, 6):         # 행
    for j in range(1, 6):    # 열
        if j == i:
            print('*', end='')
        else:
            print(' ', end='')

    print()

실습_10

집  앞  버스  정류장에서  학교까지  가는  버스  A, B, C 의  운행정보가  다음과  같을  때, 2대  이상의  버스가  정차하는  시간대를  출력해보자.
• 버스  A, B 운행  정보
- 오전  6시  첫차  : 오후  23시  운행  종료 
- 버스A : 15분  간격  운행
- 버스B : 13분  간격  운영

• 버스  C 운행  정보
- 6시  20분  첫차  : 오후  22시  운행  종료 
- 버스C : 8분  간격  운행


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('버스A와 버스B 동시 정차!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
    else:
        if i % busA == 0 and i % busB == 0:
            print('버스A와 버스B 동시 정차!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
        elif i % busA == 0 and i % busC== 0:
            print('버스A와 버스C 동시 정차!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))
        elif i % busB == 0 and i % busC == 0:
            print('버스B와 버스C 동시 정차!', end='')
            hour = 6 + i // 60
            min = i % 60
            print('\t{}:{}'.format(hour, min))

실습_11

톱니가  각각  n1개와  n2개의  톱니바퀴가  서로  맞물려  회전할  때, 회전을  시작한  후  처음 맞물린  톱니가  최초로  다시  만나게  될  때까지의  톱니의  수와  각각의  바퀴  회전수를 출력해보자.(단, n2는  n1보다  크다.)

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

실습_12

윤년  계산기를  만들어보자.
윤년  조건
- 연도가  4로  나누어떨어지고  100으로  나누어떨어지지  않으면  윤년이다. - 또는  연도가  400으로  나누어떨어지면  윤년이다.

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(2021, (2021+101)):
    if (year % 4 == 0 and year % 100 != 0) or (year % 400  == 0 ):
        print('{}년 : 윤년!!'.format(year))
else:
    print('{}년 : 평년!!'.format(year))    

💡 오늘을 마무리하면서 ...

오늘 하루도 지켰다!! 내일도 열심히 하잣!! 근데 나는 언제 아웃풋하냐 ㅠㅠ 응용1도 못해 ㅠㅠ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

오늘은 꼭 목표까지 공부하자!! 아자 아자!!

🔥 1주차 todo 리스트 (5/3~5/7)

파이썬 기초1 파이썬 기초23~ ~파이썬 기초4~ ~파이썬 기초5~ ~파이썬 기초6~ ~파이썬 기초7~ ~파이썬 기초8~ ~파이썬 기초910 반복문 횟수에 의한 반복문(for문) 반복 범위 설정(range()함수) 조건에 의한 반복(while문) for문과 while문 비교 무한루프 반복문 제어(continue) 반복문 제어(break) 중첩반복문

파이썬 기초문풀1

파이썬 기초문풀2 파이썬 기초문풀3

📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 반복문

• 특정 실행을 반복하는것.
• 반목문을 사용하면 프로그래밍이 간결하고 유지 보수가 쉽다.
• 간단하게 손쉽게 만들어 효율적이다.
  

📝 반복문의 종류

• 횟수에 의한 반복 횟수 지정 → 횟수만틈 반복 실행
• 조건에 의한 반복 조건 지정 → 조건에 만족할때까지 반복실행
  

📝 횟수에 의한 반복문(for문)

• 정해놓은 반복 횟수에 따라 반복 실행한다. (대량메일또는 문자발송, 인사말 반복, mp3반복재생)
• 횟수의 의한 반복은 for문이 주로 사용된다. for문 : 쉽고 직관적이다. while문 : 조건에 의한 반복문을 사용할때 사용한다.

📝 for문 사용 방법

for i in range(n): 조건문 [들여쓰기] print( ) : 실행문

구구단 출력해보기

for i in range(10):    # 변수_i / 실행횟수_n
    print('{} * {} = {}'.format(7, i, (7 * i)))

pass : 아직 실행문이 정해지지않음, 반복하되 실행하지 않겠다.(실행문 대신에 사용) :(코드블록), 들여쓰기 : 동일하게 들여쓰기를 하자.

실습_01

'Hello python'문자열을 5번 출력하는 코드를 작성하자

for num in range(5):
    print('Hello python')

📝 반복 범위 설정(range()함수)

range()함수 : 반복이 가능한 개체만 넣어준다. for i in range (시작, 끝, 단계)

• 매개변수의 단계가 1인 경우에만 생략이 가능하다.
• 매개변수의 시작이 0인 경우에만 생략이 가능하다.
  

실습_02

사용자가 반복의 시작과 끝으 ㄹ입력하면 1씩 증가하는 반복문을 만들어 보자.

startNum = int(input('반복의 시작 입력 : '))
endNum = int(input('반복의 끝 입력 : '))

for i in range(startNum, (endNum+1)):
    print(i)

위에서 작성한 반복문을 이용해서 2씩 증가하는 반복문을 만들어 보자.

for i in range(startNum, (endNum+1), 2):
    print(i)

실습_03

1에서 100까지의 정수중 3의 배수에 해당하는 정수만 출력하는 코드를 작성하자.

for i in range(1, 101):
    if i % 3 == 0:
        print(i)

📝 조건에 의한 반복(while문)

• 조건에 만족하면 반복실행한다. 그렇지 않으면 반복을 중단한다. (매일아침기상알람, 게임반복실행, 타이머)
• 조건에 의한 반복은 while문이 주로 사용된다.
  

📝 while문 사용 방법

while 조건식 : 조건문 [들여쓰기] print( ) : 실행문 [들여쓰기] n += 1 / 무한루프를 방지

pass : 아직 실행문이 정해지지않음, 반복하되 실행하지 않겠다.(실행문 대신에 사용) :(코드블록), 들여쓰기 : 동일하게 들여쓰기를 하자.

실습_04

1에서 100까지의 정수중 2의 배수와 3의 배수를 구분해서 출력하자.

n = 1
while n < 101 :
    if n % 2 == 0:
        print('{}은 2의 배수이다.'.format(n))
    if n % 3 == 0:
        print('{}은 3의 배수이다.'.format(n))
    n += 1

실습_05

while문을 이용해서 사용자가 입력한 구구단을 출력하자.

gugudanNum = int(input('희망구구단을 입력하세요 : '))

n = 1

while n < 10 :
    result = gugudanNum * n
    print('{} * {} = {}'.format(gugudanNum, n, result))
    n += 1

📝 for문과 while문 비교

• for문이 적합한 경우 횟수의 의한 반복이라면 for문이 while문보다 적합하다.

• while문이 적합한 경우 조건의 의한 반복이라면 while문이 for문이 보다 적합하다.

실습_05

자동차 바퀴가 한번 구를때마다 0.5mm씩 마모 된다고 한다.
현재의 바퀴두께가 30mm이고 최소 운행 가능 바퀴 두께가 20mm라고 할 때
앞으로 구를수 잇는 횟수를 구해보자.
- 휫수를 알수 없으니, 조건문에 적합한 whlie문을 이용한다.

currentThickness = 30
rotationCount = 0
removeThickness = 0.15

while currentThickness >= 20:
    rotationCount += 1
    currentThickness -= removeThickness

safeRotationCount = rotationCount - 1  # 20이하로 내려가지 않게 올림 해줌
print('운행가능 횟수 : {}'.format(safeRotationCount))

📝 무한루프

• 반복문을 빠져나올수 없는 경우를 무한 루프라고 한다. while문에서 조건식의 결과가 항상 True인 경우
• 조건식에 논리형 데이터를 사용해서 무한 반복 실행할 수 있다. if문을 사용하여 무한루프를 빠져나올수 있다.
  

실습_06

하루에 독감으로 병원에 내방하는 환자수가 50명에서 100명사이일 때,
누적 독감 환자수가 최초 10,000명을 넘는 날짜를 구해보자.

import random

sum = 0
date = 1
flag = True

while flag:
    patienCount = random.randint(50,100)
    sum += patienCount
    print('날짜: {}, \t 오늘 환자수: {}, \t 누적 환자수: {}'.format(date, patienCount, sum))
    if sum >= 10000:
        flag = False

📝 continue 키워드

반복 실행 중 continue를 만나면 실행을 생략하고, 다음 반복 실행문으로 넘어간다.

예시

for i in range(100):
    if i % 7 != 0:
        continue

print('{}는 7의 배수입니다.'.format(i))

📝 else 키워드

else의 실행문은 for문의 반복문(반복작업)이 종료된 후 실행된다.

예시

cnt = 0
for i in range(100):  # 0~99까지 진행하면서 7의 배수만 실행
    if i % 7 != 0:
        continue

    print('{}는 7의 배수입니다.'.format(i))
    cnt += 1

else:
    print("99까지의 정수 중 7의 배수는 {}개입니다.". format(cnt))

실습_07

1부터 100까지의 정수 중 3과 7의 공배수와 최소공배수를 출력하자.

minNum = 0
for i in range(1,101):
    if i % 3 != 0 or i % 7 != 0:
        continue

    print('공배수: {}'.format(i))

    if minNum == 0:
        minNum = i

else:
    print('최소 공배수: {}'. format(minNum))

📝 break 키워드

반복 실행 중 break를 만나면 반복문을 빠져 나온다.

실습_08

10의 팩토리얼(10!)을 계산하는 과장에서 결과값이 50을 넘을떄의 숫자를 구하자.

result = 1  # 결과값
num = 0

for i in range(1, 11):
    result *= i

    if result > 50:
        num = i
        break

print('num: {}, result: {}'.format(num, result))

실습_09

새끼 강아지의 체중이 2.2kg가 넘으면 이유식을 중단하려고 한다.
한번 이유식을 먹을떄ㅖ 체중이 70g 증가한다고 할때,
예상되는 이유식 날짜를 구하자.(현재 체중은 800g이다.)

limitWeight = 2200    # 결과값
currentWeight = 800   # 현재값
date = 1    # 변수

while True:
    if currentWeight >= 2200:
        break

    date += 1
    currentWeight += 70  # 한번 먹을때 70g증가 _조건식

print('이유식 중단 날짜 : {}일'.format(date))

📝 중첩반복문

• 반복문 안에 또 다른 반복문을 선언한다.
• 너무 많은 반복문은 복잡하고 계산하기 어렵다.

예시

for i in range(10, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

실습_10

구구단 전체를 출력하자.

for i in range(1, 10):
    for j in range(2, 10):
        result = j * i
        print('{} * {} = {}\t'.format(j, i, result), end='')

    print()

🏅 기초 문제풀이 _ 01

주문확인서 템플릿 만들기

name = '홍길동'
product = '야구글러브'
orderNo = 2568956
payMethod = '신용카드'
productPrice = 110000
payPrice = 100000
usePoint = 10000
payDate = '2021/08/03 21:50:12'
payDiv = 6
payDivCategory = '무'
phone = '02-1234-5678'

print('-' * 50)
print(name, '고객님 안녕하세요.')
print(name, '고객님의 주문이 완료되었습니다.')
print('다음의 주문건에 대한 상세 내역입니다.')
print('-' * 50)
print('상품명 : {}'.format(product))
print('주문번호 : {}'.format(orderNo))
print('결재방법 : {}'.format(payMethod))
print('상품금액 : {}원'.format(productPrice))
print('결재금액 : {}원'.format(payPrice))
print('포인트 : {}'.format(usePoint))
print('결제일시 : {}'.format(payDate))
print('할부 : {}개월'.format(payDiv))
print('할부유형 : {}'.format(payDivCategory))
print('문의 : {}'.format(phone))
print('-' * 50)
print('저희 사이트를 이용해 주셔서 감사합니다.')

len() 함수 : 문자 길이 반환

사용자가 입력한 데이터의 길이를 출력하는 프로그램을 만들어보자.

userMsg = input('메세지 입력 : ')
print('메세지 문자열 길이 : {}'.format(len(userMsg)))

find() 함수 :

객체지향 문자열(0부터 특정문자의 위치를 찾는다.)을 찾아 보자.

article = '모든 함수가 일단 클래스 안에 있어야 하며, 전역 함수는 static 함수를 사용하는 형태로 짜야 한다. \
그나마 객체지향이라는 직관성은 C#이 Python보다 더 좋은 편이다. \
두 언어는 서로 다른 용도로 사용되는 경우가 많지만 OpenCV와 같은 곳에서는 둘 다 사용할 수 있기도 하다.'

strIdx = article.find('객체지향')
print('객체지향 문자열 위치 : {}'.format(strIdx))

사용자가 입력한 데이터를 모두 실수로 변경한후 사각현, 삼각형의 넓이를 출력해보자.

width = float(input('가로 길이 입력 : '))
height = float(input('세로 길이 입력 : '))

triangleArea = width * height /2
squareArea = width * height

print('-' * 13, 'Result', '-' * 13)
print('삼각형 넓이 : %f' % triangleArea)
print('사각형 넓이 : %f' % squareArea)
print('삼각형 넓이 : %.2f' % triangleArea)
print('사각형 넓이 : %.2f' % squareArea)
print('-' * 34)

원의 반지르을 입력하면 원의 넓이와 둘레 길이를 출력하되,
아래의 형식으로 출력해보자.

정수
소수점 한자리
소수점 셋째자리

r = int(input('반지름(cm) 입력 : '))
pi = 3.14

area = pi * r * r
cir = 2 * r * pi

print('원의 넓이 : %dcm' % area)
print('원의 둘레 : %dcm' % cir)
print('원의 넓이 : %.1fcm' % area)
print('원의 둘레 : %.1fcm' % cir)
print('원의 넓이 : %.3fcm' % area)
print('원의 둘레 : %.3fcm' % cir)

사용자로 부터 입력받은 개인정보를 포맷 문자열을 이용해서 다음과 같이 출력해보자.

name = input('이름 입력 : ')
mail = input('메일 입력 : ')
id = input('아이디 입력 : ')
pw = input('비밀번호 입력 : ')
privateNumber1 = input('주민번호 앞자리 입력 : ')
privateNumber2 = input('주민번호 뒷자리 입력 : ')
address = input('주소 입력 : ')

pwStar = '*' * len(pw)
privateNumberStar = privateNumber2[0] + ('*' * 6)

print('-' * 36)
print(f'이름 : {name}')
print(f'메일 : {mail}')
print(f'아이디 : {id}')
print(f'비밀번호 : {pwStar}')
print(f'주민번호 : {privateNumber1} - {privateNumberStar}')
print(f'주소 : {address}')
print('-' * 36)

srt() 함수 : str에 저장된 문자열에서 첫번째 문자를 반환함

💡 오늘을 마무리하면서 ...

컨디션이 안좋아졌다. 포항 다녀오면서 너무 무리를 했나 보다. 역시 시집살이 힘들어 ㅠ (동동이 이거 보지마!) 파이썬 코드 쓸때 '-' * 이거 귀여운것 같음

print('-' * 36)

역시 힘들때엔 귀여운거 보는게 힐링이 됨 ㅎㅎㅎ

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

밀린 스터디 노트 임당ㅠㅠ 어제부터 줌 독서실 안되는 이유가 뭐지??? 자꾸 딴짓하고 싶다.

🔥 1주차 todo 리스트 (5/3~5/7)

파이썬 기초1 파이썬 기초23~ ~파이썬 기초4~ ~파이썬 기초5~ ~파이썬 기초6~ ~파이썬 기초7~ 조건식 조건문(if문) 양자택일 조건문(ifelse문) ifelse문과 조건식 ~파이썬 기초8~ 다자택일 조건문(ifelif문) 다자택일 조건문 사용시 주의할 점 중첩조건문

파이썬 기초9~10 파이썬 기초문풀1 파이썬 기초문풀2 파이썬 기초문풀3

📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 조건식

• 어떤 조건에 따라 실행이 분기되는 식.

A if 조건식 else B → 조건식의 결과가 True 이면 A실행, 그렇지 않으면 B 실행

num1 = 10
num2 = 100

numResult = True if num1 > num2 else False

print('num1 > num2 : {}'.format(numResult))
print('num1은 num2보다 크다.')

num1 > num2 : False num1은 num2보다 크다.

실습_01

적설량을 입력하고 적석량이 30mm 이상이면  대설경보를 발령하고
그렇지 않으면 대설 경보를 해제하는 코드를 작성해 보자.

limitSnowAmount = 30
snowAmount = int(input('적설량 입력(mm)  : '))

print('적설량 : {}mm, {}'.format(snowAmount, '대설 경보 발령!!')) if snowAmount >= limitSnowAmount else \
    print('적설량 : {}mm, {}'.format(snowAmount, '대설 경보 해제~~'))

적설량 입력(mm) : 59 적설량 : 59mm, 대설 경보 발령!! 적설량 입력(mm) : 18 적설량 : 18mm, 대설 경보 해제~~

실습_02

국어, 영어, 수학 점수를 입력하면 조건식을 이용해서 과목별 결과와 전체 결과를 출력하는 코드를 작성해 보자.

import operator

passScore1 = 60
passScore2 = 70

kor = int(input('국어 점수 : '))
eng = int(input('영어 점수 : '))
mat = int(input('수학 점수 : '))

totalScore = kor + eng + mat
avgScore = totalScore / 3

print('국어  : PASS') if operator.ge(kor, passScore1) else print('국어 : FAIL')
print('영어  : PASS') if operator.ge(eng, passScore1) else print('영어 : FAIL')
print('수학  : PASS') if operator.ge(mat, passScore1) else print('수학 : FAIL')

print('총점 : %d, 평균 : %.2f' % (totalScore, avgScore))

📝 조건문(if문)

• 특정조건에 따라 프로그램을 분기한다.
• 조건문의 종류 if문 → 단일조건 if ~ else문 → 양자택일 if ~ elif문 → 다자택일 (다중조건)
  

if문 if 조건식 : ____실행문

• False 일때, 아무런 반응이 없다.
  

조건문 기본

if 10 > 5 :
    print('10은 5보다 크다.')

num1 = 10
num2 = 20

if num1 >= num2 :
    print('num1은 num2보다 작거나 같다.')

10은 5보다 크다.

실습_03

국어, 영어, 수학점수를 입력하고 평균이 90점 이상이면 참 잘했어요.를 출력하는 코드를 작성하자.

kor = int(input('국어 점수 입력 : '))
eng = int(input('영어 점수 입력 : '))
mat = int(input('수학 점수 입력 : '))

avgScore = (kor + eng + mat) / 3
print('평균 : {}'.format(avgScore))

if avgScore >= 90:
    print('참 잘 했어요~~')

국어 점수 입력 : 90 영어 점수 입력 : 93 수학 점수 입력 : 100 평균 : 94.33333333333333 참 잘 했어요~~

실습_04

highTemperature = 28
lowTemperature = 20

innerTemperaute = int(input('실내온도 입력 : '))

if innerTemperaute >= highTemperature:
    print('냉방 작동!')

if innerTemperaute <= lowTemperature:
    print('난방 작동!')

실내온도 입력 : 14 난방 작동!

📝 양자택일 조건문(if~else문)

• if ~ else문 : 조건식 결과에 따라 둘 중에 하나가 실행됨

if ~ else문 if 조건식: __실행문 else: __실행문

pass 키워드 실행문이 없을때, 나중에 작성하겠다.

len() 함수 = 문자열의 길이

실습_05

나이가 65세 이상이면 교통요금 무료를 적용하는 프로그램을 만들어 보자.

seniorAge = 65

passAge = int(input('나이 입력 : '))
if passAge >= seniorAge:
    print('무료 대상 승객 입니다.')
else:
    print('유료 대상 승객 입니다.')

나이 입력 : 43 유료 대상 승객 입니다. 나이 입력 : 68 무료 대상 승객 입니다.

실습_06

소수점 첫번째 자리에서 반올림하는 프로그램을 만들어 보자.

floatNum = float(input('소수 입력 : '))

if floatNum - int(floatNum) >= 0.5:
    print('올림 : {}'.format(int(floatNum) + 1))
else:
    print('버림 : {}'.format(int(floatNum)))

조건식(삼항연산자)의 두가지 사용법

• 조건식 결과에 따른 실행만 하는 경우

  print('포인트 사용 가능') if userPoint >= minAblePoint else print('포인트 사용 불가능')

• 조건식 결과를 변수에 할당하는 경우

  result = '가능' if userPoint >= minAblePoint else '불가능'
  print('포인트 사용 가능 여부 : {}'.format(result))

• 조건식 → if ~ else문 : 모든 조건식(삼항연산자)은 if~ else문으로 변경할 수 있다.

양자택일

print('포인트 사용 가능') if userPoint >= minAblePoint else print('포인트 사용 불가능')
    ↓    ↓    ↓
if userPoint >= minAblePoint:
    print('포인트 사용 가능')
else:
    print('포인트 사용 불가능')

결과를 참(True)/거짓(False)으로 할당한다.

result = '가능' if userPoint >= minAblePoint else '불가능'
print('포인트 사용 가능 여부 : {}'.format(result))
    ↓    ↓    ↓
if userPoint >= minAblePoint:
    result = '가능'
else:
    result = '불가능'
print('포인트 사용 가능 여부 : {}'.format(result))

• if ~ else문 → 조건식 : 모든 if~ else문을 조건식(삼항연산자)은 변경할 수 있는 것이 아니다. 조건식으로 코딩하기 어렵다.

실습_07

비올 확률을 입력하고 비올 확률이 55%이상이면 '우산을 챙기세요'를 
그렇지 않음'양산을 챙기세요' 출력하는 코드를 작성하자.

rainPercentage = int(input('비올 확률 입력 : '))
minRainpercentage = 55

if rainPercentage >= minRainpercentage:
    print('우산을 챙기세요.')
else:
    print('양산을 챙기세요.')

입력 → 기준자 → 조건식 → 실행문

실습_08

다음의 요구 사항을 해결하기 위해서 조건식과 if ~ else문 중 알맞은 구문을 사용해보자.

todayTemper = int(input('오늘의 온도 입력 : '))
standardTemper = 11

print('산책하기 좋은 날씨입니다.') if todayTemper >= standardTemper else print('감기 조심하세요.')

if todayTemper >= standardTemper:
    print('산책하기 좋은 날씨입니다.')
else:
    print('감기 조심하세요.')

📝 다자택일 조건문(if~elif문)

• if ~ elif문 : 여러가지 조건식 결과에 따라 실행문이 결정됨.

입력 → 기준자 → 조건식 → 실행문

예시

exampleScore = int(input('시험 성적 입력 : '))
grades = ''

if exampleScore >= 90:
    grades = 'A'
elif exampleScore >= 80:
    grades = 'B'
elif exampleScore >= 70:
    grades = 'C'
elif exampleScore >= 60:
    grades ='D'
else:                # 생략 가능
    grades = 'F'

print('성적 : {} \t 학점 : {}'.format(exampleScore, grades))

시험 성적 입력 : 89 성적 : 89 학점 : B

실습_09

계절을 입력하면 영어로 번역되는 프로그램을 만들어 보자.

print('계절 : 봄, 여름, 가을, 겨울')
seasonstr = input('계절 입력 : ')

if seasonstr == '봄':
    print('{} : {}'.format('봄', 'Spring'))
elif seasonstr == '여름':
    print('{} : {}'.format('여름', 'Summer'))
elif seasonstr == '가을':
    print('{} : {}'.format('가을', 'Fall'))
elif seasonstr == '겨울':
    print('{} : {}'.format('겨울', 'Winter'))
else:                # 생략 가능
    print('검색 할 수 없습니다.')

계절 : 봄, 여름, 가을, 겨울 계절 입력 : 가을 가을 : Fall

실습_10

키오스크에서 메뉴를 선택하면 영수증이 출력되는 프로그램을 만들어 보자.

print('1.카페라떼(3.5) \t 2.에스프레소(3.0) \t 3.아메리카노(2.0) \t 4.곡물라떼(4.0) \t 5.밀크티(4.3)')
userSelectNumber = input('메뉴 선택 : ')

print('-' * 30)
if userSelectNumber == '1':
    print('메뉴 : {} \n가격 : {}'.format('카페라떼', '3,500원'))
elif userSelectNumber == '2':
    print('메뉴 : {} \n가격 : {}'.format('에스포레소', '3,000원'))
elif userSelectNumber == '3':
    print('메뉴 : {} \n가격 : {}'.format('아메리카노', '2,000원'))
elif userSelectNumber == '4':
    print('메뉴 : {} \n가격 : {}'.format('곡물라떼', '4,000원'))
elif userSelectNumber == '5':
    print('메뉴 : {} \n가격 : {}'.format('밀크티', '4,300원'))
print('-' * 30)

📝 다자택일 조건문 사용시 주의할 점

• 조건식 순서가 중요하다. → 순서대로 나열한다.
• 조건범위를 명시한다.

실습_11

자동차 배기량에 따라 세금을 부과한다고  할 때, 
다음 표를 보고 배기량을 입력하면 세금이 출력 되는 프로그램을 만들어보자.

배기량 5000cc 이상            세금 600,000원
배기량 5000cc 미만 4000cc 이상 세금 500,000원
배기량 4000cc 미만 3000cc 이상 세금 400,000원
배기량 3000cc 미만 2000cc 이상 세금 300,000원
배기량 2000cc 미만 1000cc 이상 세금 200,000원
배기량 1000cc 미만            세금 100,000원

입력 → 숫자변환 → 조건식 : 양자택일 → 실행문

carDisplacement = int(input('자동차 배기량 입력 : '))

if carDisplacement < 1000:
    print('세금 : 100,000원')
elif carDisplacement < 2000 and carDisplacement >= 1000:
    print('세금 : 200,000원')
elif carDisplacement < 3000 and carDisplacement >= 2000:
    print('세금 : 300,000원')
elif carDisplacement < 4000 and carDisplacement >= 3000:
    print('세금 : 400,000원')
elif carDisplacement < 5000 and carDisplacement >= 4000:
    print('세금 : 500,000원')
elif carDisplacement >= 5000:
    print('세금 : 600,000원')

📝 중첩조건문

• 조건문 안에 또 다른 조건문이 있을 수 있다. 3, 4단계 이상의 조건문은 사용하지 않는다.
  

실습_11

출퇴근시 이용하는 교통수단에 따라 세금을 감면해 주는 정책를 세우려고 한다.
다음 내용에 맞게 프로그램을 만들어 보자.

selectNum = int(input('출퇴근 대상자 인가요? \t 1.Yes \t 2.No'))

if selectNum == 1:
    print('교통수단을 선택하세요.')
    trans = int(input('1.도보,자전거 \t 2.버스,지하철 \t 3.자가용'))

    if trans == 1:
        print('세금 감면 5%')
    elif trans == 2:
        print('세금 감면 3%')
    elif trans == 3:
        print('세금 감면 1%')
elif selectNum == 2:
    print('세금 변동 없습니다.')
else:
    print('잘못 입력했습니다.')

💡 오늘을 마무리하면서 ...

할말많지만 하지않겠어..

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

어제 저녁 시할아버지 제사로 포항을 급하게 다녀왔다. 포항가는 KTX 안에서 강의를 들었는데 아직 디지털기기 쪼렙이라 패드로 키보드를 치는건 무리더라 ㅠㅠ 내가 아직 기계치일수도 있는 것이기도 하고, 늦은 공부를 시작해 보련다. 정리 할 공부량이 많지만 요번주 시간이 너무 빠르다 ㅠㅠ 화이팅!!

🔥 1주차 todo 리스트 (5/3~5/7)

파이썬 기초1 파이썬 기초23~ ~파이썬 기초4~ ~파이썬 기초5~ 산술연산자(덧셈,뺄셈> 산술연산자<곱셈과 나눗셈> 산술연산자<나머지와 몫> 산술연산자<거듭제곱> 복합연산자 ~파이썬 기초6~~ 비교연산자<숫자비교> 비교연산자<문자비교> 논리연산자 operator모듈

파이썬 기초7 파이썬 기초8 파이썬 기초9~10 파이썬 기초문풀1 파이썬 기초문풀2 파이썬 기초문풀3

📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 연산자란?

result = data1 + data2

• 피연산자(data1, data2)를 연산자로 계산
  

📝 연산자종류

• 산술 연산자 : +, -, , /, %, //, *
• 할당 연산자 : =, +=, -=, *=, /=, %=, //=
• 비교 연산자 : >, >=, <, <=, ==, != (== 같다/ != 같지않다/다르다)
  

📝 산술 연산자 <덧셈>

# 정수를 이용한 덧셈
num1 = 9
num2 = 3
result = num1 +num2
print(f'result = {result}')

# 실수를 이용한 덧셈
fNum1 = 3.14
fNum2 = 0.12
result = fNum1 + fNum2
print(f'result : {result}')
print("result : %.2f" % result)

# 정수와 실수를 이용한 덧셈
result = num1 + fNum2
print(f'result : {result}')

# 문자를 이용한 덧셈
str1 = 'Good'
str2 = ' '
str3 = 'morning'
result = str1 + str2 + str3
print(f'result : {result}')

# 숫자와 문자를 이용한 덧셈
result = num1 + str1
print(f'result : {result}')

result = 12 result : 3.2600000000000002 result : 3.26 result : 9.12 result : Good morning TypeError: unsupported operand type(s) for +: 'int' and 'str'

실습_01

#  국어, 영어, 수학 점수를 입력하고 합계를 출력해보자.
kor = int(input('국어 점수 : '))
eng = int(input('영어 점수 : '))
mat = int(input('수학 점수 : '))
total = kor + eng + mat

print('국어 점수 {}'.format(kor))
print('영어 점수 {}'.format(eng))
print('수학 점수 {}'.format(mat))
print('합계 {}'.format(total))

국어 점수 : 85 영어 점수 : 90 수학 점수 : 95 국어 점수 85 영어 점수 90 수학 점수 95 합계 270

📝 산술 연산자 <뺄셈>

# 정수를 이용한 뺄셈
num1 = 10
num2 = 29
result = num1 - num2
print(f'num1 : {num1}')
print(f'num2 : {num2}')
print(f'result : {result}')

# 실수를 이용한 뺼셈
fNum1 = 3.14
fNum2 = 0.14
result = fNum1 - fNum2
print(f'fNum1 : {fNum1}')
print(f'fNum2 : {fNum2}')
print(f'result : {result}')
print(f'type of result : {type(result)}')

# 정수와 실수를 이용한 뺄셈
result = num1 - fNum1
print(f'Num1 : {num1}')
print(f'fNum1 : {fNum1}')
print(f'result : {result}')
print(f'type of result : {type(result)}')

# 문자(열)을 이용한 뺄셈
str1 = 'Good'
str2 = ' '
str3 = 'afternoon'
result = str1 - str2 - str3
print('result : {}'.format(result))

num1 : 10 num2 : 29 result : -19 fNum1 : 3.14 fNum2 : 0.14 result : 3.0 type of result : <class 'float'> Num1 : 10 fNum1 : 3.14 result : 6.859999999999999 type of result : <class 'float'> TypeError: unsupported operand type(s) for -: 'str' and 'str'

실습_02

# 이번달 알바비와 카드값을 입력하고, 남은 금액이 얼마인지 출력해 보자.
partTimePay = int(input('알바비 입력 : '))
cardMoney = int(input('카드값 입력 : '))
result = partTimePay - cardMoney

print('알비비 : {}원'.format(partTimePay))
print('카드값 : {}원'.format(cardMoney))
print('남는 금액 : {}원'.format(result))

알바비 입력 : 800000 카드값 입력 : 453000 알비비 : 800000원 카드값 : 453000원 남는 금액 : 347000원

📝 산술 연산자 <곱셈과 나눗셈>

# 숫자(정수, 실수)를 이용한 곱셈
num1 = 20
fNum1 = 3.14
result = num1 * fNum1
print('result : {}'.format(result))
print('result : %.2f' % result)

# 문자(열)을 이용한 곱셈
str1 = 'Hi '
result = str1 * 7
print('result : {}'.format(result))

# 숫자(정수, 실수)를 이용한 나눗셈
num1 = 10
num2 = 3
result = num1 / num2
print('num1 : {}, num2 : {}'.format(num1, num2))
print('result :{}'.format(result))
print('result : %.2f' % result)

# 0을 나눗셈 하는 경우
num1 = 0
num2 = 3
result = num1 / num2
print('result : {}'.format(result))

# 0으로 나누는 경우
result = num2 / num1
print('result :{}'.format(result))

result : 62.800000000000004 result : 62.80 result : Hi Hi Hi Hi Hi Hi Hi num1 : 10, num2 : 3 result :3.3333333333333335 result : 3.33 result : 0.0 ZeroDivisionError: division by zero

• 0으로는 나눌 수 없다.
• 0을 나눗셈하는 경우엔 항상 결과는 0이다.
• 나눗셈의 결과는 항상 실수(float)이다.

# 나눗셈의 결과는 항상 실수(float)이다.
num1 = 20
num2 = 10
result = num1 / num2
print('result :{}'.format(result))
print('type of result : {}'.format(type(result)))

result :2.0 type of result : <class 'float'>

실습_03

# 국어, 영어, 수학 점수를 입력하고 합계와 평균을 출력해 보자.
kor = int(input('국어 점수 : '))
eng = int(input('영어 점수 : '))
mat = int(input('수학 점수 : '))
total = kor + eng + mat

print('국어 점수 {}'.format(kor))
print('영어 점수 {}'.format(eng))
print('수학 점수 {}'.format(mat))
print('합계 {}'.format(total))
print('평균 {}'.format(total / 3))
print('평균 %.2f' % (total / 3))

국어 점수 : 85 영어 점수 : 90 수학 점수 : 85 국어 점수 85 영어 점수 90 수학 점수 85 합계 260 평균 86.66666666666667 평균 86.67

실습_04

# 학급 전체 학생수 입력
# 한 모둠에 속하는 학생수 입력
# 전체 모둠 수 입력

everyOne = int(input('전체 학생수 : '))
stuCntOfGroup = int(input('한 모둠 학생 수 : '))
allGroupCnt = everyOne / stuCntOfGroup

print('전체 학생 수 : {}'.format(everyOne))
print('한 모둠 학생 수 : {}'.format(stuCntOfGroup))
print('모둠 수 : {}'.format(allGroupCnt))
print('모둠 수 : {}'.format(int(allGroupCnt)))

전체 학생수 : 25 한 모둠 학생 수 : 4 전체 학생 수 : 25 한 모둠 학생 수 : 4 모둠 수 : 6.25 모둠 수 : 6

📝 산술 연산자 <나머지와 몫>

# 예시 _ / 나눗셈
num1 = 10
num2 = 3
result = num1 / num2
print('num1: {}, num2: {}, result: {}'.format(num1, num2, result))

# 나눗셈 결과 나머지 만 구함 _ % 나머지
num1 = 10
num2 = 3
result = num1 % num2

print('num1: {}, num2: {}, result: {}'.format(num1, num2, result))

# 나눗셈 결과 몫 만 구함 _ // 몫
num1 = 10
num2 = 3
result = num1 // num2

print('num1: {}, num2: {}, result: {}'.format(num1, num2, result))

num1: 10, num2: 3, result: 3.3333333333333335 num1: 10, num2: 3, result: 1 num1: 10, num2: 3, result: 3

📝 divmod() 함수

• 나머지와 몫을 한번에 구하기

num1 = 10
num2 = 3

result = divmod(num1, num2)          # 인덱스 개념 [3, 1]
print('result: {}'.format(result))
print('몫 : {}'.format(result[0]))
print('나머지 : {}'.format(result[1]))

result: (3, 1) 몫 : 3 나머지 : 1

실습_05

# 학급 전체 학생수 입력
# 한 모둠에 속하는 학생수 입력
# 전체 모둠 수과 남는 학생수 입력

everyOne = int(input('전체 학생수 : '))
stuCntOfGroup = int(input('한 모둠 학생 수 : '))
allGroupCnt = everyOne // stuCntOfGroup
overGroupCnt = everyOne % stuCntOfGroup

print('전체 학생 수 : {}'.format(everyOne))
print('한 모둠 학생 수 : {}'.format(stuCntOfGroup))
print('모둠 수 : {}'.format(allGroupCnt))
print('남는 학생 수 :{}'.format(overGroupCnt))

# divmod() 함수를 이용
result = divmod(everyOne, stuCntOfGroup)
print('result : {}'.format(result))
print('모둠 수 : {}'.format(result[0]))
print('남는 학생 수 : {}'.format(result[1]))

전체 학생수 : 25 한 모둠 학생 수 : 4 전체 학생 수 : 25 한 모둠 학생 수 : 4 모둠 수 : 6 남는 학생 수 :1 result : (6, 1) 모둠 수 : 6 남는 학생 수 : 1

실습_06

# 123개의 사과를 4개씩 직원들한테 나누어 주려고 한다.
# 최대 나누어 줄수 있는 직원수와 남는 사과 개수를 출력해 보자.

emploree = 123
apple = 4
result = divmod(emploree, apple)

print('사과를 나누어 줄 수 있는 최대 직원 수 : {}명'.format(result[0]))
print('남는 사과의 갯수 : {}명'.format(result[1]))

사과를 나누어 줄 수 있는 최대 직원 수 : 30명 남는 사과의 갯수 : 3명

📝 산술 연산자 <거듭제곱>

• 같은 수를 여러 번 곱한 값을 구한다.

num1 = 2
num2 = 3
result = num1 ** num2

print('num1 : {}'.format(num1))
print('num2 : {}'.format(num2))
print('result : {}'.format(result))

num1 : 2 num2 : 3 result : 8

📝 n의 m 제곱근의 공식 _ n ** (1/m)

# 2의 제곱근 구하기
result = 2 ** (1/2)
print('2의 제곱급 %f' % result)
print('2의 제곱급 %.2f' % result)

# 2의 3제곱근 구하기
result = 2 ** (1/3)
print('2의 3제곱급 %f' % result)
print('2의 3제곱급 %.2f' % result)

# 2의 4제곱근 구하기
result = 2 ** (1/4)
print('2의 4제곱급 %f' % result)
print('2의 4제곱급 %.2f' % result)

2의 제곱급 1.414214 2의 제곱급 1.41 2의 3제곱급 1.259921 2의 3제곱급 1.26 2의 4제곱급 1.189207 2의 4제곱급 1.19

📝 math모듈의 sqrt()와 pow()함수

sqrt()함수를 이용한 제곱근 구하기 → 항상 제곱근 만 구한다.

import math

print('2의 제곱근 %f' % math.sqrt(2))
print('2의 제곱근 %.2f' % math.sqrt(2))

print('3의 제곱근 %f' % math.sqrt(3))
print('3의 제곱근 %.2f' % math.sqrt(3))

print('4의 제곱근 %f' % math.sqrt(4))
print('4의 제곱근 %.2f' % math.sqrt(4))

pow()함수를 이용한 제곱근 구하기 → [0]의 [1] 제곱근을 구하는 함수.

import math

print('2의 3제곱근 %f' % math.pow(2, 3))
print('3의 4제곱근 %f' % math.pow(3, 4))

2의 3제곱근 8.000000 3의 4제곱근 81.000000

실습_07

아들이 엄마한테 용돈을 받는데, 첫 달에는  200원을 받고 매월 이전 달의 2배씩 인상하기로 했다.
12개월째 되는 달에는 얼마를 받을 수 있는 지 계산해 보자.

firstMonthMoney = 200
after12Month = ((firstMonthMoney * 0.01) ** 12) * 100
print('12개월 후 용돈 : %.f 원' % after12Month)

after12Month =int(after12Month)
strResult = format(after12Month, ',')
print('12개월 후 용돈 : %s원' % strResult)

print(strResult, '원')

12개월 후 용돈 : 409600 원 12개월 후 용돈 : 409,600원 409,600 원

📝 복합 연산자

• 할당(대입) 연산자 = (오른쪽의 값을 왼쪽에 할당/대입한다.)

  num1 = 10
  num2 = 20
  result = num1 + num2

  복합연산자

• += 덧셈 연산 후 할당
• -= 뺄셈 연산 후 할당
• *= 곱셈 연산 후 할당
• /= 나눗셈 연산 후 할당
• %= 나머지 연산 후 할당
• //= 몫 연산후 할당
• **= 거듭제곱 연산후 할당

예시

num = 10

num1 = num + 6
num1 += 1

print('num1 : {}'.format(num1))

num1 : 17

실습_08

다음 표를 참고해서 연간 누적 강수량을 출력해보자.
|월| 1| 2| 3| 4| 5| 6| 7| 8| 9| 10| 11| 12|
|강수량| 30| 45| 47| 55| 65| 100| 128| 209| 204| 186| 67| 25|

rain = 0
totalRainAmount = 0


totalRainAmount += 30
print('1월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 45
print('2월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 47
print('3월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 55
print('4월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 65
print('5월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 100
print('6월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 128
print('7월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 209
print('8월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 204
print('9월 누적 강수량 : {}mm '.format(totalRainAmount))

totalRainAmount += 186
print('10월 누적 강수량 : {}mm '.format(format(totalRainAmount,',')))

totalRainAmount += 67
print('11월 누적 강수량 : {}mm '.format(format(totalRainAmount,',')))

totalRainAmount += 25
print('12월 누적 강수량 : {}mm '.format(format(totalRainAmount,',')))


avgRainAmount = totalRainAmount / 12


print('-' * 30)
print('연간 누적 강수량 : {}mm '.format(format(totalRainAmount,',')))
print('연간 평균 강수량 : {}mm '.format(avgRainAmount))
print('-' * 30)

1월 누적 강수량 : 30mm 2월 누적 강수량 : 75mm 3월 누적 강수량 : 122mm 4월 누적 강수량 : 177mm 5월 누적 강수량 : 242mm 6월 누적 강수량 : 342mm 7월 누적 강수량 : 470mm 8월 누적 강수량 : 679mm 9월 누적 강수량 : 883mm 10월 누적 강수량 : 1,069mm 11월 누적 강수량 : 1,136mm 12월 누적 강수량 : 1,161mm

연간 누적 강수량 : 1,161mm 연간 평균 강수량 : 96.75mm

📝 비교 연산자 <숫자비교>

• 연산결과는 bool(논리형)이다.

num1 = 10
num2 = 5

result = num1 > num2   # True
print('num1 > num2 : {}'.format(result))

result = num1 >= num2   # True
print('num1 >= num2 : {}'.format(result))

result = num1 < num2   # False
print('num1 < num2 : {}'.format(result))

result = num1 <= num2   # False
print('num1 <= num2 : {}'.format(result))

result = num1 == num2   # False
print('num1 == num2 : {}'.format(result))

result = num1 != num2   # True
print('num1 != num2 : {}'.format(result))

실습_09

숫자 두개를 입력한 후 비교연산 결과를 출력하는 코드를 작성하자.

userInputNumber1 = int(input('첫번째 숫자 입력 : '))
userInputNumber2 = int(input('두번째 숫자 입력 : '))

print('{} > {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 > userInputNumber2)))
print('{} >= {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 >= userInputNumber2)))
print('{} < {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 < userInputNumber2)))
print('{} <= {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 <= userInputNumber2)))
print('{} == {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 == userInputNumber2)))
print('{} != {} : {}'.format(userInputNumber1, userInputNumber2, (userInputNumber1 != userInputNumber2)))

첫번째 숫자 입력 : 2 두번째 숫자 입력 : 15 2 > 15 : False 2 >= 15 : False 2 < 15 : True 2 <= 15 : True 2 == 15 : False 2 != 15 : True

실습_10

자동차의 전장과 전폭을 입력하면 자동차 기계 세차 가능여부를 출력하는 코드를 작성해 보자.
(최대 전장길이 : 5200mm, 최대 전폭길이 : 1985mm)
maxLength = 5200
maxWidth = 1985

myCarLength = int(input('전장 길이 입력 : '))
myCarWidth = int(input('전폭 길이 입력 : '))

print('전장 가능 여부 : {}'.format(myCarLength <= maxLength))
print('전폭 가능 여부 : {}'.format(myCarWidth <= maxWidth))

전장 길이 입력 : 5201 전폭 길이 입력 : 1985 전장 가능 여부 : False 전폭 가능 여부 : True

📝 비교 연산자 <문자비교>

• 문자 비교 : 아스키 코드를 이용한 비교연산 아스키코드는 구글링하여 찾는다.

# 문자와 아스키 코드 변환
cha1 = 'A'    # 65
cha2 = 'S'    # 83

print('\'{}\' > \'{}\' : {}'.format(cha1, cha2, (cha1 > cha2)))
print('\'{}\' >= \'{}\' : {}'.format(cha1, cha2, (cha1 >= cha2)))
print('\'{}\' < \'{}\' : {}'.format(cha1, cha2, (cha1 < cha2)))
print('\'{}\' <= \'{}\' : {}'.format(cha1, cha2, (cha1 <= cha2)))
print('\'{}\' == \'{}\' : {}'.format(cha1, cha2, (cha1 == cha2)))
print('\'{}\' != \'{}\' : {}'.format(cha1, cha2, (cha1 != cha2)))

'A' > 'S' : False 'A' >= 'S' : False 'A' < 'S' : True 'A' <= 'S' : True 'A' == 'S' : False 'A' != 'S' : True

ord() 함수 _ 알파벳(문자)을 입력하면 아스키 코드(숫자)로 출력(10진법)

print('\'A\' -> {}'.format(ord('A')))
print('\'S\' -> {}'.format(ord('S')))

chr() 함수 _ 아스키 코드(숫자)를 입력하면 알파벳(문자)로 출력

print('65 -> {}'.format(chr(65)))
print('83 -> {}'.format(chr(83)))

• 문자열 비교 : 문자열 자체를 비교한다. (True / False) 같다/같지않다 두개만 가능하다. (문자열은 크다/작다로 비교 할 수 없다.) 한글자만 틀려도 틀리다.

str1 = 'Hello'
str2 = 'hello'

print('{} == {} : {}'.format(str1, str2, (str1 == str2)))
print('{} != {} : {}'.format(str1, str2, (str1 != str2)))

Hello == hello : False Hello != hello : True

실습_11

아이디와 패스워드를 입력한 후 비교결과을 출력하자.
systemID = 'administrator@gmail.com'
systemPW = '!@#$%qwertyQWERTY'

userInputID = input('아이디 입력 : ')
userInputPW = input('비밀번호 입력 : ')

print('아이디 비교 결과 : {}'.format(systemID == userInputID))
print('비밀번호 비교 결과 : {}'.format(systemPW == userInputPW))

아이디 입력 : administrator@gmail.com 비밀번호 입력 : 12345qwerQWERTY 아이디 비교 결과 : True 비밀번호 비교 결과 : False

📝 논리 연산자

• 피연산자의 논리(True/False)를 이용한 연산 논리 연산자 종류 : and, or, not

• and 연산 A and B A와 B모두 True인 경우만 결과값으로 True이다.

• or 연산 A or B A와 B중 어느하나만 True이면 결과값은 True이다.

• not 연산 (부정연산자) not A A의 상태를 부정하는 결과를 나타낸다.

  
  

예시

백신 접종 대상자는 20세 미만 또는 65세이상자에 한합니다.
논리연산자를 이용해서 코딩해보자.

age = int(input('나이 입력 : '))
vaccine = (age < 20) or (age >= 65)
print('age: {}, result: {}'.format(age, vaccine))

나이 입력 : 38 age: 38, result: False

나이 입력 : 66 age: 66, result: True

실습_12

국어, 영어, 수학 점수를 입력하고 평균이 10점 이상이면 True를 출력하는 코드를 작성해보자.
(단, 과목별 점수가 최소 60이상인 경우에 True를 출력한다.)

passScore1 = 60
passScore2 = 70

kor = int(input('국어 점수 입력 : '))
eng = int(input('영어 점수 입력 : '))
mat = int(input('수학 점수 입력 : '))

avgScore = (kor + eng + mat) / 3
passScoreResult = avgScore >= passScore2

korResult = kor >= passScore1
engResult = eng >= passScore1
matrResult = mat >= passScore1

subjectResult = korResult and engResult and matrResult

print('평균 : {}, 결과 : {}'.format(avgScore, passScoreResult))

print('국어 : {}, 결과 : {}'.format(kor,korResult))
print('영어 : {}, 결과 : {}'.format(eng,engResult))
print('수학 : {}, 결과 : {}'.format(mat,matrResult))


print('과락 결과 : {}'.format(subjectResult))
print('최종 결과 : {}'.format(avgScore and subjectResult))

국어 점수 입력 : 89 영어 점수 입력 : 70 수학 점수 입력 : 60 평균 : 73.0, 결과 : True 국어 : 89, 결과 : True 영어 : 70, 결과 : True 수학 : 60, 결과 : True 과락 결과 : True 최종 결과 : True

📝 operator모듈

모듈이란? 누군가 이미 만들어 놓은 훌륭한 기능

• 산술연산자 관련 함수

  num1 = 8
  num2 = 3
  

import operator

print('{} + {} : {}'.format(num1, num2, operator.add(num1,num2))) print('{} - {} : {}'.format(num1, num2, operator.sub(num1,num2))) print('{} * {} : {}'.format(num1, num2, operator.mul(num1,num2))) print('{} / {} : {}'.format(num1, num2, operator.truediv(num1,num2))) print('{} % {} : {}'.format(num1, num2, operator.mod(num1,num2))) print('{} // {} : {}'.format(num1, num2, operator.floordiv(num1,num2))) print('{} ** {} : {}'.format(num1, num2, operator.pow(num1,num2)))

***
8 + 3 : 11
8 - 3 : 5
8 * 3 : 24
8 / 3 : 2.6666666666666665
8 % 3 : 2
8 // 3 : 2
8 ** 3 : 512
***
<br/>

- 비교 연산자 관련 함수
```python
num1 = 8
num2 = 3

import operator

print('{} > {} : {}'.format(num1, num2, operator.gt(num1,num2)))
print('{} >= {} : {}'.format(num1, num2, operator.ge(num1,num2)))
print('{} < {} : {}'.format(num1, num2, operator.lt(num1,num2)))
print('{} <= {} : {}'.format(num1, num2, operator.le(num1,num2)))
print('{} == {} : {}'.format(num1, num2, operator.eq(num1,num2)))
print('{} != {} : {}'.format(num1, num2, operator.ne(num1,num2)))

8 > 3 : True 8 >= 3 : True 8 < 3 : False 8 <= 3 : False 8 == 3 : False 8 != 3 : True

• 논리 연산자 관련 함수

  flag1 = True
  flag2 = False
  

import operator

print('{} and {} : {}'.format(flag1, flag2, operator.and_(flag1,flag2))) print('{} or {} : {}'.format(flag1, flag2, operator.or_(flag1,flag2))) print('{} not {} : {}'.format(flag1, flag2, operator.not_(flag1)))

***
True and False : False
True or False : True
True not False : False
***
<br/>

`실습_13`
```python
이전 시간에 실습했던 백신 접종 대상자 출력코드를 operator 모듈을 이용해서 변경해 보자.
[이전 실습]
백신접종 대상자는 20세 미만 또는 65세 이상자에 한합니다.를 논리연산자를 이용해서 코딩해보자.

age = int(input('나이 입력 : '))

import operator
vaccine =operator.or_(operator.lt(age, 20), operator.ge(age, 65))
print('age : {}, result : {}'.format(age, vaccine))

나이 입력 : 48 age : 48, result : False 나이 입력 : 7 age : 7, result : True

실습_13

import operator

import random
rInt = random.randint(10, 100)

num10 = operator.floordiv(rInt, 10)   # 몫
num1 = operator.mod(rInt, 10)       # 나머지

print('난수 : {}'.format(rInt))
print('십의 자리 : {}'.format(num10))
print('일의 자리 : {}'.format(num1))
print('십의 자리는 3의 배수이다. : {}'.format(operator.mod(num10, 3) == 0))   # 나머지
print('일의 자리는 3의 배수이다. : {}'.format(operator.mod(num1, 3) == 0))    # 나머지

난수 : 23 십의 자리 : 2 일의 자리 : 3 십의 자리는 3의 배수이다. : False 일의 자리는 3의 배수이다. : True

💡 오늘을 마무리하면서 ...

와아.. 진짜 하루 스터디 노트 놓치니까 답이 없네ㅠㅠ 부지런히 해도 힘들구나... 영상강의도 중요한데 매일 하는 스터디 노트도 중요함 안 중요한게 하나도 없는 것 같은데.. 점점 많아지는 과제랑 수업을 잘 할수 있을까? 게을러 지면 낙오다. 하루의 귀찮아하면 다음은 없는거야!! ㅠ 힘들다 진짜... 벌서 이렇게 힘들면 안되는데 사람들은 어떻게 공부하고 있을까???

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

공식적 스터디노트 첫번째 블로그 만들고 OT글 쓰느라 시간을 뺏어 먹었다. 벨로그 쓰는 것도 어려워.. 점점 익숙해지겠지, 휴 =33 이걸 쓰고 있다는게 놀라움 ㅎ_ㅎ

🔥 1주차 todo 리스트 (5/3~5/7)

파이썬 기초1 기본 프로그램에 관한 설명과 실행방법 (0103) ~파이썬 기초23 파이참(pycham) 설치 데이터와 메모리 그리고 데이터 출력 변수와 자료형, 자료형 변환 파이썬 기초4 데이터입력/출력 format()와 형식문자 산술연산자(+/-)

파이썬 기초5 파이썬 기초6 파이썬 기초7 파이썬 기초8 파이썬 기초9~10 파이썬 기초문풀1 파이썬 기초문풀2 파이썬 기초문풀3

📝 weekly 데이터 사이언스 스쿨 퀴즈

💻 핵심 내용 정리

📝 파이썬이란?

• 1991년 네덜란드 개발자 귀로 반 로섬이 만듦.
• 처음 소규모로 프로젝트에 사용하기 위해서 만듦. 이후 주변 사람들로부터 인기를 얻어 완성도가 높은 파이썬이 탄생함.
• 구글은 자바와 함께 파이썬을 메인 언어로 사용하고 있음.
• 'python' 이라는 이름은 귀로 반 로섬이 좋아하는 프로그램에서 유래됨.
  

📝 파이썬의 특징

• 무한 정수를 처리할 수 있다. (다른 언어는 불가능 파이썬만 가능)
• 문법 구조가 쉽다
• 다양하고 뛰어난 모듈이 많다. (모듈이란 이미 다른 사람들이 만들어놓은 코딩, 우리가 가져다 써서 코딩을 좀 더 쉽게 할수있음 )
  

📝 변수란?

• 데이터가 저장되어 있는 메모리 공간.
• 수학에서는 '='는 같다는 의미지만, 파이썬에서는 할당한다고 한다.
• 파이썬에서 '=='는 같다라는 의미로 쓰인다. 예) ● = ♥ 오른쪽에 있는 하트를 원에 할당한다.(대입한다) ● == ♥ 원과 하트는 같다.
• 변수를 정의할 때 반듯이 '초기화' 하도록 한다.
  

📝 변수를 사용하는 이유

• 주로 데이타를 재사룔 하기 위한 목적으로 사용한다.
• 프로그램을 보다 효율적으로 관리할 수 있다.

실습_01

변수사용
숫자2개를 변수에 저장하고 이를 이룔해서 덧셈, 뺄셈, 곱셈, 나눗셈을 화면에 출력해보자.

a = 3
b = 12

# 덧셈
print(a + b)

# 뺄셈
print(a - b)

# 곱셈
print(a * b)

# 나눗셈
print(a / b)

실습_02

다음의 문구를 출력한다고 할 때 반복회는 데이터를 변수로 정의 해보자.

name = '박찬호'

print(name, '고객님께')
print(name, '고객님 안녕하세요.')
print('고객님께서 접수하신 A/S건에 대해서 연락을 드렸으나 연락이 어려워 메일 드립니다.')
print('--- 중략 ---')
print('A/S 접수 내용')
print('성함 :', name)
print('내용 : 에어컨고장')

📝 변수 작명법

• 영문을 사용
• 첫 번째는 소문자로
• 가급적 데이터의 의미를 파악할 수 있는 명사 사용
• 카멜표기법(customerBankAccount)또는 스네이크표기법(customer_bank_account) 사용
• 예약어(파이썬에서 이미 예약된 단어) 사용금지 → 내장함수

< 파이썬에서 사용하고 있는 예약어 불러오기 명령어 >

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

• 특수문자 사용금지(단, 언더바(_)는 사용가능
• 공백문자 사용금지
• 숫자는 사용해도 되지만 첫 번째 사용 금지

실습_03

변수 정의 (선언 및 초기화)와 사용
삼각형의 넓이를 계산하기 위한 가로, 세로의 (20cm,15cm) 변수를 정의 하고 계산 결과를 출력해 보자.
width = 20
height = 15

print(width * height / 2)
print(width * height)

📝 자료형(data type)이란?

• 효율적인 메모리 사용을 위해서 데이터를 정수현, 실수형, 문자(열)형, 논리형으로 구분한것. 정수 = int 실수 = float 문자(열) = str 논리형 = bool 문자(열)형은 작음따옴표 또는 큰따옴표를 사용할 수 있으나, 혼용해서 사용할 수는 없다.

• 정수는 메모리가 허용되는 한 무한 사용가능.

• 실수 는 대략 소수점 이하 17~18번째에서 데이터 손실이 일어남.

• 숫자(정수, 실수)도 따옴표로 묶으면 문자(열)로 인식함.

• 논리형인 True(참), False(거짓)을 구분하기 위한 자료형

  
  

📝 자료형 변환(type casting)이란?

• 데이터 타입을 변환하는 것으로 파이썬에서 제공하는 함수를 이용한다.

실습_04

# 소수에서 정수로
print(int(3.8))

# 정수에서 소수로
print(float(3))

# 문자열을 숫자로 변환
print(int("2") + int("5"))
print(float(1.1) + float(5.2))

# 숫자를 문자열로 변환
print(str(2) + str(5))

age = 7
print("제 나이는 " + str(age) + "살 입니다.")

3 3.0 7 6.300000000000001 25 제 나이는 7살 입니다.

• 논리형 변환할때에 정수는 True=1, 실수는 False=0 를 의미한다.
• 문자(열) 변환할때에 빈문자는 ''=데이터없음(False), 공백문자는 ' '=데이터있음(True) 공백도 엄연한 문자로 취급한다. → 빈문자 논리형

실습_05

var1 = 'True'
var2 = 'False'
print(type(var1))   # str
print(type(var2))   # str

var1 = bool(var1)
var2 = bool(var2)
print(type(var1))   # bool
print(type(var2))   # bool

print(var1 + var2)        # 2
print(type(var1 + var2))  # int

<class 'str'> <class 'str'> <class 'bool'> <class 'bool'> 2 <class 'int'>

📝 데이터입력

• input()함수를 이용한 데이터 입력

실습_06

print('키보드를 통해서 데이터를 입력하세요.')

usrInputData = input()
print(usrInputData)

• 입력가이드 문구 사용하기 input()함수에 입력가이드 문구 명시. (문자열을 입력 받는 함수)

실습_07

usrInputData = input('키보드를 통해서 데이터를 입력하세요.')
print(usrInputData)

• input()함수를 이용해서 입력한 데이터는 항상 문자(열) 자료형
• 형 변환 함수를 이용한 형 변환 = input('문자형을 입력하세요.') = int(input('문자형을 입력하세요.')) = float(input('문자형을 입력하세요.')) = bool(input('문자형을 입력하세요.'))
  

📝 데이터출력

• print()함수를 이용한 기본적인 데이터 출력
• 콤마(,)를 이용한 데이터 연속출력(2개 이상)
• .format() 문자열을 이용한 데이터 출력

실습_08

오늘은 2019년 10월 29일 입니다.
year = 2019
month = 10
day = 29
print("오늘은 " + str(year) + "년 " + str(month) + "월 " + str(day) + "일 입니다.")
print("오늘은 {}년 {}월 {}일 입니다.".format(year, month,day))

date_string = "오늘은 {}년 {}월 {}일 입니다."
print(date_string.format(year, month, day + 1))

#format 다루기 : 인덱스를 이용한 출력
print("저는 {1}, {0}, {2}를 좋아합니다!".format("박지성", "유재석", "빌 게이츠"))

# 문자열은 따옴표 안에 작성, 중괄호 안에 변수명 넣기, 뒤에 .format()괄호 안헤 중괄호 안에 들어갈 변수 작성
num_1 = 1
num_2 = 3
print("{0} 나누기 {1}은 {2:.2f}입니다.".format(num_1, num_2, num_1 / num_2))

오늘은 2019년 10월 29일 입니다. 오늘은 2019년 10월 29일 입니다. 오늘은 2019년 10월 30일 입니다. 저는 유재석, 박지성, 빌 게이츠를 좋아합니다! 1 나누기 3은 0.33입니다.

실습_09

새로운 방식 (f-string)
포맷의 약자인 f를 앞에 사용후 문자열은 따옴표 안에 작성, 변수는 중괄호에 넣어쓰기
name = "최지웅"
age = 32
print(f"제 이름은 {name}이고 {age}살 입니다.")

제 이름은 최지웅이고 32살 입니다.

📝 특수문자를 이용한 데이터 출력

• \t 들여쓰기(tab)
• \n 한줄 띄어쓰기(계행)
• ,end = '' 자동 계행 막기
  

📝 형식문자를 이용한 데이터 출력

• %s 문자열
• %d 정수
• %f 실수
  

📝 소수점 자릿수 정하기

• %.nf : 소수점 n자리 표현 실수라 실수로 받아야한다. (아닐 시 에러 발생)
  

💡 오늘을 마무리하면서 ...

진짜 스트레스 받는데.. 스터디 노트를 적으면서 하는건 좋은데 생각보다 시간을 엄청 잡아 먹는다. 오늘 사실 이것 저것 하느라 시간이 뺏겼는데, 진짜 이러다가는 가랑이 찢어지겠다. 4시간 30분도 택도 없어... 😵 2시 30분까지 공부 하자는 목표는 지켰는데, 오늘 처럼 오바됬을 땐 낼 어쩔티비 .. 스터디 노트 쓰는 게 일이 될 줄이야. 이렇게 디지털로 하는 수업이 진짜 적응이 어렵다는 것을 다시 한번 느낀다. 졸려서 오타가 있더래도 양해를 부탁드리며, 내일은 포항을 가야하는데 스터디 노트는 무리겠지?? 공부는 목표할당량 열심히 채우는 걸로...

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!

5월 2일 어제 OT가 있었습니다.

🤗반가워요!

늦깎이 DA/DS 취준생, 제로베이스 데이터 취업스쿨 15기 허제인입니다. (쪼매 쑥쓰럽네요 ㅎㅎㅎ) 저는 현재 직장인이고, 전공 조차 회계전공으로 컴퓨터에 대해선 잘 모르는 데 "잘 할 수 있을까? 내가 정말 배울수 있을까?" 라는 걱정이 컷는데, 옆에서 응원해주는 남편이 있어서 마음을 다시 다 잡은 것 같아요. 기초를 탄탄히 해야한다고 해서 눈물 콧물 쏟을 각오를 하고 공부 시작했습니다. 저는 끝까지 공부해서 졸업하는 게 목표예요!! 취업은 ... 😭 같이 공부할 친구 있으면 좋겠는데, 모르는 거 있을때 함께 얘기나눌 분이 있으시다면 언제든지 댓글이나 슬랙으로 챗주세요.

OT후기 새로운 분야 사람들과 만나 무언가를 한다는것 자체가 설레였는데, 뭔가 해야할 것이 많아서 우왕좌왕 ㅠㅠ (절대 무너지지 않을꺼야!!!) 한달을 1년 처럼~ (ㄹㅇ명언!!) 다시 되새김질 하며 다시 마음을 붙잡아 공부 해야겠어요.

앞으로의 다짐 지금의 간절함을 잊지말고 다시는 못올 기회를 가진 것에 항상 감사하며, 나 스스로에게 실망하지 않도록 할 수 있는 최선을 다해 끝까지 공부 해 볼 것. 결과는 어찌되든 후회하지 않게 끝까지 부딧혀 볼 것.

😃 Busy Study _ 새벽반 PM 10:00 ~ AM 2:30

여러분 화이팅!! 우리 모두 다 잘 될거예요!