제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 근삿값

특정 값과 가장 근사한 값을 배열에서 찾기

 

inputNum = 17
minNum = 30

num = [25, 15, 20, 10, 30]

for n in nums:
     absNum = abs(n-inputNum)
     
     if absNum < minNum:
         minNum = absNum
         nearNum = n
         
print(nearNum) # 15

- 특정값과 차이가 가장 작은 값이 근삿값이 된다(abs(n-inputNum))

- 배열을 돌면서 차이가 가장 작은 값이 나올 때, nearNum으로 저장한다.

 


📍 재귀

return 값으로 자신 함수를 다시 호출하는 것

 

def factorial(num):
    if num > 0:
        return num * factorial(num-1)
    else:
        return 1
        
        
print(factorial(10)) # 3628800

- factorial(팩토리얼)은 수를 1씩 빼면서 모두 곱하는 함수이다.

- 반복문을 사용하지 않고 바로 num-1한 값을 내 자신 함수에 넣어서 재귀적으로 호출한다.

 


📍 병합정렬

자료구조를 분할하고 각각의 분할된 자료구조를 정렬한 후 다시 병합하는 정렬 방법

 

 

def mSort(nums):
    if len(nums) < 2:
        return nums

    mid_idx = len(nums) // 2
    left_nums = mSort(nums[0:mid_idx])
    right_nums = mSort(nums[mid_idx:len(nums)])

    mergedNums = []
    left_idx = 0; right_idx = 0
    while left_idx < len(left_nums) and right_idx < len(right_nums):
        if left_nums[left_idx] < right_nums[right_idx]:
            mergedNums.append(left_nums[left_idx])
            left_idx += 1
        else:
            mergedNums.append(right_nums[right_idx])
            right_idx += 1

    mergedNums = mergedNums + left_nums[left_idx:]
    mergedNums = mergedNums + right_nums[right_idx:]
    print(f'mergedNums: {mergedNums}')
    return mergedNums


nums = [8, 1, 4, 3, 2, 5, 10, 6]
print(f'mergedNums: {mSort(nums)}') # 1, 2, 3, 4, 5, 6, 8, 10

- 좌우를 나눠서 서로 값을 비교하고, 더 작은 값을 병합해나간다.

- 좌우를 나눌 때마다 한쪽이 또 같은 함수를 적용하게 되기 때문에 재귀로 해결한다.

 


📍 퀵 정렬

기준 값보다 작은 값과 큰 값으로 분리한 후 다시 합치는 정렬 방법

 

 

 

def qSort(nums):

    if len(nums) < 2:
        return nums

    mid_idx = len(nums) // 2
    mid_val = nums[mid_idx]

    small_nums = []
    same_nums = []
    big_nums = []


    for n in nums:
        if n < mid_val:
            small_nums.append(n)
        elif n == mid_val:
            same_nums.append(n)
        else:
            big_nums.append(n)

    return qSort(small_nums) + same_nums + qSort(big_nums)


nums = [8, 1, 4, 3, 2, 5, 4, 10, 6, 8]
print(qSort(nums)) # 1, 2, 3, 4, 4, 6, 8, 8, 10

- 기준을 정하면 좌우가 아닌 크고 작은 값으로 같은 함수를 적용해야 할 대상이 정해진다.

- 기준보다 작은 쪽에 있는 수들에 같은 함수를 재귀적으로 적용하고, 기준보다 큰 쪽에 있는 수들에 같은 함수를 재귀적으로 적용해 마지막에 합쳐 준다.

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 이진탐색

정렬되어 있는 자료구조에서 중앙값과의 크고 작음을 이용해서 데이터를 검색한다.

 

nums = [4, 10, 22, 5, 0, 17, 7, 11, 9, 61, 88]

nums.sort()

searchData = 17

result_idx = -1

start_idx = 0
end_idx = len(nums) - 1
mid_idx = (start_idx + end_idx) // 2
mid_value = nums[mid_idx]

while True:
	if searchData == nums[len(nums) -1]:
        result_idx = len(nums) - 1
        break
    
    if searchData > mid_value:
        start_idx = mid_idx
        mid_idx = (start_idx + end_idx) // 2
        mid_value = nums[mid_idx]
        
    elif searchData < mid_value:
        end_idx = mid_idx
        mid_idx = (start_idx + end_idx) // 2
        mid_value = nums[mid_idx]
    
    if searchData == mid_value:
        result_idx = mid_idx
        break

- 검색(찾으려는 값과 일치하는 지 확인)할 때 중간값(mid_value)와 비교한 후, 반절을 고려 대상에서 제외해나가는 과정을 반복하기 때문에 빠르게 탐색할 수 있다.

 


📍 버블정렬

처음부터 끝까지 인접하는 인덱스의 값을 순차적으로 비교하면서 큰 숫자를 가장 끝으로 옮기는 알고리즘

 

nums = [10, 2, 7, 21, 0]

length = len(nums) - 1
for i in range(length):
    for j in range(length - i):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]
            
print(nums) # [0, 2, 7, 10, 21]

- 첫번째 for문의 첫 회에서 제일 큰 값이 맨 끝으로 가게 된다.

- 두번째는 그 다음으로 큰 값을 3번째에, 세번째는 그 다음으로 큰 값을 2번째에 두는 과정이 반복되는 것

 


📍 삽입정렬

왼쪽에 정렬되어 있는 자료배열과 비교하여 오른쪽 값의 정렬 위치를 찾아 삽입한다.

 

nums = [5, 10, 2, 1, 0]

for i1 in range(1, len(nums)):
    i2 = i1 - 1
    cNum = nums[i1]
    
    while nums[i2] > cNum and i2 >= 0:
        nums[i2 + 1] = nums[i2]
        i2 -= 1
        
    nums[i2 + 1] = cNum

- for 문에서 현재 기준이 되는 오른쪽의 값을 설정.

- while 문에서 왼쪽에 있는 값들이 기준 값보다 크면 값을 바꿔주는 과정 진행.

 

 


📍 선택정렬

주어진 리스트 중에 최소값을 찾아 그 값을 맨 앞에 위치한 값과 교체하는 방식

 

nums = [4, 2, 5, 1, 3]

for i in range(len(nums) -1):
    min_idx = i
    
    for j in range(i+1, len(nums)):
        if nums[min_idx] > nums[j]:
            min_idx = j
            
    nums[i], nums[min_idx] = nums[min_idx], nums[i]

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 딕셔너리(dictionary)

키(key)와 값(value)을 짝지어 자료를 관리

삭제, 수정 등은 리스트와 같이 활용 가능

 

 

students = {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철'}

 

 

 

students = {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철'}

students['s2']

# 강호동

students.get('s2')

# 강호동

- dict[key] 로 값(value)를 조회할 수 있다. 다만, 해당 키값이 없을 경우 에러가 발생

- dict.get(key)로 값을 조회하면 키 값이 없어도 에러가 나지 않고 None을 반환한다.

 

 

students = {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철'}

students['s5'] = '김연아'

print(students)

# {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철', 's5':'김연아'}

- 변수 선언처럼 dict[new key] = 값(value)를 선언하면 새로운 아이템이 추가된다.

- 수정도 마찬가지로 변수 선언처럼 존재하는 키에 다른 값을 선언하면 아이템이 변경된다.

 

 

students = {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철'}

students.keys()

# dict_keys(['s1', 's2', 's3', 's4'])

students.values()

# dict_values(['홍길동', '강호동', '이수근', '김영철'])

- dict.keys() key 만 조회하기

- dict.values() value 만 조회하기

 

 

students = {'s1':'홍길동', 's2':'강호동', 's3':'이수근', 's4':'김영철'}

's5' in students

# False

len(students)

# 4

students.clear()

# {}

- 키 in dict 로 존재하는 지 확인 가능

- len(dict) 로 딕셔너리의 길이 확인

- dict.clear() 로 아이템을 모두 비우기

 

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 리스트(list)

배열과 같이 여러 개의 데이터를 나열한 자료구조

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']
numbers = [10, 20, 30, 40, 50]

data = [10, 20, 30, [40, 50, 60]] # 리스트 안의 리스트도 가능

- 문자, 숫자 뿐만 아니라 data와 같이 리스트 안의 리스트도 가능하다.

 

 

 

students[0] # 홍길동
students[1] # 박찬호

- 리스트 아이템 조회하는 방법 students[i]

 

 

len(students) # 5

- len() 함수로 길이(length)를 반환 가능

 

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

for idx, value in enumerate(students):
    print(f'{idx} : {value}')
    
# 0 : 홍길동
# 1 : 박찬호
# 2 : 이용규
# 3 : 박승철
# 4 : 김지은

- enumerate() 함수는 아이템의 인덱스와 값을 동시에 반환한다.

 

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students.append('김희철')

print(students)

# ['홍길동', '박찬호', '이용규', '박승철', '김지은', '김희철']

- list.append( 값 ) 으로 리스트의 맨 마지막에 값을 추가할 수 있다.

 

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students.insert(3, '김연아')

print(students)

# ['홍길동', '박찬호', '이용규', '김연아', '박승철', '김지은']

- list.insert(index, 값) 으로 index 위치에 값을 삽입할 수 있다. append의 경우는 맨 오른쪽에만 삽입

 

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students.pop()

print(students)

# ['홍길동', '박찬호', '이용규', '박승철']

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students.pop(3)

print(students)

# ['홍길동', '박찬호', '이용규', '김지은']

- list.pop() 으로 맨 마지막 값 삭제 가능

- list.pop(index) 으로 index 위치의 값 삭제 가능

 

 

 

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students.remove('홍길동')

print(students)

# ['박찬호', '이용규', '박승철', '김지은']

- list.remove(값) 로 해당 값 삭제 가능

 

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은']
students_2 = ['문성곤', '오세근']

students_1.extend(students_2)

print(students)

# ['홍길동', '박찬호', '이용규', '박승철', '김지은', '문성곤', '오세근']

result = students_1 + students_2

print(result)

# ['홍길동', '박찬호', '이용규', '박승철', '김지은', '문성곤', '오세근']

- list_1.extend(list_2) 혹은 list_1 + list_2 로 리스트(list)를 연결할 수 있다.

 

 

playerscore = [3, 6, 2, 5, 6, 7]

playerscore.sort()

print(playerscore)

# [2, 3, 5, 6, 6, 7]

playerscore.sore(reverse=True)

print(playerscore)

# [ 7, 6, 6, 5, 3, 2]

- list.sort() 아이템을 오름차순으로 정렬

- list.sort(reverse=True) 아이템을 내림차순으로 정렬

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students_1.reverse()

print(students_1)

# ['김지은', '박승철', '이용규', '박찬호', '홍길동']

- list.reverse() 아이템을 역순으로 배열

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students_1[1:4]

print(students)

# ['박찬호', '이용규', '박승철']

- list[start:end] 리스트 아이템 중 start번째 부터 end번째 이전까지 조회

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

students_1.index('박찬호')

# 1

- list.index(값) 값이 있는 인덱스를 반환

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은', '홍길동']

students_1.count('홍길동')

# 2

- list.count(값) 리스트 안 값의 개수를 세어 반환

 

 

students_1 = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

del students_1[1]

print(students_1)

# ['홍길동', '이용규', '박승철', '김지은']

- del list[index] 리스트 값을 삭제하기

 

 


📍 튜플(tuple)

리스트처럼 배열을 담은 구조. 다만, 아이템 삭제, 수정 등 변경이 불가하다.

따라서 append(), 원소 재선언, pop() 이 불가하다.

extend()는 사용할 수 없고, tuple + tuple으로 연결 가능하다.

이 외의 내용은 리스트와 같이 작업할 수 있다.

 

students_1 = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

 

 

students_1 = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

'이용규' in students_1

# True

'김연아' in students_1

# False

- in, not in 을 통해 배열 안에 원소가 있는지 bool 값으로 반환

 

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 약수, 소수, 소인수 찾아내기

import random

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

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

    soinsuFlag = 0

    # 약수
    if rNum % num == 0:
        print(f'약수 : {num}')
        soinsuFlag += 1
    
    # 소수
    if num != 1:
        flag = True
        for n in range(2, num):
            if num % n == 0:
                flag = False
                break
        
        if flag:
            print(f'소수 : {num}')
            soinsuFlag += 1

    # 소인수
    if soinsuFlag == 2:
        print(f'소인수 : {num}')

지정한 숫자(rNum)를 나누었을 때 나머지가 0이면 약수

해당 숫자까지 2부터 나누었을 때 나머지가 0인 경우가 없으면 소수

약수이면서 소수인 수 => 소인수

 

 


📍 진수(진법) 변환

dNum = 23

# 10진수 -> 2, 8, 16진수

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

print(format(dNum, 'b')) # 2진수 숫자만
print(format(dNum, 'o')) # 8진수 숫자만
print(format(dNum, 'x')) # 16진수 숫자(문자)만

# x진수 -> 10진수
print(int('10111', 2))
print(int('27', 8))
print(int('27', 16))

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

2진수 등으로 바꾸면 '0b'와 같이 앞에 필요없는 문자가 붙게 된다.

format(dNum, 'b') 와 같이 사용하는게 가장 필요한 기능 일 듯 하다.

 


 

📍 등차수열, 등비수열, 계차수열

# 등차수열

inputA1 = 1 # 초항
inputD = 2 # 공차
inputN = 9 # n

# 등차 수열(일반항) 공식: an = a1 + (n-1) * d
valueN = inputA1 + (inputN-1) * inputD
print('{}번째 항의 값: {}'.format(inputN, valueN))

# 등차 수열(합) 공식: sn = n(a1 + an) / 2
sumN = inputN * (inputA1 + valueN) / 2
print('{}번째 항까지의 합: {}'.format(inputN, int(sumN)))
# 등비수열

inputA1 = 1 # 초항
inputR = 2 # 공비
inputN = 9 # n

# 등비 수열(일반항) 공식: an = a1 * r^(n-1)
valueN = inputA1 * (inputR ** (inputN-1))
print('{}번째 항의 값: {}'.format(inputN, valueN))

# 등비 수열(합) 공식: sn = a1 * (1 - r^n) / (1-r)
sumN = inputA1 * (1 - (inputR ** inputN)) / (1 - inputR)
print('{}번째 항까지의 합: {}'.format(inputN, int(sumN)))
# 계차수열

#{2, 5, 11, 20, 32, 47, 65, 86, 110, 137, 167, …}

# bn : 계차 항

# an - a1 = (b1 부터 bn-1 까지 합)

# (3n^2 - 3n + 4)/2 = an

inputA1 = int(input('a1 입력: '))
inputN = int(input('an 입력: '))

valueAN = ((3 * inputN ** 2) - (3 * inputN) + 4) / 2
print('an의 {}번째 항의 값: {}'.format(inputN, int(valueAN)))

일반항 공식만 알고 있다면 그대로 대입하면 된다.

일반항 공식을 모르더라도 for문을 통해 쉽게 해결할 수 있지만, 시간복잡도 측면에서 좋지않다.

 

 

# 피보나치

# 1, 1, 2, 3, 5, 8 ...

def fibo(n):
    if n in (1, 2):
        return 1
    
    else:
        return fibo(n-1) + fibo(n-2)


fibo(6)

피보나치 수열을 이전 두 행을 더해서 다음 행의 값이 되는 수열이다.

패턴이 있기 때문에 재귀함수를 호출해서 사용할 수도 있고, for 문을 통해 해결할 수도 있다.

재귀함수의 활용 사례를 보여주는 대표적인 수열이다.


📍 순열, 조합

# 순열 
# 9P4

# 9 * 8 * 7 * 6 

numN = 9
numR = 4
result = 1

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

print('result: {}'.format(result))
# 조합
#9c4

# 9 * 8 * 7 * 6 / 4 * 3 * 2 * 1

numN = 9
numR = 4
resultP = 1
resultR = 1
resultC = 1

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

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

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

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

순열의 계산 공식을 알고 있다면 그대로 대입만 하면 된다. 

조합은 순열을 계산한 후 팩토리얼로 나눠주기만 하면 된다.

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 예외 처리

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

 

n1 = 10
n2 = 0

print(n1 / n2) # 문법적 오류는 없으나 0으로 나누는 건 문제 상황이다.

=> 예외 발생: ZeroDivisionError: division by zero


📍 try ~ except

의도한 부분을 try 하고, 오류가 발생할 경우에도 error 발생으로 이후 스크립트가 멈추지 않고 except 이하가 실행되도록 한다.

 

n1 = 10; n2 = 0

try:
    print(n1 / n2)
except:
    n2 += 0.01
    print(n1 / n2)

=> 분모가 0인 오류 상황인데도 에러 발생으로 멈추지 않고, except에서 값을 수정하여 예외 상황에서의 실행으로 이어진다.


📍 try ~ except ~else

예외가 발생하지 않은 경우, else 이하를 실행하도록 한다.

 

n1 = 10; n2 = 1

try:
    print(n1 / n2)
except:
    n2 += 0.01
    print(n1 / n2)
else:
     print("예외 없이 실행되었습니다") # 출력

📍 finally

예외 발생 여부와 관계없이 항상 실행하도록 한다.

n1 = 10; n2 = 1

try:
    print(n1 / n2)
except:
    n2 += 0.01
    print(n1 / n2)
else:
    print("예외 없이 실행되었습니다") # 출력

finally:
    print("모든 작업이 끝났습니다) # 출력

📍 Exception 클래스

Exception 클래스로 예외 상황에서의 에러 메시지를 확인할 수 있다.

n1 = 10; n2 = 1

try:
    print(n1 / n2)
except Exception as e:
    print(f"예외 발생 : {e}")
    n2 += 0.01
    print(n1 / n2)

=> division by zero 출력

 

 

raise를 이용해 강제로 예외를 발생시킬 수 있다.

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 = "1234567891011"
 
 try:
     sendSMS(msg)
     
 except Exception as e:
     if e.args[1] == 1:
         sendMMS(msg)
     elif e.args[1] == 2:
         sendSMS(msg)

 

📍 파일 열기, 읽기, 쓰기

with ~ as 문을 이용하여 파일을 열고, 읽고, 쓸 수 있다.

 

with open("content/text.txt", 'r') as f: # 읽기
    print(f.read())
    
with open("content/text.txt", 'w') as f: # 쓰기, 이미 있다면 새로 덮어쓴다.
    f.write("안녕하세요.")

with open("content/text.txt", 'a') as f: # 쓰기, 이어서 쓴다.
    f.write("반갑습니다.")

 

📍 writelines()

여러 데이터를 포함한 자료형을 쓸 때 사용

alpha = ['a', 'b', 'c', 'd']

with open('contents/text.txt', 'a') as f:
    f.writelines(alpha)

 

📍 readlines()

파일의 모든 데이터를 읽어서 리스트 형태로 반환

 

with open('contents/text.txt', 'r') as f:
    alpha_lst = f.readlines()

 

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 객체 지향 프로그래밍

객체(object) = 속성(attribute) + 기능(function)

 

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

 

자동차를 예로 들면, 자동차의 배터리가 차체와 일체형이 아닌 교체형일 때, 배터리(수정이 필요한 부분)만 교체할 수 있어서(결합도가 낮아서) 이상적인 프로그램을 만들 수 있다.

 


📍 클래스와 객체

기능들을 아우를 수 있는 클래스를 선언하고 그 안에 각 기능을 만든다.

 

객체 car1, car2는 클래스를 호출하여 만든 각각의 객체이다. car1과 car2 라는 객체로 작업함으로써 결합도를 낮춰 원본 클래스를 유지하면서 기능하게 할 수 있다.

 

 

생성자 __init__은 객체가 생성될 때 먼저 자동 호출된다. 속성을 초기화하는 기능

 

객체의 속성값(위의 예시에서는 color, length)은 객체에 따라 다르게 지정할 수 있으며, 지정 후에도 변경할수 있다.

 

car1.color = 'orange' # red를 orange로 변경

📍 얕은 복사, 깊은 복사

car1 = Car('red', 200)

위와 같이 객체를 생성한 경우 car1이라는 변수는 객체의 메모리 주소를 저장하고 이를 통해 객체를 참조한다.

얕은 복사

그런데, car3 = car1 과 같이 car3을 생성할 경우, 객체 자체가 복사되지 않고 참조하는 주소를 복사하게 된다.

즉, car1에서 속성을 변경할 경우 car3의 속성도 변경된다.(같은 주소를 바라보고 있기 때문에)

 

깊은 복사

깊은 복사를 할 경우, 참조하는 주소를 복사하는 것이 아니라 똑같은 객체를 다른 메모리 주소에 저장한다.

즉, car1에서 속성을 변경해도 car3는 다른 주소를 참조하고 있기 때문에 영향을 받지 않는다.

# 깊은 복사

import copy

car3 = car1.copy() 

car3 = copy.deepcopy(car1) # deepcopy()는 배열의 내부 객체까지 복사. 이중 배열이상에서도 완전한 깊은 복사 가능

📍 클래스 상속

클래스는 다른 클래스를 상속하여 상위 클래스의 속성과 기능을 사용할 수 있다.

 

class CalculatorSuper:
    
    def __init__(self, pNum1, pNum2):
        self.pNum1 = pNum1
        self.pNum2 = pNum2
    
    def add(self, n1, n2):
        return n1 + n2
    
    def sub(self, n1, n2):
        return n1 - n2
        
class CalculatorChild(CalculatorSuper): # 위의 상위 클래스를 상속받는다.
     
     def __init__(self, cNum1, cNum2):
         super().__init__(100, 200) # super().__init__ 을 하면 하위 클래스 객체 생성시 상위클래스의 속성 초기화 가능
         
     def mul(self, n1, n2):
         return n1 * n2
    
     def div(self, n1, n2):
         return n1 / n2
         
 cal = CalculatorChild() # 하위 클래스 객체 생성
 
 cal.add(10, 20) # 상위 클래스의 기능임에도 상속받았기에 사용가능

 


📍 오버라이딩

오버라이딩 : 하위 클래스에서 상위 클래스의 메서드를 재정의

class Robot:

    def fire(self):
        print("총알 발사!!")

class NewRobot(Robot): # 상속
    def fire(self):
        print("레이저 발사!!") # 상위 클래스의 fire 메서드가 아닌 재정의 된 fire로, "레이저 발사!!" 출력

📍 추상클래스

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

즉, 상위 클래스에서는 메서드를 선언만 해놓고, 하위 클래스에서 꼭 구현하여야만 기능할 수 있도록 한다.

 

from abc import ABCMeta
from abc import abstractmethod

class AirPlane(metaclass=ABCMeta):
    
    @abstractmethod
    def flight(self): # 추상 클래스를 선언했으므로 하위클래스에서 이 추상 메서드를 꼭 구현하여야만 한다.
        pass
        
class Airliner(AirPlane):

    def flight(self): # 추상 메서드 구현
        print("시속 400km/h 비행!!")

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 파이썬 함수

함수 선언하는 법

def + 함수이름 + (인풋)

return 아웃풋

 

addCal(x, y) 에서 x, y는 매개변수

addCal(2, 3)으로 함수를 호출한다면 2, 3은 인수

인수의 개수를 특정하지 않을 때에는 addCal(*num) 과 같이 적으면 정해지지 않은 개수의 인수를 입력 가능

 

# x, y 를 입력하면 x + y를 반환하는 함수

def addCal(x, y):
    return x + y

📍 함수 내에서 다른 함수 호출하기

구구단 2단 함수를 호출하면 3단도 이어서 호출하는 구조 작성하기

def guguDan2():
    for i in range(1, 10):
        print('2 * {} = {}'.format(i, 2*i))
    
    guguDan3() # 함수 안에서 다른 함수 호출

def guguDan3():
    for i in range(1, 10):
        print('3 * {} = {}'.format(i, 3*i))
        
guguDan2() # 만든 함수를 호출하면 guguDan3도 함께 호출

📍 함수 만들기 실습

사용자가 길이(cm)를 입력하면 mm로 환산한 값을 반환하는 함수

def cmToMm(cm):
    result = cm * 10
    return result

length = float(input('길이(cm) 입력: '))
returnValue = cmToMm(length)
print(f'mm 반환값은 {returnValue}mm 입니다.')

📍 전역변수와 지역변수

전역변수 : 함수 밖에 선언된 변수, 함수안에서 재정의 하더라도 시스템에서는 수정되지 않는다.

num_out = 10
def printNumbers():
    num_out = 20
    print(num_out)
    
printNumbers() # 20
print(num_out) # 10

 

지역변수 : 함수 안에 선언된 변수, 함수 안에서만 사용 가능하다.

def printNumbers():
    num_in = 20
    print(num_in)

print(num_in) # NameError, 전역적으로는 선언이 되지 않았기 때문

 

함수 안에서도 전역변수를 다루고 싶을 때

num_out = 10
def printNumbers():
    global num_out # 이 변수는 전역변수다 라고 선언
    num_out = 20 # 전역변수를 수정
    print(num_out)
    
printNumbers() # 20
printNumbers() # 20

📍 전역변수 활용 실습

방문객 수를 카운트하는 함수 만들기

totalVisit = 0

def countTotalVisit():
    global totalVisit
    totalVisit = totalVisit + 1
    print(f'누적 방문객 : {totalVisit}명')
    
countTotalVisit() # 누적 방문객 : 1명
countTotalVisit() # 누적 방문객 : 2명
countTotalVisit() # 누적 방문객 : 3명

 


📍 lambda 로 함수 선언하기

공식적으로 함수를 선언해두고 다음에도 호출에서 사용하지 않고, 임시 함수를 생성할 때 lambda 이용

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

# 위와 같음

calculator = lambda n1, n2 : n1 + n2

📍 모듈

모듈 : 이미 만들어 놓은 기능. 불러와서 쉽게 사용 가능

내부 모듈 : 파이썬 설치 시 기본적으로 내장되어 있는 모듈

외부 모듈 : 별도로 설치를 통해 사용할 수 있는 모듈

사용자 모듈 : 사용자가 직접 제작한 모듈

 

 

로또 번호(6개)를 출력하는 모듈 만들기

import random # 먼저, 내부모듈 random 불러오기

def getLotto():
    result = random.randint(range(1, 46), 6)
    
    return result
import lottoMachine # 만들어 놓은 모듈(getLotto)이 있는 lottoMachine.py 불러오기

numbers = lottoMachine.getLotto()
print(numbers) # 3, 23, 20, 11, 40, 6

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 for문으로 구구단 2단 출력하기

for num in range(1, 10):
    result = 2 * num
    print(f'2 x {num} = {result}')


📍 중첩 for문으로 구구단 1~9단 표현하기

for dan in range(2, 10): # 몇 단인지
    for num in range(1, 10): # 해당 단에서의 내용
        result = dan * num
        print(f'{dan} x {num} = {result}')


📍 반복문 제어하기(continue, break)

continue(조건에 해당하면 다음 iteration으로 넘어감) 사용하여 7의 배수만 출력하기

for i in range(1, 100):
    if i % 7 != 0:
    	continue
    	
    else:
    	print(f'{i} 는 7의 배수 입니다.')

 

break(더 이상 반복하지 않고 반복문 빠져 나오기) 사용하여 n! 의 값이 처음으로 50을 넘을 때 n값 구하기

result = 1
num = 0

for i in range(1, 11):
    result *= i
    
    if result > 50:
        num = i
        break
        
print(num)

📍 기초 문제풀이

  • 문자 메시지 길이에 따라 문자 요금이 결정되는 프로그램 작성하기
message = '안녕하세요. 오늘은 비가 오네요.'

if len(message) > 20:
    print('메시지 발송 요금: 100원')
else:
    print('메시지 발송 요금: 50원')

 

 

  • 각 과목 점수의 편차를 막대그래프로 나타내기
subject = ['국어', '영어','수학','과학','국사']
score = [85, 82, 89, 75, 94]

mean = int(sum(score) / len(score))

for i in range(5):
    if score[i] >= mean:
        print(f'{subject[i]} 편차: {"+" * (score[i] - mean)}')
    else:
        print(f'{subject[i]} 편차: {"-" * (mean - score[i])}')

 

 

제로베이스 데이터 취업 스쿨 과정 학습 내용을 정리한 포스팅입니다.

 

📍 비교 연산자( ==, !=, <, >, <=, >=)

숫자 비교 : 수의 대소 관계 비교하여 Bool 값으로 출력

maxLength = 5200
maxWidth = 1985

myCarLength = 2500
myCarLength = 2000

print('Length 가능 여부: {}'.format(myCarLength <= maxLength))  # Length 가능 여부: True
print('Width 가능 여부: {}'.format(myCarWidth <= maxWidth))  # Width 가능 여부: False

 

 

문자 비교 : 문자는 아스키코드로 순서가 부여되어 순서대로 대소 비교

 

문자의 아스키코드 변환 : ord(문자)

아스키코드의 문자 변환 : chr(숫자)

print(ord('A')) # 65
print(ord('S')) # 83

print(chr(65)) # A
print(chr(83)) # S


print('A' > 'S') # False

 

문자열 자체 비교

str1 = 'Hello'
str2 = 'hello'

# 둘이 같은가? 
print(str1 == str2) # False

# 둘이 다른가?
print(str1 != str2) # True

📍 논리 연산자(and, or, not)

True and True : True

True and False : False

False and False : False

 

True or True : True

True or False : True

False or False : False

 

not True : False

not False : True

not (True and False) : True

not (False or False) : True

 


📍 Operator 모듈 이용하기

모듈 : 누군가 만들어 놓은 유용한 기능. 불러와서 사용할 수 있다.

 

import operator # 모듈 불러오기

operator.add(3, 2) # 덧셈 -> 5
operator.sub(3, 2) # 뺄셈 -> 1
operator.mul(3, 2) # 곱셈 -> 6
operator.truediv(3, 2) # 나눗셈 -> 1.5
operator.mod(3, 2) # 나머지 -> 0.5
operator.floordiv(3, 2) # 몫 -> 1
operator.pow(3, 2) # 제곱 -> 9

 


📍 조건문

# num이 10 보다 크면 if 이하 실행, 작거나 같으면 else 이하 실행

num = 6

if num > 10:
	print('정답입니다.')
else:
	print('오답입니다.')


# 점수에 따라 등급 매기기

score = 77

if score > 90:
	print('A')
elif score > 80:   # elif -> else if -> 그렇지 않고 이렇다면~ 실행
	print('B')
elif score > 70:   # 여기에서 True 이므로 C 출력
	print('C')
else:
	print('D')

📍 조건식

조건을 바탕으로 식 만들기 (ex. 조건에 따라 변수에 값을 다르게 할당)

# 한국이면 블레이크를, 아니라면 Blake를 name에 할당

country = '미국'

name = '블레이크' if country == '한국' else 'Blake'

# name = 'Blake' 할당

📍 중첩 조건문

조건문 안에 또 다른 조건문이 있는 구조

score = 68

if score <= 70:
	print('재시험')

# 그렇지 않은 경우, 다시 조건에 따라 나눈다
else:
	if score > 90:
    	print('A')
    elif score > 80:
    	print('B')
    elif score > 70:
    	print('C')

📍 반복문

반복문의 종류

  • 횟수에 의한 반복 : 횟수를 정하고 그만큼 반복 실행
for i in range(10):
	print(i)

# 1, 2, 3, 4, 5, 6, 7, 8, 9 반복 출력

 

  • 조건에 의한 반복 : 조건을 정하고 조건이 만족하는 한 계속 반복 실행
num = 0
while (num < 10):
	print(num)
    num += 1

# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 까지 출력 반복 실행하고, 그다음 10이 넘어가므로 종료

+ Recent posts