파이썬 중급

어느세 두 번째 주도 끝나간다.

1주일 내내 비가 내린다. 뉴스에서는 폭우로 인한 사건, 사고도 많이 보도 되지만 집에만 있다보니 비 한 방울 맞지 않고 한 주가 지나갔다... 처음에 예상했던 것 보다 훨씬 바쁘게 하루하루를 보냈다. 그런데도 늘 시간이 부족한 한 주였다. 그래도 그만큼 성취감도 쌓여가서 나름 기분 좋게 한 주를 마무리 했다.

노트

3_002

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

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

for number in range(1, inputNumber + 1):
    if inputNumber % number == 0:
        print('{}의 약수: {}'.format(inputNumber, number))
 
 # 파이썬을 이용해서 사용자가 입력한 숫자까지의 소수를 출력해보자.
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\t합성수!!'.format(number))

3_004

# 파이썬을 이용해서 사용자가 입력한 수를 소인수분해하자.
inputNumber = int(input('1보다 큰 정수 입력: '))

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

3_006

# 두 개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드를 작성하자.
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))

3_008

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

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

3_010

# 10진수 --> 2진수, 8진수, 16진수
# 2진수 = binary: bin()     8진수 = octal: oct()     16진수 = Hexadecimal: hex()
# 변환 결과는 문자열로 출력 된다.
dNum = int(input('dNum 입력: '))

print('2진수: {}'.format(bin(dNum)))
print('8진수: {}'.format(oct(dNum)))
print('16진수: {}'.format(hex(dNum)))

3_013

# 다음 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들어보자.
# an = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29}

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

valueN = 0
n = 1
while n <= inputN:
    valueN = inputN1 + (inputD * (n - 1))
    print('{}번째 항의 값: {}'.format(n, valueN))
    n += 1

3_014

# 다음 수열을 보고 n번째 항까지의 합을 출력하는 프로그램을 만들어보자.
# an = {5, 9, 13, 17, 21, 25, 29, 33, ....}

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

valueN = 0
n = 1
sumN = 0
while n <= inputN:
    valueN = inputN1 + (inputD * (n - 1))
    # print('{}번째 항의 값: {}'.format(n, valueN))
    sumN += valueN
    print('{}번째 항까지의 합: {}'.format(n, sumN))
    n += 1

3_021

# 파이썬을 이용해서 피보나치 수를 계산하는 프로그램을 만들어보자.
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))

3_026

# 파이썬을 이용해서 다음 순열들의 값을 구하는 프로그램을 만들어 보자.
# 8P3, 7P5

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

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

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

3_028

# 파이썬을 이용해서 다음 조합들의 값을 구하는 프로그램을 만들어 보자.
# 8C3, 7C5
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
resultP = 1
resultR = 1
resultC = 1

for i in range(numN, numN - numR, -1):
    resultP *= i
    print('n: {}'.format(i))
print('resultP: {}'.format(resultP))

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

resultC = int(resultP / resultR)
print('resultC: {}'.format(resultC))

3_030

# 박스에 '꽝'이 적힌 종이가 4장 있고, '선물'이 적힌 종이가 3장이 있을 때, 파이썬을 이용해서
# '꽝' 2장과 '선물' 1장을 뽑는 확률(%)을 출력하자.
def proFun():

    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))
    resultP = 1
    resultR = 1
    resultC = 1

    for i in range(numN, numN - numR, -1):
        resultP *= i

    for i in range(numR, 0, -1):
        resultR *= i

    resultC = int(resultP / resultR)

    return resultC

sample = proFun()
print('sample: {}'.format(sample))
event1 = proFun()
print('event1: {}'.format(event1))
event2 = proFun()
print('event2: {}'.format(event2))

probability = (event1 * event2) / sample * 100
print('probability: {}%'.format(round(probability, 2)))

5_002

# 오늘 날씨를 출력하는 함수를 선언하고 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()

5_004

# 국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 만들어 보자.
def printScore(kor, eng, mat):
    sum = kor + eng + mat
    avg = sum / 3

    print('총점: {}'.format(sum))
    print('평균: {}'.format(avg))

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

printScore(korScore, engScore, matScore)

5_005

# 함수가 return을 만나면 실행을 종료한다. 고로, return 이후의 코드는 전혀 실행이 되지 않는 결과가 나타남!!!
def divideNumber(n):

    if n % 2 == 0:
        return '짝수'
    else:
        return '홀수'

returnValue = divideNumber(4)
print(returnValue)

5_006

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

# 지역 변수: 함수 안에 선언된 변수로 함수 안에서만 사용 가능하다.
def printNumbers():
    global num_in
    num_in = 20
    print(f'num_in: {num_in}')

printNumbers() # 정상적으로 작동

print(f'num_in: {num_in}') # 지역 변수를 밖에서 사용하려 하였으므로 변수가 정의되지 않았다고 에러가 나온다.
                           # 그러므로 global 키워드를 사용하여 함수 안에서도 전역변수의 값을 수정할 수 있다.

5_007

# 중접함수: 함수안에 또 다른 함수가 있는 형태이다.
def out_function():
    print('out_function called!!')

    def in_function():
        print('in_function called!!')

    in_function()

out_function()

5_008

def calculator(n1, n2):
    return n1 + n2

returnValue = calculator(10, 20)
print('returnValue: {}'.format(returnValue))

# lambda 키워드를 사용하면 똑같지만 더욱 간단한 함수 생성 가능
calculator = lambda n1, n2: n1 + n2
returnValue = calculator(10, 20)
print('returnValue: {}'.format(returnValue))

5_015

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

# 이 파이썬 파일이 실행될 때 참조하는 디렉토리들을 명시해주는 코드!
# import sys
#
# for path in sys.path:
#     print(path)

# 내가 모듈을 생성했는데 모든 디렉토리에서 다 사용하고 싶을때 --> 모듈을 venv/Lib/sote-packages 폴더에 옮겨주면 어디서든 사용 가능!!

from calculator import cal
print('cal.add(10, 20): {}'.format(cal.add(10, 20)))
print('cal.sub(10, 20): {}'.format(cal.sub(10, 20)))
print('cal.mul(10, 20): {}'.format(cal.mul(10, 20)))
print('cal.div(10, 20): {}'.format(cal.div(10, 20)))

5_018

# 객체지향 프로그래밍: 객체(Object) = 속성(Attribute) + 기능(Function)

# 객체는 클래스에서 생성된다.

# 객체 사용의 장점: 코드 재사용, 모듈화에 좋다!

# 클래스는 class 키워드와 속성(변수) 그리고 기능(함수)를 이용해서 만든다.

5_021

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

5_022

# 덧셈, 뺄셈 기능이 있는 클래스를 만들고, 이를 상속하는 클래스를 만들어서 곱셈과 나눗셈 기능을 추가해 보자.
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

cal = CalculatorChild()

userInputNum1 = int(input('n1 입력: '))
userInputNum2 = int(input('n2 입력: '))

print('cal.add(n1, n2): {}'.format(cal.add(userInputNum1, userInputNum2)))
print('cal.sub(n1, n2): {}'.format(cal.sub(userInputNum1, userInputNum2)))
print('cal.mul(n1, n2): {}'.format(cal.mul(userInputNum1, userInputNum2)))
print('cal.div(n1, n2): {}'.format(cal.div(userInputNum1, userInputNum2)))

5_023

# 객체가 생성될 떄 생성자를 호출하면 __init__()가 자동 호출된다.

# 상위 클래스의 속성을 초기화하기 위해서 super()를 이용한다.

5_025

# 다중 상속: 2개 이상의 클래스를 상속한다.
## 다중상속의 늪에 빠지지 않기 위해서는 꼭 필요한 경우에만 최소한으로 사용하는 편이 좋다!! 개발자들 입장에서 알아보기 힘들기 때문!!!!

5_026

# 오버라이드: 하위 클래스에서 상위 클래스의 메서드를 재정의(override)한다.
# 상위클래스에서의 메서드와 이름을 똑같이 맞춘 후 재정의해주면 된다!!
class Robot:
    def __init__(self, c, h, w):
        self.color = c
        self.height = h
        self.weight = w

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

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

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

    def fire(self):
        print('레이저 발사!!!')  # 여기서 미사일을 레이저 발사로 재정의(override) 해주었다!!!!

myRobot = NewRobot('red', 200, 300)
myRobot.printRobotInfor()
myRobot.fire()

5_027

# 추상클래스: 상위 클래스에서 하위 클래스에 메서드 구현을 강요한다.
from abc import ABCMeta
from abc import abstractmethod

class AirPlane(metaclass=ABCMeta):
    @abstractmethod
    def flight(self):
        pass

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

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


class AirLiner(AirPlane):
    def __init__(self, c):
        self.color = c

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


class fighterPlane(AirPlane):
    def __init__(self, c):
        self.color = c

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



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

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

5_029

# 예외 처리: 예상하지 못한 예외가 프로그램 전체 실행에 영향이 없도록 처리함.
# 예외 발생 예상 구문을 try ~ except로 감싼다
n1 = 10; n2 = 0
try:
    print(n1 / n2)
except:
    print('예상치 못한 문제가 발생했습니다.')
    print('다음 프로그램이 정상 실행됩니다.')
print(n1 * n2)
print(n1 + n2)
print(n1 - n2)

5_031

# finally: 예외 발생과 상관없이 항상 실행한다!!

try:
    inputData = input('input number: ')
    numInt = int(inputData)

except:
    print('exception!!')
    print('not a number!!')

else:
    if numInt % 2 == 0:
        print('even number!!')
    else:
        print('odd number!!')

finally:    # 예외가 발생하였지만 finally를 통해서 실행을 이어감
    print(f'inputData: {inputData}')

5_034

# 텍스트 파일을 다루기 위한 함수들 이용:
# open(): 파일 열기
# read(), write(): 읽기 또는 쓰기
# close(): 파일 닫기

5_036

# 텍스트파일 열기 모드
# 파일 모드는 파일을 어떤 목적으로 open 할지 정한다.
# 'w': 쓰기 전용(파일이 있으면 덮어씌움)
# 'a': 쓰기 전용(파일이 있으면 덧붙임)
# 'x': 쓰기 전용(파일이 있으면 에러 발생)
# 'r': 읽기 전용(파일이 없으면 에러 발생)
uri = 'C:/pythonTxt/'

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

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

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

# 'r' 파일 모드
file = open(uri + 'hello_01.txt', 'r')
str = file.read()
print('str: {}'.format(str))
file.close()

5_037

# with ~ as문을 이용하면 파일 닫기(close)를 생략할 수 있다.
with open(uri + '5_037.txt', 'r') as f:
    print(f.read())

5_038

# writelines(): 반복 가능한 자료형의 데이터를 파일에 쓰자!
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')


# 위와 똑같은 코드를 writelines()를 활용하면 훨씬 간결하게 코딩할 수 있다!!!
uri = 'C:/pythonTxt/'
with open(uri + 'languages.txt', 'a') as f:
    f.writelines(item + '\n' for item in languages)

5_039

# readlines(): 파일의 모든 데이터를 읽어서 리스트 형태로 반환한다.
uri = 'C:/pythonTxt/'

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


# readline(): 한 행을 읽어서 문자열로 반환 한다.
with open(uri + 'lans.txt', 'r') as f:
    line = f.readline()

    while line != '':
        print('line: {}'.format(line), end='')
        line = f.readline()