자료구조 ()

📖 자료구조

‣ 대표적인 컨테이너 자료형으로는 리스트(list), 튜플(Tuple), 딕셔더너리(Dic), 셋트(Set)이 있다. ‣ 리스트는 값을 계속 변경할 수 있지만, 튜플은 정해진 값을 변경할 수 없다. ‣ 리스트는 리스트 안에 리스트가 중첩이 가능하다. ex) [10,20,30,[15,25,35],40] ‣ 딕셔너리는 키 값, 밸류 값이 있다. ‣ 셋트는 박찬호 라는 학생이 둘이 있을 수 있지만, 중복이 안된다. 리스트와 튜플은 중복 가능

student1 = '박찬호'
student1 = '홍길동'
student1 = '박지성'
student1 = '차범근'
student1 = '손흥민'
student1 = '김민재'

#list
students = ['박찬호', '홍길동', '박지성', '차범근', '손흥민', '김민재']
print(student1)
print(students)
print(type(students))

# for i in range(10):
#     print(j)

for student in students:
    print(student)  #튜플에도 적용할 수 있다.


#tuple
students = ('박찬호', '홍길동', '박지성', '차범근', '손흥민', '김민재')
print(students)
print(type(students))

# key, value
scores = {'kor':95, 'eng':80, 'mat':95}
print(scores)
print(type(scores))

#set
allSales = {100, 200, 500, 200} #중복값은 나오지 않는다.
print(allSales)
print(type(allSales))

student1에 6명의 인물을 넣어두고 list(리스트), tuple(튜플), dict(딕셔너리), set(세트)로 표현해봤다.

1. student1을 출력했을 땐 제일 마지막에 입력된 '김민재'가 나오는게 맞고,
2. for 문으로 students 에 있는 student를 하나하나 뽑아낼 수도 있다.
3. 딕셔너리는 key값, value값이 있고,
4. set은 중복값은 표현되지 않는다.
5. 리스트는 리스트안에 리스트가 들어가는 중첩이 가능하다.

list(리스트) 아이템은 인덱스로 조회가 가능하다. 파이썬은 0부터 시작하기 때문에 반복문에서 입력값의 -1까지 갔던것과 같은 논리로 생각하면 된다.

myFamilyNames = ['홍아빠', '홍엄마', '홍길동', '홍동생']
print(myFamilyNames[2]

-> 0:홍아빠, 1:홍엄마, 2번은 홍길동이 나오고, 3:홍동생

이 인덱스를 연습해보면 이렇다.

#index(인덱스 연습)
#인덱스가 홀수인, 짝수인 학생들로 나누기.
students = ['박찬호', '홍길동', '박지성', '차범근', '손흥민', '김민재']

for i in range(6):
    if i % 2 == 0:
        print('index가 짝수인 경우 --> students[{}]: {}'.format(i, students[i]))
    else:
        print('index가 홀수인 경우 --> students[{}]: {}'.format(i, students[i]))

print('index가 짝수인 student')
print('students[0]: {}'.format(students[0]))
print('students[2]: {}'.format(students[2]))
print('students[4]: {}'.format(students[4]))
print('index가 홀수인 student')
print('students[1]: {}'.format(students[1]))
print('students[3]: {}'.format(students[3]))
print('students[5]: {}'.format(students[5]))

for 문으로 반복하면서 짝수 index 학생들과, 홀수 index 학생들을 구분하여 출력할 수 있다.

★ 어려웠던 점 ★

1. init이 정확히 무슨 역할을 하는지 이해하지 못했다. ⇨ 이렇게 함수부분, 실행부분을 잘 나눌줄 알아야 효율적인 코드를 짤 수 있다는 얘기를 보았는데 아직 머릿솔에서는 한화면에 코드를 짜내야 한다는 강박(?) 같은게 있어서 구분이 안되는 것 같다. 이런 형태의 코드를 많이 보다보면 지금까지 해온것 처럼 익숙해져야할 것 같다...

매개변수가 없는 클래스의 실행 과정이 어떻게 되는지 모르겠다.(calculator) ⇨ 실행단에서 각 매개변수의 인수를 선언해주어야한다.

그 와중에 속성 변경도 가능하다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

중급4 복습 (자주 사용하는 모듈 ~ 객체 속성 변경)

📖 자주 사용하는 모듈

‣ 파이썬에서 기본 제공해주는 math, random, time 모듈을 자주 사용한다. ‣ 수학, 난수, 시간 모듈은 잘 활용하면 편하다.

#math, random, time 을 자주 사용한다.

#math -> sum, max, min, pow(제곱), round(반올림)

listVar = [2, 5, 3.14, 58, 10, 3]
print(f'pow(13,2): {pow(13, 2)}')   #제곱할수, 제곱 수
print(f'pow(13,3): {pow(13, 3)}')
print(f'pow(13,4): {pow(13, 4)}')

print(f'{round(3.141592, 1)}')  #반올림할 수, 소수점 단위
print(f'{round(3.141592, 2)}')
print(f'{round(3.141592, 3)}')
print(f'{round(3.141592, 4)}')
print(f'{round(3.141592, 5)}')


import math

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

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

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

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

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


import time

lt = time.localtime()
print(f'time.localtime(): {lt}')

print(f'lt.tm_year: {lt.tm_year}')
print(f'lt.tm_mon: {lt.tm_mon}')
print(f'lt.tm_mday: {lt.tm_mday}')
print(f'lt.tm_hour: {lt.tm_hour}')
print(f'lt.tm_min: {lt.tm_min}')
print(f'lt.tm_sec: {lt.tm_sec}')
print(f'lt.tm_wday: {lt.tm_wday}')  #요일을 나타낸다.

Random은 워낙 많이 사용하고 쉽기 때문에 넘기고, 다양한 연산과 math, time에 대해 정리했다.

📖 객체지향 프로그래밍

‣ 객체를 이용한 프로그램으로 객체는 속성과 기능으로 구성된다. ‣ 만약 자동차(Car)라면 속성(길이, 색상, 가격 등)과 기능(전진, 후진, 정지 등)으로 나눌 수 있다. ‣ 객체(Object) = 속성(Attribute) + 기능(Function) 으로 볼 수 있다. ‣ 객체는 클래스에 생성된다. ‣ 코드 재사용, 모듈화에 좋다.

📖 클래스와 객체 생성

‣ 객체를 생성하기 위해 클래스 만들기 ‣ 클래스명은 함수와 다르게 첫글자를 대문자로 만든다. (Ex. class Car) ‣ 속성은 init메소드를 넣어야한다. ‣ init 뒤에 (나 자신이라는 의미의 self, 속성, 속성들)을 선언하고, ‣ 선언한 속성들을 초기화한다.

class Car:

    def __init__(self, col, len): #self는 나 자신. Car를 지목한다.
        self.color = col    #객체가 생성될 때 객체의 속성을 초기화.
        self.length = len

    def doStop(self):   #정지하는 기능, 클래스 안의 특정한 기능은 매개변수로 self로 받아야한다.
        print('STOP!!')

    def doStart(self):
        print('STRART!!')   #여기까지 만들고 실행하면 결과값이 나오지 않는다.

    def printCarInfo(self):
        print(f'self.color: {self.color}')
        print(f'self.length: {self.length}')
#클래스는 객체를 만들기 위한 녀석일뿐 객체를 만들고 실행하야한다.

#객체 생성
car1 = Car('red', 200)   #class명과 동일
car2 = Car('blue', 300) #레퍼런스 변수들.

car1.printCarInfo()
car2.printCarInfo()

car1.doStop()
car1.doStart()

클래스의 기본 예제이다.

1. 클래스명의 첫글자는 대문자! Car
2. class 자신을 의미하므로 self, 속성인 color 와 length를 매개변수로 받고 초기화.
3. 각 기능들을 함수처럼 선언해준다.
4. 실행할 땐 클래스명과 동일하게 호출해서 인순허고 돌린다.

class Flight:
    def __init__(self, color, length, arrival): #속성들
        self.color = color
        self.length = length
        self.arrival = arrival

    def doTakeOff(self):    #기능들
        print('Take-Off!!')

    def doLanding(self):
        print('Landing~~')

    def doAutoPilot(self):
        print('Auto-Pilot Mode.')

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

flight1 = Flight('white', 150, 'seoul')
flight2 = Flight('blue', 200, 'dokdo')
flight3 = Flight('green', 3000, 'USA')

flight1.printFlightInfo()
flight1.doTakeOff()
flight1.doAutoPilot()
flight1.doLanding()

flight2.printFlightInfo()
flight2.doTakeOff()
flight2.doAutoPilot()
flight2.doLanding()

flight3.printFlightInfo()
flight3.doTakeOff()
flight3.doAutoPilot()
flight3.doLanding()

비슷하게 비행기로 짠 예제.

1. 색상과 길이, 목적지를 속성을 받았고,
2. 초기화 한 후 동작들(이륙, 오토파일럿모드, 착륙)을 객체로 선언.
3. 비행기의 속성들을 한눈에 보여주는 flightInfo도 추가

📖 객체 속성 변경

‣ 객체 속성은 변경할 수 있다. like) PC사양 업그레이드 하듯이.

class NewGenerationPC:

    def __init__(self, name, cpu, memory, ssd):
        self.name = name    #앞의 name은 객체에 속해있는 속성, 뒤의 name은 매개변수
        self.cpu = cpu
        self.memory = memory
        self.ssd = ssd

    def doExcel(self):
        print('Excel Run!!')

    def doPhotochop(self):
        print('Photoshop Run!!')

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

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

friendPC = NewGenerationPC('friendPC', 'i9', '32G', '1T')
friendPC.printPCInfo()

#myPC 객체 속성 변경 부분.
myPC.cpu = 'i9'
myPC.memory = '64G'
myPC.ssd = '8T'
myPC.printPCInfo()

Car, Flight 하듯이 똑같이 선언 실행해주니 내PC와 친구PC가 나온다.

1. 내PC를 업그레이드 하기 위해 속성을 변경한다.
2. 쉽게 생각해서 각 속성을 하나씩 바꿔주면 된다.
3. myPC.cpu = 'i9', myPC.ssd = '8T' 같이
4. 그리고 다시 Info를 출력해보면 기존 내PC와 함꼐 변경된 속성의 내PC가 나온다.

Calculator로 만든 예제

class Calculator:

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

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

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

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

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

calculator = Calculator()
calculator.number1 = 10
calculator.number2 = 20

print(f'calculator.add(): {calculator.add()}')
print(f'calculator.sub(): {calculator.sub()}')
print(f'calculator.mul(): {calculator.mul()}')
print(f'calculator.div(): {calculator.div()}')

calculator.number1 = 4
calculator.number2 = 6

print(f'calculator.add(): {calculator.add()}')
print(f'calculator.sub(): {calculator.sub()}')
print(f'calculator.mul(): {calculator.mul()}')
print(f'calculator.div(): {calculator.div()}')

강의 마지막에 강사님이 내주신 예제

1. class의 매개변수가 없다... 답을 보기 전까지 어떻게 해야할지 몰랐다.
2. 매 기능마다 result 값을 return하는 식으로 짠다.
3. 실행단에서 그냥 클래스를 호출한 후,
4. 매개변수를 따로 입력해야한다.

★ 어려웠던 점 ★

1. init이 정확히 무슨 역할을 하는지 이해하지 못했다. ⇨ 이렇게 함수부분, 실행부분을 잘 나눌줄 알아야 효율적인 코드를 짤 수 있다는 얘기를 보았는데 아직 머릿솔에서는 한화면에 코드를 짜내야 한다는 강박(?) 같은게 있어서 구분이 안되는 것 같다. 이런 형태의 코드를 많이 보다보면 지금까지 해온것 처럼 익숙해져야할 것 같다...

2. 매개변수가 없는 클래스의 실행 과정이 어떻게 되는지 모르겠다.(calculator) ⇨ 실행단에서 각 매개변수의 인수를 선언해주어야한다.

3. 그 와중에 속성 변경도 가능하다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

중급 복습 (모듈, 패키지, site-packages)

📖 모듈제작, 모듈사용

‣ 모듈은 파일자체를 함수처럼 선언하는 형식. ‣ 사용부분은 함수처럼 선언된 파일을 불러다 사용하는 형식.

cm 를 각 선언한 단위로 변환하는 모듈
def cmToMm(n):
    return round(n * 10, 3)

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

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

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

if __name__ == ' __main__':
    print(f'10cm: {cmToMm(10)}mm')
    print(f'10cm: {cmToInch(10)}inch')
    print(f'10cm: {cmToM(10)}m')
    print(f'10cm: {cmToFt(10)}ft')

선언한 모듈을 실행하는 실행파일
# cm 길이를 입력하면 각 선언한 단위로 변호나해주는 함수
import unitConversion as uc

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

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

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

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

    returnValue = uc.cmToFt(inputNumber)
    print(f'{inputNumber}cm : {returnValue}ft')

모듈을 만들었을떄 이게 올바르게 동작을 하는지 테스트 하기위해 프린트를 할 순 있지만, 그상태로 두게되면 모듈로서 불려갔을때도 실행파이렝서 프린트가 되게되므로 if name == 'main' 을 넣어주어 모듈을 메인으로 실행할 때만 테스트를 프린트하도록 만들어주는 것이 조금 더 완벽한 코드이다.

📖 패키지

‣ 모듈이 1, 2개면 모르겠는데 많아지면 깔끔하게 관리하기 위해서 사용하는 것이 좋다. ‣ 모듈을 모아놓은 것. (파일별로 모아놓는 폴더, 디렉토리 같은 형식)

패키지와 모듈의 차이는 간단하다. 여태 했던 모듈은 실행파일과 모듈파일을 나누어 깔끔하게 파일들을 관리할 수 있었던 것. 하지만 모듈이 많아봤자 덧셈, 뺄셈, 곱셈, 나눗셈 4가지였다. 모듈형 코딩이 대세라 모듈이 조그만 많아져도 헷갈리거나 관리하기가 힘들 수 있다. 그래서 package를 사용하면 깔끔하게 묶어서 관리할 수 있다.

Package는 CalculatorForInt 이고 계산하여 Int 형태로 반환하는 모듈을 모아놓은 패키지이다.

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

if __name__ == '__main__':
    print(add(3.14, 1.2))

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

if __name__ == '__main__':
    print(sub(3.14, 1.2))

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

if __name__ == '__main__':
    print(mul(3.14, 1.2))

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

if __name__ == '__main__':
    print(div(3.14, 1.2))

패키지안에 깔끔하게 4가지 모듈을 작성해주었고, CalculatorForFloat 패키지도 동일하게 만들어 주었다. 이 모두를 실행할 수 있는 package파일을 만들었다.

'packaged에서 가져오고 싶으면 from 으로 불러온다.'
from CalculatorForInt import addCal
from CalculatorForInt import subCal
from CalculatorForInt import mulCal
from CalculatorForInt import divCal

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

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

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

각 모듈엔 메인일떄만 확인할 수 있는 print를 테스트코드로 넣어두었고,

1. 패키지안의 모듈을 불러올 땐 from 패키지로 먼저 패키지를 불러주고,
2. from 패키지 import 모듈로 해당 패키지 안의 모듈을 불러와 실행할 수 있다.
3. Int형 패키지, Float형 패키지의 결과가 10, 20을 입력하였을 때 위와 같이 나온다.

📖 site-packages

‣ 기존에는 나와 동일한 곳에 모듈을 만들어서 사용했었다. ‣ 모듈이 많아지면 패키지로 묶어서 활요했었다. ‣ 다른 디렉토리에 있는 모듈을 활용하고 싶을 때 이것을 사용하면 좋다.

위 사진에 나오는 venv는 virtual environment (가상환경) 이고 이곳의 lib(라이브러리)에 site-packages에 디렉토리 및 파일을 넣어두면 파이썬 환경 어디에서든 해당 모듈을 사용할 수 있다.

예시로 약수와 소수를 구하는 패키지를 통으로 site-packages에 넣고 돌려보았다.

위의 경로로 이동하였고,

def divisor(inputNumber):
    result = [] #결과값을 리스트로 담겠다.
    for number in range(1, (inputNumber + 1)):  #입력값까지 돌릴려면 +1
        if inputNumber % number == 0:
            result.append(number)

    return result

def prime_number(inputNumber):  #소수 구하기
    result = []
    for number in range(2, (inputNumber + 1)):  #여기까진 약수
        flag = True
        for n in range(2, number):  #소수 구하기
            if number % n == 0: #입력값을 나누는 숫자를 2 이상의 수로 나누었을 떄 나누어 떨어지면 약수가 있는 수 이므로 소수가 아니다.
                flag = False    #flag를 False를 주고 위의 for문을 돌아가 다음 약수를 찾는다.
            break

        if(flag):   #flag에서 False를 받지않고 소수로 판정된 친구들은 list에 append된다.
            result.append(number)

    return result

실행파일은 다음과 같이 하였다.

from divisor_pac import divisor_mod as dm

print(f'10의 약수: {dm.divisor(10)}')
print(f'50까지의 소수: {dm.prime_number(50)}')

1. 약수를 구해서 result = [] 로 리스트에 추가하고,
2. prime_number에서 소수를 구해 result [] 로 리스트에 추가하여,
3. 실행파일에 입력값을 주면 위와 같은 결과값을 볼 수 있다.

★ 어려웠던 점 ★

1. 모듈을 선언하는 파일과 실행하는 파일을 나누는 부분. ⇨ 이렇게 함수부분, 실행부분을 잘 나눌줄 알아야 효율적인 코드를 짤 수 있다는 얘기를 보았는데 아직 머릿솔에서는 한화면에 코드를 짜내야 한다는 강박(?) 같은게 있어서 구분이 안되는 것 같다. 이런 형태의 코드를 많이 보다보면 지금까지 해온것 처럼 익숙해져야할 것 같다...

2. site-packages는 말만 어렵지 그냥 내 노트북이라는 인터넷환경에 올려놓고 검색해다 쓰는 느낌이다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

중급3 복습 (모듈)

📖 모듈제작, 모듈사용

‣ 모듈은 파일자체를 함수처럼 선언하는 형식. ‣ 사용부분은 함수처럼 선언된 파일을 불러다 사용하는 형식.

# 국어, 영어, 수학 점수를 입력하면 총점, 평균을 출력하는 모듈.
scores = []

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

def getScore():
    return scores

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

    return total

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

    return avg

모듈 부분이고,

1. 각 점수를 리스트로 받는 scores = []를 넣고
2. 세 과목의 점수를 입력받아 추가하는 add 부분,
3. 입력받은 점수들을 리스트로 보여주는 get 부분,
4. 총점을 구하는 getTotal부분,
5. 평균을 구하는 Avg 부분으로 나뉜다.

import scores as sc

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

sc.addScore(korScore)
sc.addScore(engScore)
sc.addScore(matScore)

print(sc.getScore())
print(sc.getTotalScore())
print(sc.getAvgScore())

모듈에서 선언했던 모든 부분들을 간단히 불러다 출력해낸다.

1. import scores로 모듈을 가져오고 as sc로 sc만 입력해서 불러올 수 있게 만들었다.
2. 각각의 점수를 입력해주고,
3. 모듈에서 선언한 함수들을 활용하여 출력한다.

보통의 언어는 메인 메소드가 먼저 시작되는데 파이썬은 그런게 없어서 main이 저장되어있는 곳으로 찾아간다. 파일은 기본적으로 실행파일은 전역변수 name에 자기의 파일명이 저장되는데 모듈은 main이 저장된다. 즉 실행파일을 찾아간다.

addModule.py
def add(n1, n2):
    return n1 + n2

if __name__ == '__main__':
    print(f'__name__: {__name__}')  # 모듈이지만 함수이므로 개인적으로 실행할 수 있으니 전역변수를 찍어볼 수 있다.

# 해당 파일에서 실행하면 본인이 실행파일이기 떄문에 __main__이 찍혀나온다.

subModule.py
def sub(n1, n2):
    return n1 - n2

print(f'__name__: {__name__}')

mulModule.py
def mul(n1, n2):
    return n1 * n2

print(f'__name__: {__name__}')

divModule.py
def div(n1, n2):
    return n1 / n2

print(f'__name__: {__name__}')

이렇게 여러 기능들을 모듈 파일로 따로 선언을 해두었을 때 각자의 파일에서 실행을 하게 되면 각자의 파일을 실행할 당시는 메인이기 때문에 print(f'name: {name}') 프린트를 해보면 main으로 나온다.

# add, sub, mul, div 의 모듈을 가져온다.
import addModule    # main일때만 모듈을 찍어내라고 해서 여기서는 add모듈은 찍히지 않는다.
import subModule    # 남이 import해서 가져온것이기 때문에 __main__ 아니라, 각자의 파일명이 저장된다
import mulModule
import divModule

def mod(n1, n2):    # 나머지를 반환해주는 기능
    return n1 % n2

if __name__ == '__main__':  #아래의 기능들은 main일때만 실행이 되게 된다.
    print(addModule.add(10, 20))
    print(subModule.sub(10, 20))
    print(mulModule.mul(10, 20))
    print(divModule.div(10, 20))

하지만, playMoudle.py라는 실행파일에서 모듈들을 불러온 후 실행을 하게 되면 각 모듈들은 본인이 실행파일이 아니라 불려온것이기 때문에 name == 각자의 파일이름 이 저장되게 된다. 이를 증명할 수 있는 것은 if name == 'main': 이것을 넣어주게 되면 각자의 파일이 메인일때만 해당 문구를 출력하라는 말인데 import된 함수들은 출력하지 않는다.

★ 어려웠던 점 ★

1. 모듈을 선언하는 파일과 실행하는 파일을 나누는 부분. ⇨ 이렇게 함수부분, 실행부분을 잘 나눌줄 알아야 효율적인 코드를 짤 수 있다는 얘기를 보았는데 아직 머릿솔에서는 한화면에 코드를 짜내야 한다는 강박(?) 같은게 있어서 구분이 안되는 것 같다. 이런 형태의 코드를 많이 보다보면 지금까지 해온것 처럼 익숙해져야할 것 같다...

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

기초 수학7(순열, 조합, 확률)

📖 순열

‣ 순열이란? 순서에 상관있으면서, n개에서 r개를 택하여 나열하는 경우의 수 ‣ nPr 로도 표현할 수 있다. ‣ n! / (n-r)! 으로 계산하면 된다.

# 8P3, 7P5를 구하는 프로그램을 만들어보자.

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

for n in range(numN, (numN - numR), -1): #8,3을 입력하면 6까지 범위가 설정된다.
    print('n : {}'.format((n)))
    result = result * n

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

1. n 값과 r 값을 받았고,
2. for문이라 numN 부터 numN - numR , -1 로 하나씩 줄여나가면 numN-numR+1 까지 돈다

‣ 원순열이란? 시작과 끝의 구분이 없는 순열, 일렬로는 같지만 원으로 만들면 다르다. ‣ n! / n 이나 (n-1)!로 구할 수 있다.

# {1,2,3}이라면 {123}{132}{321}등 6가지가 나온다.
# n! / n 이나 (n-1)!로 구할 수 있다.

# n명의 친구가 원탁 테이블에 앉을 수 있는 순서를 계산한다.
n = int(input('친구 수 입력: '))
result = 1
for i in range(1, n):   # (n-1)까지 돌아야하는데 for문이라 n을 입력하면 n-1까지 돌아간다.
    result *= i

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

1. 일렬로 봤을 때 순서가 같으면 사실상 같지만, 원으로 둘렀을 때 조금 달라진다.
2. 그러므로 노란색은 노란색끼리, 초록색은 초록색끼리 사실상 일렬로 봤을 때 같다.

📖 조합

‣ 조합이란? 순서 상관없이 n개에서 r개를 택하는 경우의 수 ‣ n개에서 r개 고를 때 3개 중 2개라면 순열 = 6가지(3!), 조합 = 3가지(3!/2!) 이다. ‣ 조합 nCr = nPr / r! 과 같다. 즉 n! / r!(n-r)! 이다.

순열의 경우

1. 순서가 상관있기 때문에 24가지 경우가 나온다.
2. 4 팩토리얼이기 때문에

조합의 경우

#다음 조합들의 값을 구하는 프로그램을 만들어보자.  nPr / r! 방식
numN = int(input('numN 입력: '))
numR = int(input('numR 입력: '))
resultP = 1 # 순열 값 저장
resultR = 1 # r! 값 저장
resultC = 1 # 조합 값 저장

for n in range(numN, (numN - numR), -1): #8,3을 입력하면 6까지 범위가 설정된다.
    print('n : {}'.format((n)))
    resultP = resultP * n   #여기까진 순열 구하는 코드

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

for n in range(numR, 0, -1):    # 0 바로앞인 1까지 반복.
    print('n : {}'.format((n)))
    resultR = resultR * n   #여기까지 r! 구하는 코드

print('resultR: {}'.format(resultP))

resultC = int(resultP / resultR)    # nPr / r! 로 구하는 코드
print('resultC: {}'.format(resultC))


# 카드 5장 중 2장을 선택했을 때 삼각형과 사각형이 동시에 선택될 수 있는 확률은? -> 좌우 바뀌는애들도 1가지로 침
result = (1/resultC) * 100  # 조합이고 전체 중 1가지이고 퍼센티지라 * 100
print('{}%'.format(round(result, 2)))

1. 순열과 똑같이 반복하며 P 값은 곱하면서 내려오고,
2. R 값도 1까지 곱하면서 내려온 후,
3. nPr / r! 로 구하기 위해 P 값 / R 값을 해주고 C에 넣어준다.
4. 그 중 카드 2장이 동시에 선택되는 것은 앞뒤가 바뀌는 것까지 1장으로 보기때문에 전체 중 1가지 경우이고 1/resultC * 100 으로 퍼센티지를 만들어주어 round로 2번째 자리에서 올려준다.

📖 확률

‣ 확률이란? 모든 사건에서 특정 사건이 일어날 수 있는 수를 나타낸 것.

예제로 어떤 박스에 선물 3개와 꽝 4개가 들어있는데, 이 중 각각 1개와 2개에서 뽑힐 확률 구하는 프로그램 -> 3번 반복되야함.

def proFun():
    numN = int(input('numN 입력: '))
    numR = int(input('numR 입력: '))
    resultP = 1 # 순열 값 저장
    resultR = 1 # r! 값 저장
    resultC = 1 # 조합 값 저장

    for n in range(numN, (numN - numR), -1): #먼저 순열을 구해준다.
        resultP = resultP * n   #여기까진 순열 구하는 코드
    print('resultP: {}'.format(resultP))

    for n in range(numR, 0, -1): #먼저 순열을 구해준다.
        resultR = resultR * n   #여기까진 순열 구하는 코드
    print('resultR: {}'.format(resultR))

    resultC = int(resultP / resultR)
    print('resultC: {}'.format(resultC))    #여기까지 확률 함수로 묶이고 3번 반복해야한다.

    return resultC

sample = proFun()   # sample은 모든 사건의 값이다.
print('sample: {}'.format(sample))

event1 = proFun()   # 꽝이 나올 사건
print('event1: {}'.format(event1))

event2 = proFun()   # 선물이 나올 사건
print('event2: {}'.format(event2))

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

확률 구하는 프로그램

1. 조합을 구하는 과정까지는 코드가 같다.
2. 전체 경우의 수, 꽝이 나올 경우의 수, 선물이 나올 경우의 수를 구해야해서 조합 코드가 3번 반복되어야하는데,
3. 길게 늘여쓸 필요없이 def를 사용하여 함수를 만들어버렸다. def proFun()
4. proFun()함수를 사용하여 sample(전체경우), event1(꽝), event2(선물)의 확률을 구해주고,
5. (꽝 * 선물) / 전체 * 100 으로 확률을 구해준다.

★ 어려웠던 점, 새로웠던 점 ★

1. 손으로 계산할 때 쉬운 공식이 있고, 코드를 작성할 때 쉬운 공식이 있다.

2. 반복되는 작업이고 같은 코드가 반복되는 부분이라면 과감하게 def 로 함수화 시키자 ⇨ 함수를 호출할 때 마다 print가 한 줄 되는 것이니 헷갈리지말고 sample, event1, event2 구분.

3. 조합, 순열, 확률 같은 문제는 어떤 공식을 사용할지, 얼마나 반복되는지 확인해두고 짜는게 좋을 것 같다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

기초수학 문제풀이(31_약수와소수 ~ 35_진법)

📖 약수와 소수 ‣ 약수는 어떠한 수를 나누어 떨어지게 하는 수가 그 수의 약수이다. ‣ 소수는 어떠한 수가 약수를 1과 자기자신만을 가지고 있는 수가 소수이다.

# 100부터 1000사이의 난수에 대해 약수, 소수, 소인수 출력.
import random

rNum = random.randint(100, 1000)
print(f'rNum: {rNum}')

for num in range(1, rNum + 1):

    soinsooFlag = 0

    #약수
    if rNum % num == 0:
        print(f'[약수]: {num}')
        soinsooFlag += 1

    #소수
    if num != 1:
        flag = True
        for n in range(2, num):
            if num % n == 0:
                flag = False
                break

        if(flag):
            print(f'[소수]: {num}')
            soinsooFlag += 1

    #소인수
    if soinsooFlag >= 2:
        print(f'[소인수]: {num}')

1. 100~1000사이 난수에 대해 약수, 소수, 소인수를 출력했다.
2. 나눈 수의 나머지가 0이면 약수로 출력.
3. 1이 아닌 수 중 2부터 그 수까지 반복했을 때 나누어 떨어지면 소수, 그리고 flag를 False로 탈출.
4. 약수와 소수를 찾을때마다 소인수플래그에 추가하는데 두 군데 다 추가되면 소인수로 볼 수 있다.

📖 소인수와 소인수분해 ‣ 소인수는 소수이면서 약수인 수 이다. ‣ 소인수분해는 어떠한 수를 소인수의 곱 형태로 나타내는 것이다.

# 100부터 1000사이의 난수를 소인수분해하고 소인수에 대한 지수를 출력한다.
import random

rNum = random.randint(100, 1000)
print(f'rNum: {rNum}')

soinsooList = []

n = 2
while n <= rNum:
    if rNum % n == 0:
        print(f'소인수: {n}')
        soinsooList.append(n)
        rNum /= n
    else:
        n += 1

print(f'soinsooList: {soinsooList}')

tempNum = 0
for s in soinsooList:
    if tempNum != s:
        print(f'{s}\'s count: {soinsooList.count(s)}')
        tempNum = s

1. 똑같이 random함수를 통해 난수를 출력할 것이고, 소인수리스트를 list 형식으로 선언한다.
2. 2부터 랜덤수까지 while로 반복하는데 나머지가 0인 수를 리스트에 append로 추가해주고 rNum / n 값을 rNum에 넣어준다. 나머지가 0이 아니라면 n을 증가시키며 반복한다.
3. 그렇게 추가 된 모든 소인수들을 리시트형태로 출력해준다.
4. 지수를 뽑아내기 위해 tempNum을 초기화 해주고,
5. 리스트에 있는 수를 count하는데 처음엔 다르니 체크해주고, 체크된 수를 tempNum에 담아준다.

📖 최대공약수 ‣ 어떤 수를 나누었을 때 나머지가 0인 수가 약수이다. ‣ 그 약수들 중 가장 큰 수가 최대공약수이다.

# 100부터 1000사이의 난수들의 최대공약수를 구한다.
import random

rNum1 = random.randint(100, 1000)
rNum2 = random.randint(100, 1000)

print(f'rNum1: {rNum1}')
print(f'rNum2: {rNum2}')

maxNum = 0
for n in range(1, (min(rNum1, rNum2) + 1)): #min을 통해 둘 중 작은 수를 골라낸다.
    if rNum1 % n == 0 and rNum2 % n == 0:
        print(f'공약수: {n}')
        maxNum = n

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

1. 두 랜덤함수를 생성하는데, 공약수를 구하니 둘 중 작은 수 이상의 수는 구하는 의미가 없다.
2. min(a, b) 함수를 통해 둘 중 작은 함수가 선발되어 for문 범위를 정한다.
3. 만약 두 공약수가 1뿐이라면 두 수는 서로소 인것까지 출력해본다.

📖 최소공배수 ‣ 어떤 수 들의 공통된 배수 중 가장 작은 수가 최소공배수이다. ‣ 두 수라면 (n1 * n2) / 최대공약수 로 구할 수 있다.

# 100부터 1000사이의 난수들의 최소공배수를 구한다.
import random

rNum1 = random.randint(100, 1000)
rNum2 = random.randint(100, 1000)

print(f'rNum1: {rNum1}')
print(f'rNum2: {rNum2}')

maxNum = 0
for n in range(1, (min(rNum1, rNum2) + 1)): #min을 통해 둘 중 작은 수를 골라낸다.
    if rNum1 % n == 0 and rNum2 % n == 0:
        print(f'공약수: {n}')
        maxNum = n

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

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

1. 최대공약수를 구한 후, 두 수의 곱을 최대공약수로 나누어주면 최소공배수가 나온다.

📖 진법 ‣ 흔히 2진법, 8진법, 10진법, 16진법을 사용한다. ‣ 어떠한 수를 나타내는 방법

# 여러가지 진법
dNum = int(input('10진수 입력: '))

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

print('2진수(0b10101) -> 10진수({})'.format(int('0b10101', 2)))
print('8진수(0o25) -> 10진수({})'.format(int('0o25', 8)))
print('16진수(0x15) -> 10진수({})'.format(int('0x15', 16)))

1. 간단하게 입력 받은 수를 형태에 따라 캐스팅하듯이 출력해주면 변환된다.

★ 어려웠던 점(새로웠던 점) ★

1. 랜덤함수로 두 수를 받으면 어떤 수를 작은 수로 골라내나 생각했었는데 min함수를 통해 두 수를 비교하고 작은 수를 찾아낼 수 있었다.

2.진법을 바꿀 때 format에는 변환하고 싶은 수를 문자열로 쓰고 (변환 수, 진수) 콤마 뒤에 몇 진수인지를 써준다. ⇨ 2진수(bin), 8진수(oct), 16진수(oct), 10진수(int) 를 사용하면된다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

기초수학 7~8(최소공배수)

📖 최소공배수 구하기

‣ 최소공배수는 어떠한 두 개 이상의 수가 같은 수가 되는 가장 낮은 배수의 수. ‣ 두 수의 곱을 최대공약수로 나누어 준 값이 최소공배수가 된다.

# 임의의 두 수에 대해 최대공약수, 최소공배수 출력한다.
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))

1. 임의의 두 수를 입력 받고, 최대공약수를 담을 maxNum을 초기화해준다.
2. for 문이기 때문에 num1이 num2보다 작다는 가정하에 num1 + 1 만큼 반복해준다.
3. 마지막에 담기는 최대 공약수를 num1 * num2 // maxNum 에 사용하고 몫만을 가져오면 최소공배수이다.

최대공약수랑 비슷하게 세 개 이상의 수의 최소 공배수를 구할 수 있다.(약간 다름)

# 세 개의 수에 최소공배수를 출력한다.
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(num1, num2, minNum))

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

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

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

1. 세 개의 수를 입력 받고 maxNum을 초기화 해준다.
2. 두 개의 수의 최대공약수, 최소공배수 구하는 과정은 같다.
3. 먼저 두 수에 대해 구해주고, 그 최소공배수를 newNum에 넣고 newNum과 num3에 대해 다시 돌린다.
4. 그렇게 나온 최소공배수는 num1, num2, num3에 대한 최소공배수이다.

같은 내용이지만 일상에 비유한다면, 어느 섬마을에 과일 파는 배(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))

1. 똑같이 첫 배와 두 번째 배의 최소공배수를 구해주고,
2. 그 최소공배수를 가지고 세 번째 배와 다시 돌려주어서
3. 세 배의 동시 입항 일을 구해줄 수 있다.

★ 어려웠던 점 ★

1. 어려웠다기보다 공식을 알면 쉬웠던 부분, ⇨ 최소공배수 = 두 수의 곱 // 최대공약수
2. 연습해야 할 부분 ⇨ 두 수의 최소공배수를 다른 변수에 넣어두고 그 변수를 세 번째 수와 반복문을 돌릴 수 있다!

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

기초 수학 3~6(소인수 분해, 최대 공약수)

📖 소인수 분해

‣ 소수는 어떠한 수가 약수를 1과 자기자신만을 가지고 있는 수가 소수(소인수)이다. ‣ 어떠한 수를 소인수의 곱으로만 나타내는 것이다.

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

n = 2
while n <= inputNumber:     # n이 입력값보다 작을 동안 돈다.
    if inputNumber % n == 0:    # 나머지가 0 이면 약수
        print('소인수: {}'.format(n))
        inputNumber /= n    # 안될떄까지 계속 나누어준다.
    else:
        n += 1

1. 1은 소수가 아니기에 2로 초기화하고 2부터 시작한다.
2. n으로 입력값을 나눴을 떄 0이면 약수이다.
3. 나누고 남은 수를 inputNumber에 다시 넣어주어 입력값보다 n이 커질때까지 반복한다.(탈출조건)
4. n으로 나누어서 나머지가 0이 아니라면 n값을 증가해서 계속 반복한다.

소인수 분해의 가장 기본이 되는 예제였고, 다음 예제를 본다.

# 입력값에 x를 곱하면 y의 제곱일때 x의 가장 작은값
inputNumber = int(input('1보다 큰 정수 입력: '))
searchNumber = []   # 약수를 담는 리스트
n = 2
while n <= inputNumber:     # n이 입력값보다 작을 동안 돈다.
    if inputNumber % n == 0:    # 나머지가 0 이면 약수
        print('소인수: {}'.format(n))
        if searchNumber.count(n) == 0:  # 소수가 리스트에 없을떄 담아준다.
            searchNumber.append(n)  #append 는 리스트에 추가해주는 함수
        elif searchNumber.count(n) == 1:    # 소수가 리스트에 1개라도 있으면,
            searchNumber.remove(n)  # remove 함수로 리스트에서 지운다.
        inputNumber /= n    # 안될떄까지 계속 나누어준다.
    else:
        n += 1
print('searchNumber: {}'.format(searchNumber))

이 예제는 입력값에 어떤한 수 x를 곱했을 때 y의 제곱이 된다면 x의 가장 작은 값을 구한다.

1. 위와 비슷하나 약수를 담을 searchNumber 라는 리스트를 만들어준다.
2. 약수를 구하는 지점에서 append 함수를 통해 리스트에 소수를 추가한다.
3. 만약 count를 했을 때 이미 리스트에 해당 소수가 있다면 remove 함수를 통해 제거한다.

소수의 제곱형태로 나타내어 예를 들어 72라는 입력값이라면 2x2x2 x 3x3 인데, 2만 더 곱해진다면 (2x2x3)^2 으로 나눌 수 있기 때문에 72 라는 입력값을 최소값 x는 2이다.

📖 공약수, 최대 공약수 구하기.

‣ 공약수는 2개 이상의 수를 나누었을 떄 나머지가 0이되는 공통된 약수를 말한다. ‣ 최대 공약수는 그 공약수들 중 가장 큰 수 를 말한다.

# 두 수의 공약수, 최대공약수 구하기.
num1 = int(input('1보다 큰 정수 입력: '))  #두 수의 공약수, 최대 공약수이기 때문에
num2 = int(input('1보다 큰 정수 입력: '))  #입력값이 2개가 필요하다.
maxNum = 0  #최대 공약수를 담을 maxNum 초기화

for i in range(1, (num1 + 1)):  # 1부터 num1 수까지 반복 / num1 을 넘어가면 공약수의 의미가 없기때문에
    if num1 % i == 0 and num2 % i == 0: #두 수를 나눴을때 나머지가 0인 수는 공약수
        print('공약수: {}'.format(i))
        maxNum = i  #공약수가 나올때마다 담다가 마지막 수만 출력될 것.

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

1. 두 수를 입력값으로 받고, 최대 공약수를 담을 maxNum을 초기화해준다.
2. 공약수가 대상이 되는 수들 중 가장 작은 수보다 크면 의미가 없기 떄문에 num1 < num2 라는 가정하에 num1까지만 for문으로 반복한다.
3. 두 수를 나눴을 떄 나머지가 0임을 만족하는 수를 maxNum에 담아주고 다음 수로 넘어가서 반복한다.

지금은 기본인 두 수로 보았는데, 세 개 네 개가 되면 방식만 살짝 바꿔주고 똑같이 반복하면된다.

# 세 수의 공약수, 최대공약수 구하기.
num1 = int(input('1보다 큰 정수 입력: '))  #세 수의 공약수, 최대 공약수이기 때문에
num2 = int(input('1보다 큰 정수 입력: '))  #입력값이 3개가 필요하다.
num3 = int(input('1보다 큰 정수 입력: '))  #입력값이 3개가 필요하다.
maxNum = 0  #최대 공약수를 담을 maxNum 초기화

for i in range(1, (num1 + 1)):  # 1부터 num1 수까지 반복 / num1 을 넘어가면 공약수의 의미가 없기때문에
    if num1 % i == 0 and num2 % i == 0 and num3 % i == 0: #세 수를 나눴을때 나머지가 0인 수는 공약수
        print('공약수: {}'.format(i))
        maxNum = i  #공약수가 나올때마다 담다가 마지막 수만 출력될 것.

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

1. 세 개의 수를 비교해야 하기 때문에 입력을 세 개로 바꾸어 주었다.
2. 나머지가 0인 수를 구할 때도 세 개의 수를 and 로 묶어서 비교한다.
3. 똑같이 그 수를 maxNum에 담아서 최대 공약수를 출력한다.

공약수, 최대 공약수를 이렇게 구할 수 도 있지만, <테라토스테네스의 체>처럼 <유클리드 호제법>이라는 방식으로 구할 수 있다.

첫 자리부터 num1, num2, r 이라 했을 떄, num1을 num2로 나눈 값을 r에 적고 시작한다. 만약 num1보다 num2가 크다면 첫 나머지 값은 그대로 num1이 될 것이다. 그렇게 *num1 % num2 = r * 형식으로 쓰여있다면 다음 줄엔 num1 자리에 num2가 오고 num2 자리에 r값이 와서 r을 계산해가며 내려간다. 그리고 나머지 값이 0이 될 때 까지 진행하고 그 때 num2 자리의 값이 최대 공약수가 되는 것이다.

# 유클리드 호제법
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, (temp + 1)):
    if temp1 % n == 0:
        print('{}, {}의 공약수: {}'.format(num1, num2, n))

1. 앞서 설명한 것처럼 num1, num2를 받고,
2. temp2 가 0 이 될 때 까지 반복을 해준다.
3. temp 에 잠시 temp2를 넣어두고 자리를 옮긴 후 temp1 에 temp2를 넣어주는 식으로 반복한다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

기초 수학 1, 2(약수와 소수)

📖 약수와 소수

‣ 약수는 어떠한 수를 나누어 떨어지게 하는 수가 그 수의 약수이다. ‣ 소수는 어떠한 수가 약수를 1과 자기자신만을 가지고 있는 수가 소수이다.

약수를 먼저 보면, 예를 들어 15의 약수를 구하라. 15는 2로 나누어 떨어지지 않으므로 2는 15의 약수가 아니다. 3으로 나눌 수 있고 몫은 5이면 3과 5는 15의 약수이다.

# 약수와 소수, 1은 제외
inputNumber = int(input("0보다 큰 정수 입력: "))

for number in range(1, (inputNumber + 1)):  # 1부터 사용자가 입력한 수까지.
    if inputNumber % number == 0:
        print('{}의 약수'.format((inputNumber, number)))

0 보다 큰 정수를 입력받아 약수를 구해주는 코드이다.

1. 입력값으로 0보다 큰 정수(int)를 입력 받고,
2. for문으로 반복해서 (1부터, 내가 입력한수)까지 반복을 해준다. ⇨ 파이썬은 0부터 시작하기 때문에 입력값보다 1작은 수까지 반복되므로 +1해준다.
3. 입력값을 반복문에 들어가는 수로 나누었을 때 나머지가 0으로 나누어 떨어지면 그 수는 약수이다.

소수의 경우를 보면, 예를 들어 똑같이 15는 소수인가? 15는 앞서 본것처럼 약수(1,3,5,15)가 존재하기 때문에 소수가 아니다. 1부터 15까지의 소수를 찾으면 약수가 1과 자기자신만을 갖는[3,5,7,11,13]이 있다.

# 1부터 입력한 숫자까지의 소수를 출력한다.
inputNumber = int(input('0보다 큰 정수 입력: '))

for number in range(2, inputNumber + 1):  # 1은 소수가 아니라 2부터 시작, 사용자가 입력한 숫자까지라 +1 해준다.
    flag = True # 반복을 위해 flag

    for n in range(2, number):  # 위 for에서 나온 item을 반복 -> 시작 숫자부터 n 바로 직전 숫자까지 반복.
        # ex 1~5까지면 2,3,4 가 있는데 5라는 숫자를 2, 3, 4로 나눠봐서 0이면 소수, 소수가 아닌 합성수라 False가 되면서 끝.
        if number % n == 0: # 약수가 아니게 되므로
            flag = False    # False를 준다.
            break

    if flag:
        print('{} : 소수!!'.format(number))   # 1과 본인자신만을 약수로 갖는 수
    else:
        print('{} : \t\t 합성수!!'.format(number))  # 소수와 반대

# 마지막 if, else가 백탭해서 들어가면 10만 출력된다.

1은 소수가 아니기 때문에 2부터 시작한다.

1. 똑같이 입력 값(int)을 받고,
2. for문으로 2부터 입력 값까지 반복하는데 True flag를 넣어준다.
3. for문 안에 for문을 넣고 위에서 선언한 item을 반복하는데 시작 숫자부터 입력 값 바로 전까지 반복이다. ⇨ ex 입력 값이 5일 때 밖 for문의 범위가 1~5까지면 안 for문에선 2,3,4 가 있는데 5라는 숫자를 2, 3, 4로 나눠봐서 0이면 소수, 소수가 아닌 합성수라 flag가 False가 되면서 끝.
4. 그렇게 결과 값이 소수 이거나 소수가 아닌 합성수가 나온다.

소수란 어떤 것이냐 하는 것은 학교에서 배웠던 부분이라 다들 알겠지만 구현하는데 있어 어려움이 있을 순 있다. 소수를 구하는 방법 중 유명한 <테라토스테네스의 체> 라는 알고리즘이 있다. 위에 구현한 것 처럼 입력 값마다 대입하면서 구해내는 것이 아니라, 입력 값까지의 범위 중 약수, 약수의 배수들을 제거해 나가는 방식이다. 만약 소수를 구하고자 하는 범위가 크다면 테라토스테네스의 체 알고리즘이 훨씬 빠르고 효율적으로 구할 수 있을 것 같다.

★ 어려웠던 점 ★

1. 소수를 구할 때 for문 안에 for문이 들어갔던 부분. ⇨ 설명을 들으면서 작성은 했지만, 정확하게 이해가 가지않아 아직 혼자 작성한다면 떠오르는 방법이 아닌듯하다.

2. 바깥쪽 for문과 같은 라인에 마지막 출력단이 놓였을 때 입력 값에 대한 결과만 출력이 됐었다. 안쪽 for문과 같은 라인에 출력단을 놓으니 원하는 결과로 구하고자 했던 범위의 수 전체가 출력이 되는데 안쪽 for문을 거치면서 출력을 뽑아줬어야 원하는 결과를 보는건데 거치지 않고 바깥 쪽 for문만 출력해서 그런 것 같다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

> 파이썬 중급 문제풀이6(함수) ~ 모듈(1~2)

📖 함수6 등비수열, 등비수열의 합 구하기

어제는 초항에서 공차만큼 커지는 수를 보는 등차수열이었다. 오늘은 초항에서 공비만큼 커지는 수를 보는 등비수열이다!!

# 출력물 만들기(등비 수열의 합)
# 등비 수열(일반항) 공식: an = a1 * r^(n-1)
# 등비 수열(합) 공식: sn = a1 * (1-r^n) / (1-r)

def geoSequence(a, r, n): # 초항, 공비, n항
    # 먼저 선언해준다.
    valueN = 0  # n항의 값
    sumN = 0    # n항까지 합의 값

    i = 1
    while i <= n:
        if i == 1:
            valueN = a
            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

inputA = int(input('초항 입력: '))
intputR = int(input('공비 입력: '))
intputN = int(input('n번쨰항 입력: '))

geoSequence(inputA, intputR, intputN)

등차수열과 다른부분은 r 만큼 커지던게 r 배 만큼 커진다는거? 그래서 기억을 더듬어 혼자 짜보려 했지만 안된다 아직... 우선 강의를 들으며 이해하면서 따라해봤다.

1. n항의 값, n항까지의 값을 선언하고 초기화 해주고, i=1 까지 해주고 while문으로 들어간다.

★ while문은 만들자마자 탈출구를 만들어 놓자! 2. 현재 항의 값에 공비를 곱한 값을 현재 항의 값에 넣어주고, 현재 항 까지의 합 값에 계속 더해준다. 3. 입력값은 당연히 int로 캐스팅해서 받아줘야 계산이 들어갈 수 있다.

강의를 들으면서 따라치면 이해도되고 중간중간 실행했을 때 나는 error도 잡아내는데 혼자 짜라그러면 머리만 복잡하고 손이 안움직인다... 연습만이 살길이다.

📖 모듈1 시험점수를 입력받아 Pass or Fail 출력하기.

여태 선언과 출력을 한 파일에서 했다면 지금부터는 모듈따로 실행따로다. 우선 과목별 점수로 합격 여부를 출력하는 모듈을 보면,

# 과목별 점수로 합격 여부 출력하는 모듈
def exampleResult(s1, s2, s3, s4, s5):
    # 매개변수가 몇개가 들어올지 모를때 튜플로 만들어서 *s 형태로 사용하는 것으로 한번 짜보기.

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

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

1. 매개변수로 5과목을 받을 수 있게 준비해둔다.
2. 평균점수 합격커트, 최저점수를 선언하고 초기화 해준다.
3. 함수안의 함수로 전체 총점, 전체 평균, 과목별 합격/불합격 여부, 최종 합격/불합격 여부를 선언해준다.
4. 마지막에 결과물에서 원하는 서식에 맞게 평균, 과목별 합불, 최종 합불을 호출한다.

우선 이부분은 강의를 들으면서 따라했는데 중간에 getAverage에서 return을 하지않아 값이 넘어가지 못해서 error가 났었다. 항상 ★ return이 필요하다면 까먹지말고 해주기!!!

자, 이제 모듈을 만들었다면 실행파일을 만들어준다.

import passOrFail as pf # 너무 길어서 치환

if __name__ == '__main__':  # 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)

많은 내용이 입력되고 출력되는 코드치고 아주 간결해서 좋긴하다...

1. import로 앞서 만들어둔 passOrFail 모듈을 불러오고, 이름이 너무 기니까 as를 사용해서 pf로 치환.
2. 처음보는 name == 'main' 이라는 문법이 나왔는데, 다른언어와 달리 파이썬만의 특징 때문에 있는부분이다. ‣ 파이썬은 타 언어와 달리 main이 존재하지 않는다. ‣ 파이썬은 들여쓰기로만 level을 나누어 안인지 밖인지를 구분한다. ‣ 파이썬은 타 언어와 달리 동시에 번역하는 인터프리터 언어이다. 그래서 import해서 사용한다면 무엇인가 따로 써줄 필요없이 값을 넣어서 돌리면 끝이다. 아니라면 위의 코드처럼 무엇인가 토를 달아야한다.

📖 모듈2 구매갯수에 따라 할인율, 가격 출력하기.

이 문제도 처음에 머리속으로 구상하고 시작했는데 엉뚱한 결과만 나와서 따라했다. 우선 이 문제는 몇개나 살지 모르는 상황이여서 매개변수를 튜플로 담으려 했었는데 중간에 멈추고 강사님 방식으로 따라했다. ★ 꼭 처음 생각했던 (*변수)방식으로 다시 짜봐야겠다(메모..)

# 상품 구매 개수에 따라 할인율이 결정되는 모듈을 만들자.
def discountPurchase(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)]   # rates안에 있는 갯수라면 5~20퍼 아니라면 25퍼

        for g in gs:
            totalPrice += g * (1 - rate * 0.01)

        return [rate, int(totalPrice)]

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

할인율 밑 총 가격을 계산해줄 모듈이다.

1. 상품을 몇개 살지 모르니 len으로 카운트하고 만약 담은 물건이 없을 때를 먼저 만들어줬다.
2. rates (할인율)을 딕셔너리에 담아서 1개(5%)일때~4개(20%)일때까지 담아준다. ‣ 딕셔너리는 키(key)값, 벨류(value) 값으로 정의되는 방식이다. 튜플이나 리스트와는 달리 키 값을 입력하면 벨류 값을 출력할 수 있고, 추가 및 제거가 가능하다.
3. 할인율과 금액을 반환한다.
4. 💻 for g in gs:

    totalPrice += g * (1 - rate * 0.01) 이부분이 아직 잘 이해가 안간다...

위 내용을 가지고 출력할 파일이다.

# 상품 구매 개수에 따라 할인율이 결정되는 모듈을 만들자.
import discount as dc


if __name__ == '__main__':   # 전역변수 -> main과 같다면 실행파일
    flag = True #flag에 True가 들어있으면 while에서 반복할 수 있음
    gs = []

    while flag:

        selectNumber = int(input('1.구매, 2.종료'))

        if selectNumber == 1:
            goods_price = int(input('상품 가격 입력: '))
            gs.append(goods_price)  #append 리스트에? 담다.

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

    print(f'할인율: {result[0]}%')
    print(f'합계: {result[1]:,}원')    #fomatedNumber 써도 됨.

1. discount 지만 as dc를 사용해 dc로 치환해준다.
2. flag에 True(1)을 넣어주고 while에 flag를 두어 False가 되기 전까지 돌아갈 수 있도록 한다.
3. while 이 도는 동안 계속 1. 구매인지 2. 종료인지를 입력받는다. 당연히 int로 캐스팅
4. 1. 구매를 선택하면 가격 입력받는 단계로 넘어가고 goods인 리스트 gs에 append 함수를 통해 담아준다.
5. 만약 2. 종료를 선택하면 바로 결과값을 반환하고, flag를 False로 바꿔주며 while을 탈출한다.
6. 이전에 만들었던 formatedNumber를 사용해도 되지만, 내가 사용하기 편했던 (숫자:,)를 사용해서 금액을 이쁘게 출력해주었다.

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자🔥🔥

파이썬 중급 문제풀이 3 ~ 5

📖 비행기 요금표 출력(할인 기능 포함)

지난 문제풀이 2와 비슷하게 함수를 활용하여 출력물과 같은 결과를 내는 문제였다.

#비행기 요금표 출력(할인 포함)
childPrice = 18000
infanPrice = 25000
adultPrice = 50000
specialDC = 50

#천 단위로 , 찍는 함수 ***모르던 것***
def fomatedNumber(n):
    return format(n, ',')

def printAirPlaneReceipt(c1,c2, i1, i2, a1, a2):
    print('=' * 40)
    cp = c1 * childPrice
    cp_dc = int(c2 * childPrice * 0.5)
    print(f'유아 {c1}명 요금: {fomatedNumber(cp)}원')
    print(f'유아 할인 대상 {c2}명 요금: {fomatedNumber(cp_dc)}원')

    ip = i1 *infanPrice
    ip_dc = int(i2 * infanPrice * 0.5)
    print(f'소아 {i1}명 요금: {fomatedNumber(ip)}원')
    print(f'소아 할인 대상 {i2}명 요금: {fomatedNumber(ip_dc)}원')

    ap = a1 * adultPrice
    ap_dc = int(a2 * adultPrice * 0.5)
    print(f'성인 {a1}명 요금: {fomatedNumber(ap)}원')
    print(f'성인 할인 대상 {a2}명 요금: {fomatedNumber(ap_dc)}원')
    print('=' * 40)
    print(f'Total: {c1 + c2 + i1 + i2 + a1 + a2}')
    print(f'TotalPrice: {fomatedNumber(cp + cp_dc + ip + ip_dc + ap + ap_dc)}원')

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

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

aultCnt = int(input('성인 입력: '))
specialAdultCnt = int(input('할인 대상 성인 입력: '))

printAirPlaneReceipt(childCnt, specialChildCnt,
                     infantCnt, specialInfantCnt,
                     aultCnt, specialAdultCnt)
print('=' * 40)

또 길다.. 이젠 그러려니 한다. 적응해야 살아남는다.

1. 전역 변수로 유아(child), 소아(infan), 성인(adult)기준 금액들을 선언해준다.
2. 인수로 받아야 할 것이 유아, 유아 할인, 소아, 소아 할인, 성인, 성인 할인 이라 함수의 매개변수역시 6개로 지정.
3. 일반 가격은 각 인원 * 금액이고, 할인 가격은 인원 * 금액 * 0.5(50%할인) 이다.
4. 인수를 각각의 Cnt로 입력 받는다. ★인원수를 입력받아 계산해야하기 때문에 int로 캐스팅 중요!!!!★
5. 그리고 요금표 함수를 불러와 입력값들을 넣어주면 이쁜 3인 가족의 비행기 티켓 영수증이 출력된다.

설명안한 fomatedNumber 함수는 금액이 구분점 없이 "TotalPrice: 139500" 이런 식으로 출력되는 것을 "TotalPrice: 139,500" 로 바꿔주는 함수이다.

강의에서는 없었지만 파이썬의 기본 함수인 format(숫자, ',') 함수이다. 다른 방법으로는 print(f'{숫자:,}') ,print('{0:.}'.format(숫자)) 등의 방법이 있다. 다 한번씩 연습해보는 것도 좋지만 함수로 선언해놓고 호출하는게 편할 듯 하다.

📖 비행기 요금표 출력(할인 기능 포함)

① 입력 값의 팩토리얼 출력하기.

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

def recursionFun(n):  #재귀함수

    if n == 1:
        return n   #n이 1이면 끝난다.

    return n * recursionFun(n-1)   #n-1을 계속해서 호출하면서 n 이 1 이 될때까지 곱해준다.

intputNumber = int(input('input number: '))
print(format(recursionFun(intputNumber), ',')) #이렇게 format함수를 사용하던지, 위에서 함수를 선언하던지

1. 함수안에서 자기자신을 호출하는 recursion(재귀함수)을 선언한다.
2. 팩토리얼은 자기자신부터 -1 씩 곱해나가는 함수이기 때문에 1까지 갔을 때 종료되고 반환하면 된다.
3. 이 함수는 나와 나보다 -1인 값을 곱한 값을 반환한다.
4. 값을 입력하면 결과가 나오고 앞서말한 formatedNumber 함수를 활용해서 결과를 이쁘게 출력.

코드도 짧고 간단해 보이지만 처음 이 문제를 보고 생각했을 땐 머리속에서 난리를 치고있었다. 전날 연습했던 것처럼 함수에서 함수를 호출하는 효율적인 방법들을 익숙해질때까지 반복하는 것이 중요해보인다.

② 단리 / 월복리 계산하는 함수 만들기. 몰랐던 부분이라 설명해놓고 넘어가자면 단리 : 기간, 예산에 상관없이 최초 원금에 대한 이자만 붙는다. 복리 : 원금에 이자가 붙은 금액에 이자가 붙어 나가는 형태. 이자에 이자가 붙는다.

## 단리 / 월복리 계산기 함수 만들기.
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)   #totalRateMoney 에서 0.01 때문에 int로

# 월복리
def multiRateCalculator(m, t, r):

    t = (t * 12)  # 기간이 (년) 단위라 월로 바꿔준다.
    rpm = (r / 12) * 0.01

    totalMoney = m

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

    return int(totalMoney)

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

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

이 문제... 길고도 험했다. 중간에 빠트린 부분이 생겨서 질문도 해버렸었다...

1. 크게 단리 계산함수, 복리 계산함수를 선언한다. 두 함수 모두 매개변수로(금액, 기간, 이율)을 받는다.

----------------------------------------[단리]---------------------------------------- 2. 이자율을 for 문을 통해 i 가 t(기간)까지 금액 * 이율 * 0.01(백분율)로 구한다. 3. 총 금액은 초기 금액 + 총 이자금액 이고, 돈이 소수점으로 나올 수 없기 때문에 ★int로 캐스팅 ----------------------------------------[복리]---------------------------------------- 2. 월 복리이기 때문에 기간을 12로 나누어 한달치 이자율을 계산하기 쉽게 만들어준다. 3. 이자율(rate per money)도 같이 나눠주고 0.01(백분율)도 곱해준다. 4. money(금액), term(기간), rate(이율)을 입력값으로 받고, 5. 입력값을 \t 를 활용해 일정 칸 탭을 해주어 정렬해준다. 6. 앞서 사용한 formatedNumber를 가져와 이쁘게 서식에 맞추어 출력한다.

입력값을 int로 캐스팅하지 않고 코드를 돌리니 계산이 안된다는 error가 나지... error 나는 순간 벙쪄서 이게 안보이고 검색하고 있었다. 지금보니 별거 아닌걸 깨우쳤으니 앞으로도 천천히 따져가면서 해석하면 실력이 향상될 것이라 믿는다.

📖 등차수열의 합 구하기

등차수열은 초기값 부터 공차 만큼씩 n 항까지 나아가는 수열이다. 이 문제도 보자마자 노가다성 코드가 생각났다...

#등차수열의 합 구하기.
def sequenceCal(n1, d, n): # d=공차

    valueN = 0;# n항의 값
    sumN =0; # n 항까지 합의 값

    i = 1
    while i <= n: # i 가 n 보다 작거나 같을떄 까지
        if i == 1:
            valueN = n1   #초항
            sumN += valueN
            print(f'{i}번쨰 항의 값: {valueN}')
            print(f'{i}번쨰 항까지의 값: {sumN}')

            i += 1  # i가 n보다 크게되면 스톱
            continue

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

        i += 1   # i에 +1씩 해줘야 무한반복에 빠지지 않음.

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

sequenceCal(inputN1, inputD, inputN)

1. sequenceCal(등차수열의 합을 구하는 함수)는 매개변수로 (n1(초항), d(공차), n(마지막항))을 갖는다.
2. i = 1 부터 while문으로 i 가 n 보다 같거나 작을 때까지 계속 돌린다. 하지만 i 가 1이면 초항이 곧 끝이다. 그래서 i += 1 을 해주고 continue로 진행시켜~
3. 이전 값(valueN)에 공차 d를 계속 += d 더해주고 그 값을 등차수열의 합 sumN 에 넣어준다.
4. 그리고 중요한 ★ 무한루프에 빠지지 않기 위해 i += 1 을 해준다!!
5. 입력값을 int로 캐스팅해서 받고 함수를 호출하면 결과가 나온다. 초항은 1 이고 공차는 3 이고 7 번째까지의 합을 구하는 함수였다.

🔥🔥 바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자!🔥🔥

파이썬 중급 5(모듈제작), 파이썬 중급 문제풀이 1 ~ 2

📖 모듈은 파이썬 파일이다!

지난시간에 만들었던 4칙연산 기능을 하는 calculator 를 .py 파일로 따로 저장하면 그또한 모듈이 되는것이다.

calculator 같은 .py 파일을 하나 만든다. 모듈을 활용한 .py파일을 하나 더 만든다. 모듈을 활용할 곳에서 import calculator 를 한 후 마치 이 파일에 작성한 것 처럼 활용한다.

예제) 문자열을 입력하면 뒤집어서 출력하는 모듈

#뒤집어서 반환하는 모듈 reverseStr.py
def reverseStr(str):
    reverseString = ''

    for c in str:
        reverseString = c + reverseString

    return reverseString

#모듈을 활용해서 출력하는 module.py
import reverseStr

userInputStr = input('문자열 입력: ')
reverseString = reverseStr.reverseStr(userInputStr)
print(f'reverseString: {reverseString}')

reverseStr.py 부터 살펴보면

1. parameter로 들어온 값을 매개변수로 str이 받는다.
2. 변수 reverseString 을 선언.
3. for 문을 통해 입력받을 str 값에서 c로 나눠서 한글자씩 뒤로 밀면서 저장한다.

📖 중급 문제풀이 1

7가지의 함수를 선언하고, 골라서 사용할 수 있게 만들어본다!

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:
        add(num1, num2)
        print(f'{num1} + {num2} = {add(num1, num2)}')

    elif selectNum == 2:
        sub(num1, num2)
        print(f'{num1} - {num2} = {sub(num1, num2)}')

    elif selectNum == 3:
        mul(num1, num2)
        print(f'{num1} * {num2} = {mul(num1, num2)}')

    elif selectNum == 4:
        div(num1, num2)
        print(f'{num1} / {num2} = {div(num1, num2)}')

    elif selectNum == 5:
        mod(num1, num2)
        print(f'{num1} % {num2} = {mod(num1, num2)}')

    elif selectNum == 6:
        flo(num1, num2)
        print(f'{num1} // {num2} = {flo(num1, num2)}')

    elif selectNum == 7:
        exp(num1, num2)
        print(f'{num1} ** {num2} = {exp(num1, num2)}')

    else:
        print('잘못 입력하셨습니다. 다시 입력하세요.')
    print('-' * 60)

중급넘어왔다고 바로 길어져버렸다.... 하지만! 이해를 하고 넘어가야하니 설명간다.

1. def 부분은 순서대로 덧셈, 뺄셈, 곱셈, 나눗셈, 나머지, 몫, 제곱을 구하는 함수를 선언.
2. while 반복문은 조건이 참 일동안 도는데 True 를 넣어줘서 사실상 계속 도는 구조를 만든다.
3. 빠져나가긴 해야하니 8 번은 break 를 걸어준다. (★ while문 만들면 탈출구 부터 찾아두자!!)
4. 어떤 함수든 인수를 넣어줘야 하니까 input 값을 받아줄 num1, num2 를 선언.
5. 어떤 함수를 사용할지를 골랐을 때 나올 수 있도록 if, elif 그리고 범위를 넘어갔을 때 돌려줄 else.

코드와 설명은 간단하지만 길어졌다고 쫄았다...

📖 중급 문제풀이 2

요구하는 출력물을 만들어내라!

1. 90(km/h)의 속도로 2(h)시간 45(m)분 동안 이동한 거리 : 247.5km 을 만들어라.

def getDistance(speed, hout, minute):
    return speed * (hout + (minute / 60))
#    print(getDistance(s, 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)분 동안 이동한 거리 : {getDistance(s, h, m)}(km)')

1. s, h, m 변수로 속도, 시간, 분 을 입력받는다. (easy)
2. 속도와 시간으로 거리를 구해야하므로 거시속, 거속시 공식을 getDistance 함수로 만든다.
3. 단위를 맞춰줘야 하기에 분은 60분 기준으로 맞춘다. (입력값은 시간값이므로 60으로 나누어 분으로 맞춤)

나쁘지 않은 난이도 였지만 거시속, 거속시 공식에서 단위를 맞추어 주는것이 포인트인듯한 문제.

2. 90(km/h)속도로 247.5(km) 이동한 시간 : 2(h)시간 45(m)분 을 만들어라.

   def getTime(speed, distance):
    time = distance / speed
    print(f'time: {time}')
    h = int(time)
    m = int((time - h) * 100 * 60 / 100)
   
    return [h, m] #값이 2개라 리스트로 묶어서 반환
   

s = float(input('속도(km/h)를 입력하시오. ')) d = float(input('거리(km/h)를 입력하시오. ')) t = getTime(s, d)

print(f'{s}(km/h)속도로 {d}(km) 이동한 시간: {t[0]}(h)시간 {t[1]}(m)분') print('*' * 60)

```

1. getTime 함수로 속도, 거리를 받아 시간을 구한다.
2. 100 기준 75 이니 60분 기준일 때 시간은 x 다 ☞ 100 : 75 = 60 : x 로 거시속 공식!
3. 결과물에서 시간을 h, m 두 개로 나누었기 때문에 시간(t) 값을 list[h, m]으로 반환!

1번 문제와 비슷했지만 역시 단위 환산과 시간을 리스트로 묶는 센스를 볼 수 있는 문제였다.

● MAC 기준 작성하다 Windows와 키를 헷갈려서 복붙한다는게 [control + c] 를 눌렀는데 input을 입력할 수 없는 keyboardinterrupt error가 발생해서 애 먹었다... 다시 한번 [control + c] 이 친구를 입력하면 풀리니 당황하지 마시길!!

🔥🔥바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자!🔥🔥

파이썬 중급 4(인수와 매개변수) ~ 9(모듈)

📖 파이썬 중급 4(인수와 매개변수)

이전에 def 키워드를 활용하여 함수를 선언할 수 있었다.

‣ 함수의 호출부에서 데이터 값을 전달할 수 있다. ‣ 함수 선언부의 매개변수 ★ def greet(country) ⇨ country가 매개변수 ‣ 함수 호출부의 인수 ★ greet(Korea) ⇨ korea가 인수 ‣ 인수와 매개변수는 쌍을 이루어야 한다.

함수를 좀 더 효율적으로 보다 많은 곳에 사용할 수 있어졌다. 하지만, 참가자 100명 중 생존한 n명의 번호를 나열하라! 처럼 매개변수가 정해져 있지 않을 수 있다. 그럴 땐 매개변수를 튜플로 만들어버려서 가변적으로 활용할 수 있는 방법이 있다.

def printNum(*numbers):
    for number in numbers:
        print(number, end=' ')
    print()

printNum()
printNum(1)
printNum(1, 2, 3)
printNum(1, 2, 3, 4, 5)

매개변수를 매번 인수와 맞춰주지 않아도 있으면 있는만큼 없으면 없는만큼 아래의 결과처럼 맞춰서 출력할 수 있다.

빈칸 1 1 2 3 1 2 3 4 5

📖 파이썬 중급 5(데이터 반환)

함수 실행결과를 호출부로 돌려줄수 있다! (with return)

def calculator(n1, n2):
    result = n1 + n2 

    return result

returnValue = calculator(10, 20)
print(f'returnValue: {returnValue / 2}')

여기는 조금 헷갈릴 수 있다. 코드 작성하기 전 천천히 머리속으로든 메모를하든 정리해두고 가지않으면 꼬일 것 같은 부분이다...

1. calculator라는 함수는 n1과 n2를 매개변수로 받는 함수이다.
2. result에 n1 + n2 값을 담겠다.
3. result값을 return으로 호출부에 반환을 하겠다.
4. 반환된 값을 returnvalue에 담겠다.
5. 매개변수의 인수로 10, 20 을 주겠다. ‣ 이 부분이 헷갈릴 수 있는데, returnValue엔 result 값인 30이 들어오고 뒤에 있는 calculator 부분은 원래의 목적 그대로 10, 20 을 선언부로 던져주는 것이다.
6. 이렇게 반환받은 데이터는 추가 가공이 가능해진다.

내 기준 헷갈릴 수 있는 부분은 returnValue = calculator(10, 20) 이 부분인데, 반복해서 이해는 갔으니 계속 눈에 익혀서 익숙해지는 방법뿐이 없을 것 같다.

📖 파이썬 중급 6(지역 변수와 전역 변수)

함수 내에서만 사용할 수 있는 변수가 있다! (with global 키워드)

#지역 변수 구분법
def printNumber():
    num_in = 20
    print(f'num_in: {num_in}')

printNumber()                ------------- ①
print(f'num_in: {num_in}')   ------------- ②

① 까지만 입력했을 땐 정상적으로 num_in: 20이 출력된다. ‣ printNumber 라는 함수의 결과를 출력한 것이기 때문에. ① 이 없고 ② 를 입력한다면 error가 난다. num_in은 printNumber() 함수 안에서만 사용되는 지역 변수이기 때문에 print를 한다면 선언되지 않은 변수를 출력하려하는 것이기 때문이다. 만약 def 밖에 num_in 을 선언하고 초기화 해주었다면, 전역 변수로서의 num_in을 출력할 수 있다.

아래의 예제에서 width와 height는 전역 변수로서 함수 안에서 얼마든지 활용은 가능하다.

#지역 변수활용 예제
def printArea():
    triangleArea = width * height / 2
    squareArea = width * height

    print(f'삼각형의 넓이는? {triangleArea}')
    print(f'사각형의 넓이는? {squareArea}')
width = int(input('가로의 길이를 입력하시오: ')) #width, height는 전역변수
height = int(input('세로의 길이를 입력하시오: '))
printArea()

📖 파이썬 중급 7(지역 변수와 전역 변수)

함수 속 또 다른 함수! (with calculator)

3에서 배웠던 함수 내 다른 함수 호출과 비슷하다. ex) 구구단 2단 함수 안에 3단 호출 함수같이 하지만 함수 안에 또 다른 함수를 선언하는 것이기 때문에 완전 다르다. 전역 변수, 지역 변수처럼 내부 함수를 밖에서 따로 호출할 수는 없다.

def out_fun():
    print('out_fun called')

    def in_fun():
    print('in_fun called')

    in_fun() ------------- ①
 in_fun() ------------- ②

‣ ① 은 함수안에서 선언되고 함수 안에서 호출된거라 가능 ‣ ② 는 함수 밖에서 내부 함수만 따로 호출한거라 불가능

예제가 어려워졌다... 코드 조금 길어지니깐 정신 차리기 힘든상황...

#중첩함수 예제 계산기
def calculator(n1, n2, operator):

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

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

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

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

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

while True:
    num1 = float(input('실수(n1) 입력: '))
    num2 = float(input('실수(n2) 입력: '))

    operatorNum = int(input('1. 덧셈, 2. 뺄셈, 3. 곱셈, 4. 나눗셈, 5. 종료'))

    if operatorNum == 5:
        print('Bye')
        break

    calculator(num1, num2, operatorNum)

1. 매개변수 3개를 갖는 calculator 함수안에 add, sub, multiple, divide 를 선언
2. 기능 선택에서 입력을 받고 각 입력 값 별로 기능을 실행할 수 있는 조건문
3. 계속해서 돌아갈 수 있ㄱㅔ While 문을 넣어주고 입력 값들을 받는다.

while 문과 if 문이 헷갈리는데 이 부분은 문제를 많이 풀며 익혀야겠다...

📖 파이썬 중급 8(lambda 함수)

간단한 기능의 함수를 간단하게! (with calculator)

기존에 사용했던 함수들은 def 부터 기능까지 상세하게 적었다면, 간단한 기능의 함수들은 lambda를 활용하여 간단하게 선언가능!

#lamda함수 예제
def calculator(n1, n2):
    return n1 + n2

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

calculator2 = lambda n1, n2: n1 + n2
returnValue2 = calculator2(10, 20)
print(f'returnValue2: {returnValue2}')

calculator 함수는 기존에 배웠던 방식으로 선언하고 호출하는 방법이고, calculator2 함수는 lambda를 활용해서 매개변수와 기능을 바로 선언해버리기 때문에 코드가 5줄에서 ⇨ 3줄이 되는 기적이 일어난다.

#한번의 입력으로 여러 값을 받아보는 lambda 활용법
getTriangleValue = lambda n1, n2: n1 * n2 / 2
getSquareValue = lambda n1, n2: n1 * n2
getCircleValue = lambda n1 : n1 * n1 * 3.14

width = int(input('가로(반지름) 길이를 입력하시오.'))
height = int(input('세로 길이를 입력하시오.'))

getTriangle = getTriangleValue(width, height)
getSquare = getSquareValue(width, height)
getCircle = getCircleValue(width)

print(f'삼각형의 넓이: {getTriangle}')
print(f'사각형의 넓이: {getSquare}')
print(f'원의 넓이: {getCircle}')

def 를 사용했다면 엄청 길어졌을 코드가 lambda를 활용함으로써 깔끔하게 덩어리지고 간결해졌다.

📖 파이썬 중급 9(모듈)

함수가 선언되어 있는 파이썬 파일

모듈이란? 내부 모듈, 외부 모듈, 사용자 모듈로 크게 나눌 수 있다. 내부 모듈 : 파이썬 설치하면 기본적으로 사용 가능한 모듈 외부 모듈 : 별도로 설치해서 사용하는 모듈 사용자 모듈 : 사용자가 직접 만들어 사용하는 모듈 조립식 컴퓨터에 부분 부분 좋은 부품으로 교체해서 업그레이드를 시킨다 생각하면 각 부품은 모듈이 된다.

🔥🔥 바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자! 🔥🔥

스터디노트 3일차 범위

파이썬 기초 1주차 퀴즈 1,2 연습문제 3~5 파이썬 중급 1 - 3

★ 파이썬 기초 1주차 퀴즈 1, 2

● 퀴즈로 복기하는 주의해야할 부분들!

‣ 변수를 선언하면 반드시 초기화를 해줘야함 ‣ print(f'User name : {var}') 포맷문자열 활용 ‣ 형식 문자로 정수, 실수, 문자열 구분 ‣ %.4f 처럼 소수점 자리를 정해놓으면 반올림이 되기도 함 ‣ 문자열간 뺼셈은 적용되지 않음 ‣ 0으로는 나눌 수 없음

★ 형변환과 대치

● 어제까지 배웠던 len()함수를 이용한 문자(열)의 길이 파악과 대치를 활용하여 간단한 예시를 짤 수 있다.

#자리 치환 활용
id = input('id: ')
pw = input('pw: ')
privateNum1 = input('privateNum1: ')
privateNum2 = input('privateNum2: ')

print(f'id : {id}')
pwStar = len(pw) * '*'
print(f'pw : {pwStar}')
prNumStar = privateNum2[0] + len(privateNum2) * '*'
print(f'privateNum : {privateNum1}-{prNumStar}')

‣ 출력물 : 입력한 ID값
‣ 출력물 : 입력한 PW값 길이 만큼의 '*'
‣ 출력물 : 입력한 주민등록번호 ex) 941212-1******

1. input함수를 활용하여 id값, pw값, 주민번호 앞, 뒷 자리를 입력받는다.
2. id, 주민번호 앞자리, 뒷자리 첫 숫자(성별)은 그대로 출력
3. pw값과 남은 주민번호 뒷자리는 ' * '로 대치

len()을 활용하여 길이만큼 자동으로 대치 두 가지 포멧함수 활용 ‣ f'pw : {pwStar}' ‣ 'pw : { }'.format(pwStar)

★ 임시저장 변수

● 직관적인 지금까지의 과정과는 조금 다른 임시저장 변수를 활용한 변수값 변경한다.

#trans position
num1 = 10
num2 = 20

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

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

1. 임시저장 변수인 tempNum
2. num2의 값을 tempNum에 저장해두고,
3. num1의 값을 num2에 넣어둔다. (num1과 num2가 같아지는 지점)
4. num1에 tempNum에 들어있던 값을 넣어준다. (num1, 2가 바뀌는 지점)

간단하게 생각했다가, 처음엔 당황스러울 수 있는 문제를 임시변수로 해결한다.

★ 파이썬 중급(1-3) 함수

● 다양한 함수를 선언하고 호출한다.

함수 선언 def addCal(): \t n1 = int(input()) \t n2 = int(input()) \t print(f'n1 + n2 = {n1 + n2}')

1. def을 먼저 쓰고 뒤에 함수명을 선언한다.
2. 콜론 ( : )을 빼먹지 않도록 주의한다.
3. 이후엔 함수명으로 호출해서 사용한다.

● 함수안에 함수를 또 호출할 수 있다.

함수 안에 함수를 호출하여 연쇄적으로 실행되게 할 수 있다. pass를 이용하여 실행문을 생략할 수 있다.

def addCal1():
  print(addCal1)
‣ addCal2()    #함수안에 함수 호출

def addCal2():
  print(addCal2)

addCal1()

addCal1()이라는 함수를 선언하고 함수 안에 addCal2()라는 함수를 호출할 수 있다. 이런경우 addCal1()을 실행하였을 때 addCal2()까지 연쇄적으로 실행이 된다.

바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자!

파이썬 기초

★ 자료형 변환(type cating)

‣ 데이터 타입을 변환하는 것으로 파이썬에서 제공하는 함수를 이용.

정수 <---type cating ---> 문자(열) 실수 <---type cating ---> 정수 논리 <---type cating ---> 문자(열) 등 다양한 자료형을 서로서로 변환 해줄 수 있다.

먼저 내가 가진 데이터의 타입을 확인하려면 type 함수를 이용하여

var = 100
print(var)
print(type(var))

데이터의 타입을 확인할 수 있다.

예를 들어 입력된 정수형(int) 데이터를 문자(열)로 변환하고 싶다?

var = str(var)
print(var)
print(type(var))

이런식으로 변환이 가능하다. 같은 100으로 출력이 된 것처럼 보이지만 데이터 타입은 정수형 -> 문자형이 된다.

논리(boolean)의 경우 True or False로 나뉘고 True = 1, False = 0

var = True
print(var)
print(type(var))   #출력값은 'bool'이 나올 것.

#논리 -> 문자(열) 변환
var = str(var)
print(var)
print(type(var))   #같은 True로 보이겠지만 타입은 'str'

이 밖의 자주쓰는 데이터 타입으로는

정수형 = int 실수형 = float 논리형 = bool 문자(열) = str

등이 있으니 참고해서 활용하면 된다.

★ [연습문제] 데이터와 변수

‣ 영수증 같은 반복되는 템플릿을 만들때에는 앞서배운 변수를 활용하면 편하다.

잘생긴 회원님 안녕하세요. 잘생긴 회원님의 결제가 완료되었습니다. 다음은 상세 결제 내역입니다.

--------------------------------

상품명 : 크로스핏화 결제방법 : 신용카드 결제금액 : 150000원 결제일시 : 2023/02/02 19:05:12 할부 : 3개월 할부유형 : 무 문의 : 010-0000-0000

--------------------------------

저희 센터를 이용해 주셔서 감사합니다.

위와 같은 형식의 영수증이라면 '잘생긴', '상품명' 부터 '문의' 까지 변수를 사용한다면 효율적일 것이다.

★ [연습문제] 데이터와 변수 2

‣ 데이터를 효율적으로 다루려면 내 입맛에 맞춰 가공할 줄 아는것이 중요하다. 파이썬에서 제공되는 len() , find() 함수를 활용하면 좋다.

len() : 데이터의 길이를 세어주는 함수 find() : 데이터에서 찾고자 하는 부분을 찾아주는 함수

len() 함수의 예를보면

msg = 'Hello python!'
print(len(msg))

#출력값 => 13

바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자!

파이썬 기초

★ 파이썬 특징

‣ 다른 언어들에 비해 문법 구조가 쉽다. ‣ 무한 정수를 처리할 수 있다. ‣ 다양하고 뛰어난 모듈이 많다.

★ 파이썬 설치

‣ https://www.python.org/ 에 접속해서 최신버전 다운로드 ‣ MAC OS 환경에서는 다음, 다음만 눌러주면 깔끔하게 설치 완료!

★ PyCharm 설치

‣ https://www.jetbrains.com/ 에 접속해서 다운로드 및 설치 ‣ 파이썬을 조금 더 쉽고 다양한 모듈을 활용할 수 있게 해주는 개발자 도구

#간단한 내용 출력 테스트
#가로가 10cm, 세로가 25cm인 삼각형의 넓이 출력

width = 10
height = 25

print('삼각형의 넓이는 : ", width * height / 2, 'cm')

★ 데이터와 메모 그리고 데이터 출력

파이썬은 숫자: 10, 20,... / 문자: '가', 'python', '^&/ 음원, 영상, 이미지 등 다양한 *데이터를 **메모리라는 변수에 저장하다가 PC에서 실행시킨다.

★ 변수

number(숫자)라는 변수에 10을 저장한다면 파이썬에서는

ex) number = 10

이렇게 적어준다. 수학에서의 등호와 다르게 등호 오른쪽의 데이터를 등호 왼쪽의 변수에 저장한다는 의미이다.

★ 변수를 사용하는 이유

변수를 사용하는 이유는 프로그래밍의 효율을 챙길 수 있기 떄문! Hello world!를 10번 출력해야할때,

print('Hello world!')
print('Hello world!')
print('Hello world!')
print('Hello world!')
print('Hello world!')

.
.
.

이렇게 써야한다면 10번정도는 쓰겠다만... 코드가 길어질수록 힘들것이다.

greeting = 'Hello world!'

print(greeting)
print(greeting)
print(greeting)
print(greeting)
.
.
.

이렇게 변수를 사용한다면, 후에 변수명만 수정한다면 10번이든 10000번이든 한방에 수정이 가능하다.

★ 변수명은 이렇게 하세요.

이렇게 효율적인 변수를 사용하는데 주의할 점이 있다!

우선 안되는 경우를 보면

● 시작과 중간에 공백 금지 ● 변수의 시작은 숫자 금지 (특수문자는 언더바를 제외하고 가능)

변수명을 한글로 써도 되지만,

도시 = '대한민국 서울시'

오류가 날 수 있기 때문에

city = 'Korea seoul'

영어로 작성해주는 것이 정신건강에 좋을 것이다.

영어로 작성하는 방법도 여러가지가 있는데 대표적으로

● 카멜 표기법 : 낙타의 등에 있는 혹과 비슷하다 하여 지어진 이름으로, 시작은 소문자, 단어와 단어를 구분할 때 대문자로!

myHeight = 180
print(myHeight)

● 스네이크 표기법 : 카멜 표기법과 다르게 변수가 뱀처럼 생겼다 해서 스네이크 표기법. 단어와 단어사이를 언더바( _ )로 이어준다.

customer_phone_number = '010-0000-0000'

이 외의 방법들로도 변수를 정할 수는 있지만, 정신건강을 위해 권장하지는 않는다.

바쁜시간 쪼개서 매일매일 성장해 나가는 모습을 기록하자!

Java와 기초 수학에 대해서만 진도를 나가고 있다가 컴퓨터 공학 이론도 보기 시작했다. 전공자라면 당연하게 생각할 수도 있고, 비전공자라면 공부할 양이 늘어나는 부분. 하지만 개발자가 되기 위해선 잘 숙지하고 있어야 면접때도 써먹는 부분이다.

컴퓨터 구조

비슷한 학과를 나와서 컴퓨터 구조 수업을 들었어서 익숙한 이름들이다.

컴퓨터는 크게 HW(하드웨어)와 SW(소프트웨어)로 구성되어있고, HW에는 Input/Output Device와 Storage(저장장치) 등 눈에 보이는 것들. SW에는 OS(Operating System)운영체제 등으로 나눌 수 있다.

기억장치는 주기억장치와 보조기억장치로 나누어 볼 수 있는데, 먼저, 주기억장치는 기억된 내용을 읽기만 가능한 ROM(Read Only Memory)와 휘발성 메모리인 기억소자로 연산결과를 저장하거나 다음 연산에 사용할 수 있어서, 컴퓨터 체감속도에 큰 영향을 주는 RAM(Random Access Memory)가 있다.

보조기억장치는 흔히 아는 HDD, SSD, USB, CD 등 Data를 저장하고 꺼내서 사용하는 저장장치를 말한다. 물론 종류에 따라 동작 방식, 처리속도, 구조 등이 다르지만 다음에 자세하게 파해쳐보려한다.

요즘은 공정의 발전으로 성능이 많이 좋아져서 개인적으로 예전의 인텔의 i7이 지금의 i3정도로 체감된다.. 앞으로는 과학자들과 박사님들의 말처럼 _"양자를 이해한사람은 아무도 없다.."_의 양자를 이용한 양자컴퓨터가 판도를 바꿀 것으로 보인다. 0과 1을 가지고 움직이는 현재의 컴퓨터와 다르게 큐비트(qubit)를 가지고 작동하기 때문에 연산속도가 엄청나게 빨라져서 현재 기술력의 암호문은 의미가 없다는 말도 본적이 있다. 때문에 양자컴퓨터의 리더자리를 차지하려는 IBM, 구글, MS, 인텔 등 대형 컴퓨터업계의 신경전도 많이 보았다.

비트(bit)란

공대에 처음 왔을 때 이과에 처음 들어간 고2 때 수학선생님께서 "이과와 공대는 0과 1만 알면 다 끝나. 쉽지?" 라고 하셨었는데 따지고 보면 또 틀린말은 아닌거같다... 우리가 아는 비트는 0 또는 1을 가지는 코드를 비트라고 한다. 우리가 컴퓨터살때나 사용할때 따지는 용량에서 많이보는 단위에도 <bit -> byte -> KB -> MB -> GB -> TB> bit가 들어간다.

2진수

bit는 0 또는 1로 이루어진 코드이고, 컴퓨터 내에서 데이터를 표현하기 위해 0 과 1로 표현할 수 있는 2진수가 있다. 우리가 일상생활에 흔히 사용하는 숫자는 0부터 시작해서 9까지를 기준으로 하는 10진수 인데, 컴퓨터는 0과 1만을 사용하는 2진법 체계를 가지고 있기 때문에 진법의 변환이 필요하다. 변환을 통해서 컴퓨터 프로그래머들은 8진수 또는 16진수를 쓰는 경우도 많다.

만약 10진수 숫자인 80을 16진수로 변환한다면, 10진수로 표현된 숫자를 변환하고 싶은 진수의 수로 나누어 주면된다. 16진수는 0~F까지로 나타낼 수 있기 때문에 주의해서 계산하면 80 / 16 = 5 ... 0 이 나오고 16진수로 표현할때에는 더 이상 나누어 지지않는 몫이 나올때까지 나누고 마지막 몫부터 나머지를 거꾸로 읽어주면 된다. 따라서 10진수 80은 16진수 50(16)의 값을 갖는다.

논리연산자

0과 1로 이루어지긴 하지만 규칙에 맞게 다루어야 우리가 원하는 동작을 하는 컴퓨터를 만들 수 있을 것이다. 회로설계할 때 많이 사용하던 논리연산자를 가지고 규칙을 만들면 된다.

논리연산자는 0과1 둘다 참일 때 참이 되는 AND, 둘 중 하나만 참이여도 참이 되는 OR, 0이면 1을 1이면 0을 반환하는 NOT부터 NAND, NOR, ExOR 등이 있다. 학부시절 과제 때문에 회로를 설계하는데 파일이 자꾸 날라가고 선이 끊겨서 분노를 참지 못하고 싹다 AND, OR로 짠 적이 있는데... 회로가 상상을 초월하는 거대한 사이즈로 나왔던 웃픈 사연이...

과제를 바로 시작하고 머리 좋던 친구들은 NAND, NOR, Ex연산자를 잘 활용해서 깔끔하고 간단하게 꾸몄다. 이렇게 논리연산자로 0과 1을 규칙에 맞게 동작할 수 있게 하면 우리가 컴퓨터를 사용할 수 있게된다.

예로 for문을 사용 했을 때

public void exLoop()
{
    for (int i = 0; i <= 5; i++) {
        System.out.println(i);
    }
}

이런 식으로 숫자를 출력할 수 있다면, IntStream을 사용한 반복문은 한 줄로 표현이 가능하다. 예를 들면 아래와 같다.

public void exIntStream()
{
    IntStream.range(0, 6).forEach(System.out::println);
}

위의 for문과 아래의 IntStream을 사용한 반복문의 결과는 0 1 2 3 4 5로 같다.

range는 종료 값을 포함하지 않아서 5까지 출력하려면 6을 쓰게 되는데, rangeClosed를 사용하면 종료 값도 포함하여 깔끔하게 표현 가능하다.